method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
OneToManyCategoryAlgorithmGenerator extends AbstractCategoryAlgorithmGenerator { @Override public boolean isSuitable(Attribute targetAttribute, List<Attribute> sourceAttributes) { return isXrefOrCategorialDataType(targetAttribute) && (sourceAttributes.stream().allMatch(this::isXrefOrCategorialDataType)) && sourceAttributes.size() > 1; } OneToManyCategoryAlgorithmGenerator(DataService dataService); @Override boolean isSuitable(Attribute targetAttribute, List<Attribute> sourceAttributes); @Override String generate(
Attribute targetAttribute,
List<Attribute> sourceAttributes,
EntityType targetEntityType,
EntityType sourceEntityType); String generateWeightedMap(Attribute attribute); String groupCategoryValues(Attribute attribute); }### Answer:
@Test void testIsSuitable() { assertTrue( categoryAlgorithmGenerator.isSuitable( targetAttribute, Arrays.asList(sourceAttribute, sourceAttribute1))); }
|
### Question:
OneToManyCategoryAlgorithmGenerator extends AbstractCategoryAlgorithmGenerator { public String generateWeightedMap(Attribute attribute) { StringBuilder stringBuilder = new StringBuilder(); for (Category sourceCategory : convertToCategory(attribute)) { AmountWrapper amountWrapper = sourceCategory.getAmountWrapper(); if (amountWrapper != null) { if (stringBuilder.length() == 0) { stringBuilder.append("$('").append(attribute.getName()).append("').map({"); } Amount<?> amount = amountWrapper.getAmount(); if (amount == null) { throw new IllegalArgumentException("Amount wrapper amount can't be null"); } double estimatedValue = amount.getEstimatedValue(); stringBuilder .append("\"") .append(sourceCategory.getCode()) .append("\":") .append(DECIMAL_FORMAT.format(estimatedValue)) .append(","); } } if (stringBuilder.length() > 0) { stringBuilder.deleteCharAt(stringBuilder.length() - 1); stringBuilder.append("}, null, null).value()"); } return stringBuilder.toString(); } OneToManyCategoryAlgorithmGenerator(DataService dataService); @Override boolean isSuitable(Attribute targetAttribute, List<Attribute> sourceAttributes); @Override String generate(
Attribute targetAttribute,
List<Attribute> sourceAttributes,
EntityType targetEntityType,
EntityType sourceEntityType); String generateWeightedMap(Attribute attribute); String groupCategoryValues(Attribute attribute); }### Answer:
@Test void testGenerateWeightedMap() { String expected = "$('MESHED_POTATO').map({\"1\":0,\"2\":0.2,\"3\":0.6,\"4\":1,\"5\":2.5,\"6\":4.5,\"7\":6.5}, null, null).value()"; String actual = categoryAlgorithmGenerator.generateWeightedMap(sourceAttribute); assertEquals(expected, actual); }
|
### Question:
OneToManyCategoryAlgorithmGenerator extends AbstractCategoryAlgorithmGenerator { boolean suitableForGeneratingWeightedMap( Attribute targetAttribute, List<Attribute> sourceAttributes) { boolean isTargetSuitable = oneToOneCategoryAlgorithmGenerator.isFrequencyCategory(convertToCategory(targetAttribute)); boolean areSourcesSuitable = sourceAttributes.stream() .map(this::convertToCategory) .allMatch(oneToOneCategoryAlgorithmGenerator::isFrequencyCategory); return isTargetSuitable && areSourcesSuitable; } OneToManyCategoryAlgorithmGenerator(DataService dataService); @Override boolean isSuitable(Attribute targetAttribute, List<Attribute> sourceAttributes); @Override String generate(
Attribute targetAttribute,
List<Attribute> sourceAttributes,
EntityType targetEntityType,
EntityType sourceEntityType); String generateWeightedMap(Attribute attribute); String groupCategoryValues(Attribute attribute); }### Answer:
@Test void testSuitableForGeneratingWeightedMap() { assertTrue( categoryAlgorithmGenerator.suitableForGeneratingWeightedMap( targetAttribute, Arrays.asList(sourceAttribute, sourceAttribute1))); assertFalse( categoryAlgorithmGenerator.suitableForGeneratingWeightedMap( targetAttribute, Arrays.asList(sourceAttribute, sourceAttribute1, sourceAttribute2))); }
|
### Question:
OneToManyCategoryAlgorithmGenerator extends AbstractCategoryAlgorithmGenerator { String createAlgorithmNullCheckIfStatement(List<Attribute> sourceAttributes) { StringBuilder stringBuilder = new StringBuilder(); if (!sourceAttributes.isEmpty()) { stringBuilder.append("var SUM_WEIGHT;\n").append("if("); sourceAttributes.stream() .forEach( attribute -> stringBuilder .append("$('") .append(attribute.getName()) .append("').isNull().value() && ")); stringBuilder.delete(stringBuilder.length() - 4, stringBuilder.length()); stringBuilder .append("){\n") .append("\tSUM_WEIGHT = new newValue();\n") .append("\tSUM_WEIGHT.value();\n}"); } return stringBuilder.toString(); } OneToManyCategoryAlgorithmGenerator(DataService dataService); @Override boolean isSuitable(Attribute targetAttribute, List<Attribute> sourceAttributes); @Override String generate(
Attribute targetAttribute,
List<Attribute> sourceAttributes,
EntityType targetEntityType,
EntityType sourceEntityType); String generateWeightedMap(Attribute attribute); String groupCategoryValues(Attribute attribute); }### Answer:
@Test void testCreateAlgorithmNullCheck() { String actual = "var SUM_WEIGHT;\nif($('MESHED_POTATO_1').isNull().value() && $('MESHED_POTATO').isNull().value() && $('Stroke').isNull().value()){\n\tSUM_WEIGHT = new newValue();\n\tSUM_WEIGHT.value();\n}"; String createAlgorithmNullCheck = categoryAlgorithmGenerator.createAlgorithmNullCheckIfStatement( Arrays.asList(sourceAttribute1, sourceAttribute, sourceAttribute2)); assertEquals(actual, createAlgorithmNullCheck); }
|
### Question:
InternalAbstractCategoryRule implements CategoryRule { @Override public CategoryMatchQuality<Double> createCategoryMatchQuality( Category targetCategory, Category sourceCategory) { String matchedTermForTargetLabel = getMatchedTermFromTheRulelabelContainsWords(targetCategory.getLabel()); String matchedTermForSourceLabel = getMatchedTermFromTheRulelabelContainsWords(sourceCategory.getLabel()); boolean ruleApplied = StringUtils.isNotBlank(matchedTermForTargetLabel) && StringUtils.isNotBlank(matchedTermForSourceLabel); Quality<Double> quality = NumericQuality.create( createNumericQualityIndicator(matchedTermForTargetLabel, matchedTermForSourceLabel)); return CategoryMatchQuality.create(ruleApplied, quality, targetCategory, sourceCategory); } InternalAbstractCategoryRule(Set<String> words); @Override CategoryMatchQuality<Double> createCategoryMatchQuality(
Category targetCategory, Category sourceCategory); }### Answer:
@Test void testCreateNumericQualityIndicatorDoesNotThrowNPE() { InternalAbstractCategoryRule rule = new NegativeCategoryRule(); Category target = mock(Category.class); when(target.getLabel()).thenReturn("label1"); Category source = mock(Category.class); when(source.getLabel()).thenReturn("label2"); rule.createCategoryMatchQuality(target, source); }
|
### Question:
TagWizardController extends PluginController { public TagWizardController( DataService dataService, OntologyService ontologyService, OntologyTagService ontologyTagService, SemanticSearchService semanticSearchService) { super(URI); this.dataService = requireNonNull(dataService); this.ontologyService = requireNonNull(ontologyService); this.ontologyTagService = requireNonNull(ontologyTagService); this.semanticSearchService = requireNonNull(semanticSearchService); } TagWizardController(
DataService dataService,
OntologyService ontologyService,
OntologyTagService ontologyTagService,
SemanticSearchService semanticSearchService); @GetMapping String viewTagWizard(
@RequestParam(required = false, value = "selectedTarget") String target, Model model); @PostMapping("/tagattribute") @ResponseBody OntologyTag addTagAttribute(@Valid @RequestBody AddTagRequest request); @PostMapping("/deletesingletag") @ResponseBody void deleteSingleTag(@Valid @RequestBody RemoveTagRequest request); @PostMapping("/clearalltags") @ResponseBody void clearAllTags(@RequestParam String entityTypeId); @PostMapping("/autotagattributes") @ResponseBody Map<String, OntologyTag> autoTagAttributes(
@Valid @RequestBody AutoTagRequest request); @PostMapping("/getontologyterms") @ResponseBody List<OntologyTerm> getAllOntologyTerms(
@Valid @RequestBody GetOntologyTermRequest request); @ExceptionHandler(RuntimeException.class) @ResponseBody @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR) ErrorMessageResponse handleRuntimeException(RuntimeException e); static final String ID; static final String URI; }### Answer:
@Test void testTagWizardController() { assertThrows(NullPointerException.class, () -> new TagWizardController(null, null, null, null)); }
|
### Question:
MappingTargetRepositoryImpl implements MappingTargetRepository { @Override public List<MappingTarget> toMappingTargets(List<Entity> mappingTargetEntities) { return mappingTargetEntities.stream().map(this::toMappingTarget).collect(Collectors.toList()); } MappingTargetRepositoryImpl(EntityMappingRepository entityMappingRepository); @Override List<Entity> upsert(Collection<MappingTarget> collection); @Override List<MappingTarget> toMappingTargets(List<Entity> mappingTargetEntities); }### Answer:
@Test void testToMappingTargets() { when(dataService.getEntityType("target")).thenReturn(targetEntityType); when(entityMappingRepository.toEntityMappings(entityMappingEntities)) .thenReturn(entityMappings); when(dataService.hasRepository("target")).thenReturn(true); assertEquals(mappingTargets, mappingTargetRepository.toMappingTargets(mappingTargetEntities)); }
|
### Question:
PackageUtils { public static boolean contains(Package pack, Package wantedPackage) { return new PackageTreeTraverser() .postOrderTraversal(pack) .anyMatch(childPackage -> Objects.equals(childPackage, wantedPackage)); } private PackageUtils(); static boolean isSystemPackage(@Nullable @CheckForNull Package aPackage); static boolean contains(Package pack, Package wantedPackage); }### Answer:
@Test void testContains() { Package packageA = mock(Package.class); Package packageAa = mock(Package.class); Package packageAb = mock(Package.class); Package packageAba = mock(Package.class); Package packageC = mock(Package.class); when(packageA.getChildren()).thenReturn(asList(packageAa, packageAb, packageC)); when(packageAb.getChildren()).thenReturn(singletonList(packageAba)); assertTrue(PackageUtils.contains(packageA, packageAba)); }
@Test void testNotContains() { Package packageA = mock(Package.class); Package packageAa = mock(Package.class); Package packageAb = mock(Package.class); Package packageAba = mock(Package.class); Package packageC = mock(Package.class); when(packageA.getChildren()).thenReturn(asList(packageAa, packageAb, packageC)); when(packageAb.getChildren()).thenReturn(singletonList(packageAba)); assertFalse(PackageUtils.contains(packageA, mock(Package.class))); }
@Test void testContainsIsItself() { Package packageA = mock(Package.class); assertTrue(PackageUtils.contains(packageA, packageA)); }
|
### Question:
MappingTargetRepositoryImpl implements MappingTargetRepository { @Override public List<Entity> upsert(Collection<MappingTarget> collection) { return collection.stream().map(this::upsert).collect(Collectors.toList()); } MappingTargetRepositoryImpl(EntityMappingRepository entityMappingRepository); @Override List<Entity> upsert(Collection<MappingTarget> collection); @Override List<MappingTarget> toMappingTargets(List<Entity> mappingTargetEntities); }### Answer:
@Test void testUpdate() { when(entityMappingRepository.upsert(entityMappings)).thenReturn(entityMappingEntities); List<Entity> result = mappingTargetRepository.upsert(mappingTargets); assertEquals(result.size(), mappingTargetEntities.size()); for (int i = 0; i < mappingTargetEntities.size(); ++i) { assertTrue(EntityUtils.equals(mappingTargetEntities.get(i), result.get(i))); } }
@Test void testInsert() { mappingTargets.get(0).setIdentifier(null); when(idGenerator.generateId()).thenReturn("mappingTargetID"); when(entityMappingRepository.upsert(entityMappings)).thenReturn(entityMappingEntities); List<Entity> result = mappingTargetRepository.upsert(mappingTargets); assertEquals(result.size(), mappingTargetEntities.size()); for (int i = 0; i < mappingTargetEntities.size(); ++i) { assertTrue(EntityUtils.equals(mappingTargetEntities.get(i), result.get(i))); } }
|
### Question:
MappingProjectRepositoryImpl implements MappingProjectRepository { @Override @Transactional public void add(MappingProject mappingProject) { if (mappingProject.getIdentifier() != null) { throw new MolgenisDataException("MappingProject already exists"); } dataService.add(MAPPING_PROJECT, toEntity(mappingProject)); } MappingProjectRepositoryImpl(
DataService dataService,
MappingTargetRepository mappingTargetRepo,
IdGenerator idGenerator,
MappingProjectMetadata mappingProjectMeta); @Override @Transactional void add(MappingProject mappingProject); @Override @Transactional void update(MappingProject mappingProject); @Override MappingProject getMappingProject(String identifier); @Override List<MappingProject> getAllMappingProjects(); @Override List<MappingProject> getMappingProjects(Query<Entity> q); @Override void delete(String mappingProjectId); }### Answer:
@Test void testAdd() { when(idGenerator.generateId()).thenReturn("mappingProjectID"); when(mappingTargetRepository.upsert(asList(mappingTarget1, mappingTarget2))) .thenReturn(mappingTargetEntities); mappingProjectRepositoryImpl.add(mappingProject); ArgumentCaptor<DynamicEntity> argumentCaptor = ArgumentCaptor.forClass(DynamicEntity.class); Mockito.verify(dataService).add(eq(MAPPING_PROJECT), argumentCaptor.capture()); assertEquals("mappingProjectID", argumentCaptor.getValue().getString(IDENTIFIER)); assertNull(mappingTarget1.getIdentifier()); assertNull(mappingTarget2.getIdentifier()); }
@Test void testAddWithIdentifier() { MappingProject mappingProject = new MappingProject("My first mapping project", 3); mappingProject.setIdentifier("mappingProjectID"); try { mappingProjectRepositoryImpl.add(mappingProject); } catch (MolgenisDataException mde) { assertEquals("MappingProject already exists", mde.getMessage()); } }
|
### Question:
MappingProjectRepositoryImpl implements MappingProjectRepository { @Override public void delete(String mappingProjectId) { dataService.deleteById(MAPPING_PROJECT, mappingProjectId); } MappingProjectRepositoryImpl(
DataService dataService,
MappingTargetRepository mappingTargetRepo,
IdGenerator idGenerator,
MappingProjectMetadata mappingProjectMeta); @Override @Transactional void add(MappingProject mappingProject); @Override @Transactional void update(MappingProject mappingProject); @Override MappingProject getMappingProject(String identifier); @Override List<MappingProject> getAllMappingProjects(); @Override List<MappingProject> getMappingProjects(Query<Entity> q); @Override void delete(String mappingProjectId); }### Answer:
@Test void testDelete() { mappingProjectRepositoryImpl.delete("abc"); Mockito.verify(dataService).deleteById(MAPPING_PROJECT, "abc"); }
|
### Question:
MappingProjectRepositoryImpl implements MappingProjectRepository { @Override public List<MappingProject> getMappingProjects(Query<Entity> q) { List<MappingProject> results = new ArrayList<>(); dataService .findAll(MAPPING_PROJECT, q) .forEach(entity -> results.add(toMappingProject(entity))); return results; } MappingProjectRepositoryImpl(
DataService dataService,
MappingTargetRepository mappingTargetRepo,
IdGenerator idGenerator,
MappingProjectMetadata mappingProjectMeta); @Override @Transactional void add(MappingProject mappingProject); @Override @Transactional void update(MappingProject mappingProject); @Override MappingProject getMappingProject(String identifier); @Override List<MappingProject> getAllMappingProjects(); @Override List<MappingProject> getMappingProjects(Query<Entity> q); @Override void delete(String mappingProjectId); }### Answer:
@Test void testQuery() { Query<Entity> q = new QueryImpl<>(); when(dataService.findAll(MAPPING_PROJECT, q)).thenReturn(Stream.of(mappingProjectEntity)); when(mappingTargetRepository.toMappingTargets(mappingTargetEntities)) .thenReturn(asList(mappingTarget1, mappingTarget2)); List<MappingProject> result = mappingProjectRepositoryImpl.getMappingProjects(q); mappingProject.setIdentifier("mappingProjectID"); assertEquals(singletonList(mappingProject), result); }
|
### Question:
MappingProjectRepositoryImpl implements MappingProjectRepository { @Override public List<MappingProject> getAllMappingProjects() { List<MappingProject> results = new ArrayList<>(); dataService.findAll(MAPPING_PROJECT).forEach(entity -> results.add(toMappingProject(entity))); return results; } MappingProjectRepositoryImpl(
DataService dataService,
MappingTargetRepository mappingTargetRepo,
IdGenerator idGenerator,
MappingProjectMetadata mappingProjectMeta); @Override @Transactional void add(MappingProject mappingProject); @Override @Transactional void update(MappingProject mappingProject); @Override MappingProject getMappingProject(String identifier); @Override List<MappingProject> getAllMappingProjects(); @Override List<MappingProject> getMappingProjects(Query<Entity> q); @Override void delete(String mappingProjectId); }### Answer:
@Test void testFindAll() { when(dataService.findAll(MAPPING_PROJECT)).thenReturn(Stream.of(mappingProjectEntity)); when(mappingTargetRepository.toMappingTargets(mappingTargetEntities)) .thenReturn(asList(mappingTarget1, mappingTarget2)); List<MappingProject> result = mappingProjectRepositoryImpl.getAllMappingProjects(); mappingProject.setIdentifier("mappingProjectID"); assertEquals(singletonList(mappingProject), result); }
|
### Question:
MappingProjectRepositoryImpl implements MappingProjectRepository { @Override @Transactional public void update(MappingProject mappingProject) { MappingProject existing = getMappingProject(mappingProject.getIdentifier()); if (existing == null) { throw new MolgenisDataException("MappingProject does not exist"); } Entity mappingProjectEntity = toEntity(mappingProject); dataService.update(MAPPING_PROJECT, mappingProjectEntity); } MappingProjectRepositoryImpl(
DataService dataService,
MappingTargetRepository mappingTargetRepo,
IdGenerator idGenerator,
MappingProjectMetadata mappingProjectMeta); @Override @Transactional void add(MappingProject mappingProject); @Override @Transactional void update(MappingProject mappingProject); @Override MappingProject getMappingProject(String identifier); @Override List<MappingProject> getAllMappingProjects(); @Override List<MappingProject> getMappingProjects(Query<Entity> q); @Override void delete(String mappingProjectId); }### Answer:
@Test void testUpdateUnknown() { mappingProject.setIdentifier("mappingProjectID"); when(dataService.findOneById(TAG, "mappingProjectID")).thenReturn(null); try { mappingProjectRepositoryImpl.update(mappingProject); fail("Expected exception"); } catch (MolgenisDataException expected) { assertEquals("MappingProject does not exist", expected.getMessage()); } }
|
### Question:
UnitHelper { public static String superscriptToNumber(String str) { str = str.replace("⁰", "0"); str = str.replace("¹", "1"); str = str.replace("²", "2"); str = str.replace("³", "3"); str = str.replace("⁴", "4"); str = str.replace("⁵", "5"); str = str.replace("⁶", "6"); str = str.replace("⁷", "7"); str = str.replace("⁸", "8"); str = str.replace("⁹", "9"); return str; } private UnitHelper(); static String superscriptToNumber(String str); static String numberToSuperscript(String str); }### Answer:
@Test void superscriptToNumber() { assertEquals("598034test716222", UnitHelper.superscriptToNumber("⁵⁹⁸⁰³⁴test⁷¹⁶²²²")); }
|
### Question:
UnitHelper { public static String numberToSuperscript(String str) { str = str.replace("0", "⁰"); str = str.replace("1", "¹"); str = str.replace("2", "²"); str = str.replace("3", "³"); str = str.replace("4", "⁴"); str = str.replace("5", "⁵"); str = str.replace("6", "⁶"); str = str.replace("7", "⁷"); str = str.replace("8", "⁸"); str = str.replace("9", "⁹"); return str; } private UnitHelper(); static String superscriptToNumber(String str); static String numberToSuperscript(String str); }### Answer:
@Test void numberToSuperscript() { assertEquals("⁵⁹⁸⁰³⁴test⁷¹⁶²²²", UnitHelper.numberToSuperscript("598034test716222")); }
|
### Question:
MagmaUnitConverter { public String convertUnit(Unit<? extends Quantity> standardUnit, Unit<? extends Quantity> unit) { if (standardUnit != null && unit != null) { StringBuilder conversionScript = new StringBuilder(); for (String standardUnitName : findCompositeUnitNames(standardUnit.toString())) { for (String customeUnitName : findCompositeUnitNames(unit.toString())) { Unit<?> unit1 = Unit.valueOf(standardUnitName); Unit<?> unit2 = Unit.valueOf(customeUnitName); if (unit1 != null && unit2 != null && unit1.isCompatible(unit2) && !unit1.equals(unit2)) { Amount<?> value2 = Amount.valueOf(1, unit2); Amount<?> value1 = value2.to(unit1); double estimatedValue1 = value1.getEstimatedValue(); double estimatedValue2 = value2.getEstimatedValue(); if (estimatedValue1 > estimatedValue2) { conversionScript .append(".times(") .append(value1.divide(value2).getEstimatedValue()) .append(")"); } else { conversionScript .append(".div(") .append(value2.divide(value1).getEstimatedValue()) .append(")"); } } if (conversionScript.length() > 0) { return conversionScript.toString(); } } } } return StringUtils.EMPTY; } String convertUnit(Unit<? extends Quantity> standardUnit, Unit<? extends Quantity> unit); }### Answer:
@Test void convertUnit() { assertEquals(".div(1000.0)", unitConverter.convertUnit(valueOf("kg"), valueOf("g"))); assertEquals(".div(100.0)", unitConverter.convertUnit(valueOf("m"), valueOf("cm"))); assertEquals(".div(1000.0)", unitConverter.convertUnit(valueOf("kg/m²"), valueOf("g"))); assertEquals(".div(100.0)", unitConverter.convertUnit(valueOf("kg/m²"), valueOf("cm"))); }
|
### Question:
MagmaUnitConverter { Set<String> findCompositeUnitNames(String unitName) { Set<String> newUnitNames = new HashSet<>(); if (StringUtils.isNotBlank(unitName)) { newUnitNames.add(unitName); if (unitName.contains("/")) { newUnitNames.addAll( Arrays.asList(unitName.split("/")).stream() .map(UnitHelper::superscriptToNumber) .map(unit -> unit.replaceAll("\\d+", "")) .collect(Collectors.toSet())); } } return newUnitNames; } String convertUnit(Unit<? extends Quantity> standardUnit, Unit<? extends Quantity> unit); }### Answer:
@Test void findCompositeUnitNames() { Set<String> findCompositeUnitNames = unitConverter.findCompositeUnitNames("kg/m²"); assertTrue(Sets.newHashSet("kg", "m", "kg/m²").containsAll(findCompositeUnitNames)); }
|
### Question:
EntityMapping { public void addAttributeMapping(AttributeMapping attributeMapping) { String targetAttributeName = attributeMapping.getTargetAttributeName(); if (attributeMappings.containsKey(targetAttributeName)) { throw new IllegalStateException( "AttributeMapping already exists for target attribute " + targetAttributeName); } attributeMappings.put(targetAttributeName, attributeMapping); } EntityMapping(EntityType source, EntityType target); EntityMapping(
String identifier,
EntityType sourceEntityType,
EntityType targetEntityType,
List<AttributeMapping> attributeMappings); String getIdentifier(); void setIdentifier(String identifier); void removeIdentifiers(); String getName(); String getLabel(); EntityType getSourceEntityType(); EntityType getTargetEntityType(); Collection<AttributeMapping> getAttributeMappings(); AttributeMapping getAttributeMapping(String name); Stream<String> getMissingTargetAttributeNames(); void addAttributeMapping(AttributeMapping attributeMapping); AttributeMapping addAttributeMapping(String targetAttributeName); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); void deleteAttributeMapping(String attribute); }### Answer:
@Test void testAddAttributeMapping() { AttributeMapping attributeMapping = mock(AttributeMapping.class); String targetAttributeName = "MyTargetAttributeName"; when(attributeMapping.getTargetAttributeName()).thenReturn(targetAttributeName); entityMapping.addAttributeMapping(attributeMapping); assertEquals( singletonList(attributeMapping), new ArrayList<>(entityMapping.getAttributeMappings())); }
@Test void testAddAttributeMappingAlreadyExists() { AttributeMapping attributeMapping = mock(AttributeMapping.class); String targetAttributeName = "MyTargetAttributeName"; when(attributeMapping.getTargetAttributeName()).thenReturn(targetAttributeName); entityMapping.addAttributeMapping(attributeMapping); assertThrows( IllegalStateException.class, () -> entityMapping.addAttributeMapping(attributeMapping)); }
|
### Question:
AttributeMapping { public static AttributeMapping createCopy(AttributeMapping attributeMapping) { return new AttributeMapping( attributeMapping.getIdentifier(), attributeMapping.getTargetAttributeName(), attributeMapping.getTargetAttribute(), attributeMapping.getAlgorithm(), attributeMapping.getSourceAttributes(), attributeMapping.getAlgorithmState().name()); } AttributeMapping(
String identifier,
String targetAttributeName,
Attribute targetAttribute,
String algorithm,
List<Attribute> sourceAttributes); AttributeMapping(
String identifier,
String targetAttributeName,
Attribute targetAttribute,
String algorithm,
List<Attribute> sourceAttributes,
String algorithmState); AttributeMapping(Attribute target); String getIdentifier(); String getTargetAttributeName(); Attribute getTargetAttribute(); List<Attribute> getSourceAttributes(); String getAlgorithm(); AlgorithmState getAlgorithmState(); @Override int hashCode(); @Override boolean equals(Object obj); void setIdentifier(String identifier); void setAlgorithmState(AlgorithmState algorithmState); @Override String toString(); void setAlgorithm(String algorithm); static AttributeMapping createCopy(AttributeMapping attributeMapping); }### Answer:
@Test void testCreateCopy() { String identifier = "MyIdentifier"; String targetAttributeName = "MyTargetAttributeName"; Attribute targetAttribute = mock(Attribute.class); String algorithm = "MyAlgorithm"; List<Attribute> sourceAttributes = emptyList(); String algorithmState = AlgorithmState.CURATED.name(); AttributeMapping attributeMapping = new AttributeMapping( identifier, targetAttributeName, targetAttribute, algorithm, sourceAttributes, algorithmState); assertEquals(attributeMapping, createCopy(attributeMapping)); }
|
### Question:
CategoryMapping { public String getAlgorithm() { if (!isNullValueUndefined()) { return String.format( "$('%s').map(%s, %s, %s).value();", getSourceAttributeName(), gson.toJson(getMap()), gson.toJson(getDefaultValue()), gson.toJson(getNullValue())); } if (!isDefaultValueUndefined()) { return String.format( "$('%s').map(%s, %s).value();", getSourceAttributeName(), gson.toJson(getMap()), gson.toJson(getDefaultValue())); } return String.format( "$('%s').map(%s).value();", getSourceAttributeName(), gson.toJson(getMap())); } abstract String getSourceAttributeName(); abstract Map<S, T> getMap(); @Nullable @CheckForNull abstract T getDefaultValue(); abstract boolean isDefaultValueUndefined(); @Nullable @CheckForNull abstract T getNullValue(); abstract boolean isNullValueUndefined(); static CategoryMapping<S, T> create(String sourceAttributeName, Map<S, T> map); static CategoryMapping<S, T> create(
String sourceAttributeName, Map<S, T> map, T defaultValue); static CategoryMapping<S, T> create(
String sourceAttributeName, Map<S, T> map, T defaultValue, T nullValue); String getAlgorithm(); static CategoryMapping<S, T> createEmpty(String attributeName); static CategoryMapping<S, T> create(String algorithm); }### Answer:
@Test void testGetAlgorithm() { assertEquals("$('blah').map({\"Human\":\"1\",\"Orc\":\"2\"}).value();", mapping.getAlgorithm()); assertEquals( "$('blah').map({\"Human\":\"1\",\"Orc\":\"2\"}, \"3\").value();", mappingWithDefault.getAlgorithm()); assertEquals( "$('blah').map({\"Human\":\"1\",\"Orc\":\"2\"}, \"3\", \"5\").value();", mappingWithNullValue.getAlgorithm()); assertEquals( "$('blah').map({\"Human\":\"1\",\"Orc\":\"2\"}, \"3\", null).value();", mappingWithNullValueEqualsNull.getAlgorithm()); }
|
### Question:
QuestionnaireController extends PluginController { @ResponseBody @GetMapping(value = "/list") public List<QuestionnaireResponse> getQuestionnaires() { return questionnaireService .getQuestionnaires() .map(this::createQuestionnaireResponse) .collect(Collectors.toList()); } QuestionnaireController(
QuestionnaireService questionnaireService,
MenuReaderService menuReaderService,
AppSettings appSettings,
UserAccountService userAccountService); @GetMapping("/**") String initView(Model model); @ResponseBody @GetMapping(value = "/list") List<QuestionnaireResponse> getQuestionnaires(); @GetMapping(value = "/start/{id}") @ResponseBody QuestionnaireResponse startQuestionnaire(@PathVariable("id") String id); @ResponseBody @GetMapping("/submission-text/{id}") @SuppressWarnings("javasecurity:S5131") // id is validated in questionnaireService String getQuestionnaireSubmissionText(@PathVariable("id") String id); static final String ID; static final String URI; }### Answer:
@Test void testGetQuestionnaireList() throws Exception { EntityType questionnaire = mock(EntityType.class); when(questionnaire.getId()).thenReturn("test_quest"); when(questionnaire.getLabel("en")).thenReturn("label"); when(questionnaire.getDescription("en")).thenReturn("description"); List<EntityType> questionnaires = Arrays.asList(questionnaire); when(questionnaireService.getQuestionnaires()).thenReturn(questionnaires.stream()); MvcResult result = mockMvc .perform(get(QuestionnaireController.URI + "/list")) .andExpect(status().isOk()) .andReturn(); String actual = result.getResponse().getContentAsString(); String expected = "[{\"id\":\"test_quest\",\"label\":\"label\",\"description\":\"description\",\"status\":\"NOT_STARTED\"}]"; assertEquals(expected, actual); }
|
### Question:
QuestionnaireController extends PluginController { @GetMapping(value = "/start/{id}") @ResponseBody public QuestionnaireResponse startQuestionnaire(@PathVariable("id") String id) { return questionnaireService.startQuestionnaire(id); } QuestionnaireController(
QuestionnaireService questionnaireService,
MenuReaderService menuReaderService,
AppSettings appSettings,
UserAccountService userAccountService); @GetMapping("/**") String initView(Model model); @ResponseBody @GetMapping(value = "/list") List<QuestionnaireResponse> getQuestionnaires(); @GetMapping(value = "/start/{id}") @ResponseBody QuestionnaireResponse startQuestionnaire(@PathVariable("id") String id); @ResponseBody @GetMapping("/submission-text/{id}") @SuppressWarnings("javasecurity:S5131") // id is validated in questionnaireService String getQuestionnaireSubmissionText(@PathVariable("id") String id); static final String ID; static final String URI; }### Answer:
@Test void testStartQuestionnaire() throws Exception { String id = "1"; QuestionnaireResponse questionnaireResponse = QuestionnaireResponse.create(id, "label", "desc", QuestionnaireStatus.NOT_STARTED); when(questionnaireService.startQuestionnaire(id)).thenReturn(questionnaireResponse); mockMvc .perform(get(QuestionnaireController.URI + "/start/" + id)) .andExpect(status().isOk()) .andExpect(jsonPath("$.id", Matchers.is(id))); verify(questionnaireService).startQuestionnaire(id); }
|
### Question:
QuestionnaireController extends PluginController { @ResponseBody @GetMapping("/submission-text/{id}") @SuppressWarnings("javasecurity:S5131") public String getQuestionnaireSubmissionText(@PathVariable("id") String id) { return questionnaireService.getQuestionnaireSubmissionText(id); } QuestionnaireController(
QuestionnaireService questionnaireService,
MenuReaderService menuReaderService,
AppSettings appSettings,
UserAccountService userAccountService); @GetMapping("/**") String initView(Model model); @ResponseBody @GetMapping(value = "/list") List<QuestionnaireResponse> getQuestionnaires(); @GetMapping(value = "/start/{id}") @ResponseBody QuestionnaireResponse startQuestionnaire(@PathVariable("id") String id); @ResponseBody @GetMapping("/submission-text/{id}") @SuppressWarnings("javasecurity:S5131") // id is validated in questionnaireService String getQuestionnaireSubmissionText(@PathVariable("id") String id); static final String ID; static final String URI; }### Answer:
@Test void testGetQuestionnaireSubmissionText() throws Exception { when(questionnaireService.getQuestionnaireSubmissionText("1")).thenReturn("thanks!"); MvcResult result = mockMvc .perform(get(QuestionnaireController.URI + "/submission-text/1")) .andExpect(status().isOk()) .andReturn(); String actual = result.getResponse().getContentAsString(); String expected = "\"thanks!\""; assertEquals(expected, actual); }
|
### Question:
EntityPager { public Integer getNextStart() { if (this.start + this.num > this.total - 1) return null; else return this.start + this.num; } EntityPager(int start, int num, long total, Iterable<T> iterable); int getStart(); int getNum(); long getTotal(); Integer getNextStart(); Integer getPrevStart(); Iterable<T> getIterable(); }### Answer:
@Test void getNextStart() { EntityPager<DynamicEntity> entityPager = new EntityPager<>(2, 5, 10, null); assertEquals(valueOf(7), entityPager.getNextStart()); }
@Test void getNextStart_limit() { EntityPager<DynamicEntity> entityPager = new EntityPager<>(2, 5, 4, null); assertNull(entityPager.getNextStart()); }
@Test void getNextStart_borderLeft() { EntityPager<DynamicEntity> entityPager = new EntityPager<>(0, 3, 10, null); assertEquals(valueOf(3), entityPager.getNextStart()); }
@Test void getNextStart_borderRight() { EntityPager<DynamicEntity> entityPager = new EntityPager<>(0, 1, 2, null); assertEquals(valueOf(1), entityPager.getNextStart()); }
|
### Question:
EntityModelWriter { void addStatementsForEntity(Model model, Resource subject, Entity entity) { for (SemanticTag<EntityType, LabeledResource, LabeledResource> tag : tagService.getTagsForEntity(entity.getEntityType())) { if (tag.getRelation() == Relation.isAssociatedWith) { LabeledResource object = tag.getObject(); model.add(subject, rdfTypePredicate, valueFactory.createIRI(object.getIri())); if (DCAT_RESOURCE.equals(object.getIri())) { model.add(subject, fdpMetadataIdentifier, createDataciteIdentifierNode(model, subject)); } if (R3D_REPOSITORY.equals(object.getIri())) { model.add(subject, r3dRepositoryIdentifier, createDataciteIdentifierNode(model, subject)); } } } } EntityModelWriter(
TagService<LabeledResource, LabeledResource> tagService, SimpleValueFactory valueFactory); Model createRdfModel(Entity objectEntity); Model createEmptyModel(); void addEntityToModel(Resource subject, Entity objectEntity, Model model); boolean isADcatResource(EntityType entityType); static final String NS_DCAT; static final String NS_FDP; static final String NS_R3D; static final String NS_DATACITE; static final String NS_DCT; static final String NS_RDF; }### Answer:
@Test void testAddStatementsForEntityType() { Model model = new LinkedHashModel(); Resource subject = valueFactory.createIRI("http: LabeledResource object = new LabeledResource("http: LabeledResource codeSystem = new LabeledResource("ex:object"); SemanticTag<EntityType, LabeledResource, LabeledResource> tag = new SemanticTag<>("tagId", entityType, isAssociatedWith, object, codeSystem); when(objectEntity.getEntityType()).thenReturn(entityType); when(tagService.getTagsForEntity(entityType)).thenReturn(List.of(tag)); writer.addStatementsForEntity(model, subject, objectEntity); Statement statement = valueFactory.createStatement( subject, TYPE, valueFactory.createIRI("http: assertEquals(singletonList(statement), newArrayList(model)); }
|
### Question:
OntologyServiceImpl implements OntologyService { @Override public List<Ontology> getOntologies() { return ontologyRepository.getOntologies().collect(toList()); } OntologyServiceImpl(
OntologyRepository ontologyRepository, OntologyTermRepository ontologyTermRepository); @Override List<Ontology> getOntologies(); @Override List<Ontology> getOntologies(List<String> ontologyIds); @Override List<String> getAllOntologiesIds(); @Override Ontology getOntology(String name); @Override OntologyTerm getOntologyTerm(String iri); @Override List<OntologyTerm> findExactOntologyTerms(
List<String> ontologyIds, Set<String> terms, int pageSize); @Override List<OntologyTerm> findOntologyTerms(
List<String> ontologyIds, Set<String> terms, int pageSize); @Override List<OntologyTerm> getChildren(OntologyTerm ontologyTerm); @Override Integer getOntologyTermDistance(OntologyTerm ontologyTerm1, OntologyTerm ontologyTerm2); }### Answer:
@Test void testGetOntologiesList() { List<String> ontologyIds = asList("id0", "id1"); Ontology ontology0 = mock(Ontology.class); Ontology ontology1 = mock(Ontology.class); when(ontologyRepository.getOntologies(ontologyIds)).thenReturn(Stream.of(ontology0, ontology1)); assertEquals(asList(ontology0, ontology1), ontologyServiceImpl.getOntologies(ontologyIds)); }
|
### Question:
OntologyServiceImpl implements OntologyService { @Override public List<OntologyTerm> findExactOntologyTerms( List<String> ontologyIds, Set<String> terms, int pageSize) { if (ontologyIds.isEmpty()) { return Collections.emptyList(); } if (null == terms || terms.isEmpty()) { return Lists.newArrayList(); } return ontologyTermRepository.findExcatOntologyTerms(ontologyIds, terms, pageSize); } OntologyServiceImpl(
OntologyRepository ontologyRepository, OntologyTermRepository ontologyTermRepository); @Override List<Ontology> getOntologies(); @Override List<Ontology> getOntologies(List<String> ontologyIds); @Override List<String> getAllOntologiesIds(); @Override Ontology getOntology(String name); @Override OntologyTerm getOntologyTerm(String iri); @Override List<OntologyTerm> findExactOntologyTerms(
List<String> ontologyIds, Set<String> terms, int pageSize); @Override List<OntologyTerm> findOntologyTerms(
List<String> ontologyIds, Set<String> terms, int pageSize); @Override List<OntologyTerm> getChildren(OntologyTerm ontologyTerm); @Override Integer getOntologyTermDistance(OntologyTerm ontologyTerm1, OntologyTerm ontologyTerm2); }### Answer:
@Test void testFindExactOntologyTerms() { List<String> ontologies = singletonList("ontology1"); Set<String> ontologyTermStrings = singleton("term1"); int pageSize = 100; List<OntologyTerm> ontologyTerms = singletonList(mock(OntologyTerm.class)); when(ontologyTermRepository.findExcatOntologyTerms(ontologies, ontologyTermStrings, pageSize)) .thenReturn(ontologyTerms); assertEquals( ontologyTerms, ontologyServiceImpl.findExactOntologyTerms(ontologies, ontologyTermStrings, pageSize)); }
|
### Question:
OntologyRepository { public Stream<Ontology> getOntologies() { return dataService.findAll(ONTOLOGY).map(OntologyRepository::toOntology); } Stream<Ontology> getOntologies(); Stream<Ontology> getOntologies(List<String> ontologyIds); Ontology getOntology(String iri); }### Answer:
@Test void testGetOntologies() { ontologyEntity = mock(org.molgenis.ontology.core.meta.Ontology.class); when(ontologyEntity.getString(ID)).thenReturn("1"); when(ontologyEntity.getString(ONTOLOGY_IRI)).thenReturn("http: when(ontologyEntity.getString(ONTOLOGY_NAME)).thenReturn("testOntology"); when(dataService.findAll(eq(ONTOLOGY))).thenReturn(Stream.of(ontologyEntity)); List<Ontology> ontologies = ontologyRepository.getOntologies().collect(toList()); assertEquals(asList(create("1", "http: }
@Test void testGetOntologiesList() { ontologyEntity = mock(org.molgenis.ontology.core.meta.Ontology.class); when(ontologyEntity.getString(ID)).thenReturn("1"); when(ontologyEntity.getString(ONTOLOGY_IRI)).thenReturn("http: when(ontologyEntity.getString(ONTOLOGY_NAME)).thenReturn("testOntology"); @SuppressWarnings("unchecked") ArgumentCaptor<Stream<Object>> idCaptor = ArgumentCaptor.forClass(Stream.class); when(dataService.findAll( eq(ONTOLOGY), idCaptor.capture(), eq(org.molgenis.ontology.core.meta.Ontology.class))) .thenReturn(Stream.of(ontologyEntity)); List<Ontology> ontologies = ontologyRepository.getOntologies(singletonList("1")).collect(toList()); assertEquals(asList(create("1", "http: assertEquals(singletonList("1"), idCaptor.getValue().collect(toList())); }
|
### Question:
OntologyRepository { public Ontology getOntology(String iri) { org.molgenis.ontology.core.meta.Ontology ontology = dataService .query(ONTOLOGY, org.molgenis.ontology.core.meta.Ontology.class) .eq(ONTOLOGY_IRI, iri) .findOne(); return toOntology(ontology); } Stream<Ontology> getOntologies(); Stream<Ontology> getOntologies(List<String> ontologyIds); Ontology getOntology(String iri); }### Answer:
@Test void testGetOntology() { ontologyEntity = mock(org.molgenis.ontology.core.meta.Ontology.class); when(ontologyEntity.getString(ID)).thenReturn("1"); when(ontologyEntity.getString(ONTOLOGY_IRI)).thenReturn("http: when(ontologyEntity.getString(ONTOLOGY_NAME)).thenReturn("testOntology"); @SuppressWarnings("unchecked") Query<org.molgenis.ontology.core.meta.Ontology> query = mock(Query.class, RETURNS_SELF); when(dataService.query(ONTOLOGY, org.molgenis.ontology.core.meta.Ontology.class)) .thenReturn(query); when(query.eq(ONTOLOGY_IRI, "http: .thenReturn(ontologyEntity); assertEquals( create("1", "http: ontologyRepository.getOntology("http: }
|
### Question:
PubMedTermFrequencyService { public PubMedTFEntity parseResponse(String response) { Matcher matcher = PATTERN_REGEX.matcher(response); if (matcher.find()) { String countString = matcher.group(1); if (StringUtils.isNotEmpty(countString)) { int occurrence = Integer.parseInt(countString); if (occurrence != 0) { double frequency = Math.abs(Math.log10((double) occurrence / TOTAL_NUMBER_PUBLICATION)); return new PubMedTFEntity(occurrence, frequency); } } } return null; } PubMedTFEntity getTermFrequency(String term); PubMedTFEntity parseResponse(String response); String httpGet(String targetURL); }### Answer:
@Test void testRegexPattern() { assertEquals( 4603, termFrequencyService .parseResponse( "<eSearchResult><Count>4603</Count><RetMax>20</RetMax><RetStart>0</RetStart><IdList>") .getOccurrence()); assertEquals( null, termFrequencyService.parseResponse( "<eSearchResult><RetMax>20</RetMax><RetStart>0</RetStart><IdList>")); assertEquals( null, termFrequencyService.parseResponse( "<eSearchResult><Count></Count><RetMax>20</RetMax><RetStart>0</RetStart><IdList>")); }
|
### Question:
EntityPager { public Integer getPrevStart() { if (this.start == 0) return null; else return this.start - this.num >= 0 ? this.start - this.num : 0; } EntityPager(int start, int num, long total, Iterable<T> iterable); int getStart(); int getNum(); long getTotal(); Integer getNextStart(); Integer getPrevStart(); Iterable<T> getIterable(); }### Answer:
@Test void getPrevStart() { EntityPager<DynamicEntity> entityPager = new EntityPager<>(8, 5, 10, null); assertEquals(valueOf(3), entityPager.getPrevStart()); }
@Test void getPrevStart_offset() { EntityPager<DynamicEntity> entityPager = new EntityPager<>(0, 3, 10, null); assertNull(entityPager.getPrevStart()); }
@Test void getPrevStart_borderLeft() { EntityPager<DynamicEntity> entityPager = new EntityPager<>(3, 3, 10, null); assertEquals(valueOf(0), entityPager.getPrevStart()); }
|
### Question:
BatchingIterable implements Iterable<T> { @Override public Iterator<T> iterator() { return new Iterator<T>() { private int index = offset; private Iterator<T> it; @Override public boolean hasNext() { boolean hasNext; if (it == null) { it = nextBatch(); hasNext = it.hasNext(); if (!hasNext) { return false; } } else { hasNext = it.hasNext(); } if (!hasNext) { it = nextBatch(); hasNext = it.hasNext(); } return hasNext; } @Override public T next() { if (!hasNext()) { throw new NoSuchElementException(); } T element = it.next(); ++index; return element; } @Override public void remove() { throw new UnsupportedOperationException(); } private Iterator<T> nextBatch() { int nextBatchSize; if (index == offset || (index - offset) % batchSize == 0) { if (limit == 0) { nextBatchSize = batchSize; } else { if (index == offset + limit) { nextBatchSize = 0; } else if (index + batchSize <= offset + limit) { nextBatchSize = batchSize; } else { nextBatchSize = offset + limit - index; } } } else { nextBatchSize = 0; } if (nextBatchSize == 0) { return Collections.emptyIterator(); } else { return getBatch(index, nextBatchSize).iterator(); } } }; } BatchingIterable(int batchSize, int offset, int limit); @Override Iterator<T> iterator(); }### Answer:
@Test void iteratorNoResults() { Iterable<Integer> iterable = new BatchingIterable<>(1000, 0, 10) { @Override protected List<Integer> getBatch(int offset, int batchSize) { return Collections.emptyList(); } }; assertFalse(iterable.iterator().hasNext()); }
|
### Question:
GenericDependencyResolver { public <A> List<A> resolve(Collection<A> items, Function<A, Set<A>> getDependencies) { List<A> result = newArrayList(); Set<A> alreadyResolved = newHashSet(); Set<A> stillToResolve = newHashSet(items); while (!stillToResolve.isEmpty()) { List<A> newlyResolved = stillToResolve.stream() .filter(item -> alreadyResolved.containsAll(getDependencies.apply(item))) .collect(Collectors.toList()); if (newlyResolved.isEmpty()) { throw new MolgenisDataException( "Could not resolve dependencies of items " + stillToResolve + ". Are there circular dependencies?"); } alreadyResolved.addAll(newlyResolved); stillToResolve.removeAll(newlyResolved); result.addAll(newlyResolved); } return result; } List<A> resolve(Collection<A> items, Function<A, Set<A>> getDependencies); Set<A> getAllDependants(
A item, Function<A, Integer> getDepth, Function<A, Set<A>> getDependants); }### Answer:
@SuppressWarnings("deprecation") @Test void testCyclicDependencies() { DependentOn d1 = new DependentOn("1"); DependentOn d2 = new DependentOn("2"); DependentOn d3 = new DependentOn("3"); d1.addDependency(d2); d2.addDependency(d3); d3.addDependency(d1); assertThrows( MolgenisDataException.class, () -> genericDependencyResolver.resolve( Sets.newHashSet(d1, d2, d3), DependentOn::getDependencies)); }
@Test void testResolveTransientDependency() { DependentOn d1 = new DependentOn("1"); DependentOn d2 = new DependentOn("2"); DependentOn d3 = new DependentOn("3"); d1.addDependency(d2); d2.addDependency(d3); assertEquals( genericDependencyResolver.resolve(newHashSet(d1, d2, d3), DependentOn::getDependencies), newArrayList(d3, d2, d1)); }
|
### Question:
QueryRule { public Object getValue() { return value; } QueryRule(); QueryRule(List<QueryRule> nestedRules); QueryRule(QueryRule copy); QueryRule(String field, Operator operator, Object value); @SuppressWarnings("unchecked") QueryRule(Operator operator, Object value); QueryRule(Operator operator, QueryRule nestedRules); QueryRule(Operator operator); QueryRule(String field, Operator equals, String value); String getField(); void setField(String field); Operator getOperator(); void setOperator(Operator operator); Object getValue(); void setValue(Object value); List<QueryRule> getNestedRules(); @Override String toString(); static QueryRule eq(String name, Object value); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test void valuesForRangeOperator() { QueryRule qr = new QueryRule("field", RANGE, Arrays.asList(10, 10)); assertEquals(asList(10, 10), qr.getValue()); }
|
### Question:
ExceptionResponseGeneratorRegistrar { public ExceptionResponseGeneratorRegistrar( ExceptionResponseGeneratorRegistry responseGeneratorRegistry) { this.responseGeneratorRegistry = requireNonNull(responseGeneratorRegistry); } ExceptionResponseGeneratorRegistrar(
ExceptionResponseGeneratorRegistry responseGeneratorRegistry); void register(ApplicationContext applicationContext); }### Answer:
@Test void testExceptionResponseGeneratorRegistrar() { assertThrows(NullPointerException.class, () -> new ExceptionResponseGeneratorRegistrar(null)); }
|
### Question:
PluginController { public String getUri() { return uri; } PluginController(String uri); String getUri(); String getId(); @SuppressWarnings("WeakerAccess") Entity getPluginSettings(); static final String PLUGIN_URI_PREFIX; }### Answer:
@Test void getUri() { String uri = PluginController.PLUGIN_URI_PREFIX + "test"; PluginController molgenisPlugin = new PluginController(uri) {}; assertEquals(uri, molgenisPlugin.getUri()); }
|
### Question:
QueryRule { public List<QueryRule> getNestedRules() { if (nestedRules == null) { return Collections.emptyList(); } return nestedRules; } QueryRule(); QueryRule(List<QueryRule> nestedRules); QueryRule(QueryRule copy); QueryRule(String field, Operator operator, Object value); @SuppressWarnings("unchecked") QueryRule(Operator operator, Object value); QueryRule(Operator operator, QueryRule nestedRules); QueryRule(Operator operator); QueryRule(String field, Operator equals, String value); String getField(); void setField(String field); Operator getOperator(); void setOperator(Operator operator); Object getValue(); void setValue(Object value); List<QueryRule> getNestedRules(); @Override String toString(); static QueryRule eq(String name, Object value); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test void equalsWithNestedRules() { QueryRule q = new QueryRule(); assertNotNull(q.getNestedRules()); assertTrue(q.getNestedRules().isEmpty()); QueryRule nested = new QueryRule("field", EQUALS, "Test"); q = new QueryRule(Operator.NOT, new QueryRule(nested)); assertEquals(1, q.getNestedRules().size()); assertEquals(q.getNestedRules().get(0), nested); }
|
### Question:
AutoValuePopulator { public void populate(Entity entity) { generateAutoDateOrDateTime(singletonList(entity), entity.getEntityType().getAttributes()); Attribute idAttr = entity.getEntityType().getIdAttribute(); if (idAttr != null && idAttr.isAuto() && entity.getIdValue() == null && (idAttr.getDataType() == STRING)) { entity.set(idAttr.getName(), idGenerator.generateId()); } } AutoValuePopulator(IdGenerator idGenerator); void populate(Entity entity); }### Answer:
@Test void populateAutoValues() { Entity entity = new DynamicEntity(entityType); autoValuePopulator.populate(entity); assertNotNull(entity.getIdValue()); assertNull(entity.getLocalDate(ATTR_DATE_AUTO_DEFAULT)); assertNull(entity.getLocalDate(ATTR_DATE_AUTO_FALSE)); assertNotNull(entity.getLocalDate(ATTR_DATE_AUTO_TRUE)); assertNull(entity.getInstant(ATTR_DATETIME_AUTO_DEFAULT)); assertNull(entity.getInstant(ATTR_DATETIME_AUTO_FALSE)); assertNotNull(entity.getInstant(ATTR_DATETIME_AUTO_TRUE)); }
|
### Question:
ExistingNullValueException extends DataConstraintViolationException { @Override public String getMessage() { return "entityTypeId:" + entityTypeId + " attributeName:" + attributeName; } ExistingNullValueException(
@Nullable @CheckForNull String entityTypeId,
@Nullable @CheckForNull String attributeName,
@Nullable @CheckForNull Throwable cause); @Override String getMessage(); }### Answer:
@Test void testGetMessage() { ExistingNullValueException ex = new ExistingNullValueException("MyEntityType", "myAttributeName", mock(Throwable.class)); assertEquals("entityTypeId:MyEntityType attributeName:myAttributeName", ex.getMessage()); }
|
### Question:
ValueReferencedException extends DataConstraintViolationException { @Override public String getMessage() { return "entityTypeId:" + entityTypeId + " attributeName:" + attributeName + " value:" + value; } ValueReferencedException(
@Nullable @CheckForNull String entityTypeId,
@Nullable @CheckForNull String attributeName,
String value,
@Nullable @CheckForNull Throwable cause); @Override String getMessage(); }### Answer:
@Test void testGetMessage() { ValueReferencedException ex = new ValueReferencedException( "MyEntityType", "myAttributeName", "myValue", mock(Throwable.class)); assertEquals( "entityTypeId:MyEntityType attributeName:myAttributeName value:myValue", ex.getMessage()); }
|
### Question:
AbstractEntityDecorator extends ForwardingObject implements Entity { @Override protected Entity delegate() { return delegateEntity; } AbstractEntityDecorator(Entity entity); @Override EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void testDelegate() { assertEquals(delegateEntity, testEntity.delegate()); }
|
### Question:
AbstractEntityDecorator extends ForwardingObject implements Entity { @Override public EntityType getEntityType() { return delegateEntity.getEntityType(); } AbstractEntityDecorator(Entity entity); @Override EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void testGetEntityType() { testEntity.getEntityType(); verify(delegateEntity).getEntityType(); }
|
### Question:
AbstractEntityDecorator extends ForwardingObject implements Entity { @Override public Iterable<String> getAttributeNames() { return delegateEntity.getAttributeNames(); } AbstractEntityDecorator(Entity entity); @Override EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void testGetAttributeNames() { testEntity.getAttributeNames(); verify(delegateEntity).getAttributeNames(); }
|
### Question:
AbstractEntityDecorator extends ForwardingObject implements Entity { @Override public Object getIdValue() { return delegateEntity.getIdValue(); } AbstractEntityDecorator(Entity entity); @Override EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void testGetIdValue() { testEntity.getIdValue(); verify(delegateEntity).getIdValue(); }
|
### Question:
AbstractEntityDecorator extends ForwardingObject implements Entity { @Override public void setIdValue(Object id) { delegateEntity.setIdValue(id); } AbstractEntityDecorator(Entity entity); @Override EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void testSetIdValue() { testEntity.setIdValue(""); verify(delegateEntity).setIdValue(""); }
|
### Question:
AbstractEntityDecorator extends ForwardingObject implements Entity { @Override public Object getLabelValue() { return delegateEntity.getLabelValue(); } AbstractEntityDecorator(Entity entity); @Override EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void testGetLabelValue() { testEntity.getLabelValue(); verify(delegateEntity).getLabelValue(); }
|
### Question:
ExceptionResponseGeneratorRegistrar { public void register(ApplicationContext applicationContext) { Map<String, ExceptionResponseGenerator> responseGeneratorMap = applicationContext.getBeansOfType(ExceptionResponseGenerator.class); responseGeneratorMap.values().forEach(this::registerResponseGenerator); } ExceptionResponseGeneratorRegistrar(
ExceptionResponseGeneratorRegistry responseGeneratorRegistry); void register(ApplicationContext applicationContext); }### Answer:
@Test void testRegister() { ExceptionResponseGenerator exceptionResponseGenerator = mock(ExceptionResponseGenerator.class); ApplicationContext applicationContext = mock(ApplicationContext.class); when(applicationContext.getBeansOfType(ExceptionResponseGenerator.class)) .thenReturn(singletonMap("exceptionResponseGenerator", exceptionResponseGenerator)); exceptionResponseGeneratorRegistrar.register(applicationContext); verify(exceptionResponseGeneratorRegistry) .registerExceptionResponseGenerator(exceptionResponseGenerator); }
|
### Question:
AbstractEntityDecorator extends ForwardingObject implements Entity { @Override public Object get(String attributeName) { return delegateEntity.get(attributeName); } AbstractEntityDecorator(Entity entity); @Override EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void testGet() { testEntity.get(""); verify(delegateEntity).get(""); }
|
### Question:
AbstractEntityDecorator extends ForwardingObject implements Entity { @Override public String getString(String attributeName) { return delegateEntity.getString(attributeName); } AbstractEntityDecorator(Entity entity); @Override EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void testGetString() { testEntity.getString(""); verify(delegateEntity).getString(""); }
|
### Question:
AbstractEntityDecorator extends ForwardingObject implements Entity { @Override public Integer getInt(String attributeName) { return delegateEntity.getInt(attributeName); } AbstractEntityDecorator(Entity entity); @Override EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void testGetInt() { testEntity.getInt(""); verify(delegateEntity).getInt(""); }
|
### Question:
AbstractEntityDecorator extends ForwardingObject implements Entity { @Override public Long getLong(String attributeName) { return delegateEntity.getLong(attributeName); } AbstractEntityDecorator(Entity entity); @Override EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void testGetLong() { testEntity.getLong(""); verify(delegateEntity).getLong(""); }
|
### Question:
AbstractEntityDecorator extends ForwardingObject implements Entity { @Override public Boolean getBoolean(String attributeName) { return delegateEntity.getBoolean(attributeName); } AbstractEntityDecorator(Entity entity); @Override EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void testGetBoolean() { testEntity.getBoolean(""); verify(delegateEntity).getBoolean(""); }
|
### Question:
AbstractEntityDecorator extends ForwardingObject implements Entity { @Override public Double getDouble(String attributeName) { return delegateEntity.getDouble(attributeName); } AbstractEntityDecorator(Entity entity); @Override EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void testGetDouble() { testEntity.getDouble(""); verify(delegateEntity).getDouble(""); }
|
### Question:
AbstractEntityDecorator extends ForwardingObject implements Entity { @Override public Instant getInstant(String attributeName) { return delegateEntity.getInstant(attributeName); } AbstractEntityDecorator(Entity entity); @Override EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void testGetInstant() { testEntity.getInstant(""); verify(delegateEntity).getInstant(""); }
|
### Question:
AbstractEntityDecorator extends ForwardingObject implements Entity { @Override public LocalDate getLocalDate(String attributeName) { return delegateEntity.getLocalDate(attributeName); } AbstractEntityDecorator(Entity entity); @Override EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void testGetLocalDate() { testEntity.getLocalDate(""); verify(delegateEntity).getLocalDate(""); }
|
### Question:
AbstractEntityDecorator extends ForwardingObject implements Entity { @Override public Entity getEntity(String attributeName) { return delegateEntity.getEntity(attributeName); } AbstractEntityDecorator(Entity entity); @Override EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void testGetEntity() { testEntity.getEntity(""); verify(delegateEntity).getEntity(""); }
@Test void testGetEntityTyped() { testEntity.getEntity("", EntityType.class); verify(delegateEntity).getEntity("", EntityType.class); }
|
### Question:
ExceptionResponseGeneratorRegistryImpl implements ExceptionResponseGeneratorRegistry { @Override public void registerExceptionResponseGenerator( ExceptionResponseGenerator exceptionResponseGenerator) { ExceptionResponseType type = exceptionResponseGenerator.getType(); if (responseGeneratorMap.containsKey(type)) { throw new IllegalArgumentException( format("Duplicate exception response generator [%s]", type)); } responseGeneratorMap.put(type, exceptionResponseGenerator); } ExceptionResponseGeneratorRegistryImpl(); @Override void registerExceptionResponseGenerator(
ExceptionResponseGenerator exceptionResponseGenerator); @Override ExceptionResponseGenerator getExceptionResponseGenerator(ExceptionResponseType type); }### Answer:
@Test void testRegisterExceptionResponseGenerator() { ExceptionResponseGenerator responseGenerator = mock(ExceptionResponseGenerator.class); when(responseGenerator.getType()).thenReturn(PROBLEM); exceptionResponseGeneratorRegistryImpl.registerExceptionResponseGenerator(responseGenerator); assertEquals( responseGenerator, exceptionResponseGeneratorRegistryImpl.getExceptionResponseGenerator(PROBLEM)); }
@Test void testRegisterExceptionResponseGeneratorAlreadyExists() { ExceptionResponseGenerator responseGenerator = mock(ExceptionResponseGenerator.class); when(responseGenerator.getType()).thenReturn(PROBLEM); exceptionResponseGeneratorRegistryImpl.registerExceptionResponseGenerator(responseGenerator); assertThrows( IllegalArgumentException.class, () -> exceptionResponseGeneratorRegistryImpl.registerExceptionResponseGenerator( responseGenerator)); }
|
### Question:
AbstractEntityDecorator extends ForwardingObject implements Entity { @Override public Iterable<Entity> getEntities(String attributeName) { return delegateEntity.getEntities(attributeName); } AbstractEntityDecorator(Entity entity); @Override EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void testGetEntities() { testEntity.getEntities(""); verify(delegateEntity).getEntities(""); }
@Test void testGetEntitiesTyped() { testEntity.getEntities("", EntityType.class); verify(delegateEntity).getEntities("", EntityType.class); }
|
### Question:
AbstractEntityDecorator extends ForwardingObject implements Entity { @Override public void set(String attributeName, Object value) { delegateEntity.set(attributeName, value); } AbstractEntityDecorator(Entity entity); @Override EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void testSet() { testEntity.set("", ""); verify(delegateEntity).set("", ""); }
@Test void testSetEntity() { Entity entity = mock(Entity.class); testEntity.set(entity); verify(delegateEntity).set(entity); }
|
### Question:
UnknownValueReferenceException extends DataConstraintViolationException { @Override public String getMessage() { return "entityTypeId:" + entityTypeId + " attributeName:" + attributeName + " value:" + value; } UnknownValueReferenceException(
@Nullable @CheckForNull String entityTypeId,
@Nullable @CheckForNull String attributeName,
String value,
@Nullable @CheckForNull Throwable cause); @Override String getMessage(); }### Answer:
@Test void testGetMessage() { UnknownValueReferenceException ex = new UnknownValueReferenceException( "MyEntityType", "myAttributeName", "myValue", mock(Throwable.class)); assertEquals( "entityTypeId:MyEntityType attributeName:myAttributeName value:myValue", ex.getMessage()); }
|
### Question:
DuplicateValueException extends DataConstraintViolationException { @Override public String getMessage() { return "entityTypeId:" + entityTypeId + " attributeName:" + attributeName + " value:" + value; } DuplicateValueException(
@Nullable @CheckForNull String entityTypeId,
@Nullable @CheckForNull String attributeName,
String value,
@Nullable @CheckForNull Throwable cause); @Override String getMessage(); }### Answer:
@Test void testGetMessage() { DuplicateValueException ex = new DuplicateValueException( "MyEntityType", "myAttributeName", "myValue", mock(Throwable.class)); assertEquals( "entityTypeId:MyEntityType attributeName:myAttributeName value:myValue", ex.getMessage()); }
|
### Question:
ValueLengthExceededException extends DataConstraintViolationException { @Override public String getMessage() { return null; } ValueLengthExceededException(@Nullable @CheckForNull Throwable cause); @Override String getMessage(); }### Answer:
@Test void testGetMessage() { ValueLengthExceededException ex = new ValueLengthExceededException(mock(Throwable.class)); assertNull(ex.getMessage()); }
|
### Question:
UnknownEnumValueException extends DataConstraintViolationException { @Override public String getMessage() { return "entityTypeId:" + entityTypeId + " attributeName:" + attributeName; } UnknownEnumValueException(
@Nullable @CheckForNull String entityTypeId,
@Nullable @CheckForNull String attributeName,
@Nullable @CheckForNull Throwable cause); @Override String getMessage(); }### Answer:
@Test void testGetMessage() { UnknownEnumValueException ex = new UnknownEnumValueException("MyEntityType", "myAttributeName", mock(Throwable.class)); assertEquals("entityTypeId:MyEntityType attributeName:myAttributeName", ex.getMessage()); }
|
### Question:
TransactionalRepositoryDecorator extends AbstractRepositoryDecorator<E> { @SuppressWarnings("ConstantConditions") @Override public long count() { if (TransactionSynchronizationManager.isSynchronizationActive()) { return delegate().count(); } else { return createReadonlyTransactionTemplate().execute(status -> delegate().count()); } } TransactionalRepositoryDecorator(
Repository<E> delegateRepository, PlatformTransactionManager transactionManager); @Override void forEachBatched(Consumer<List<E>> consumer, int batchSize); @Override void forEachBatched(Fetch fetch, Consumer<List<E>> consumer, int batchSize); @SuppressWarnings("ConstantConditions") @Override long count(); @SuppressWarnings("ConstantConditions") @Override long count(Query<E> q); @Override Stream<E> findAll(Query<E> q); @Override E findOne(Query<E> q); @Override E findOneById(Object id); @Override E findOneById(Object id, Fetch fetch); @Override Stream<E> findAll(Stream<Object> ids); @Override Stream<E> findAll(Stream<Object> ids, Fetch fetch); @Override AggregateResult aggregate(AggregateQuery aggregateQuery); @Override void update(E entity); @Override void update(Stream<E> entities); @Override void delete(E entity); @Override void delete(Stream<E> entities); @Override void deleteById(Object id); @Override void deleteAll(Stream<Object> ids); @Override void deleteAll(); @Override void add(E entity); @Override Integer add(Stream<E> entities); @SuppressWarnings({"ConstantConditions", "NullableProblems"}) @Override Iterator<E> iterator(); }### Answer:
@Test void count() { transactionalRepo.count(); verify(transactionManager).getTransaction(any(TransactionDefinition.class)); verify(delegateRepository).count(); }
@Test void countQuery() { @SuppressWarnings("unchecked") Query<Entity> query = mock(Query.class); transactionalRepo.count(query); verify(transactionManager).getTransaction(any(TransactionDefinition.class)); verify(delegateRepository).count(query); }
|
### Question:
TransactionalRepositoryDecorator extends AbstractRepositoryDecorator<E> { @Override public E findOne(Query<E> q) { if (TransactionSynchronizationManager.isSynchronizationActive()) { return delegate().findOne(q); } else { return createReadonlyTransactionTemplate().execute(status -> delegate().findOne(q)); } } TransactionalRepositoryDecorator(
Repository<E> delegateRepository, PlatformTransactionManager transactionManager); @Override void forEachBatched(Consumer<List<E>> consumer, int batchSize); @Override void forEachBatched(Fetch fetch, Consumer<List<E>> consumer, int batchSize); @SuppressWarnings("ConstantConditions") @Override long count(); @SuppressWarnings("ConstantConditions") @Override long count(Query<E> q); @Override Stream<E> findAll(Query<E> q); @Override E findOne(Query<E> q); @Override E findOneById(Object id); @Override E findOneById(Object id, Fetch fetch); @Override Stream<E> findAll(Stream<Object> ids); @Override Stream<E> findAll(Stream<Object> ids, Fetch fetch); @Override AggregateResult aggregate(AggregateQuery aggregateQuery); @Override void update(E entity); @Override void update(Stream<E> entities); @Override void delete(E entity); @Override void delete(Stream<E> entities); @Override void deleteById(Object id); @Override void deleteAll(Stream<Object> ids); @Override void deleteAll(); @Override void add(E entity); @Override Integer add(Stream<E> entities); @SuppressWarnings({"ConstantConditions", "NullableProblems"}) @Override Iterator<E> iterator(); }### Answer:
@Test void findOne() { @SuppressWarnings("unchecked") Query<Entity> query = mock(Query.class); transactionalRepo.findOne(query); verify(transactionManager).getTransaction(any(TransactionDefinition.class)); verify(delegateRepository).findOne(query); }
|
### Question:
TransactionalRepositoryDecorator extends AbstractRepositoryDecorator<E> { @Override public AggregateResult aggregate(AggregateQuery aggregateQuery) { if (TransactionSynchronizationManager.isSynchronizationActive()) { return delegate().aggregate(aggregateQuery); } else { return createReadonlyTransactionTemplate() .execute(status -> delegate().aggregate(aggregateQuery)); } } TransactionalRepositoryDecorator(
Repository<E> delegateRepository, PlatformTransactionManager transactionManager); @Override void forEachBatched(Consumer<List<E>> consumer, int batchSize); @Override void forEachBatched(Fetch fetch, Consumer<List<E>> consumer, int batchSize); @SuppressWarnings("ConstantConditions") @Override long count(); @SuppressWarnings("ConstantConditions") @Override long count(Query<E> q); @Override Stream<E> findAll(Query<E> q); @Override E findOne(Query<E> q); @Override E findOneById(Object id); @Override E findOneById(Object id, Fetch fetch); @Override Stream<E> findAll(Stream<Object> ids); @Override Stream<E> findAll(Stream<Object> ids, Fetch fetch); @Override AggregateResult aggregate(AggregateQuery aggregateQuery); @Override void update(E entity); @Override void update(Stream<E> entities); @Override void delete(E entity); @Override void delete(Stream<E> entities); @Override void deleteById(Object id); @Override void deleteAll(Stream<Object> ids); @Override void deleteAll(); @Override void add(E entity); @Override Integer add(Stream<E> entities); @SuppressWarnings({"ConstantConditions", "NullableProblems"}) @Override Iterator<E> iterator(); }### Answer:
@Test void aggregate() { AggregateQuery aggregateQuery = mock(AggregateQuery.class); transactionalRepo.aggregate(aggregateQuery); verify(transactionManager).getTransaction(any(TransactionDefinition.class)); verify(delegateRepository).aggregate(aggregateQuery); }
|
### Question:
TransactionalRepositoryDecorator extends AbstractRepositoryDecorator<E> { @Override public void update(E entity) { if (TransactionSynchronizationManager.isSynchronizationActive()) { delegate().update(entity); } else { createWriteTransactionTemplate() .execute( status -> { delegate().update(entity); return null; }); } } TransactionalRepositoryDecorator(
Repository<E> delegateRepository, PlatformTransactionManager transactionManager); @Override void forEachBatched(Consumer<List<E>> consumer, int batchSize); @Override void forEachBatched(Fetch fetch, Consumer<List<E>> consumer, int batchSize); @SuppressWarnings("ConstantConditions") @Override long count(); @SuppressWarnings("ConstantConditions") @Override long count(Query<E> q); @Override Stream<E> findAll(Query<E> q); @Override E findOne(Query<E> q); @Override E findOneById(Object id); @Override E findOneById(Object id, Fetch fetch); @Override Stream<E> findAll(Stream<Object> ids); @Override Stream<E> findAll(Stream<Object> ids, Fetch fetch); @Override AggregateResult aggregate(AggregateQuery aggregateQuery); @Override void update(E entity); @Override void update(Stream<E> entities); @Override void delete(E entity); @Override void delete(Stream<E> entities); @Override void deleteById(Object id); @Override void deleteAll(Stream<Object> ids); @Override void deleteAll(); @Override void add(E entity); @Override Integer add(Stream<E> entities); @SuppressWarnings({"ConstantConditions", "NullableProblems"}) @Override Iterator<E> iterator(); }### Answer:
@Test void update() { Entity entity = mock(Entity.class); transactionalRepo.update(entity); verify(transactionManager).getTransaction(any(TransactionDefinition.class)); verify(delegateRepository).update(entity); }
@Test void updateStream() { @SuppressWarnings("unchecked") Stream<Entity> entityStream = mock(Stream.class); transactionalRepo.update(entityStream); verify(transactionManager).getTransaction(any(TransactionDefinition.class)); verify(delegateRepository).update(entityStream); }
|
### Question:
ExceptionResponseGeneratorRegistryImpl implements ExceptionResponseGeneratorRegistry { @Override public ExceptionResponseGenerator getExceptionResponseGenerator(ExceptionResponseType type) { ExceptionResponseGenerator<?> exceptionResponseGenerator = responseGeneratorMap.get(type); if (exceptionResponseGenerator == null) { throw new UnexpectedEnumException(type); } return exceptionResponseGenerator; } ExceptionResponseGeneratorRegistryImpl(); @Override void registerExceptionResponseGenerator(
ExceptionResponseGenerator exceptionResponseGenerator); @Override ExceptionResponseGenerator getExceptionResponseGenerator(ExceptionResponseType type); }### Answer:
@Test void testGetExceptionResponseGenerator() { assertThrows( UnexpectedEnumException.class, () -> exceptionResponseGeneratorRegistryImpl.getExceptionResponseGenerator(PROBLEM)); }
|
### Question:
TransactionalRepositoryDecorator extends AbstractRepositoryDecorator<E> { @Override public void delete(E entity) { if (TransactionSynchronizationManager.isSynchronizationActive()) { delegate().delete(entity); } else { createWriteTransactionTemplate() .execute( status -> { delegate().delete(entity); return null; }); } } TransactionalRepositoryDecorator(
Repository<E> delegateRepository, PlatformTransactionManager transactionManager); @Override void forEachBatched(Consumer<List<E>> consumer, int batchSize); @Override void forEachBatched(Fetch fetch, Consumer<List<E>> consumer, int batchSize); @SuppressWarnings("ConstantConditions") @Override long count(); @SuppressWarnings("ConstantConditions") @Override long count(Query<E> q); @Override Stream<E> findAll(Query<E> q); @Override E findOne(Query<E> q); @Override E findOneById(Object id); @Override E findOneById(Object id, Fetch fetch); @Override Stream<E> findAll(Stream<Object> ids); @Override Stream<E> findAll(Stream<Object> ids, Fetch fetch); @Override AggregateResult aggregate(AggregateQuery aggregateQuery); @Override void update(E entity); @Override void update(Stream<E> entities); @Override void delete(E entity); @Override void delete(Stream<E> entities); @Override void deleteById(Object id); @Override void deleteAll(Stream<Object> ids); @Override void deleteAll(); @Override void add(E entity); @Override Integer add(Stream<E> entities); @SuppressWarnings({"ConstantConditions", "NullableProblems"}) @Override Iterator<E> iterator(); }### Answer:
@Test void delete() { Entity entity = mock(Entity.class); transactionalRepo.delete(entity); verify(transactionManager).getTransaction(any(TransactionDefinition.class)); verify(delegateRepository).delete(entity); }
@Test void deleteStream() { @SuppressWarnings("unchecked") Stream<Entity> entityStream = mock(Stream.class); transactionalRepo.delete(entityStream); verify(transactionManager).getTransaction(any(TransactionDefinition.class)); verify(delegateRepository).delete(entityStream); }
|
### Question:
TransactionalRepositoryDecorator extends AbstractRepositoryDecorator<E> { @Override public void deleteById(Object id) { if (TransactionSynchronizationManager.isSynchronizationActive()) { delegate().deleteById(id); } else { createWriteTransactionTemplate() .execute( status -> { delegate().deleteById(id); return null; }); } } TransactionalRepositoryDecorator(
Repository<E> delegateRepository, PlatformTransactionManager transactionManager); @Override void forEachBatched(Consumer<List<E>> consumer, int batchSize); @Override void forEachBatched(Fetch fetch, Consumer<List<E>> consumer, int batchSize); @SuppressWarnings("ConstantConditions") @Override long count(); @SuppressWarnings("ConstantConditions") @Override long count(Query<E> q); @Override Stream<E> findAll(Query<E> q); @Override E findOne(Query<E> q); @Override E findOneById(Object id); @Override E findOneById(Object id, Fetch fetch); @Override Stream<E> findAll(Stream<Object> ids); @Override Stream<E> findAll(Stream<Object> ids, Fetch fetch); @Override AggregateResult aggregate(AggregateQuery aggregateQuery); @Override void update(E entity); @Override void update(Stream<E> entities); @Override void delete(E entity); @Override void delete(Stream<E> entities); @Override void deleteById(Object id); @Override void deleteAll(Stream<Object> ids); @Override void deleteAll(); @Override void add(E entity); @Override Integer add(Stream<E> entities); @SuppressWarnings({"ConstantConditions", "NullableProblems"}) @Override Iterator<E> iterator(); }### Answer:
@Test void deleteById() { Object id = mock(Object.class); transactionalRepo.deleteById(id); verify(transactionManager).getTransaction(any(TransactionDefinition.class)); verify(delegateRepository).deleteById(id); }
|
### Question:
TransactionalRepositoryDecorator extends AbstractRepositoryDecorator<E> { @Override public void deleteAll(Stream<Object> ids) { if (TransactionSynchronizationManager.isSynchronizationActive()) { delegate().deleteAll(ids); } else { createWriteTransactionTemplate() .execute( status -> { delegate().deleteAll(ids); return null; }); } } TransactionalRepositoryDecorator(
Repository<E> delegateRepository, PlatformTransactionManager transactionManager); @Override void forEachBatched(Consumer<List<E>> consumer, int batchSize); @Override void forEachBatched(Fetch fetch, Consumer<List<E>> consumer, int batchSize); @SuppressWarnings("ConstantConditions") @Override long count(); @SuppressWarnings("ConstantConditions") @Override long count(Query<E> q); @Override Stream<E> findAll(Query<E> q); @Override E findOne(Query<E> q); @Override E findOneById(Object id); @Override E findOneById(Object id, Fetch fetch); @Override Stream<E> findAll(Stream<Object> ids); @Override Stream<E> findAll(Stream<Object> ids, Fetch fetch); @Override AggregateResult aggregate(AggregateQuery aggregateQuery); @Override void update(E entity); @Override void update(Stream<E> entities); @Override void delete(E entity); @Override void delete(Stream<E> entities); @Override void deleteById(Object id); @Override void deleteAll(Stream<Object> ids); @Override void deleteAll(); @Override void add(E entity); @Override Integer add(Stream<E> entities); @SuppressWarnings({"ConstantConditions", "NullableProblems"}) @Override Iterator<E> iterator(); }### Answer:
@Test void deleteAll() { transactionalRepo.deleteAll(); verify(transactionManager).getTransaction(any(TransactionDefinition.class)); verify(delegateRepository).deleteAll(); }
@Test void deleteAllStream() { @SuppressWarnings("unchecked") Stream<Object> entityIds = mock(Stream.class); transactionalRepo.deleteAll(entityIds); verify(transactionManager).getTransaction(any(TransactionDefinition.class)); verify(delegateRepository).deleteAll(entityIds); }
|
### Question:
TransactionalRepositoryDecorator extends AbstractRepositoryDecorator<E> { @Override public void add(E entity) { if (TransactionSynchronizationManager.isSynchronizationActive()) { delegate().add(entity); } else { createWriteTransactionTemplate() .execute( status -> { delegate().add(entity); return null; }); } } TransactionalRepositoryDecorator(
Repository<E> delegateRepository, PlatformTransactionManager transactionManager); @Override void forEachBatched(Consumer<List<E>> consumer, int batchSize); @Override void forEachBatched(Fetch fetch, Consumer<List<E>> consumer, int batchSize); @SuppressWarnings("ConstantConditions") @Override long count(); @SuppressWarnings("ConstantConditions") @Override long count(Query<E> q); @Override Stream<E> findAll(Query<E> q); @Override E findOne(Query<E> q); @Override E findOneById(Object id); @Override E findOneById(Object id, Fetch fetch); @Override Stream<E> findAll(Stream<Object> ids); @Override Stream<E> findAll(Stream<Object> ids, Fetch fetch); @Override AggregateResult aggregate(AggregateQuery aggregateQuery); @Override void update(E entity); @Override void update(Stream<E> entities); @Override void delete(E entity); @Override void delete(Stream<E> entities); @Override void deleteById(Object id); @Override void deleteAll(Stream<Object> ids); @Override void deleteAll(); @Override void add(E entity); @Override Integer add(Stream<E> entities); @SuppressWarnings({"ConstantConditions", "NullableProblems"}) @Override Iterator<E> iterator(); }### Answer:
@Test void add() { Entity entity = mock(Entity.class); transactionalRepo.add(entity); verify(transactionManager).getTransaction(any(TransactionDefinition.class)); verify(delegateRepository).add(entity); }
@Test void addStream() { @SuppressWarnings("unchecked") Stream<Entity> entityStream = mock(Stream.class); transactionalRepo.add(entityStream); verify(transactionManager).getTransaction(any(TransactionDefinition.class)); verify(delegateRepository).add(entityStream); }
|
### Question:
TransactionalRepositoryDecorator extends AbstractRepositoryDecorator<E> { @SuppressWarnings({"ConstantConditions", "NullableProblems"}) @Override public Iterator<E> iterator() { if (TransactionSynchronizationManager.isSynchronizationActive()) { return delegate().iterator(); } else { return createReadonlyTransactionTemplate().execute(status -> delegate().iterator()); } } TransactionalRepositoryDecorator(
Repository<E> delegateRepository, PlatformTransactionManager transactionManager); @Override void forEachBatched(Consumer<List<E>> consumer, int batchSize); @Override void forEachBatched(Fetch fetch, Consumer<List<E>> consumer, int batchSize); @SuppressWarnings("ConstantConditions") @Override long count(); @SuppressWarnings("ConstantConditions") @Override long count(Query<E> q); @Override Stream<E> findAll(Query<E> q); @Override E findOne(Query<E> q); @Override E findOneById(Object id); @Override E findOneById(Object id, Fetch fetch); @Override Stream<E> findAll(Stream<Object> ids); @Override Stream<E> findAll(Stream<Object> ids, Fetch fetch); @Override AggregateResult aggregate(AggregateQuery aggregateQuery); @Override void update(E entity); @Override void update(Stream<E> entities); @Override void delete(E entity); @Override void delete(Stream<E> entities); @Override void deleteById(Object id); @Override void deleteAll(Stream<Object> ids); @Override void deleteAll(); @Override void add(E entity); @Override Integer add(Stream<E> entities); @SuppressWarnings({"ConstantConditions", "NullableProblems"}) @Override Iterator<E> iterator(); }### Answer:
@Test void iterator() { transactionalRepo.iterator(); verify(transactionManager).getTransaction(any(TransactionDefinition.class)); verify(delegateRepository).iterator(); }
|
### Question:
EntityTypeReferencedException extends DataConstraintViolationException { @Override public String getMessage() { return "dependencies:" + entityTypeDependencyMap.entrySet().stream() .map(entry -> entry.getKey() + '=' + String.join(",", entry.getValue())) .collect(Collectors.joining(";")); } EntityTypeReferencedException(
Map<String, Set<String>> entityTypeDependencyMap, @Nullable @CheckForNull Throwable cause); @Override String getMessage(); }### Answer:
@Test void testGetMessage() { Map<String, Set<String>> entityTypeDependencyMap = ImmutableMap.of( "MyEntityType0", ImmutableSet.of("MyRefEntityType0", "MyRefEntityType1"), "MyEntityType1", ImmutableSet.of("MyRefEntityType2")); EntityTypeReferencedException ex = new EntityTypeReferencedException(entityTypeDependencyMap, mock(Throwable.class)); assertEquals( "dependencies:MyEntityType0=MyRefEntityType0,MyRefEntityType1;MyEntityType1=MyRefEntityType2", ex.getMessage()); }
|
### Question:
DynamicRepositoryDecoratorRegistryImpl implements DynamicRepositoryDecoratorRegistry { @Override public synchronized void addFactory(DynamicRepositoryDecoratorFactory factory) { String factoryId = factory.getId(); if (factories.containsKey(factoryId)) { throw new IllegalArgumentException(format("Duplicate decorator id [%s]", factoryId)); } factories.put(factoryId, factory); } DynamicRepositoryDecoratorRegistryImpl(DataService dataService, Gson gson); @Override synchronized void addFactory(DynamicRepositoryDecoratorFactory factory); @Override Stream<String> getFactoryIds(); @Override DynamicRepositoryDecoratorFactory getFactory(String id); @Override synchronized Repository<Entity> decorate(Repository<Entity> repository); @EventListener void onApplicationEvent(BootstrappingEvent bootstrappingEvent); }### Answer:
@Test void testAddFactory() { DynamicRepositoryDecoratorFactory factory1 = mock(DynamicRepositoryDecoratorFactory.class); when(factory1.getId()).thenReturn("test1"); DynamicRepositoryDecoratorFactory factory2 = mock(DynamicRepositoryDecoratorFactory.class); when(factory2.getId()).thenReturn("test2"); registry.addFactory(factory1); registry.addFactory(factory2); assertEquals(newHashSet("test1", "test2"), registry.getFactoryIds().collect(toSet())); }
@Test void testAddDuplicateFactory() { DynamicRepositoryDecoratorFactory factory = mock(DynamicRepositoryDecoratorFactory.class); when(factory.getId()).thenReturn("test"); registry.addFactory(factory); Exception exception = assertThrows(IllegalArgumentException.class, () -> registry.addFactory(factory)); assertThat(exception.getMessage()).containsPattern("Duplicate decorator id \\[test\\]"); }
|
### Question:
DynamicRepositoryDecoratorRegistryImpl implements DynamicRepositoryDecoratorRegistry { @Override public DynamicRepositoryDecoratorFactory getFactory(String id) { if (!factories.containsKey(id)) { throw new IllegalArgumentException(format("Decorator [%s] does not exist", id)); } return factories.get(id); } DynamicRepositoryDecoratorRegistryImpl(DataService dataService, Gson gson); @Override synchronized void addFactory(DynamicRepositoryDecoratorFactory factory); @Override Stream<String> getFactoryIds(); @Override DynamicRepositoryDecoratorFactory getFactory(String id); @Override synchronized Repository<Entity> decorate(Repository<Entity> repository); @EventListener void onApplicationEvent(BootstrappingEvent bootstrappingEvent); }### Answer:
@Test void testGetFactory() { DynamicRepositoryDecoratorFactory factory = mock(DynamicRepositoryDecoratorFactory.class); when(factory.getId()).thenReturn("test"); registry.addFactory(factory); DynamicRepositoryDecoratorFactory returnedFactory = registry.getFactory("test"); assertEquals(factory, returnedFactory); }
@Test void testGetNonExistingFactory() { Exception exception = assertThrows(IllegalArgumentException.class, () -> registry.getFactory("test")); assertThat(exception.getMessage()).containsPattern("Decorator \\[test\\] does not exist"); }
|
### Question:
DynamicRepositoryDecoratorFactoryRegistrar { public void register(ApplicationContext context) { Map<String, DynamicRepositoryDecoratorFactory> repositoryDecoratorFactoryMap = context.getBeansOfType(DynamicRepositoryDecoratorFactory.class); repositoryDecoratorFactoryMap.values().forEach(repositoryDecoratorRegistry::addFactory); } DynamicRepositoryDecoratorFactoryRegistrar(
DynamicRepositoryDecoratorRegistry repositoryDecoratorRegistry); void register(ApplicationContext context); }### Answer:
@Test void testRegister() { Map<String, DynamicRepositoryDecoratorFactory> map = new HashMap<>(); map.put("decoratorFactory1", decoratorFactory1); map.put("decoratorFactory2", decoratorFactory2); when(context.getBeansOfType(DynamicRepositoryDecoratorFactory.class)).thenReturn(map); DynamicRepositoryDecoratorFactoryRegistrar dynamicRepositoryDecoratorFactoryRegistrar = new DynamicRepositoryDecoratorFactoryRegistrar(repositoryDecoratorRegistry); dynamicRepositoryDecoratorFactoryRegistrar.register(context); verify(repositoryDecoratorRegistry).addFactory(decoratorFactory1); verify(repositoryDecoratorRegistry).addFactory(decoratorFactory2); }
|
### Question:
DecoratorParametersRepositoryDecorator extends AbstractRepositoryDecorator<DecoratorParameters> { @Override public void update(DecoratorParameters decoratorParameters) { validateParameters(decoratorParameters); delegate().update(decoratorParameters); } DecoratorParametersRepositoryDecorator(
Repository<DecoratorParameters> delegateRepository, JsonValidator jsonValidator); @Override void update(DecoratorParameters decoratorParameters); @Override void update(Stream<DecoratorParameters> decoratorParameters); @Override void add(DecoratorParameters decoratorParameters); @Override Integer add(Stream<DecoratorParameters> decoratorParameters); }### Answer:
@Test void testUpdate() { decorator.update(mockParameters()); verify(jsonValidator).validate(JSON, SCHEMA); }
@Test @SuppressWarnings("unchecked") void testUpdateStream() { decorator.update(Stream.of(mockParameters(), mockParameters())); verify(delegateRepo).update(streamCaptor.capture()); streamCaptor .getValue() .forEach( t -> { }); verify(jsonValidator, times(2)).validate(JSON, SCHEMA); }
|
### Question:
DecoratorParametersRepositoryDecorator extends AbstractRepositoryDecorator<DecoratorParameters> { @Override public void add(DecoratorParameters decoratorParameters) { validateParameters(decoratorParameters); delegate().add(decoratorParameters); } DecoratorParametersRepositoryDecorator(
Repository<DecoratorParameters> delegateRepository, JsonValidator jsonValidator); @Override void update(DecoratorParameters decoratorParameters); @Override void update(Stream<DecoratorParameters> decoratorParameters); @Override void add(DecoratorParameters decoratorParameters); @Override Integer add(Stream<DecoratorParameters> decoratorParameters); }### Answer:
@Test void testAdd() { decorator.add(mockParameters()); verify(jsonValidator).validate(JSON, SCHEMA); }
@Test @SuppressWarnings("unchecked") void testAddStream() { decorator.add(Stream.of(mockParameters(), mockParameters())); verify(delegateRepo).add(streamCaptor.capture()); streamCaptor .getValue() .forEach( t -> { }); verify(jsonValidator, times(2)).validate(JSON, SCHEMA); }
@Test void testNoValidationWhenNullParameters() { DecoratorParameters parameters = mock(DecoratorParameters.class, RETURNS_DEEP_STUBS); decorator.add(parameters); verifyZeroInteractions(jsonValidator); }
|
### Question:
PermissionCheckingDecorator extends AbstractRepositoryDecorator<E> { public PermissionCheckingDecorator( Repository<E> delegateRepository, PermissionChecker<E> permissionChecker) { super(delegateRepository); this.permissionChecker = requireNonNull(permissionChecker); } PermissionCheckingDecorator(
Repository<E> delegateRepository, PermissionChecker<E> permissionChecker); @Override @Nonnull Iterator<E> iterator(); @Override void forEachBatched(Fetch fetch, Consumer<List<E>> consumer, int batchSize); @Override long count(); @Override long count(Query<E> q); @Override Stream<E> findAll(Query<E> q); @Override E findOne(Query<E> q); @Override E findOneById(Object id); @Override E findOneById(Object id, Fetch fetch); @Override Stream<E> findAll(Stream<Object> ids); @Override Stream<E> findAll(Stream<Object> ids, Fetch fetch); @Override void update(E entity); @Override void update(Stream<E> entities); @Override void delete(E entity); @Override void delete(Stream<E> entities); @Override void deleteById(Object id); @Transactional @Override void deleteAll(Stream<Object> ids); @Transactional @Override void deleteAll(); @Override void add(E entity); @Override Integer add(Stream<E> entities); @Override AggregateResult aggregate(AggregateQuery aggregateQuery); }### Answer:
@Test void testPermissionCheckingDecorator() { assertThrows(NullPointerException.class, () -> new PermissionCheckingDecorator<>(null, null)); }
|
### Question:
PermissionCheckingDecorator extends AbstractRepositoryDecorator<E> { @Override public @Nonnull Iterator<E> iterator() { return Streams.stream(delegate().iterator()) .filter(permissionChecker::isReadAllowed) .iterator(); } PermissionCheckingDecorator(
Repository<E> delegateRepository, PermissionChecker<E> permissionChecker); @Override @Nonnull Iterator<E> iterator(); @Override void forEachBatched(Fetch fetch, Consumer<List<E>> consumer, int batchSize); @Override long count(); @Override long count(Query<E> q); @Override Stream<E> findAll(Query<E> q); @Override E findOne(Query<E> q); @Override E findOneById(Object id); @Override E findOneById(Object id, Fetch fetch); @Override Stream<E> findAll(Stream<Object> ids); @Override Stream<E> findAll(Stream<Object> ids, Fetch fetch); @Override void update(E entity); @Override void update(Stream<E> entities); @Override void delete(E entity); @Override void delete(Stream<E> entities); @Override void deleteById(Object id); @Transactional @Override void deleteAll(Stream<Object> ids); @Transactional @Override void deleteAll(); @Override void add(E entity); @Override Integer add(Stream<E> entities); @Override AggregateResult aggregate(AggregateQuery aggregateQuery); }### Answer:
@Test void testIterator() { Entity permittedEntity = mock(Entity.class); Entity notPermittedEntity = mock(Entity.class); when(delegateRepository.iterator()) .thenReturn(asList(permittedEntity, notPermittedEntity).iterator()); when(permissionChecker.isReadAllowed(permittedEntity)).thenReturn(true); assertEquals( singletonList(permittedEntity), newArrayList(permissionCheckingDecorator.iterator())); }
|
### Question:
PermissionCheckingDecorator extends AbstractRepositoryDecorator<E> { @Override public long count() { return count(new QueryImpl<>()); } PermissionCheckingDecorator(
Repository<E> delegateRepository, PermissionChecker<E> permissionChecker); @Override @Nonnull Iterator<E> iterator(); @Override void forEachBatched(Fetch fetch, Consumer<List<E>> consumer, int batchSize); @Override long count(); @Override long count(Query<E> q); @Override Stream<E> findAll(Query<E> q); @Override E findOne(Query<E> q); @Override E findOneById(Object id); @Override E findOneById(Object id, Fetch fetch); @Override Stream<E> findAll(Stream<Object> ids); @Override Stream<E> findAll(Stream<Object> ids, Fetch fetch); @Override void update(E entity); @Override void update(Stream<E> entities); @Override void delete(E entity); @Override void delete(Stream<E> entities); @Override void deleteById(Object id); @Transactional @Override void deleteAll(Stream<Object> ids); @Transactional @Override void deleteAll(); @Override void add(E entity); @Override Integer add(Stream<E> entities); @Override AggregateResult aggregate(AggregateQuery aggregateQuery); }### Answer:
@Test void testCount() { Entity permittedEntity = mock(Entity.class); Entity notPermittedEntity = mock(Entity.class); when(delegateRepository.findAll(new QueryImpl<>().offset(0).pageSize(Integer.MAX_VALUE))) .thenReturn(Stream.of(permittedEntity, notPermittedEntity)); when(permissionChecker.isCountAllowed(permittedEntity)).thenReturn(true); assertEquals(1L, permissionCheckingDecorator.count()); }
|
### Question:
PermissionCheckingDecorator extends AbstractRepositoryDecorator<E> { @Override public void deleteById(Object id) { E entity = delegate().findOneById(id); if (entity == null || permissionChecker.isDeleteAllowed(entity)) { delegate().deleteById(id); } } PermissionCheckingDecorator(
Repository<E> delegateRepository, PermissionChecker<E> permissionChecker); @Override @Nonnull Iterator<E> iterator(); @Override void forEachBatched(Fetch fetch, Consumer<List<E>> consumer, int batchSize); @Override long count(); @Override long count(Query<E> q); @Override Stream<E> findAll(Query<E> q); @Override E findOne(Query<E> q); @Override E findOneById(Object id); @Override E findOneById(Object id, Fetch fetch); @Override Stream<E> findAll(Stream<Object> ids); @Override Stream<E> findAll(Stream<Object> ids, Fetch fetch); @Override void update(E entity); @Override void update(Stream<E> entities); @Override void delete(E entity); @Override void delete(Stream<E> entities); @Override void deleteById(Object id); @Transactional @Override void deleteAll(Stream<Object> ids); @Transactional @Override void deleteAll(); @Override void add(E entity); @Override Integer add(Stream<E> entities); @Override AggregateResult aggregate(AggregateQuery aggregateQuery); }### Answer:
@Test void testDeleteByIdUnknownEntity() { permissionCheckingDecorator.deleteById("unknownEntityId"); verify(delegateRepository).deleteById("unknownEntityId"); }
|
### Question:
ReadonlyValueException extends DataConstraintViolationException { @Override public String getMessage() { return "entityTypeId:" + entityTypeId + " attributeName:" + attributeName + " entityId:" + entityId; } ReadonlyValueException(
@Nullable @CheckForNull String entityTypeId,
@Nullable @CheckForNull String attributeName,
String entityId,
@Nullable @CheckForNull Throwable cause); @Override String getMessage(); }### Answer:
@Test void testGetMessage() { ReadonlyValueException ex = new ReadonlyValueException( "MyEntityType", "myAttributeName", "myEntityId", mock(Throwable.class)); assertEquals( "entityTypeId:MyEntityType attributeName:myAttributeName entityId:myEntityId", ex.getMessage()); }
|
### Question:
EntityManagerImpl implements EntityManager { @Override public Entity getReference(EntityType entityType, Object id) { return entityReferenceCreator.getReference(entityType, id); } EntityManagerImpl(
DataService dataService,
EntityFactoryRegistry entityFactoryRegistry,
EntityPopulator entityPopulator,
EntityReferenceCreator entityReferenceCreator); @Override Entity create(EntityType entityType, CreationMode creationMode); @Override Entity createFetch(EntityType entityType, Fetch fetch); @Override Entity getReference(EntityType entityType, Object id); @Override Iterable<Entity> getReferences(EntityType entityType, Iterable<?> ids); @Override Entity resolveReferences(EntityType entityType, Entity entity, Fetch fetch); @Override Stream<Entity> resolveReferences(
EntityType entityType, Stream<Entity> entities, Fetch fetch); }### Answer:
@Test void getReference() { EntityType entityType = mock(EntityType.class); Object id = mock(Object.class); entityManagerImpl.getReference(entityType, id); verify(entityReferenceCreator).getReference(entityType, id); }
|
### Question:
EntityManagerImpl implements EntityManager { @Override public Iterable<Entity> getReferences(EntityType entityType, Iterable<?> ids) { return entityReferenceCreator.getReferences(entityType, ids); } EntityManagerImpl(
DataService dataService,
EntityFactoryRegistry entityFactoryRegistry,
EntityPopulator entityPopulator,
EntityReferenceCreator entityReferenceCreator); @Override Entity create(EntityType entityType, CreationMode creationMode); @Override Entity createFetch(EntityType entityType, Fetch fetch); @Override Entity getReference(EntityType entityType, Object id); @Override Iterable<Entity> getReferences(EntityType entityType, Iterable<?> ids); @Override Entity resolveReferences(EntityType entityType, Entity entity, Fetch fetch); @Override Stream<Entity> resolveReferences(
EntityType entityType, Stream<Entity> entities, Fetch fetch); }### Answer:
@Test void getReferences() { EntityType entityType = mock(EntityType.class); Iterable<?> ids = mock(Iterable.class); entityManagerImpl.getReferences(entityType, ids); verify(entityReferenceCreator).getReferences(entityType, ids); }
|
### Question:
HttpLocaleResolver implements LocaleResolver { @Override public Locale resolveLocale(HttpServletRequest request) { String username = SecurityUtils.getCurrentUsername(); Locale locale; if (username != null) { locale = userLocaleResolver.resolveLocale(username); } else { locale = fallbackLocaleSupplier.get(); } return locale; } HttpLocaleResolver(
UserLocaleResolver userLocaleResolver,
FallbackLocaleSupplier fallbackLocaleSupplier,
UserService userService); @Override Locale resolveLocale(HttpServletRequest request); @Override void setLocale(HttpServletRequest request, HttpServletResponse response, Locale locale); }### Answer:
@WithMockUser @Test void testResolveLocaleAuthenticated() { HttpServletRequest httpServletRequest = mock(HttpServletRequest.class); String username = "user"; when(userLocaleResolver.resolveLocale(username)).thenReturn(Locale.GERMAN); assertEquals(GERMAN, httpLocaleResolver.resolveLocale(httpServletRequest)); }
@Test void testResolveLocaleNotAuthenticated() { HttpServletRequest httpServletRequest = mock(HttpServletRequest.class); when(fallbackLocaleSupplier.get()).thenReturn(Locale.GERMAN); assertEquals(GERMAN, httpLocaleResolver.resolveLocale(httpServletRequest)); }
|
### Question:
EntityManagerImpl implements EntityManager { @Override public Entity resolveReferences(EntityType entityType, Entity entity, Fetch fetch) { if (fetch == null) { return entity; } List<Attribute> resolvableAttrs = getResolvableAttrs(entityType, fetch); if (resolvableAttrs.isEmpty()) { return entity; } return resolveReferences(resolvableAttrs, singletonList(entity), fetch).iterator().next(); } EntityManagerImpl(
DataService dataService,
EntityFactoryRegistry entityFactoryRegistry,
EntityPopulator entityPopulator,
EntityReferenceCreator entityReferenceCreator); @Override Entity create(EntityType entityType, CreationMode creationMode); @Override Entity createFetch(EntityType entityType, Fetch fetch); @Override Entity getReference(EntityType entityType, Object id); @Override Iterable<Entity> getReferences(EntityType entityType, Iterable<?> ids); @Override Entity resolveReferences(EntityType entityType, Entity entity, Fetch fetch); @Override Stream<Entity> resolveReferences(
EntityType entityType, Stream<Entity> entities, Fetch fetch); }### Answer:
@Test void resolveReferencesNoFetch() { EntityType entityType = mock(EntityType.class); Entity entity0 = new DynamicEntity(entityType); Entity entity1 = new DynamicEntity(entityType); Stream<Entity> entities = Stream.of(entity0, entity1); Fetch fetch = null; assertEquals(entityManagerImpl.resolveReferences(entityType, entities, fetch), entities); }
@Test void resolveReferencesStreamNoFetch() { EntityType entityType = mock(EntityType.class); Entity entity0 = new DynamicEntity(entityType); Entity entity1 = new DynamicEntity(entityType); Fetch fetch = null; Stream<Entity> entities = entityManagerImpl.resolveReferences(entityType, Stream.of(entity0, entity1), fetch); assertEquals(asList(entity0, entity1), entities.collect(toList())); }
|
### Question:
RepositoryCollectionRegistry { public RepositoryCollection getRepositoryCollection(String name) { RepositoryCollection repoCollection = repoCollectionMap.get(name); return repoCollection != null ? repoCollectionDecoratorFactory.createDecoratedRepositoryCollection(repoCollection) : null; } RepositoryCollectionRegistry(
RepositoryCollectionDecoratorFactory repoCollectionDecoratorFactory); Stream<RepositoryCollection> getRepositoryCollections(); void addRepositoryCollection(RepositoryCollection repoCollection); RepositoryCollection getRepositoryCollection(String name); boolean hasRepositoryCollection(String name); RepositoryCollection getDefaultRepoCollection(); }### Answer:
@Test void testGetRepositoryCollection() { RepositoryCollection decoratedRepositoryCollection = mock(RepositoryCollection.class); RepositoryCollection repositoryCollection = mock(RepositoryCollection.class); when(repositoryCollectionDecoratorFactory.createDecoratedRepositoryCollection( repositoryCollection)) .thenReturn(decoratedRepositoryCollection); String repositoryCollectionName = "MyRepositoryCollectionName"; when(repositoryCollection.getName()).thenReturn(repositoryCollectionName); repositoryCollectionRegistry.addRepositoryCollection(repositoryCollection); assertEquals( decoratedRepositoryCollection, repositoryCollectionRegistry.getRepositoryCollection(repositoryCollectionName)); }
|
### Question:
RepositoryCollectionRegistry { public Stream<RepositoryCollection> getRepositoryCollections() { return repoCollectionMap.values().stream() .map(repoCollectionDecoratorFactory::createDecoratedRepositoryCollection); } RepositoryCollectionRegistry(
RepositoryCollectionDecoratorFactory repoCollectionDecoratorFactory); Stream<RepositoryCollection> getRepositoryCollections(); void addRepositoryCollection(RepositoryCollection repoCollection); RepositoryCollection getRepositoryCollection(String name); boolean hasRepositoryCollection(String name); RepositoryCollection getDefaultRepoCollection(); }### Answer:
@Test void testGetRepositoryCollections() { RepositoryCollection decoratedRepositoryCollection = mock(RepositoryCollection.class); RepositoryCollection repositoryCollection = mock(RepositoryCollection.class); when(repositoryCollectionDecoratorFactory.createDecoratedRepositoryCollection( repositoryCollection)) .thenReturn(decoratedRepositoryCollection); String repositoryCollectionName = "MyRepositoryCollectionName"; when(repositoryCollection.getName()).thenReturn(repositoryCollectionName); repositoryCollectionRegistry.addRepositoryCollection(repositoryCollection); assertEquals( singletonList(decoratedRepositoryCollection), repositoryCollectionRegistry.getRepositoryCollections().collect(toList())); }
|
### Question:
RepositoryCollectionRegistry { public boolean hasRepositoryCollection(String name) { return repoCollectionMap.containsKey(name); } RepositoryCollectionRegistry(
RepositoryCollectionDecoratorFactory repoCollectionDecoratorFactory); Stream<RepositoryCollection> getRepositoryCollections(); void addRepositoryCollection(RepositoryCollection repoCollection); RepositoryCollection getRepositoryCollection(String name); boolean hasRepositoryCollection(String name); RepositoryCollection getDefaultRepoCollection(); }### Answer:
@Test void testHasRepositoryCollection() { RepositoryCollection repositoryCollection = mock(RepositoryCollection.class); String repositoryCollectionName = "MyRepositoryCollectionName"; when(repositoryCollection.getName()).thenReturn(repositoryCollectionName); repositoryCollectionRegistry.addRepositoryCollection(repositoryCollection); assertTrue(repositoryCollectionRegistry.hasRepositoryCollection(repositoryCollectionName)); }
|
### Question:
RepositoryCollectionRegistry { public RepositoryCollection getDefaultRepoCollection() { return repoCollectionDecoratorFactory.createDecoratedRepositoryCollection( defaultRepoCollection); } RepositoryCollectionRegistry(
RepositoryCollectionDecoratorFactory repoCollectionDecoratorFactory); Stream<RepositoryCollection> getRepositoryCollections(); void addRepositoryCollection(RepositoryCollection repoCollection); RepositoryCollection getRepositoryCollection(String name); boolean hasRepositoryCollection(String name); RepositoryCollection getDefaultRepoCollection(); }### Answer:
@Test void testGetDefaultRepoCollection() { RepositoryCollection decoratedRepositoryCollection = mock(RepositoryCollection.class); RepositoryCollection defaultRepositoryCollection = mock(RepositoryCollection.class); when(repositoryCollectionDecoratorFactory.createDecoratedRepositoryCollection( defaultRepositoryCollection)) .thenReturn(decoratedRepositoryCollection); repositoryCollectionRegistry.setDefaultRepoCollection(defaultRepositoryCollection); assertEquals( decoratedRepositoryCollection, repositoryCollectionRegistry.getDefaultRepoCollection()); }
|
### Question:
ListValueAlreadyExistsException extends DataConstraintViolationException { @Override public String getMessage() { return "entityTypeId:" + entityTypeId + " attributeName:" + attributeName + " entityId:" + entityId + " value:" + value; } ListValueAlreadyExistsException(
@Nullable @CheckForNull String entityTypeId,
@Nullable @CheckForNull String attributeName,
String entityId,
String value,
@Nullable @CheckForNull Throwable cause); @Override String getMessage(); }### Answer:
@Test void testGetMessage() { ListValueAlreadyExistsException ex = new ListValueAlreadyExistsException( "MyEntityTypeId", "myAttributeName", "myEntityId", "myValue", mock(Throwable.class)); assertEquals( "entityTypeId:MyEntityTypeId attributeName:myAttributeName entityId:myEntityId value:myValue", ex.getMessage()); }
|
### Question:
Fetch implements Iterable<Entry<String, Fetch>> { public Fetch field(String field) { return field(field, null); } Fetch(); Fetch(boolean validated); Fetch field(String field); Fetch field(String field, Fetch fetch); @Nullable @CheckForNull Fetch getFetch(String field); @Nullable @CheckForNull Fetch getFetch(Attribute attr); boolean hasField(String field); boolean hasField(Attribute attr); Set<String> getFields(); boolean isValidated(); @Override Iterator<Entry<String, Fetch>> iterator(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer:
@Test void equalsTrue() { String field = "field"; assertEquals(new Fetch().field(field), new Fetch().field(field)); }
@Test void equalsFalse() { assertNotEquals(new Fetch().field("field0"), new Fetch().field("field1")); }
@Test void equalsSubFetchTrue() { String field = "field"; Fetch subFetch = new Fetch(); assertEquals(new Fetch().field(field, subFetch), new Fetch().field(field, subFetch)); }
@Test void equalsSubFetchFalse() { String field = "field"; Fetch subFetch = new Fetch(); assertNotEquals(new Fetch().field(field, subFetch), new Fetch().field(field)); }
|
### Question:
FallbackExceptionHandler { @ResponseStatus(INTERNAL_SERVER_ERROR) @ExceptionHandler public Object handleInternalServerErrorException(Exception e, HandlerMethod handlerMethod) { return exceptionHandlerFacade.logAndHandleException(e, INTERNAL_SERVER_ERROR, handlerMethod); } FallbackExceptionHandler(ExceptionHandlerFacade exceptionHandlerFacade); @ResponseStatus(INTERNAL_SERVER_ERROR) @ExceptionHandler Object handleInternalServerErrorException(Exception e, HandlerMethod handlerMethod); }### Answer:
@Test void testHandleInternalServerErrorException() { Exception e = mock(Exception.class); HandlerMethod method = mock(HandlerMethod.class); fallbackExceptionHandler.handleInternalServerErrorException(e, method); verify(exceptionHandlerFacade).logAndHandleException(e, INTERNAL_SERVER_ERROR, method); }
|
### Question:
Fetch implements Iterable<Entry<String, Fetch>> { @Nullable @CheckForNull public Fetch getFetch(String field) { return attrFetchMap.get(field); } Fetch(); Fetch(boolean validated); Fetch field(String field); Fetch field(String field, Fetch fetch); @Nullable @CheckForNull Fetch getFetch(String field); @Nullable @CheckForNull Fetch getFetch(Attribute attr); boolean hasField(String field); boolean hasField(Attribute attr); Set<String> getFields(); boolean isValidated(); @Override Iterator<Entry<String, Fetch>> iterator(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer:
@Test void getFetch() { String field = "field"; Fetch subFetch = new Fetch(); assertEquals(new Fetch().field(field, subFetch).getFetch(field), subFetch); }
|
### Question:
Fetch implements Iterable<Entry<String, Fetch>> { public Set<String> getFields() { return Collections.unmodifiableMap(attrFetchMap).keySet(); } Fetch(); Fetch(boolean validated); Fetch field(String field); Fetch field(String field, Fetch fetch); @Nullable @CheckForNull Fetch getFetch(String field); @Nullable @CheckForNull Fetch getFetch(Attribute attr); boolean hasField(String field); boolean hasField(Attribute attr); Set<String> getFields(); boolean isValidated(); @Override Iterator<Entry<String, Fetch>> iterator(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer:
@Test void getFields() { String field0 = "field0"; String field1 = "field1"; String field2 = "field2"; Fetch fetch = new Fetch().field(field0).field(field1).field(field2); assertEquals(fetch.getFields(), newHashSet(field0, field1, field2)); }
|
### Question:
Fetch implements Iterable<Entry<String, Fetch>> { public boolean hasField(String field) { return attrFetchMap.containsKey(field); } Fetch(); Fetch(boolean validated); Fetch field(String field); Fetch field(String field, Fetch fetch); @Nullable @CheckForNull Fetch getFetch(String field); @Nullable @CheckForNull Fetch getFetch(Attribute attr); boolean hasField(String field); boolean hasField(Attribute attr); Set<String> getFields(); boolean isValidated(); @Override Iterator<Entry<String, Fetch>> iterator(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer:
@Test void hasFieldFalse() { String field = "field"; assertFalse(new Fetch().hasField(field)); }
|
### Question:
Fetch implements Iterable<Entry<String, Fetch>> { @Override public Iterator<Entry<String, Fetch>> iterator() { return Collections.unmodifiableMap(attrFetchMap).entrySet().iterator(); } Fetch(); Fetch(boolean validated); Fetch field(String field); Fetch field(String field, Fetch fetch); @Nullable @CheckForNull Fetch getFetch(String field); @Nullable @CheckForNull Fetch getFetch(Attribute attr); boolean hasField(String field); boolean hasField(Attribute attr); Set<String> getFields(); boolean isValidated(); @Override Iterator<Entry<String, Fetch>> iterator(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer:
@Test void iterator() { String field0 = "field0"; String field1 = "field1"; String field2 = "field2"; Fetch fetch = new Fetch().field(field0).field(field1).field(field2); Iterator<Entry<String, Fetch>> it = fetch.iterator(); assertTrue(it.hasNext()); assertEquals("field0", it.next().getKey()); assertTrue(it.hasNext()); assertEquals("field1", it.next().getKey()); assertTrue(it.hasNext()); assertEquals("field2", it.next().getKey()); assertFalse(it.hasNext()); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.