method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
ExcelUtils { public static int getNumberOfSheets(File file) { if (!isExcelFile(file.getName())) return -1; try (FileInputStream fis = new FileInputStream(file); Workbook workbook = WorkbookFactory.create(fis)) { return workbook.getNumberOfSheets(); } catch (Exception e) { throw new MolgenisDataException(e); } } private ExcelUtils(); static void renameSheet(String newSheetname, File file, int index); static int getNumberOfSheets(File file); static boolean isExcelFile(String filename); }### Answer:
@Test void getNumberOfSheetsTest() { File file = ResourceUtils.getFile(getClass(), "/test.xls"); assertEquals(3, getNumberOfSheets(file)); }
@Test void getNumberOfSheetsTestCSV() { File file = ResourceUtils.getFile(getClass(), "/test.csv"); assertEquals(-1, getNumberOfSheets(file)); }
|
### Question:
ExcelUtils { public static boolean isExcelFile(String filename) { String extension = FilenameUtils.getExtension(filename); return ExcelFileExtensions.getExcel().contains(extension); } private ExcelUtils(); static void renameSheet(String newSheetname, File file, int index); static int getNumberOfSheets(File file); static boolean isExcelFile(String filename); }### Answer:
@Test void testIsExcelFileTrueXLSX() { assertEquals(true, isExcelFile("test.xlsx")); }
@Test void testIsExcelFileTrueXLS() { assertEquals(true, isExcelFile("test.xls")); }
@Test void testIsExcelFileFalse() { assertEquals(false, isExcelFile("test.csv")); }
|
### Question:
XlsxWriter implements AutoCloseable { public boolean hasSheet(String name) { try { return workbook.getSheet(name) != null; } catch (RuntimeException e) { throw new XlsxWriterException(e); } } XlsxWriter(Path target, Workbook workbook); boolean hasSheet(String name); void createSheet(String name, List<Object> headers); void writeRows(Stream<List<Object>> rows, String sheetName); @Override void close(); }### Answer:
@Test void testHasSheetTrue() { Sheet sheet = mock(Sheet.class); when(workbook.getSheet("test")).thenReturn(sheet); assertTrue(xlsxWriter.hasSheet("test")); }
@Test void testHasSheetFalse() { when(workbook.getSheet("test")).thenReturn(null); assertFalse(xlsxWriter.hasSheet("test")); }
|
### Question:
EntityListenersService { Stream<Entity> updateEntities(String repoFullName, Stream<Entity> entities) { lock.readLock().lock(); try { verifyRepoRegistered(repoFullName); SetMultimap<Object, EntityListener> entityListeners = this.entityListenersByRepo.get(repoFullName); return entities.filter( entity -> { Set<EntityListener> entityEntityListeners = entityListeners.get(entity.getIdValue()); entityEntityListeners.forEach(entityListener -> entityListener.postUpdate(entity)); return true; }); } finally { lock.readLock().unlock(); } } void addEntityListener(String repoFullName, EntityListener entityListener); boolean removeEntityListener(String repoFullName, EntityListener entityListener); }### Answer:
@Test void updateEntitiesTest() { String repoFullName = "EntityRepo"; Entity entity1 = Mockito.mock(Entity.class); Entity entity2 = Mockito.mock(Entity.class); entityListenersService.register(repoFullName); EntityListener entityListener1 = Mockito.when(Mockito.mock(EntityListener.class).getEntityId()).thenReturn(1).getMock(); EntityListener entityListener2 = Mockito.when(Mockito.mock(EntityListener.class).getEntityId()).thenReturn(2).getMock(); Mockito.when(entity1.getIdValue()).thenReturn(1).getMock(); Mockito.when(entity2.getIdValue()).thenReturn(2).getMock(); entityListenersService.addEntityListener(repoFullName, entityListener1); entityListenersService.addEntityListener(repoFullName, entityListener2); entityListenersService .updateEntities(repoFullName, Stream.of(entity1, entity2)) .collect(Collectors.toList()); Mockito.verify(entityListener1).postUpdate(entity1); Mockito.verify(entityListener2).postUpdate(entity2); entityListenersService.removeEntityListener(repoFullName, entityListener1); entityListenersService.removeEntityListener(repoFullName, entityListener2); assertTrue(entityListenersService.isEmpty(repoFullName)); }
|
### Question:
XlsxWriter implements AutoCloseable { public void createSheet(String name, List<Object> headers) { try { if (name.length() <= MAXIMUM_SHEET_LENGTH) { Sheet sheet = workbook.getSheet(name); if (sheet == null) { sheet = workbook.createSheet(name); writeRow(headers, sheet, 0); } } else { throw new MaximumSheetNameLengthExceededException(name); } } catch (MaximumSheetNameLengthExceededException e) { throw e; } catch (RuntimeException e) { throw new XlsxWriterException(e); } } XlsxWriter(Path target, Workbook workbook); boolean hasSheet(String name); void createSheet(String name, List<Object> headers); void writeRows(Stream<List<Object>> rows, String sheetName); @Override void close(); }### Answer:
@Test void testCreateSheet() { Cell cell0 = mock(Cell.class); Cell cell1 = mock(Cell.class); Row row = mock(Row.class); doReturn(cell0).when(row).createCell(0); doReturn(cell1).when(row).createCell(1); when(sheet.createRow(0)).thenReturn(row); when(workbook.getSheet("test")).thenReturn(null); when(workbook.createSheet("test")).thenReturn(sheet); xlsxWriter.createSheet("test", asList("head1", "head2")); verify(cell0).setCellValue("head1"); verify(cell1).setCellValue("head2"); }
|
### Question:
XlsxWriter implements AutoCloseable { @Override public void close() throws IOException { try { workbook.write(Files.newOutputStream(target)); } catch (RuntimeException e) { throw new XlsxWriterException(e); } finally { workbook.close(); } } XlsxWriter(Path target, Workbook workbook); boolean hasSheet(String name); void createSheet(String name, List<Object> headers); void writeRows(Stream<List<Object>> rows, String sheetName); @Override void close(); }### Answer:
@Test void testClose() throws IOException { xlsxWriter.close(); verify(workbook).close(); }
|
### Question:
ExcelSheetWriter extends AbstractWritable { public void addCellProcessor(CellProcessor cellProcessor) { if (cellProcessors == null) cellProcessors = new ArrayList<>(); cellProcessors.add(cellProcessor); } ExcelSheetWriter(
Sheet sheet,
Iterable<Attribute> attributes,
AttributeWriteMode attributeWriteMode,
List<CellProcessor> cellProcessors); @Override void add(Entity entity); void writeAttributeHeaders(
Iterable<Attribute> attributes, AttributeWriteMode attributeWriteMode); void addCellProcessor(CellProcessor cellProcessor); @Override void close(); @Override void flush(); @Override void clearCache(); }### Answer:
@Test void addCellProcessor() { CellProcessor processor = when(mock(CellProcessor.class).processData()).thenReturn(true).getMock(); Entity entity = new DynamicEntity(mock(EntityType.class)) { @Override protected void validateValueType(String attrName, Object value) { } }; entity.set("col1", "val1"); entity.set("col2", "val2"); excelSheetWriter.addCellProcessor(processor); excelSheetWriter.add(entity); verify(processor).process("val1"); verify(processor).process("val2"); }
|
### Question:
EntityListenersService { void updateEntity(String repoFullName, Entity entity) { lock.readLock().lock(); try { verifyRepoRegistered(repoFullName); SetMultimap<Object, EntityListener> entityListeners = this.entityListenersByRepo.get(repoFullName); Set<EntityListener> entityEntityListeners = entityListeners.get(entity.getIdValue()); entityEntityListeners.forEach(entityListener -> entityListener.postUpdate(entity)); } finally { lock.readLock().unlock(); } } void addEntityListener(String repoFullName, EntityListener entityListener); boolean removeEntityListener(String repoFullName, EntityListener entityListener); }### Answer:
@Test void updateEntityTest() { String repoFullName = "EntityRepo"; Entity entity = Mockito.mock(Entity.class); EntityListener entityListener1 = Mockito.when(Mockito.mock(EntityListener.class).getEntityId()).thenReturn(1).getMock(); EntityListener entityListener2 = Mockito.when(Mockito.mock(EntityListener.class).getEntityId()).thenReturn(1).getMock(); Mockito.when(entity.getIdValue()).thenReturn(1).getMock(); entityListenersService.register(repoFullName); entityListenersService.addEntityListener(repoFullName, entityListener1); entityListenersService.addEntityListener(repoFullName, entityListener2); entityListenersService.updateEntity(repoFullName, entity); Mockito.verify(entityListener1).postUpdate(entity); Mockito.verify(entityListener2).postUpdate(entity); entityListenersService.removeEntityListener(repoFullName, entityListener1); entityListenersService.removeEntityListener(repoFullName, entityListener2); assertTrue(entityListenersService.isEmpty(repoFullName)); }
|
### Question:
ExcelRepositoryCollection extends FileRepositoryCollection { @Override public Repository<Entity> getRepository(String name) { Sheet poiSheet = workbook.getSheet(name); if (poiSheet == null) { return null; } return new ExcelRepository(poiSheet, entityTypeFactory, attributeFactory, cellProcessors); } ExcelRepositoryCollection(File file); ExcelRepositoryCollection(File file, CellProcessor... cellProcessors); ExcelRepositoryCollection(InputStream in, CellProcessor... cellProcessors); @Override void init(); @Override Iterable<String> getEntityTypeIds(); @Override Repository<Entity> getRepository(String name); int getNumberOfSheets(); String getSheetName(int i); ExcelRepository getSheet(int i); @Override String getName(); @Override Iterator<Repository<Entity>> iterator(); @Override boolean hasRepository(String name); @Override boolean hasRepository(EntityType entityType); @Autowired void setEntityTypeFactory(EntityTypeFactory entityTypeFactory); @Autowired void setAttributeFactory(AttributeFactory attributeFactory); }### Answer:
@Test void testGetRepository() { assertNotNull(excelRepositoryCollection.getRepository("attributes")); }
@Test void testGetRepositoryNotExists() { assertNull(excelRepositoryCollection.getRepository("blaat")); }
|
### Question:
ExcelRepositoryCollection extends FileRepositoryCollection { public ExcelRepository getSheet(int i) { Sheet poiSheet = workbook.getSheetAt(i); if (poiSheet == null) { return null; } return new ExcelRepository(poiSheet, entityTypeFactory, attributeFactory, cellProcessors); } ExcelRepositoryCollection(File file); ExcelRepositoryCollection(File file, CellProcessor... cellProcessors); ExcelRepositoryCollection(InputStream in, CellProcessor... cellProcessors); @Override void init(); @Override Iterable<String> getEntityTypeIds(); @Override Repository<Entity> getRepository(String name); int getNumberOfSheets(); String getSheetName(int i); ExcelRepository getSheet(int i); @Override String getName(); @Override Iterator<Repository<Entity>> iterator(); @Override boolean hasRepository(String name); @Override boolean hasRepository(EntityType entityType); @Autowired void setEntityTypeFactory(EntityTypeFactory entityTypeFactory); @Autowired void setAttributeFactory(AttributeFactory attributeFactory); }### Answer:
@Test void testGetSheet() { assertNotNull(excelRepositoryCollection.getSheet(0)); }
@Test void testGetSheetNotExists() { assertThrows(IllegalArgumentException.class, () -> excelRepositoryCollection.getSheet(123)); }
|
### Question:
ExcelWriter implements WritableFactory { public ExcelWriter(OutputStream os, AttributeFactory attrMetaFactory) { this(os, attrMetaFactory, FileFormat.XLS); } ExcelWriter(OutputStream os, AttributeFactory attrMetaFactory); ExcelWriter(OutputStream os, AttributeFactory attrMetaFactory, FileFormat format); void addCellProcessor(CellProcessor cellProcessor); @Override ExcelSheetWriter createWritable(
String entityTypeId, Iterable<Attribute> attributes, AttributeWriteMode attributeWriteMode); @Override void close(); @Override ExcelSheetWriter createWritable(String entityTypeId, List<String> attributeNames); }### Answer:
@SuppressWarnings("resource") @Test void ExcelWriter() { assertThrows( NullPointerException.class, () -> new ExcelWriter((OutputStream) null, attrMetaFactory)); }
|
### Question:
ExcelWriter implements WritableFactory { @Override public ExcelSheetWriter createWritable( String entityTypeId, Iterable<Attribute> attributes, AttributeWriteMode attributeWriteMode) { Sheet poiSheet = workbook.createSheet(entityTypeId); return new ExcelSheetWriter(poiSheet, attributes, attributeWriteMode, cellProcessors); } ExcelWriter(OutputStream os, AttributeFactory attrMetaFactory); ExcelWriter(OutputStream os, AttributeFactory attrMetaFactory, FileFormat format); void addCellProcessor(CellProcessor cellProcessor); @Override ExcelSheetWriter createWritable(
String entityTypeId, Iterable<Attribute> attributes, AttributeWriteMode attributeWriteMode); @Override void close(); @Override ExcelSheetWriter createWritable(String entityTypeId, List<String> attributeNames); }### Answer:
@Test void createSheet() throws IOException { OutputStream os = mock(OutputStream.class); try (ExcelWriter excelWriter = new ExcelWriter(os, attrMetaFactory)) { assertNotNull(excelWriter.createWritable("sheet", null)); } }
@Test void createSheet_null() throws IOException { OutputStream os = mock(OutputStream.class); try (ExcelWriter excelWriter = new ExcelWriter(os, attrMetaFactory)) { assertThrows(IllegalArgumentException.class, () -> excelWriter.createWritable(null, null)); } }
|
### Question:
EntityListenersService { public void addEntityListener(String repoFullName, EntityListener entityListener) { lock.writeLock().lock(); try { verifyRepoRegistered(repoFullName); SetMultimap<Object, EntityListener> entityListeners = this.entityListenersByRepo.get(repoFullName); entityListeners.put(entityListener.getEntityId(), entityListener); } finally { lock.writeLock().unlock(); } } void addEntityListener(String repoFullName, EntityListener entityListener); boolean removeEntityListener(String repoFullName, EntityListener entityListener); }### Answer:
@Test void addEntityListenerTest() { String repoFullName = "EntityRepo"; EntityListener entityListener = Mockito.when(Mockito.mock(EntityListener.class).getEntityId()).thenReturn(1).getMock(); entityListenersService.register(repoFullName); entityListenersService.addEntityListener(repoFullName, entityListener); Mockito.verify(entityListener).getEntityId(); entityListenersService.removeEntityListener(repoFullName, entityListener); assertTrue(entityListenersService.isEmpty(repoFullName)); }
|
### Question:
SpringExceptionHandler { @ExceptionHandler(HttpRequestMethodNotSupportedException.class) public final Object handleSpringMethodNotAllowedException( Exception e, HttpServletRequest request) { return logAndHandleException(e, METHOD_NOT_ALLOWED, request); } @ExceptionHandler(HttpRequestMethodNotSupportedException.class) final Object handleSpringMethodNotAllowedException(
Exception e, HttpServletRequest request); @ExceptionHandler(NoHandlerFoundException.class) final Object handleSpringNotFoundException(Exception e, HttpServletRequest request); @ExceptionHandler(MaxUploadSizeExceededException.class) final Object handleSpringPayloadTooLargeException(
Exception e, HttpServletRequest request); @ExceptionHandler(HttpMediaTypeNotSupportedException.class) final Object handleSpringUnsupportedMediaTypeException(
Exception e, HandlerMethod handlerMethod); @ExceptionHandler(HttpMediaTypeNotAcceptableException.class) final Object handleSpringNotAcceptableException(Exception e, HandlerMethod handlerMethod); @ExceptionHandler({ MissingServletRequestParameterException.class, ServletRequestBindingException.class, TypeMismatchException.class, HttpMessageNotReadableException.class, MethodArgumentNotValidException.class, MissingServletRequestPartException.class, BindException.class, ConstraintViolationException.class }) final Object handleSpringBadRequestException(Exception e, HandlerMethod handlerMethod); @ExceptionHandler(AsyncRequestTimeoutException.class) final Object handleSpringServiceUnavailableException(
Exception e, HandlerMethod handlerMethod); }### Answer:
@Test void testHandleSpringMethodNotAllowedException() { Exception e = mock(Exception.class); HttpServletRequest request = new MockHttpServletRequest(); springExceptionHandler.handleSpringMethodNotAllowedException(e, request); verify(springExceptionHandler).logAndHandleException(e, METHOD_NOT_ALLOWED, request); }
|
### Question:
ExcelEntity extends DynamicEntity { @Override public void set(String attributeName, Object value) { if (cachedValueMap == null) { cachedValueMap = new LinkedHashMap<>(); } cachedValueMap.put(attributeName, value); } ExcelEntity(
Row row,
Map<String, Integer> colNamesMap,
List<CellProcessor> cellProcessors,
EntityType entityType); @Override Object get(String attributeName); @Override void set(String attributeName, Object value); @Override void set(Entity values); @Override String toString(); @Override Iterable<String> getAttributeNames(); }### Answer:
@Test void set() { excelEntity.set("attr1", "test"); assertEquals("test", excelEntity.get("attr1")); }
|
### Question:
ExcelRepository extends AbstractRepository { public ExcelRepository( Sheet sheet, EntityTypeFactory entityTypeFactory, AttributeFactory attrMetaFactory) { this(sheet, entityTypeFactory, attrMetaFactory, null); } ExcelRepository(
Sheet sheet, EntityTypeFactory entityTypeFactory, AttributeFactory attrMetaFactory); ExcelRepository(
Sheet sheet,
EntityTypeFactory entityTypeFactory,
AttributeFactory attrMetaFactory,
List<CellProcessor> cellProcessors); int getNrRows(); @Override Iterator<Entity> iterator(); void addCellProcessor(CellProcessor cellProcessor); EntityType getEntityType(); @Override Set<RepositoryCapability> getCapabilities(); @Override long count(); }### Answer:
@SuppressWarnings({"resource", "deprecation"}) @Test void ExcelRepository() { assertThrows( MolgenisDataException.class, () -> new ExcelRepository( workbook.getSheet("test_mergedcells"), entityTypeFactory, attrMetaFactory)); }
|
### Question:
EntityListenersService { public boolean removeEntityListener(String repoFullName, EntityListener entityListener) { lock.writeLock().lock(); try { verifyRepoRegistered(repoFullName); SetMultimap<Object, EntityListener> entityListeners = this.entityListenersByRepo.get(repoFullName); if (entityListeners.containsKey(entityListener.getEntityId())) { entityListeners.remove(entityListener.getEntityId(), entityListener); return true; } return false; } finally { lock.writeLock().unlock(); } } void addEntityListener(String repoFullName, EntityListener entityListener); boolean removeEntityListener(String repoFullName, EntityListener entityListener); }### Answer:
@Test void removeEntityListenerTest() { String repoFullName = "EntityRepo"; EntityListener entityListener = Mockito.when(Mockito.mock(EntityListener.class).getEntityId()).thenReturn(1).getMock(); entityListenersService.register(repoFullName); entityListenersService.addEntityListener(repoFullName, entityListener); assertFalse(entityListenersService.isEmpty(repoFullName)); entityListenersService.removeEntityListener(repoFullName, entityListener); assertTrue(entityListenersService.isEmpty(repoFullName)); }
|
### Question:
ExcelRepository extends AbstractRepository { public void addCellProcessor(CellProcessor cellProcessor) { if (cellProcessors == null) cellProcessors = new ArrayList<>(); cellProcessors.add(cellProcessor); } ExcelRepository(
Sheet sheet, EntityTypeFactory entityTypeFactory, AttributeFactory attrMetaFactory); ExcelRepository(
Sheet sheet,
EntityTypeFactory entityTypeFactory,
AttributeFactory attrMetaFactory,
List<CellProcessor> cellProcessors); int getNrRows(); @Override Iterator<Entity> iterator(); void addCellProcessor(CellProcessor cellProcessor); EntityType getEntityType(); @Override Set<RepositoryCapability> getCapabilities(); @Override long count(); }### Answer:
@Test void addCellProcessor_header() { CellProcessor processor = mock(CellProcessor.class); when(processor.processHeader()).thenReturn(true); when(processor.process("col1")).thenReturn("col1"); when(processor.process("col2")).thenReturn("col2"); excelSheetReader.addCellProcessor(processor); for (@SuppressWarnings("unused") Entity entity : excelSheetReader) {} verify(processor).process("col1"); verify(processor).process("col2"); }
@Test void addCellProcessor_data() { CellProcessor processor = when(mock(CellProcessor.class).processData()).thenReturn(true).getMock(); excelSheetReader.addCellProcessor(processor); for (Entity entity : excelSheetReader) entity.get("col2"); verify(processor).process("val2"); verify(processor).process("val4"); verify(processor).process("val6"); }
|
### Question:
ExcelRepository extends AbstractRepository { public EntityType getEntityType() { if (entityType == null) { String sheetName = sheet.getSheetName(); EntityType newEntityType = entityTypeFactory.create(sheetName).setLabel(sheetName); if (colNamesMap == null) { Iterator<Row> it = sheet.iterator(); if (it.hasNext()) { colNamesMap = toColNamesMap(it.next()); } } if (colNamesMap != null) { for (String colName : colNamesMap.keySet()) { newEntityType.addAttribute(attrMetaFactory.create().setName(colName).setDataType(STRING)); } } this.entityType = newEntityType; } return entityType; } ExcelRepository(
Sheet sheet, EntityTypeFactory entityTypeFactory, AttributeFactory attrMetaFactory); ExcelRepository(
Sheet sheet,
EntityTypeFactory entityTypeFactory,
AttributeFactory attrMetaFactory,
List<CellProcessor> cellProcessors); int getNrRows(); @Override Iterator<Entity> iterator(); void addCellProcessor(CellProcessor cellProcessor); EntityType getEntityType(); @Override Set<RepositoryCapability> getCapabilities(); @Override long count(); }### Answer:
@Test void getAttribute() { Attribute attr = excelSheetReader.getEntityType().getAttribute("col1"); assertNotNull(attr); assertEquals(STRING, attr.getDataType()); assertEquals("col1", attr.getName()); }
@Test void getDescription() { assertNull(excelSheetReader.getEntityType().getDescription()); }
@Test void getIdAttribute() { assertNull(excelSheetReader.getEntityType().getIdAttribute()); }
@Test void getLabel() { assertEquals("test", excelSheetReader.getEntityType().getLabel()); }
@Test void getLabelAttribute() { assertNull(excelSheetReader.getEntityType().getLabelAttribute()); }
|
### Question:
ExcelRepository extends AbstractRepository { public int getNrRows() { return sheet.getLastRowNum() + 1; } ExcelRepository(
Sheet sheet, EntityTypeFactory entityTypeFactory, AttributeFactory attrMetaFactory); ExcelRepository(
Sheet sheet,
EntityTypeFactory entityTypeFactory,
AttributeFactory attrMetaFactory,
List<CellProcessor> cellProcessors); int getNrRows(); @Override Iterator<Entity> iterator(); void addCellProcessor(CellProcessor cellProcessor); EntityType getEntityType(); @Override Set<RepositoryCapability> getCapabilities(); @Override long count(); }### Answer:
@Test void getNrRows() { assertEquals(5, excelSheetReader.getNrRows()); }
|
### Question:
EntityListenersService { boolean isEmpty(String repoFullName) { lock.readLock().lock(); try { verifyRepoRegistered(repoFullName); return entityListenersByRepo.get(repoFullName).isEmpty(); } finally { lock.readLock().unlock(); } } void addEntityListener(String repoFullName, EntityListener entityListener); boolean removeEntityListener(String repoFullName, EntityListener entityListener); }### Answer:
@Test void isEmptyTest() { String repoFullName = "EntityRepo"; entityListenersService.register(repoFullName); assertTrue(entityListenersService.isEmpty(repoFullName)); }
@Test void noExceptionsStressTest() { List<Thread> ts = new ArrayList<>(); ts.add(new NewThread("EntityRepo1", 0, 10).getThread()); ts.add(new NewThread("EntityRepo1", 0, 10).getThread()); ts.add(new NewThread("EntityRepo2", 0, 10).getThread()); ts.add(new NewThread("EntityRepo2", 0, 10).getThread()); ts.forEach( t -> { try { t.join(); } catch (InterruptedException e) { throw new RuntimeException(e); } }); ts.forEach(t -> assertFalse(t.isAlive())); assertTrue(entityListenersService.isEmpty("EntityRepo1")); assertTrue(entityListenersService.isEmpty("EntityRepo2")); }
|
### Question:
Icd10ExpanderDecorator extends AbstractRepositoryDecorator<Entity> { @Override public long count(Query<Entity> query) { query = query != null ? transformQuery(query) : null; return delegate().count(query); } Icd10ExpanderDecorator(
Repository<Entity> delegateRepository,
CollectionsQueryTransformer queryTransformer,
String icd10EntityTypeId,
String expandAttribute); @Override long count(Query<Entity> query); @Override Entity findOne(Query<Entity> query); @Override Stream<Entity> findAll(Query<Entity> query); @Override AggregateResult aggregate(AggregateQuery aggregateQuery); }### Answer:
@Test void testCount() { when(decoratedRepository.count(transformedQuery)).thenReturn(123L); assertEquals(123L, icd10ExpanderDecorator.count(query)); }
|
### Question:
Icd10ExpanderDecorator extends AbstractRepositoryDecorator<Entity> { @Override public Entity findOne(Query<Entity> query) { query = query != null ? transformQuery(query) : null; return delegate().findOne(query); } Icd10ExpanderDecorator(
Repository<Entity> delegateRepository,
CollectionsQueryTransformer queryTransformer,
String icd10EntityTypeId,
String expandAttribute); @Override long count(Query<Entity> query); @Override Entity findOne(Query<Entity> query); @Override Stream<Entity> findAll(Query<Entity> query); @Override AggregateResult aggregate(AggregateQuery aggregateQuery); }### Answer:
@Test void testFindOne() { Entity entity = mock(Entity.class); when(decoratedRepository.findOne(transformedQuery)).thenReturn(entity); assertEquals(entity, icd10ExpanderDecorator.findOne(query)); }
|
### Question:
Icd10ExpanderDecorator extends AbstractRepositoryDecorator<Entity> { @Override public Stream<Entity> findAll(Query<Entity> query) { query = query != null ? transformQuery(query) : null; return delegate().findAll(query); } Icd10ExpanderDecorator(
Repository<Entity> delegateRepository,
CollectionsQueryTransformer queryTransformer,
String icd10EntityTypeId,
String expandAttribute); @Override long count(Query<Entity> query); @Override Entity findOne(Query<Entity> query); @Override Stream<Entity> findAll(Query<Entity> query); @Override AggregateResult aggregate(AggregateQuery aggregateQuery); }### Answer:
@Test void testFindAll() { Stream<Entity> entities = Stream.empty(); when(decoratedRepository.findAll(transformedQuery)).thenReturn(entities); assertEquals(entities, icd10ExpanderDecorator.findAll(query)); }
|
### Question:
PluginRepositoryDecorator extends AbstractRepositoryDecorator<Plugin> { PluginRepositoryDecorator(Repository<Plugin> delegateRepository, AppSettings appSettings) { super(delegateRepository); this.appSettings = requireNonNull(appSettings); this.gson = new Gson(); } PluginRepositoryDecorator(Repository<Plugin> delegateRepository, AppSettings appSettings); @Override void delete(Plugin plugin); @Override void deleteById(Object id); @Override void deleteAll(); @Override void delete(Stream<Plugin> pluginStream); @Override void deleteAll(Stream<Object> ids); }### Answer:
@Test void testPluginRepositoryDecorator() { assertThrows(NullPointerException.class, () -> new PluginRepositoryDecorator(null, null)); }
|
### Question:
PluginRepositoryDecorator extends AbstractRepositoryDecorator<Plugin> { @Override public void delete(Plugin plugin) { super.delete(plugin); deleteMenuEntries(plugin); } PluginRepositoryDecorator(Repository<Plugin> delegateRepository, AppSettings appSettings); @Override void delete(Plugin plugin); @Override void deleteById(Object id); @Override void deleteAll(); @Override void delete(Stream<Plugin> pluginStream); @Override void deleteAll(Stream<Object> ids); }### Answer:
@Test void testDelete() { String pluginId = "myPluginId"; Plugin plugin = when(mock(Plugin.class).getId()).thenReturn(pluginId).getMock(); String menu = "{\"type\":\"menu\",\"id\":\"main\",\"items\":[{\"type\":\"plugin\",\"id\":\"myPluginId\"}]}"; when(appSettings.getMenu()).thenReturn(menu); pluginRepositoryDecorator.delete(plugin); verify(delegateRepository).delete(plugin); verify(appSettings).setMenu("{\"type\":\"menu\",\"id\":\"main\",\"items\":[]}"); }
|
### Question:
PluginRepositoryDecorator extends AbstractRepositoryDecorator<Plugin> { @Override public void deleteById(Object id) { super.deleteById(id); deleteMenuEntriesById(id); } PluginRepositoryDecorator(Repository<Plugin> delegateRepository, AppSettings appSettings); @Override void delete(Plugin plugin); @Override void deleteById(Object id); @Override void deleteAll(); @Override void delete(Stream<Plugin> pluginStream); @Override void deleteAll(Stream<Object> ids); }### Answer:
@Test void testDeleteById() { String pluginId = "myPluginId"; String menu = "{\"type\":\"menu\",\"id\":\"main\",\"items\":[{\"type\":\"plugin\",\"id\":\"myPluginId\"}]}"; when(appSettings.getMenu()).thenReturn(menu); pluginRepositoryDecorator.deleteById(pluginId); verify(delegateRepository).deleteById(pluginId); verify(appSettings).setMenu("{\"type\":\"menu\",\"id\":\"main\",\"items\":[]}"); }
|
### Question:
PluginRepositoryDecorator extends AbstractRepositoryDecorator<Plugin> { @Override public void deleteAll() { forEachBatched(this::deleteBatch, BATCH_SIZE); } PluginRepositoryDecorator(Repository<Plugin> delegateRepository, AppSettings appSettings); @Override void delete(Plugin plugin); @Override void deleteById(Object id); @Override void deleteAll(); @Override void delete(Stream<Plugin> pluginStream); @Override void deleteAll(Stream<Object> ids); }### Answer:
@Test void testDeleteAll() { String pluginId = "myPluginId"; Plugin plugin = when(mock(Plugin.class).getId()).thenReturn(pluginId).getMock(); doAnswer( invocation -> { Consumer<List<Plugin>> consumer = invocation.getArgument(1); consumer.accept(singletonList(plugin)); return null; }) .when(delegateRepository) .forEachBatched(any(), any(), eq(1000)); String menu = "{\"type\":\"menu\",\"id\":\"main\",\"items\":[{\"type\":\"plugin\",\"id\":\"myPluginId\"}]}"; when(appSettings.getMenu()).thenReturn(menu); pluginRepositoryDecorator.deleteAll(); @SuppressWarnings("unchecked") ArgumentCaptor<Stream<Plugin>> pluginCaptor = ArgumentCaptor.forClass(Stream.class); verify(delegateRepository).delete(pluginCaptor.capture()); assertEquals(singletonList(plugin), pluginCaptor.getValue().collect(toList())); verify(appSettings).setMenu("{\"type\":\"menu\",\"id\":\"main\",\"items\":[]}"); }
|
### Question:
PluginSecurityRepositoryDecorator extends AbstractRepositoryDecorator<Plugin> { PluginSecurityRepositoryDecorator( Repository<Plugin> delegateRepository, MutableAclService mutableAclService) { super(delegateRepository); this.mutableAclService = mutableAclService; } PluginSecurityRepositoryDecorator(
Repository<Plugin> delegateRepository, MutableAclService mutableAclService); @Override void add(Plugin plugin); @Override Integer add(Stream<Plugin> pluginStream); @Override void delete(Plugin plugin); @Override void deleteById(Object pluginId); @Override void deleteAll(); @Override void delete(Stream<Plugin> pluginStream); @Override void deleteAll(Stream<Object> ids); }### Answer:
@Test void testPluginSecurityRepositoryDecorator() { assertThrows( NullPointerException.class, () -> new PluginSecurityRepositoryDecorator(null, null)); }
|
### Question:
PluginSecurityRepositoryDecorator extends AbstractRepositoryDecorator<Plugin> { @Override public void add(Plugin plugin) { createAcl(plugin); super.add(plugin); } PluginSecurityRepositoryDecorator(
Repository<Plugin> delegateRepository, MutableAclService mutableAclService); @Override void add(Plugin plugin); @Override Integer add(Stream<Plugin> pluginStream); @Override void delete(Plugin plugin); @Override void deleteById(Object pluginId); @Override void deleteAll(); @Override void delete(Stream<Plugin> pluginStream); @Override void deleteAll(Stream<Object> ids); }### Answer:
@Test void testAdd() { Plugin plugin = when(mock(Plugin.class).getId()).thenReturn("plugin0").getMock(); pluginSecurityRepositoryDecorator.add(plugin); verify(mutableAclService).createAcl(new PluginIdentity("plugin0")); verify(delegateRepository).add(plugin); }
|
### Question:
EntityListenersService { private void verifyRepoRegistered(String repoFullName) { lock.readLock().lock(); try { if (!entityListenersByRepo.containsKey(requireNonNull(repoFullName))) { LOG.error( "Repository [{}] is not registered in the entity listeners service", repoFullName); throw new MolgenisDataException( "Repository [" + repoFullName + "] is not registered, please contact your administrator"); } } finally { lock.readLock().unlock(); } } void addEntityListener(String repoFullName, EntityListener entityListener); boolean removeEntityListener(String repoFullName, EntityListener entityListener); }### Answer:
@Test void verifyRepoRegistered() { this.entityListenersService = new EntityListenersService(); String repoFullName = "EntityRepo"; EntityListener entityListener = Mockito.when(Mockito.mock(EntityListener.class).getEntityId()).thenReturn(1).getMock(); try { entityListenersService.addEntityListener(repoFullName, entityListener); } catch (MolgenisDataException mde) { entityListenersService.register(repoFullName); assertTrue(entityListenersService.isEmpty(repoFullName)); assertEquals( "Repository [EntityRepo] is not registered, please contact your administrator", mde.getMessage()); return; } fail(); }
|
### Question:
PluginSecurityRepositoryDecorator extends AbstractRepositoryDecorator<Plugin> { @Override public void delete(Plugin plugin) { deleteAcl(plugin); super.delete(plugin); } PluginSecurityRepositoryDecorator(
Repository<Plugin> delegateRepository, MutableAclService mutableAclService); @Override void add(Plugin plugin); @Override Integer add(Stream<Plugin> pluginStream); @Override void delete(Plugin plugin); @Override void deleteById(Object pluginId); @Override void deleteAll(); @Override void delete(Stream<Plugin> pluginStream); @Override void deleteAll(Stream<Object> ids); }### Answer:
@Test void testDelete() { Plugin plugin = when(mock(Plugin.class).getId()).thenReturn("plugin0").getMock(); pluginSecurityRepositoryDecorator.delete(plugin); verify(mutableAclService).deleteAcl(new PluginIdentity("plugin0"), true); verify(delegateRepository).delete(plugin); }
|
### Question:
PluginSecurityRepositoryDecorator extends AbstractRepositoryDecorator<Plugin> { @Override public void deleteById(Object pluginId) { deleteAcl(pluginId.toString()); super.deleteById(pluginId); } PluginSecurityRepositoryDecorator(
Repository<Plugin> delegateRepository, MutableAclService mutableAclService); @Override void add(Plugin plugin); @Override Integer add(Stream<Plugin> pluginStream); @Override void delete(Plugin plugin); @Override void deleteById(Object pluginId); @Override void deleteAll(); @Override void delete(Stream<Plugin> pluginStream); @Override void deleteAll(Stream<Object> ids); }### Answer:
@Test void testDeleteById() { pluginSecurityRepositoryDecorator.deleteById("plugin0"); verify(mutableAclService).deleteAcl(new PluginIdentity("plugin0"), true); verify(delegateRepository).deleteById("plugin0"); }
|
### Question:
PluginSecurityRepositoryDecorator extends AbstractRepositoryDecorator<Plugin> { @Override public void deleteAll() { iterator().forEachRemaining(this::deleteAcl); super.deleteAll(); } PluginSecurityRepositoryDecorator(
Repository<Plugin> delegateRepository, MutableAclService mutableAclService); @Override void add(Plugin plugin); @Override Integer add(Stream<Plugin> pluginStream); @Override void delete(Plugin plugin); @Override void deleteById(Object pluginId); @Override void deleteAll(); @Override void delete(Stream<Plugin> pluginStream); @Override void deleteAll(Stream<Object> ids); }### Answer:
@Test void testDeleteAll() { Plugin plugin0 = when(mock(Plugin.class).getId()).thenReturn("plugin0").getMock(); Plugin plugin1 = when(mock(Plugin.class).getId()).thenReturn("plugin1").getMock(); when(delegateRepository.iterator()).thenReturn(Stream.of(plugin0, plugin1).iterator()); pluginSecurityRepositoryDecorator.deleteAll(); verify(delegateRepository).deleteAll(); verify(mutableAclService).deleteAcl(new PluginIdentity("plugin0"), true); verify(mutableAclService).deleteAcl(new PluginIdentity("plugin1"), true); }
|
### Question:
ExpressionValidator { List<Boolean> resolveBooleanExpressions(List<String> expressions, Entity entity) { if (expressions.isEmpty()) { return Collections.emptyList(); } return jsMagmaScriptEvaluator.eval(expressions, entity).stream() .map(this::convertToBoolean) .collect(toList()); } ExpressionValidator(JsMagmaScriptEvaluator jsMagmaScriptEvaluator); }### Answer:
@Test void testResolveBooleanExpressions() { List<String> expressions = Arrays.asList("a", "b"); when(jsMagmaScriptEvaluator.eval(expressions, entity)).thenReturn(Arrays.asList(TRUE, FALSE)); assertEquals( asList(true, false), expressionValidator.resolveBooleanExpressions(expressions, entity)); }
|
### Question:
DefaultValueReferenceValidatorImpl implements DefaultValueReferenceValidator { DefaultValueReferenceValidatorImpl(DataService dataService) { this.dataService = requireNonNull(dataService); } DefaultValueReferenceValidatorImpl(DataService dataService); @Override void validateEntityNotReferenced(Entity entity); @Override Stream<Entity> validateEntitiesNotReferenced(
Stream<Entity> entityStream, EntityType entityType); @Override void validateEntityNotReferencedById(Object entityId, EntityType entityType); @Override Stream<Object> validateEntitiesNotReferencedById(
Stream<Object> entityIdStream, EntityType entityType); @Override void validateEntityTypeNotReferenced(EntityType entityType); }### Answer:
@Test void testDefaultValueReferenceValidatorImpl() { assertThrows(NullPointerException.class, () -> new DefaultValueReferenceValidatorImpl(null)); }
|
### Question:
DefaultValueReferenceValidatorImpl implements DefaultValueReferenceValidator { @Override public void validateEntityNotReferenced(Entity entity) { validateEntityNotReferencedById(entity.getIdValue(), entity.getEntityType()); } DefaultValueReferenceValidatorImpl(DataService dataService); @Override void validateEntityNotReferenced(Entity entity); @Override Stream<Entity> validateEntitiesNotReferenced(
Stream<Entity> entityStream, EntityType entityType); @Override void validateEntityNotReferencedById(Object entityId, EntityType entityType); @Override Stream<Object> validateEntitiesNotReferencedById(
Stream<Object> entityIdStream, EntityType entityType); @Override void validateEntityTypeNotReferenced(EntityType entityType); }### Answer:
@Test void testValidateEntityNotReferenced() { Attribute attribute = createMockAttribute(AttributeType.XREF, "otherId"); initializeDataServiceMock(Stream.of(attribute)); Entity entity = createMockEntity("id"); defaultValueReferenceValidator.validateEntityNotReferenced(entity); }
@Test void testValidateEntityNotReferencedValidationException() { Attribute attribute = createMockAttribute(AttributeType.XREF, "id"); initializeDataServiceMock(Stream.of(attribute)); Entity entity = createMockEntity("id"); Exception exception = assertThrows( MolgenisValidationException.class, () -> defaultValueReferenceValidator.validateEntityNotReferenced(entity)); assertThat(exception.getMessage()) .containsPattern( "'My Entity Type' with id 'id' is referenced as default value by attribute\\(s\\): 'myAttribute'"); }
|
### Question:
DefaultValueReferenceValidatorImpl implements DefaultValueReferenceValidator { @Override public Stream<Entity> validateEntitiesNotReferenced( Stream<Entity> entityStream, EntityType entityType) { Multimap<String, Attribute> defaultValueMap = getDefaultValueMap(entityType); return entityStream.filter( entity -> { validateEntityNotReferenced(entity.getIdValue(), entityType, defaultValueMap); return true; }); } DefaultValueReferenceValidatorImpl(DataService dataService); @Override void validateEntityNotReferenced(Entity entity); @Override Stream<Entity> validateEntitiesNotReferenced(
Stream<Entity> entityStream, EntityType entityType); @Override void validateEntityNotReferencedById(Object entityId, EntityType entityType); @Override Stream<Object> validateEntitiesNotReferencedById(
Stream<Object> entityIdStream, EntityType entityType); @Override void validateEntityTypeNotReferenced(EntityType entityType); }### Answer:
@Test void testValidateEntitiesNotReferenced() { Attribute attribute = createMockAttribute(AttributeType.MREF, "id0,id1"); initializeDataServiceMock(Stream.of(attribute)); Entity entity = createMockEntity("id2"); defaultValueReferenceValidator .validateEntitiesNotReferenced(Stream.of(entity), entityType) .count(); }
@Test void testValidateEntitiesNotReferencedValidationException() { Attribute attribute = createMockAttribute(AttributeType.MREF, "id0,id1"); initializeDataServiceMock(Stream.of(attribute)); Entity entity = createMockEntity("id1"); @SuppressWarnings("ResultOfMethodCallIgnored") Exception exception = assertThrows( MolgenisValidationException.class, () -> defaultValueReferenceValidator .validateEntitiesNotReferenced(Stream.of(entity), entityType) .count()); assertThat(exception.getMessage()) .containsPattern( "'My Entity Type' with id 'id1' is referenced as default value by attribute\\(s\\): 'myAttribute'"); }
|
### Question:
DefaultValueReferenceValidatorImpl implements DefaultValueReferenceValidator { @Override public void validateEntityNotReferencedById(Object entityId, EntityType entityType) { validateEntityNotReferenced(entityId, entityType, getDefaultValueMap(entityType)); } DefaultValueReferenceValidatorImpl(DataService dataService); @Override void validateEntityNotReferenced(Entity entity); @Override Stream<Entity> validateEntitiesNotReferenced(
Stream<Entity> entityStream, EntityType entityType); @Override void validateEntityNotReferencedById(Object entityId, EntityType entityType); @Override Stream<Object> validateEntitiesNotReferencedById(
Stream<Object> entityIdStream, EntityType entityType); @Override void validateEntityTypeNotReferenced(EntityType entityType); }### Answer:
@Test void testValidateEntityNotReferencedById() { Attribute attribute = createMockAttribute(AttributeType.XREF, "otherId"); initializeDataServiceMock(Stream.of(attribute)); defaultValueReferenceValidator.validateEntityNotReferencedById("id", entityType); }
@Test void testValidateEntityNotReferencedByIdValidationException() { Attribute attribute = createMockAttribute(AttributeType.XREF, "id"); initializeDataServiceMock(Stream.of(attribute)); Exception exception = assertThrows( MolgenisValidationException.class, () -> defaultValueReferenceValidator.validateEntityNotReferencedById("id", entityType)); assertThat(exception.getMessage()) .containsPattern( "'My Entity Type' with id 'id' is referenced as default value by attribute\\(s\\): 'myAttribute'"); }
|
### Question:
DefaultValueReferenceValidatorImpl implements DefaultValueReferenceValidator { @Override public Stream<Object> validateEntitiesNotReferencedById( Stream<Object> entityIdStream, EntityType entityType) { Multimap<String, Attribute> defaultValueMap = getDefaultValueMap(entityType); return entityIdStream.filter( entityId -> { validateEntityNotReferenced(entityId, entityType, defaultValueMap); return true; }); } DefaultValueReferenceValidatorImpl(DataService dataService); @Override void validateEntityNotReferenced(Entity entity); @Override Stream<Entity> validateEntitiesNotReferenced(
Stream<Entity> entityStream, EntityType entityType); @Override void validateEntityNotReferencedById(Object entityId, EntityType entityType); @Override Stream<Object> validateEntitiesNotReferencedById(
Stream<Object> entityIdStream, EntityType entityType); @Override void validateEntityTypeNotReferenced(EntityType entityType); }### Answer:
@Test void testValidateEntitiesNotReferencedById() { Attribute attribute = createMockAttribute(AttributeType.MREF, "id0,id1"); initializeDataServiceMock(Stream.of(attribute)); defaultValueReferenceValidator .validateEntitiesNotReferencedById(Stream.of("id2"), entityType) .count(); }
@Test void testValidateEntitiesNotReferencedByIdValidationException() { Attribute attribute = createMockAttribute(AttributeType.MREF, "id0,id1"); initializeDataServiceMock(Stream.of(attribute)); Exception exception = assertThrows( MolgenisValidationException.class, () -> defaultValueReferenceValidator .validateEntitiesNotReferencedById(Stream.of("id1"), entityType) .count()); assertThat(exception.getMessage()) .containsPattern( "'My Entity Type' with id 'id1' is referenced as default value by attribute\\(s\\): 'myAttribute'"); }
|
### Question:
DefaultValueReferenceValidatorImpl implements DefaultValueReferenceValidator { @Override public void validateEntityTypeNotReferenced(EntityType entityType) { if (!getDefaultValueMap(entityType).isEmpty()) { throw new MolgenisValidationException( new ConstraintViolation( String.format( "'%s' entities are referenced as default value by attributes", entityType.getLabel()))); } } DefaultValueReferenceValidatorImpl(DataService dataService); @Override void validateEntityNotReferenced(Entity entity); @Override Stream<Entity> validateEntitiesNotReferenced(
Stream<Entity> entityStream, EntityType entityType); @Override void validateEntityNotReferencedById(Object entityId, EntityType entityType); @Override Stream<Object> validateEntitiesNotReferencedById(
Stream<Object> entityIdStream, EntityType entityType); @Override void validateEntityTypeNotReferenced(EntityType entityType); }### Answer:
@Test void testValidateEntityTypeNotReferenced() { initializeDataServiceMock(Stream.empty()); defaultValueReferenceValidator.validateEntityTypeNotReferenced(entityType); }
@Test void testValidateEntityTypeNotReferencedValidationException() { Attribute attribute = createMockAttribute(AttributeType.MREF, "id0,id1"); initializeDataServiceMock(Stream.of(attribute)); Exception exception = assertThrows( MolgenisValidationException.class, () -> defaultValueReferenceValidator.validateEntityTypeNotReferenced(entityType)); assertThat(exception.getMessage()) .containsPattern("'My Entity Type' entities are referenced as default value by attributes"); }
|
### Question:
TagValidator { @SuppressWarnings("MethodMayBeStatic") public void validate(Tag tag) { String relationIri = tag.getRelationIri(); Relation relation = Relation.forIRI(relationIri); if (relation == null) { throw new MolgenisValidationException( new ConstraintViolation(format("Unknown relation IRI [%s]", relationIri))); } } @SuppressWarnings("MethodMayBeStatic") void validate(Tag tag); }### Answer:
@Test void validateValid() { Tag tag = mock(Tag.class); when(tag.getRelationIri()).thenReturn(Relation.isRealizationOf.getIRI()); tagValidator.validate(tag); }
@SuppressWarnings("deprecation") @Test void validateInvalid() { Tag tag = mock(Tag.class); when(tag.getRelationIri()).thenReturn("blaat"); assertThrows(MolgenisValidationException.class, () -> tagValidator.validate(tag)); }
|
### Question:
AttributeRepositoryValidationDecorator extends AbstractRepositoryDecorator<Attribute> { public AttributeRepositoryValidationDecorator( Repository<Attribute> delegateRepository, AttributeValidator attributeValidator) { super(delegateRepository); this.attributeValidator = requireNonNull(attributeValidator); } AttributeRepositoryValidationDecorator(
Repository<Attribute> delegateRepository, AttributeValidator attributeValidator); @Override void update(Attribute attr); @Override void update(Stream<Attribute> attrs); @Override void add(Attribute attr); @Override Integer add(Stream<Attribute> attrs); }### Answer:
@Test void attributeRepositoryValidationDecorator() { assertThrows( NullPointerException.class, () -> new AttributeRepositoryValidationDecorator(null, null)); }
|
### Question:
PackageRepositoryDecorator extends AbstractRepositoryDecorator<Package> { public PackageRepositoryDecorator( Repository<Package> delegateRepository, DataService dataService) { super(delegateRepository); this.dataService = requireNonNull(dataService); } PackageRepositoryDecorator(
Repository<Package> delegateRepository, DataService dataService); @Override void delete(Package entity); @Override void delete(Stream<Package> entities); @Override void deleteById(Object id); @Override void deleteAll(Stream<Object> ids); @Override void deleteAll(); }### Answer:
@Test void testPackageRepositoryDecorator() { assertThrows(NullPointerException.class, () -> new PackageRepositoryDecorator(null, null)); }
|
### Question:
EntityTypeValidator { static void validateEntityId(EntityType entityType) { String id = entityType.getId(); if (!id.equals(ATTRIBUTE_META_DATA) && !id.equals(ENTITY_TYPE_META_DATA) && !id.equals(PACKAGE)) { try { NameValidator.validateEntityName(entityType.getId()); } catch (MolgenisDataException e) { throw new MolgenisValidationException(new ConstraintViolation(e.getMessage())); } } } EntityTypeValidator(DataService dataService, SystemEntityTypeRegistry systemEntityTypeRegistry); void validate(EntityType entityType); }### Answer:
@Test void testValidateEntityIdIsReservedKeyword() { when(entityType.getId()).thenReturn("logout"); Exception exception = assertThrows( MolgenisValidationException.class, () -> EntityTypeValidator.validateEntityId(entityType)); assertThat(exception.getMessage()) .containsPattern("Name \\[logout\\] is not allowed because it is a reserved keyword."); }
@Test void testValidateEntityIdValid() { when(entityType.getId()).thenReturn("entity"); EntityTypeValidator.validateEntityId(entityType); }
|
### Question:
EntityTypeValidator { static void validateEntityLabel(EntityType entityType) { String label = entityType.getLabel(); if (label != null) { if (label.isEmpty()) { throw new MolgenisValidationException( new ConstraintViolation( format("Label of EntityType [%s] is empty", entityType.getId()))); } else if (label.trim().equals("")) { throw new MolgenisValidationException( new ConstraintViolation( format("Label of EntityType [%s] contains only white space", entityType.getId()))); } } } EntityTypeValidator(DataService dataService, SystemEntityTypeRegistry systemEntityTypeRegistry); void validate(EntityType entityType); }### Answer:
@Test void testValidateLabelIsEmpty() { when(entityType.getId()).thenReturn("entity"); when(entityType.getLabel()).thenReturn(""); Exception exception = assertThrows( MolgenisValidationException.class, () -> EntityTypeValidator.validateEntityLabel(entityType)); assertThat(exception.getMessage()).containsPattern("Label of EntityType \\[entity\\] is empty"); }
@Test void testValidateLabelIsWhiteSpace() { when(entityType.getId()).thenReturn("entity"); when(entityType.getLabel()).thenReturn(" "); Exception exception = assertThrows( MolgenisValidationException.class, () -> EntityTypeValidator.validateEntityLabel(entityType)); assertThat(exception.getMessage()) .containsPattern("Label of EntityType \\[entity\\] contains only white space"); }
@Test void testValidateLabelIsValid() { when(entityType.getLabel()).thenReturn(" Label "); EntityTypeValidator.validateEntityLabel(entityType); }
|
### Question:
EntityTypeValidator { void validatePackage(EntityType entityType) { Package pack = entityType.getPackage(); if (pack != null && isSystemPackage(pack) && !systemEntityTypeRegistry.hasSystemEntityType(entityType.getId())) { throw new MolgenisValidationException( new ConstraintViolation( format( "Adding entity [%s] to system package [%s] is not allowed", entityType.getId(), pack.getId()))); } } EntityTypeValidator(DataService dataService, SystemEntityTypeRegistry systemEntityTypeRegistry); void validate(EntityType entityType); }### Answer:
@Test void testValidatePackageNonSystem() { when(entityType.getPackage()).thenReturn(aPackage); when(aPackage.getId()).thenReturn("nosys"); entityTypeValidator.validatePackage(entityType); }
@Test void testValidatePackageNull() { when(entityType.getPackage()).thenReturn(null); entityTypeValidator.validatePackage(entityType); }
@Test void testValidateSystemPackageInvalid() { when(entityType.getId()).thenReturn("entity"); when(entityType.getPackage()).thenReturn(aPackage); when(aPackage.getId()).thenReturn(PACKAGE_SYSTEM); when(systemEntityTypeRegistry.hasSystemEntityType("entity")).thenReturn(false); Exception exception = assertThrows( MolgenisValidationException.class, () -> entityTypeValidator.validatePackage(entityType)); assertThat(exception.getMessage()) .containsPattern("Adding entity \\[entity\\] to system package \\[sys\\] is not allowed"); }
@Test void testValidateSystemPackageValid() { when(entityType.getId()).thenReturn("entity"); when(entityType.getPackage()).thenReturn(aPackage); when(aPackage.getId()).thenReturn(PACKAGE_SYSTEM); when(systemEntityTypeRegistry.hasSystemEntityType("entity")).thenReturn(true); entityTypeValidator.validatePackage(entityType); }
|
### Question:
EntityTypeValidator { static void validateExtends(EntityType entityType) { EntityType entityTypeExtends = entityType.getExtends(); if (entityTypeExtends != null && !entityTypeExtends.isAbstract()) { throw new MolgenisValidationException( new ConstraintViolation( format( "EntityType [%s] is not abstract; EntityType [%s] can't extend it", entityTypeExtends.getId(), entityType.getId()))); } } EntityTypeValidator(DataService dataService, SystemEntityTypeRegistry systemEntityTypeRegistry); void validate(EntityType entityType); }### Answer:
@Test void testValidateExtendsNonAbstract() { when(entityType.getExtends()).thenReturn(parent); when(parent.isAbstract()).thenReturn(false); when(entityType.getId()).thenReturn("entity"); when(parent.getId()).thenReturn("parent"); Exception exception = assertThrows( MolgenisValidationException.class, () -> EntityTypeValidator.validateExtends(entityType)); assertThat(exception.getMessage()) .containsPattern( "EntityType \\[parent\\] is not abstract; EntityType \\[entity\\] can't extend it"); }
@Test void testValidateExtendsValid() { when(entityType.getExtends()).thenReturn(parent); when(parent.isAbstract()).thenReturn(true); EntityTypeValidator.validateExtends(entityType); }
|
### Question:
EntityTypeValidator { void validateBackend(EntityType entityType) { String backendName = entityType.getBackend(); if (!dataService.getMeta().hasBackend(backendName)) { throw new MolgenisValidationException( new ConstraintViolation(format("Unknown backend [%s]", backendName))); } } EntityTypeValidator(DataService dataService, SystemEntityTypeRegistry systemEntityTypeRegistry); void validate(EntityType entityType); }### Answer:
@Test void testValidateBackendInvalid() { when(entityType.getBackend()).thenReturn("BackendName"); when(dataService.getMeta()).thenReturn(metaDataService); when(metaDataService.hasBackend("BackendName")).thenReturn(false); Exception exception = assertThrows( MolgenisValidationException.class, () -> entityTypeValidator.validateBackend(entityType)); assertThat(exception.getMessage()).containsPattern("Unknown backend \\[BackendName\\]"); }
@Test void testValidateBackendValid() { when(entityType.getBackend()).thenReturn("BackendName"); when(dataService.getMeta()).thenReturn(metaDataService); when(metaDataService.hasBackend("BackendName")).thenReturn(true); entityTypeValidator.validateBackend(entityType); }
|
### Question:
EntityTypeValidator { public void validate(EntityType entityType) { validateEntityId(entityType); validateEntityLabel(entityType); validatePackage(entityType); validateExtends(entityType); validateOwnAttributes(entityType); Map<String, Attribute> ownAllAttrMap = stream(entityType.getOwnAllAttributes()) .collect(toLinkedMap(Attribute::getIdentifier, Function.identity())); validateOwnIdAttribute(entityType, ownAllAttrMap); validateOwnLabelAttribute(entityType, ownAllAttrMap); validateOwnLookupAttributes(entityType, ownAllAttrMap); validateLabelAttribute(entityType); validateBackend(entityType); } EntityTypeValidator(DataService dataService, SystemEntityTypeRegistry systemEntityTypeRegistry); void validate(EntityType entityType); }### Answer:
@Test void testValidateValid() { when(entityType.getId()).thenReturn("entity"); when(entityType.getLabel()).thenReturn("Label"); when(entityType.getPackage()).thenReturn(null); when(entityType.getExtends()).thenReturn(null); when(idAttr.getIdentifier()).thenReturn("abcde"); when(idAttr.getDataType()).thenReturn(STRING); when(idAttr.isUnique()).thenReturn(true); when(idAttr.isVisible()).thenReturn(true); when(entityType.getAllAttributes()).thenReturn(singletonList(idAttr)); when(entityType.getOwnAllAttributes()).thenReturn(singletonList(idAttr)); when(entityType.getOwnIdAttribute()).thenReturn(idAttr); when(entityType.getIdAttribute()).thenReturn(idAttr); when(entityType.getBackend()).thenReturn("PostgreSQL"); when(dataService.getMeta()).thenReturn(metaDataService); when(metaDataService.hasBackend("PostgreSQL")).thenReturn(true); entityTypeValidator.validate(entityType); }
|
### Question:
TagRepositoryValidationDecorator extends AbstractRepositoryDecorator<Tag> { public TagRepositoryValidationDecorator( Repository<Tag> delegateRepository, TagValidator tagValidator) { super(delegateRepository); this.tagValidator = requireNonNull(tagValidator); } TagRepositoryValidationDecorator(
Repository<Tag> delegateRepository, TagValidator tagValidator); @Override void update(Tag tag); @Override void add(Tag tag); @Override Integer add(Stream<Tag> tagStream); @Override void update(Stream<Tag> tagStream); }### Answer:
@Test void tagRepositoryValidationDecorator() { assertThrows( NullPointerException.class, () -> new TagRepositoryValidationDecorator(null, null)); }
|
### Question:
SpringExceptionHandler { @ExceptionHandler(NoHandlerFoundException.class) public final Object handleSpringNotFoundException(Exception e, HttpServletRequest request) { return logAndHandleException(e, NOT_FOUND, request); } @ExceptionHandler(HttpRequestMethodNotSupportedException.class) final Object handleSpringMethodNotAllowedException(
Exception e, HttpServletRequest request); @ExceptionHandler(NoHandlerFoundException.class) final Object handleSpringNotFoundException(Exception e, HttpServletRequest request); @ExceptionHandler(MaxUploadSizeExceededException.class) final Object handleSpringPayloadTooLargeException(
Exception e, HttpServletRequest request); @ExceptionHandler(HttpMediaTypeNotSupportedException.class) final Object handleSpringUnsupportedMediaTypeException(
Exception e, HandlerMethod handlerMethod); @ExceptionHandler(HttpMediaTypeNotAcceptableException.class) final Object handleSpringNotAcceptableException(Exception e, HandlerMethod handlerMethod); @ExceptionHandler({ MissingServletRequestParameterException.class, ServletRequestBindingException.class, TypeMismatchException.class, HttpMessageNotReadableException.class, MethodArgumentNotValidException.class, MissingServletRequestPartException.class, BindException.class, ConstraintViolationException.class }) final Object handleSpringBadRequestException(Exception e, HandlerMethod handlerMethod); @ExceptionHandler(AsyncRequestTimeoutException.class) final Object handleSpringServiceUnavailableException(
Exception e, HandlerMethod handlerMethod); }### Answer:
@Test void testHandleSpringNotFoundException() { Exception e = mock(Exception.class); HttpServletRequest request = new MockHttpServletRequest(); springExceptionHandler.handleSpringNotFoundException(e, request); verify(springExceptionHandler).logAndHandleException(e, NOT_FOUND, request); }
|
### Question:
PackageRepositoryDecoratorFactory extends AbstractSystemRepositoryDecoratorFactory<Package, PackageMetadata> { public PackageRepositoryDecoratorFactory( PackageMetadata packageMetadata, DataService dataService, PackageValidator packageValidator, MutableAclService mutableAclService, UserPermissionEvaluator userPermissionEvaluator, GroupPackageService groupPackageService) { super(packageMetadata); this.dataService = requireNonNull(dataService); this.packageValidator = requireNonNull(packageValidator); this.mutableAclService = requireNonNull(mutableAclService); this.userPermissionEvaluator = requireNonNull(userPermissionEvaluator); this.groupPackageService = requireNonNull(groupPackageService); } PackageRepositoryDecoratorFactory(
PackageMetadata packageMetadata,
DataService dataService,
PackageValidator packageValidator,
MutableAclService mutableAclService,
UserPermissionEvaluator userPermissionEvaluator,
GroupPackageService groupPackageService); @Override Repository<Package> createDecoratedRepository(Repository<Package> repository); }### Answer:
@Test void testPackageRepositoryDecoratorFactory() { assertThrows( NullPointerException.class, () -> new PackageRepositoryDecoratorFactory(null, null, null, null, null, null)); }
|
### Question:
PackageRepositoryDecoratorFactory extends AbstractSystemRepositoryDecoratorFactory<Package, PackageMetadata> { @Override public Repository<Package> createDecoratedRepository(Repository<Package> repository) { repository = new PackageRepositoryDecorator(repository, dataService); repository = new GroupPackageRepositoryDecorator(repository, groupPackageService); repository = new PackageRepositorySecurityDecorator( repository, mutableAclService, userPermissionEvaluator); return new PackageRepositoryValidationDecorator(repository, packageValidator); } PackageRepositoryDecoratorFactory(
PackageMetadata packageMetadata,
DataService dataService,
PackageValidator packageValidator,
MutableAclService mutableAclService,
UserPermissionEvaluator userPermissionEvaluator,
GroupPackageService groupPackageService); @Override Repository<Package> createDecoratedRepository(Repository<Package> repository); }### Answer:
@Test void testCreateDecoratedRepository() { EntityType entityType = mock(EntityType.class); Repository<Package> repository = when(mock(Repository.class).getEntityType()).thenReturn(entityType).getMock(); Repository<Package> decoratedRepository = packageRepositoryDecoratorFactory.createDecoratedRepository(repository); assertEquals(entityType, decoratedRepository.getEntityType()); }
|
### Question:
PackageRepositoryValidationDecorator extends AbstractRepositoryDecorator<Package> { @Override public void deleteById(Object id) { Package aPackage = findOneById(id); if (aPackage == null) { throw new UnknownEntityException(getEntityType(), id); } packageValidator.validate(aPackage, ValidationMode.DELETE); super.deleteById(id); } PackageRepositoryValidationDecorator(
Repository<Package> delegateRepository, PackageValidator packageValidator); @Override void add(Package aPackage); @Override Integer add(Stream<Package> packageStream); @Override void update(Package aPackage); @Override void update(Stream<Package> packageStream); @Override void delete(Package aPackage); @Override void delete(Stream<Package> packageStream); @Override void deleteById(Object id); @Override void deleteAll(); @Override void deleteAll(Stream<Object> ids); }### Answer:
@Test void testDeleteByIdValid() { Package package_ = mock(Package.class); Object id = mock(Object.class); when(delegateRepository.findOneById(id)).thenReturn(package_); packageRepositoryValidationDecorator.deleteById(id); verify(packageValidator).validate(package_, ValidationMode.DELETE); verify(delegateRepository).deleteById(id); }
@Test void testDeleteByIdInvalid() { Package package_ = mock(Package.class); Object id = mock(Object.class); when(delegateRepository.findOneById(id)).thenReturn(package_); doThrow(mock(MolgenisValidationException.class)) .when(packageValidator) .validate(package_, ValidationMode.DELETE); assertThrows( MolgenisValidationException.class, () -> packageRepositoryValidationDecorator.deleteById(id)); }
|
### Question:
EntityTypeRepositoryValidationDecorator extends AbstractRepositoryDecorator<EntityType> { public EntityTypeRepositoryValidationDecorator( Repository<EntityType> delegateRepository, EntityTypeValidator entityTypeValidator) { super(delegateRepository); this.entityTypeValidator = requireNonNull(entityTypeValidator); } EntityTypeRepositoryValidationDecorator(
Repository<EntityType> delegateRepository, EntityTypeValidator entityTypeValidator); @Override void update(EntityType entityType); @Override void update(Stream<EntityType> entities); @Override void add(EntityType entityType); @Override Integer add(Stream<EntityType> entities); }### Answer:
@Test void EntityTypeRepositoryValidationDecorator() { assertThrows( NullPointerException.class, () -> new EntityTypeRepositoryValidationDecorator(null, null)); }
|
### Question:
PackageFactory extends AbstractSystemEntityFactory<Package, PackageMetadata, String> { public Package create(String id, String description) { Package pack = create(id); pack.setLabel(id); pack.setDescription(description); return pack; } PackageFactory(PackageMetadata packageMetadata, EntityPopulator entityPopulator); Package create(String id, String description); @Override Package create(String id); Package create(String id, String description, Package parentPackage); Package create(PackageValue packageValue); }### Answer:
@Override @Test public void testCreate() { super.testCreate(factory, Package.class); }
@Test void testCreatePackageValue() { PackageValue packageValue = PackageValue.builder() .setName("name") .setLabel("label") .setDescription("description") .build(); Package actual = factory.create(packageValue); assertEquals("name", actual.getId()); assertEquals("label", actual.getLabel()); assertEquals("description", actual.getDescription()); }
@Test void testCreatePackageValueNulls() { PackageValue packageValue = PackageValue.builder().setName("name").setLabel("label").build(); Package actual = factory.create(packageValue); assertEquals("name", actual.getId()); assertEquals("label", actual.getLabel()); assertNull(actual.getDescription()); }
|
### Question:
NameValidator { public static void validateEntityName(String name) { checkForKeyword(name); checkForIllegalCharacters(name); } private NameValidator(); static void validateAttributeName(String name); static void validateEntityName(String name); @SuppressWarnings("java:S2386") // false positive: Mutable fields should not be "static"
static final Set<String> KEYWORDS; }### Answer:
@Test void testValidateNameInvalidCharacters() { assertThrows( MolgenisDataException.class, () -> NameValidator.validateEntityName("Invalid.Name")); }
@Test void testValidateNameStartsWithDigit() { NameValidator.validateEntityName("6valid"); }
@Test void testReservedKeyword() { assertThrows(MolgenisDataException.class, () -> NameValidator.validateEntityName("base")); }
@Test void testI18nNameMulti() { NameValidator.validateEntityName("test-en-nl"); }
@Test void testI18nTooLong() { NameValidator.validateEntityName("test-xxxx"); }
@Test void testI18nMissing() { NameValidator.validateEntityName("test-"); }
@Test void testI18nUpperCase() { NameValidator.validateEntityName("test-NL"); }
@Test void testI18nNumber() { NameValidator.validateEntityName("test-n2"); }
|
### Question:
NameValidator { public static void validateAttributeName(String name) { checkForKeyword(name); checkForLeadingDigit(name); if (!name.matches("[a-zA-Z0-9_#]+(-[a-z]{2,3})??$")) { throw new MolgenisDataException( "Invalid characters in: [" + name + "] Only letters (a-z, A-Z), digits (0-9), underscores (_) and hashes (#) are allowed."); } } private NameValidator(); static void validateAttributeName(String name); static void validateEntityName(String name); @SuppressWarnings("java:S2386") // false positive: Mutable fields should not be "static"
static final Set<String> KEYWORDS; }### Answer:
@Test void testValidateAttributeNameStartsWithDigit() { assertThrows( MolgenisDataException.class, () -> NameValidator.validateAttributeName("6invalid")); }
@Test void testI18nAttributeNameMulti() { assertThrows( MolgenisDataException.class, () -> NameValidator.validateAttributeName("test-en-nl")); }
@Test void testI18nAttributeNameTooLong() { assertThrows( MolgenisDataException.class, () -> NameValidator.validateAttributeName("test-xxxx")); }
@Test void testI18nAttributeNameMissing() { assertThrows(MolgenisDataException.class, () -> NameValidator.validateAttributeName("test-")); }
@Test void testI18nAttributeNameUpperCase() { assertThrows(MolgenisDataException.class, () -> NameValidator.validateAttributeName("test-NL")); }
@Test void testI18nAttributeNameNumber() { assertThrows(MolgenisDataException.class, () -> NameValidator.validateAttributeName("test-n2")); }
@Test void testI18nName() { NameValidator.validateAttributeName("test-en"); NameValidator.validateAttributeName("test-eng"); }
@Test void testUnderscoreAttr() { NameValidator.validateAttributeName("test_test"); }
|
### Question:
RepositoryValidationDecorator extends AbstractRepositoryDecorator<Entity> { @Override public void deleteById(Object id) { defaultValueReferenceValidator.validateEntityNotReferencedById(id, getEntityType()); delegate().deleteById(id); } RepositoryValidationDecorator(
DataService dataService,
Repository<Entity> delegateRepository,
EntityAttributesValidator entityAttributesValidator,
DefaultValueReferenceValidator defaultValueReferenceValidator); @Override void update(Entity entity); @Override void update(Stream<Entity> entities); @Override void add(Entity entity); @Override Integer add(Stream<Entity> entities); @Override void delete(Entity entity); @Override void deleteById(Object id); @Override void deleteAll(); @Override void delete(Stream<Entity> entities); @Override void deleteAll(Stream<Object> ids); }### Answer:
@Test void testDeleteById() { Object entityId = "id"; repositoryValidationDecorator.deleteById(entityId); verify(delegateRepository).deleteById(entityId); verify(defaultValueReferenceValidator).validateEntityNotReferencedById(entityId, entityType); }
@Test void testDeleteByIdValidationException() { Object entityId = "id"; doThrow(MolgenisValidationException.class) .when(defaultValueReferenceValidator) .validateEntityNotReferencedById(entityId, entityType); assertThrows( MolgenisValidationException.class, () -> repositoryValidationDecorator.deleteById(entityId)); }
|
### Question:
Package extends StaticEntity { @SuppressWarnings("java:S2259") public Package getRootPackage() { Package aPackage = this; while (aPackage.getParent() != null) { aPackage = aPackage.getParent(); } return aPackage; } Package(Entity entity); Package(EntityType entityType); Package(String packageId, EntityType entityType); static Package newInstance(Package aPackage); String getId(); Package setId(String id); @Nullable @CheckForNull Package getParent(); Package setParent(Package parentPackage); Iterable<Package> getChildren(); String getLabel(); Package setLabel(String label); @Nullable @CheckForNull String getDescription(); Package setDescription(String description); Iterable<Tag> getTags(); Package setTags(Iterable<Tag> tags); void addTag(Tag tag); void removeTag(Tag tag); Iterable<EntityType> getEntityTypes(); @SuppressWarnings("java:S2259") // potential multi-threading NPE Package getRootPackage(); @SuppressWarnings("java:S2259") // potential multi-threading NPEs @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); static final String PACKAGE_SEPARATOR; }### Answer:
@Test void getRootPackageNoParent() throws Exception { PackageMetadata packageMetadata = mock(PackageMetadata.class); Package package_ = new Package(packageMetadata); assertEquals(package_, package_.getRootPackage()); }
|
### Question:
RepositoryConstraintViolationException extends RuntimeException implements Errors { @Override public @Nonnull String getObjectName() { return entityErrors.getObjectName(); } RepositoryConstraintViolationException(EntityErrors entityErrors); @Override @Nonnull String getObjectName(); @Override void setNestedPath(@Nonnull String nestedPath); @Override @Nonnull String getNestedPath(); @Override void pushNestedPath(@Nonnull String subPath); @Override void popNestedPath(); @Override void reject(@Nonnull String errorCode); @Override void reject(@Nonnull String errorCode, @Nonnull String defaultMessage); @Override void reject(@Nonnull String errorCode, Object[] errorArgs, String defaultMessage); @Override void rejectValue(String field, @Nonnull String errorCode); @Override void rejectValue(String field, @Nonnull String errorCode, @Nonnull String defaultMessage); @Override void rejectValue(
String field, @Nonnull String errorCode, Object[] errorArgs, String defaultMessage); @Override void addAllErrors(@Nonnull Errors errors); @Override boolean hasErrors(); @Override int getErrorCount(); @Override @Nonnull List<ObjectError> getAllErrors(); @Override boolean hasGlobalErrors(); @Override int getGlobalErrorCount(); @Override @Nonnull List<ObjectError> getGlobalErrors(); @Override @Nullable ObjectError getGlobalError(); @Override boolean hasFieldErrors(); @Override int getFieldErrorCount(); @Override @Nonnull List<FieldError> getFieldErrors(); @Override @Nullable FieldError getFieldError(); @Override boolean hasFieldErrors(@Nonnull String field); @Override int getFieldErrorCount(@Nonnull String field); @Override @Nonnull List<FieldError> getFieldErrors(@Nonnull String field); @Override @Nullable FieldError getFieldError(@Nonnull String field); @Override @Nullable Object getFieldValue(@Nonnull String field); @Override @Nullable Class<?> getFieldType(@Nonnull String field); }### Answer:
@Test void getObjectName() { EntityErrors entityErrors = mock(EntityErrors.class); RepositoryConstraintViolationException exception = new RepositoryConstraintViolationException(entityErrors); exception.getObjectName(); verify(entityErrors).getObjectName(); }
|
### Question:
RepositoryConstraintViolationException extends RuntimeException implements Errors { @Override public void setNestedPath(@Nonnull String nestedPath) { entityErrors.setNestedPath(nestedPath); } RepositoryConstraintViolationException(EntityErrors entityErrors); @Override @Nonnull String getObjectName(); @Override void setNestedPath(@Nonnull String nestedPath); @Override @Nonnull String getNestedPath(); @Override void pushNestedPath(@Nonnull String subPath); @Override void popNestedPath(); @Override void reject(@Nonnull String errorCode); @Override void reject(@Nonnull String errorCode, @Nonnull String defaultMessage); @Override void reject(@Nonnull String errorCode, Object[] errorArgs, String defaultMessage); @Override void rejectValue(String field, @Nonnull String errorCode); @Override void rejectValue(String field, @Nonnull String errorCode, @Nonnull String defaultMessage); @Override void rejectValue(
String field, @Nonnull String errorCode, Object[] errorArgs, String defaultMessage); @Override void addAllErrors(@Nonnull Errors errors); @Override boolean hasErrors(); @Override int getErrorCount(); @Override @Nonnull List<ObjectError> getAllErrors(); @Override boolean hasGlobalErrors(); @Override int getGlobalErrorCount(); @Override @Nonnull List<ObjectError> getGlobalErrors(); @Override @Nullable ObjectError getGlobalError(); @Override boolean hasFieldErrors(); @Override int getFieldErrorCount(); @Override @Nonnull List<FieldError> getFieldErrors(); @Override @Nullable FieldError getFieldError(); @Override boolean hasFieldErrors(@Nonnull String field); @Override int getFieldErrorCount(@Nonnull String field); @Override @Nonnull List<FieldError> getFieldErrors(@Nonnull String field); @Override @Nullable FieldError getFieldError(@Nonnull String field); @Override @Nullable Object getFieldValue(@Nonnull String field); @Override @Nullable Class<?> getFieldType(@Nonnull String field); }### Answer:
@Test void setNestedPath() { EntityErrors entityErrors = mock(EntityErrors.class); RepositoryConstraintViolationException exception = new RepositoryConstraintViolationException(entityErrors); exception.setNestedPath("test"); verify(entityErrors).setNestedPath("test"); }
|
### Question:
RepositoryConstraintViolationException extends RuntimeException implements Errors { @Override public @Nonnull String getNestedPath() { return entityErrors.getNestedPath(); } RepositoryConstraintViolationException(EntityErrors entityErrors); @Override @Nonnull String getObjectName(); @Override void setNestedPath(@Nonnull String nestedPath); @Override @Nonnull String getNestedPath(); @Override void pushNestedPath(@Nonnull String subPath); @Override void popNestedPath(); @Override void reject(@Nonnull String errorCode); @Override void reject(@Nonnull String errorCode, @Nonnull String defaultMessage); @Override void reject(@Nonnull String errorCode, Object[] errorArgs, String defaultMessage); @Override void rejectValue(String field, @Nonnull String errorCode); @Override void rejectValue(String field, @Nonnull String errorCode, @Nonnull String defaultMessage); @Override void rejectValue(
String field, @Nonnull String errorCode, Object[] errorArgs, String defaultMessage); @Override void addAllErrors(@Nonnull Errors errors); @Override boolean hasErrors(); @Override int getErrorCount(); @Override @Nonnull List<ObjectError> getAllErrors(); @Override boolean hasGlobalErrors(); @Override int getGlobalErrorCount(); @Override @Nonnull List<ObjectError> getGlobalErrors(); @Override @Nullable ObjectError getGlobalError(); @Override boolean hasFieldErrors(); @Override int getFieldErrorCount(); @Override @Nonnull List<FieldError> getFieldErrors(); @Override @Nullable FieldError getFieldError(); @Override boolean hasFieldErrors(@Nonnull String field); @Override int getFieldErrorCount(@Nonnull String field); @Override @Nonnull List<FieldError> getFieldErrors(@Nonnull String field); @Override @Nullable FieldError getFieldError(@Nonnull String field); @Override @Nullable Object getFieldValue(@Nonnull String field); @Override @Nullable Class<?> getFieldType(@Nonnull String field); }### Answer:
@Test void getNestedPath() { EntityErrors entityErrors = mock(EntityErrors.class); when(entityErrors.getNestedPath()).thenReturn("nestedPath"); RepositoryConstraintViolationException exception = new RepositoryConstraintViolationException(entityErrors); assertEquals("nestedPath", exception.getNestedPath()); }
|
### Question:
RepositoryConstraintViolationException extends RuntimeException implements Errors { @Override public void pushNestedPath(@Nonnull String subPath) { entityErrors.pushNestedPath(subPath); } RepositoryConstraintViolationException(EntityErrors entityErrors); @Override @Nonnull String getObjectName(); @Override void setNestedPath(@Nonnull String nestedPath); @Override @Nonnull String getNestedPath(); @Override void pushNestedPath(@Nonnull String subPath); @Override void popNestedPath(); @Override void reject(@Nonnull String errorCode); @Override void reject(@Nonnull String errorCode, @Nonnull String defaultMessage); @Override void reject(@Nonnull String errorCode, Object[] errorArgs, String defaultMessage); @Override void rejectValue(String field, @Nonnull String errorCode); @Override void rejectValue(String field, @Nonnull String errorCode, @Nonnull String defaultMessage); @Override void rejectValue(
String field, @Nonnull String errorCode, Object[] errorArgs, String defaultMessage); @Override void addAllErrors(@Nonnull Errors errors); @Override boolean hasErrors(); @Override int getErrorCount(); @Override @Nonnull List<ObjectError> getAllErrors(); @Override boolean hasGlobalErrors(); @Override int getGlobalErrorCount(); @Override @Nonnull List<ObjectError> getGlobalErrors(); @Override @Nullable ObjectError getGlobalError(); @Override boolean hasFieldErrors(); @Override int getFieldErrorCount(); @Override @Nonnull List<FieldError> getFieldErrors(); @Override @Nullable FieldError getFieldError(); @Override boolean hasFieldErrors(@Nonnull String field); @Override int getFieldErrorCount(@Nonnull String field); @Override @Nonnull List<FieldError> getFieldErrors(@Nonnull String field); @Override @Nullable FieldError getFieldError(@Nonnull String field); @Override @Nullable Object getFieldValue(@Nonnull String field); @Override @Nullable Class<?> getFieldType(@Nonnull String field); }### Answer:
@Test void pushNestedPath() { EntityErrors entityErrors = mock(EntityErrors.class); RepositoryConstraintViolationException exception = new RepositoryConstraintViolationException(entityErrors); exception.pushNestedPath("test"); verify(entityErrors).pushNestedPath("test"); }
|
### Question:
RepositoryConstraintViolationException extends RuntimeException implements Errors { @Override public void popNestedPath() { entityErrors.popNestedPath(); } RepositoryConstraintViolationException(EntityErrors entityErrors); @Override @Nonnull String getObjectName(); @Override void setNestedPath(@Nonnull String nestedPath); @Override @Nonnull String getNestedPath(); @Override void pushNestedPath(@Nonnull String subPath); @Override void popNestedPath(); @Override void reject(@Nonnull String errorCode); @Override void reject(@Nonnull String errorCode, @Nonnull String defaultMessage); @Override void reject(@Nonnull String errorCode, Object[] errorArgs, String defaultMessage); @Override void rejectValue(String field, @Nonnull String errorCode); @Override void rejectValue(String field, @Nonnull String errorCode, @Nonnull String defaultMessage); @Override void rejectValue(
String field, @Nonnull String errorCode, Object[] errorArgs, String defaultMessage); @Override void addAllErrors(@Nonnull Errors errors); @Override boolean hasErrors(); @Override int getErrorCount(); @Override @Nonnull List<ObjectError> getAllErrors(); @Override boolean hasGlobalErrors(); @Override int getGlobalErrorCount(); @Override @Nonnull List<ObjectError> getGlobalErrors(); @Override @Nullable ObjectError getGlobalError(); @Override boolean hasFieldErrors(); @Override int getFieldErrorCount(); @Override @Nonnull List<FieldError> getFieldErrors(); @Override @Nullable FieldError getFieldError(); @Override boolean hasFieldErrors(@Nonnull String field); @Override int getFieldErrorCount(@Nonnull String field); @Override @Nonnull List<FieldError> getFieldErrors(@Nonnull String field); @Override @Nullable FieldError getFieldError(@Nonnull String field); @Override @Nullable Object getFieldValue(@Nonnull String field); @Override @Nullable Class<?> getFieldType(@Nonnull String field); }### Answer:
@Test void popNestedPath() { EntityErrors entityErrors = mock(EntityErrors.class); RepositoryConstraintViolationException exception = new RepositoryConstraintViolationException(entityErrors); exception.popNestedPath(); verify(entityErrors).popNestedPath(); }
|
### Question:
SpringExceptionHandler { @ExceptionHandler(MaxUploadSizeExceededException.class) public final Object handleSpringPayloadTooLargeException( Exception e, HttpServletRequest request) { Exception cause = e; while (cause.getCause() instanceof Exception) { cause = (Exception) cause.getCause(); } return logAndHandleException(cause, PAYLOAD_TOO_LARGE, request); } @ExceptionHandler(HttpRequestMethodNotSupportedException.class) final Object handleSpringMethodNotAllowedException(
Exception e, HttpServletRequest request); @ExceptionHandler(NoHandlerFoundException.class) final Object handleSpringNotFoundException(Exception e, HttpServletRequest request); @ExceptionHandler(MaxUploadSizeExceededException.class) final Object handleSpringPayloadTooLargeException(
Exception e, HttpServletRequest request); @ExceptionHandler(HttpMediaTypeNotSupportedException.class) final Object handleSpringUnsupportedMediaTypeException(
Exception e, HandlerMethod handlerMethod); @ExceptionHandler(HttpMediaTypeNotAcceptableException.class) final Object handleSpringNotAcceptableException(Exception e, HandlerMethod handlerMethod); @ExceptionHandler({ MissingServletRequestParameterException.class, ServletRequestBindingException.class, TypeMismatchException.class, HttpMessageNotReadableException.class, MethodArgumentNotValidException.class, MissingServletRequestPartException.class, BindException.class, ConstraintViolationException.class }) final Object handleSpringBadRequestException(Exception e, HandlerMethod handlerMethod); @ExceptionHandler(AsyncRequestTimeoutException.class) final Object handleSpringServiceUnavailableException(
Exception e, HandlerMethod handlerMethod); }### Answer:
@Test void testHandleSpringPayloadTooLargeException() { Exception e = mock(Exception.class); HttpServletRequest request = new MockHttpServletRequest(); Exception cause = mock(Exception.class); when(e.getCause()).thenReturn(cause); springExceptionHandler.handleSpringPayloadTooLargeException(e, request); verify(springExceptionHandler).logAndHandleException(cause, PAYLOAD_TOO_LARGE, request); }
|
### Question:
RepositoryConstraintViolationException extends RuntimeException implements Errors { @Override public void addAllErrors(@Nonnull Errors errors) { this.entityErrors.addAllErrors(errors); } RepositoryConstraintViolationException(EntityErrors entityErrors); @Override @Nonnull String getObjectName(); @Override void setNestedPath(@Nonnull String nestedPath); @Override @Nonnull String getNestedPath(); @Override void pushNestedPath(@Nonnull String subPath); @Override void popNestedPath(); @Override void reject(@Nonnull String errorCode); @Override void reject(@Nonnull String errorCode, @Nonnull String defaultMessage); @Override void reject(@Nonnull String errorCode, Object[] errorArgs, String defaultMessage); @Override void rejectValue(String field, @Nonnull String errorCode); @Override void rejectValue(String field, @Nonnull String errorCode, @Nonnull String defaultMessage); @Override void rejectValue(
String field, @Nonnull String errorCode, Object[] errorArgs, String defaultMessage); @Override void addAllErrors(@Nonnull Errors errors); @Override boolean hasErrors(); @Override int getErrorCount(); @Override @Nonnull List<ObjectError> getAllErrors(); @Override boolean hasGlobalErrors(); @Override int getGlobalErrorCount(); @Override @Nonnull List<ObjectError> getGlobalErrors(); @Override @Nullable ObjectError getGlobalError(); @Override boolean hasFieldErrors(); @Override int getFieldErrorCount(); @Override @Nonnull List<FieldError> getFieldErrors(); @Override @Nullable FieldError getFieldError(); @Override boolean hasFieldErrors(@Nonnull String field); @Override int getFieldErrorCount(@Nonnull String field); @Override @Nonnull List<FieldError> getFieldErrors(@Nonnull String field); @Override @Nullable FieldError getFieldError(@Nonnull String field); @Override @Nullable Object getFieldValue(@Nonnull String field); @Override @Nullable Class<?> getFieldType(@Nonnull String field); }### Answer:
@Test void addAllErrors() { EntityErrors entityErrors = mock(EntityErrors.class); RepositoryConstraintViolationException exception = new RepositoryConstraintViolationException(entityErrors); Errors errors = mock(Errors.class); exception.addAllErrors(errors); verify(entityErrors).addAllErrors(errors); }
|
### Question:
RepositoryConstraintViolationException extends RuntimeException implements Errors { @Override public boolean hasErrors() { return entityErrors.hasErrors(); } RepositoryConstraintViolationException(EntityErrors entityErrors); @Override @Nonnull String getObjectName(); @Override void setNestedPath(@Nonnull String nestedPath); @Override @Nonnull String getNestedPath(); @Override void pushNestedPath(@Nonnull String subPath); @Override void popNestedPath(); @Override void reject(@Nonnull String errorCode); @Override void reject(@Nonnull String errorCode, @Nonnull String defaultMessage); @Override void reject(@Nonnull String errorCode, Object[] errorArgs, String defaultMessage); @Override void rejectValue(String field, @Nonnull String errorCode); @Override void rejectValue(String field, @Nonnull String errorCode, @Nonnull String defaultMessage); @Override void rejectValue(
String field, @Nonnull String errorCode, Object[] errorArgs, String defaultMessage); @Override void addAllErrors(@Nonnull Errors errors); @Override boolean hasErrors(); @Override int getErrorCount(); @Override @Nonnull List<ObjectError> getAllErrors(); @Override boolean hasGlobalErrors(); @Override int getGlobalErrorCount(); @Override @Nonnull List<ObjectError> getGlobalErrors(); @Override @Nullable ObjectError getGlobalError(); @Override boolean hasFieldErrors(); @Override int getFieldErrorCount(); @Override @Nonnull List<FieldError> getFieldErrors(); @Override @Nullable FieldError getFieldError(); @Override boolean hasFieldErrors(@Nonnull String field); @Override int getFieldErrorCount(@Nonnull String field); @Override @Nonnull List<FieldError> getFieldErrors(@Nonnull String field); @Override @Nullable FieldError getFieldError(@Nonnull String field); @Override @Nullable Object getFieldValue(@Nonnull String field); @Override @Nullable Class<?> getFieldType(@Nonnull String field); }### Answer:
@Test void hasErrors() { EntityErrors entityErrors = mock(EntityErrors.class); when(entityErrors.hasErrors()).thenReturn(true); RepositoryConstraintViolationException exception = new RepositoryConstraintViolationException(entityErrors); assertTrue(exception.hasErrors()); }
|
### Question:
RepositoryConstraintViolationException extends RuntimeException implements Errors { @Override public int getErrorCount() { return entityErrors.getErrorCount(); } RepositoryConstraintViolationException(EntityErrors entityErrors); @Override @Nonnull String getObjectName(); @Override void setNestedPath(@Nonnull String nestedPath); @Override @Nonnull String getNestedPath(); @Override void pushNestedPath(@Nonnull String subPath); @Override void popNestedPath(); @Override void reject(@Nonnull String errorCode); @Override void reject(@Nonnull String errorCode, @Nonnull String defaultMessage); @Override void reject(@Nonnull String errorCode, Object[] errorArgs, String defaultMessage); @Override void rejectValue(String field, @Nonnull String errorCode); @Override void rejectValue(String field, @Nonnull String errorCode, @Nonnull String defaultMessage); @Override void rejectValue(
String field, @Nonnull String errorCode, Object[] errorArgs, String defaultMessage); @Override void addAllErrors(@Nonnull Errors errors); @Override boolean hasErrors(); @Override int getErrorCount(); @Override @Nonnull List<ObjectError> getAllErrors(); @Override boolean hasGlobalErrors(); @Override int getGlobalErrorCount(); @Override @Nonnull List<ObjectError> getGlobalErrors(); @Override @Nullable ObjectError getGlobalError(); @Override boolean hasFieldErrors(); @Override int getFieldErrorCount(); @Override @Nonnull List<FieldError> getFieldErrors(); @Override @Nullable FieldError getFieldError(); @Override boolean hasFieldErrors(@Nonnull String field); @Override int getFieldErrorCount(@Nonnull String field); @Override @Nonnull List<FieldError> getFieldErrors(@Nonnull String field); @Override @Nullable FieldError getFieldError(@Nonnull String field); @Override @Nullable Object getFieldValue(@Nonnull String field); @Override @Nullable Class<?> getFieldType(@Nonnull String field); }### Answer:
@Test void getErrorCount() { EntityErrors entityErrors = mock(EntityErrors.class); when(entityErrors.getErrorCount()).thenReturn(3); RepositoryConstraintViolationException exception = new RepositoryConstraintViolationException(entityErrors); assertEquals(3, exception.getErrorCount()); }
|
### Question:
RepositoryConstraintViolationException extends RuntimeException implements Errors { @Override public boolean hasGlobalErrors() { return entityErrors.hasGlobalErrors(); } RepositoryConstraintViolationException(EntityErrors entityErrors); @Override @Nonnull String getObjectName(); @Override void setNestedPath(@Nonnull String nestedPath); @Override @Nonnull String getNestedPath(); @Override void pushNestedPath(@Nonnull String subPath); @Override void popNestedPath(); @Override void reject(@Nonnull String errorCode); @Override void reject(@Nonnull String errorCode, @Nonnull String defaultMessage); @Override void reject(@Nonnull String errorCode, Object[] errorArgs, String defaultMessage); @Override void rejectValue(String field, @Nonnull String errorCode); @Override void rejectValue(String field, @Nonnull String errorCode, @Nonnull String defaultMessage); @Override void rejectValue(
String field, @Nonnull String errorCode, Object[] errorArgs, String defaultMessage); @Override void addAllErrors(@Nonnull Errors errors); @Override boolean hasErrors(); @Override int getErrorCount(); @Override @Nonnull List<ObjectError> getAllErrors(); @Override boolean hasGlobalErrors(); @Override int getGlobalErrorCount(); @Override @Nonnull List<ObjectError> getGlobalErrors(); @Override @Nullable ObjectError getGlobalError(); @Override boolean hasFieldErrors(); @Override int getFieldErrorCount(); @Override @Nonnull List<FieldError> getFieldErrors(); @Override @Nullable FieldError getFieldError(); @Override boolean hasFieldErrors(@Nonnull String field); @Override int getFieldErrorCount(@Nonnull String field); @Override @Nonnull List<FieldError> getFieldErrors(@Nonnull String field); @Override @Nullable FieldError getFieldError(@Nonnull String field); @Override @Nullable Object getFieldValue(@Nonnull String field); @Override @Nullable Class<?> getFieldType(@Nonnull String field); }### Answer:
@Test void hasGlobalErrors() { EntityErrors entityErrors = mock(EntityErrors.class); when(entityErrors.hasGlobalErrors()).thenReturn(true); RepositoryConstraintViolationException exception = new RepositoryConstraintViolationException(entityErrors); assertTrue(exception.hasGlobalErrors()); }
|
### Question:
RepositoryConstraintViolationException extends RuntimeException implements Errors { @Override public int getGlobalErrorCount() { return entityErrors.getGlobalErrorCount(); } RepositoryConstraintViolationException(EntityErrors entityErrors); @Override @Nonnull String getObjectName(); @Override void setNestedPath(@Nonnull String nestedPath); @Override @Nonnull String getNestedPath(); @Override void pushNestedPath(@Nonnull String subPath); @Override void popNestedPath(); @Override void reject(@Nonnull String errorCode); @Override void reject(@Nonnull String errorCode, @Nonnull String defaultMessage); @Override void reject(@Nonnull String errorCode, Object[] errorArgs, String defaultMessage); @Override void rejectValue(String field, @Nonnull String errorCode); @Override void rejectValue(String field, @Nonnull String errorCode, @Nonnull String defaultMessage); @Override void rejectValue(
String field, @Nonnull String errorCode, Object[] errorArgs, String defaultMessage); @Override void addAllErrors(@Nonnull Errors errors); @Override boolean hasErrors(); @Override int getErrorCount(); @Override @Nonnull List<ObjectError> getAllErrors(); @Override boolean hasGlobalErrors(); @Override int getGlobalErrorCount(); @Override @Nonnull List<ObjectError> getGlobalErrors(); @Override @Nullable ObjectError getGlobalError(); @Override boolean hasFieldErrors(); @Override int getFieldErrorCount(); @Override @Nonnull List<FieldError> getFieldErrors(); @Override @Nullable FieldError getFieldError(); @Override boolean hasFieldErrors(@Nonnull String field); @Override int getFieldErrorCount(@Nonnull String field); @Override @Nonnull List<FieldError> getFieldErrors(@Nonnull String field); @Override @Nullable FieldError getFieldError(@Nonnull String field); @Override @Nullable Object getFieldValue(@Nonnull String field); @Override @Nullable Class<?> getFieldType(@Nonnull String field); }### Answer:
@Test void getGlobalErrorCount() { EntityErrors entityErrors = mock(EntityErrors.class); when(entityErrors.getGlobalErrorCount()).thenReturn(6); RepositoryConstraintViolationException exception = new RepositoryConstraintViolationException(entityErrors); assertEquals(6, exception.getGlobalErrorCount()); }
|
### Question:
AttributeFactory implements EntityFactory<Attribute, String> { @Override public Attribute create() { Attribute attribute = new Attribute(attributeMetadata); entityPopulator.populate(attribute); return attribute; } AttributeFactory(EntityPopulator entityPopulator); @Override String getEntityTypeId(); @Override Attribute create(); @Override Attribute create(String entityId); @Override Attribute create(Entity entity); @Autowired void setAttributeMetadata(AttributeMetadata attributeMetadata); AttributeMetadata getAttributeMetadata(); }### Answer:
@Override @Test public void testCreate() { super.testCreate(factory, Attribute.class); }
|
### Question:
RepositoryConstraintViolationException extends RuntimeException implements Errors { @Override @Nullable public Object getFieldValue(@Nonnull String field) { return entityErrors.getFieldValue(field); } RepositoryConstraintViolationException(EntityErrors entityErrors); @Override @Nonnull String getObjectName(); @Override void setNestedPath(@Nonnull String nestedPath); @Override @Nonnull String getNestedPath(); @Override void pushNestedPath(@Nonnull String subPath); @Override void popNestedPath(); @Override void reject(@Nonnull String errorCode); @Override void reject(@Nonnull String errorCode, @Nonnull String defaultMessage); @Override void reject(@Nonnull String errorCode, Object[] errorArgs, String defaultMessage); @Override void rejectValue(String field, @Nonnull String errorCode); @Override void rejectValue(String field, @Nonnull String errorCode, @Nonnull String defaultMessage); @Override void rejectValue(
String field, @Nonnull String errorCode, Object[] errorArgs, String defaultMessage); @Override void addAllErrors(@Nonnull Errors errors); @Override boolean hasErrors(); @Override int getErrorCount(); @Override @Nonnull List<ObjectError> getAllErrors(); @Override boolean hasGlobalErrors(); @Override int getGlobalErrorCount(); @Override @Nonnull List<ObjectError> getGlobalErrors(); @Override @Nullable ObjectError getGlobalError(); @Override boolean hasFieldErrors(); @Override int getFieldErrorCount(); @Override @Nonnull List<FieldError> getFieldErrors(); @Override @Nullable FieldError getFieldError(); @Override boolean hasFieldErrors(@Nonnull String field); @Override int getFieldErrorCount(@Nonnull String field); @Override @Nonnull List<FieldError> getFieldErrors(@Nonnull String field); @Override @Nullable FieldError getFieldError(@Nonnull String field); @Override @Nullable Object getFieldValue(@Nonnull String field); @Override @Nullable Class<?> getFieldType(@Nonnull String field); }### Answer:
@Test void getFieldValue() { EntityErrors entityErrors = mock(EntityErrors.class); when(entityErrors.getFieldValue("field")).thenReturn("value"); RepositoryConstraintViolationException exception = new RepositoryConstraintViolationException(entityErrors); assertEquals("value", exception.getFieldValue("field")); }
|
### Question:
FetchValidatorImpl implements FetchValidator { @Override public Fetch validateFetch(Fetch fetch, EntityType entityType) { if (fetch.isValidated()) { return fetch; } Fetch validatedFetch = new Fetch(true); Attribute idAttribute = entityType.getIdAttribute(); if (idAttribute != null && !fetch.hasField(idAttribute)) { validatedFetch.field(idAttribute.getName()); } fetch .getFields() .forEach( field -> { Fetch subFetch = fetch.getFetch(field); if (subFetch != null) { Fetch validatedSubFetch = validateFetch(subFetch, entityType.getAttribute(field).getRefEntity()); validatedFetch.field(field, validatedSubFetch); } else { validatedFetch.field(field); } }); return validatedFetch; } @Override Fetch validateFetch(Fetch fetch, EntityType entityType); }### Answer:
@Test void validateFetch() { Fetch fetch = new Fetch().field("label").field("ref", new Fetch().field("refLabel")); EntityType entityType = mock(EntityType.class); Attribute idAttribute = mock(Attribute.class); when(idAttribute.getName()).thenReturn("id"); when(entityType.getIdAttribute()).thenReturn(idAttribute); Attribute refAttribute = mock(Attribute.class); EntityType refEntityType = mock(EntityType.class); Attribute refIdAttribute = mock(Attribute.class); when(refIdAttribute.getName()).thenReturn("refId"); when(refEntityType.getIdAttribute()).thenReturn(refIdAttribute); when(refAttribute.getRefEntity()).thenReturn(refEntityType); when(entityType.getAttribute("ref")).thenReturn(refAttribute); Fetch expectedFetch = new Fetch(true) .field("id") .field("label") .field("ref", new Fetch(true).field("refId").field("refLabel")); assertEquals(expectedFetch, fetchValidatorImpl.validateFetch(fetch, entityType)); }
@Test void validateFetchNoValidationRequired() { Fetch fetch = new Fetch(true); EntityType entityType = mock(EntityType.class); fetchValidatorImpl.validateFetch(fetch, entityType); verifyNoInteractions(entityType); }
|
### Question:
EntityTypeRepositoryDecorator extends AbstractRepositoryDecorator<EntityType> { @Override public void add(EntityType entity) { addEntityType(entity); } EntityTypeRepositoryDecorator(
Repository<EntityType> delegateRepository,
DataService dataService,
EntityTypeDependencyResolver entityTypeDependencyResolver); @Override void update(EntityType entity); @Override void update(Stream<EntityType> entities); @Override void delete(EntityType entity); @Override void delete(Stream<EntityType> entities); @Override void deleteById(Object id); @Override void deleteAll(Stream<Object> ids); @Override void deleteAll(); @Override void add(EntityType entity); @Override Integer add(Stream<EntityType> entities); }### Answer:
@Test void addWithKnownBackend() { when(entityType1.getId()).thenReturn(entityTypeId1); when(dataService.getMeta()).thenReturn(metaDataService); when(metaDataService.getBackend(entityType1)).thenReturn(repositoryCollection); repo.add(entityType1); verify(delegateRepository).add(entityType1); }
@Test void addWithUnknownBackend() { when(entityType1.getId()).thenReturn(entityTypeId1); String backend = "backend"; when(entityType1.getBackend()).thenReturn(backend); when(dataService.getMeta()).thenReturn(metaDataService); Exception exception = assertThrows(MolgenisDataException.class, () -> repo.add(entityType1)); assertThat(exception.getMessage()).containsPattern("Unknown backend \\[backend\\]"); verify(delegateRepository).add(entityType1); }
|
### Question:
EntityValidator implements Validator { @Override public boolean supports(@Nonnull Class<?> clazz) { return Entity.class.isAssignableFrom(clazz); } EntityValidator(ExpressionValidator expressionValidator); @Override boolean supports(@Nonnull Class<?> clazz); @Override void validate(@Nonnull Object target, @Nonnull Errors errors); }### Answer:
@Test void testSupportsEntity() { assertTrue(entityValidator.supports(Entity.class)); }
@Test void testSupportsString() { assertFalse(entityValidator.supports(String.class)); }
|
### Question:
EntityValidator implements Validator { private void validateNullableExpressionConstraint( Entity entity, Attribute attribute, Errors errors) { String nullableExpression = attribute.getNullableExpression(); if (nullableExpression == null) { return; } boolean valid = expressionValidator.resolveBooleanExpression(nullableExpression, entity); if (!valid) { errors.rejectValue( attribute.getName(), ERROR_CODE_NULLABLE_EXPRESSION, new Object[] {nullableExpression}, null); } } EntityValidator(ExpressionValidator expressionValidator); @Override boolean supports(@Nonnull Class<?> clazz); @Override void validate(@Nonnull Object target, @Nonnull Errors errors); }### Answer:
@Test void testValidateNullableExpressionConstraint() { String attributeName = "attr"; Attribute attribute = when(mock(Attribute.class).getDataType()).thenReturn(STRING).getMock(); when(attribute.getName()).thenReturn(attributeName); String expression = "MyExpression"; when(attribute.getNullableExpression()).thenReturn(expression); EntityType entityType = when(mock(EntityType.class).getAtomicAttributes()) .thenReturn(singletonList(attribute)) .getMock(); Entity entity = when(mock(Entity.class).getEntityType()).thenReturn(entityType).getMock(); Errors errors = mock(Errors.class); entityValidator.validate(entity, errors); verify(errors) .rejectValue( attributeName, "constraints.NullableExpression", new Object[] {expression}, null); }
|
### Question:
EntityValidator implements Validator { private void validateValidationExpressionConstraint( Entity entity, Attribute attribute, Errors errors) { String validationExpression = attribute.getValidationExpression(); if (validationExpression == null) { return; } boolean valid = expressionValidator.resolveBooleanExpression(validationExpression, entity); if (!valid) { errors.rejectValue( attribute.getName(), ERROR_CODE_VALIDATION_EXPRESSION, new Object[] {validationExpression}, null); } } EntityValidator(ExpressionValidator expressionValidator); @Override boolean supports(@Nonnull Class<?> clazz); @Override void validate(@Nonnull Object target, @Nonnull Errors errors); }### Answer:
@Test void testValidateValidationExpressionConstraint() { String attributeName = "attr"; Attribute attribute = when(mock(Attribute.class).getDataType()).thenReturn(STRING).getMock(); when(attribute.getName()).thenReturn(attributeName); String expression = "MyExpression"; when(attribute.getValidationExpression()).thenReturn(expression); EntityType entityType = when(mock(EntityType.class).getAtomicAttributes()) .thenReturn(singletonList(attribute)) .getMock(); Entity entity = when(mock(Entity.class).getEntityType()).thenReturn(entityType).getMock(); Errors errors = mock(Errors.class); entityValidator.validate(entity, errors); verify(errors) .rejectValue( attributeName, "constraints.ValidationExpression", new Object[] {expression}, null); }
|
### Question:
EntityValidator implements Validator { private void validateEmailConstraint(Entity entity, Attribute attribute, Errors errors) { if (attribute.getDataType() != AttributeType.EMAIL) { return; } String emailValue = entity.getString(attribute); if (emailValue == null) { return; } boolean valid = emailValidator.isValid(emailValue, null); if (!valid) { errors.rejectValue(attribute.getName(), ERROR_CODE_EMAIL, null, null); } } EntityValidator(ExpressionValidator expressionValidator); @Override boolean supports(@Nonnull Class<?> clazz); @Override void validate(@Nonnull Object target, @Nonnull Errors errors); }### Answer:
@Test void testValidateEmailConstraint() { String attributeName = "attr"; Attribute attribute = when(mock(Attribute.class).getDataType()).thenReturn(EMAIL).getMock(); when(attribute.getName()).thenReturn(attributeName); EntityType entityType = when(mock(EntityType.class).getAtomicAttributes()) .thenReturn(singletonList(attribute)) .getMock(); String value = "invalidEmail"; Entity entity = when(mock(Entity.class).getEntityType()).thenReturn(entityType).getMock(); when(entity.getString(attribute)).thenReturn(value); Errors errors = mock(Errors.class); entityValidator.validate(entity, errors); verify(errors).rejectValue(attributeName, "constraints.Email", null, null); }
|
### Question:
EntityValidator implements Validator { private void validateUriConstraint(Entity entity, Attribute attribute, Errors errors) { if (attribute.getDataType() != AttributeType.HYPERLINK) { return; } String hyperlinkValue = entity.getString(attribute); if (hyperlinkValue == null) { return; } try { new URI(hyperlinkValue); } catch (URISyntaxException e) { errors.rejectValue(attribute.getName(), ERROR_CODE_URI, null, null); } } EntityValidator(ExpressionValidator expressionValidator); @Override boolean supports(@Nonnull Class<?> clazz); @Override void validate(@Nonnull Object target, @Nonnull Errors errors); }### Answer:
@Test void testValidateUriConstraint() { String attributeName = "attr"; Attribute attribute = when(mock(Attribute.class).getDataType()).thenReturn(HYPERLINK).getMock(); when(attribute.getName()).thenReturn(attributeName); EntityType entityType = when(mock(EntityType.class).getAtomicAttributes()) .thenReturn(singletonList(attribute)) .getMock(); String value = "\\"; Entity entity = when(mock(Entity.class).getEntityType()).thenReturn(entityType).getMock(); when(entity.getString(attribute)).thenReturn(value); Errors errors = mock(Errors.class); entityValidator.validate(entity, errors); verify(errors).rejectValue(attributeName, "constraints.Uri", null, null); }
|
### Question:
EntityValidator implements Validator { private void validateEnumConstraint(Entity entity, Attribute attribute, Errors errors) { if (attribute.getDataType() != AttributeType.ENUM) { return; } String enumValue = entity.getString(attribute); if (enumValue == null) { return; } List<String> enumOptions = attribute.getEnumOptions(); if (!enumOptions.contains(enumValue)) { errors.rejectValue( attribute.getName(), ERROR_CODE_ENUM, new Object[] {String.join(", ", enumOptions)}, null); } } EntityValidator(ExpressionValidator expressionValidator); @Override boolean supports(@Nonnull Class<?> clazz); @Override void validate(@Nonnull Object target, @Nonnull Errors errors); }### Answer:
@Test void testValidateEnumConstraint() { String attributeName = "attr"; Attribute attribute = when(mock(Attribute.class).getDataType()).thenReturn(ENUM).getMock(); List<String> enumOptions = asList("enum0", "enum1", "enum2"); when(attribute.getEnumOptions()).thenReturn(enumOptions); when(attribute.getName()).thenReturn(attributeName); EntityType entityType = when(mock(EntityType.class).getAtomicAttributes()) .thenReturn(singletonList(attribute)) .getMock(); String value = "invalidEnum"; Entity entity = when(mock(Entity.class).getEntityType()).thenReturn(entityType).getMock(); when(entity.getString(attribute)).thenReturn(value); Errors errors = mock(Errors.class); entityValidator.validate(entity, errors); verify(errors) .rejectValue( attributeName, "constraints.Enum", new Object[] {String.join(", ", enumOptions)}, null); }
|
### Question:
QueryValidationRepositoryDecorator extends AbstractRepositoryDecorator<E> { public QueryValidationRepositoryDecorator( Repository<E> delegateRepository, QueryValidator queryValidator, FetchValidator fetchValidator) { super(delegateRepository); this.queryValidator = requireNonNull(queryValidator); this.fetchValidator = requireNonNull(fetchValidator); } QueryValidationRepositoryDecorator(
Repository<E> delegateRepository,
QueryValidator queryValidator,
FetchValidator fetchValidator); @Override long count(Query<E> q); @Override Stream<E> findAll(Query<E> q); @Override E findOne(Query<E> q); @Override void forEachBatched(Fetch fetch, Consumer<List<E>> consumer, int batchSize); @Override E findOneById(Object id, Fetch fetch); @Override Stream<E> findAll(Stream<Object> ids, Fetch fetch); }### Answer:
@Test void testQueryValidationRepositoryDecorator() { assertThrows( NullPointerException.class, () -> new QueryValidationRepositoryDecorator<>(null, null, null)); }
|
### Question:
QueryValidationRepositoryDecorator extends AbstractRepositoryDecorator<E> { @Override public long count(Query<E> q) { queryValidator.validate(q, getEntityType()); return super.count(q); } QueryValidationRepositoryDecorator(
Repository<E> delegateRepository,
QueryValidator queryValidator,
FetchValidator fetchValidator); @Override long count(Query<E> q); @Override Stream<E> findAll(Query<E> q); @Override E findOne(Query<E> q); @Override void forEachBatched(Fetch fetch, Consumer<List<E>> consumer, int batchSize); @Override E findOneById(Object id, Fetch fetch); @Override Stream<E> findAll(Stream<Object> ids, Fetch fetch); }### Answer:
@Test void testCountQueryValid() { @SuppressWarnings("unchecked") Query<Entity> query = mock(Query.class); long count = 123L; when(delegateRepository.count(query)).thenReturn(count); assertEquals(queryValidationRepositoryDecorator.count(query), count); verify(queryValidator).validate(query, entityType); }
@Test void testCountQueryInvalid() { @SuppressWarnings("unchecked") Query<Entity> query = mock(Query.class); doThrow(mock(MolgenisValidationException.class)) .when(queryValidator) .validate(query, entityType); assertThrows( MolgenisValidationException.class, () -> queryValidationRepositoryDecorator.count(query)); }
|
### Question:
QueryValidationRepositoryDecorator extends AbstractRepositoryDecorator<E> { @Override public Stream<E> findAll(Query<E> q) { queryValidator.validate(q, getEntityType()); return super.findAll(q); } QueryValidationRepositoryDecorator(
Repository<E> delegateRepository,
QueryValidator queryValidator,
FetchValidator fetchValidator); @Override long count(Query<E> q); @Override Stream<E> findAll(Query<E> q); @Override E findOne(Query<E> q); @Override void forEachBatched(Fetch fetch, Consumer<List<E>> consumer, int batchSize); @Override E findOneById(Object id, Fetch fetch); @Override Stream<E> findAll(Stream<Object> ids, Fetch fetch); }### Answer:
@Test void testFindAllQueryValid() { @SuppressWarnings("unchecked") Query<Entity> query = mock(Query.class); @SuppressWarnings("unchecked") Stream<Entity> entityStream = mock(Stream.class); when(delegateRepository.findAll(query)).thenReturn(entityStream); assertEquals(queryValidationRepositoryDecorator.findAll(query), entityStream); verify(queryValidator).validate(query, entityType); }
@Test void testFindAllQueryInvalid() { @SuppressWarnings("unchecked") Query<Entity> query = mock(Query.class); doThrow(mock(MolgenisValidationException.class)) .when(queryValidator) .validate(query, entityType); assertThrows( MolgenisValidationException.class, () -> queryValidationRepositoryDecorator.findAll(query)); }
|
### Question:
QueryValidationRepositoryDecorator extends AbstractRepositoryDecorator<E> { @Override public E findOne(Query<E> q) { queryValidator.validate(q, getEntityType()); return super.findOne(q); } QueryValidationRepositoryDecorator(
Repository<E> delegateRepository,
QueryValidator queryValidator,
FetchValidator fetchValidator); @Override long count(Query<E> q); @Override Stream<E> findAll(Query<E> q); @Override E findOne(Query<E> q); @Override void forEachBatched(Fetch fetch, Consumer<List<E>> consumer, int batchSize); @Override E findOneById(Object id, Fetch fetch); @Override Stream<E> findAll(Stream<Object> ids, Fetch fetch); }### Answer:
@Test void testFindOneQueryValid() { @SuppressWarnings("unchecked") Query<Entity> query = mock(Query.class); Entity entity = mock(Entity.class); when(delegateRepository.findOne(query)).thenReturn(entity); assertEquals(queryValidationRepositoryDecorator.findOne(query), entity); verify(queryValidator).validate(query, entityType); }
@Test void testFindOneQueryInvalid() { @SuppressWarnings("unchecked") Query<Entity> query = mock(Query.class); doThrow(mock(MolgenisValidationException.class)) .when(queryValidator) .validate(query, entityType); assertThrows( MolgenisValidationException.class, () -> queryValidationRepositoryDecorator.findOne(query)); }
|
### Question:
QueryValidator { public QueryValidator(FetchValidator fetchValidator, EntityManager entityManager) { this.fetchValidator = requireNonNull(fetchValidator); this.entityManager = requireNonNull(entityManager); } QueryValidator(FetchValidator fetchValidator, EntityManager entityManager); void validate(Query<? extends Entity> query, EntityType entityType); }### Answer:
@Test void testQueryValidator() { assertThrows(NullPointerException.class, () -> new QueryValidator(null, null)); }
|
### Question:
QueryValidator { public void validate(Query<? extends Entity> query, EntityType entityType) { query.getRules().forEach(queryRule -> validateQueryRule(queryRule, entityType)); Fetch fetch = query.getFetch(); if (fetch != null) { Fetch validatedFetch = fetchValidator.validateFetch(fetch, entityType); query.setFetch(validatedFetch); } } QueryValidator(FetchValidator fetchValidator, EntityManager entityManager); void validate(Query<? extends Entity> query, EntityType entityType); }### Answer:
@Test void testValidateFetch() { @SuppressWarnings("unchecked") Query<Entity> query = mock(Query.class); Fetch fetch = mock(Fetch.class); when(query.getFetch()).thenReturn(fetch); EntityType entityType = mock(EntityType.class); queryValidator.validate(query, entityType); verify(fetchValidator).validateFetch(fetch, entityType); }
|
### Question:
BaseQueryClauseRangeGenerator extends BaseQueryClauseGenerator { QueryBuilder mapQueryRule(QueryRule queryRule, EntityType entityType) { List<Attribute> attributePath = getAttributePathExpanded(queryRule.getField(), entityType); Attribute attr = attributePath.get(attributePath.size() - 1); validateNumericalQueryField(attr); String fieldName = getQueryFieldName(attributePath); Object queryValue = getQueryValue(attr, queryRule.getValue()); if (queryValue == null) { throw new MolgenisQueryException(QUERY_VALUE_CANNOT_BE_NULL_MSG); } RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery(fieldName); switch (getOperator()) { case GREATER: rangeQueryBuilder.gt(queryValue); break; case GREATER_EQUAL: rangeQueryBuilder.gte(queryValue); break; case LESS: rangeQueryBuilder.lt(queryValue); break; case LESS_EQUAL: rangeQueryBuilder.lte(queryValue); break; default: throw new UnexpectedEnumException(getOperator()); } return QueryBuilders.constantScoreQuery( nestedQueryBuilder(entityType, attributePath, rangeQueryBuilder)); } BaseQueryClauseRangeGenerator(DocumentIdGenerator documentIdGenerator, Operator operator); }### Answer:
@SuppressWarnings("deprecation") @Test void mapQueryRuleNullValue() { QueryRule queryRule = mock(QueryRule.class); when(queryRule.getField()).thenReturn("attr"); Attribute attribute = mock(Attribute.class); when(attribute.getDataType()).thenReturn(AttributeType.INT); when(documentIdGenerator.generateId(attribute)).thenReturn("attr"); EntityType entityType = mock(EntityType.class); when(entityType.getAttributeByName("attr")).thenReturn(attribute); assertThrows( MolgenisQueryException.class, () -> baseQueryClauseRangeGenerator.mapQueryRule(queryRule, entityType)); }
|
### Question:
DocumentContentBuilder { DocumentContentBuilder(DocumentIdGenerator documentIdGenerator) { this.documentIdGenerator = requireNonNull(documentIdGenerator); } DocumentContentBuilder(DocumentIdGenerator documentIdGenerator); }### Answer:
@Test void DocumentContentBuilder() { assertThrows(NullPointerException.class, () -> new DocumentContentBuilder(null)); }
|
### Question:
DocumentContentBuilder { Document createDocument(Object entityId) { String documentId = toElasticsearchId(entityId); return Document.builder().setId(documentId).build(); } DocumentContentBuilder(DocumentIdGenerator documentIdGenerator); }### Answer:
@Test void createDocumentObject() { String entityId = "id"; Document document = documentContentBuilder.createDocument(entityId); Document expectedDocument = Document.builder().setId(entityId).build(); assertEquals(expectedDocument, document); }
|
### Question:
BaseQueryClauseGenerator implements QueryClauseGenerator { @Override public Operator getOperator() { return operator; } BaseQueryClauseGenerator(DocumentIdGenerator documentIdGenerator, Operator operator); @Override Operator getOperator(); @Override QueryBuilder createQueryClause(QueryRule queryRule, EntityType entityType); }### Answer:
@Test void testGetOperator() { assertEquals(Operator.EQUALS, queryGenerator.getOperator()); }
|
### Question:
BaseQueryClauseGenerator implements QueryClauseGenerator { String getQueryFieldName(List<Attribute> attributePath) { return attributePath.stream() .map(this::getQueryFieldName) .collect(joining(ATTRIBUTE_SEPARATOR)); } BaseQueryClauseGenerator(DocumentIdGenerator documentIdGenerator, Operator operator); @Override Operator getOperator(); @Override QueryBuilder createQueryClause(QueryRule queryRule, EntityType entityType); }### Answer:
@Test void testGetQueryFieldName() { String fieldName = "MyFieldId"; Attribute attribute = mock(Attribute.class); when(documentIdGenerator.generateId(attribute)).thenReturn(fieldName); assertEquals(fieldName, queryGenerator.getQueryFieldName(attribute)); }
@Test void testGetQueryFieldNameList() { String fieldName0 = "MyFieldId1"; Attribute attribute0 = mock(Attribute.class); doReturn(fieldName0).when(documentIdGenerator).generateId(attribute0); String fieldName1 = "MyFieldId0"; Attribute attribute1 = mock(Attribute.class); doReturn(fieldName1).when(documentIdGenerator).generateId(attribute1); assertEquals( "MyFieldId1.MyFieldId0", queryGenerator.getQueryFieldName(asList(attribute0, attribute1))); }
|
### Question:
BaseQueryClauseGenerator implements QueryClauseGenerator { @SuppressWarnings("UnstableApiUsage") List<Object> getQueryValues(Attribute attr, Object queryRuleValue) { if (queryRuleValue == null) { throw new MolgenisQueryException(QUERY_VALUE_CANNOT_BE_NULL_MSG); } if (!(queryRuleValue instanceof Iterable<?>)) { throw new MolgenisQueryException( "Query value must be a Iterable instead of [" + queryRuleValue.getClass().getSimpleName() + "]"); } return Streams.stream((Iterable<?>) queryRuleValue) .map(aQueryRuleValue -> getQueryValue(attr, aQueryRuleValue)) .collect(toList()); } BaseQueryClauseGenerator(DocumentIdGenerator documentIdGenerator, Operator operator); @Override Operator getOperator(); @Override QueryBuilder createQueryClause(QueryRule queryRule, EntityType entityType); }### Answer:
@Test void testQueryValues() { Attribute attribute = when(mock(Attribute.class).getDataType()).thenReturn(STRING).getMock(); assertEquals( asList("string0", "string1"), queryGenerator.getQueryValues(attribute, asList("string0", "string1"))); }
|
### Question:
BaseQueryClauseGenerator implements QueryClauseGenerator { void validateNumericalQueryField(Attribute attr) { AttributeType dataType = attr.getDataType(); switch (dataType) { case DATE: case DATE_TIME: case DECIMAL: case INT: case LONG: break; case BOOL: case CATEGORICAL: case CATEGORICAL_MREF: case COMPOUND: case EMAIL: case ENUM: case FILE: case HTML: case HYPERLINK: case MREF: case ONE_TO_MANY: case SCRIPT: case STRING: case TEXT: case XREF: throw new MolgenisQueryException("Range query not allowed for type [" + dataType + "]"); default: throw new UnexpectedEnumException(dataType); } } BaseQueryClauseGenerator(DocumentIdGenerator documentIdGenerator, Operator operator); @Override Operator getOperator(); @Override QueryBuilder createQueryClause(QueryRule queryRule, EntityType entityType); }### Answer:
@Test void testValidateNumericalQueryFieldInt() { Attribute attribute = when(mock(Attribute.class).getDataType()).thenReturn(INT).getMock(); assertDoesNotThrow(() -> queryGenerator.validateNumericalQueryField(attribute)); }
@SuppressWarnings("deprecation") @Test void testValidateNumericalQueryFieldBool() { Attribute attribute = when(mock(Attribute.class).getDataType()).thenReturn(BOOL).getMock(); assertThrows( MolgenisQueryException.class, () -> queryGenerator.validateNumericalQueryField(attribute)); }
|
### Question:
PackagePersister { public PackagePersister(DataService dataService) { this.dataService = requireNonNull(dataService); } PackagePersister(DataService dataService); @Transactional void upsertPackages(Stream<Package> packages); }### Answer:
@Test void testPackagePersister() { assertThrows(NullPointerException.class, () -> new PackagePersister(null)); }
|
### Question:
SpringExceptionHandler { @ExceptionHandler(HttpMediaTypeNotSupportedException.class) public final Object handleSpringUnsupportedMediaTypeException( Exception e, HandlerMethod handlerMethod) { return logAndHandleException(e, UNSUPPORTED_MEDIA_TYPE, handlerMethod); } @ExceptionHandler(HttpRequestMethodNotSupportedException.class) final Object handleSpringMethodNotAllowedException(
Exception e, HttpServletRequest request); @ExceptionHandler(NoHandlerFoundException.class) final Object handleSpringNotFoundException(Exception e, HttpServletRequest request); @ExceptionHandler(MaxUploadSizeExceededException.class) final Object handleSpringPayloadTooLargeException(
Exception e, HttpServletRequest request); @ExceptionHandler(HttpMediaTypeNotSupportedException.class) final Object handleSpringUnsupportedMediaTypeException(
Exception e, HandlerMethod handlerMethod); @ExceptionHandler(HttpMediaTypeNotAcceptableException.class) final Object handleSpringNotAcceptableException(Exception e, HandlerMethod handlerMethod); @ExceptionHandler({ MissingServletRequestParameterException.class, ServletRequestBindingException.class, TypeMismatchException.class, HttpMessageNotReadableException.class, MethodArgumentNotValidException.class, MissingServletRequestPartException.class, BindException.class, ConstraintViolationException.class }) final Object handleSpringBadRequestException(Exception e, HandlerMethod handlerMethod); @ExceptionHandler(AsyncRequestTimeoutException.class) final Object handleSpringServiceUnavailableException(
Exception e, HandlerMethod handlerMethod); }### Answer:
@Test void testHandleSpringUnsupportedMediaTypeException() { Exception e = mock(Exception.class); HandlerMethod method = mock(HandlerMethod.class); springExceptionHandler.handleSpringUnsupportedMediaTypeException(e, method); verify(springExceptionHandler).logAndHandleException(e, UNSUPPORTED_MEDIA_TYPE, method); }
|
### Question:
MappingGenerator { MappingGenerator(DocumentIdGenerator documentIdGenerator) { this.documentIdGenerator = requireNonNull(documentIdGenerator); } MappingGenerator(DocumentIdGenerator documentIdGenerator); static MappingType getMappingType(Attribute attribute); }### Answer:
@Test void testMappingGenerator() { assertThrows(NullPointerException.class, () -> new MappingGenerator(null)); }
|
### Question:
PackagePersister { @Transactional public void upsertPackages(Stream<Package> packages) { Iterator<List<Package>> partitions = Iterators.partition(packages.iterator(), BATCH_SIZE); partitions.forEachRemaining(this::upsertPackages); } PackagePersister(DataService dataService); @Transactional void upsertPackages(Stream<Package> packages); }### Answer:
@Test void testUpsertPackages() throws Exception { Package newPackage = mock(Package.class); when(newPackage.getId()).thenReturn("newPackageId"); Package unchangedPackage = mock(Package.class); when(unchangedPackage.getId()).thenReturn("unchangedPackageId"); Package updatedPackage = mock(Package.class); when(updatedPackage.getId()).thenReturn("updatedPackageId"); Package existingUpdatedPackage = mock(Package.class); when(existingUpdatedPackage.getId()).thenReturn("updatedPackageId"); @SuppressWarnings("unchecked") Query<Package> query = mock(Query.class); when(dataService.query(PACKAGE, Package.class)).thenReturn(query); when(query.in(eq(PackageMetadata.ID), any(Set.class))).thenReturn(query); when(query.findAll()).thenReturn(Stream.of(unchangedPackage, existingUpdatedPackage)); packagePersister.upsertPackages(Stream.of(newPackage, unchangedPackage, updatedPackage)); @SuppressWarnings("unchecked") ArgumentCaptor<Stream<Package>> addCaptor = ArgumentCaptor.forClass(Stream.class); verify(dataService).add(eq(PACKAGE), addCaptor.capture()); assertEquals(singletonList(newPackage), addCaptor.getValue().collect(toList())); @SuppressWarnings("unchecked") ArgumentCaptor<Stream<Package>> updateCaptor = ArgumentCaptor.forClass(Stream.class); verify(dataService).update(eq(PACKAGE), updateCaptor.capture()); assertEquals(singletonList(updatedPackage), updateCaptor.getValue().collect(toList())); }
|
### Question:
AbstractMetadataIdGenerator implements MetadataIdGenerator { protected String generateHashcode(Object id) { return Hashing.crc32().hashString(id.toString(), UTF_8).toString(); } }### Answer:
@Test void testGenerateHashcode() { String id = "0123456789"; assertEquals("c6c784a6", abstractMetadataIdGenerator.generateHashcode(id)); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.