Datasets:

Minata
/

512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 184k rows

method2testcases stringlengths 118 3.08k
### Question: Reflection { public static <T> T instantiate(Class<T> clazz) throws BeanInstantiationException { if (clazz.isInterface()) { throw new BeanInstantiationException(clazz, "specified class is an interface"); } try { return clazz.newInstance(); } catch (InstantiationException e) { throw new BeanInstantiationException(clazz, "Is it an abstract class?", e); } catch (IllegalAccessException e) { throw new BeanInstantiationException(clazz, "Is the constructor accessible?", e); } } 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 testInstantiate() throws Exception { Reflection.instantiateClass(A.class); }
### Question: QCodec extends RFC1522Codec implements StringEncoder, StringDecoder { @Override public String decode(final String str) throws DecoderException { if (str == null) { return null; } try { return decodeText(str); } catch (final UnsupportedEncodingException e) { throw new DecoderException(e.getMessage(), e); } } QCodec(); QCodec(final Charset charset); QCodec(final String charsetName); String encode(final String str, final Charset charset); String encode(final String str, final String charset); @Override String encode(final String str); @Override String decode(final String str); @Override Object encode(final Object obj); @Override Object decode(final Object obj); Charset getCharset(); String getDefaultCharset(); boolean isEncodeBlanks(); void setEncodeBlanks(final boolean b); }### Answer: @Test public void testDecodeStringWithNull() throws Exception { final QCodec qcodec = new QCodec(); final String test = null; final String result = qcodec.decode( test ); assertEquals("Result should be null", null, result); } @Test public void testDecodeObjects() throws Exception { final QCodec qcodec = new QCodec(); final String decoded = "=?UTF-8?Q?1+1 =3D 2?="; final String plain = (String) qcodec.decode((Object) decoded); assertEquals("Basic Q decoding test", "1+1 = 2", plain); final Object result = qcodec.decode((Object) null); assertEquals( "Decoding a null Object should return null", null, result); try { final Object dObj = new Double(3.0); qcodec.decode( dObj ); fail( "Trying to url encode a Double object should cause an exception."); } catch (final DecoderException ee) { } }
### Question: BCodec extends RFC1522Codec implements StringEncoder, StringDecoder { public String encode(final String value, final Charset charset) throws EncoderException { if (value == null) { return null; } return encodeText(value, charset); } BCodec(); BCodec(final Charset charset); BCodec(final String charsetName); String encode(final String value, final Charset charset); String encode(final String value, final String charset); @Override String encode(final String value); @Override String decode(final String value); @Override Object encode(final Object value); @Override Object decode(final Object value); Charset getCharset(); String getDefaultCharset(); }### Answer: @Test public void testEncodeStringWithNull() throws Exception { final BCodec bcodec = new BCodec(); final String test = null; final String result = bcodec.encode(test, "charset"); assertEquals("Result should be null", null, result); } @Test public void testEncodeObjects() throws Exception { final BCodec bcodec = new BCodec(); final String plain = "what not"; final String encoded = (String) bcodec.encode((Object) plain); assertEquals("Basic B encoding test", "=?UTF-8?B?d2hhdCBub3Q=?=", encoded); final Object result = bcodec.encode((Object) null); assertEquals("Encoding a null Object should return null", null, result); try { final Object dObj = new Double(3.0); bcodec.encode(dObj); fail("Trying to url encode a Double object should cause an exception."); } catch (final EncoderException ee) { } }
### Question: BCodec extends RFC1522Codec implements StringEncoder, StringDecoder { @Override public String decode(final String value) throws DecoderException { if (value == null) { return null; } try { return this.decodeText(value); } catch (final UnsupportedEncodingException e) { throw new DecoderException(e.getMessage(), e); } } BCodec(); BCodec(final Charset charset); BCodec(final String charsetName); String encode(final String value, final Charset charset); String encode(final String value, final String charset); @Override String encode(final String value); @Override String decode(final String value); @Override Object encode(final Object value); @Override Object decode(final Object value); Charset getCharset(); String getDefaultCharset(); }### Answer: @Test public void testDecodeStringWithNull() throws Exception { final BCodec bcodec = new BCodec(); final String test = null; final String result = bcodec.decode(test); assertEquals("Result should be null", null, result); } @Test public void testDecodeObjects() throws Exception { final BCodec bcodec = new BCodec(); final String decoded = "=?UTF-8?B?d2hhdCBub3Q=?="; final String plain = (String) bcodec.decode((Object) decoded); assertEquals("Basic B decoding test", "what not", plain); final Object result = bcodec.decode((Object) null); assertEquals("Decoding a null Object should return null", null, result); try { final Object dObj = new Double(3.0); bcodec.decode(dObj); fail("Trying to url encode a Double object should cause an exception."); } catch (final DecoderException ee) { } }
### Question: DaitchMokotoffSoundex implements StringEncoder { @Override public Object encode(final Object obj) throws EncoderException { if (!(obj instanceof String)) { throw new EncoderException( "Parameter supplied to DaitchMokotoffSoundex encode is not of type java.lang.String"); } return encode((String) obj); } DaitchMokotoffSoundex(); DaitchMokotoffSoundex(final boolean folding); @Override Object encode(final Object obj); @Override String encode(final String source); String soundex(final String source); }### Answer: @Test public void testEncodeIgnoreTrimmable() { Assert.assertEquals("746536", encode(" \t\n\r Washington \t\n\r ")); Assert.assertEquals("746536", encode("Washington")); }
### Question: CommonGetAllBuilder extends AbstractCommonBuilder { @Override public String buildSql() { String s1 = Joiner.on(", ").join(columns); return String.format(SQL, s1, s1); } CommonGetAllBuilder(List<String> cols); @Override String buildSql(); }### Answer: @Test public void build() throws Exception { List<String> columns = Lists.newArrayList("id2", "user_name", "user_age"); CommonGetAllBuilder b = new CommonGetAllBuilder(columns); assertThat(b.buildSql(), equalTo("select id2, user_name, user_age from #table")); }
### Question: ColognePhonetic implements StringEncoder { public boolean isEncodeEqual(final String text1, final String text2) { return colognePhonetic(text1).equals(colognePhonetic(text2)); } String colognePhonetic(String text); @Override Object encode(final Object object); @Override String encode(final String text); boolean isEncodeEqual(final String text1, final String text2); }### Answer: @Test public void testIsEncodeEquals() { final String[][] data = { {"Meyer", "M\u00fcller"}, {"Meyer", "Mayr"}, {"house", "house"}, {"House", "house"}, {"Haus", "house"}, {"ganz", "Gans"}, {"ganz", "G\u00e4nse"}, {"Miyagi", "Miyako"}}; for (final String[] element : data) { this.getStringEncoder().isEncodeEqual(element[1], element[0]); } }
### Question: RefinedSoundex implements StringEncoder { public int difference(final String s1, final String s2) throws EncoderException { return SoundexUtils.difference(this, s1, s2); } RefinedSoundex(); RefinedSoundex(final char[] mapping); RefinedSoundex(final String mapping); int difference(final String s1, final String s2); @Override Object encode(final Object obj); @Override String encode(final String str); String soundex(String str); static final String US_ENGLISH_MAPPING_STRING; static final RefinedSoundex US_ENGLISH; }### Answer: @Test public void testDifference() throws EncoderException { assertEquals(0, this.getStringEncoder().difference(null, null)); assertEquals(0, this.getStringEncoder().difference("", "")); assertEquals(0, this.getStringEncoder().difference(" ", " ")); assertEquals(6, this.getStringEncoder().difference("Smith", "Smythe")); assertEquals(3, this.getStringEncoder().difference("Ann", "Andrew")); assertEquals(1, this.getStringEncoder().difference("Margaret", "Andrew")); assertEquals(1, this.getStringEncoder().difference("Janet", "Margaret")); assertEquals(5, this.getStringEncoder().difference("Green", "Greene")); assertEquals(1, this.getStringEncoder().difference("Blotchet-Halls", "Greene")); assertEquals(6, this.getStringEncoder().difference("Smith", "Smythe")); assertEquals(8, this.getStringEncoder().difference("Smithers", "Smythers")); assertEquals(5, this.getStringEncoder().difference("Anothers", "Brothers")); }
### Question: RefinedSoundex implements StringEncoder { @Override public Object encode(final Object obj) throws EncoderException { if (!(obj instanceof String)) { throw new EncoderException("Parameter supplied to RefinedSoundex encode is not of type java.lang.String"); } return soundex((String) obj); } RefinedSoundex(); RefinedSoundex(final char[] mapping); RefinedSoundex(final String mapping); int difference(final String s1, final String s2); @Override Object encode(final Object obj); @Override String encode(final String str); String soundex(String str); static final String US_ENGLISH_MAPPING_STRING; static final RefinedSoundex US_ENGLISH; }### Answer: @Test public void testEncode() { assertEquals("T6036084", this.getStringEncoder().encode("testing")); assertEquals("T6036084", this.getStringEncoder().encode("TESTING")); assertEquals("T60", this.getStringEncoder().encode("The")); assertEquals("Q503", this.getStringEncoder().encode("quick")); assertEquals("B1908", this.getStringEncoder().encode("brown")); assertEquals("F205", this.getStringEncoder().encode("fox")); assertEquals("J408106", this.getStringEncoder().encode("jumped")); assertEquals("O0209", this.getStringEncoder().encode("over")); assertEquals("T60", this.getStringEncoder().encode("the")); assertEquals("L7050", this.getStringEncoder().encode("lazy")); assertEquals("D6043", this.getStringEncoder().encode("dogs")); assertEquals("D6043", RefinedSoundex.US_ENGLISH.encode("dogs")); }
### Question: RefinedSoundex implements StringEncoder { char getMappingCode(final char c) { if (!Character.isLetter(c)) { return 0; } return this.soundexMapping[Character.toUpperCase(c) - 'A']; } RefinedSoundex(); RefinedSoundex(final char[] mapping); RefinedSoundex(final String mapping); int difference(final String s1, final String s2); @Override Object encode(final Object obj); @Override String encode(final String str); String soundex(String str); static final String US_ENGLISH_MAPPING_STRING; static final RefinedSoundex US_ENGLISH; }### Answer: @Test public void testGetMappingCodeNonLetter() { final char code = this.getStringEncoder().getMappingCode('#'); assertEquals("Code does not equals zero", 0, code); }
### Question: RefinedSoundex implements StringEncoder { public String soundex(String str) { if (str == null) { return null; } str = SoundexUtils.clean(str); if (str.length() == 0) { return str; } final StringBuilder sBuf = new StringBuilder(); sBuf.append(str.charAt(0)); char last, current; last = '*'; for (int i = 0; i < str.length(); i++) { current = getMappingCode(str.charAt(i)); if (current == last) { continue; } else if (current != 0) { sBuf.append(current); } last = current; } return sBuf.toString(); } RefinedSoundex(); RefinedSoundex(final char[] mapping); RefinedSoundex(final String mapping); int difference(final String s1, final String s2); @Override Object encode(final Object obj); @Override String encode(final String str); String soundex(String str); static final String US_ENGLISH_MAPPING_STRING; static final RefinedSoundex US_ENGLISH; }### Answer: @Test public void testNewInstance() { assertEquals("D6043", new RefinedSoundex().soundex("dogs")); } @Test public void testNewInstance2() { assertEquals("D6043", new RefinedSoundex(RefinedSoundex.US_ENGLISH_MAPPING_STRING.toCharArray()).soundex("dogs")); } @Test public void testNewInstance3() { assertEquals("D6043", new RefinedSoundex(RefinedSoundex.US_ENGLISH_MAPPING_STRING).soundex("dogs")); }
### Question: PhoneticEngine { public String encode(final String input) { final Languages.LanguageSet languageSet = this.lang.guessLanguages(input); return encode(input, languageSet); } PhoneticEngine(final NameType nameType, final RuleType ruleType, final boolean concat); PhoneticEngine(final NameType nameType, final RuleType ruleType, final boolean concat, final int maxPhonemes); String encode(final String input); String encode(String input, final Languages.LanguageSet languageSet); Lang getLang(); NameType getNameType(); RuleType getRuleType(); boolean isConcat(); int getMaxPhonemes(); }### Answer: @Test(timeout = 10000L) public void testEncode() { final PhoneticEngine engine = new PhoneticEngine(this.nameType, this.ruleType, this.concat, this.maxPhonemes); final String phoneticActual = engine.encode(this.name); assertEquals("phoneme incorrect", this.phoneticExpected, phoneticActual); if (this.concat) { final String[] split = phoneticActual.split("\\\|"); assertTrue(split.length <= this.maxPhonemes); } else { final String[] words = phoneticActual.split("-"); for (final String word : words) { final String[] split = word.split("\\\|"); assertTrue(split.length <= this.maxPhonemes); } } }
### Question: BeiderMorseEncoder implements StringEncoder { public void setConcat(final boolean concat) { this.engine = new PhoneticEngine(this.engine.getNameType(), this.engine.getRuleType(), concat, this.engine.getMaxPhonemes()); } @Override Object encode(final Object source); @Override String encode(final String source); NameType getNameType(); RuleType getRuleType(); boolean isConcat(); void setConcat(final boolean concat); void setNameType(final NameType nameType); void setRuleType(final RuleType ruleType); void setMaxPhonemes(final int maxPhonemes); }### Answer: @Test public void testSetConcat() { final BeiderMorseEncoder bmpm = new BeiderMorseEncoder(); bmpm.setConcat(false); assertFalse("Should be able to set concat to false", bmpm.isConcat()); }
### Question: BeiderMorseEncoder implements StringEncoder { public void setRuleType(final RuleType ruleType) { this.engine = new PhoneticEngine(this.engine.getNameType(), ruleType, this.engine.isConcat(), this.engine.getMaxPhonemes()); } @Override Object encode(final Object source); @Override String encode(final String source); NameType getNameType(); RuleType getRuleType(); boolean isConcat(); void setConcat(final boolean concat); void setNameType(final NameType nameType); void setRuleType(final RuleType ruleType); void setMaxPhonemes(final int maxPhonemes); }### Answer: @Test(expected = IllegalArgumentException.class) public void testSetRuleTypeToRulesIllegalArgumentException() { final BeiderMorseEncoder bmpm = new BeiderMorseEncoder(); bmpm.setRuleType(RuleType.RULES); }
### 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 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 { 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: DefaultProviderDataAccessor implements ProviderDataAccessor { @Override public void deleteProjects(Collection<ProviderProject> providerProjects) { providerProjects.forEach(project -> providerProjectRepository.deleteByHref(project.getHref())); } @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 deleteProjectsTest() { ProviderProject providerProject = new ProviderProject(name, description, href, projectOwnerEmail); ProviderProjectRepository providerProjectRepository = Mockito.mock(ProviderProjectRepository.class); DefaultProviderDataAccessor providerDataAccessor = new DefaultProviderDataAccessor(providerProjectRepository, null, null, null); providerDataAccessor.deleteProjects(List.of(providerProject)); Mockito.verify(providerProjectRepository).deleteByHref(Mockito.any()); }
### Question: DefaultCustomCertificateAccessor implements CustomCertificateAccessor { @Override public List<CustomCertificateModel> getCertificates() { return customCertificateRepository.findAll() .stream() .map(this::createModel) .collect(Collectors.toList()); } @Autowired DefaultCustomCertificateAccessor(CustomCertificateRepository customCertificateRepository); @Override List<CustomCertificateModel> getCertificates(); @Override Optional<CustomCertificateModel> getCertificate(Long id); @Override CustomCertificateModel storeCertificate(CustomCertificateModel certificateModel); @Override void deleteCertificate(String certificateAlias); @Override void deleteCertificate(Long certificateId); }### Answer: @Test public void getCertificatesTest() { CustomCertificateRepository customCertificateRepository = new MockCustomCertificateRepository(alias, content, testDate); DefaultCustomCertificateAccessor customCertificateAccessor = new DefaultCustomCertificateAccessor(customCertificateRepository); List<CustomCertificateModel> customCertificateModelList = customCertificateAccessor.getCertificates(); assertEquals(1, customCertificateModelList.size()); CustomCertificateModel customCertificateModel = customCertificateModelList.get(0); testCustomCertificateModel(expectedCustomCertificateModel, customCertificateModel); }
### Question: DefaultCustomCertificateAccessor implements CustomCertificateAccessor { @Override public Optional<CustomCertificateModel> getCertificate(Long id) { return customCertificateRepository.findById(id) .map(this::createModel); } @Autowired DefaultCustomCertificateAccessor(CustomCertificateRepository customCertificateRepository); @Override List<CustomCertificateModel> getCertificates(); @Override Optional<CustomCertificateModel> getCertificate(Long id); @Override CustomCertificateModel storeCertificate(CustomCertificateModel certificateModel); @Override void deleteCertificate(String certificateAlias); @Override void deleteCertificate(Long certificateId); }### Answer: @Test public void getCertificateTest() { CustomCertificateRepository customCertificateRepository = new MockCustomCertificateRepository(alias, content, testDate); DefaultCustomCertificateAccessor customCertificateAccessor = new DefaultCustomCertificateAccessor(customCertificateRepository); Optional<CustomCertificateModel> customCertificateModelOptional = customCertificateAccessor.getCertificate(0L); Optional<CustomCertificateModel> customCertificateModelOptionalEmpty = customCertificateAccessor.getCertificate(9L); assertTrue(customCertificateModelOptional.isPresent()); assertFalse(customCertificateModelOptionalEmpty.isPresent()); CustomCertificateModel customCertificateModel = customCertificateModelOptional.get(); testCustomCertificateModel(expectedCustomCertificateModel, customCertificateModel); }
### Question: DefaultCustomCertificateAccessor implements CustomCertificateAccessor { @Override public void deleteCertificate(String certificateAlias) throws AlertDatabaseConstraintException { if (StringUtils.isBlank(certificateAlias)) { throw new AlertDatabaseConstraintException("The field 'certificateAlias' cannot be blank"); } CustomCertificateEntity customCertificateEntity = customCertificateRepository.findByAlias(certificateAlias) .orElseThrow(() -> new AlertDatabaseConstraintException("A custom certificate with the alias " + certificateAlias + " did not exist")); deleteCertificate(customCertificateEntity.getId()); } @Autowired DefaultCustomCertificateAccessor(CustomCertificateRepository customCertificateRepository); @Override List<CustomCertificateModel> getCertificates(); @Override Optional<CustomCertificateModel> getCertificate(Long id); @Override CustomCertificateModel storeCertificate(CustomCertificateModel certificateModel); @Override void deleteCertificate(String certificateAlias); @Override void deleteCertificate(Long certificateId); }### Answer: @Test public void deleteCertificateByAliasBlankTest() throws Exception { CustomCertificateRepository customCertificateRepository = new MockCustomCertificateRepository(alias, content, testDate); DefaultCustomCertificateAccessor customCertificateAccessor = new DefaultCustomCertificateAccessor(customCertificateRepository); try { customCertificateAccessor.deleteCertificate(""); fail(); } catch (AlertDatabaseConstraintException e) { assertNotNull(e); } } @Test public void deleteCertificateByIdNullTest() throws Exception { CustomCertificateRepository customCertificateRepository = new MockCustomCertificateRepository(alias, content, testDate); DefaultCustomCertificateAccessor customCertificateAccessor = new DefaultCustomCertificateAccessor(customCertificateRepository); try { Long certificateId = null; customCertificateAccessor.deleteCertificate(certificateId); fail(); } catch (AlertDatabaseConstraintException e) { assertNotNull(e); } try { customCertificateAccessor.deleteCertificate(-1L); fail(); } catch (AlertDatabaseConstraintException e) { assertNotNull(e); } }
### Question: DefaultSystemStatusAccessor implements SystemStatusAccessor { @Override @Transactional public boolean isSystemInitialized() { return getSystemStatus().isInitialConfigurationPerformed(); } @Autowired DefaultSystemStatusAccessor(SystemStatusRepository systemStatusRepository); @Override @Transactional boolean isSystemInitialized(); @Override @Transactional void setSystemInitialized(boolean systemInitialized); @Override @Transactional void startupOccurred(); @Override @Transactional OffsetDateTime getStartupTime(); static final Long SYSTEM_STATUS_ID; }### Answer: @Test public void isSystemInitializedTest() { SystemStatusRepository systemStatusRepository = Mockito.mock(SystemStatusRepository.class); SystemStatusEntity systemStatus = new SystemStatusEntity(Boolean.TRUE, DateUtils.createCurrentDateTimestamp()); Mockito.when(systemStatusRepository.findById(Mockito.any())).thenReturn(Optional.of(systemStatus)); DefaultSystemStatusAccessor systemStatusUtility = new DefaultSystemStatusAccessor(systemStatusRepository); assertTrue(systemStatusUtility.isSystemInitialized()); }
### Question: DefaultSystemStatusAccessor implements SystemStatusAccessor { @Override @Transactional public void setSystemInitialized(boolean systemInitialized) { SystemStatusEntity systemStatus = getSystemStatus(); SystemStatusEntity newSystemStatus = new SystemStatusEntity(systemInitialized, systemStatus.getStartupTime()); updateSystemStatus(newSystemStatus); } @Autowired DefaultSystemStatusAccessor(SystemStatusRepository systemStatusRepository); @Override @Transactional boolean isSystemInitialized(); @Override @Transactional void setSystemInitialized(boolean systemInitialized); @Override @Transactional void startupOccurred(); @Override @Transactional OffsetDateTime getStartupTime(); static final Long SYSTEM_STATUS_ID; }### Answer: @Test public void setSystemInitializedTest() { SystemStatusRepository systemStatusRepository = new MockSystemStatusRepository(Boolean.FALSE); DefaultSystemStatusAccessor systemStatusUtility = new DefaultSystemStatusAccessor(systemStatusRepository); systemStatusUtility.setSystemInitialized(Boolean.TRUE); SystemStatusEntity testSystemStatus = systemStatusRepository.findAll().get(0); assertTrue(testSystemStatus.isInitialConfigurationPerformed()); }
### Question: DefaultSystemStatusAccessor implements SystemStatusAccessor { @Override @Transactional public void startupOccurred() { SystemStatusEntity systemStatus = getSystemStatus(); SystemStatusEntity newSystemStatus = new SystemStatusEntity(systemStatus.isInitialConfigurationPerformed(), createCurrentDateTimestamp()); updateSystemStatus(newSystemStatus); } @Autowired DefaultSystemStatusAccessor(SystemStatusRepository systemStatusRepository); @Override @Transactional boolean isSystemInitialized(); @Override @Transactional void setSystemInitialized(boolean systemInitialized); @Override @Transactional void startupOccurred(); @Override @Transactional OffsetDateTime getStartupTime(); static final Long SYSTEM_STATUS_ID; }### Answer: @Test public void startupOccurred() { SystemStatusRepository systemStatusRepository = new MockSystemStatusRepository(Boolean.FALSE); DefaultSystemStatusAccessor systemStatusUtility = new DefaultSystemStatusAccessor(systemStatusRepository); systemStatusUtility.startupOccurred(); LocalDateTime estimatedDate = LocalDateTime.now(); SystemStatusEntity testSystemStatus = systemStatusRepository.findAll().get(0); LocalDateTime systemStatusLocalDateTime = testSystemStatus.getStartupTime() .toInstant() .atZone(ZoneId.systemDefault()) .toLocalDateTime(); assertFalse(testSystemStatus.isInitialConfigurationPerformed()); assertNotNull(testSystemStatus.getStartupTime()); assertEquals(estimatedDate.getHour(), systemStatusLocalDateTime.getHour()); assertEquals(estimatedDate.getMinute(), systemStatusLocalDateTime.getMinute()); }
### Question: DefaultSystemStatusAccessor implements SystemStatusAccessor { @Override @Transactional public OffsetDateTime getStartupTime() { return getSystemStatus().getStartupTime(); } @Autowired DefaultSystemStatusAccessor(SystemStatusRepository systemStatusRepository); @Override @Transactional boolean isSystemInitialized(); @Override @Transactional void setSystemInitialized(boolean systemInitialized); @Override @Transactional void startupOccurred(); @Override @Transactional OffsetDateTime getStartupTime(); static final Long SYSTEM_STATUS_ID; }### Answer: @Test public void getStartupTime() { SystemStatusRepository systemStatusRepository = Mockito.mock(SystemStatusRepository.class); OffsetDateTime date = DateUtils.createCurrentDateTimestamp(); SystemStatusEntity systemStatus = new SystemStatusEntity(Boolean.TRUE, date); Mockito.when(systemStatusRepository.findById(Mockito.any())).thenReturn(Optional.of(systemStatus)); DefaultSystemStatusAccessor systemStatusUtility = new DefaultSystemStatusAccessor(systemStatusRepository); assertEquals(date, systemStatusUtility.getStartupTime()); }
### Question: DefaultRoleAccessor implements RoleAccessor { @Override public boolean doesRoleNameExist(String name) { return roleRepository.existsRoleEntityByRoleName(name); } @Autowired DefaultRoleAccessor(RoleRepository roleRepository, UserRoleRepository userRoleRepository, PermissionMatrixRepository permissionMatrixRepository, RegisteredDescriptorRepository registeredDescriptorRepository, ConfigContextRepository configContextRepository); @Override Set<UserRoleModel> getRoles(); @Override Set<UserRoleModel> getRoles(Collection<Long> roleIds); @Override boolean doesRoleNameExist(String name); @Override UserRoleModel createRole(String roleName); @Override UserRoleModel createRoleWithPermissions(String roleName, PermissionMatrixModel permissionMatrix); @Override void updateRoleName(Long roleId, String roleName); @Override PermissionMatrixModel updatePermissionsForRole(String roleName, PermissionMatrixModel permissionMatrix); @Override void deleteRole(Long roleId); @Override void updateUserRoles(Long userId, Collection<UserRoleModel> roles); @Override PermissionMatrixModel mergePermissionsForRoles(Collection<String> roleNames); @Override PermissionMatrixModel readPermissionsForRole(Long roleId); }### Answer: @Test public void doesRoleNameExistTest() { Mockito.when(roleRepository.existsRoleEntityByRoleName(Mockito.any())).thenReturn(true); DefaultRoleAccessor authorizationUtility = new DefaultRoleAccessor(roleRepository, userRoleRepository, permissionMatrixRepository, registeredDescriptorRepository, configContextRepository); assertTrue(authorizationUtility.doesRoleNameExist("name")); }
### Question: DefaultRoleAccessor implements RoleAccessor { @Override public UserRoleModel createRole(String roleName) throws AlertDatabaseConstraintException { RoleEntity dbRole = createRole(roleName, true); return UserRoleModel.of(dbRole.getRoleName(), dbRole.getCustom()); } @Autowired DefaultRoleAccessor(RoleRepository roleRepository, UserRoleRepository userRoleRepository, PermissionMatrixRepository permissionMatrixRepository, RegisteredDescriptorRepository registeredDescriptorRepository, ConfigContextRepository configContextRepository); @Override Set<UserRoleModel> getRoles(); @Override Set<UserRoleModel> getRoles(Collection<Long> roleIds); @Override boolean doesRoleNameExist(String name); @Override UserRoleModel createRole(String roleName); @Override UserRoleModel createRoleWithPermissions(String roleName, PermissionMatrixModel permissionMatrix); @Override void updateRoleName(Long roleId, String roleName); @Override PermissionMatrixModel updatePermissionsForRole(String roleName, PermissionMatrixModel permissionMatrix); @Override void deleteRole(Long roleId); @Override void updateUserRoles(Long userId, Collection<UserRoleModel> roles); @Override PermissionMatrixModel mergePermissionsForRoles(Collection<String> roleNames); @Override PermissionMatrixModel readPermissionsForRole(Long roleId); }### Answer: @Test public void createRoleTest() throws Exception { final String roleName = "roleName"; Mockito.when(roleRepository.save(Mockito.any())).thenReturn(new RoleEntity(roleName, true)); DefaultRoleAccessor authorizationUtility = new DefaultRoleAccessor(roleRepository, userRoleRepository, permissionMatrixRepository, registeredDescriptorRepository, configContextRepository); UserRoleModel userRoleModel = authorizationUtility.createRole(roleName); UserRoleModel expectedUserRoleModel = createUserRoleModel(null, roleName, true); assertEquals(expectedUserRoleModel, userRoleModel); } @Test public void createRoleNullTest() throws Exception { DefaultRoleAccessor authorizationUtility = new DefaultRoleAccessor(roleRepository, userRoleRepository, permissionMatrixRepository, registeredDescriptorRepository, configContextRepository); try { authorizationUtility.createRole(""); fail("Blank roleName did not throw expected AlertDatabaseConstraintException."); } catch (AlertDatabaseConstraintException e) { assertNotNull(e); } }
### Question: DefaultAuthenticationTypeAccessor implements AuthenticationTypeAccessor { @Override public Optional<AuthenticationTypeDetails> getAuthenticationTypeDetails(AuthenticationType authenticationType) { Optional<AuthenticationTypeEntity> authenticationTypeEntity = authenticationTypeRepository.findById(authenticationType.getId()); return authenticationTypeEntity.map(entity -> new AuthenticationTypeDetails(entity.getId(), entity.getName())); } @Autowired DefaultAuthenticationTypeAccessor(AuthenticationTypeRepository authenticationTypeRepository); @Override Optional<AuthenticationTypeDetails> getAuthenticationTypeDetails(AuthenticationType authenticationType); @Override Optional<AuthenticationType> getAuthenticationType(Long id); }### Answer: @Test public void getAuthenticationTypeDetailsTest() { AuthenticationTypeRepository authenticationTypeRepository = Mockito.mock(AuthenticationTypeRepository.class); DefaultAuthenticationTypeAccessor authenticationTypeAccessor = new DefaultAuthenticationTypeAccessor(authenticationTypeRepository); AuthenticationTypeEntity authenticationTypeEntity = new AuthenticationTypeEntity("name-test"); Mockito.when(authenticationTypeRepository.findById(Mockito.any())).thenReturn(Optional.of(authenticationTypeEntity)); Optional<AuthenticationTypeDetails> testAuthenticationTypeDetails = authenticationTypeAccessor.getAuthenticationTypeDetails(AuthenticationType.DATABASE); assertTrue(testAuthenticationTypeDetails.isPresent()); AuthenticationTypeDetails authenticationTypeDetails = testAuthenticationTypeDetails.get(); assertEquals(authenticationTypeEntity.getName(), authenticationTypeDetails.getName()); assertEquals(authenticationTypeEntity.getId(), authenticationTypeDetails.getId()); } @Test public void getAuthenticationTypeDetailsNullTest() { AuthenticationTypeRepository authenticationTypeRepository = Mockito.mock(AuthenticationTypeRepository.class); DefaultAuthenticationTypeAccessor authenticationTypeAccessor = new DefaultAuthenticationTypeAccessor(authenticationTypeRepository); Mockito.when(authenticationTypeRepository.findById(Mockito.any())).thenReturn(Optional.empty()); Optional<AuthenticationTypeDetails> testAuthenticationTypeDetails = authenticationTypeAccessor.getAuthenticationTypeDetails(AuthenticationType.DATABASE); assertFalse(testAuthenticationTypeDetails.isPresent()); }
### Question: DefaultAuthenticationTypeAccessor implements AuthenticationTypeAccessor { @Override public Optional<AuthenticationType> getAuthenticationType(Long id) { return AuthenticationType.getById(id); } @Autowired DefaultAuthenticationTypeAccessor(AuthenticationTypeRepository authenticationTypeRepository); @Override Optional<AuthenticationTypeDetails> getAuthenticationTypeDetails(AuthenticationType authenticationType); @Override Optional<AuthenticationType> getAuthenticationType(Long id); }### Answer: @Test public void getAuthenticationTypeTest() { AuthenticationTypeRepository authenticationTypeRepository = Mockito.mock(AuthenticationTypeRepository.class); DefaultAuthenticationTypeAccessor authenticationTypeAccessor = new DefaultAuthenticationTypeAccessor(authenticationTypeRepository); assertEquals(AuthenticationType.DATABASE, authenticationTypeAccessor.getAuthenticationType(1L).get()); assertEquals(AuthenticationType.LDAP, authenticationTypeAccessor.getAuthenticationType(2L).get()); assertEquals(AuthenticationType.SAML, authenticationTypeAccessor.getAuthenticationType(3L).get()); assertFalse(authenticationTypeAccessor.getAuthenticationType(5L).isPresent()); }
### Question: DefaultProviderTaskPropertiesAccessor implements ProviderTaskPropertiesAccessor { @Override public Optional<String> getTaskProperty(String taskName, String propertyKey) { if (StringUtils.isBlank(taskName) \|\| StringUtils.isBlank(propertyKey)) { return Optional.empty(); } return providerTaskPropertiesRepository.findByTaskNameAndPropertyName(taskName, propertyKey).map(ProviderTaskPropertiesEntity::getValue); } @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 getTaskPropertyTest() { DefaultProviderTaskPropertiesAccessor providerTaskPropertiesAccessor = new DefaultProviderTaskPropertiesAccessor(providerTaskPropertiesRepository); Optional<String> taskPropertyValue = providerTaskPropertiesAccessor.getTaskProperty(taskName, propertyName); assertTrue(taskPropertyValue.isPresent()); assertEquals(value, taskPropertyValue.get()); } @Test public void getTaskPropertyEmptyTest() { DefaultProviderTaskPropertiesAccessor providerTaskPropertiesAccessor = new DefaultProviderTaskPropertiesAccessor(providerTaskPropertiesRepository); Optional<String> taskPropertyOptionalEmpty = providerTaskPropertiesAccessor.getTaskProperty("invalidTaskName", "invalidPropertyKey"); Optional<String> taskPropertyValueEmpty = providerTaskPropertiesAccessor.getTaskProperty("", ""); assertFalse(taskPropertyOptionalEmpty.isPresent()); assertFalse(taskPropertyValueEmpty.isPresent()); }
### Question: linkedList { public linkedList() { start = null; end = null; size = 0; } linkedList(); boolean isEmpty(); int getSize(); void insertAtStart(int val); void insertAtEnd(int val); void insertAtPos(int val , int pos); void deleteAtPos(int pos); void display(); public int size; }### Answer: @Test public void testLinkedList(){ LinkedList<Integer> intList = new LinkedList<Integer>(); assertTrue(intList.add(1)); assertTrue(intList.add(2)); assertEquals(new Integer(1), intList.head()); assertEquals(new Integer(2), intList.tail()); assertTrue(intList.add(3)); assertEquals(new Integer(3), intList.tail()); assertEquals(3, intList.size()); assertFalse(intList.add(null)); assertTrue(intList.remove(new Integer(3))); assertFalse(intList.contains(new Integer(3))); assertEquals(2, intList.size()); assertTrue(intList.contains(new Integer(2))); assertFalse(intList.remove(new Integer(3))); }
### Question: DatabaseConnectionDialog { public void registerClass( String key, String className ) { extendedClasses.put( key, className ); } DatabaseConnectionDialog(); void registerClass( String key, String className ); XulDomContainer getSwtInstance( Shell shell ); XulDomContainer getSwtInstance( SwtXulLoader loader, Shell shell ); static final String DIALOG_DEFINITION_FILE; }### Answer: @Test public void testRegisterClass() throws Exception { assertTrue( dialog.extendedClasses.isEmpty() ); dialog.registerClass( "MyClass", "org.pentaho.test.MyClass" ); assertFalse( dialog.extendedClasses.isEmpty() ); assertEquals( "org.pentaho.test.MyClass", dialog.extendedClasses.get( "MyClass" ) ); }
### Question: Utils { public static String resolvePassword( VariableSpace variables, String password ) { String resolvedPassword = variables.environmentSubstitute( password ); if ( resolvedPassword != null ) { return Encr.decryptPasswordOptionallyEncrypted( resolvedPassword ); } else { return resolvedPassword; } } static int getDamerauLevenshteinDistance( String s, String t ); static boolean isEmpty( CharSequence val ); static boolean isEmpty( CharSequence[] strings ); static boolean isEmpty( Object[] array ); static boolean isEmpty( List<?> list ); static String resolvePassword( VariableSpace variables, String password ); static String[][] normalizeArrays( int normalizeToLength, String[]... arraysToNormalize ); static long[][] normalizeArrays( int normalizeToLength, long[]... arraysToNormalize ); static int[][] normalizeArrays( int normalizeToLength, int[]... arraysToNormalize ); static boolean[][] normalizeArrays( int normalizeToLength, boolean[]... arraysToNormalize ); static short[][] normalizeArrays( int normalizeToLength, short[]... arraysToNormalize ); }### Answer: @Test public void testResolvePassword() { String password = "password"; assertSame( password, Utils.resolvePassword( Variables.getADefaultVariableSpace(), password ).intern() ); } @Test public void testResolvePasswordEncrypted() { String decPassword = "password"; String encPassword = "Encrypted 2be98afc86aa7f2e4bb18bd63c99dbdde"; assertSame( decPassword, Utils.resolvePassword( Variables.getADefaultVariableSpace(), encPassword ).intern() ); } @Test public void testResolvePasswordNull() { String password = null; assertSame( password, Utils.resolvePassword( Variables.getADefaultVariableSpace(), password ) ); } @Test public void testResolvePasswordVariable() { String passwordKey = "PASS_VAR"; String passwordVar = "${" + passwordKey + "}"; String passwordValue = "password"; Variables vars = new Variables(); vars.setVariable( passwordKey, passwordValue ); assertSame( passwordValue, Utils.resolvePassword( vars, passwordVar ).intern() ); }
### Question: SessionConfigurator extends ClientEndpointConfig.Configurator { @Override public void beforeRequest( Map<String, List<String>> headers ) { if ( withAuth ) { Header authenticationHeader = getAuthenticationHeader( url ); if ( authenticationHeader != null ) { headers .put( authenticationHeader.getName(), Collections.singletonList( authenticationHeader.getValue() ) ); } } } SessionConfigurator( URI url, String keytab, String principal ); @Override void beforeRequest( Map<String, List<String>> headers ); @Override void afterResponse( HandshakeResponse hr ); }### Answer: @Test public void testNoAuthentication() throws URISyntaxException { sessionConfigurator = new SessionConfigurator( new URI( "ws: sessionConfigurator.beforeRequest( headers ); verify( headers, times( 0 ) ).put( any(), any() ); } @Test public void testPrincipal() throws URISyntaxException, RuntimeException { sessionConfigurator = new SessionConfigurator( new URI( "ws: expectedException.expect( RuntimeException.class ); sessionConfigurator.beforeRequest( headers ); } @Test public void testPrincipalKeytab() throws URISyntaxException, RuntimeException { sessionConfigurator = new SessionConfigurator( new URI( "ws: expectedException.expect( RuntimeException.class ); sessionConfigurator.beforeRequest( headers ); }

Subsets and Splits

No saved queries yet

Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.