method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
Metaphone implements StringEncoder { public Metaphone() { super(); } Metaphone(); String metaphone(final String txt); @Override Object encode(final Object obj); @Override String encode(final String str); boolean isMetaphoneEqual(final String str1, final String str2); int getMaxCodeLen(); void setMaxCodeLen(final int maxCodeLen); }### Answer:
@Test public void testMetaphone() { assertEquals("HL", this.getStringEncoder().metaphone("howl")); assertEquals("TSTN", this.getStringEncoder().metaphone("testing")); assertEquals("0", this.getStringEncoder().metaphone("The")); assertEquals("KK", this.getStringEncoder().metaphone("quick")); assertEquals("BRN", this.getStringEncoder().metaphone("brown")); assertEquals("FKS", this.getStringEncoder().metaphone("fox")); assertEquals("JMPT", this.getStringEncoder().metaphone("jumped")); assertEquals("OFR", this.getStringEncoder().metaphone("over")); assertEquals("0", this.getStringEncoder().metaphone("the")); assertEquals("LS", this.getStringEncoder().metaphone("lazy")); assertEquals("TKS", this.getStringEncoder().metaphone("dogs")); }
@Test public void testWordEndingInMB() { assertEquals( "KM", this.getStringEncoder().metaphone("COMB") ); assertEquals( "TM", this.getStringEncoder().metaphone("TOMB") ); assertEquals( "WM", this.getStringEncoder().metaphone("WOMB") ); }
@Test public void testDiscardOfSCEOrSCIOrSCY() { assertEquals( "SNS", this.getStringEncoder().metaphone("SCIENCE") ); assertEquals( "SN", this.getStringEncoder().metaphone("SCENE") ); assertEquals( "S", this.getStringEncoder().metaphone("SCY") ); }
@Test public void testWhy() { assertEquals("", this.getStringEncoder().metaphone("WHY")); }
@Test public void testWordsWithCIA() { assertEquals( "XP", this.getStringEncoder().metaphone("CIAPO") ); }
@Test public void testTranslateOfSCHAndCH() { assertEquals( "SKTL", this.getStringEncoder().metaphone("SCHEDULE") ); assertEquals( "SKMT", this.getStringEncoder().metaphone("SCHEMATIC") ); assertEquals( "KRKT", this.getStringEncoder().metaphone("CHARACTER") ); assertEquals( "TX", this.getStringEncoder().metaphone("TEACH") ); }
@Test public void testTranslateToJOfDGEOrDGIOrDGY() { assertEquals( "TJ", this.getStringEncoder().metaphone("DODGY") ); assertEquals( "TJ", this.getStringEncoder().metaphone("DODGE") ); assertEquals( "AJMT", this.getStringEncoder().metaphone("ADGIEMTI") ); }
@Test public void testDiscardOfSilentHAfterG() { assertEquals( "KNT", this.getStringEncoder().metaphone("GHENT") ); assertEquals( "B", this.getStringEncoder().metaphone("BAUGH") ); }
@Test public void testDiscardOfSilentGN() { assertEquals( "N", this.getStringEncoder().metaphone("GNU") ); assertEquals( "SNT", this.getStringEncoder().metaphone("SIGNED") ); }
@Test public void testPHTOF() { assertEquals( "FX", this.getStringEncoder().metaphone("PHISH") ); }
@Test public void testSHAndSIOAndSIAToX() { assertEquals( "XT", this.getStringEncoder().metaphone("SHOT") ); assertEquals( "OTXN", this.getStringEncoder().metaphone("ODSIAN") ); assertEquals( "PLXN", this.getStringEncoder().metaphone("PULSION") ); }
@Test public void testTIOAndTIAToX() { assertEquals( "OX", this.getStringEncoder().metaphone("OTIA") ); assertEquals( "PRXN", this.getStringEncoder().metaphone("PORTION") ); }
@Test public void testTCH() { assertEquals( "RX", this.getStringEncoder().metaphone("RETCH") ); assertEquals( "WX", this.getStringEncoder().metaphone("WATCH") ); }
@Test public void testExceedLength() { assertEquals( "AKSK", this.getStringEncoder().metaphone("AXEAXE") ); } |
### Question:
DoubleMetaphone implements StringEncoder { public boolean isDoubleMetaphoneEqual(final String value1, final String value2) { return isDoubleMetaphoneEqual(value1, value2, false); } DoubleMetaphone(); String doubleMetaphone(final String value); String doubleMetaphone(String value, final boolean alternate); @Override Object encode(final Object obj); @Override String encode(final String value); boolean isDoubleMetaphoneEqual(final String value1, final String value2); boolean isDoubleMetaphoneEqual(final String value1, final String value2, final boolean alternate); int getMaxCodeLen(); void setMaxCodeLen(final int maxCodeLen); }### Answer:
@Test public void testCCedilla() { assertTrue(this.getStringEncoder().isDoubleMetaphoneEqual("\u00e7", "S")); }
@Test public void testCodec184() throws Throwable { assertTrue(new DoubleMetaphone().isDoubleMetaphoneEqual("", "", false)); assertTrue(new DoubleMetaphone().isDoubleMetaphoneEqual("", "", true)); assertFalse(new DoubleMetaphone().isDoubleMetaphoneEqual("aa", "", false)); assertFalse(new DoubleMetaphone().isDoubleMetaphoneEqual("aa", "", true)); assertFalse(new DoubleMetaphone().isDoubleMetaphoneEqual("", "aa", false)); assertFalse(new DoubleMetaphone().isDoubleMetaphoneEqual("", "aa", true)); }
@Test public void testIsDoubleMetaphoneEqualExtended3() { this.validateFixture(FIXTURE); final StringBuilder failures = new StringBuilder(); final StringBuilder matches = new StringBuilder(); final String cr = System.getProperty("line.separator"); matches.append("private static final String[][] MATCHES = {" + cr); int failCount = 0; for (int i = 0; i < FIXTURE.length; i++) { final String name0 = FIXTURE[i][0]; final String name1 = FIXTURE[i][1]; final boolean match1 = this.getStringEncoder().isDoubleMetaphoneEqual(name0, name1, false); final boolean match2 = this.getStringEncoder().isDoubleMetaphoneEqual(name0, name1, true); if (match1 == false && match2 == false) { final String failMsg = "[" + i + "] " + name0 + " and " + name1 + cr; failures.append(failMsg); failCount++; } else { matches.append("{\"" + name0 + "\", \"" + name1 + "\"}," + cr); } } matches.append("};"); if (failCount > 0) { } }
@Test public void testIsDoubleMetaphoneEqualWithMATCHES() { this.validateFixture(MATCHES); for (int i = 0; i < MATCHES.length; i++) { final String name0 = MATCHES[i][0]; final String name1 = MATCHES[i][1]; final boolean match1 = this.getStringEncoder().isDoubleMetaphoneEqual(name0, name1, false); final boolean match2 = this.getStringEncoder().isDoubleMetaphoneEqual(name0, name1, true); if (match1 == false && match2 == false) { fail("Expected match [" + i + "] " + name0 + " and " + name1); } } }
@Test public void testNTilde() { assertTrue(this.getStringEncoder().isDoubleMetaphoneEqual("\u00f1", "N")); } |
### Question:
DoubleMetaphone implements StringEncoder { public DoubleMetaphone() { super(); } DoubleMetaphone(); String doubleMetaphone(final String value); String doubleMetaphone(String value, final boolean alternate); @Override Object encode(final Object obj); @Override String encode(final String value); boolean isDoubleMetaphoneEqual(final String value1, final String value2); boolean isDoubleMetaphoneEqual(final String value1, final String value2, final boolean alternate); int getMaxCodeLen(); void setMaxCodeLen(final int maxCodeLen); }### Answer:
@Test public void testDoubleMetaphone() { assertDoubleMetaphone("TSTN", "testing"); assertDoubleMetaphone("0", "The"); assertDoubleMetaphone("KK", "quick"); assertDoubleMetaphone("PRN", "brown"); assertDoubleMetaphone("FKS", "fox"); assertDoubleMetaphone("JMPT", "jumped"); assertDoubleMetaphone("AFR", "over"); assertDoubleMetaphone("0", "the"); assertDoubleMetaphone("LS", "lazy"); assertDoubleMetaphone("TKS", "dogs"); assertDoubleMetaphone("MKFR", "MacCafferey"); assertDoubleMetaphone("STFN", "Stephan"); assertDoubleMetaphone("KSSK", "Kuczewski"); assertDoubleMetaphone("MKLL", "McClelland"); assertDoubleMetaphone("SNHS", "san jose"); assertDoubleMetaphone("SNFP", "xenophobia"); assertDoubleMetaphoneAlt("TSTN", "testing"); assertDoubleMetaphoneAlt("T", "The"); assertDoubleMetaphoneAlt("KK", "quick"); assertDoubleMetaphoneAlt("PRN", "brown"); assertDoubleMetaphoneAlt("FKS", "fox"); assertDoubleMetaphoneAlt("AMPT", "jumped"); assertDoubleMetaphoneAlt("AFR", "over"); assertDoubleMetaphoneAlt("T", "the"); assertDoubleMetaphoneAlt("LS", "lazy"); assertDoubleMetaphoneAlt("TKS", "dogs"); assertDoubleMetaphoneAlt("MKFR", "MacCafferey"); assertDoubleMetaphoneAlt("STFN", "Stephan"); assertDoubleMetaphoneAlt("KXFS", "Kutchefski"); assertDoubleMetaphoneAlt("MKLL", "McClelland"); assertDoubleMetaphoneAlt("SNHS", "san jose"); assertDoubleMetaphoneAlt("SNFP", "xenophobia"); assertDoubleMetaphoneAlt("FKR", "Fokker"); assertDoubleMetaphoneAlt("AK", "Joqqi"); assertDoubleMetaphoneAlt("HF", "Hovvi"); assertDoubleMetaphoneAlt("XRN", "Czerny"); }
@Test public void testEmpty() { assertEquals(null, this.getStringEncoder().doubleMetaphone(null)); assertEquals(null, this.getStringEncoder().doubleMetaphone("")); assertEquals(null, this.getStringEncoder().doubleMetaphone(" ")); assertEquals(null, this.getStringEncoder().doubleMetaphone("\t\n\r ")); } |
### Question:
Nysiis implements StringEncoder { @Override public Object encode(final Object obj) throws EncoderException { if (!(obj instanceof String)) { throw new EncoderException("Parameter supplied to Nysiis encode is not of type java.lang.String"); } return this.nysiis((String) obj); } Nysiis(); Nysiis(final boolean strict); @Override Object encode(final Object obj); @Override String encode(final String str); boolean isStrict(); String nysiis(String str); }### Answer:
@Test public void testTrueVariant() { final Nysiis encoder = new Nysiis(true); final String encoded = encoder.encode("WESTERLUND"); Assert.assertTrue(encoded.length() <= 6); Assert.assertEquals("WASTAR", encoded); } |
### Question:
MatchRatingApproachEncoder implements StringEncoder { String removeAccents(final String accentedWord) { if (accentedWord == null) { return null; } final StringBuilder sb = new StringBuilder(); final int n = accentedWord.length(); for (int i = 0; i < n; i++) { final char c = accentedWord.charAt(i); final int pos = UNICODE.indexOf(c); if (pos > -1) { sb.append(PLAIN_ASCII.charAt(pos)); } else { sb.append(c); } } return sb.toString(); } @Override final Object encode(final Object pObject); @Override final String encode(String name); boolean isEncodeEquals(String name1, String name2); }### Answer:
@Test public final void testAccentRemoval_AllLower_SuccessfullyRemoved() { assertEquals("aeiou", this.getStringEncoder().removeAccents("áéíóú")); }
@Test public final void testAccentRemoval_WithSpaces_SuccessfullyRemovedAndSpacesInvariant() { assertEquals("ae io u", this.getStringEncoder().removeAccents("áé íó ú")); }
@Test public final void testAccentRemoval_UpperandLower_SuccessfullyRemovedAndCaseInvariant() { assertEquals("AeiOuu", this.getStringEncoder().removeAccents("ÁeíÓuu")); }
@Test public final void testAccentRemoval_MixedWithUnusualChars_SuccessfullyRemovedAndUnusualcharactersInvariant() { assertEquals("A-e'i.,o&u", this.getStringEncoder().removeAccents("Á-e'í.,ó&ú")); }
@Test public final void testAccentRemoval_ComprehensiveAccentMix_AllSuccessfullyRemoved() { assertEquals("E,E,E,E,U,U,I,I,A,A,O,e,e,e,e,u,u,i,i,a,a,o,c", this.getStringEncoder().removeAccents("È,É,Ê,Ë,Û,Ù,Ï,Î,À,Â,Ô,è,é,ê,ë,û,ù,ï,î,à,â,ô,ç")); }
@Test public final void testAccentRemovalNormalString_NoChange() { assertEquals("Colorless green ideas sleep furiously", this.getStringEncoder().removeAccents("Colorless green ideas sleep furiously")); }
@Test public final void testAccentRemoval_NINO_NoChange() { assertEquals("", this.getStringEncoder().removeAccents("")); }
@Test public final void testAccentRemoval_NullValue_ReturnNullSuccessfully() { assertEquals(null, this.getStringEncoder().removeAccents(null)); } |
### Question:
MatchRatingApproachEncoder implements StringEncoder { String removeDoubleConsonants(final String name) { String replacedName = name.toUpperCase(); for (final String dc : DOUBLE_CONSONANT) { if (replacedName.contains(dc)) { final String singleLetter = dc.substring(0, 1); replacedName = replacedName.replace(dc, singleLetter); } } return replacedName; } @Override final Object encode(final Object pObject); @Override final String encode(String name); boolean isEncodeEquals(String name1, String name2); }### Answer:
@Test public final void testRemoveSingleDoubleConsonants_BUBLE_RemovedSuccessfully() { assertEquals("BUBLE", this.getStringEncoder().removeDoubleConsonants("BUBBLE")); }
@Test public final void testRemoveDoubleConsonants_MISSISSIPPI_RemovedSuccessfully() { assertEquals("MISISIPI", this.getStringEncoder().removeDoubleConsonants("MISSISSIPPI")); }
@Test public final void testRemoveDoubleDoubleVowel_BEETLE_NotRemoved() { assertEquals("BEETLE", this.getStringEncoder().removeDoubleConsonants("BEETLE")); } |
### Question:
MatchRatingApproachEncoder implements StringEncoder { boolean isVowel(final String letter) { return letter.equalsIgnoreCase("E") || letter.equalsIgnoreCase("A") || letter.equalsIgnoreCase("O") || letter.equalsIgnoreCase("I") || letter.equalsIgnoreCase("U"); } @Override final Object encode(final Object pObject); @Override final String encode(String name); boolean isEncodeEquals(String name1, String name2); }### Answer:
@Test public final void testIsVowel_CapitalA_ReturnsTrue() { assertTrue(this.getStringEncoder().isVowel("A")); }
@Test public final void testIsVowel_SmallD_ReturnsFalse() { assertFalse(this.getStringEncoder().isVowel("d")); }
@Test public final void testisVowel_SingleVowel_ReturnsTrue() { assertTrue(this.getStringEncoder().isVowel(("I"))); } |
### Question:
MatchRatingApproachEncoder implements StringEncoder { String removeVowels(String name) { final String firstLetter = name.substring(0, 1); name = name.replaceAll("A", EMPTY); name = name.replaceAll("E", EMPTY); name = name.replaceAll("I", EMPTY); name = name.replaceAll("O", EMPTY); name = name.replaceAll("U", EMPTY); name = name.replaceAll("\\s{2,}\\b", SPACE); if (isVowel(firstLetter)) { return firstLetter + name; } else { return name; } } @Override final Object encode(final Object pObject); @Override final String encode(String name); boolean isEncodeEquals(String name1, String name2); }### Answer:
@Test public final void testRemoveVowel_ALESSANDRA_Returns_ALSSNDR() { assertEquals("ALSSNDR", this.getStringEncoder().removeVowels("ALESSANDRA")); }
@Test public final void testRemoveVowel__AIDAN_Returns_ADN() { assertEquals("ADN", this.getStringEncoder().removeVowels("AIDAN")); }
@Test public final void testRemoveVowel__DECLAN_Returns_DCLN() { assertEquals("DCLN", this.getStringEncoder().removeVowels("DECLAN")); } |
### Question:
MatchRatingApproachEncoder implements StringEncoder { String getFirst3Last3(final String name) { final int nameLength = name.length(); if (nameLength > SIX) { final String firstThree = name.substring(0, THREE); final String lastThree = name.substring(nameLength - THREE, nameLength); return firstThree + lastThree; } else { return name; } } @Override final Object encode(final Object pObject); @Override final String encode(String name); boolean isEncodeEquals(String name1, String name2); }### Answer:
@Test public final void testGetFirstLast3__ALEXANDER_Returns_Aleder() { assertEquals("Aleder", this.getStringEncoder().getFirst3Last3("Alexzander")); }
@Test public final void testGetFirstLast3_PETE_Returns_PETE() { assertEquals("PETE", this.getStringEncoder().getFirst3Last3("PETE")); } |
### Question:
MatchRatingApproachEncoder implements StringEncoder { int leftToRightThenRightToLeftProcessing(final String name1, final String name2) { final char[] name1Char = name1.toCharArray(); final char[] name2Char = name2.toCharArray(); final int name1Size = name1.length() - 1; final int name2Size = name2.length() - 1; String name1LtRStart = EMPTY; String name1LtREnd = EMPTY; String name2RtLStart = EMPTY; String name2RtLEnd = EMPTY; for (int i = 0; i < name1Char.length; i++) { if (i > name2Size) { break; } name1LtRStart = name1.substring(i, i + 1); name1LtREnd = name1.substring(name1Size - i, name1Size - i + 1); name2RtLStart = name2.substring(i, i + 1); name2RtLEnd = name2.substring(name2Size - i, name2Size - i + 1); if (name1LtRStart.equals(name2RtLStart)) { name1Char[i] = ' '; name2Char[i] = ' '; } if (name1LtREnd.equals(name2RtLEnd)) { name1Char[name1Size - i] = ' '; name2Char[name2Size - i] = ' '; } } final String strA = new String(name1Char).replaceAll("\\s+", EMPTY); final String strB = new String(name2Char).replaceAll("\\s+", EMPTY); if (strA.length() > strB.length()) { return Math.abs(SIX - strA.length()); } else { return Math.abs(SIX - strB.length()); } } @Override final Object encode(final Object pObject); @Override final String encode(String name); boolean isEncodeEquals(String name1, String name2); }### Answer:
@Test public final void testleftTorightThenRightToLeft_ALEXANDER_ALEXANDRA_Returns4() { assertEquals(4, this.getStringEncoder().leftToRightThenRightToLeftProcessing("ALEXANDER", "ALEXANDRA")); }
@Test public final void testleftTorightThenRightToLeft_EINSTEIN_MICHAELA_Returns0() { assertEquals(0, this.getStringEncoder().leftToRightThenRightToLeftProcessing("EINSTEIN", "MICHAELA")); } |
### Question:
MatchRatingApproachEncoder implements StringEncoder { int getMinRating(final int sumLength) { int minRating = 0; if (sumLength <= FOUR) { minRating = FIVE; } else if (sumLength >= FIVE && sumLength <= SEVEN) { minRating = FOUR; } else if (sumLength >= EIGHT && sumLength <= ELEVEN) { minRating = THREE; } else if (sumLength == TWELVE) { minRating = TWO; } else { minRating = ONE; } return minRating; } @Override final Object encode(final Object pObject); @Override final String encode(String name); boolean isEncodeEquals(String name1, String name2); }### Answer:
@Test public final void testGetMinRating_7_Return4_Successfully() { assertEquals(4, this.getStringEncoder().getMinRating(7)); }
@Test public final void testGetMinRating_1_Returns5_Successfully() { assertEquals(5, this.getStringEncoder().getMinRating(1)); }
@Test public final void testGetMinRating_2_Returns5_Successfully() { assertEquals(5, this.getStringEncoder().getMinRating(2)); }
@Test public final void testgetMinRating_5_Returns4_Successfully(){ assertEquals(4, this.getStringEncoder().getMinRating(5)); }
@Test public final void testgetMinRating_5_Returns4_Successfully2(){ assertEquals(4, this.getStringEncoder().getMinRating(5)); }
@Test public final void testgetMinRating_6_Returns4_Successfully(){ assertEquals(4, this.getStringEncoder().getMinRating(6)); }
@Test public final void testgetMinRating_7_Returns4_Successfully(){ assertEquals(4, this.getStringEncoder().getMinRating(7)); }
@Test public final void testgetMinRating_8_Returns3_Successfully(){ assertEquals(3, this.getStringEncoder().getMinRating(8)); }
@Test public final void testgetMinRating_10_Returns3_Successfully(){ assertEquals(3, this.getStringEncoder().getMinRating(10)); }
@Test public final void testgetMinRating_11_Returns_3_Successfully(){ assertEquals(3, this.getStringEncoder().getMinRating(11)); }
@Test public final void testGetMinRating_13_Returns_1_Successfully() { assertEquals(1, this.getStringEncoder().getMinRating(13)); } |
### Question:
MatchRatingApproachEncoder implements StringEncoder { String cleanName(final String name) { String upperName = name.toUpperCase(Locale.ENGLISH); final String[] charsToTrim = { "\\-", "[&]", "\\'", "\\.", "[\\,]" }; for (final String str : charsToTrim) { upperName = upperName.replaceAll(str, EMPTY); } upperName = removeAccents(upperName); upperName = upperName.replaceAll("\\s+", EMPTY); return upperName; } @Override final Object encode(final Object pObject); @Override final String encode(String name); boolean isEncodeEquals(String name1, String name2); }### Answer:
@Test public final void testcleanName_SuccessfullyClean() { assertEquals("THISISATEST", this.getStringEncoder().cleanName("This-ís a t.,es &t")); } |
### Question:
MatchRatingApproachEncoder implements StringEncoder { @Override public final Object encode(final Object pObject) throws EncoderException { if (!(pObject instanceof String)) { throw new EncoderException( "Parameter supplied to Match Rating Approach encoder is not of type java.lang.String"); } return encode((String) pObject); } @Override final Object encode(final Object pObject); @Override final String encode(String name); boolean isEncodeEquals(String name1, String name2); }### Answer:
@Test public final void testGetEncoding_HARPER_HRPR() { assertEquals("HRPR", this.getStringEncoder().encode("HARPER")); }
@Test public final void testGetEncoding_SMITH_to_SMTH() { assertEquals("SMTH", this.getStringEncoder().encode("Smith")); }
@Test public final void testGetEncoding_SMYTH_to_SMYTH() { assertEquals("SMYTH", this.getStringEncoder().encode("Smyth")); }
@Test public final void testGetEncoding_Space_to_Nothing() { assertEquals("", this.getStringEncoder().encode(" ")); }
@Test public final void testGetEncoding_NoSpace_to_Nothing() { assertEquals("", this.getStringEncoder().encode("")); }
@Test public final void testGetEncoding_Null_to_Nothing() { assertEquals("", this.getStringEncoder().encode(null)); }
@Test public final void testGetEncoding_One_Letter_to_Nothing() { assertEquals("", this.getStringEncoder().encode("E")); } |
### Question:
Parser implements ParserTreeConstants, ParserConstants { final public void Expression() throws ParseException { ASTExpression jjtn000 = new ASTExpression(JJTEXPRESSION); boolean jjtc000 = true; jjtree.openNodeScope(jjtn000); jjtn000.jjtSetFirstToken(getToken(1)); try { ConditionalOrExpression(); } catch (Throwable jjte000) { if (jjtc000) { jjtree.clearNodeScope(jjtn000); jjtc000 = false; } else { jjtree.popNode(); } if (jjte000 instanceof RuntimeException) { {if (true) throw (RuntimeException)jjte000;} } if (jjte000 instanceof ParseException) { {if (true) throw (ParseException)jjte000;} } {if (true) throw (Error)jjte000;} } finally { if (jjtc000) { jjtree.closeNodeScope(jjtn000, true); jjtn000.jjtSetLastToken(getToken(0)); } } } Parser(String s); Parser(java.io.InputStream stream); Parser(java.io.InputStream stream, String encoding); Parser(Reader stream); Parser(ParserTokenManager tm); final ASTRootNode parse(); final void DML(); final void Insert(); final void Delete(); final void Update(); final void Select(); final void Replace(); final void Merge(); final void Truncate(); final void Statement(); final void JDBCParameter(); final void JDBCIterableParameter(); final void GlobalTable(); final void JoinParameter(); final void QuoteText(); final void Text(); final void Blank(); final void IfStatement(); final void ElseStatement(); final void ElseIfStatement(); final void Expression(); final void ConditionalOrExpression(); final void ConditionalAndExpression(); final void RelationalExpression(); final void UnaryExpression(); final void PrimaryExpression(); final void ExpressionParameter(); final void IntegerLiteral(); final void StringLiteral(); final void True(); final void False(); final void Null(); void ReInit(java.io.InputStream stream); void ReInit(java.io.InputStream stream, String encoding); void ReInit(Reader stream); void ReInit(ParserTokenManager tm); final Token getNextToken(); final Token getToken(int index); ParseException generateParseException(); final void enable_tracing(); final void disable_tracing(); public ParserTokenManager token_source; public Token token; public Token jj_nt; }### Answer:
@Test public void testExpression() throws Exception { String sql = "select where 1=1 #if(:1==false && :2!=null && :3==true) and id>10 #end"; ASTRootNode n = new Parser(sql).parse().init(); ParameterContext ctx = getParameterContext(Lists.newArrayList((Type) Boolean.class, Object.class, Boolean.class)); n.checkAndBind(ctx); InvocationContext context = DefaultInvocationContext.create(); context.addParameter("1", false); context.addParameter("2", new Object()); context.addParameter("3", true); n.render(context); BoundSql boundSql = context.getBoundSql(); assertThat(boundSql.getSql().toString(), equalTo("select where 1=1 and id>10 ")); } |
### Question:
Reflection { public static Set<Annotation> getAnnotations(Class<?> clazz) { Set<Annotation> annos = new HashSet<Annotation>(); getAnnotations(clazz, annos); return annos; } static T instantiate(Class<T> clazz); static T instantiateClass(Class<T> clazz); static T instantiateClass(Constructor<T> ctor, Object... args); static T newProxy(
Class<T> interfaceType, InvocationHandler handler); static void makeAccessible(Constructor<?> ctor); static Set<Annotation> getAnnotations(Class<?> clazz); }### Answer:
@Test public void testGetAnnotations() throws Exception { Set<Annotation> annos = new HashSet<Annotation>(); Reflection.getAnnotations(SubDao.class, annos); assertThat(annos.size(), equalTo(1)); } |
### Question:
DefaultProviderDataAccessor implements ProviderDataAccessor { @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) public List<ProviderProject> getProjectsByProviderConfigName(String providerConfigName) { try { Optional<Long> optionalConfigId = configurationAccessor.getProviderConfigurationByName(providerConfigName) .map(ConfigurationModel::getConfigurationId); if (optionalConfigId.isPresent()) { return providerProjectRepository.findByProviderConfigId(optionalConfigId.get()) .stream() .map(this::convertToProjectModel) .collect(Collectors.toList()); } } catch (AlertDatabaseConstraintException ignored) { } return List.of(); } @Autowired DefaultProviderDataAccessor(ProviderProjectRepository providerProjectRepository, ProviderUserProjectRelationRepository providerUserProjectRelationRepository, ProviderUserRepository providerUserRepository,
ConfigurationAccessor configurationAccessor); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<ProviderProject> getProjectsByProviderConfigName(String providerConfigName); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<ProviderProject> getProjectsByProviderConfigId(Long providerConfigId); @Override void deleteProjects(Collection<ProviderProject> providerProjects); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) Set<String> getEmailAddressesForProjectHref(String projectHref); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<ProviderUserModel> getUsersByProviderConfigId(Long providerConfigId); @Override List<ProviderUserModel> getUsersByProviderConfigName(String providerConfigName); @Override void updateProjectAndUserData(Long providerConfigId, Map<ProviderProject, Set<String>> projectToUserData, Set<String> additionalRelevantUsers); static final int MAX_DESCRIPTION_LENGTH; static final int MAX_PROJECT_NAME_LENGTH; }### Answer:
@Test public void getProjectsByProviderConfigNameTest() throws Exception { ConfigurationModel configurationModel = createConfigurationModel(); ProviderProjectEntity providerProjectEntity = new ProviderProjectEntity(name, description, href, projectOwnerEmail, 1L); ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); ProviderProjectRepository providerProjectRepository = Mockito.mock(ProviderProjectRepository.class); Mockito.when(configurationAccessor.getProviderConfigurationByName(Mockito.any())).thenReturn(Optional.of(configurationModel)); Mockito.when(providerProjectRepository.findByProviderConfigId(Mockito.any())).thenReturn(List.of(providerProjectEntity)); DefaultProviderDataAccessor providerDataAccessor = new DefaultProviderDataAccessor(providerProjectRepository, null, null, configurationAccessor); List<ProviderProject> providerProjectList = providerDataAccessor.getProjectsByProviderConfigName("test-providerConfigName"); assertEquals(1, providerProjectList.size()); ProviderProject providerProject = providerProjectList.get(0); testProviderProject(expectedProviderProject, providerProject); }
@Test public void getProjectsByProviderConfigNameEmptyTest() throws Exception { ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); ProviderProjectRepository providerProjectRepository = Mockito.mock(ProviderProjectRepository.class); Mockito.when(configurationAccessor.getProviderConfigurationByName(Mockito.any())).thenReturn(Optional.empty()); DefaultProviderDataAccessor providerDataAccessor = new DefaultProviderDataAccessor(providerProjectRepository, null, null, configurationAccessor); List<ProviderProject> providerProjectList = providerDataAccessor.getProjectsByProviderConfigName("test-providerConfigName"); assertTrue(providerProjectList.isEmpty()); } |
### Question:
DefaultProviderTaskPropertiesAccessor implements ProviderTaskPropertiesAccessor { @Override public void setTaskProperty(Long configId, String taskName, String propertyKey, String propertyValue) throws AlertDatabaseConstraintException { if (null == configId || StringUtils.isBlank(taskName) || StringUtils.isBlank(propertyKey) || StringUtils.isBlank(propertyValue)) { throw new AlertDatabaseConstraintException("All fields are required to save a task property"); } ProviderTaskPropertiesEntity taskPropertyToSave = new ProviderTaskPropertiesEntity(configId, taskName, propertyKey, propertyValue); providerTaskPropertiesRepository.save(taskPropertyToSave); } @Autowired DefaultProviderTaskPropertiesAccessor(ProviderTaskPropertiesRepository providerTaskPropertiesRepository); @Override Optional<String> getTaskProperty(String taskName, String propertyKey); @Override void setTaskProperty(Long configId, String taskName, String propertyKey, String propertyValue); }### Answer:
@Test public void setTaskPropertyExceptionTest() throws Exception { DefaultProviderTaskPropertiesAccessor providerTaskPropertiesAccessor = new DefaultProviderTaskPropertiesAccessor(providerTaskPropertiesRepository); try { providerTaskPropertiesAccessor.setTaskProperty(null, "", "", ""); fail(); } catch (AlertDatabaseConstraintException e) { assertNotNull(e); } }
@Test public void setTaskPropertyTest() throws Exception { final Long newConfigId = 2L; final String newTaskName = "taskName-new"; final String newPropertyName = "propertyName-new"; final String newValue = "value-new"; DefaultProviderTaskPropertiesAccessor providerTaskPropertiesAccessor = new DefaultProviderTaskPropertiesAccessor(providerTaskPropertiesRepository); providerTaskPropertiesAccessor.setTaskProperty(newConfigId, newTaskName, newPropertyName, newValue); Optional<ProviderTaskPropertiesEntity> providerTaskPropertiesEntityOptional = providerTaskPropertiesRepository.findByTaskNameAndPropertyName(newTaskName, newPropertyName); assertTrue(providerTaskPropertiesEntityOptional.isPresent()); ProviderTaskPropertiesEntity providerTaskPropertiesEntity = providerTaskPropertiesEntityOptional.get(); assertEquals(newConfigId, providerTaskPropertiesEntity.getProviderConfigId()); assertEquals(newTaskName, providerTaskPropertiesEntity.getTaskName()); assertEquals(newPropertyName, providerTaskPropertiesEntity.getPropertyName()); assertEquals(newValue, providerTaskPropertiesEntity.getValue()); } |
### Question:
DefaultDescriptorAccessor implements DescriptorAccessor { @Override public List<RegisteredDescriptorModel> getRegisteredDescriptors() throws AlertDatabaseConstraintException { List<RegisteredDescriptorEntity> allDescriptors = registeredDescriptorRepository.findAll(); List<RegisteredDescriptorModel> descriptorModels = new ArrayList<>(); for (RegisteredDescriptorEntity entity : allDescriptors) { descriptorModels.add(createRegisteredDescriptorModel(entity)); } return descriptorModels; } @Autowired DefaultDescriptorAccessor(RegisteredDescriptorRepository registeredDescriptorRepository, DefinedFieldRepository definedFieldRepository, ConfigContextRepository configContextRepository,
DescriptorTypeRepository descriptorTypeRepository); @Override List<RegisteredDescriptorModel> getRegisteredDescriptors(); @Override Optional<RegisteredDescriptorModel> getRegisteredDescriptorByKey(DescriptorKey descriptorKey); @Override List<RegisteredDescriptorModel> getRegisteredDescriptorsByType(DescriptorType descriptorType); @Override Optional<RegisteredDescriptorModel> getRegisteredDescriptorById(Long descriptorId); @Override List<DefinedFieldModel> getFieldsForDescriptor(DescriptorKey descriptorKey, ConfigContextEnum context); @Override List<DefinedFieldModel> getFieldsForDescriptorById(Long descriptorId, ConfigContextEnum context); }### Answer:
@Test public void getRegisteredDescriptorsTest() throws Exception { final String name = "name-test"; final Long typeId = 1L; final DescriptorType descriptorType = DescriptorType.CHANNEL; RegisteredDescriptorEntity registeredDescriptorEntity = new RegisteredDescriptorEntity(name, typeId); registeredDescriptorEntity.setId(1L); DescriptorTypeEntity descriptorTypeEntity = new DescriptorTypeEntity(descriptorType.name()); RegisteredDescriptorRepository registeredDescriptorRepository = Mockito.mock(RegisteredDescriptorRepository.class); DescriptorTypeRepository descriptorTypeRepository = Mockito.mock(DescriptorTypeRepository.class); Mockito.when(registeredDescriptorRepository.findAll()).thenReturn(List.of(registeredDescriptorEntity)); Mockito.when(descriptorTypeRepository.findById(Mockito.any())).thenReturn(Optional.of(descriptorTypeEntity)); DefaultDescriptorAccessor descriptorAccessor = new DefaultDescriptorAccessor(registeredDescriptorRepository, null, null, descriptorTypeRepository); List<RegisteredDescriptorModel> registeredDescriptorModelList = descriptorAccessor.getRegisteredDescriptors(); assertEquals(1, registeredDescriptorModelList.size()); RegisteredDescriptorModel registeredDescriptorModel = registeredDescriptorModelList.get(0); assertEquals(name, registeredDescriptorModel.getName()); assertEquals(descriptorType, registeredDescriptorModel.getType()); } |
### Question:
DefaultDescriptorAccessor implements DescriptorAccessor { @Override public Optional<RegisteredDescriptorModel> getRegisteredDescriptorByKey(DescriptorKey descriptorKey) throws AlertDatabaseConstraintException { if (null == descriptorKey || StringUtils.isBlank(descriptorKey.getUniversalKey())) { throw new AlertDatabaseConstraintException(String.format("DescriptorKey is not valid. %s", descriptorKey)); } Optional<RegisteredDescriptorEntity> descriptorEntity = registeredDescriptorRepository.findFirstByName(descriptorKey.getUniversalKey()); if (descriptorEntity.isPresent()) { return Optional.of(createRegisteredDescriptorModel(descriptorEntity.get())); } return Optional.empty(); } @Autowired DefaultDescriptorAccessor(RegisteredDescriptorRepository registeredDescriptorRepository, DefinedFieldRepository definedFieldRepository, ConfigContextRepository configContextRepository,
DescriptorTypeRepository descriptorTypeRepository); @Override List<RegisteredDescriptorModel> getRegisteredDescriptors(); @Override Optional<RegisteredDescriptorModel> getRegisteredDescriptorByKey(DescriptorKey descriptorKey); @Override List<RegisteredDescriptorModel> getRegisteredDescriptorsByType(DescriptorType descriptorType); @Override Optional<RegisteredDescriptorModel> getRegisteredDescriptorById(Long descriptorId); @Override List<DefinedFieldModel> getFieldsForDescriptor(DescriptorKey descriptorKey, ConfigContextEnum context); @Override List<DefinedFieldModel> getFieldsForDescriptorById(Long descriptorId, ConfigContextEnum context); }### Answer:
@Test public void getRegisteredDescriptorByKeyTest() throws Exception { final String name = "name-test"; final Long typeId = 1L; final DescriptorType descriptorType = DescriptorType.CHANNEL; RegisteredDescriptorEntity registeredDescriptorEntity = new RegisteredDescriptorEntity(name, typeId); registeredDescriptorEntity.setId(1L); DescriptorKey descriptorKey = createDescriptorKey("descriptorKey-test"); DescriptorKey emptyDescriptorKey = createDescriptorKey("bad-key"); DescriptorTypeEntity descriptorTypeEntity = new DescriptorTypeEntity(descriptorType.name()); RegisteredDescriptorRepository registeredDescriptorRepository = Mockito.mock(RegisteredDescriptorRepository.class); DescriptorTypeRepository descriptorTypeRepository = Mockito.mock(DescriptorTypeRepository.class); Mockito.when(registeredDescriptorRepository.findFirstByName(descriptorKey.getUniversalKey())).thenReturn(Optional.of(registeredDescriptorEntity)); Mockito.when(registeredDescriptorRepository.findFirstByName(emptyDescriptorKey.getUniversalKey())).thenReturn(Optional.empty()); Mockito.when(descriptorTypeRepository.findById(Mockito.any())).thenReturn(Optional.of(descriptorTypeEntity)); DefaultDescriptorAccessor descriptorAccessor = new DefaultDescriptorAccessor(registeredDescriptorRepository, null, null, descriptorTypeRepository); Optional<RegisteredDescriptorModel> registeredDescriptorModelOptional = descriptorAccessor.getRegisteredDescriptorByKey(descriptorKey); Optional<RegisteredDescriptorModel> registeredDescriptorModelOptionalEmpty = descriptorAccessor.getRegisteredDescriptorByKey(emptyDescriptorKey); assertTrue(registeredDescriptorModelOptional.isPresent()); RegisteredDescriptorModel registeredDescriptorModel = registeredDescriptorModelOptional.get(); assertFalse(registeredDescriptorModelOptionalEmpty.isPresent()); assertEquals(name, registeredDescriptorModel.getName()); assertEquals(descriptorType, registeredDescriptorModel.getType()); }
@Test public void descriptorKeyFailureTest() throws Exception { DefaultDescriptorAccessor descriptorAccessor = new DefaultDescriptorAccessor(null, null, null, null); DescriptorKey descriptorKey = createDescriptorKey(""); try { descriptorAccessor.getRegisteredDescriptorByKey(descriptorKey); fail(); } catch (AlertDatabaseConstraintException e) { logger.error(e.getMessage(), e); } } |
### Question:
DefaultDescriptorAccessor implements DescriptorAccessor { @Override public Optional<RegisteredDescriptorModel> getRegisteredDescriptorById(Long descriptorId) throws AlertDatabaseConstraintException { RegisteredDescriptorEntity descriptor = findDescriptorById(descriptorId); return Optional.of(createRegisteredDescriptorModel(descriptor)); } @Autowired DefaultDescriptorAccessor(RegisteredDescriptorRepository registeredDescriptorRepository, DefinedFieldRepository definedFieldRepository, ConfigContextRepository configContextRepository,
DescriptorTypeRepository descriptorTypeRepository); @Override List<RegisteredDescriptorModel> getRegisteredDescriptors(); @Override Optional<RegisteredDescriptorModel> getRegisteredDescriptorByKey(DescriptorKey descriptorKey); @Override List<RegisteredDescriptorModel> getRegisteredDescriptorsByType(DescriptorType descriptorType); @Override Optional<RegisteredDescriptorModel> getRegisteredDescriptorById(Long descriptorId); @Override List<DefinedFieldModel> getFieldsForDescriptor(DescriptorKey descriptorKey, ConfigContextEnum context); @Override List<DefinedFieldModel> getFieldsForDescriptorById(Long descriptorId, ConfigContextEnum context); }### Answer:
@Test public void getRegisteredDescriptorByIdTest() throws Exception { final String name = "name-test"; final Long typeId = 1L; final DescriptorType descriptorType = DescriptorType.CHANNEL; final Long descriptorId = 2L; RegisteredDescriptorEntity registeredDescriptorEntity = new RegisteredDescriptorEntity(name, typeId); registeredDescriptorEntity.setId(1L); DescriptorTypeEntity descriptorTypeEntity = new DescriptorTypeEntity(descriptorType.name()); descriptorTypeEntity.setId(2L); RegisteredDescriptorRepository registeredDescriptorRepository = Mockito.mock(RegisteredDescriptorRepository.class); DescriptorTypeRepository descriptorTypeRepository = Mockito.mock(DescriptorTypeRepository.class); Mockito.when(registeredDescriptorRepository.findById(descriptorId)).thenReturn(Optional.of(registeredDescriptorEntity)); Mockito.when(descriptorTypeRepository.findById(Mockito.any())).thenReturn(Optional.of(descriptorTypeEntity)); DefaultDescriptorAccessor descriptorAccessor = new DefaultDescriptorAccessor(registeredDescriptorRepository, null, null, descriptorTypeRepository); Optional<RegisteredDescriptorModel> registeredDescriptorModelOptional = descriptorAccessor.getRegisteredDescriptorById(descriptorId); assertTrue(registeredDescriptorModelOptional.isPresent()); RegisteredDescriptorModel registeredDescriptorModel = registeredDescriptorModelOptional.get(); assertEquals(typeId, registeredDescriptorModel.getId()); assertEquals(name, registeredDescriptorModel.getName()); assertEquals(descriptorType, registeredDescriptorModel.getType()); } |
### Question:
DefaultDescriptorAccessor implements DescriptorAccessor { @Override public List<DefinedFieldModel> getFieldsForDescriptor(DescriptorKey descriptorKey, ConfigContextEnum context) throws AlertDatabaseConstraintException { RegisteredDescriptorEntity descriptor = findDescriptorByKey(descriptorKey); Long contextId = saveContextAndReturnId(context); return getFieldsForDescriptorId(descriptor.getId(), contextId, context); } @Autowired DefaultDescriptorAccessor(RegisteredDescriptorRepository registeredDescriptorRepository, DefinedFieldRepository definedFieldRepository, ConfigContextRepository configContextRepository,
DescriptorTypeRepository descriptorTypeRepository); @Override List<RegisteredDescriptorModel> getRegisteredDescriptors(); @Override Optional<RegisteredDescriptorModel> getRegisteredDescriptorByKey(DescriptorKey descriptorKey); @Override List<RegisteredDescriptorModel> getRegisteredDescriptorsByType(DescriptorType descriptorType); @Override Optional<RegisteredDescriptorModel> getRegisteredDescriptorById(Long descriptorId); @Override List<DefinedFieldModel> getFieldsForDescriptor(DescriptorKey descriptorKey, ConfigContextEnum context); @Override List<DefinedFieldModel> getFieldsForDescriptorById(Long descriptorId, ConfigContextEnum context); }### Answer:
@Test public void getFieldsForDescriptorTest() throws Exception { final String name = "name-test"; final Long typeId = 1L; final ConfigContextEnum configContextEnum = ConfigContextEnum.GLOBAL; final ConfigContextEnum invalidConfigContextEnum = ConfigContextEnum.DISTRIBUTION; final String definedFieldsKey = "defined-field-key-test"; Boolean isSensitive = Boolean.TRUE; RegisteredDescriptorEntity registeredDescriptorEntity = new RegisteredDescriptorEntity(name, typeId); registeredDescriptorEntity.setId(1L); DescriptorKey descriptorKey = createDescriptorKey("descriptorKey-test"); ConfigContextEntity configContextEntity = new ConfigContextEntity(configContextEnum.name()); configContextEntity.setId(3L); DefinedFieldEntity definedFieldEntity = new DefinedFieldEntity(definedFieldsKey, isSensitive); RegisteredDescriptorRepository registeredDescriptorRepository = Mockito.mock(RegisteredDescriptorRepository.class); DefinedFieldRepository definedFieldRepository = Mockito.mock(DefinedFieldRepository.class); ConfigContextRepository configContextRepository = Mockito.mock(ConfigContextRepository.class); DescriptorTypeRepository descriptorTypeRepository = Mockito.mock(DescriptorTypeRepository.class); Mockito.when(registeredDescriptorRepository.findFirstByName(descriptorKey.getUniversalKey())).thenReturn(Optional.of(registeredDescriptorEntity)); Mockito.when(configContextRepository.findFirstByContext(configContextEnum.name())).thenReturn(Optional.of(configContextEntity)); Mockito.when(configContextRepository.findFirstByContext(invalidConfigContextEnum.name())).thenReturn(Optional.empty()); Mockito.when(configContextRepository.save(Mockito.any())).thenReturn(configContextEntity); Mockito.when(definedFieldRepository.findByDescriptorIdAndContext(Mockito.any(), Mockito.any())).thenReturn(List.of(definedFieldEntity)); DefaultDescriptorAccessor descriptorAccessor = new DefaultDescriptorAccessor(registeredDescriptorRepository, definedFieldRepository, configContextRepository, descriptorTypeRepository); List<DefinedFieldModel> definedFieldModelList = descriptorAccessor.getFieldsForDescriptor(descriptorKey, configContextEnum); List<DefinedFieldModel> emptyConfigContextDefinedFieldModelList = descriptorAccessor.getFieldsForDescriptor(descriptorKey, invalidConfigContextEnum); assertEquals(1, definedFieldModelList.size()); DefinedFieldModel definedFieldModel = definedFieldModelList.get(0); assertEquals(definedFieldsKey, definedFieldModel.getKey()); assertEquals(isSensitive, definedFieldModel.getSensitive()); List<ConfigContextEnum> configContextList = new ArrayList<>(definedFieldModel.getContexts()); assertEquals(configContextEnum, configContextList.get(0)); assertEquals(1, emptyConfigContextDefinedFieldModelList.size()); DefinedFieldModel emptyConfigContextDefinedFieldModel = emptyConfigContextDefinedFieldModelList.get(0); assertEquals(definedFieldsKey, emptyConfigContextDefinedFieldModel.getKey()); assertEquals(isSensitive, emptyConfigContextDefinedFieldModel.getSensitive()); List<ConfigContextEnum> configContextList2 = new ArrayList<>(emptyConfigContextDefinedFieldModel.getContexts()); assertEquals(invalidConfigContextEnum, configContextList2.get(0)); } |
### Question:
DefaultDescriptorAccessor implements DescriptorAccessor { @Override public List<DefinedFieldModel> getFieldsForDescriptorById(Long descriptorId, ConfigContextEnum context) throws AlertDatabaseConstraintException { RegisteredDescriptorEntity descriptor = findDescriptorById(descriptorId); Long contextId = saveContextAndReturnId(context); return getFieldsForDescriptorId(descriptor.getId(), contextId, context); } @Autowired DefaultDescriptorAccessor(RegisteredDescriptorRepository registeredDescriptorRepository, DefinedFieldRepository definedFieldRepository, ConfigContextRepository configContextRepository,
DescriptorTypeRepository descriptorTypeRepository); @Override List<RegisteredDescriptorModel> getRegisteredDescriptors(); @Override Optional<RegisteredDescriptorModel> getRegisteredDescriptorByKey(DescriptorKey descriptorKey); @Override List<RegisteredDescriptorModel> getRegisteredDescriptorsByType(DescriptorType descriptorType); @Override Optional<RegisteredDescriptorModel> getRegisteredDescriptorById(Long descriptorId); @Override List<DefinedFieldModel> getFieldsForDescriptor(DescriptorKey descriptorKey, ConfigContextEnum context); @Override List<DefinedFieldModel> getFieldsForDescriptorById(Long descriptorId, ConfigContextEnum context); }### Answer:
@Test public void getFieldsForDescriptorByIdTest() throws Exception { final String name = "name-test"; final Long typeId = 1L; final ConfigContextEnum configContextEnum = ConfigContextEnum.GLOBAL; final String definedFieldsKey = "defined-field-key-test"; Boolean isSensitive = Boolean.TRUE; final Long descriptorId = 1L; RegisteredDescriptorEntity registeredDescriptorEntity = new RegisteredDescriptorEntity(name, typeId); registeredDescriptorEntity.setId(1L); ConfigContextEntity configContextEntity = new ConfigContextEntity(configContextEnum.name()); configContextEntity.setId(3L); DefinedFieldEntity definedFieldEntity = new DefinedFieldEntity(definedFieldsKey, isSensitive); RegisteredDescriptorRepository registeredDescriptorRepository = Mockito.mock(RegisteredDescriptorRepository.class); DefinedFieldRepository definedFieldRepository = Mockito.mock(DefinedFieldRepository.class); ConfigContextRepository configContextRepository = Mockito.mock(ConfigContextRepository.class); DescriptorTypeRepository descriptorTypeRepository = Mockito.mock(DescriptorTypeRepository.class); Mockito.when(registeredDescriptorRepository.findById(descriptorId)).thenReturn(Optional.of(registeredDescriptorEntity)); Mockito.when(configContextRepository.findFirstByContext(configContextEnum.name())).thenReturn(Optional.of(configContextEntity)); Mockito.when(definedFieldRepository.findByDescriptorIdAndContext(Mockito.any(), Mockito.any())).thenReturn(List.of(definedFieldEntity)); DefaultDescriptorAccessor descriptorAccessor = new DefaultDescriptorAccessor(registeredDescriptorRepository, definedFieldRepository, configContextRepository, descriptorTypeRepository); List<DefinedFieldModel> definedFieldModelList = descriptorAccessor.getFieldsForDescriptorById(descriptorId, configContextEnum); assertEquals(1, definedFieldModelList.size()); DefinedFieldModel definedFieldModel = definedFieldModelList.get(0); assertEquals(definedFieldsKey, definedFieldModel.getKey()); assertEquals(isSensitive, definedFieldModel.getSensitive()); List<ConfigContextEnum> configContextList = new ArrayList<>(definedFieldModel.getContexts()); assertEquals(configContextEnum, configContextList.get(0)); } |
### Question:
DefaultProviderDataAccessor implements ProviderDataAccessor { @Override public List<ProviderUserModel> getUsersByProviderConfigName(String providerConfigName) { if (StringUtils.isBlank(providerConfigName)) { return List.of(); } try { Optional<Long> optionalProviderConfigId = configurationAccessor.getProviderConfigurationByName(providerConfigName) .map(ConfigurationModel::getConfigurationId); if (optionalProviderConfigId.isPresent()) { return getUsersByProviderConfigId(optionalProviderConfigId.get()); } } catch (AlertDatabaseConstraintException ignored) { } return List.of(); } @Autowired DefaultProviderDataAccessor(ProviderProjectRepository providerProjectRepository, ProviderUserProjectRelationRepository providerUserProjectRelationRepository, ProviderUserRepository providerUserRepository,
ConfigurationAccessor configurationAccessor); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<ProviderProject> getProjectsByProviderConfigName(String providerConfigName); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<ProviderProject> getProjectsByProviderConfigId(Long providerConfigId); @Override void deleteProjects(Collection<ProviderProject> providerProjects); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) Set<String> getEmailAddressesForProjectHref(String projectHref); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<ProviderUserModel> getUsersByProviderConfigId(Long providerConfigId); @Override List<ProviderUserModel> getUsersByProviderConfigName(String providerConfigName); @Override void updateProjectAndUserData(Long providerConfigId, Map<ProviderProject, Set<String>> projectToUserData, Set<String> additionalRelevantUsers); static final int MAX_DESCRIPTION_LENGTH; static final int MAX_PROJECT_NAME_LENGTH; }### Answer:
@Test public void getUsersByProviderConfigNameOptionalEmptyTest() throws Exception { ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); Mockito.when(configurationAccessor.getProviderConfigurationByName(Mockito.any())).thenReturn(Optional.empty()); DefaultProviderDataAccessor providerDataAccessor = new DefaultProviderDataAccessor(null, null, null, configurationAccessor); List<ProviderUserModel> providerUserModelList = providerDataAccessor.getUsersByProviderConfigName("providerConfigName-test"); assertTrue(providerUserModelList.isEmpty()); }
@Test public void getUsersByProviderConfigNameTest() throws Exception { ConfigurationModel configurationModel = createConfigurationModel(); ProviderUserEntity providerUserEntity = new ProviderUserEntity(projectOwnerEmail, true, 1L); ProviderProjectRepository providerProjectRepository = Mockito.mock(ProviderProjectRepository.class); ProviderUserRepository providerUserRepository = Mockito.mock(ProviderUserRepository.class); ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); Mockito.when(configurationAccessor.getProviderConfigurationByName(Mockito.any())).thenReturn(Optional.of(configurationModel)); Mockito.when(providerUserRepository.findByProviderConfigId(Mockito.any())).thenReturn(List.of(providerUserEntity)); DefaultProviderDataAccessor providerDataAccessor = new DefaultProviderDataAccessor(providerProjectRepository, null, providerUserRepository, configurationAccessor); List<ProviderUserModel> providerUserModelList = providerDataAccessor.getUsersByProviderConfigName("providerConfigName-test"); assertEquals(1, providerUserModelList.size()); ProviderUserModel providerUserModel = providerUserModelList.get(0); assertEquals(projectOwnerEmail, providerUserModel.getEmailAddress()); assertTrue(providerUserModel.getOptOut()); }
@Test public void getUsersByProviderConfigNameBlankTest() { DefaultProviderDataAccessor providerDataAccessor = new DefaultProviderDataAccessor(null, null, null, null); List<ProviderUserModel> providerUserModelList = providerDataAccessor.getUsersByProviderConfigName(""); assertTrue(providerUserModelList.isEmpty()); } |
### Question:
DefaultUserAccessor implements UserAccessor { @Override public List<UserModel> getUsers() { List<UserEntity> userList = userRepository.findAll(); return userList.stream().map(this::createModel).collect(Collectors.toList()); } @Autowired DefaultUserAccessor(UserRepository userRepository, UserRoleRepository userRoleRepository, PasswordEncoder defaultPasswordEncoder, DefaultRoleAccessor roleAccessor,
AuthenticationTypeAccessor authenticationTypeAccessor); @Override List<UserModel> getUsers(); @Override Optional<UserModel> getUser(Long userId); @Override Optional<UserModel> getUser(String username); @Override UserModel addUser(String userName, String password, String emailAddress); @Override UserModel addUser(UserModel user, boolean passwordEncoded); @Override UserModel updateUser(UserModel user, boolean passwordEncoded); @Override boolean assignRoles(String username, Set<Long> roleIds); @Override boolean changeUserPassword(String username, String newPassword); @Override boolean changeUserEmailAddress(String username, String emailAddress); @Override void deleteUser(String userName); @Override void deleteUser(Long userId); }### Answer:
@Test public void getUsersTest() { final Long authenticationTypeId = 1L; final String roleName = "userName"; UserEntity userEntity = new UserEntity(username, password, emailAddress, authenticationTypeId); userEntity.setId(1L); UserRoleRelation userRoleRelation = new UserRoleRelation(1L, 2L); UserRoleModel userRoleModel = createUserRoleModel(1L, roleName, true); Mockito.when(userRepository.findAll()).thenReturn(List.of(userEntity)); createModelMocks(userRoleRelation, userRoleModel, AuthenticationType.DATABASE); DefaultUserAccessor defaultUserAccessor = new DefaultUserAccessor(userRepository, userRoleRepository, defaultPasswordEncoder, roleAccessor, authenticationTypeAccessor); List<UserModel> userModelList = defaultUserAccessor.getUsers(); assertEquals(1, userModelList.size()); UserModel userModel = userModelList.get(0); testUserModel(userEntity.getId(), username, emailAddress, roleName, userModel); } |
### Question:
DefaultUserAccessor implements UserAccessor { @Override public Optional<UserModel> getUser(Long userId) { return userRepository.findById(userId).map(this::createModel); } @Autowired DefaultUserAccessor(UserRepository userRepository, UserRoleRepository userRoleRepository, PasswordEncoder defaultPasswordEncoder, DefaultRoleAccessor roleAccessor,
AuthenticationTypeAccessor authenticationTypeAccessor); @Override List<UserModel> getUsers(); @Override Optional<UserModel> getUser(Long userId); @Override Optional<UserModel> getUser(String username); @Override UserModel addUser(String userName, String password, String emailAddress); @Override UserModel addUser(UserModel user, boolean passwordEncoded); @Override UserModel updateUser(UserModel user, boolean passwordEncoded); @Override boolean assignRoles(String username, Set<Long> roleIds); @Override boolean changeUserPassword(String username, String newPassword); @Override boolean changeUserEmailAddress(String username, String emailAddress); @Override void deleteUser(String userName); @Override void deleteUser(Long userId); }### Answer:
@Test public void getUserByUserIdTest() { final Long userId = 1L; final Long emptyUserId = 5L; final Long authenticationTypeId = 1L; final String roleName = "userName"; UserEntity userEntity = new UserEntity(username, password, emailAddress, authenticationTypeId); userEntity.setId(1L); UserRoleRelation userRoleRelation = new UserRoleRelation(1L, 2L); UserRoleModel userRoleModel = createUserRoleModel(1L, roleName, true); Mockito.when(userRepository.findById(userId)).thenReturn(Optional.of(userEntity)); Mockito.when(userRepository.findById(emptyUserId)).thenReturn(Optional.empty()); createModelMocks(userRoleRelation, userRoleModel, AuthenticationType.DATABASE); DefaultUserAccessor defaultUserAccessor = new DefaultUserAccessor(userRepository, userRoleRepository, defaultPasswordEncoder, roleAccessor, authenticationTypeAccessor); Optional<UserModel> userModelOptional = defaultUserAccessor.getUser(userId); Optional<UserModel> userModelOptionalEmpty = defaultUserAccessor.getUser(emptyUserId); assertTrue(userModelOptional.isPresent()); assertFalse(userModelOptionalEmpty.isPresent()); UserModel userModel = userModelOptional.get(); testUserModel(userEntity.getId(), username, emailAddress, roleName, userModel); }
@Test public void getUserByUsernameTest() { final String emptyUsername = ""; final Long authenticationTypeId = 1L; final String roleName = "userName"; UserEntity userEntity = new UserEntity(username, password, emailAddress, authenticationTypeId); userEntity.setId(1L); UserRoleRelation userRoleRelation = new UserRoleRelation(1L, 2L); UserRoleModel userRoleModel = createUserRoleModel(1L, roleName, true); Mockito.when(userRepository.findByUserName(username)).thenReturn(Optional.of(userEntity)); Mockito.when(userRepository.findByUserName(emptyUsername)).thenReturn(Optional.empty()); createModelMocks(userRoleRelation, userRoleModel, AuthenticationType.DATABASE); DefaultUserAccessor defaultUserAccessor = new DefaultUserAccessor(userRepository, userRoleRepository, defaultPasswordEncoder, roleAccessor, authenticationTypeAccessor); Optional<UserModel> userModelOptional = defaultUserAccessor.getUser(username); Optional<UserModel> userModelOptionalEmpty = defaultUserAccessor.getUser(emptyUsername); assertTrue(userModelOptional.isPresent()); assertFalse(userModelOptionalEmpty.isPresent()); UserModel userModel = userModelOptional.get(); testUserModel(userEntity.getId(), username, emailAddress, roleName, userModel); } |
### Question:
DefaultUserAccessor implements UserAccessor { @Override public UserModel addUser(String userName, String password, String emailAddress) throws AlertDatabaseConstraintException { return addUser(UserModel.newUser(userName, password, emailAddress, AuthenticationType.DATABASE, Collections.emptySet(), true), false); } @Autowired DefaultUserAccessor(UserRepository userRepository, UserRoleRepository userRoleRepository, PasswordEncoder defaultPasswordEncoder, DefaultRoleAccessor roleAccessor,
AuthenticationTypeAccessor authenticationTypeAccessor); @Override List<UserModel> getUsers(); @Override Optional<UserModel> getUser(Long userId); @Override Optional<UserModel> getUser(String username); @Override UserModel addUser(String userName, String password, String emailAddress); @Override UserModel addUser(UserModel user, boolean passwordEncoded); @Override UserModel updateUser(UserModel user, boolean passwordEncoded); @Override boolean assignRoles(String username, Set<Long> roleIds); @Override boolean changeUserPassword(String username, String newPassword); @Override boolean changeUserEmailAddress(String username, String emailAddress); @Override void deleteUser(String userName); @Override void deleteUser(Long userId); }### Answer:
@Test public void addUserTest() throws Exception { final String roleName = "userName"; UserEntity userEntity = new UserEntity(username, password, emailAddress, 2L); userEntity.setId(1L); AuthenticationTypeDetails authenticationTypeDetails = new AuthenticationTypeDetails(2L, "authentication-name"); UserRoleRelation userRoleRelation = new UserRoleRelation(1L, 2L); UserRoleModel userRoleModel = createUserRoleModel(1L, roleName, true); Mockito.when(userRepository.findByUserName(Mockito.any())).thenReturn(Optional.empty()); Mockito.when(authenticationTypeAccessor.getAuthenticationTypeDetails(Mockito.any())).thenReturn(Optional.of(authenticationTypeDetails)); Mockito.when(userRepository.save(Mockito.any())).thenReturn(userEntity); createModelMocks(userRoleRelation, userRoleModel, AuthenticationType.DATABASE); DefaultUserAccessor defaultUserAccessor = new DefaultUserAccessor(userRepository, userRoleRepository, defaultPasswordEncoder, roleAccessor, authenticationTypeAccessor); UserModel userModel = defaultUserAccessor.addUser(username, password, emailAddress); testUserModel(userEntity.getId(), username, emailAddress, roleName, userModel); }
@Test public void addUserExistsTest() throws Exception { UserEntity userEntity = new UserEntity(username, password, emailAddress, 2L); userEntity.setId(1L); Mockito.when(userRepository.findByUserName(Mockito.any())).thenReturn(Optional.of(userEntity)); DefaultUserAccessor defaultUserAccessor = new DefaultUserAccessor(userRepository, userRoleRepository, defaultPasswordEncoder, roleAccessor, authenticationTypeAccessor); try { defaultUserAccessor.addUser(username, password, emailAddress); fail("User with the same name that already exists in the userRepository did not throw expected AlertForbiddenOperationException."); } catch (AlertDatabaseConstraintException e) { assertNotNull(e); } } |
### Question:
DefaultUserAccessor implements UserAccessor { @Override public boolean assignRoles(String username, Set<Long> roleIds) { Optional<Long> optionalUserId = userRepository.findByUserName(username).map(UserEntity::getId); if (optionalUserId.isPresent()) { roleAccessor.updateUserRoles(optionalUserId.get(), roleAccessor.getRoles(roleIds)); return true; } return false; } @Autowired DefaultUserAccessor(UserRepository userRepository, UserRoleRepository userRoleRepository, PasswordEncoder defaultPasswordEncoder, DefaultRoleAccessor roleAccessor,
AuthenticationTypeAccessor authenticationTypeAccessor); @Override List<UserModel> getUsers(); @Override Optional<UserModel> getUser(Long userId); @Override Optional<UserModel> getUser(String username); @Override UserModel addUser(String userName, String password, String emailAddress); @Override UserModel addUser(UserModel user, boolean passwordEncoded); @Override UserModel updateUser(UserModel user, boolean passwordEncoded); @Override boolean assignRoles(String username, Set<Long> roleIds); @Override boolean changeUserPassword(String username, String newPassword); @Override boolean changeUserEmailAddress(String username, String emailAddress); @Override void deleteUser(String userName); @Override void deleteUser(Long userId); }### Answer:
@Test public void assignRolesTest() { final String badUsername = "badUsername"; final Long roleId = 5L; UserEntity userEntity = new UserEntity(username, password, emailAddress, 2L); userEntity.setId(1L); Mockito.when(userRepository.findByUserName(Mockito.eq(username))).thenReturn(Optional.of(userEntity)); Mockito.when(userRepository.findByUserName(Mockito.eq(badUsername))).thenReturn(Optional.empty()); DefaultUserAccessor defaultUserAccessor = new DefaultUserAccessor(userRepository, userRoleRepository, defaultPasswordEncoder, roleAccessor, authenticationTypeAccessor); boolean assignedRoles = defaultUserAccessor.assignRoles(username, Set.of(roleId)); boolean assignedRolesFalse = defaultUserAccessor.assignRoles(badUsername, Set.of(roleId)); Mockito.verify(roleAccessor).updateUserRoles(Mockito.eq(userEntity.getId()), Mockito.any()); Mockito.verify(roleAccessor).getRoles(Mockito.any()); assertTrue(assignedRoles); assertFalse(assignedRolesFalse); } |
### Question:
DefaultUserAccessor implements UserAccessor { @Override public boolean changeUserPassword(String username, String newPassword) { Optional<UserEntity> entity = userRepository.findByUserName(username); if (entity.isPresent()) { return changeUserPassword(entity.get(), newPassword); } return false; } @Autowired DefaultUserAccessor(UserRepository userRepository, UserRoleRepository userRoleRepository, PasswordEncoder defaultPasswordEncoder, DefaultRoleAccessor roleAccessor,
AuthenticationTypeAccessor authenticationTypeAccessor); @Override List<UserModel> getUsers(); @Override Optional<UserModel> getUser(Long userId); @Override Optional<UserModel> getUser(String username); @Override UserModel addUser(String userName, String password, String emailAddress); @Override UserModel addUser(UserModel user, boolean passwordEncoded); @Override UserModel updateUser(UserModel user, boolean passwordEncoded); @Override boolean assignRoles(String username, Set<Long> roleIds); @Override boolean changeUserPassword(String username, String newPassword); @Override boolean changeUserEmailAddress(String username, String emailAddress); @Override void deleteUser(String userName); @Override void deleteUser(Long userId); }### Answer:
@Test public void changeUserPasswordTest() { final String badUsername = "badUsername"; final String newPassword = "newPassword"; UserEntity userEntity = new UserEntity(username, password, emailAddress, 2L); userEntity.setId(1L); UserEntity newUserEntity = new UserEntity(username, newPassword, emailAddress, 2L); userEntity.setId(1L); Mockito.when(userRepository.findByUserName(Mockito.eq(username))).thenReturn(Optional.of(userEntity)); Mockito.when(userRepository.findByUserName(Mockito.eq(badUsername))).thenReturn(Optional.empty()); Mockito.when(defaultPasswordEncoder.encode(Mockito.any())).thenReturn(newPassword); Mockito.when(userRepository.save(Mockito.any())).thenReturn(newUserEntity); DefaultUserAccessor defaultUserAccessor = new DefaultUserAccessor(userRepository, userRoleRepository, defaultPasswordEncoder, roleAccessor, authenticationTypeAccessor); assertTrue(defaultUserAccessor.changeUserPassword(username, newPassword)); assertFalse(defaultUserAccessor.changeUserPassword(badUsername, newPassword)); } |
### Question:
DefaultUserAccessor implements UserAccessor { @Override public boolean changeUserEmailAddress(String username, String emailAddress) { Optional<UserEntity> entity = userRepository.findByUserName(username); if (entity.isPresent()) { return changeUserEmailAddress(entity.get(), emailAddress); } return false; } @Autowired DefaultUserAccessor(UserRepository userRepository, UserRoleRepository userRoleRepository, PasswordEncoder defaultPasswordEncoder, DefaultRoleAccessor roleAccessor,
AuthenticationTypeAccessor authenticationTypeAccessor); @Override List<UserModel> getUsers(); @Override Optional<UserModel> getUser(Long userId); @Override Optional<UserModel> getUser(String username); @Override UserModel addUser(String userName, String password, String emailAddress); @Override UserModel addUser(UserModel user, boolean passwordEncoded); @Override UserModel updateUser(UserModel user, boolean passwordEncoded); @Override boolean assignRoles(String username, Set<Long> roleIds); @Override boolean changeUserPassword(String username, String newPassword); @Override boolean changeUserEmailAddress(String username, String emailAddress); @Override void deleteUser(String userName); @Override void deleteUser(Long userId); }### Answer:
@Test public void changeUserEmailAddressTest() { final String badUsername = "badUsername"; final String newEmailAddress = "[email protected]"; UserEntity userEntity = new UserEntity(username, password, emailAddress, 2L); userEntity.setId(1L); UserEntity newUserEntity = new UserEntity(username, password, newEmailAddress, 2L); userEntity.setId(1L); Mockito.when(userRepository.findByUserName(Mockito.eq(username))).thenReturn(Optional.of(userEntity)); Mockito.when(userRepository.findByUserName(Mockito.eq(badUsername))).thenReturn(Optional.empty()); Mockito.when(userRepository.save(Mockito.any())).thenReturn(newUserEntity); DefaultUserAccessor defaultUserAccessor = new DefaultUserAccessor(userRepository, userRoleRepository, defaultPasswordEncoder, roleAccessor, authenticationTypeAccessor); assertTrue(defaultUserAccessor.changeUserEmailAddress(username, newEmailAddress)); assertFalse(defaultUserAccessor.changeUserEmailAddress(badUsername, newEmailAddress)); } |
### Question:
DefaultUserAccessor implements UserAccessor { @Override public void deleteUser(String userName) throws AlertForbiddenOperationException { Optional<UserEntity> optionalUser = userRepository.findByUserName(userName); if (optionalUser.isPresent()) { UserEntity user = optionalUser.get(); deleteUserEntity(user); } } @Autowired DefaultUserAccessor(UserRepository userRepository, UserRoleRepository userRoleRepository, PasswordEncoder defaultPasswordEncoder, DefaultRoleAccessor roleAccessor,
AuthenticationTypeAccessor authenticationTypeAccessor); @Override List<UserModel> getUsers(); @Override Optional<UserModel> getUser(Long userId); @Override Optional<UserModel> getUser(String username); @Override UserModel addUser(String userName, String password, String emailAddress); @Override UserModel addUser(UserModel user, boolean passwordEncoded); @Override UserModel updateUser(UserModel user, boolean passwordEncoded); @Override boolean assignRoles(String username, Set<Long> roleIds); @Override boolean changeUserPassword(String username, String newPassword); @Override boolean changeUserEmailAddress(String username, String emailAddress); @Override void deleteUser(String userName); @Override void deleteUser(Long userId); }### Answer:
@Test public void deleteUserByNameTest() throws Exception { UserEntity userEntity = new UserEntity(username, password, emailAddress, 2L); userEntity.setId(5L); Mockito.when(userRepository.findByUserName(Mockito.eq(username))).thenReturn(Optional.of(userEntity)); DefaultUserAccessor defaultUserAccessor = new DefaultUserAccessor(userRepository, userRoleRepository, defaultPasswordEncoder, roleAccessor, authenticationTypeAccessor); defaultUserAccessor.deleteUser(username); Mockito.verify(roleAccessor).updateUserRoles(Mockito.any(), Mockito.any()); Mockito.verify(userRepository).deleteById(Mockito.any()); }
@Test public void deleteUserByIdTest() throws Exception { UserEntity userEntity = new UserEntity(username, password, emailAddress, 2L); userEntity.setId(5L); Mockito.when(userRepository.findById(Mockito.eq(userEntity.getId()))).thenReturn(Optional.of(userEntity)); DefaultUserAccessor defaultUserAccessor = new DefaultUserAccessor(userRepository, userRoleRepository, defaultPasswordEncoder, roleAccessor, authenticationTypeAccessor); defaultUserAccessor.deleteUser(userEntity.getId()); Mockito.verify(roleAccessor).updateUserRoles(Mockito.any(), Mockito.any()); Mockito.verify(userRepository).deleteById(Mockito.any()); }
@Test public void deleteUserReservedIdTest() throws Exception { UserEntity userEntity = new UserEntity(username, password, emailAddress, 2L); userEntity.setId(1L); Mockito.when(userRepository.findByUserName(Mockito.eq(username))).thenReturn(Optional.of(userEntity)); Mockito.when(userRepository.findById(Mockito.any())).thenReturn(Optional.of(userEntity)); DefaultUserAccessor defaultUserAccessor = new DefaultUserAccessor(userRepository, userRoleRepository, defaultPasswordEncoder, roleAccessor, authenticationTypeAccessor); try { defaultUserAccessor.deleteUser(username); fail("A forbidden userEntity id did not throw the expected AlertForbiddenOperationException"); } catch (AlertForbiddenOperationException e) { assertNotNull(e); } } |
### Question:
AzureFieldsExtractor { public <T> Optional<T> extractField(JsonObject fieldsObject, AzureFieldDefinition<T> fieldDefinition) { JsonElement foundField = fieldsObject.get(fieldDefinition.getFieldName()); if (null != foundField) { T fieldValue = gson.fromJson(foundField, fieldDefinition.getFieldType()); return Optional.of(fieldValue); } return Optional.empty(); } AzureFieldsExtractor(Gson gson); Optional<T> extractField(JsonObject fieldsObject, AzureFieldDefinition<T> fieldDefinition); }### Answer:
@Test public void extractFieldValidTest() { Gson gson = new GsonBuilder().create(); AzureFieldsExtractor azureFieldsExtractor = new AzureFieldsExtractor(gson); FieldsTestClass originalCopy = createTestClass("a value", 42, "a different value", 8675309); String jsonString = gson.toJson(originalCopy); JsonObject jsonObject = gson.fromJson(jsonString, JsonObject.class); Optional<String> field1Value = azureFieldsExtractor.extractField(jsonObject, FieldsTestClass.FIELD_1); assertTrue(field1Value.isPresent(), "Field 1 was not present"); assertEquals(originalCopy.getField1(), field1Value.get()); Optional<Integer> field2Value = azureFieldsExtractor.extractField(jsonObject, FieldsTestClass.FIELD_2); assertTrue(field2Value.isPresent(), "Field 2 was not present"); assertEquals(originalCopy.getField2(), field2Value.get()); Optional<FieldsTestInnerClass> field3Value = azureFieldsExtractor.extractField(jsonObject, FieldsTestClass.FIELD_3); assertTrue(field3Value.isPresent(), "Field 3 was not present"); FieldsTestInnerClass field3Object = field3Value.get(); assertEquals(originalCopy.getField3().getInnerField1(), field3Object.getInnerField1()); assertEquals(originalCopy.getField3().getInnerField2(), field3Object.getInnerField2()); } |
### Question:
JiraServerProperties implements IssueTrackerServiceConfig { public JiraServerServiceFactory createJiraServicesServerFactory(Logger logger, Gson gson) throws IssueTrackerException { JiraServerRestConfig jiraServerConfig = createJiraServerConfig(); Slf4jIntLogger intLogger = new Slf4jIntLogger(logger); JiraHttpClient jiraHttpClient = jiraServerConfig.createJiraHttpClient(intLogger); return new JiraServerServiceFactory(intLogger, jiraHttpClient, gson); } JiraServerProperties(String url, String password, String username, boolean pluginCheckDisabled); JiraServerRestConfig createJiraServerConfig(); JiraServerServiceFactory createJiraServicesServerFactory(Logger logger, Gson gson); String getUrl(); String getPassword(); String getUsername(); boolean isPluginCheckDisabled(); }### Answer:
@Test public void testServerServiceFactory() { try { JiraServerProperties properties = new JiraServerProperties("http: JiraServerServiceFactory serviceFactory = properties.createJiraServicesServerFactory(LoggerFactory.getLogger(getClass()), new Gson()); assertNotNull(serviceFactory); } catch (IssueTrackerException ex) { ex.printStackTrace(); fail(); } } |
### Question:
JiraServerIssueConfigValidator extends JiraIssueConfigValidator { @Override public Collection<ProjectComponent> getProjectsByName(String jiraProjectName) throws IntegrationException { return projectService.getProjectsByName(jiraProjectName); } JiraServerIssueConfigValidator(ProjectService projectService, UserSearchService userSearchService, IssueTypeService issueTypeService, IssueMetaDataService issueMetaDataService); @Override String getProjectFieldKey(); @Override String getIssueTypeFieldKey(); @Override String getIssueCreatorFieldKey(); @Override String getAddCommentsFieldKey(); @Override String getResolveTransitionFieldKey(); @Override String getOpenTransitionFieldKey(); @Override Collection<ProjectComponent> getProjectsByName(String jiraProjectName); @Override boolean isUserValid(String issueCreator); }### Answer:
@Test public void validateSuccessTest() throws IntegrationException { ProjectService projectService = Mockito.mock(ProjectService.class); UserSearchService userSearchService = Mockito.mock(UserSearchService.class); IssueTypeService issueTypeService = Mockito.mock(IssueTypeService.class); IssueMetaDataService issueMetaDataService = Mockito.mock(IssueMetaDataService.class); Mockito.when(issueMetaDataService.doesProjectContainIssueType(Mockito.anyString(), Mockito.anyString())).thenReturn(Boolean.TRUE); JiraServerIssueConfigValidator jiraIssueConfigValidator = new JiraServerIssueConfigValidator(projectService, userSearchService, issueTypeService, issueMetaDataService); String resolveTransitionString = "Resolve"; String projectName = "ProjectName"; String issueTypeString = "IssueType"; String issueCreatorString = "IssueCreator"; IssueConfig issueConfig = new IssueConfig(); issueConfig.setCommentOnIssues(true); issueConfig.setResolveTransition(resolveTransitionString); issueConfig.setProjectName(projectName); issueConfig.setIssueType(issueTypeString); issueConfig.setIssueCreator(issueCreatorString); IssueTypeResponseModel issue = Mockito.mock(IssueTypeResponseModel.class); Mockito.when(issue.getName()).thenReturn(issueTypeString); List<IssueTypeResponseModel> issueResponses = new ArrayList<>(1); issueResponses.add(issue); Mockito.when(issueTypeService.getAllIssueTypes()).thenReturn(issueResponses); UserDetailsResponseModel user = Mockito.mock(UserDetailsResponseModel.class); Mockito.when(user.getName()).thenReturn(issueCreatorString); Mockito.when(userSearchService.findUserByUsername(Mockito.anyString())).thenReturn(Optional.of(user)); ProjectComponent projectComponent = Mockito.mock(ProjectComponent.class); Mockito.when(projectComponent.getName()).thenReturn(projectName); List<ProjectComponent> projectComponents = new ArrayList<>(1); projectComponents.add(projectComponent); Mockito.when(projectService.getProjectsByName(Mockito.anyString())).thenReturn(projectComponents); try { IssueTrackerContext context = new IssueTrackerContext(null, issueConfig); jiraIssueConfigValidator.createValidIssueConfig(context); Assertions.assertEquals(resolveTransitionString, issueConfig.getResolveTransition().orElse("")); Assertions.assertEquals(projectName, issueConfig.getProjectName()); Assertions.assertEquals(issueCreatorString, issueConfig.getIssueCreator()); Assertions.assertEquals(issueTypeString, issueConfig.getIssueType()); } catch (AlertFieldException e) { fail(); } } |
### Question:
DefaultSettingsKeyAccessor implements SettingsKeyAccessor { @Override public List<SettingsKeyModel> getSettingsKeys() { return settingsKeyRepository.findAll() .stream() .map(this::convertToSettingsKeyModel) .collect(Collectors.toList()); } DefaultSettingsKeyAccessor(SettingsKeyRepository settingsKeyRepository); @Override List<SettingsKeyModel> getSettingsKeys(); @Override Optional<SettingsKeyModel> getSettingsKeyByKey(String key); @Override SettingsKeyModel saveSettingsKey(String key, String value); @Override void deleteSettingsKeyByKey(String key); @Override void deleteSettingsKeyById(Long id); }### Answer:
@Test public void getSettingsKeysTest() { final String key = "key1"; final String key2 = "key2"; final String value1 = "value1"; final String value2 = "value2"; SettingsKeyEntity settingsKeyEntity1 = new SettingsKeyEntity(key, value1); SettingsKeyEntity settingsKeyEntity2 = new SettingsKeyEntity(key2, value2); settingsKeyEntity1.setId(1L); settingsKeyEntity2.setId(2L); SettingsKeyRepository settingsKeyRepository = new MockSettingsKeyRepository(); settingsKeyRepository.save(settingsKeyEntity1); settingsKeyRepository.save(settingsKeyEntity2); DefaultSettingsKeyAccessor settingsKeyAccessor = new DefaultSettingsKeyAccessor(settingsKeyRepository); List<SettingsKeyModel> settingsKeyModelList = settingsKeyAccessor.getSettingsKeys(); assertEquals(2, settingsKeyModelList.size()); SettingsKeyModel settingsKeyModel1 = settingsKeyModelList.get(0); SettingsKeyModel settingsKeyModel2 = settingsKeyModelList.get(1); assertEquals(key, settingsKeyModel1.getKey()); assertEquals(value1, settingsKeyModel1.getValue()); assertEquals(key2, settingsKeyModel2.getKey()); assertEquals(value2, settingsKeyModel2.getValue()); } |
### Question:
DefaultSettingsKeyAccessor implements SettingsKeyAccessor { @Override public Optional<SettingsKeyModel> getSettingsKeyByKey(String key) { return settingsKeyRepository.findByKey(key).map(this::convertToSettingsKeyModel); } DefaultSettingsKeyAccessor(SettingsKeyRepository settingsKeyRepository); @Override List<SettingsKeyModel> getSettingsKeys(); @Override Optional<SettingsKeyModel> getSettingsKeyByKey(String key); @Override SettingsKeyModel saveSettingsKey(String key, String value); @Override void deleteSettingsKeyByKey(String key); @Override void deleteSettingsKeyById(Long id); }### Answer:
@Test public void getSettingsByKeyTest() { final String key = "key1"; final String value1 = "value1"; SettingsKeyEntity settingsKeyEntity = new SettingsKeyEntity(key, value1); settingsKeyEntity.setId(1L); SettingsKeyRepository settingsKeyRepository = new MockSettingsKeyRepository(); settingsKeyRepository.save(settingsKeyEntity); DefaultSettingsKeyAccessor settingsKeyAccessor = new DefaultSettingsKeyAccessor(settingsKeyRepository); Optional<SettingsKeyModel> settingsKeyModelOptional = settingsKeyAccessor.getSettingsKeyByKey("key1"); Optional<SettingsKeyModel> settingsKeyModelOptionalNull = settingsKeyAccessor.getSettingsKeyByKey("-1"); assertTrue(settingsKeyModelOptional.isPresent()); assertFalse(settingsKeyModelOptionalNull.isPresent()); SettingsKeyModel settingsKeyModel = settingsKeyModelOptional.get(); assertEquals(key, settingsKeyModel.getKey()); assertEquals(value1, settingsKeyModel.getValue()); } |
### Question:
JiraCloudIssueConfigValidator extends JiraIssueConfigValidator { @Override public Collection<ProjectComponent> getProjectsByName(String jiraProjectName) throws IntegrationException { PageOfProjectsResponseModel projectsResponseModel = projectService.getProjectsByName(jiraProjectName); return projectsResponseModel.getProjects(); } JiraCloudIssueConfigValidator(ProjectService projectService, UserSearchService userSearchService, IssueTypeService issueTypeService, IssueMetaDataService issueMetaDataService); @Override String getProjectFieldKey(); @Override String getIssueTypeFieldKey(); @Override String getIssueCreatorFieldKey(); @Override String getAddCommentsFieldKey(); @Override String getResolveTransitionFieldKey(); @Override String getOpenTransitionFieldKey(); @Override Collection<ProjectComponent> getProjectsByName(String jiraProjectName); @Override boolean isUserValid(String issueCreator); }### Answer:
@Test public void validateSuccessTest() throws IntegrationException { ProjectService projectService = Mockito.mock(ProjectService.class); UserSearchService userSearchService = Mockito.mock(UserSearchService.class); IssueTypeService issueTypeService = Mockito.mock(IssueTypeService.class); IssueMetaDataService issueMetaDataService = Mockito.mock(IssueMetaDataService.class); Mockito.when(issueMetaDataService.doesProjectContainIssueType(Mockito.anyString(), Mockito.anyString())).thenReturn(Boolean.TRUE); JiraCloudIssueConfigValidator jiraIssueConfigValidator = new JiraCloudIssueConfigValidator(projectService, userSearchService, issueTypeService, issueMetaDataService); String resolveTransitionString = "Resolve"; String projectName = "ProjectName"; String issueTypeString = "IssueType"; String issueCreatorString = "IssueCreator"; IssueConfig issueConfig = new IssueConfig(); issueConfig.setCommentOnIssues(true); issueConfig.setResolveTransition(resolveTransitionString); issueConfig.setProjectName(projectName); issueConfig.setIssueType(issueTypeString); issueConfig.setIssueCreator(issueCreatorString); IssueTypeResponseModel issue = Mockito.mock(IssueTypeResponseModel.class); Mockito.when(issue.getName()).thenReturn(issueTypeString); List<IssueTypeResponseModel> issueResponses = new ArrayList<>(1); issueResponses.add(issue); Mockito.when(issueTypeService.getAllIssueTypes()).thenReturn(issueResponses); UserDetailsResponseModel user = Mockito.mock(UserDetailsResponseModel.class); Mockito.when(user.getEmailAddress()).thenReturn(issueCreatorString); List<UserDetailsResponseModel> userResponses = new ArrayList<>(1); userResponses.add(user); Mockito.when(userSearchService.findUser(Mockito.anyString())).thenReturn(userResponses); ProjectComponent projectComponent = Mockito.mock(ProjectComponent.class); Mockito.when(projectComponent.getName()).thenReturn(projectName); PageOfProjectsResponseModel projectResponse = Mockito.mock(PageOfProjectsResponseModel.class); List<ProjectComponent> projectComponents = new ArrayList<>(1); projectComponents.add(projectComponent); Mockito.when(projectResponse.getProjects()).thenReturn(projectComponents); Mockito.when(projectService.getProjectsByName(Mockito.anyString())).thenReturn(projectResponse); try { IssueTrackerContext context = new IssueTrackerContext(null, issueConfig); jiraIssueConfigValidator.createValidIssueConfig(context); Assertions.assertEquals(resolveTransitionString, issueConfig.getResolveTransition().orElse("")); Assertions.assertEquals(projectName, issueConfig.getProjectName()); Assertions.assertEquals(issueCreatorString, issueConfig.getIssueCreator()); Assertions.assertEquals(issueTypeString, issueConfig.getIssueType()); } catch (AlertFieldException e) { fail(); } } |
### Question:
JiraCloudProperties implements IssueTrackerServiceConfig { public JiraCloudServiceFactory createJiraServicesCloudFactory(Logger logger, Gson gson) throws IssueTrackerException { JiraCloudRestConfig jiraServerConfig = createJiraServerConfig(); Slf4jIntLogger intLogger = new Slf4jIntLogger(logger); JiraHttpClient jiraHttpClient = jiraServerConfig.createJiraHttpClient(intLogger); return new JiraCloudServiceFactory(intLogger, jiraHttpClient, gson); } JiraCloudProperties(String url, String accessToken, String username, boolean pluginCheckDisabled); JiraCloudRestConfig createJiraServerConfig(); JiraCloudServiceFactory createJiraServicesCloudFactory(Logger logger, Gson gson); String getUrl(); String getAccessToken(); String getUsername(); boolean isPluginCheckDisabled(); }### Answer:
@Test public void testServerServiceFactory() { try { JiraCloudProperties properties = new JiraCloudProperties("http: JiraCloudServiceFactory serviceFactory = properties.createJiraServicesCloudFactory(LoggerFactory.getLogger(getClass()), new Gson()); assertNotNull(serviceFactory); } catch (IssueTrackerException ex) { ex.printStackTrace(); fail(); } } |
### Question:
ResponseBodyBuilder { public ResponseBodyBuilder() { map = new JsonObject(); } ResponseBodyBuilder(); ResponseBodyBuilder(String id, String message); ResponseBodyBuilder(String message); ResponseBodyBuilder put(String key, Boolean value); ResponseBodyBuilder put(String key, Number value); ResponseBodyBuilder put(String key, String value); ResponseBodyBuilder putErrors(List<AlertFieldStatus> errors); String build(); @Override String toString(); }### Answer:
@Test public void testResponseBodyBuilder() { ResponseBodyBuilder responseBodyBuilder = new ResponseBodyBuilder("55L", "Message"); responseBodyBuilder.put("Key1", "Value"); responseBodyBuilder.put("Key2", 22); responseBodyBuilder.put("Key3", false); assertEquals("{\"id\":\"55L\",\"message\":\"Message\",\"Key1\":\"Value\",\"Key2\":22,\"Key3\":false}", responseBodyBuilder.build()); } |
### Question:
FieldValueModel extends AlertSerializableModel { public Collection<String> getValues() { if (null != values) { return values; } return Set.of(); } private FieldValueModel(); FieldValueModel(Collection<String> values, boolean isSet); Collection<String> getValues(); void setValues(Collection<String> values); @JsonIgnore Optional<String> getValue(); @JsonIgnore void setValue(String value); boolean getIsSet(); void setIsSet(boolean isSet); boolean hasValues(); boolean containsNoData(); }### Answer:
@Test public void getValuesTest() { String duplicateTestValue = testValue; List<String> values = new ArrayList(); values.add(testValue); values.add(duplicateTestValue); FieldValueModel testFieldValueModel = new FieldValueModel(values, Boolean.TRUE); assertTrue(testFieldValueModel.getValues().containsAll(values)); assertEquals(1, testFieldValueModel.getValues().size(), "getValues is expected to return a Set of 1."); }
@Test public void getNullValuesTest() { FieldValueModel testFieldValueModel = createEmptyFieldValueModel(); assertTrue(testFieldValueModel.getValues().isEmpty()); } |
### Question:
FieldValueModel extends AlertSerializableModel { @JsonIgnore public Optional<String> getValue() { return getValues().stream().findFirst(); } private FieldValueModel(); FieldValueModel(Collection<String> values, boolean isSet); Collection<String> getValues(); void setValues(Collection<String> values); @JsonIgnore Optional<String> getValue(); @JsonIgnore void setValue(String value); boolean getIsSet(); void setIsSet(boolean isSet); boolean hasValues(); boolean containsNoData(); }### Answer:
@Test public void getValueTest() { List<String> values = new ArrayList(); values.add(testValue); FieldValueModel testFieldValueModel = new FieldValueModel(values, Boolean.TRUE); assertTrue(testFieldValueModel.getValue().isPresent()); assertEquals(testValue, testFieldValueModel.getValue().get()); } |
### Question:
FieldValueModel extends AlertSerializableModel { @JsonIgnore public void setValue(String value) { if (null == value) { setValues(Set.of()); } else { setValues(Set.of(value)); } } private FieldValueModel(); FieldValueModel(Collection<String> values, boolean isSet); Collection<String> getValues(); void setValues(Collection<String> values); @JsonIgnore Optional<String> getValue(); @JsonIgnore void setValue(String value); boolean getIsSet(); void setIsSet(boolean isSet); boolean hasValues(); boolean containsNoData(); }### Answer:
@Test public void setValueTest() { String overwrittenTestValue = "new-value-overwriting-testValue"; FieldValueModel testFieldValueModel = createEmptyFieldValueModel(); testFieldValueModel.setValue(testValue); testFieldValueModel.setValue(overwrittenTestValue); assertTrue(testFieldValueModel.getValues().contains(overwrittenTestValue)); assertEquals(1, testFieldValueModel.getValues().size(), "getValues is expected to return a Set of 1."); } |
### Question:
FieldValueModel extends AlertSerializableModel { public void setIsSet(boolean isSet) { this.isSet = isSet; } private FieldValueModel(); FieldValueModel(Collection<String> values, boolean isSet); Collection<String> getValues(); void setValues(Collection<String> values); @JsonIgnore Optional<String> getValue(); @JsonIgnore void setValue(String value); boolean getIsSet(); void setIsSet(boolean isSet); boolean hasValues(); boolean containsNoData(); }### Answer:
@Test public void setIsSetTest() { FieldValueModel testFieldValueModel = createEmptyFieldValueModel(); testFieldValueModel.setIsSet(Boolean.FALSE); assertFalse(testFieldValueModel.getIsSet()); } |
### Question:
FieldValueModel extends AlertSerializableModel { public boolean hasValues() { return !getValues().isEmpty(); } private FieldValueModel(); FieldValueModel(Collection<String> values, boolean isSet); Collection<String> getValues(); void setValues(Collection<String> values); @JsonIgnore Optional<String> getValue(); @JsonIgnore void setValue(String value); boolean getIsSet(); void setIsSet(boolean isSet); boolean hasValues(); boolean containsNoData(); }### Answer:
@Test public void hasValuesTest() { FieldValueModel testFieldValueModel = createEmptyFieldValueModel(); FieldValueModel testFieldValueModelNoValues = createEmptyFieldValueModel(); List<String> values = new ArrayList(); values.add(testValue); testFieldValueModel.setValues(values); assertTrue(testFieldValueModel.hasValues()); assertFalse(testFieldValueModelNoValues.hasValues()); } |
### Question:
DefaultSettingsKeyAccessor implements SettingsKeyAccessor { @Override public SettingsKeyModel saveSettingsKey(String key, String value) { Optional<SettingsKeyEntity> settingsKeyOptional = settingsKeyRepository.findByKey(key); if (settingsKeyOptional.isPresent()) { Long id = settingsKeyOptional.get().getId(); SettingsKeyEntity settingsKeyEntity = new SettingsKeyEntity(key, value); settingsKeyEntity.setId(id); SettingsKeyEntity updatedSettingsKeyEntity = settingsKeyRepository.save(settingsKeyEntity); return convertToSettingsKeyModel(updatedSettingsKeyEntity); } SettingsKeyEntity newSettingsKeyEntity = settingsKeyRepository.save(new SettingsKeyEntity(key, value)); return convertToSettingsKeyModel(newSettingsKeyEntity); } DefaultSettingsKeyAccessor(SettingsKeyRepository settingsKeyRepository); @Override List<SettingsKeyModel> getSettingsKeys(); @Override Optional<SettingsKeyModel> getSettingsKeyByKey(String key); @Override SettingsKeyModel saveSettingsKey(String key, String value); @Override void deleteSettingsKeyByKey(String key); @Override void deleteSettingsKeyById(Long id); }### Answer:
@Test public void saveSettingsKeyTest() { final String key = "key1"; final String key2 = "key2"; final String originalValue = "originalValue"; final String newValue = "newValue"; final String newValue2 = "newValue-2"; SettingsKeyEntity settingsKeyEntity = new SettingsKeyEntity(key, originalValue); settingsKeyEntity.setId(1L); SettingsKeyRepository settingsKeyRepository = new MockSettingsKeyRepository(); settingsKeyRepository.save(settingsKeyEntity); DefaultSettingsKeyAccessor settingsKeyAccessor = new DefaultSettingsKeyAccessor(settingsKeyRepository); SettingsKeyModel settingsKeyModel = settingsKeyAccessor.saveSettingsKey(key, newValue); SettingsKeyModel settingsKeyModelKeyNotPresent = settingsKeyAccessor.saveSettingsKey(key2, newValue2); assertEquals(key, settingsKeyModel.getKey()); assertEquals(newValue, settingsKeyModel.getValue()); assertEquals(key2, settingsKeyModelKeyNotPresent.getKey()); assertEquals(newValue2, settingsKeyModelKeyNotPresent.getValue()); } |
### Question:
FieldValueModel extends AlertSerializableModel { public boolean containsNoData() { return !hasValues() && !getIsSet(); } private FieldValueModel(); FieldValueModel(Collection<String> values, boolean isSet); Collection<String> getValues(); void setValues(Collection<String> values); @JsonIgnore Optional<String> getValue(); @JsonIgnore void setValue(String value); boolean getIsSet(); void setIsSet(boolean isSet); boolean hasValues(); boolean containsNoData(); }### Answer:
@Test public void containsNoDataTest() { FieldValueModel testFieldValueModelNoValueIsNotSet = createEmptyFieldValueModel(); testFieldValueModelNoValueIsNotSet.setIsSet((Boolean.FALSE)); FieldValueModel testFieldValueModelNoValue = createEmptyFieldValueModel(); FieldValueModel testFieldValueModelIsNotSet = createEmptyFieldValueModel(); testFieldValueModelIsNotSet.setValue(testValue); testFieldValueModelIsNotSet.setIsSet(Boolean.FALSE); FieldValueModel testFieldValueModel = createEmptyFieldValueModel(); testFieldValueModel.setValue(testValue); assertTrue(testFieldValueModelNoValueIsNotSet.containsNoData()); assertFalse(testFieldValueModelNoValue.containsNoData()); assertFalse(testFieldValueModelIsNotSet.containsNoData()); assertFalse(testFieldValueModel.containsNoData()); } |
### Question:
Configuration extends AlertSerializableModel { public FieldUtility getFieldUtility() { return fieldUtility; } Configuration(@NotNull Map<String, ConfigurationFieldModel> keyToFieldMap); FieldUtility getFieldUtility(); }### Answer:
@Test public void getFieldAccessorTest() { String fieldKey = "Key1"; ConfigurationFieldModel testConfigurationFieldModel = Mockito.mock(ConfigurationFieldModel.class); Map<String, ConfigurationFieldModel> keyToFieldMapTest = new HashMap<>(); keyToFieldMapTest.put(fieldKey, testConfigurationFieldModel); Configuration testConfig = new Configuration(keyToFieldMapTest); FieldUtility testFieldUtility = testConfig.getFieldUtility(); Optional<ConfigurationFieldModel> newConfigurationFieldModel = testFieldUtility.getField(fieldKey); assertTrue(newConfigurationFieldModel.isPresent()); assertEquals(testConfigurationFieldModel, newConfigurationFieldModel.get()); } |
### Question:
JobAuditModel extends Config { public String getConfigId() { return configId; } JobAuditModel(); JobAuditModel(final String id, final String configId, final String name, final String eventType, final AuditJobStatusModel auditJobStatusModel, final String errorMessage, final String errorStackTrace); String getConfigId(); String getName(); String getEventType(); AuditJobStatusModel getAuditJobStatusModel(); String getErrorMessage(); String getErrorStackTrace(); }### Answer:
@Test public void getConfigIdTest() { assertEquals(testConfigId, testJobAuditModel.getConfigId()); } |
### Question:
JobAuditModel extends Config { public String getName() { return name; } JobAuditModel(); JobAuditModel(final String id, final String configId, final String name, final String eventType, final AuditJobStatusModel auditJobStatusModel, final String errorMessage, final String errorStackTrace); String getConfigId(); String getName(); String getEventType(); AuditJobStatusModel getAuditJobStatusModel(); String getErrorMessage(); String getErrorStackTrace(); }### Answer:
@Test public void getNameTest() { assertEquals(testName, testJobAuditModel.getName()); } |
### Question:
JobAuditModel extends Config { public String getEventType() { return eventType; } JobAuditModel(); JobAuditModel(final String id, final String configId, final String name, final String eventType, final AuditJobStatusModel auditJobStatusModel, final String errorMessage, final String errorStackTrace); String getConfigId(); String getName(); String getEventType(); AuditJobStatusModel getAuditJobStatusModel(); String getErrorMessage(); String getErrorStackTrace(); }### Answer:
@Test public void getEventTypeTest() { assertEquals(testEventType, testJobAuditModel.getEventType()); } |
### Question:
JobAuditModel extends Config { public AuditJobStatusModel getAuditJobStatusModel() { return auditJobStatusModel; } JobAuditModel(); JobAuditModel(final String id, final String configId, final String name, final String eventType, final AuditJobStatusModel auditJobStatusModel, final String errorMessage, final String errorStackTrace); String getConfigId(); String getName(); String getEventType(); AuditJobStatusModel getAuditJobStatusModel(); String getErrorMessage(); String getErrorStackTrace(); }### Answer:
@Test public void getAuditJobStatusModelTest() { assertEquals(testAuditJobStatusModel, testJobAuditModel.getAuditJobStatusModel()); } |
### Question:
JobAuditModel extends Config { public String getErrorMessage() { return errorMessage; } JobAuditModel(); JobAuditModel(final String id, final String configId, final String name, final String eventType, final AuditJobStatusModel auditJobStatusModel, final String errorMessage, final String errorStackTrace); String getConfigId(); String getName(); String getEventType(); AuditJobStatusModel getAuditJobStatusModel(); String getErrorMessage(); String getErrorStackTrace(); }### Answer:
@Test public void getErrorMessageTest() { assertEquals(testErrorMessage, testJobAuditModel.getErrorMessage()); } |
### Question:
JobAuditModel extends Config { public String getErrorStackTrace() { return errorStackTrace; } JobAuditModel(); JobAuditModel(final String id, final String configId, final String name, final String eventType, final AuditJobStatusModel auditJobStatusModel, final String errorMessage, final String errorStackTrace); String getConfigId(); String getName(); String getEventType(); AuditJobStatusModel getAuditJobStatusModel(); String getErrorMessage(); String getErrorStackTrace(); }### Answer:
@Test public void getErrorStackTraceTest() { assertEquals(testErrorStackTrace, testJobAuditModel.getErrorStackTrace()); } |
### Question:
AlertPagedModel extends AlertSerializableModel { public int getTotalPages() { return totalPages; } AlertPagedModel(int totalPages, int currentPage, int pageSize, List<M> content); int getTotalPages(); int getCurrentPage(); int getPageSize(); List<M> getContent(); }### Answer:
@Test public void getTotalPagesTest() { assertEquals(testTotalPages, testAlertPagedModel.getTotalPages()); } |
### Question:
AlertPagedModel extends AlertSerializableModel { public int getCurrentPage() { return currentPage; } AlertPagedModel(int totalPages, int currentPage, int pageSize, List<M> content); int getTotalPages(); int getCurrentPage(); int getPageSize(); List<M> getContent(); }### Answer:
@Test public void getCurrentPageTest() { assertEquals(testCurrentPage, testAlertPagedModel.getCurrentPage()); } |
### Question:
DefaultSettingsKeyAccessor implements SettingsKeyAccessor { @Override public void deleteSettingsKeyByKey(String key) { getSettingsKeyByKey(key).ifPresent(settingsKeyModel -> deleteSettingsKeyById(settingsKeyModel.getId())); } DefaultSettingsKeyAccessor(SettingsKeyRepository settingsKeyRepository); @Override List<SettingsKeyModel> getSettingsKeys(); @Override Optional<SettingsKeyModel> getSettingsKeyByKey(String key); @Override SettingsKeyModel saveSettingsKey(String key, String value); @Override void deleteSettingsKeyByKey(String key); @Override void deleteSettingsKeyById(Long id); }### Answer:
@Test public void deleteSettingsKeyByKeyTest() { final String key = "key1"; final String originalValue = "originalValue"; SettingsKeyEntity settingsKeyEntity = new SettingsKeyEntity(key, originalValue); settingsKeyEntity.setId(1L); SettingsKeyRepository settingsKeyRepository = new MockSettingsKeyRepository(); settingsKeyRepository.save(settingsKeyEntity); DefaultSettingsKeyAccessor settingsKeyAccessor = new DefaultSettingsKeyAccessor(settingsKeyRepository); assertTrue(settingsKeyRepository.findByKey(key).isPresent()); settingsKeyAccessor.deleteSettingsKeyByKey(key); assertFalse(settingsKeyRepository.findByKey(key).isPresent()); } |
### Question:
AlertPagedModel extends AlertSerializableModel { public int getPageSize() { return pageSize; } AlertPagedModel(int totalPages, int currentPage, int pageSize, List<M> content); int getTotalPages(); int getCurrentPage(); int getPageSize(); List<M> getContent(); }### Answer:
@Test public void getPageSizeTest() { assertEquals(testPageSize, testAlertPagedModel.getPageSize()); } |
### Question:
AlertPagedModel extends AlertSerializableModel { public List<M> getContent() { return content; } AlertPagedModel(int totalPages, int currentPage, int pageSize, List<M> content); int getTotalPages(); int getCurrentPage(); int getPageSize(); List<M> getContent(); }### Answer:
@Test public void getContentTest() { assertEquals(testContent, testAlertPagedModel.getContent()); } |
### Question:
FieldModel extends Config { private FieldModel() { this(null, null, null, null, null); } private FieldModel(); FieldModel(String descriptorName, String context, Map<String, FieldValueModel> keyToValues); FieldModel(String configId, String descriptorName, String context, Map<String, FieldValueModel> keyToValues); FieldModel(String descriptorName, String context, String createdAt, String lastUpdated, Map<String, FieldValueModel> keyToValues); FieldModel(String configId, String descriptorName, String context, String createdAt, String lastUpdated, Map<String, FieldValueModel> keyToValues); String getDescriptorName(); String getContext(); String getCreatedAt(); String getLastUpdated(); Map<String, FieldValueModel> getKeyToValues(); void setKeyToValues(final Map<String, FieldValueModel> keyToValues); Optional<FieldValueModel> getFieldValueModel(final String key); Optional<String> getFieldValue(final String key); void putField(final String key, final FieldValueModel field); void removeField(final String key); FieldModel fill(final FieldModel fieldModel); }### Answer:
@Test public void fieldModelTest() { String descriptor = "description1"; String context = "context1"; String key = "Key1"; String configId = "Id1"; String createdAt = "2020-01-22-14-11-20-124"; String lastUpdated = "2020-01-1"; FieldValueModel testFieldValueModel = Mockito.mock(FieldValueModel.class); Map<String, FieldValueModel> keyToValues = new HashMap<>(); keyToValues.put(key, testFieldValueModel); FieldModel testFieldModel = new FieldModel(configId, descriptor, context, createdAt, lastUpdated, keyToValues); assertEquals(descriptor, testFieldModel.getDescriptorName()); assertEquals(context, testFieldModel.getContext()); assertTrue(testFieldModel.getKeyToValues().containsKey(key)); assertEquals(configId, testFieldModel.getId()); assertEquals(createdAt, testFieldModel.getCreatedAt()); assertEquals(lastUpdated, testFieldModel.getLastUpdated()); } |
### Question:
FieldModel extends Config { public void setKeyToValues(final Map<String, FieldValueModel> keyToValues) { this.keyToValues = keyToValues; } private FieldModel(); FieldModel(String descriptorName, String context, Map<String, FieldValueModel> keyToValues); FieldModel(String configId, String descriptorName, String context, Map<String, FieldValueModel> keyToValues); FieldModel(String descriptorName, String context, String createdAt, String lastUpdated, Map<String, FieldValueModel> keyToValues); FieldModel(String configId, String descriptorName, String context, String createdAt, String lastUpdated, Map<String, FieldValueModel> keyToValues); String getDescriptorName(); String getContext(); String getCreatedAt(); String getLastUpdated(); Map<String, FieldValueModel> getKeyToValues(); void setKeyToValues(final Map<String, FieldValueModel> keyToValues); Optional<FieldValueModel> getFieldValueModel(final String key); Optional<String> getFieldValue(final String key); void putField(final String key, final FieldValueModel field); void removeField(final String key); FieldModel fill(final FieldModel fieldModel); }### Answer:
@Test public void setKeyToValuesTest() { String descriptor = "description1"; String context = "context1"; String key1 = "original key"; String key2 = "key to be added into keyToValues"; FieldValueModel testFieldValueModel = Mockito.mock(FieldValueModel.class); Map<String, FieldValueModel> keyToValues = new HashMap<>(); keyToValues.put(key1, testFieldValueModel); FieldModel testFieldModel = new FieldModel(descriptor, context, keyToValues); assertTrue(testFieldModel.getKeyToValues().containsKey(key1)); assertFalse(testFieldModel.getKeyToValues().containsKey(key2)); keyToValues.put(key2, testFieldValueModel); testFieldModel.setKeyToValues(keyToValues); assertTrue(testFieldModel.getKeyToValues().containsKey(key1)); assertTrue(testFieldModel.getKeyToValues().containsKey(key2)); } |
### Question:
FieldModel extends Config { public Optional<FieldValueModel> getFieldValueModel(final String key) { return Optional.ofNullable(keyToValues.get(key)); } private FieldModel(); FieldModel(String descriptorName, String context, Map<String, FieldValueModel> keyToValues); FieldModel(String configId, String descriptorName, String context, Map<String, FieldValueModel> keyToValues); FieldModel(String descriptorName, String context, String createdAt, String lastUpdated, Map<String, FieldValueModel> keyToValues); FieldModel(String configId, String descriptorName, String context, String createdAt, String lastUpdated, Map<String, FieldValueModel> keyToValues); String getDescriptorName(); String getContext(); String getCreatedAt(); String getLastUpdated(); Map<String, FieldValueModel> getKeyToValues(); void setKeyToValues(final Map<String, FieldValueModel> keyToValues); Optional<FieldValueModel> getFieldValueModel(final String key); Optional<String> getFieldValue(final String key); void putField(final String key, final FieldValueModel field); void removeField(final String key); FieldModel fill(final FieldModel fieldModel); }### Answer:
@Test public void getFieldValueModelTest() { String descriptor = "description1"; String context = "context1"; String keyValid = "Key1"; String keyBad = "This key is not in the Field Model"; FieldValueModel testFieldValueModel = Mockito.mock(FieldValueModel.class); Map<String, FieldValueModel> keyToValues = new HashMap<>(); keyToValues.put(keyValid, testFieldValueModel); FieldModel testFieldModel = new FieldModel(descriptor, context, keyToValues); Optional<FieldValueModel> verifyFieldValueModel = testFieldModel.getFieldValueModel(keyValid); assertTrue(verifyFieldValueModel.isPresent()); assertEquals(testFieldValueModel, verifyFieldValueModel.get()); verifyFieldValueModel = testFieldModel.getFieldValueModel(keyBad); assertFalse(verifyFieldValueModel.isPresent()); } |
### Question:
FieldModel extends Config { public Optional<String> getFieldValue(final String key) { return getFieldValueModel(key).flatMap(FieldValueModel::getValue); } private FieldModel(); FieldModel(String descriptorName, String context, Map<String, FieldValueModel> keyToValues); FieldModel(String configId, String descriptorName, String context, Map<String, FieldValueModel> keyToValues); FieldModel(String descriptorName, String context, String createdAt, String lastUpdated, Map<String, FieldValueModel> keyToValues); FieldModel(String configId, String descriptorName, String context, String createdAt, String lastUpdated, Map<String, FieldValueModel> keyToValues); String getDescriptorName(); String getContext(); String getCreatedAt(); String getLastUpdated(); Map<String, FieldValueModel> getKeyToValues(); void setKeyToValues(final Map<String, FieldValueModel> keyToValues); Optional<FieldValueModel> getFieldValueModel(final String key); Optional<String> getFieldValue(final String key); void putField(final String key, final FieldValueModel field); void removeField(final String key); FieldModel fill(final FieldModel fieldModel); }### Answer:
@Test public void getFieldValueTest() { String descriptor = "description1"; String context = "context1"; String key = "Key1"; String badKey = "This key doesn't exist"; String testFieldValue = "FieldValue1"; List<String> values = new ArrayList(); values.add(testFieldValue); FieldValueModel newFieldValueModel = new FieldValueModel(values, Boolean.TRUE); Map<String, FieldValueModel> keyToValues = new HashMap<>(); keyToValues.put(key, newFieldValueModel); FieldModel testFieldModel = new FieldModel(descriptor, context, keyToValues); Optional<String> value = testFieldModel.getFieldValue(key); assertEquals(testFieldValue, value.get()); assertTrue(value.isPresent()); value = testFieldModel.getFieldValue(badKey); assertFalse(value.isPresent()); } |
### Question:
FieldModel extends Config { public void putField(final String key, final FieldValueModel field) { keyToValues.put(key, field); } private FieldModel(); FieldModel(String descriptorName, String context, Map<String, FieldValueModel> keyToValues); FieldModel(String configId, String descriptorName, String context, Map<String, FieldValueModel> keyToValues); FieldModel(String descriptorName, String context, String createdAt, String lastUpdated, Map<String, FieldValueModel> keyToValues); FieldModel(String configId, String descriptorName, String context, String createdAt, String lastUpdated, Map<String, FieldValueModel> keyToValues); String getDescriptorName(); String getContext(); String getCreatedAt(); String getLastUpdated(); Map<String, FieldValueModel> getKeyToValues(); void setKeyToValues(final Map<String, FieldValueModel> keyToValues); Optional<FieldValueModel> getFieldValueModel(final String key); Optional<String> getFieldValue(final String key); void putField(final String key, final FieldValueModel field); void removeField(final String key); FieldModel fill(final FieldModel fieldModel); }### Answer:
@Test public void putFieldTest() { String descriptor = "description1"; String context = "context1"; String key = "Key1"; String newKey = "Key2"; FieldValueModel testFieldValueModel = Mockito.mock(FieldValueModel.class); Map<String, FieldValueModel> keyToValues = new HashMap<>(); keyToValues.put(key, testFieldValueModel); FieldModel testFieldModel = new FieldModel(descriptor, context, keyToValues); assertTrue(testFieldModel.getKeyToValues().containsKey(key)); assertFalse(testFieldModel.getKeyToValues().containsKey(newKey)); testFieldModel.putField(newKey, testFieldValueModel); assertTrue(testFieldModel.getKeyToValues().containsKey(key)); assertTrue(testFieldModel.getKeyToValues().containsKey(newKey), "The newKey was not successfully added into the testFieldModel."); } |
### Question:
FieldModel extends Config { public void removeField(final String key) { keyToValues.remove(key); } private FieldModel(); FieldModel(String descriptorName, String context, Map<String, FieldValueModel> keyToValues); FieldModel(String configId, String descriptorName, String context, Map<String, FieldValueModel> keyToValues); FieldModel(String descriptorName, String context, String createdAt, String lastUpdated, Map<String, FieldValueModel> keyToValues); FieldModel(String configId, String descriptorName, String context, String createdAt, String lastUpdated, Map<String, FieldValueModel> keyToValues); String getDescriptorName(); String getContext(); String getCreatedAt(); String getLastUpdated(); Map<String, FieldValueModel> getKeyToValues(); void setKeyToValues(final Map<String, FieldValueModel> keyToValues); Optional<FieldValueModel> getFieldValueModel(final String key); Optional<String> getFieldValue(final String key); void putField(final String key, final FieldValueModel field); void removeField(final String key); FieldModel fill(final FieldModel fieldModel); }### Answer:
@Test public void removeFieldTest() { String descriptor = "description1"; String context = "context1"; String keyValid = "Key1"; String keyToDelete = "Key2"; FieldValueModel testFieldValueModel = Mockito.mock(FieldValueModel.class); Map<String, FieldValueModel> keyToValues = new HashMap<>(); keyToValues.put(keyValid, testFieldValueModel); keyToValues.put(keyToDelete, testFieldValueModel); FieldModel testFieldModel = new FieldModel(descriptor, context, keyToValues); Map<String, FieldValueModel> testKeyToValues = testFieldModel.getKeyToValues(); assertTrue(testKeyToValues.containsKey(keyValid)); assertTrue(testKeyToValues.containsKey(keyToDelete)); testFieldModel.removeField(keyToDelete); testKeyToValues = testFieldModel.getKeyToValues(); assertTrue(testKeyToValues.containsKey(keyValid)); assertFalse(testKeyToValues.containsKey(keyToDelete), "The keyToDelete was not successfully removed."); } |
### Question:
FieldModel extends Config { public FieldModel fill(final FieldModel fieldModel) { final Map<String, FieldValueModel> fieldValueModelMap = new HashMap<>(); fieldValueModelMap.putAll(getKeyToValues()); final Map<String, FieldValueModel> fieldsToAdd = fieldModel.getKeyToValues(); for (final Map.Entry<String, FieldValueModel> entry : fieldsToAdd.entrySet()) { final String key = entry.getKey(); if (!fieldValueModelMap.containsKey(key) || fieldValueModelMap.get(key).getValue().isEmpty()) { fieldValueModelMap.put(key, entry.getValue()); } } final String modelDescriptorName = StringUtils.isNotBlank(getDescriptorName()) ? getDescriptorName() : fieldModel.getDescriptorName(); final String modelContext = StringUtils.isNotBlank(getContext()) ? getContext() : fieldModel.getContext(); final String modelCreatedAt = StringUtils.isNotBlank(getCreatedAt()) ? getCreatedAt() : fieldModel.getCreatedAt(); final String modelLastUpdated = StringUtils.isNotBlank(getLastUpdated()) ? getLastUpdated() : fieldModel.getLastUpdated(); final FieldModel newFieldModel = new FieldModel(modelDescriptorName, modelContext, modelCreatedAt, modelLastUpdated, fieldValueModelMap); final String id = StringUtils.isNotBlank(getId()) ? getId() : fieldModel.getId(); newFieldModel.setId(id); return newFieldModel; } private FieldModel(); FieldModel(String descriptorName, String context, Map<String, FieldValueModel> keyToValues); FieldModel(String configId, String descriptorName, String context, Map<String, FieldValueModel> keyToValues); FieldModel(String descriptorName, String context, String createdAt, String lastUpdated, Map<String, FieldValueModel> keyToValues); FieldModel(String configId, String descriptorName, String context, String createdAt, String lastUpdated, Map<String, FieldValueModel> keyToValues); String getDescriptorName(); String getContext(); String getCreatedAt(); String getLastUpdated(); Map<String, FieldValueModel> getKeyToValues(); void setKeyToValues(final Map<String, FieldValueModel> keyToValues); Optional<FieldValueModel> getFieldValueModel(final String key); Optional<String> getFieldValue(final String key); void putField(final String key, final FieldValueModel field); void removeField(final String key); FieldModel fill(final FieldModel fieldModel); }### Answer:
@Test public void fillTest() { String descriptor = "description1"; String context = "context1"; String key = "Key1"; String configId = "Id1"; String createdAt = "2020-01-22-14-11-20-124"; String lastUpdated = "2020-01-1"; FieldValueModel testFieldValueModel = Mockito.mock(FieldValueModel.class); Map<String, FieldValueModel> keyToValues = new HashMap<>(); keyToValues.put(key, testFieldValueModel); FieldModel testFieldModel = new FieldModel(configId, descriptor, context, createdAt, lastUpdated, keyToValues); FieldModel newTestFieldModel = testFieldModel.fill(testFieldModel); assertEquals(testFieldModel, newTestFieldModel); assertFalse(testFieldModel == newTestFieldModel); assertEquals(descriptor, newTestFieldModel.getDescriptorName()); assertEquals(context, newTestFieldModel.getContext()); assertTrue(newTestFieldModel.getKeyToValues().containsKey(key)); assertEquals(configId, newTestFieldModel.getId()); assertEquals(createdAt, newTestFieldModel.getCreatedAt()); assertEquals(lastUpdated, newTestFieldModel.getLastUpdated()); } |
### Question:
JobFieldModel extends AlertSerializableModel { public JobFieldModel() { this(null, null); } JobFieldModel(); JobFieldModel(final String jobId, final Set<FieldModel> fieldModels); String getJobId(); void setJobId(final String jobId); Set<FieldModel> getFieldModels(); void setFieldModels(final Set<FieldModel> fieldModels); }### Answer:
@Test public void jobFieldModelTest() { JobFieldModel testJobFieldModel = new JobFieldModel(); assertNull(testJobFieldModel.getJobId()); assertNull(testJobFieldModel.getFieldModels()); } |
### Question:
DefaultConfigurationAccessor implements ConfigurationAccessor { @Override public List<ConfigurationJobModel> getAllJobs() { List<ConfigGroupEntity> jobEntities = configGroupRepository.findAll(); SetMap<UUID, ConfigGroupEntity> jobMap = SetMap.createDefault(); for (ConfigGroupEntity entity : jobEntities) { UUID entityJobId = entity.getJobId(); jobMap.add(entityJobId, entity); } return jobMap.entrySet() .stream() .map(entry -> createJobModelFromExistingConfigs(entry.getKey(), entry.getValue())) .collect(Collectors.toList()); } @Autowired DefaultConfigurationAccessor(RegisteredDescriptorRepository registeredDescriptorRepository, DescriptorTypeRepository descriptorTypeRepository, DefinedFieldRepository definedFieldRepository,
DescriptorConfigRepository descriptorConfigsRepository, ConfigGroupRepository configGroupRepository, ConfigContextRepository configContextRepository, FieldValueRepository fieldValueRepository,
EncryptionUtility encryptionUtility); @Override List<ConfigurationJobModel> getAllJobs(); @Override Optional<ConfigurationJobModel> getJobById(UUID jobId); @Override List<ConfigurationJobModel> getJobsByFrequency(FrequencyType frequency); @Override ConfigurationJobModel createJob(Collection<String> descriptorNames, Collection<ConfigurationFieldModel> configuredFields); @Override ConfigurationJobModel updateJob(UUID jobId, Collection<String> descriptorNames, Collection<ConfigurationFieldModel> configuredFields); @Override void deleteJob(UUID jobId); @Override Optional<ConfigurationModel> getProviderConfigurationByName(String providerConfigName); @Override Optional<ConfigurationModel> getConfigurationById(Long id); @Override List<ConfigurationModel> getConfigurationsByDescriptorKey(DescriptorKey descriptorKey); @Override List<ConfigurationModel> getConfigurationsByDescriptorType(DescriptorType descriptorType); @Override List<ConfigurationModel> getChannelConfigurationsByFrequency(FrequencyType frequencyType); @Override List<ConfigurationModel> getConfigurationsByDescriptorKeyAndContext(DescriptorKey descriptorKey, ConfigContextEnum context); @Override ConfigurationModel createConfiguration(DescriptorKey descriptorKey, ConfigContextEnum context, Collection<ConfigurationFieldModel> configuredFields); @Override List<ConfigurationModel> getConfigurationsByDescriptorNameAndContext(String descriptorName, ConfigContextEnum context); @Override ConfigurationModel updateConfiguration(Long descriptorConfigId, Collection<ConfigurationFieldModel> configuredFields); @Override void deleteConfiguration(ConfigurationModel configModel); @Override void deleteConfiguration(Long descriptorConfigId); static final String EXCEPTION_FORMAT_DESCRIPTOR_KEY_IS_NOT_VALID; }### Answer:
@Test public void getAllJobsTest() { UUID uuid = UUID.randomUUID(); ConfigGroupEntity configGroupEntity = new ConfigGroupEntity(1L, uuid); DescriptorConfigEntity descriptorConfigEntity = new DescriptorConfigEntity(2L, 2L, DateUtils.createCurrentDateTimestamp(), DateUtils.createCurrentDateTimestamp()); descriptorConfigEntity.setId(3L); ConfigContextEntity configContextEntity = new ConfigContextEntity(configContextEnum.name()); FieldValueEntity fieldValueEntity = new FieldValueEntity(3L, 4L, fieldValue); DefinedFieldEntity definedFieldEntity = new DefinedFieldEntity(fieldKey, false); definedFieldEntity.setId(4L); Mockito.when(configGroupRepository.findAll()).thenReturn(List.of(configGroupEntity)); setupGetJobMocks(descriptorConfigEntity, configContextEntity, fieldValueEntity, definedFieldEntity); DefaultConfigurationAccessor configurationAccessor = new DefaultConfigurationAccessor(null, null, definedFieldRepository, descriptorConfigRepository, configGroupRepository, configContextRepository, fieldValueRepository, encryptionUtility); List<ConfigurationJobModel> configurationJobModelList = configurationAccessor.getAllJobs(); assertEquals(1, configurationJobModelList.size()); ConfigurationJobModel configurationJobModel = configurationJobModelList.get(0); assertEquals(uuid, configurationJobModel.getJobId()); assertEquals(fieldValue, configurationJobModel.getName()); } |
### Question:
MessageContentGroupCsvCreator { public String createCsvString(MessageContentGroup messageContentGroup) { LinkableItem commonProvider = messageContentGroup.getCommonProvider(); LinkableItem commonTopic = messageContentGroup.getCommonTopic(); List<ProviderMessageContent> contents = messageContentGroup.getSubContent(); StringBuilder csvBuilder = new StringBuilder(); List<String> columnNames = createColumnNames(commonTopic, contents); appendLine(csvBuilder, columnNames); List<List<String>> rowValues = createRowValues(commonProvider, commonTopic, contents); for (List<String> row : rowValues) { appendLine(csvBuilder, row); } return csvBuilder.toString(); } String createCsvString(MessageContentGroup messageContentGroup); }### Answer:
@Test public void createCsvStringTest() throws AlertException { MessageContentGroup messageContentGroup = new MessageContentGroup(); ProviderMessageContent.Builder providerMessageBuilder = new ProviderMessageContent.Builder(); providerMessageBuilder.applyProvider("Example Provider", 1L, "Example Config"); providerMessageBuilder.applyTopic("Example Topic Name", "Example Topic Value"); ComponentItem.Builder componentItemBuilder = new ComponentItem.Builder(); componentItemBuilder.applyNotificationId(1L); componentItemBuilder.applyOperation(ItemOperation.INFO); componentItemBuilder.applyCategory("Example Category"); componentItemBuilder.applyComponentData("Example Component Name", "Example Component Value", "https: componentItemBuilder.applySubComponent("Example SubComponent Name", "Example SubComponent Value", "https: componentItemBuilder.applyCategoryItem("Example Category Item Name", "Example Category Item Value"); componentItemBuilder.applyCategoryGroupingAttribute("Example Category Grouping Attribute Name", "Example Category Grouping Attribute Value"); providerMessageBuilder.applyComponentItem(componentItemBuilder.build()); messageContentGroup.add(providerMessageBuilder.build()); MessageContentGroupCsvCreator messageContentGroupCsvCreator = new MessageContentGroupCsvCreator(); String csvString = messageContentGroupCsvCreator.createCsvString(messageContentGroup); assertNotNull(csvString); } |
### Question:
DateUtils { public static OffsetDateTime createCurrentDateTimestamp() { return OffsetDateTime.now(ZoneOffset.UTC); } private DateUtils(); static OffsetDateTime createCurrentDateTimestamp(); static String createCurrentDateString(String format); static String formatDate(OffsetDateTime date, String format); static OffsetDateTime fromDateUTC(Date date); static OffsetDateTime parseDate(String dateTime, String format); static final String DOCKER_DATE_FORMAT; static final String AUDIT_DATE_FORMAT; static final String UTC_DATE_FORMAT_TO_MINUTE; }### Answer:
@Test public void createCurrentDateTimestampOffsetTest() { OffsetDateTime alertDateTime = DateUtils.createCurrentDateTimestamp(); assertEquals(ZoneOffset.UTC, alertDateTime.getOffset()); }
@Test public void createCurrentDateTimestampZonedDateTimeTest() { OffsetDateTime alertDateTime = DateUtils.createCurrentDateTimestamp(); ZonedDateTime localZonedDateTime = ZonedDateTime.now(); ZonedDateTime reZonedLocalTime = localZonedDateTime.withZoneSameInstant(alertDateTime.getOffset()); assertEquals(alertDateTime.getHour(), reZonedLocalTime.getHour()); assertEquals(alertDateTime.getMinute(), reZonedLocalTime.getMinute()); }
@Test public void checkCurrentTime() throws InterruptedException { OffsetDateTime firstTimeStamp = DateUtils.createCurrentDateTimestamp(); TimeUnit.SECONDS.sleep(1); OffsetDateTime currentDateTimestamp = DateUtils.createCurrentDateTimestamp(); assertTrue(currentDateTimestamp.isAfter(firstTimeStamp)); assertTrue(firstTimeStamp.isBefore(currentDateTimestamp)); } |
### Question:
DataStructureUtils { public static <K, V> Map<K, V> mapToValues(Collection<V> valueCollection, Function<V, K> keyExtractor) { return mapToMap(valueCollection, keyExtractor, Function.identity()); } private DataStructureUtils(); static Map<K, V> mapToValues(Collection<V> valueCollection, Function<V, K> keyExtractor); static Map<K, V> mapToKeys(Collection<K> valueCollection, Function<K, V> valueExtractor); static Map<K, V> mapToMap(Collection<C> valueCollection, Function<C, K> keyExtractor, Function<C, V> valueExtractor); }### Answer:
@Test public void convertListWithNameKey() { String key1 = "key1"; String key2 = "key2"; TestObject testObject1 = new TestObject(key1, "something"); TestObject testObject2 = new TestObject(key2, "something"); Map<String, TestObject> mapWithNameKey = DataStructureUtils.mapToValues(List.of(testObject1, testObject2), TestObject::getName); assertTrue(mapWithNameKey.containsKey(key1)); assertTrue(mapWithNameKey.containsKey(key2)); assertEquals(testObject1, mapWithNameKey.get(key1)); assertFalse(mapWithNameKey.containsKey(testObject1)); assertFalse(mapWithNameKey.containsKey(testObject1.getDesc())); } |
### Question:
DataStructureUtils { public static <K, V> Map<K, V> mapToKeys(Collection<K> valueCollection, Function<K, V> valueExtractor) { return mapToMap(valueCollection, Function.identity(), valueExtractor); } private DataStructureUtils(); static Map<K, V> mapToValues(Collection<V> valueCollection, Function<V, K> keyExtractor); static Map<K, V> mapToKeys(Collection<K> valueCollection, Function<K, V> valueExtractor); static Map<K, V> mapToMap(Collection<C> valueCollection, Function<C, K> keyExtractor, Function<C, V> valueExtractor); }### Answer:
@Test public void convertListWithObjectKey() { String key1 = "key1"; String key2 = "key2"; TestObject testObject1 = new TestObject(key1, "something"); TestObject testObject2 = new TestObject(key2, "something"); Map<TestObject, String> mapWithObjectKey = DataStructureUtils.mapToKeys(List.of(testObject1, testObject2), TestObject::getName); assertTrue(mapWithObjectKey.containsKey(testObject1)); assertTrue(mapWithObjectKey.containsKey(testObject2)); assertEquals(key1, mapWithObjectKey.get(testObject1)); assertFalse(mapWithObjectKey.containsKey(key1)); } |
### Question:
DataStructureUtils { public static <K, V, C> Map<K, V> mapToMap(Collection<C> valueCollection, Function<C, K> keyExtractor, Function<C, V> valueExtractor) { return valueCollection.stream().collect(Collectors.toMap(keyExtractor::apply, valueExtractor::apply)); } private DataStructureUtils(); static Map<K, V> mapToValues(Collection<V> valueCollection, Function<V, K> keyExtractor); static Map<K, V> mapToKeys(Collection<K> valueCollection, Function<K, V> valueExtractor); static Map<K, V> mapToMap(Collection<C> valueCollection, Function<C, K> keyExtractor, Function<C, V> valueExtractor); }### Answer:
@Test public void convertListWithNameAndObject() { String key1 = "key1"; String key2 = "key2"; TestObject testObject1 = new TestObject(key1, "something"); TestObject testObject2 = new TestObject(key2, "something"); Map<String, String> mapWithNameAndObjectKey = DataStructureUtils.mapToMap(List.of(testObject1, testObject2), TestObject::getName, TestObject::getDesc); assertEquals(2, mapWithNameAndObjectKey.size()); assertTrue(mapWithNameAndObjectKey.containsKey(key1)); assertTrue(mapWithNameAndObjectKey.containsKey(key2)); assertEquals(testObject1.getDesc(), mapWithNameAndObjectKey.get(key1)); assertEquals(testObject2.getDesc(), mapWithNameAndObjectKey.get(key2)); } |
### Question:
MessageContentKey extends AlertSerializableModel { public static MessageContentKey from(final String topicName, final String topicValue) { final String partialKey = String.format("%s%s%s", topicName, SEPARATOR, topicValue); return new MessageContentKey(partialKey); } private MessageContentKey(final String key); static MessageContentKey from(final String topicName, final String topicValue); static MessageContentKey from(final String topicName, final String topicValue, final String subTopicName, final String subTopicValue); static MessageContentKey from(final String topicName, final String topicValue, final Set<LinkableItem> subTopics); String getKey(); }### Answer:
@Test public void equalsTest() { final String topicName = "Topic"; final String topicValue = "My Topic"; final String subTopicName = "Sub Topic"; final String subTopicValue = "A Sub Topic"; final MessageContentKey contentKey1 = MessageContentKey.from(topicName, topicValue); final MessageContentKey contentKey2 = MessageContentKey.from(topicName, topicValue); final MessageContentKey contentKey3 = MessageContentKey.from(topicName, topicValue, subTopicName, subTopicValue); final MessageContentKey contentKey4 = MessageContentKey.from(topicName, topicValue, subTopicName, subTopicValue); assertEquals(contentKey1, contentKey2); assertNotEquals(contentKey1, contentKey3); assertEquals(contentKey3, contentKey4); } |
### Question:
DefaultConfigurationAccessor implements ConfigurationAccessor { @Override public Optional<ConfigurationJobModel> getJobById(UUID jobId) throws AlertDatabaseConstraintException { if (jobId == null) { throw new AlertDatabaseConstraintException(NULL_JOB_ID); } List<ConfigGroupEntity> jobConfigEntities = configGroupRepository.findByJobId(jobId); return jobConfigEntities .stream() .findAny() .map(configGroupEntity -> createJobModelFromExistingConfigs(configGroupEntity.getJobId(), jobConfigEntities)); } @Autowired DefaultConfigurationAccessor(RegisteredDescriptorRepository registeredDescriptorRepository, DescriptorTypeRepository descriptorTypeRepository, DefinedFieldRepository definedFieldRepository,
DescriptorConfigRepository descriptorConfigsRepository, ConfigGroupRepository configGroupRepository, ConfigContextRepository configContextRepository, FieldValueRepository fieldValueRepository,
EncryptionUtility encryptionUtility); @Override List<ConfigurationJobModel> getAllJobs(); @Override Optional<ConfigurationJobModel> getJobById(UUID jobId); @Override List<ConfigurationJobModel> getJobsByFrequency(FrequencyType frequency); @Override ConfigurationJobModel createJob(Collection<String> descriptorNames, Collection<ConfigurationFieldModel> configuredFields); @Override ConfigurationJobModel updateJob(UUID jobId, Collection<String> descriptorNames, Collection<ConfigurationFieldModel> configuredFields); @Override void deleteJob(UUID jobId); @Override Optional<ConfigurationModel> getProviderConfigurationByName(String providerConfigName); @Override Optional<ConfigurationModel> getConfigurationById(Long id); @Override List<ConfigurationModel> getConfigurationsByDescriptorKey(DescriptorKey descriptorKey); @Override List<ConfigurationModel> getConfigurationsByDescriptorType(DescriptorType descriptorType); @Override List<ConfigurationModel> getChannelConfigurationsByFrequency(FrequencyType frequencyType); @Override List<ConfigurationModel> getConfigurationsByDescriptorKeyAndContext(DescriptorKey descriptorKey, ConfigContextEnum context); @Override ConfigurationModel createConfiguration(DescriptorKey descriptorKey, ConfigContextEnum context, Collection<ConfigurationFieldModel> configuredFields); @Override List<ConfigurationModel> getConfigurationsByDescriptorNameAndContext(String descriptorName, ConfigContextEnum context); @Override ConfigurationModel updateConfiguration(Long descriptorConfigId, Collection<ConfigurationFieldModel> configuredFields); @Override void deleteConfiguration(ConfigurationModel configModel); @Override void deleteConfiguration(Long descriptorConfigId); static final String EXCEPTION_FORMAT_DESCRIPTOR_KEY_IS_NOT_VALID; }### Answer:
@Test public void getJobByIdTest() throws Exception { UUID jobId = UUID.randomUUID(); ConfigGroupEntity configGroupEntity = new ConfigGroupEntity(1L, jobId); DescriptorConfigEntity descriptorConfigEntity = new DescriptorConfigEntity(2L, 2L, DateUtils.createCurrentDateTimestamp(), DateUtils.createCurrentDateTimestamp()); descriptorConfigEntity.setId(3L); ConfigContextEntity configContextEntity = new ConfigContextEntity(configContextEnum.name()); FieldValueEntity fieldValueEntity = new FieldValueEntity(3L, 4L, fieldValue); DefinedFieldEntity definedFieldEntity = new DefinedFieldEntity(fieldKey, false); definedFieldEntity.setId(4L); Mockito.when(configGroupRepository.findByJobId(Mockito.any())).thenReturn(List.of(configGroupEntity)); setupGetJobMocks(descriptorConfigEntity, configContextEntity, fieldValueEntity, definedFieldEntity); DefaultConfigurationAccessor configurationAccessor = new DefaultConfigurationAccessor(null, null, definedFieldRepository, descriptorConfigRepository, configGroupRepository, configContextRepository, fieldValueRepository, encryptionUtility); Optional<ConfigurationJobModel> configurationJobModelOptional = configurationAccessor.getJobById(jobId); assertTrue(configurationJobModelOptional.isPresent()); ConfigurationJobModel configurationJobModel = configurationJobModelOptional.get(); assertEquals(jobId, configurationJobModel.getJobId()); assertEquals(fieldValue, configurationJobModel.getName()); }
@Test public void getJobByIdNullTest() throws Exception { DefaultConfigurationAccessor configurationAccessor = new DefaultConfigurationAccessor(null, null, null, null, null, null, null, null); try { configurationAccessor.getJobById(null); fail("Null jobId did not throw expected AlertDatabaseConstraintException."); } catch (AlertDatabaseConstraintException e) { assertNotNull(e); } } |
### Question:
DefaultDescriptorGlobalConfigUtility { public DescriptorKey getKey() { return key; } DefaultDescriptorGlobalConfigUtility(DescriptorKey descriptorKey, ConfigurationAccessor configurationAccessor, ApiAction apiAction,
ConfigurationFieldModelConverter configurationFieldModelConverter); DescriptorKey getKey(); boolean doesConfigurationExist(); Optional<ConfigurationModel> getConfiguration(); Optional<FieldModel> getFieldModel(); FieldModel save(FieldModel fieldModel); FieldModel update(Long id, FieldModel fieldModel); }### Answer:
@Test public void testGetKey() { DescriptorKey descriptorKey = createDescriptorKey(); DefaultDescriptorGlobalConfigUtility configUtility = new DefaultDescriptorGlobalConfigUtility(descriptorKey, null, null, null); assertEquals(descriptorKey, configUtility.getKey()); } |
### Question:
DefaultDescriptorGlobalConfigUtility { public boolean doesConfigurationExist() { try { return !configurationAccessor.getConfigurationsByDescriptorKeyAndContext(key, context).isEmpty(); } catch (AlertException ex) { logger.debug("Error reading configuration from database.", ex); return false; } } DefaultDescriptorGlobalConfigUtility(DescriptorKey descriptorKey, ConfigurationAccessor configurationAccessor, ApiAction apiAction,
ConfigurationFieldModelConverter configurationFieldModelConverter); DescriptorKey getKey(); boolean doesConfigurationExist(); Optional<ConfigurationModel> getConfiguration(); Optional<FieldModel> getFieldModel(); FieldModel save(FieldModel fieldModel); FieldModel update(Long id, FieldModel fieldModel); }### Answer:
@Test public void testConfigurationExists() throws Exception { DescriptorKey descriptorKey = createDescriptorKey(); ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); DefaultDescriptorGlobalConfigUtility configUtility = new DefaultDescriptorGlobalConfigUtility(descriptorKey, configurationAccessor, null, null); assertFalse(configUtility.doesConfigurationExist()); ConfigurationModel configurationModel = Mockito.mock(ConfigurationModel.class); Mockito.when(configurationAccessor.getConfigurationsByDescriptorKeyAndContext(Mockito.any(DescriptorKey.class), Mockito.any(ConfigContextEnum.class))).thenReturn(List.of(configurationModel)); assertTrue(configUtility.doesConfigurationExist()); }
@Test public void testConfigurationExistsWithException() throws Exception { DescriptorKey descriptorKey = createDescriptorKey(); ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); Mockito.when(configurationAccessor.getConfigurationsByDescriptorKeyAndContext(Mockito.any(DescriptorKey.class), Mockito.any(ConfigContextEnum.class))).thenThrow(new AlertDatabaseConstraintException("Test exception")); DefaultDescriptorGlobalConfigUtility configUtility = new DefaultDescriptorGlobalConfigUtility(descriptorKey, configurationAccessor, null, null); assertFalse(configUtility.doesConfigurationExist()); } |
### Question:
DefaultDescriptorGlobalConfigUtility { public Optional<ConfigurationModel> getConfiguration() throws AlertException { return configurationAccessor.getConfigurationsByDescriptorKeyAndContext(key, context) .stream() .findFirst(); } DefaultDescriptorGlobalConfigUtility(DescriptorKey descriptorKey, ConfigurationAccessor configurationAccessor, ApiAction apiAction,
ConfigurationFieldModelConverter configurationFieldModelConverter); DescriptorKey getKey(); boolean doesConfigurationExist(); Optional<ConfigurationModel> getConfiguration(); Optional<FieldModel> getFieldModel(); FieldModel save(FieldModel fieldModel); FieldModel update(Long id, FieldModel fieldModel); }### Answer:
@Test public void testGetConfiguration() throws Exception { DescriptorKey descriptorKey = createDescriptorKey(); ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); DefaultDescriptorGlobalConfigUtility configUtility = new DefaultDescriptorGlobalConfigUtility(descriptorKey, configurationAccessor, null, null); assertFalse(configUtility.getConfiguration().isPresent()); ConfigurationModel configurationModel = Mockito.mock(ConfigurationModel.class); Mockito.when(configurationAccessor.getConfigurationsByDescriptorKeyAndContext(Mockito.any(DescriptorKey.class), Mockito.any(ConfigContextEnum.class))).thenReturn(List.of(configurationModel)); assertTrue(configUtility.getConfiguration().isPresent()); } |
### Question:
DefaultDescriptorGlobalConfigUtility { public Optional<FieldModel> getFieldModel() throws AlertException { Optional<ConfigurationModel> configurationModelOptional = getConfiguration(); if (configurationModelOptional.isPresent()) { ConfigurationModel configurationModel = configurationModelOptional.get(); FieldModel fieldModel = configurationFieldModelConverter.convertToFieldModel(configurationModel); return Optional.ofNullable(apiAction.afterGetAction(fieldModel)); } return Optional.empty(); } DefaultDescriptorGlobalConfigUtility(DescriptorKey descriptorKey, ConfigurationAccessor configurationAccessor, ApiAction apiAction,
ConfigurationFieldModelConverter configurationFieldModelConverter); DescriptorKey getKey(); boolean doesConfigurationExist(); Optional<ConfigurationModel> getConfiguration(); Optional<FieldModel> getFieldModel(); FieldModel save(FieldModel fieldModel); FieldModel update(Long id, FieldModel fieldModel); }### Answer:
@Test public void testGetFieldModelEmptyConfiguration() throws Exception { DescriptorKey descriptorKey = createDescriptorKey(); ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); ConfigurationFieldModelConverter converter = Mockito.mock(ConfigurationFieldModelConverter.class); DefaultDescriptorGlobalConfigUtility configUtility = new DefaultDescriptorGlobalConfigUtility(descriptorKey, configurationAccessor, null, converter); assertFalse(configUtility.getFieldModel().isPresent()); }
@Test public void testGetFieldModel() throws Exception { DescriptorKey descriptorKey = createDescriptorKey(); FieldModel fieldModel = new FieldModel(descriptorKey.getUniversalKey(), ConfigContextEnum.GLOBAL.name(), Map.of()); ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); ConfigurationFieldModelConverter converter = Mockito.mock(ConfigurationFieldModelConverter.class); ConfigurationModel configurationModel = Mockito.mock(ConfigurationModel.class); ApiAction apiAction = Mockito.mock(ApiAction.class); Mockito.when(configurationAccessor.getConfigurationsByDescriptorKeyAndContext(Mockito.any(DescriptorKey.class), Mockito.any(ConfigContextEnum.class))).thenReturn(List.of(configurationModel)); Mockito.when(converter.convertToFieldModel(Mockito.any())).thenReturn(fieldModel); Mockito.when(apiAction.afterGetAction(Mockito.eq(fieldModel))).thenReturn(fieldModel); DefaultDescriptorGlobalConfigUtility configUtility = new DefaultDescriptorGlobalConfigUtility(descriptorKey, configurationAccessor, apiAction, converter); FieldModel actualFieldModel = configUtility.getFieldModel().orElse(null); assertEquals(fieldModel, actualFieldModel); }
@Test public void testGetFieldModelActionNull() throws Exception { DescriptorKey descriptorKey = createDescriptorKey(); FieldModel fieldModel = new FieldModel(descriptorKey.getUniversalKey(), ConfigContextEnum.GLOBAL.name(), Map.of()); ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); ConfigurationFieldModelConverter converter = Mockito.mock(ConfigurationFieldModelConverter.class); ConfigurationModel configurationModel = Mockito.mock(ConfigurationModel.class); ApiAction apiAction = Mockito.mock(ApiAction.class); Mockito.when(configurationAccessor.getConfigurationsByDescriptorKeyAndContext(Mockito.any(DescriptorKey.class), Mockito.any(ConfigContextEnum.class))).thenReturn(List.of(configurationModel)); Mockito.when(converter.convertToFieldModel(Mockito.any())).thenReturn(fieldModel); Mockito.when(apiAction.afterGetAction(Mockito.eq(fieldModel))).thenReturn(null); DefaultDescriptorGlobalConfigUtility configUtility = new DefaultDescriptorGlobalConfigUtility(descriptorKey, configurationAccessor, apiAction, converter); Optional<FieldModel> actualFieldModel = configUtility.getFieldModel(); assertFalse(actualFieldModel.isPresent()); } |
### Question:
DefaultConfigurationAccessor implements ConfigurationAccessor { @Override public List<ConfigurationJobModel> getJobsByFrequency(FrequencyType frequency) { return getAllJobs() .stream() .filter(job -> frequency == job.getFrequencyType()) .collect(Collectors.toList()); } @Autowired DefaultConfigurationAccessor(RegisteredDescriptorRepository registeredDescriptorRepository, DescriptorTypeRepository descriptorTypeRepository, DefinedFieldRepository definedFieldRepository,
DescriptorConfigRepository descriptorConfigsRepository, ConfigGroupRepository configGroupRepository, ConfigContextRepository configContextRepository, FieldValueRepository fieldValueRepository,
EncryptionUtility encryptionUtility); @Override List<ConfigurationJobModel> getAllJobs(); @Override Optional<ConfigurationJobModel> getJobById(UUID jobId); @Override List<ConfigurationJobModel> getJobsByFrequency(FrequencyType frequency); @Override ConfigurationJobModel createJob(Collection<String> descriptorNames, Collection<ConfigurationFieldModel> configuredFields); @Override ConfigurationJobModel updateJob(UUID jobId, Collection<String> descriptorNames, Collection<ConfigurationFieldModel> configuredFields); @Override void deleteJob(UUID jobId); @Override Optional<ConfigurationModel> getProviderConfigurationByName(String providerConfigName); @Override Optional<ConfigurationModel> getConfigurationById(Long id); @Override List<ConfigurationModel> getConfigurationsByDescriptorKey(DescriptorKey descriptorKey); @Override List<ConfigurationModel> getConfigurationsByDescriptorType(DescriptorType descriptorType); @Override List<ConfigurationModel> getChannelConfigurationsByFrequency(FrequencyType frequencyType); @Override List<ConfigurationModel> getConfigurationsByDescriptorKeyAndContext(DescriptorKey descriptorKey, ConfigContextEnum context); @Override ConfigurationModel createConfiguration(DescriptorKey descriptorKey, ConfigContextEnum context, Collection<ConfigurationFieldModel> configuredFields); @Override List<ConfigurationModel> getConfigurationsByDescriptorNameAndContext(String descriptorName, ConfigContextEnum context); @Override ConfigurationModel updateConfiguration(Long descriptorConfigId, Collection<ConfigurationFieldModel> configuredFields); @Override void deleteConfiguration(ConfigurationModel configModel); @Override void deleteConfiguration(Long descriptorConfigId); static final String EXCEPTION_FORMAT_DESCRIPTOR_KEY_IS_NOT_VALID; }### Answer:
@Test public void getJobsByFrequency() { FrequencyType frequencyType = FrequencyType.DAILY; final Long jobId = 1L; UUID uuid = UUID.randomUUID(); String fieldValueFrequency = frequencyType.name(); final String fieldKeyFrequency = "channel.common.frequency"; ConfigGroupEntity configGroupEntity = new ConfigGroupEntity(jobId, uuid); DescriptorConfigEntity descriptorConfigEntity = new DescriptorConfigEntity(2L, 2L, DateUtils.createCurrentDateTimestamp(), DateUtils.createCurrentDateTimestamp()); descriptorConfigEntity.setId(3L); ConfigContextEntity configContextEntity = new ConfigContextEntity(configContextEnum.name()); FieldValueEntity fieldValueEntity = new FieldValueEntity(3L, 4L, fieldValueFrequency); DefinedFieldEntity definedFieldEntity = new DefinedFieldEntity(fieldKeyFrequency, false); definedFieldEntity.setId(4L); Mockito.when(configGroupRepository.findAll()).thenReturn(List.of(configGroupEntity)); setupGetJobMocks(descriptorConfigEntity, configContextEntity, fieldValueEntity, definedFieldEntity); DefaultConfigurationAccessor configurationAccessor = new DefaultConfigurationAccessor(null, null, definedFieldRepository, descriptorConfigRepository, configGroupRepository, configContextRepository, fieldValueRepository, encryptionUtility); List<ConfigurationJobModel> configurationJobModelList = configurationAccessor.getJobsByFrequency(frequencyType); assertEquals(1, configurationJobModelList.size()); ConfigurationJobModel configurationJobModel = configurationJobModelList.get(0); assertEquals(uuid, configurationJobModel.getJobId()); assertEquals(fieldValueFrequency, configurationJobModel.getFrequencyType().name()); } |
### Question:
DefaultDescriptorGlobalConfigUtility { public FieldModel save(FieldModel fieldModel) throws AlertException { FieldModel beforeAction = apiAction.beforeSaveAction(fieldModel); Collection<ConfigurationFieldModel> values = configurationFieldModelConverter.convertToConfigurationFieldModelMap(beforeAction).values(); ConfigurationModel configuration = configurationAccessor.createConfiguration(key, context, values); FieldModel convertedFieldModel = configurationFieldModelConverter.convertToFieldModel(configuration); return apiAction.afterSaveAction(convertedFieldModel); } DefaultDescriptorGlobalConfigUtility(DescriptorKey descriptorKey, ConfigurationAccessor configurationAccessor, ApiAction apiAction,
ConfigurationFieldModelConverter configurationFieldModelConverter); DescriptorKey getKey(); boolean doesConfigurationExist(); Optional<ConfigurationModel> getConfiguration(); Optional<FieldModel> getFieldModel(); FieldModel save(FieldModel fieldModel); FieldModel update(Long id, FieldModel fieldModel); }### Answer:
@Test public void testSave() throws Exception { DescriptorKey descriptorKey = createDescriptorKey(); FieldModel fieldModel = new FieldModel(descriptorKey.getUniversalKey(), ConfigContextEnum.GLOBAL.name(), Map.of()); Map<String, ConfigurationFieldModel> configurationFieldModelCollection = Map.of(); ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); ConfigurationFieldModelConverter converter = Mockito.mock(ConfigurationFieldModelConverter.class); ConfigurationModel configurationModel = Mockito.mock(ConfigurationModel.class); ApiAction apiAction = Mockito.mock(ApiAction.class); Mockito.when(configurationAccessor.createConfiguration(Mockito.eq(descriptorKey), Mockito.any(ConfigContextEnum.class), Mockito.anyCollection())).thenReturn(configurationModel); Mockito.when(converter.convertToConfigurationFieldModelMap(Mockito.eq(fieldModel))).thenReturn(configurationFieldModelCollection); Mockito.when(converter.convertToFieldModel(Mockito.any())).thenReturn(fieldModel); Mockito.when(apiAction.beforeSaveAction(Mockito.eq(fieldModel))).thenReturn(fieldModel); Mockito.when(apiAction.afterSaveAction(Mockito.eq(fieldModel))).thenReturn(fieldModel); DefaultDescriptorGlobalConfigUtility configUtility = new DefaultDescriptorGlobalConfigUtility(descriptorKey, configurationAccessor, apiAction, converter); FieldModel savedModel = configUtility.save(fieldModel); assertEquals(fieldModel, savedModel); Mockito.verify(configurationAccessor).createConfiguration(Mockito.eq(descriptorKey), Mockito.eq(ConfigContextEnum.GLOBAL), Mockito.anyCollection()); } |
### Question:
ValidationResult { public Collection<String> getErrors() { return errors; } private ValidationResult(); private ValidationResult(Collection<String> errors, Collection<String> warnings); static ValidationResult success(); static ValidationResult errors(Collection<String> errors); static ValidationResult errors(String... errors); static ValidationResult warnings(Collection<String> warnings); static ValidationResult warnings(String... warnings); static ValidationResult of(ValidationResult... validationResults); Collection<String> getErrors(); Collection<String> getWarnings(); boolean hasErrors(); boolean hasWarnings(); String combineErrorMessages(); String combineWarningMessages(); }### Answer:
@Test public void getErrorsTest() { ValidationResult errors = ValidationResult.errors(ERROR_MESSAGE_1); ArrayList<String> errorList = new ArrayList<>(errors.getErrors()); assertEquals(1, errorList.size()); assertEquals(ERROR_MESSAGE_1, errorList.get(0)); } |
### Question:
ValidationResult { public Collection<String> getWarnings() { return warnings; } private ValidationResult(); private ValidationResult(Collection<String> errors, Collection<String> warnings); static ValidationResult success(); static ValidationResult errors(Collection<String> errors); static ValidationResult errors(String... errors); static ValidationResult warnings(Collection<String> warnings); static ValidationResult warnings(String... warnings); static ValidationResult of(ValidationResult... validationResults); Collection<String> getErrors(); Collection<String> getWarnings(); boolean hasErrors(); boolean hasWarnings(); String combineErrorMessages(); String combineWarningMessages(); }### Answer:
@Test public void getWarningsTest() { ValidationResult warnings = ValidationResult.warnings(WARNING_MESSAGE_1); ArrayList<String> warningList = new ArrayList<>(warnings.getWarnings()); assertEquals(1, warningList.size()); assertEquals(WARNING_MESSAGE_1, warningList.get(0)); } |
### Question:
ValidationResult { public boolean hasErrors() { return !errors.isEmpty(); } private ValidationResult(); private ValidationResult(Collection<String> errors, Collection<String> warnings); static ValidationResult success(); static ValidationResult errors(Collection<String> errors); static ValidationResult errors(String... errors); static ValidationResult warnings(Collection<String> warnings); static ValidationResult warnings(String... warnings); static ValidationResult of(ValidationResult... validationResults); Collection<String> getErrors(); Collection<String> getWarnings(); boolean hasErrors(); boolean hasWarnings(); String combineErrorMessages(); String combineWarningMessages(); }### Answer:
@Test public void hasErrorsTest() { ValidationResult errors = ValidationResult.errors(ERROR_MESSAGE_1); ValidationResult emptyErrors = ValidationResult.success(); assertTrue(errors.hasErrors()); assertFalse(emptyErrors.hasErrors()); } |
### Question:
ValidationResult { public boolean hasWarnings() { return !warnings.isEmpty(); } private ValidationResult(); private ValidationResult(Collection<String> errors, Collection<String> warnings); static ValidationResult success(); static ValidationResult errors(Collection<String> errors); static ValidationResult errors(String... errors); static ValidationResult warnings(Collection<String> warnings); static ValidationResult warnings(String... warnings); static ValidationResult of(ValidationResult... validationResults); Collection<String> getErrors(); Collection<String> getWarnings(); boolean hasErrors(); boolean hasWarnings(); String combineErrorMessages(); String combineWarningMessages(); }### Answer:
@Test public void hasWarningsTest() { ValidationResult warnings = ValidationResult.warnings(WARNING_MESSAGE_1); ValidationResult emptyWarnings = ValidationResult.success(); assertTrue(warnings.hasWarnings()); assertFalse(emptyWarnings.hasErrors()); } |
### Question:
ValidationResult { public String combineErrorMessages() { return combineMessages(errors); } private ValidationResult(); private ValidationResult(Collection<String> errors, Collection<String> warnings); static ValidationResult success(); static ValidationResult errors(Collection<String> errors); static ValidationResult errors(String... errors); static ValidationResult warnings(Collection<String> warnings); static ValidationResult warnings(String... warnings); static ValidationResult of(ValidationResult... validationResults); Collection<String> getErrors(); Collection<String> getWarnings(); boolean hasErrors(); boolean hasWarnings(); String combineErrorMessages(); String combineWarningMessages(); }### Answer:
@Test public void combineErrorMessages() { List<String> listOfErrorStrings = List.of(ERROR_MESSAGE_1, ERROR_MESSAGE_2); ValidationResult errors = ValidationResult.errors(listOfErrorStrings); String expectedString = StringUtils.join(listOfErrorStrings, ", "); assertEquals(2, errors.getErrors().size()); assertEquals(expectedString, errors.combineErrorMessages()); } |
### Question:
ValidationResult { public String combineWarningMessages() { return combineMessages(warnings); } private ValidationResult(); private ValidationResult(Collection<String> errors, Collection<String> warnings); static ValidationResult success(); static ValidationResult errors(Collection<String> errors); static ValidationResult errors(String... errors); static ValidationResult warnings(Collection<String> warnings); static ValidationResult warnings(String... warnings); static ValidationResult of(ValidationResult... validationResults); Collection<String> getErrors(); Collection<String> getWarnings(); boolean hasErrors(); boolean hasWarnings(); String combineErrorMessages(); String combineWarningMessages(); }### Answer:
@Test public void combineWarningMessages() { List<String> listOfWarningsStrings = List.of(WARNING_MESSAGE_1, WARNING_MESSAGE_2); ValidationResult warnings = ValidationResult.warnings(listOfWarningsStrings); String expectedString = StringUtils.join(listOfWarningsStrings, ", "); assertEquals(2, warnings.getWarnings().size()); assertEquals(expectedString, warnings.combineWarningMessages()); } |
### Question:
ChannelEventManager extends EventManager { @Override @Transactional public void sendEvent(AlertEvent alertEvent) { if (alertEvent instanceof DistributionEvent) { String destination = alertEvent.getDestination(); DistributionEvent distributionEvent = (DistributionEvent) alertEvent; UUID jobId = UUID.fromString(distributionEvent.getConfigId()); Map<Long, Long> notificationIdToAuditId = auditAccessor.createAuditEntry(distributionEvent.getNotificationIdToAuditId(), jobId, distributionEvent.getContent()); distributionEvent.setNotificationIdToAuditId(notificationIdToAuditId); String jsonMessage = getContentConverter().getJsonString(distributionEvent); getJmsTemplate().convertAndSend(destination, jsonMessage); } } @Autowired ChannelEventManager(ContentConverter contentConverter, JmsTemplate jmsTemplate, AuditAccessor auditAccessor); @Override @Transactional void sendEvent(AlertEvent alertEvent); }### Answer:
@Test public void testNotAbstractChannelEvent() throws Exception { AuditAccessor auditAccessor = Mockito.mock(AuditAccessor.class); JmsTemplate jmsTemplate = Mockito.mock(JmsTemplate.class); ContentConverter contentConverter = Mockito.mock(ContentConverter.class); Mockito.doNothing().when(jmsTemplate).convertAndSend(Mockito.anyString(), Mockito.any(Object.class)); ChannelEventManager eventManager = new ChannelEventManager(contentConverter, jmsTemplate, auditAccessor); LinkableItem subTopic = new LinkableItem("subTopic", "sub topic", null); ProviderMessageContent content = new ProviderMessageContent.Builder() .applyProvider("testProvider", 1L, "testProviderConfig") .applyTopic("testTopic", "topic") .applySubTopic(subTopic.getName(), subTopic.getValue()) .build(); AlertEvent dbStoreEvent = new ContentEvent("", RestConstants.formatDate(new Date()), 1L, "FORMAT", MessageContentGroup.singleton(content)); eventManager.sendEvent(dbStoreEvent); } |
### Question:
ConfigurationModel extends AlertSerializableModel { public Long getDescriptorId() { return descriptorId; } ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, String context); ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context); ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context, Map<String, ConfigurationFieldModel> configuredFields); Long getDescriptorId(); Long getConfigurationId(); String getCreatedAt(); String getLastUpdated(); ConfigContextEnum getDescriptorContext(); Optional<ConfigurationFieldModel> getField(String fieldKey); List<ConfigurationFieldModel> getCopyOfFieldList(); Map<String, ConfigurationFieldModel> getCopyOfKeyToFieldMap(); ConfigurationModelMutable createMutableCopy(); }### Answer:
@Test public void getDescriptorIdTest() { ConfigurationModel configurationModel = createConfigurationModel(); assertEquals(descriptorId, configurationModel.getDescriptorId()); } |
### Question:
ConfigurationModel extends AlertSerializableModel { public Long getConfigurationId() { return configurationId; } ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, String context); ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context); ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context, Map<String, ConfigurationFieldModel> configuredFields); Long getDescriptorId(); Long getConfigurationId(); String getCreatedAt(); String getLastUpdated(); ConfigContextEnum getDescriptorContext(); Optional<ConfigurationFieldModel> getField(String fieldKey); List<ConfigurationFieldModel> getCopyOfFieldList(); Map<String, ConfigurationFieldModel> getCopyOfKeyToFieldMap(); ConfigurationModelMutable createMutableCopy(); }### Answer:
@Test public void getConfigurationIdTest() { ConfigurationModel configurationModel = createConfigurationModel(); assertEquals(configurationId, configurationModel.getConfigurationId()); } |
### Question:
ConfigurationModel extends AlertSerializableModel { public String getCreatedAt() { return createdAt; } ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, String context); ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context); ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context, Map<String, ConfigurationFieldModel> configuredFields); Long getDescriptorId(); Long getConfigurationId(); String getCreatedAt(); String getLastUpdated(); ConfigContextEnum getDescriptorContext(); Optional<ConfigurationFieldModel> getField(String fieldKey); List<ConfigurationFieldModel> getCopyOfFieldList(); Map<String, ConfigurationFieldModel> getCopyOfKeyToFieldMap(); ConfigurationModelMutable createMutableCopy(); }### Answer:
@Test public void getCreatedAtTest() { ConfigurationModel configurationModel = createConfigurationModel(); assertEquals(createdAt, configurationModel.getCreatedAt()); } |
### Question:
ConfigurationModel extends AlertSerializableModel { public String getLastUpdated() { return lastUpdated; } ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, String context); ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context); ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context, Map<String, ConfigurationFieldModel> configuredFields); Long getDescriptorId(); Long getConfigurationId(); String getCreatedAt(); String getLastUpdated(); ConfigContextEnum getDescriptorContext(); Optional<ConfigurationFieldModel> getField(String fieldKey); List<ConfigurationFieldModel> getCopyOfFieldList(); Map<String, ConfigurationFieldModel> getCopyOfKeyToFieldMap(); ConfigurationModelMutable createMutableCopy(); }### Answer:
@Test public void getLastUpdatedTest() { ConfigurationModel configurationModel = createConfigurationModel(); assertEquals(lastUpdated, configurationModel.getLastUpdated()); } |
### Question:
ConfigurationModel extends AlertSerializableModel { public ConfigContextEnum getDescriptorContext() { return context; } ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, String context); ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context); ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context, Map<String, ConfigurationFieldModel> configuredFields); Long getDescriptorId(); Long getConfigurationId(); String getCreatedAt(); String getLastUpdated(); ConfigContextEnum getDescriptorContext(); Optional<ConfigurationFieldModel> getField(String fieldKey); List<ConfigurationFieldModel> getCopyOfFieldList(); Map<String, ConfigurationFieldModel> getCopyOfKeyToFieldMap(); ConfigurationModelMutable createMutableCopy(); }### Answer:
@Test public void getDescriptorContextTest() { ConfigurationModel configurationModel = createConfigurationModel(); assertEquals(configContextEnum, configurationModel.getDescriptorContext()); } |
### Question:
ConfigurationModel extends AlertSerializableModel { public Optional<ConfigurationFieldModel> getField(String fieldKey) { Objects.requireNonNull(fieldKey); return Optional.ofNullable(configuredFields.get(fieldKey)); } ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, String context); ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context); ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context, Map<String, ConfigurationFieldModel> configuredFields); Long getDescriptorId(); Long getConfigurationId(); String getCreatedAt(); String getLastUpdated(); ConfigContextEnum getDescriptorContext(); Optional<ConfigurationFieldModel> getField(String fieldKey); List<ConfigurationFieldModel> getCopyOfFieldList(); Map<String, ConfigurationFieldModel> getCopyOfKeyToFieldMap(); ConfigurationModelMutable createMutableCopy(); }### Answer:
@Test public void getFieldTest() { ConfigurationModel configurationModel = createConfigurationModel(); assertTrue(configurationModel.getField(fieldKey).isPresent()); assertFalse(configurationModel.getField("badFieldKey").isPresent()); } |
### Question:
ConfigurationModel extends AlertSerializableModel { public List<ConfigurationFieldModel> getCopyOfFieldList() { return new ArrayList<>(configuredFields.values()); } ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, String context); ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context); ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context, Map<String, ConfigurationFieldModel> configuredFields); Long getDescriptorId(); Long getConfigurationId(); String getCreatedAt(); String getLastUpdated(); ConfigContextEnum getDescriptorContext(); Optional<ConfigurationFieldModel> getField(String fieldKey); List<ConfigurationFieldModel> getCopyOfFieldList(); Map<String, ConfigurationFieldModel> getCopyOfKeyToFieldMap(); ConfigurationModelMutable createMutableCopy(); }### Answer:
@Test public void getCopyOfFieldListTest() { ConfigurationModel configurationModel = createConfigurationModel(); List<ConfigurationFieldModel> fieldList = configurationModel.getCopyOfFieldList(); assertEquals(1, fieldList.size()); assertEquals(configurationFieldModel, fieldList.get(0)); } |
### Question:
ConfigurationModel extends AlertSerializableModel { public Map<String, ConfigurationFieldModel> getCopyOfKeyToFieldMap() { return new HashMap<>(configuredFields); } ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, String context); ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context); ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context, Map<String, ConfigurationFieldModel> configuredFields); Long getDescriptorId(); Long getConfigurationId(); String getCreatedAt(); String getLastUpdated(); ConfigContextEnum getDescriptorContext(); Optional<ConfigurationFieldModel> getField(String fieldKey); List<ConfigurationFieldModel> getCopyOfFieldList(); Map<String, ConfigurationFieldModel> getCopyOfKeyToFieldMap(); ConfigurationModelMutable createMutableCopy(); }### Answer:
@Test public void getCopyOfKeyToFieldMapTest() { ConfigurationModel configurationModel = createConfigurationModel(); Map<String, ConfigurationFieldModel> keyToFieldMap = configurationModel.getCopyOfKeyToFieldMap(); assertFalse(keyToFieldMap.isEmpty()); assertTrue(keyToFieldMap.containsValue(configurationFieldModel)); } |
### Question:
ConfigurationModel extends AlertSerializableModel { public ConfigurationModelMutable createMutableCopy() { ConfigurationModelMutable mutableCopy = new ConfigurationModelMutable(descriptorId, configurationId, createdAt, lastUpdated, context); mutableCopy.getConfiguredFields().putAll(configuredFields); return mutableCopy; } ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, String context); ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context); ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context, Map<String, ConfigurationFieldModel> configuredFields); Long getDescriptorId(); Long getConfigurationId(); String getCreatedAt(); String getLastUpdated(); ConfigContextEnum getDescriptorContext(); Optional<ConfigurationFieldModel> getField(String fieldKey); List<ConfigurationFieldModel> getCopyOfFieldList(); Map<String, ConfigurationFieldModel> getCopyOfKeyToFieldMap(); ConfigurationModelMutable createMutableCopy(); }### Answer:
@Test public void createMutableCopyTest() { ConfigurationModel configurationModel = createConfigurationModel(); ConfigurationModelMutable configurationModelMutable = configurationModel.createMutableCopy(); assertEquals(configurationModel, configurationModelMutable); assertTrue(configurationModel != configurationModelMutable); } |
### Question:
ConfigurationModelMutable extends ConfigurationModel { public void put(ConfigurationFieldModel configFieldModel) { Objects.requireNonNull(configFieldModel); String fieldKey = configFieldModel.getFieldKey(); Objects.requireNonNull(fieldKey); if (getConfiguredFields().containsKey(fieldKey)) { ConfigurationFieldModel oldConfigField = getConfiguredFields().get(fieldKey); List<String> values = combine(oldConfigField, configFieldModel); oldConfigField.setFieldValues(values); } else { getConfiguredFields().put(fieldKey, configFieldModel); } } ConfigurationModelMutable(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, String context); ConfigurationModelMutable(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context); void put(ConfigurationFieldModel configFieldModel); }### Answer:
@Test public void putTest() { final String fieldValue2 = "fieldValue-2"; ConfigurationFieldModel configurationFieldModel2 = ConfigurationFieldModel.create(fieldKey); configurationFieldModel2.setFieldValue(fieldValue2); ConfigurationModelMutable configurationModelMutable = createConfigurationModelMutable(); configurationModelMutable.put(configurationFieldModel); configurationModelMutable.put(configurationFieldModel2); Optional<ConfigurationFieldModel> testConfigurationFieldModelOptional = configurationModelMutable.getField(fieldKey); assertTrue(testConfigurationFieldModelOptional.isPresent()); ArrayList<String> fieldValues = new ArrayList<>(testConfigurationFieldModelOptional.get().getFieldValues()); assertEquals(2, fieldValues.size()); assertTrue(fieldValues.contains(fieldValue)); assertTrue(fieldValues.contains(fieldValue2)); }
@Test public void getFieldTest() { ConfigurationModelMutable configurationModelMutable = new ConfigurationModelMutable(descriptorId, configurationId, createdAt, lastUpdated, configContextEnum.name()); configurationModelMutable.put(configurationFieldModel); Optional<ConfigurationFieldModel> testConfigurationFieldModel = configurationModelMutable.getField(fieldKey); Optional<ConfigurationFieldModel> testConfigurationFieldModelEmpty = configurationModelMutable.getField("badKey"); assertTrue(testConfigurationFieldModel.isPresent()); assertFalse(testConfigurationFieldModelEmpty.isPresent()); assertEquals(configurationFieldModel, testConfigurationFieldModel.get()); }
@Test public void getCopyOfFieldListTest() { ConfigurationModelMutable configurationModelMutable = createConfigurationModelMutable(); configurationModelMutable.put(configurationFieldModel); List<ConfigurationFieldModel> testConfigurationFieldModelList = configurationModelMutable.getCopyOfFieldList(); assertEquals(1, testConfigurationFieldModelList.size()); assertEquals(configurationFieldModel, testConfigurationFieldModelList.get(0)); }
@Test public void getCopyOfKeyToFieldMapTest() { ConfigurationModelMutable configurationModelMutable = createConfigurationModelMutable(); configurationModelMutable.put(configurationFieldModel); Map<String, ConfigurationFieldModel> configurationFieldModelMap = configurationModelMutable.getCopyOfKeyToFieldMap(); assertEquals(1, configurationFieldModelMap.size()); assertEquals(configurationFieldModel, configurationFieldModelMap.get(fieldKey)); } |
### Question:
DefaultConfigurationAccessor implements ConfigurationAccessor { @Override public ConfigurationJobModel createJob(Collection<String> descriptorNames, Collection<ConfigurationFieldModel> configuredFields) throws AlertDatabaseConstraintException { return createJob(null, descriptorNames, configuredFields); } @Autowired DefaultConfigurationAccessor(RegisteredDescriptorRepository registeredDescriptorRepository, DescriptorTypeRepository descriptorTypeRepository, DefinedFieldRepository definedFieldRepository,
DescriptorConfigRepository descriptorConfigsRepository, ConfigGroupRepository configGroupRepository, ConfigContextRepository configContextRepository, FieldValueRepository fieldValueRepository,
EncryptionUtility encryptionUtility); @Override List<ConfigurationJobModel> getAllJobs(); @Override Optional<ConfigurationJobModel> getJobById(UUID jobId); @Override List<ConfigurationJobModel> getJobsByFrequency(FrequencyType frequency); @Override ConfigurationJobModel createJob(Collection<String> descriptorNames, Collection<ConfigurationFieldModel> configuredFields); @Override ConfigurationJobModel updateJob(UUID jobId, Collection<String> descriptorNames, Collection<ConfigurationFieldModel> configuredFields); @Override void deleteJob(UUID jobId); @Override Optional<ConfigurationModel> getProviderConfigurationByName(String providerConfigName); @Override Optional<ConfigurationModel> getConfigurationById(Long id); @Override List<ConfigurationModel> getConfigurationsByDescriptorKey(DescriptorKey descriptorKey); @Override List<ConfigurationModel> getConfigurationsByDescriptorType(DescriptorType descriptorType); @Override List<ConfigurationModel> getChannelConfigurationsByFrequency(FrequencyType frequencyType); @Override List<ConfigurationModel> getConfigurationsByDescriptorKeyAndContext(DescriptorKey descriptorKey, ConfigContextEnum context); @Override ConfigurationModel createConfiguration(DescriptorKey descriptorKey, ConfigContextEnum context, Collection<ConfigurationFieldModel> configuredFields); @Override List<ConfigurationModel> getConfigurationsByDescriptorNameAndContext(String descriptorName, ConfigContextEnum context); @Override ConfigurationModel updateConfiguration(Long descriptorConfigId, Collection<ConfigurationFieldModel> configuredFields); @Override void deleteConfiguration(ConfigurationModel configModel); @Override void deleteConfiguration(Long descriptorConfigId); static final String EXCEPTION_FORMAT_DESCRIPTOR_KEY_IS_NOT_VALID; }### Answer:
@Test public void createJobTest() throws Exception { List<String> descriptorNames = List.of("descriptor-name-test"); ConfigurationFieldModel configurationFieldModel = ConfigurationFieldModel.create("channel.common.name"); configurationFieldModel.setFieldValue(fieldValue); List<ConfigurationFieldModel> configuredFields = List.of(configurationFieldModel); RegisteredDescriptorEntity registeredDescriptorEntity = new RegisteredDescriptorEntity("name", 1L); registeredDescriptorEntity.setId(2L); ConfigContextEntity configContextEntity = new ConfigContextEntity(configContextEnum.name()); configContextEntity.setId(3L); DefinedFieldEntity definedFieldEntity = new DefinedFieldEntity(fieldKey, false); definedFieldEntity.setId(4L); DescriptorConfigEntity descriptorConfigEntity = new DescriptorConfigEntity(5L, 6L, DateUtils.createCurrentDateTimestamp(), DateUtils.createCurrentDateTimestamp()); descriptorConfigEntity.setId(5L); setupCreateJobMocks(registeredDescriptorEntity, configContextEntity, definedFieldEntity, descriptorConfigEntity); DefaultConfigurationAccessor configurationAccessor = new DefaultConfigurationAccessor(registeredDescriptorRepository, null, definedFieldRepository, descriptorConfigRepository, configGroupRepository, configContextRepository, fieldValueRepository, null); ConfigurationJobModel configurationJobModel = configurationAccessor.createJob(descriptorNames, configuredFields); assertEquals(fieldValue, configurationJobModel.getName()); } |
### Question:
EventManager { @Transactional public void sendEvents(List<? extends AlertEvent> eventList) { if (!eventList.isEmpty()) { eventList.forEach(this::sendEvent); } } @Autowired EventManager(ContentConverter contentConverter, JmsTemplate jmsTemplate); @Transactional void sendEvents(List<? extends AlertEvent> eventList); @Transactional void sendEvent(AlertEvent event); JmsTemplate getJmsTemplate(); ContentConverter getContentConverter(); }### Answer:
@Test public void testSendEvents() throws Exception { JmsTemplate jmsTemplate = Mockito.mock(JmsTemplate.class); ContentConverter contentConverter = Mockito.mock(ContentConverter.class); Mockito.doNothing().when(jmsTemplate).convertAndSend(Mockito.anyString(), Mockito.any(Object.class)); EventManager eventManager = new EventManager(contentConverter, jmsTemplate); LinkableItem subTopic = new LinkableItem("subTopic", "sub topic", null); ProviderMessageContent content = new ProviderMessageContent.Builder() .applyProvider("1", 1L, "providerConfig") .applyTopic("testTopic", "topic") .applySubTopic(subTopic.getName(), subTopic.getValue()) .build(); FieldUtility fieldUtility = new FieldUtility(Map.of()); DistributionEvent event = new DistributionEvent(UUID.randomUUID().toString(), "destination", RestConstants.formatDate(new Date()), 1L, "FORMAT", MessageContentGroup.singleton(content), fieldUtility); eventManager.sendEvents(List.of(event)); } |
### Question:
EventManager { @Transactional public void sendEvent(AlertEvent event) { String destination = event.getDestination(); String jsonMessage = contentConverter.getJsonString(event); jmsTemplate.convertAndSend(destination, jsonMessage); } @Autowired EventManager(ContentConverter contentConverter, JmsTemplate jmsTemplate); @Transactional void sendEvents(List<? extends AlertEvent> eventList); @Transactional void sendEvent(AlertEvent event); JmsTemplate getJmsTemplate(); ContentConverter getContentConverter(); }### Answer:
@Test public void testNotAbstractChannelEvent() throws Exception { JmsTemplate jmsTemplate = Mockito.mock(JmsTemplate.class); ContentConverter contentConverter = Mockito.mock(ContentConverter.class); Mockito.doNothing().when(jmsTemplate).convertAndSend(Mockito.anyString(), Mockito.any(Object.class)); EventManager eventManager = new EventManager(contentConverter, jmsTemplate); LinkableItem subTopic = new LinkableItem("subTopic", "sub topic", null); ProviderMessageContent content = new ProviderMessageContent.Builder() .applyProvider("1", 1L, "providerConfig") .applyTopic("testTopic", "topic") .applySubTopic(subTopic.getName(), subTopic.getValue()) .build(); AlertEvent dbStoreEvent = new ContentEvent("", RestConstants.formatDate(new Date()), 1L, "FORMAT", MessageContentGroup.singleton(content)); eventManager.sendEvent(dbStoreEvent); } |
### Question:
DefaultConfigurationAccessor implements ConfigurationAccessor { @Override public ConfigurationJobModel updateJob(UUID jobId, Collection<String> descriptorNames, Collection<ConfigurationFieldModel> configuredFields) throws AlertDatabaseConstraintException { if (jobId == null) { throw new AlertDatabaseConstraintException(NULL_JOB_ID); } deleteJob(jobId); return createJob(jobId, descriptorNames, configuredFields); } @Autowired DefaultConfigurationAccessor(RegisteredDescriptorRepository registeredDescriptorRepository, DescriptorTypeRepository descriptorTypeRepository, DefinedFieldRepository definedFieldRepository,
DescriptorConfigRepository descriptorConfigsRepository, ConfigGroupRepository configGroupRepository, ConfigContextRepository configContextRepository, FieldValueRepository fieldValueRepository,
EncryptionUtility encryptionUtility); @Override List<ConfigurationJobModel> getAllJobs(); @Override Optional<ConfigurationJobModel> getJobById(UUID jobId); @Override List<ConfigurationJobModel> getJobsByFrequency(FrequencyType frequency); @Override ConfigurationJobModel createJob(Collection<String> descriptorNames, Collection<ConfigurationFieldModel> configuredFields); @Override ConfigurationJobModel updateJob(UUID jobId, Collection<String> descriptorNames, Collection<ConfigurationFieldModel> configuredFields); @Override void deleteJob(UUID jobId); @Override Optional<ConfigurationModel> getProviderConfigurationByName(String providerConfigName); @Override Optional<ConfigurationModel> getConfigurationById(Long id); @Override List<ConfigurationModel> getConfigurationsByDescriptorKey(DescriptorKey descriptorKey); @Override List<ConfigurationModel> getConfigurationsByDescriptorType(DescriptorType descriptorType); @Override List<ConfigurationModel> getChannelConfigurationsByFrequency(FrequencyType frequencyType); @Override List<ConfigurationModel> getConfigurationsByDescriptorKeyAndContext(DescriptorKey descriptorKey, ConfigContextEnum context); @Override ConfigurationModel createConfiguration(DescriptorKey descriptorKey, ConfigContextEnum context, Collection<ConfigurationFieldModel> configuredFields); @Override List<ConfigurationModel> getConfigurationsByDescriptorNameAndContext(String descriptorName, ConfigContextEnum context); @Override ConfigurationModel updateConfiguration(Long descriptorConfigId, Collection<ConfigurationFieldModel> configuredFields); @Override void deleteConfiguration(ConfigurationModel configModel); @Override void deleteConfiguration(Long descriptorConfigId); static final String EXCEPTION_FORMAT_DESCRIPTOR_KEY_IS_NOT_VALID; }### Answer:
@Test public void updateJobTest() throws Exception { UUID uuid = UUID.randomUUID(); List<String> descriptorNames = List.of("descriptor-name-test"); ConfigurationFieldModel configurationFieldModel = ConfigurationFieldModel.create("channel.common.name"); configurationFieldModel.setFieldValue(fieldValue); List<ConfigurationFieldModel> configuredFields = List.of(configurationFieldModel); RegisteredDescriptorEntity registeredDescriptorEntity = new RegisteredDescriptorEntity("name", 1L); registeredDescriptorEntity.setId(2L); ConfigContextEntity configContextEntity = new ConfigContextEntity(configContextEnum.name()); configContextEntity.setId(3L); DefinedFieldEntity definedFieldEntity = new DefinedFieldEntity(fieldKey, false); definedFieldEntity.setId(4L); DescriptorConfigEntity descriptorConfigEntity = new DescriptorConfigEntity(5L, 6L, DateUtils.createCurrentDateTimestamp(), DateUtils.createCurrentDateTimestamp()); descriptorConfigEntity.setId(5L); ConfigGroupEntity configGroupEntity = new ConfigGroupEntity(6L, uuid); Mockito.when(configGroupRepository.findByJobId(Mockito.any())).thenReturn(List.of(configGroupEntity)); setupCreateJobMocks(registeredDescriptorEntity, configContextEntity, definedFieldEntity, descriptorConfigEntity); DefaultConfigurationAccessor configurationAccessor = new DefaultConfigurationAccessor(registeredDescriptorRepository, null, definedFieldRepository, descriptorConfigRepository, configGroupRepository, configContextRepository, fieldValueRepository, null); ConfigurationJobModel configurationJobModel = configurationAccessor.updateJob(uuid, descriptorNames, configuredFields); Mockito.verify(descriptorConfigRepository).deleteById(Mockito.any()); assertEquals(uuid, configurationJobModel.getJobId()); assertEquals(fieldValue, configurationJobModel.getName()); }
@Test public void updateJobNullIdTest() throws Exception { DefaultConfigurationAccessor configurationAccessor = new DefaultConfigurationAccessor(null, null, null, null, null, null, null, null); try { configurationAccessor.updateJob(null, null, null); fail("Null jobId did not throw expected AlertDatabaseConstraintException."); } catch (AlertDatabaseConstraintException e) { assertNotNull(e); } } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.