method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
Wizard implements Serializable { public boolean isLastPage() { if (pages.isEmpty()) { throw new IllegalStateException(NO_WIZARD_PAGES_DEFINED_MSG); } return currentPageIndex == pages.size() - 1; } void addPage(WizardPage page); List<WizardPage> getPages(); WizardPage getCurrentPage(); boolean isLastPage(); boolean isFirstPage(); void next(); void previous(); WizardButton getNextButton(); WizardButton getPreviousButton(); }### Answer:
@Test void isLastPage() { Wizard wizard = new Wizard(); wizard.addPage(new TestWizardPage()); wizard.addPage(new TestWizardPage()); assertFalse(wizard.isLastPage()); wizard.next(); assertTrue(wizard.isLastPage()); }
|
### Question:
Wizard implements Serializable { public void next() { if (isLastPage()) { throw new IllegalStateException("There is no next page"); } currentPageIndex++; } void addPage(WizardPage page); List<WizardPage> getPages(); WizardPage getCurrentPage(); boolean isLastPage(); boolean isFirstPage(); void next(); void previous(); WizardButton getNextButton(); WizardButton getPreviousButton(); }### Answer:
@Test void next() { Wizard wizard = new Wizard(); WizardPage p1 = new TestWizardPage(); wizard.addPage(p1); WizardPage p2 = new TestWizardPage(); wizard.addPage(p2); assertEquals(p1, wizard.getCurrentPage()); wizard.next(); assertEquals(p2, wizard.getCurrentPage()); }
|
### Question:
Wizard implements Serializable { public void previous() { if (isFirstPage()) { throw new IllegalStateException("There is no previous page"); } currentPageIndex--; } void addPage(WizardPage page); List<WizardPage> getPages(); WizardPage getCurrentPage(); boolean isLastPage(); boolean isFirstPage(); void next(); void previous(); WizardButton getNextButton(); WizardButton getPreviousButton(); }### Answer:
@Test void previous() { Wizard wizard = new Wizard(); WizardPage p1 = new TestWizardPage(); wizard.addPage(p1); WizardPage p2 = new TestWizardPage(); wizard.addPage(p2); wizard.next(); assertEquals(p2, wizard.getCurrentPage()); wizard.previous(); assertEquals(p1, wizard.getCurrentPage()); }
|
### Question:
MenuReaderServiceImpl implements MenuReaderService { @Override @Nullable public String findMenuItemPath(String menuItemId) { return getMenu() .flatMap(it -> it.getPath(menuItemId)) .map(Collection::stream) .map(stream -> stream.collect(joining("/", "/menu/", ""))) .orElse(null); } MenuReaderServiceImpl(
AppSettings appSettings, Gson gson, UserPermissionEvaluator userPermissionEvaluator); @Override Optional<Menu> getMenu(); @Override @Nullable String findMenuItemPath(String menuItemId); }### Answer:
@Test void findMenuItemPath() { String menuString = gson.toJson(menu); when(appSettings.getMenu()).thenReturn(menuString); when(userPermissionEvaluator.hasPermission( any(PluginIdentity.class), eq(PluginPermission.VIEW_PLUGIN))) .thenReturn(true); assertEquals("/menu/root/p1_0", menuReaderService.findMenuItemPath("p1_0")); assertEquals("/menu/root/p1_1", menuReaderService.findMenuItemPath("p1_1")); assertEquals("/menu/p1_1/p2_0", menuReaderService.findMenuItemPath("p2_0")); assertEquals("/menu/p1_1/p2_1", menuReaderService.findMenuItemPath("p2_1")); assertEquals("/menu/p2_0/p3_0", menuReaderService.findMenuItemPath("p3_0")); assertEquals("/menu/p2_0/p3_1", menuReaderService.findMenuItemPath("p3_1")); assertNull(menuReaderService.findMenuItemPath("non_existing")); }
|
### Question:
MenuReaderServiceImpl implements MenuReaderService { @Override public Optional<Menu> getMenu() { return Optional.ofNullable(appSettings.getMenu()) .map(menuJson -> gson.fromJson(menuJson, Menu.class)) .flatMap(menu -> menu.filter(this::userHasViewPermission)) .map(Menu.class::cast); } MenuReaderServiceImpl(
AppSettings appSettings, Gson gson, UserPermissionEvaluator userPermissionEvaluator); @Override Optional<Menu> getMenu(); @Override @Nullable String findMenuItemPath(String menuItemId); }### Answer:
@Test void getMenu() { when(appSettings.getMenu()) .thenReturn( "{\n" + " \"type\": \"menu\",\n" + " \"id\": \"menu\",\n" + " \"label\": \"Menu\",\n" + " \"items\": [{\n" + " \"type\": \"plugin\",\n" + " \"id\": \"plugin0\",\n" + " \"label\": \"Plugin #0\",\n" + " \"params\": \"a=0&b=1\"\n" + " },\n" + " {\n" + " \"type\": \"menu\",\n" + " \"id\": \"submenu\",\n" + " \"label\": \"Submenu\",\n" + " \"items\": [{\n" + " \"type\": \"plugin\",\n" + " \"id\": \"plugin1\",\n" + " \"label\": \"Plugin #1\"\n" + " }]\n" + " }]\n" + "}"); MenuItem plugin0 = MenuItem.create("plugin0", "Plugin #0", "a=0&b=1"); MenuItem plugin1 = MenuItem.create("plugin1", "Plugin #1"); Menu submenu = Menu.create("submenu", "Submenu", Collections.singletonList(plugin1)); Menu menu = Menu.create("menu", "Menu", ImmutableList.of(plugin0, submenu)); when(userPermissionEvaluator.hasPermission(any(), eq(PluginPermission.VIEW_PLUGIN))) .thenReturn(true); assertEquals(of(menu), menuReaderService.getMenu()); }
|
### Question:
BootstrapThemePopulator { public void populate() { PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver(); try { Resource[] bootstrap3Themes = resolver.getResources(LOCAL_CSS_BOOTSTRAP_3_THEME_LOCATION); Resource[] bootstrap4Themes = resolver.getResources(LOCAL_CSS_BOOTSTRAP_4_THEME_LOCATION); List<Resource> newThemes = Arrays.stream(bootstrap3Themes) .filter( theme -> dataService.getRepository(STYLE_SHEET).findOneById(theme.getFilename()) == null) .collect(Collectors.toList()); newThemes.forEach(nt -> addNewTheme(nt, bootstrap4Themes)); } catch (Exception e) { LOG.error("error populating bootstrap themes", e); } } BootstrapThemePopulator(StyleService styleService, DataService dataService); void populate(); }### Answer:
@Test void noNewThemes() throws GetThemeException { bootstrapThemePopulator.populate(); verify(styleService, never()).addStyle(any(), any(), any(), any(), any()); }
|
### Question:
MenuUtils { public static String readDefaultMenuValueFromClasspath() { return new Scanner(MenuUtils.class.getResourceAsStream(DEFAULT_MENU_RESOURCE_NAME)) .useDelimiter(START_OF_STRING) .next(); } private MenuUtils(); static String readDefaultMenuValueFromClasspath(); }### Answer:
@Test void getMenuJson() { assertNotNull(MenuUtils.readDefaultMenuValueFromClasspath()); }
|
### Question:
BootstrapThemePopulator { private void addNewTheme(Resource bootstrap3Resource, Resource[] bootstrap4Themes) { String bootstrap3FileName = bootstrap3Resource.getFilename(); LOG.debug("Add theme with name {}", bootstrap3FileName); try (InputStream bootstrap3Data = bootstrap3Resource.getInputStream()) { Optional<Resource> bootstrap4Optional = guessMatchingBootstrap4File(bootstrap4Themes, bootstrap3FileName); if (bootstrap4Optional.isPresent()) { Resource bootstrap4resource = bootstrap4Optional.get(); addBootstrap3And4Style(bootstrap3FileName, bootstrap3Data, bootstrap4resource); } else { LOG.debug("No matching bootstrap 4 theme found, falling back to default"); styleService.addStyle(bootstrap3FileName, bootstrap3FileName, bootstrap3Data, null, null); } } catch (Exception e) { LOG.error("error adding new bootstrap themes", e); } } BootstrapThemePopulator(StyleService styleService, DataService dataService); void populate(); }### Answer:
@Test void addNewTheme() throws GetThemeException { when(styleRepository.findOneById(ArgumentMatchers.eq("bootstrap-yeti.min.css"))) .thenReturn(null); bootstrapThemePopulator.populate(); verify(styleService, times(1)).addStyle(any(), any(), any(), any(), any()); }
|
### Question:
ThemeFingerprintRegistry { public String getFingerprint(String themeUri) throws IOException { String fileFingerprint = styleFingerprints.get(themeUri); if (fileFingerprint == null) { fileFingerprint = createFingerprint(themeUri); styleFingerprints.put(themeUri, fileFingerprint); } return fileFingerprint; } ThemeFingerprintRegistry(StyleService styleService); String getFingerprint(String themeUri); }### Answer:
@Test void getFingerprint() throws IOException { String theme = "bootstrap-theme-name.min.css"; String version = "bootstrap-3"; String themeUri = "css/theme/" + version + "/" + theme; FileSystemResource themeFile = mock(FileSystemResource.class); InputStream themeDataStream = IOUtils.toInputStream("yo yo yo data"); when(themeFile.getInputStream()).thenReturn(themeDataStream); when(styleService.getThemeData(theme, BootstrapVersion.BOOTSTRAP_VERSION_3)) .thenReturn(themeFile); String firstResult = themeFingerprintRegistry.getFingerprint(themeUri); assertNotNull(firstResult); verify(styleService).getThemeData(theme, BootstrapVersion.BOOTSTRAP_VERSION_3); String secondResult = themeFingerprintRegistry.getFingerprint(themeUri); verifyNoMoreInteractions(styleService); assertEquals(secondResult, firstResult); }
|
### Question:
Style { public static Style createLocal(String location) { String name = location.replaceFirst("bootstrap-", ""); name = name.replaceFirst(".min", ""); name = name.replaceFirst(".css", ""); return new AutoValue_Style(name, false, location); } abstract String getName(); abstract boolean isRemote(); abstract String getLocation(); static Style createLocal(String location); }### Answer:
@Test void createLocal() { assertEquals("bootstrap", Style.createLocal("bootstrap.min.css").getName()); assertEquals("yeti", Style.createLocal("bootstrap-yeti.min.css").getName()); assertEquals("mystyle", Style.createLocal("mystyle.css").getName()); assertEquals("my-style", Style.createLocal("my-style.css").getName()); }
|
### Question:
StyleSheetRepositoryDecorator extends AbstractRepositoryDecorator<StyleSheet> { @Override public void deleteById(Object id) { checkAndUpdateAppSettings(id); super.deleteById(id); } StyleSheetRepositoryDecorator(
Repository<StyleSheet> delegateRepository, AppSettings appSettings); @Override void delete(StyleSheet sheet); @Override void deleteById(Object id); @Override void deleteAll(); @Override void delete(Stream<StyleSheet> styleSheetStream); @Override void deleteAll(Stream<Object> ids); }### Answer:
@Test void testDeleteById() { decorator.deleteById("1"); verify(delegate).deleteById("1"); }
@SuppressWarnings("deprecation") @Test void testDeleteByIdCurrent() { assertThrows(MolgenisDataException.class, () -> decorator.deleteById("2")); }
|
### Question:
StyleSheetRepositoryDecorator extends AbstractRepositoryDecorator<StyleSheet> { @Override public void delete(StyleSheet sheet) { checkAndUpdateAppSettings(sheet.getId()); super.delete(sheet); } StyleSheetRepositoryDecorator(
Repository<StyleSheet> delegateRepository, AppSettings appSettings); @Override void delete(StyleSheet sheet); @Override void deleteById(Object id); @Override void deleteAll(); @Override void delete(Stream<StyleSheet> styleSheetStream); @Override void deleteAll(Stream<Object> ids); }### Answer:
@Test void testDelete() { StyleSheet sheet = mock(StyleSheet.class); when(sheet.getId()).thenReturn("1"); decorator.delete(sheet); verify(delegate).delete(sheet); }
@SuppressWarnings("deprecation") @Test void testDeleteCurrent() { StyleSheet sheet = mock(StyleSheet.class); when(sheet.getId()).thenReturn("2"); assertThrows(MolgenisDataException.class, () -> decorator.delete(sheet)); verifyZeroInteractions(delegate); }
|
### Question:
StyleSheetRepositoryDecorator extends AbstractRepositoryDecorator<StyleSheet> { @Override public void deleteAll() { throw new MolgenisDataException( "Cannot delete all boostrap themes, at least one theme is needed for the application"); } StyleSheetRepositoryDecorator(
Repository<StyleSheet> delegateRepository, AppSettings appSettings); @Override void delete(StyleSheet sheet); @Override void deleteById(Object id); @Override void deleteAll(); @Override void delete(Stream<StyleSheet> styleSheetStream); @Override void deleteAll(Stream<Object> ids); }### Answer:
@SuppressWarnings("deprecation") @Test void testDeleteAll() { assertThrows(MolgenisDataException.class, () -> decorator.deleteAll()); }
@SuppressWarnings("deprecation") @Test void testDeleteAllStream() { assertThrows( MolgenisDataException.class, () -> decorator.deleteAll(Stream.of("1", "2", "3", "4"))); }
|
### Question:
MolgenisInterceptor extends HandlerInterceptorAdapter { public MolgenisInterceptor( ResourceFingerprintRegistry resourceFingerprintRegistry, ThemeFingerprintRegistry themeFingerprintRegistry, AppSettings appSettings, AuthenticationSettings authenticationSettings, @Value("${environment}") String environment, MessageSource messageSource, Gson gson, PlatformTransactionManager transactionManager, UserAccountService userAccountService) { this.resourceFingerprintRegistry = requireNonNull(resourceFingerprintRegistry); this.themeFingerprintRegistry = requireNonNull(themeFingerprintRegistry); this.appSettings = requireNonNull(appSettings); this.authenticationSettings = requireNonNull(authenticationSettings); this.environment = requireNonNull(environment); this.messageSource = requireNonNull(messageSource); this.gson = requireNonNull(gson); this.transactionManager = requireNonNull(transactionManager); this.userAccountService = requireNonNull(userAccountService); } MolgenisInterceptor(
ResourceFingerprintRegistry resourceFingerprintRegistry,
ThemeFingerprintRegistry themeFingerprintRegistry,
AppSettings appSettings,
AuthenticationSettings authenticationSettings,
@Value("${environment}") String environment,
MessageSource messageSource,
Gson gson,
PlatformTransactionManager transactionManager,
UserAccountService userAccountService); @Override void postHandle(
HttpServletRequest request,
HttpServletResponse response,
Object handler,
ModelAndView modelAndView); static final String KEY_LANGUAGE; static final String KEY_FALLBACK_LANGUAGE; static final String KEY_SUPER_USER; static final String ATTRIBUTE_ENVIRONMENT_TYPE; }### Answer:
@Test void MolgenisInterceptor() { assertThrows( NullPointerException.class, () -> new MolgenisInterceptor(null, null, null, null, null, null, null, null, null)); }
|
### Question:
UserManagerServiceImpl implements UserManagerService { UserManagerServiceImpl(DataService dataService) { this.dataService = requireNonNull(dataService); } UserManagerServiceImpl(DataService dataService); @Override @PreAuthorize("hasAnyRole('ROLE_SU','ROLE_MANAGER')") @Transactional(readOnly = true) List<UserViewData> getAllUsers(); @Override @PreAuthorize("hasAnyRole('ROLE_SU','ROLE_MANAGER')") @Transactional void setActivationUser(String userId, Boolean active); }### Answer:
@Test void userManagerServiceImpl() { assertThrows(NullPointerException.class, () -> new UserManagerServiceImpl(null)); }
|
### Question:
UserManagerServiceImpl implements UserManagerService { @Override @PreAuthorize("hasAnyRole('ROLE_SU','ROLE_MANAGER')") @Transactional(readOnly = true) public List<UserViewData> getAllUsers() { Stream<User> users = dataService.findAll(USER, User.class); return this.parseToMolgenisUserViewData(users); } UserManagerServiceImpl(DataService dataService); @Override @PreAuthorize("hasAnyRole('ROLE_SU','ROLE_MANAGER')") @Transactional(readOnly = true) List<UserViewData> getAllUsers(); @Override @PreAuthorize("hasAnyRole('ROLE_SU','ROLE_MANAGER')") @Transactional void setActivationUser(String userId, Boolean active); }### Answer:
@Test void getAllMolgenisUsersSu() { String molgenisUserId0 = "id0"; String molgenisUserName0 = "user0"; User user0 = when(mock(User.class).getId()).thenReturn(molgenisUserId0).getMock(); when(user0.getUsername()).thenReturn(molgenisUserName0); String molgenisUserId1 = "id1"; String molgenisUserName1 = "user1"; User user1 = when(mock(User.class).getId()).thenReturn(molgenisUserId1).getMock(); when(user1.getUsername()).thenReturn(molgenisUserName1); when(dataService.findOneById(USER, molgenisUserId0, User.class)).thenReturn(user0); when(dataService.findOneById(USER, molgenisUserId1, User.class)).thenReturn(user1); when(dataService.findAll(USER, User.class)).thenReturn(Stream.of(user0, user1)); this.setSecurityContextSuperUser(); assertEquals( asList(new UserViewData(user0), new UserViewData(user1)), userManagerService.getAllUsers()); }
@Test void getAllMolgenisUsersNonSu() { this.setSecurityContextNonSuperUserWrite(); assertThrows(AccessDeniedException.class, () -> this.userManagerService.getAllUsers()); }
|
### Question:
UserManagerServiceImpl implements UserManagerService { @Override @PreAuthorize("hasAnyRole('ROLE_SU','ROLE_MANAGER')") @Transactional public void setActivationUser(String userId, Boolean active) { User user = dataService.findOneById(USER, userId, User.class); if (user == null) { throw new UnknownEntityException(USER, userId); } user.setActive(active); this.dataService.update(USER, user); } UserManagerServiceImpl(DataService dataService); @Override @PreAuthorize("hasAnyRole('ROLE_SU','ROLE_MANAGER')") @Transactional(readOnly = true) List<UserViewData> getAllUsers(); @Override @PreAuthorize("hasAnyRole('ROLE_SU','ROLE_MANAGER')") @Transactional void setActivationUser(String userId, Boolean active); }### Answer:
@Test void testSetActivationUser() { this.setSecurityContextSuperUser(); String userId = "MyUserId"; User user = mock(User.class); when(dataService.findOneById(USER, userId, User.class)).thenReturn(user); userManagerService.setActivationUser(userId, true); verify(user).setActive(true); verify(dataService).update(USER, user); }
@Test void testSetActivationUserUnknown() { this.setSecurityContextSuperUser(); assertThrows( UnknownEntityException.class, () -> userManagerService.setActivationUser("unknownUserId", true)); }
|
### Question:
ErrorMessageResponse { public ErrorMessageResponse() {} ErrorMessageResponse(); ErrorMessageResponse(ErrorMessage errorMessage); ErrorMessageResponse(List<ErrorMessage> errorMessages); List<ErrorMessage> getErrors(); void addErrorMessage(ErrorMessage errorMessage); void addErrorMessages(List<ErrorMessage> errorMessages); static ErrorMessageResponse create(String errorMessage); static ErrorMessageResponse create(
String errorMessage, @Nullable @CheckForNull String errorCode); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer:
@Test void ErrorMessageResponse() { ErrorMessageResponse errorMessageResponse = new ErrorMessageResponse(); assertEquals(emptyList(), errorMessageResponse.getErrors()); }
|
### Question:
UnexpectedPermissionException extends RuntimeException { public <E extends Enum> UnexpectedPermissionException(Permission permission) { this.permission = requireNonNull(permission); } <E extends Enum> UnexpectedPermissionException(Permission permission); @Override String getMessage(); }### Answer:
@Test void testUnexpectedPermissionException() { Permission permission = mock(Permission.class); when(permission.toString()).thenReturn("test"); assertEquals( "Illegal permission 'test'", new UnexpectedPermissionException(permission).getMessage()); }
|
### Question:
ErrorMessageResponse { public List<ErrorMessage> getErrors() { return errors != null ? errors : Collections.emptyList(); } ErrorMessageResponse(); ErrorMessageResponse(ErrorMessage errorMessage); ErrorMessageResponse(List<ErrorMessage> errorMessages); List<ErrorMessage> getErrors(); void addErrorMessage(ErrorMessage errorMessage); void addErrorMessages(List<ErrorMessage> errorMessages); static ErrorMessageResponse create(String errorMessage); static ErrorMessageResponse create(
String errorMessage, @Nullable @CheckForNull String errorCode); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer:
@Test void ErrorMessageResponseErrorMessage() { ErrorMessage errorMessage = new ErrorMessage("message"); ErrorMessageResponse errorMessageResponse = new ErrorMessageResponse(errorMessage); assertEquals(singletonList(errorMessage), errorMessageResponse.getErrors()); }
@Test void ErrorMessageResponseListErrorMessage() { List<ErrorMessage> errorMessages = Arrays.asList(new ErrorMessage("message1"), new ErrorMessage("message2")); ErrorMessageResponse errorMessageResponse = new ErrorMessageResponse(errorMessages); assertEquals(errorMessages, errorMessageResponse.getErrors()); }
|
### Question:
L1Cache implements TransactionListener { void evict(Entity entity) { CombinedEntityCache entityCache = caches.get(); if (entityCache != null) { entityCache.evict( Stream.of(EntityKey.create(entity.getEntityType().getId(), entity.getIdValue()))); } } L1Cache(TransactionManager transactionManager, EntityHydration entityHydration); @Override void transactionStarted(String transactionId); @Override void doCleanupAfterCompletion(String transactionId); Optional<CacheHit<Entity>> get(EntityType entityType, Object entityId); Optional<CacheHit<Entity>> get(
EntityType entityType, Object entityId, @Nullable @CheckForNull Fetch fetch); void put(Entity entity); }### Answer:
@Test void evict() { String entityTypeId = "MyEntityTypeId"; EntityType entityType = when(mock(EntityType.class).getId()).thenReturn(entityTypeId).getMock(); Object entityId = mock(Object.class); Entity entity = when(mock(Entity.class).getIdValue()).thenReturn(entityId).getMock(); when(entity.getEntityType()).thenReturn(entityType); l1Cache.put(entity); l1Cache.evict(entity); assertEquals(Optional.empty(), l1Cache.get(entityType, entityId)); }
|
### Question:
L1Cache implements TransactionListener { void evictAll(EntityType entityType) { CombinedEntityCache entityCache = caches.get(); if (entityCache != null) { LOG.trace("Removing all entities from L1 cache that belong to {}", entityType.getId()); entityCache.evictAll(entityType); } } L1Cache(TransactionManager transactionManager, EntityHydration entityHydration); @Override void transactionStarted(String transactionId); @Override void doCleanupAfterCompletion(String transactionId); Optional<CacheHit<Entity>> get(EntityType entityType, Object entityId); Optional<CacheHit<Entity>> get(
EntityType entityType, Object entityId, @Nullable @CheckForNull Fetch fetch); void put(Entity entity); }### Answer:
@Test void evictAll() { String entityTypeId = "MyEntityTypeId"; EntityType entityType = when(mock(EntityType.class).getId()).thenReturn(entityTypeId).getMock(); Object entityId = mock(Object.class); Entity entity = when(mock(Entity.class).getIdValue()).thenReturn(entityId).getMock(); when(entity.getEntityType()).thenReturn(entityType); l1Cache.putDeletion(entity); l1Cache.evictAll(entityType); assertEquals(Optional.empty(), l1Cache.get(entityType, entityId)); }
|
### Question:
ErrorMessageResponse { public void addErrorMessage(ErrorMessage errorMessage) { if (this.errors == null) errors = new ArrayList<>(); this.errors.add(errorMessage); } ErrorMessageResponse(); ErrorMessageResponse(ErrorMessage errorMessage); ErrorMessageResponse(List<ErrorMessage> errorMessages); List<ErrorMessage> getErrors(); void addErrorMessage(ErrorMessage errorMessage); void addErrorMessages(List<ErrorMessage> errorMessages); static ErrorMessageResponse create(String errorMessage); static ErrorMessageResponse create(
String errorMessage, @Nullable @CheckForNull String errorCode); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer:
@Test void addErrorMessage() { ErrorMessageResponse errorMessageResponse = new ErrorMessageResponse(); ErrorMessage errorMessage1 = new ErrorMessage("message1"); ErrorMessage errorMessage2 = new ErrorMessage("message2"); errorMessageResponse.addErrorMessage(errorMessage1); errorMessageResponse.addErrorMessage(errorMessage2); assertEquals( asList(new ErrorMessage("message1"), new ErrorMessage("message2")), errorMessageResponse.getErrors()); }
|
### Question:
ErrorMessageResponse { public void addErrorMessages(List<ErrorMessage> errorMessages) { if (this.errors == null) errors = new ArrayList<>(); this.errors.addAll(errorMessages); } ErrorMessageResponse(); ErrorMessageResponse(ErrorMessage errorMessage); ErrorMessageResponse(List<ErrorMessage> errorMessages); List<ErrorMessage> getErrors(); void addErrorMessage(ErrorMessage errorMessage); void addErrorMessages(List<ErrorMessage> errorMessages); static ErrorMessageResponse create(String errorMessage); static ErrorMessageResponse create(
String errorMessage, @Nullable @CheckForNull String errorCode); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer:
@Test void addErrorMessages() { ErrorMessage errorMessage1 = new ErrorMessage("message1"); ErrorMessage errorMessage2 = new ErrorMessage("message2"); List<ErrorMessage> errorMessages1 = Arrays.asList(errorMessage1, errorMessage2); ErrorMessage errorMessage3 = new ErrorMessage("message3"); ErrorMessage errorMessage4 = new ErrorMessage("message4"); List<ErrorMessage> errorMessages2 = Arrays.asList(errorMessage3, errorMessage4); ErrorMessageResponse errorMessageResponse = new ErrorMessageResponse(); errorMessageResponse.addErrorMessages(errorMessages1); errorMessageResponse.addErrorMessages(errorMessages2); assertEquals( asList(errorMessage1, errorMessage2, errorMessage3, errorMessage4), errorMessageResponse.getErrors()); }
|
### Question:
L1CacheJanitorImpl implements L1CacheJanitor { @Override public void cleanCacheBeforeDeleteAll(EntityType entityType) { } L1CacheJanitorImpl(L1Cache l1Cache); @Override void cleanCacheBeforeAdd(Entity entity); @Override Stream<Entity> cleanCacheBeforeAdd(EntityType entityType, Stream<Entity> entityStream); @Override void cleanCacheBeforeUpdate(Entity entity); @Override Stream<Entity> cleanCacheBeforeUpdate(EntityType entityType, Stream<Entity> entityStream); @Override void cleanCacheBeforeDelete(Entity entity); @Override Stream<Entity> cleanCacheBeforeDelete(EntityType entityType, Stream<Entity> entityStream); @Override void cleanCacheBeforeDeleteById(EntityType entityType, Object entityId); @Override Stream<Object> cleanCacheBeforeDeleteById(
EntityType entityType, Stream<Object> entityIdStream); @Override void cleanCacheBeforeDeleteAll(EntityType entityType); }### Answer:
@Test void cleanCacheBeforeDeleteAll() { EntityType entityType = mock(EntityType.class); l1CacheJanitorImpl.cleanCacheBeforeDeleteAll(entityType); verifyNoInteractions(l1Cache); }
|
### Question:
CsvHttpMessageConverter extends BaseHttpMessageConverter<EntityCollection> { @Override protected void writeInternal(EntityCollection entities, HttpOutputMessage outputMessage) throws IOException { Charset charset = getCharset(outputMessage.getHeaders()); try (CsvWriter csvWriter = new CsvWriter(new OutputStreamWriter(outputMessage.getBody(), charset))) { csvWriter.writeAttributeNames(entities.getAttributeNames()); csvWriter.add(entities.stream()); } } CsvHttpMessageConverter(); }### Answer:
@Test void testWriteInternal() throws IOException { List<String> attrName = asList("attr0", "attr1"); Entity entity0 = mock(Entity.class); Entity entity1 = mock(Entity.class); EntityCollection entityCollection = mock(EntityCollection.class); when(entityCollection.getAttributeNames()).thenReturn(attrName); when(entityCollection.stream()).thenReturn(Stream.of(entity0, entity1)); HttpHeaders httpHeaders = mock(HttpHeaders.class); when(httpHeaders.getContentType()).thenReturn(APPLICATION_JSON_UTF8); OutputStream outputStream = mock(OutputStream.class); HttpOutputMessage outputMessage = mock(HttpOutputMessage.class); when(outputMessage.getHeaders()).thenReturn(httpHeaders); when(outputMessage.getBody()).thenReturn(outputStream); csvHttpMessageConverter.writeInternal(entityCollection, outputMessage); verify(outputStream).close(); }
|
### Question:
CsvHttpMessageConverter extends BaseHttpMessageConverter<EntityCollection> { @Override protected boolean supports(Class<?> clazz) { return EntityCollection.class.isAssignableFrom(clazz); } CsvHttpMessageConverter(); }### Answer:
@Test void testSupports() { assertTrue(csvHttpMessageConverter.supports(EntityCollection.class)); }
@Test void testSupportsNo() { assertFalse(csvHttpMessageConverter.supports(Object.class)); }
|
### Question:
L1CacheRepositoryDecorator extends AbstractRepositoryDecorator<Entity> { @Override public void deleteById(Object id) { if (useCache()) { EntityType entityType = getEntityType(); l1CacheJanitor.cleanCacheBeforeDeleteById(entityType, id); delCache(entityType, id); } delegate().deleteById(id); } L1CacheRepositoryDecorator(
Repository<Entity> delegateRepository, L1Cache l1Cache, L1CacheJanitor l1CacheJanitor); @Override void add(Entity entity); @Override Integer add(Stream<Entity> entities); @Override Entity findOneById(Object id); @Override Entity findOneById(Object id, Fetch fetch); @Override Stream<Entity> findAll(Stream<Object> ids); @Override Stream<Entity> findAll(Stream<Object> ids, Fetch fetch); @Override void update(Entity entity); @Override void update(Stream<Entity> entities); @Override void delete(Entity entity); @Override void delete(Stream<Entity> entities); @Override void deleteById(Object id); @Override void deleteAll(Stream<Object> ids); @Override void deleteAll(); }### Answer:
@Test void testDeleteById() { EntityType entityType = mock(EntityType.class); when(delegateRepository.getEntityType()).thenReturn(entityType); Object entityId = mock(Object.class); l1CacheRepositoryDecorator.deleteById(entityId); verify(l1CacheJanitor).cleanCacheBeforeDeleteById(entityType, entityId); verify(l1Cache).putDeletion(entityType, entityId); verify(delegateRepository).deleteById(entityId); verifyNoMoreInteractions(l1CacheJanitor, l1Cache, delegateRepository); }
|
### Question:
CombinedEntityCache { public Optional<CacheHit<Entity>> getIfPresent(EntityType entityType, Object id) { return getIfPresent(entityType, id, null); } CombinedEntityCache(
EntityHydration entityHydration, Cache<EntityKey, CacheHit<Map<String, Object>>> cache); void putDeletion(EntityKey entityKey); void evictAll(EntityType entityType); Optional<CacheHit<Entity>> getIfPresent(EntityType entityType, Object id); Optional<CacheHit<Entity>> getIfPresent(
EntityType entityType, Object id, @Nullable @CheckForNull Fetch fetch); void put(Entity entity); void evict(Stream<EntityKey> entityKeys); }### Answer:
@Test void getIfPresentIntegerIdEntityNotPresentInCache() { when(cache.getIfPresent(EntityKey.create("TestEntity", 123))).thenReturn(null); assertEquals(empty(), entityCache.getIfPresent(entityType, 123)); }
@Test void getIfPresentIntegerIdDeletionLoggedInCache() { when(cache.getIfPresent(EntityKey.create("TestEntity", 123))).thenReturn(CacheHit.empty()); assertEquals(of(CacheHit.empty()), entityCache.getIfPresent(entityType, 123)); }
|
### Question:
EntityHydration { public Entity hydrate(Map<String, Object> dehydratedEntity, EntityType entityType) { if (LOG.isTraceEnabled()) { LOG.trace("Hydrating entity: {} for entity {}", dehydratedEntity, entityType.getId()); } Entity hydratedEntity = entityManager.create(entityType, NO_POPULATE); for (Attribute attribute : entityType.getAtomicAttributes()) { hydrateValue(dehydratedEntity, attribute, hydratedEntity); } return hydratedEntity; } EntityHydration(EntityManager entityManager); Entity hydrate(Map<String, Object> dehydratedEntity, EntityType entityType); Entity hydrate(
Map<String, Object> dehydratedEntity,
EntityType entityType,
@Nullable @CheckForNull Fetch fetch); Map<String, Object> dehydrate(Entity entity); }### Answer:
@Test void hydrateTest() { Entity actualHydratedEntity = entityHydration.hydrate(dehydratedEntity, entityType); assertTrue(EntityUtils.equals(actualHydratedEntity, hydratedEntity)); assertTrue( entityTypeArgumentCaptor.getAllValues().stream() .allMatch(emd -> emd.getId().equals("TypeTestRefDynamic"))); }
|
### Question:
L3CacheRepositoryDecorator extends AbstractRepositoryDecorator<Entity> { @Override public Entity findOne(Query<Entity> query) { if (transactionInformation.isRepositoryCompletelyClean(getEntityType()) && cacheable) { QueryImpl<Entity> cacheKey = new QueryImpl<>(query).setPageSize(1); List<Object> ids = l3Cache.get(delegate(), cacheKey); if (ids.isEmpty()) { return null; } return delegate().findOneById(ids.get(0), query.getFetch()); } return delegate().findOne(query); } L3CacheRepositoryDecorator(
Repository<Entity> delegateRepository,
L3Cache l3Cache,
TransactionInformation transactionInformation); @Override Stream<Entity> findAll(Query<Entity> query); @Override Entity findOne(Query<Entity> query); }### Answer:
@Test void testFindOneRepositoryClean() { when(transactionInformation.isRepositoryCompletelyClean(entityType)).thenReturn(true); Query<Entity> queryWithPageSizeOne = new QueryImpl<>(query).pageSize(1); when(l3Cache.get(delegateRepository, queryWithPageSizeOne)).thenReturn(singletonList(3)); when(delegateRepository.findOneById(3, fetch)).thenReturn(entity3); assertEquals(entity3, l3CacheRepositoryDecorator.findOne(queryWithPageSizeOne)); verify(delegateRepository, times(1)).findOneById(3, fetch); verify(delegateRepository, atLeast(0)).getEntityType(); verifyNoMoreInteractions(delegateRepository); }
@Test void testFindOneRepositoryDirty() { when(transactionInformation.isRepositoryCompletelyClean(entityType)).thenReturn(false); when(delegateRepository.findOne(query)).thenReturn(entity3); assertEquals(entity3, l3CacheRepositoryDecorator.findOne(query)); verifyNoMoreInteractions(l3Cache); }
|
### Question:
CsvHttpMessageConverter extends BaseHttpMessageConverter<EntityCollection> { @Override protected EntityCollection readInternal( Class<? extends EntityCollection> clazz, HttpInputMessage inputMessage) { throw new UnsupportedOperationException(); } CsvHttpMessageConverter(); }### Answer:
@Test void testReadInternal() throws IOException { assertThrows( UnsupportedOperationException.class, () -> csvHttpMessageConverter.readInternal( EntityCollection.class, mock(HttpInputMessage.class))); }
|
### Question:
L2Cache implements TransactionListener { public List<Entity> getBatch(Repository<Entity> repository, Iterable<Object> ids) { try { EntityType entityType = repository.getEntityType(); return getEntityCache(repository).getAll(ids).values().stream() .filter(Optional::isPresent) .map(e -> entityHydration.hydrate(e.get(), entityType)) .collect(toList()); } catch (ExecutionException exception) { throw translateExecutionException(exception); } } L2Cache(
TransactionManager transactionManager,
EntityHydration entityHydration,
TransactionInformation transactionInformation,
MeterRegistry meterRegistry); @Override void afterCommitTransaction(String transactionId); Entity get(Repository<Entity> repository, Object id); Entity get(Repository<Entity> repository, Object id, Fetch fetch); List<Entity> getBatch(Repository<Entity> repository, Iterable<Object> ids); List<Entity> getBatch(Repository<Entity> repository, Iterable<Object> ids, Fetch fetch); @Scheduled(fixedRate = 60000) void logStatistics(); }### Answer:
@SuppressWarnings("unchecked") @Test void testGetBatchIdLoaderThrowsException() { when(repository.findAll(any(Stream.class))) .thenThrow(new MolgenisDataException("Table is missing for entity TestEntity")); assertThrows( UncheckedExecutionException.class, () -> l2Cache.getBatch(repository, newArrayList("1", "2"))); }
@Test void testGetBatch() { when(repository.findAll(idStreamCaptor.capture())).thenReturn(testEntities.stream()); List<Entity> result = l2Cache.getBatch(repository, newArrayList("0", "1", "2", "3")); Map<Object, Entity> retrievedEntities = result.stream().collect(toMap(Entity::getIdValue, e -> e)); assertEquals(4, retrievedEntities.size()); assertTrue(EntityUtils.equals(retrievedEntities.get("1"), testEntities.get(1))); assertEquals(newArrayList("0", "1", "2", "3"), idStreamCaptor.getValue().collect(toList())); }
|
### Question:
JsScriptRunner implements ScriptRunner { @Override public boolean hasFileOutput(Script script) { return false; } JsScriptRunner(JsScriptExecutor jsScriptExecutor); @Override String getName(); @Override boolean hasFileOutput(Script script); @Override String runScript(Script script, Map<String, Object> parameters); }### Answer:
@Test void testHasFileOutput() { assertFalse(jsScriptRunner.hasFileOutput(mock(Script.class))); }
|
### Question:
NashornScriptEngine { public Object eval(String script) throws ScriptException { return convertNashornValue(scriptEngine.eval(script, new SimpleBindings())); } NashornScriptEngine(); Object eval(String script); Object eval(Bindings bindings, String expression); ScriptObjectMirror newJSArray(); }### Answer:
@Test void testInvokeFunction() throws Exception { long epoch = 1487342481434L; assertEquals(epoch, nashornScriptEngine.eval("new Date(" + epoch + ")")); }
@Test void testInvokeDateDMY() throws Exception { LocalDate localDate = LocalDate.now(); String script = String.format( "new Date(%d,%d,%d)", localDate.getYear(), localDate.getMonth().getValue() - 1, localDate.getDayOfMonth()); long epochMilli = localDate.atStartOfDay(ZoneId.systemDefault()).toInstant().toEpochMilli(); assertEquals(epochMilli, nashornScriptEngine.eval(script)); }
@Test void doesntDirtyContext() throws ScriptException { nashornScriptEngine.eval("piet = 3"); Exception exception = assertThrows(ScriptException.class, () -> nashornScriptEngine.eval("piet")); assertThat(exception.getMessage()) .containsPattern("ReferenceError: \"piet\" is not defined in <eval> at line number 1"); }
|
### Question:
JsMagmaScriptRunner implements ScriptRunner { @Override public boolean hasFileOutput(Script script) { return false; } JsMagmaScriptRunner(JsMagmaScriptExecutor jsMagmaScriptExecutor); @Override String getName(); @Override boolean hasFileOutput(Script script); @Override String runScript(Script script, Map<String, Object> parameters); static final String NAME; }### Answer:
@Test void testHasFileOutput() { assertFalse(jsMagmaScriptRunner.hasFileOutput(mock(Script.class))); }
|
### Question:
JsMagmaScriptExecutor { Object executeScript(String jsScript, Map<String, Object> parameters) { EntityType entityType = entityTypeFactory.create("entity"); Set<String> attributeNames = parameters.keySet(); attributeNames.forEach(key -> entityType.addAttribute(attributeFactory.create().setName(key))); if (attributeNames.iterator().hasNext()) { entityType.getAttribute(attributeNames.iterator().next()).setIdAttribute(true); } Entity entity = new DynamicEntity(entityType); parameters.forEach(entity::set); return jsMagmaScriptEvaluator.eval(jsScript, entity); } JsMagmaScriptExecutor(
JsMagmaScriptEvaluator jsMagmaScriptEvaluator,
EntityTypeFactory entityTypeFactory,
AttributeFactory attributeFactory); }### Answer:
@Test void testExecuteScript() { String entityId = "entity"; String attributeName = "myAttribute"; String attributeValue = "value"; String jsScript = "MyJsScript"; Attribute attribute = mock(Attribute.class); when(attribute.getDataType()).thenReturn(STRING); when(attributeFactory.create()).thenReturn(attribute); EntityType entityType = mock(EntityType.class); when(entityType.getAttribute(attributeName)).thenReturn(attribute); when(entityTypeFactory.create(entityId)).thenReturn(entityType); Object object = mock(Object.class); ArgumentCaptor<Entity> entityCaptor = ArgumentCaptor.forClass(Entity.class); when(jsMagmaScriptEvaluator.eval(eq(jsScript), entityCaptor.capture())).thenReturn(object); Map<String, Object> parameters = Collections.singletonMap(attributeName, attributeValue); assertEquals(object, jsMagmaScriptExecutor.executeScript(jsScript, parameters)); verify(attribute).setName(attributeName); assertEquals(attributeValue, entityCaptor.getValue().get(attributeName)); }
|
### Question:
ScheduledScriptConfig { Map<String, Object> getParameterMap(ScriptJobExecution scriptJobExecution) { Map<String, Object> params = new HashMap<>(); String parameterString = scriptJobExecution.getParameters(); if (!Strings.isNullOrEmpty(parameterString)) { params.putAll(gson.fromJson(parameterString, MAP_TOKEN)); } params.put("scriptJobExecutionId", scriptJobExecution.getIdValue()); return params; } ScheduledScriptConfig(
SavedScriptRunner savedScriptRunner,
ScheduledJobTypeFactory scheduledJobTypeFactory,
ScriptJobExecutionMetadata scriptJobExecutionMetadata,
Gson gson); @Bean JobFactory<ScriptJobExecution> scriptJobFactory(); @Lazy @Bean ScheduledJobType scriptJobType(); }### Answer:
@Test void testGetParameterMap() { ScriptJobExecution scriptJobExecution = mock(ScriptJobExecution.class); when(scriptJobExecution.getParameters()).thenReturn("{param1:test,param2:value}"); when(scriptJobExecution.getIdValue()).thenReturn("scriptJobExecutionIdentifier"); Map<String, Object> actual = scheduledJobConfig.getParameterMap(scriptJobExecution); Map<String, Object> expected = new HashMap<>(); expected.put("param1", "test"); expected.put("param2", "value"); expected.put("scriptJobExecutionId", "scriptJobExecutionIdentifier"); assertEquals(expected, actual); }
@Test void testGetParameterMapEmptyString() { ScriptJobExecution scriptJobExecution = mock(ScriptJobExecution.class); when(scriptJobExecution.getParameters()).thenReturn(null); when(scriptJobExecution.getIdValue()).thenReturn("scriptJobExecutionIdentifier"); Map<String, Object> actual = scheduledJobConfig.getParameterMap(scriptJobExecution); Map<String, Object> expected = new HashMap<>(); expected.put("scriptJobExecutionId", "scriptJobExecutionIdentifier"); assertEquals(expected, actual); }
|
### Question:
MolgenisTimedAspect { @Around("execution (@io.micrometer.core.annotation.Timed * *.*(..))") public Object timedMethod(ProceedingJoinPoint pjp) throws Throwable { Method method = ((MethodSignature) pjp.getSignature()).getMethod(); return timedProceed(pjp, method.getAnnotation(Timed.class)); } MolgenisTimedAspect(MeterRegistry registry); MolgenisTimedAspect(
MeterRegistry registry, Function<ProceedingJoinPoint, Iterable<Tag>> tagsBasedOnJoinpoint); @Around("execution(* (@io.micrometer.core.annotation.Timed *).*(..))") Object timedClassMethod(ProceedingJoinPoint pjp); @Around("execution (@io.micrometer.core.annotation.Timed * *.*(..))") Object timedMethod(ProceedingJoinPoint pjp); }### Answer:
@Test void testExecuteAnnotatedMethod() throws Throwable { when(clock.monotonicTime()).thenReturn(0L, 100L); when(proceedingJoinPoint.getSignature()).thenReturn(signature); when(signature.getMethod()).thenReturn(AnnotatedMethod.class.getMethod("annotatedMethod")); when(proceedingJoinPoint.getStaticPart()).thenReturn(staticPart); when(staticPart.getSignature()).thenReturn(signature); when(proceedingJoinPoint.getSignature()).thenReturn(signature); when(signature.getDeclaringTypeName()).thenReturn("AnnotatedMethod"); when(signature.getName()).thenReturn("annotatedMethod"); when(proceedingJoinPoint.proceed()).thenReturn(42); assertEquals(42, timedAspect.timedMethod(proceedingJoinPoint)); verify(proceedingJoinPoint, times(1)).proceed(); Timer timer = meterRegistry.get("test.method").timer(); assertEquals(1, timer.count()); assertEquals(100.0, timer.max(NANOSECONDS)); }
|
### Question:
MolgenisTimedAspect { @Around("execution(* (@io.micrometer.core.annotation.Timed *).*(..))") public Object timedClassMethod(ProceedingJoinPoint pjp) throws Throwable { Method method = ((MethodSignature) pjp.getSignature()).getMethod(); return timedProceed(pjp, method.getDeclaringClass().getAnnotation(Timed.class)); } MolgenisTimedAspect(MeterRegistry registry); MolgenisTimedAspect(
MeterRegistry registry, Function<ProceedingJoinPoint, Iterable<Tag>> tagsBasedOnJoinpoint); @Around("execution(* (@io.micrometer.core.annotation.Timed *).*(..))") Object timedClassMethod(ProceedingJoinPoint pjp); @Around("execution (@io.micrometer.core.annotation.Timed * *.*(..))") Object timedMethod(ProceedingJoinPoint pjp); }### Answer:
@Test void testExecuteAnnotatedClass() throws Throwable { doReturn(0L, 100L).when(clock).monotonicTime(); when(proceedingJoinPoint.getSignature()).thenReturn(signature); when(signature.getMethod()).thenReturn(AnnotatedClass.class.getMethod("annotatedMethod")); when(proceedingJoinPoint.getStaticPart()).thenReturn(staticPart); when(staticPart.getSignature()).thenReturn(signature); when(proceedingJoinPoint.getSignature()).thenReturn(signature); when(signature.getDeclaringTypeName()).thenReturn("AnnotatedMethod"); when(signature.getName()).thenReturn("annotatedMethod"); when(proceedingJoinPoint.proceed()).thenReturn(42); assertEquals(42, timedAspect.timedClassMethod(proceedingJoinPoint)); verify(proceedingJoinPoint, times(1)).proceed(); Timer timer = meterRegistry.get("test.class").timer(); assertEquals(1, timer.count()); assertEquals(100.0, timer.max(NANOSECONDS)); }
|
### Question:
AllPropertiesMessageSource extends ResourceBundleMessageSource { public SetMultimap<String, String> getAllMessageIds() { ImmutableSetMultimap.Builder<String, String> result = ImmutableSetMultimap.builder(); getBasenameSet() .forEach(basename -> result.putAll(basename.substring(5), getMessageIds(basename))); return result.build(); } AllPropertiesMessageSource(); void addMolgenisNamespaces(String... namespaces); SetMultimap<String, String> getAllMessageIds(); @Override // Overridden to make the visibility String resolveCodeWithoutArguments(String code, Locale locale); }### Answer:
@Test void testGetAllMessageIds() throws Exception { assertEquals( of("test", "EN_ONLY", "test", "EN_PLUS_NL", "test", "BIOBANK_UTF8", "test", "NL_ONLY"), propertiesMessageSource.getAllMessageIds()); }
|
### Question:
AllPropertiesMessageSource extends ResourceBundleMessageSource { @Override public String resolveCodeWithoutArguments(String code, Locale locale) { return super.resolveCodeWithoutArguments(code, locale); } AllPropertiesMessageSource(); void addMolgenisNamespaces(String... namespaces); SetMultimap<String, String> getAllMessageIds(); @Override // Overridden to make the visibility String resolveCodeWithoutArguments(String code, Locale locale); }### Answer:
@Test void testGetMessageSpecifiedInBundle() throws Exception { assertEquals( "alleen Nederlands", propertiesMessageSource.resolveCodeWithoutArguments("NL_ONLY", DUTCH)); }
@Test void testGetMessageSpecifiedInOtherBundle() throws Exception { assertNull(propertiesMessageSource.resolveCodeWithoutArguments("EN_ONLY", new Locale("nl"))); }
@Test void testGetMessageNotSpecified() throws Exception { assertNull(propertiesMessageSource.resolveCodeWithoutArguments("MISSING", new Locale("nl"))); }
@Test void testGetMessageSpecifiedInBoth() throws Exception { assertEquals( "English plus Dutch", propertiesMessageSource.resolveCodeWithoutArguments("EN_PLUS_NL", ENGLISH)); assertEquals( "Engels plus Nederlands", propertiesMessageSource.resolveCodeWithoutArguments("EN_PLUS_NL", new Locale("nl"))); }
@Test void testGetMessageUTF8() { assertEquals( "Biøbånk\uD83D\uDC00", propertiesMessageSource.resolveCodeWithoutArguments("BIOBANK_UTF8", ENGLISH)); }
|
### Question:
ListEscapeUtils { public static List<String> toList(String str) { return toList(str, DEFAULT_SEPARATOR, DEFAULT_ESCAPE_CHAR); } private ListEscapeUtils(); static String toString(List<?> list); static String toString(List<?> list, char sep, char esc); static List<String> toList(String str); static List<String> toList(String str, char sep, char esc); static final char DEFAULT_SEPARATOR; static final char DEFAULT_ESCAPE_CHAR; }### Answer:
@Test void toListString() { assertEquals(singletonList("a"), toList("a")); assertEquals(asList("a", "b", "c"), toList("a,b,c")); assertEquals(singletonList(","), toList("\\,")); assertEquals(singletonList("a,b"), toList("a\\,b")); assertEquals(singletonList("\\"), toList("\\\\")); assertEquals(singletonList("a\\b"), toList("a\\\\b")); assertEquals(asList("a", "b", ""), toList("a,b,")); assertEquals(asList("a", "", "c"), toList("a,,c")); assertEquals(asList("", "b", "c"), toList(",b,c")); assertEquals(emptyList(), toList("")); assertNull(ListEscapeUtils.toList(null)); }
@Test void toListStringcharchar_exception() { assertThrows(IllegalArgumentException.class, () -> ListEscapeUtils.toList("", 'a', 'a')); }
|
### Question:
UnexpectedEnumException extends RuntimeException { public <E extends Enum> UnexpectedEnumException(E enumConstant) { this.enumConstant = requireNonNull(enumConstant); } <E extends Enum> UnexpectedEnumException(E enumConstant); @Override String getMessage(); }### Answer:
@Test void testUnexpectedEnumException() { assertEquals( "Unexpected enum constant 'MY_ENUM_CONSTANT' for type 'MyEnum'", new UnexpectedEnumException(MY_ENUM_CONSTANT).getMessage()); }
|
### Question:
HugeSet implements Set<E>, Closeable { @Override public boolean add(E obj) { if (hashSet.size() == THRESHOLD) { File dbFile; try { dbFile = File.createTempFile("mapdb", "temp"); } catch (IOException e) { throw new UncheckedIOException(e); } mapDB = DBMaker.newFileDB(dbFile).deleteFilesAfterClose().transactionDisable().make(); set = mapDB.createHashSet("set").make(); set.addAll(hashSet); hashSet.clear(); } if (set == null) { return hashSet.add(obj); } return set.add(obj); } @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Iterator<E> iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(E obj); @Override boolean remove(Object o); @Override boolean containsAll(Collection<?> c); @Override boolean addAll(Collection<? extends E> c); @Override boolean retainAll(Collection<?> c); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override void close(); }### Answer:
@Test void add() { hugeSet.add("test"); assertEquals(1, hugeSet.size()); }
|
### Question:
HugeSet implements Set<E>, Closeable { @Override public int size() { if (set == null) return hashSet.size(); return set.size(); } @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Iterator<E> iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(E obj); @Override boolean remove(Object o); @Override boolean containsAll(Collection<?> c); @Override boolean addAll(Collection<? extends E> c); @Override boolean retainAll(Collection<?> c); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override void close(); }### Answer:
@Test void addLarge() { fillToThreshold(); assertEquals(THRESHOLD, hugeSet.size()); }
|
### Question:
HugeSet implements Set<E>, Closeable { @Override public void clear() { if (set == null) { hashSet.clear(); } else { set.clear(); } } @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Iterator<E> iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(E obj); @Override boolean remove(Object o); @Override boolean containsAll(Collection<?> c); @Override boolean addAll(Collection<? extends E> c); @Override boolean retainAll(Collection<?> c); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override void close(); }### Answer:
@Test void clear() { List<String> contents = Arrays.asList("test1", "test2", "test3"); hugeSet.addAll(contents); hugeSet.clear(); assertTrue(hugeSet.isEmpty()); }
|
### Question:
HugeSet implements Set<E>, Closeable { @Override public boolean contains(Object o) { if (set == null) return hashSet.contains(o); return set.contains(o); } @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Iterator<E> iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(E obj); @Override boolean remove(Object o); @Override boolean containsAll(Collection<?> c); @Override boolean addAll(Collection<? extends E> c); @Override boolean retainAll(Collection<?> c); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override void close(); }### Answer:
@Test void contains() { List<String> contents = Arrays.asList("test1", "test2", "test3"); hugeSet.addAll(contents); assertTrue(hugeSet.contains("test2")); assertFalse(hugeSet.contains("test4")); }
@Test void containsLarge() { fillToThreshold(); assertTrue(hugeSet.contains("2")); assertFalse(hugeSet.contains("test")); }
|
### Question:
HugeSet implements Set<E>, Closeable { @Override public boolean containsAll(Collection<?> c) { if (set == null) return hashSet.containsAll(c); return set.containsAll(c); } @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Iterator<E> iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(E obj); @Override boolean remove(Object o); @Override boolean containsAll(Collection<?> c); @Override boolean addAll(Collection<? extends E> c); @Override boolean retainAll(Collection<?> c); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override void close(); }### Answer:
@Test void containsAll() { List<String> contents = Arrays.asList("test1", "test2", "test3"); hugeSet.addAll(contents); assertTrue(hugeSet.containsAll(contents)); }
@Test void containsAllLarge() { fillToThreshold(); Set<String> contents = new HashSet<>(); IntStream.range(0, HugeSet.THRESHOLD).mapToObj(Integer::toString).forEach(contents::add); assertTrue(hugeSet.containsAll(contents)); }
|
### Question:
HugeSet implements Set<E>, Closeable { @Override public Iterator<E> iterator() { if (set == null) return hashSet.iterator(); return set.iterator(); } @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Iterator<E> iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(E obj); @Override boolean remove(Object o); @Override boolean containsAll(Collection<?> c); @Override boolean addAll(Collection<? extends E> c); @Override boolean retainAll(Collection<?> c); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override void close(); }### Answer:
@Test void iterator() { List<String> contents = Arrays.asList("test1", "test2", "test3"); hugeSet.addAll(contents); Iterator<String> it = hugeSet.iterator(); assertEquals(contents.size(), size(it)); for (String s : hugeSet) { assertTrue(contents.contains(s)); } }
|
### Question:
HugeSet implements Set<E>, Closeable { @Override public boolean remove(Object o) { if (set == null) return hashSet.remove(o); return set.remove(o); } @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Iterator<E> iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(E obj); @Override boolean remove(Object o); @Override boolean containsAll(Collection<?> c); @Override boolean addAll(Collection<? extends E> c); @Override boolean retainAll(Collection<?> c); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override void close(); }### Answer:
@Test void remove() { List<String> contents = Arrays.asList("test1", "test2", "test3"); hugeSet.addAll(contents); hugeSet.remove("test1"); assertEquals(2, hugeSet.size()); }
|
### Question:
HugeSet implements Set<E>, Closeable { @Override public boolean removeAll(Collection<?> c) { if (set == null) return hashSet.removeAll(c); return set.removeAll(c); } @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Iterator<E> iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(E obj); @Override boolean remove(Object o); @Override boolean containsAll(Collection<?> c); @Override boolean addAll(Collection<? extends E> c); @Override boolean retainAll(Collection<?> c); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override void close(); }### Answer:
@Test void removeAll() { List<String> contents = Arrays.asList("test1", "test2", "test3"); hugeSet.addAll(contents); hugeSet.removeAll(contents); assertEquals(0, hugeSet.size()); }
|
### Question:
HugeSet implements Set<E>, Closeable { @Override public boolean retainAll(Collection<?> c) { if (set == null) return hashSet.retainAll(c); return set.retainAll(c); } @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Iterator<E> iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(E obj); @Override boolean remove(Object o); @Override boolean containsAll(Collection<?> c); @Override boolean addAll(Collection<? extends E> c); @Override boolean retainAll(Collection<?> c); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override void close(); }### Answer:
@Test void retainAll() { List<String> contents = Arrays.asList("test1", "test2", "test3"); hugeSet.addAll(contents); hugeSet.retainAll(Arrays.asList("test2", "test3")); assertEquals(2, hugeSet.size()); }
|
### Question:
HugeSet implements Set<E>, Closeable { @Override public Object[] toArray() { if (set == null) return hashSet.toArray(); return set.toArray(); } @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Iterator<E> iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(E obj); @Override boolean remove(Object o); @Override boolean containsAll(Collection<?> c); @Override boolean addAll(Collection<? extends E> c); @Override boolean retainAll(Collection<?> c); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override void close(); }### Answer:
@Test void toArray() { List<String> contents = Arrays.asList("test1", "test2", "test3"); hugeSet.addAll(contents); assertEquals(3, hugeSet.toArray().length); }
@Test void toArrayLarge() { fillToThreshold(); assertEquals(THRESHOLD, hugeSet.toArray().length); }
|
### Question:
MapCollectors { @SuppressWarnings("java:S1452") public static <T, K, U> Collector<T, ?, Map<K, U>> toLinkedMap( Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper) { return Collectors.toMap(keyMapper, valueMapper, throwingMerger(), LinkedHashMap::new); } private MapCollectors(); @SuppressWarnings("java:S1452") static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper); }### Answer:
@Test void testToLinkedMap() { Map<String, Integer> expectedLinkedMap = new LinkedHashMap<>(); expectedLinkedMap.put("a", 1); expectedLinkedMap.put("bb", 2); expectedLinkedMap.put("ccc", 3); Map<String, Integer> actualLinkedMap = Stream.of("a", "bb", "ccc").collect(MapCollectors.toLinkedMap(identity(), String::length)); assertEquals(actualLinkedMap, expectedLinkedMap); }
@Test void testToLinkedMapDuplicateKey() { Exception exception = assertThrows( IllegalStateException.class, () -> Stream.of("a1", "a2") .collect( MapCollectors.toLinkedMap(str -> str.charAt(0), str -> str.charAt(1)))); assertEquals("Duplicate key detected with values '1' and '2'", exception.getMessage()); }
|
### Question:
ZipFileUtil { public static void unzip(InputStream is, File outputDir) { try { ZipUtil.unpack(is, outputDir); } catch (Exception ex) { throw new UnzipException(ex); } } private ZipFileUtil(); static void unzip(InputStream is, File outputDir); static List<File> unzipSkipHidden(File file); }### Answer:
@Test void testUnzipInvalid() { InputStream is = ZipFileUtil.class.getResourceAsStream("flip.zip"); assertThrows(UnzipException.class, () -> ZipFileUtil.unzip(is, tempDir)); }
@Test void testUnzip() { InputStream is = ZipFileUtil.class.getResourceAsStream("emx-csv.zip"); ZipFileUtil.unzip(is, tempDir); Path tempDirPath = tempDir.toPath(); Map<Path, String> checksums = ImmutableMap.of( tempDirPath.resolve("attributes.csv"), "4cc30a6b867ce0689f19bdaadcd30dd9", tempDirPath.resolve("entities.csv"), "8a306d69b8654f54f1e9175ce68b5a6f", tempDirPath.resolve("it_csv_hospital.csv"), "87824a0ec5312a81e4f9fd8ad51b666b", tempDirPath.resolve("it_csv_patients.csv"), "497e36e9b850a5a66f292378c68bce15", tempDirPath.resolve("packages.csv"), "11e879ddd1ebe6376be309acb910d232"); checksums.forEach( (key, value) -> assertEquals(md5Hash(key), value, key + " should have md5 sum " + value)); }
|
### Question:
ZipFileUtil { public static List<File> unzipSkipHidden(File file) { return unzip(file, name -> name.startsWith(".") || name.startsWith("_") ? null : name); } private ZipFileUtil(); static void unzip(InputStream is, File outputDir); static List<File> unzipSkipHidden(File file); }### Answer:
@Test void testUnzipSkipHidden() throws IOException { InputStream is = ZipFileUtil.class.getResourceAsStream("test.zip"); Path tempDirPath = tempDir.toPath(); Path targetPath = tempDirPath.resolve("test.zip"); java.nio.file.Files.copy(is, targetPath); List<File> files = ZipFileUtil.unzipSkipHidden(targetPath.toFile()); Path visiblePath = tempDirPath.resolve(Paths.get("subdir", "visible.txt")); assertEquals(singletonList(visiblePath.toFile()), files); assertEquals("aff776838092862d398b58e380901753", md5Hash(visiblePath)); }
@Test void testUnzipSkipHiddenInvalid() throws IOException { InputStream is = ZipFileUtil.class.getResourceAsStream("flip.zip"); Path tempDirPath = tempDir.toPath(); Path targetPath = tempDirPath.resolve("flip.zip"); java.nio.file.Files.copy(is, targetPath); assertThrows(UnzipException.class, () -> ZipFileUtil.unzipSkipHidden(targetPath.toFile())); }
|
### Question:
JavaMailSenderFactory implements MailSenderFactory { @Override public void validateConnection(MailSettings mailSettings) { LOG.info("Validating mail settings..."); try { JavaMailSenderImpl sender = createMailSender(mailSettings); sender.testConnection(); LOG.info("OK."); } catch (MessagingException ex) { String message = format("Unable to ping to %s", mailSettings.getHost()); LOG.info(message, ex); throw new IllegalStateException(message, ex); } } @Override JavaMailSenderImpl createMailSender(MailSettings mailSettings); @Override void validateConnection(MailSettings mailSettings); static final String MAIL_SMTP_STARTTLS_ENABLE; static final String MAIL_SMTP_QUITWAIT; static final String MAIL_SMTP_AUTH; static final String MAIL_SMTP_FROM_ADDRESS; }### Answer:
@Test void testValidateConnectionInvalidConnection() { Exception exception = assertThrows( IllegalStateException.class, () -> javaMailSenderFactory.validateConnection(mailSettings)); assertEquals("Unable to ping to host", exception.getMessage()); }
|
### Question:
HugeMap implements Map<K, V>, Closeable { @Override public void clear() { if (map == null) { hashMap.clear(); } else { map.clear(); } } @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override V remove(Object key); @Override void putAll(Map<? extends K, ? extends V> m); @Override void clear(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<java.util.Map.Entry<K, V>> entrySet(); @Override void close(); }### Answer:
@Test void clear() { hugeMap.put("key", "value"); hugeMap.clear(); assertTrue(hugeMap.isEmpty()); }
|
### Question:
HugeMap implements Map<K, V>, Closeable { @Override public boolean containsKey(Object key) { if (map == null) return hashMap.containsKey(key); return map.containsKey(key); } @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override V remove(Object key); @Override void putAll(Map<? extends K, ? extends V> m); @Override void clear(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<java.util.Map.Entry<K, V>> entrySet(); @Override void close(); }### Answer:
@Test void containsKey() { hugeMap.put("key", "value"); assertTrue(hugeMap.containsKey("key")); assertFalse(hugeMap.containsKey("value")); }
@Test void containsKeyLarge() { fillToThreshold(); assertTrue(hugeMap.containsKey("3")); assertFalse(hugeMap.containsKey("value")); }
|
### Question:
HugeMap implements Map<K, V>, Closeable { @Override public boolean containsValue(Object value) { if (map == null) return hashMap.containsValue(value); return map.containsValue(value); } @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override V remove(Object key); @Override void putAll(Map<? extends K, ? extends V> m); @Override void clear(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<java.util.Map.Entry<K, V>> entrySet(); @Override void close(); }### Answer:
@Test void containsValue() { hugeMap.put("key", "value"); assertTrue(hugeMap.containsValue("value")); assertFalse(hugeMap.containsValue("key")); }
@Test void containsValueLarge() { fillToThreshold(); assertTrue(hugeMap.containsValue("3")); assertFalse(hugeMap.containsValue("key")); }
|
### Question:
HugeMap implements Map<K, V>, Closeable { @Override public Set<java.util.Map.Entry<K, V>> entrySet() { if (map == null) return hashMap.entrySet(); return map.entrySet(); } @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override V remove(Object key); @Override void putAll(Map<? extends K, ? extends V> m); @Override void clear(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<java.util.Map.Entry<K, V>> entrySet(); @Override void close(); }### Answer:
@Test void entrySet() { hugeMap.put("key", "value"); assertEquals(1, hugeMap.entrySet().size()); }
|
### Question:
HugeMap implements Map<K, V>, Closeable { @Override public V get(Object key) { if (map == null) return hashMap.get(key); return map.get(key); } @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override V remove(Object key); @Override void putAll(Map<? extends K, ? extends V> m); @Override void clear(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<java.util.Map.Entry<K, V>> entrySet(); @Override void close(); }### Answer:
@Test void get() { hugeMap.put("key", "value"); assertEquals("value", hugeMap.get("key")); assertNull(hugeMap.get("value")); }
@Test void getLarge() { fillToThreshold(); assertEquals("2", hugeMap.get("2")); assertNull(hugeMap.get("value")); }
|
### Question:
HugeMap implements Map<K, V>, Closeable { @Override public boolean isEmpty() { if (map == null) return hashMap.isEmpty(); return map.isEmpty(); } @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override V remove(Object key); @Override void putAll(Map<? extends K, ? extends V> m); @Override void clear(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<java.util.Map.Entry<K, V>> entrySet(); @Override void close(); }### Answer:
@Test void isEmpty() { assertTrue(hugeMap.isEmpty()); hugeMap.put("key", "value"); assertFalse(hugeMap.isEmpty()); }
@Test void isEmptyLarge() { assertTrue(hugeMap.isEmpty()); fillToThreshold(); assertFalse(hugeMap.isEmpty()); }
|
### Question:
HugeMap implements Map<K, V>, Closeable { @Override public Set<K> keySet() { if (map == null) return hashMap.keySet(); return map.keySet(); } @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override V remove(Object key); @Override void putAll(Map<? extends K, ? extends V> m); @Override void clear(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<java.util.Map.Entry<K, V>> entrySet(); @Override void close(); }### Answer:
@Test void keySet() { hugeMap.put("key", "value"); assertEquals(newHashSet("key"), hugeMap.keySet()); }
|
### Question:
HugeMap implements Map<K, V>, Closeable { @Override public void putAll(Map<? extends K, ? extends V> m) { m.forEach(this::put); } @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override V remove(Object key); @Override void putAll(Map<? extends K, ? extends V> m); @Override void clear(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<java.util.Map.Entry<K, V>> entrySet(); @Override void close(); }### Answer:
@Test void putAll() { hugeMap.putAll(Collections.singletonMap("key", "value")); assertEquals(1, hugeMap.size()); }
|
### Question:
HugeMap implements Map<K, V>, Closeable { @Override public V remove(Object key) { if (map == null) return hashMap.remove(key); return map.remove(key); } @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override V remove(Object key); @Override void putAll(Map<? extends K, ? extends V> m); @Override void clear(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<java.util.Map.Entry<K, V>> entrySet(); @Override void close(); }### Answer:
@Test void remove() { fillToThreshold(); assertEquals("5", hugeMap.remove("5")); assertEquals(THRESHOLD - 1, hugeMap.size()); }
|
### Question:
HugeMap implements Map<K, V>, Closeable { @Override public Collection<V> values() { if (map == null) return hashMap.values(); return map.values(); } @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override V remove(Object key); @Override void putAll(Map<? extends K, ? extends V> m); @Override void clear(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<java.util.Map.Entry<K, V>> entrySet(); @Override void close(); }### Answer:
@Test void values() { hugeMap.put("key", "value"); assertEquals(1, hugeMap.values().size()); }
|
### Question:
ResourceUtils { public static String getString(String resourceName) throws IOException { URL resourceUrl = Resources.getResource(resourceName); return getString(resourceUrl, UTF_8); } private ResourceUtils(); static File getFile(String resourceName); static File getFile(Class<?> contextClass, String resourceName); static String getString(String resourceName); static String getString(Class<?> contextClass, String resourceName); static String getString(Class<?> contextClass, String resourceName, Charset charset); static byte[] getBytes(String resourceName); static byte[] getBytes(Class<?> contextClass, String resourceName); }### Answer:
@Test void getStringClassString() throws IOException { assertEquals("example resource", getString(getClass(), "/resource.txt")); }
@Test void getStringClassStringCharset() throws IOException { assertEquals("example resource", getString(getClass(), "/resource.txt", UTF_8)); }
@Test void getMySqlQueryFromFileTest() throws IOException { String query = ResourceUtils.getString(getClass(), "/test_mysql_repo_util_query.sql"); assertEquals("SELECT * FROM `test` WHERE `test`='test';", query); }
|
### Question:
ResourceUtils { public static byte[] getBytes(String resourceName) throws IOException { URL resourceUrl = Resources.getResource(resourceName); return getBytes(resourceUrl); } private ResourceUtils(); static File getFile(String resourceName); static File getFile(Class<?> contextClass, String resourceName); static String getString(String resourceName); static String getString(Class<?> contextClass, String resourceName); static String getString(Class<?> contextClass, String resourceName, Charset charset); static byte[] getBytes(String resourceName); static byte[] getBytes(Class<?> contextClass, String resourceName); }### Answer:
@Test void getBytes() throws IOException { assertEquals(16, ResourceUtils.getBytes(getClass(), "/resource.txt").length); }
|
### Question:
ExecutorServiceUtils { public static void shutdownAndAwaitTermination(ExecutorService executorService) { shutdownAndAwaitTermination(executorService, 10, 5); } private ExecutorServiceUtils(); static void shutdownAndAwaitTermination(ExecutorService executorService); static void shutdownAndAwaitTermination(
ExecutorService executorService, long shutdownTimeout, long shutdownNowTimeout); }### Answer:
@Test void testShutdownAndAwaitTermination() { ExecutorService executorService = Executors.newSingleThreadExecutor(); assertDoesNotThrow(() -> ExecutorServiceUtils.shutdownAndAwaitTermination(executorService)); }
|
### Question:
CircularRoleHierarchyException extends BadRequestException { @Override public String getMessage() { return format("id:%s,name:%s", id, name); } CircularRoleHierarchyException(Role role); @Override String getMessage(); }### Answer:
@Test void testGetMessage() { Role role = mock(Role.class); when(role.getId()).thenReturn("test"); when(role.getName()).thenReturn("test_VIEWER"); CircularRoleHierarchyException ex = new CircularRoleHierarchyException(role); assertEquals("id:test,name:test_VIEWER", ex.getMessage()); }
|
### Question:
SuperUserPermissionsException extends CodedRuntimeException { @Override public String getMessage() { return String.format("name:%s", name); } SuperUserPermissionsException(String name); @Override String getMessage(); }### Answer:
@Test void testGetMessage() { CodedRuntimeException ex = new SuperUserPermissionsException("admin"); assertEquals("name:admin", ex.getMessage()); }
|
### Question:
PermissionNotSuitableException extends BadRequestException { @Override public String getMessage() { return String.format("permission:%s, typeId:%s", permission, typeId); } PermissionNotSuitableException(String permission, String typeId); @Override String getMessage(); }### Answer:
@Test void testGetMessage() { CodedRuntimeException ex = new PermissionNotSuitableException("permission", "type"); assertEquals("permission:permission, typeId:type", ex.getMessage()); }
|
### Question:
UnknownAceException extends UnknownDataException { @Override public String getMessage() { return String.format( "typeId:%s, identifier:%s, sid:%s, operation:%s", objectIdentity.getType(), objectIdentity.getIdentifier(), sid, operation); } UnknownAceException(ObjectIdentity objectIdentity, Sid sid, String operation); @Override String getMessage(); }### Answer:
@Test void testGetMessage() { UnknownDataException ex = new UnknownAceException(objectIdentity, new GrantedAuthoritySid("ROLE_role1"), "delete"); assertEquals( "typeId:type, identifier:id, sid:GrantedAuthoritySid[ROLE_role1], operation:delete", ex.getMessage()); }
|
### Question:
InvalidTypeIdException extends BadRequestException { @Override public String getMessage() { return String.format("typeId:%s", typeId); } InvalidTypeIdException(String typeId); @Override String getMessage(); }### Answer:
@Test void testGetMessage() { CodedRuntimeException ex = new InvalidTypeIdException("type"); assertEquals("typeId:type", ex.getMessage()); }
|
### Question:
SidPermissionException extends PermissionDeniedException { @Override public String getMessage() { return String.format("sids:%s", sids); } SidPermissionException(String sids); @Override String getMessage(); }### Answer:
@Test void testGetMessage() { CodedRuntimeException ex = new SidPermissionException("user1,user2,roleA,roleB"); assertEquals("sids:user1,user2,roleA,roleB", ex.getMessage()); }
|
### Question:
AclClassAlreadyExistsException extends DataAlreadyExistsException { @Override public String getMessage() { return String.format("typeId:%s", typeId); } AclClassAlreadyExistsException(String typeId); @Override String getMessage(); }### Answer:
@Test void testGetMessage() { CodedRuntimeException ex = new AclNotFoundException("type"); assertEquals("typeId:type", ex.getMessage()); }
|
### Question:
UnknownTypeException extends UnknownDataException { @Override public String getMessage() { return String.format("typeId:%s", type); } UnknownTypeException(String type); @Override String getMessage(); }### Answer:
@Test void testGetMessage() { UnknownDataException ex = new UnknownTypeException("type"); assertEquals("typeId:type", ex.getMessage()); }
|
### Question:
ReadPermissionDeniedException extends PermissionDeniedException { @Override public String getMessage() { return String.format("typeId:%s", typeId); } ReadPermissionDeniedException(String typeId); @Override String getMessage(); }### Answer:
@Test void testGetMessage() { CodedRuntimeException ex = new ReadPermissionDeniedException("type"); assertEquals("typeId:type", ex.getMessage()); }
|
### Question:
DuplicatePermissionException extends DataAlreadyExistsException { @Override public String getMessage() { return String.format( "typeId:%s, identifier:%s, sid:%s", objectIdentity.getType(), objectIdentity.getIdentifier(), sid); } DuplicatePermissionException(ObjectIdentity objectIdentity, Sid sid); @Override String getMessage(); }### Answer:
@Test void testGetMessage() { DataAlreadyExistsException ex = new DuplicatePermissionException(objectIdentity, new GrantedAuthoritySid("ROLE_role1")); assertEquals( "typeId:type, identifier:id, sid:GrantedAuthoritySid[ROLE_role1]", ex.getMessage()); }
|
### Question:
GroupPackageDowngradeException extends CodedRuntimeException { @Override public String getMessage() { return format("id:%s", aPackage.getId()); } GroupPackageDowngradeException(Package aPackage); @Override String getMessage(); }### Answer:
@Test void testGetMessage() { Package aPackage = mock(Package.class); when(aPackage.getId()).thenReturn("test"); GroupPackageDowngradeException ex = new GroupPackageDowngradeException(aPackage); assertEquals("id:test", ex.getMessage()); }
|
### Question:
SystemRlsModificationException extends ForbiddenException { @Override public String getMessage() { return String.format("entityType:%s", entityType); } SystemRlsModificationException(String entityType); @Override String getMessage(); }### Answer:
@Test void testGetMessage() { CodedRuntimeException ex = new SystemRlsModificationException("type"); assertEquals("entityType:type", ex.getMessage()); }
|
### Question:
AclAlreadyExistsException extends DataAlreadyExistsException { @Override public String getMessage() { return String.format("typeId:%s, id:%s", typeId, id); } AclAlreadyExistsException(String typeId, String id); @Override String getMessage(); }### Answer:
@Test void testGetMessage() { DataAlreadyExistsException ex = new AclAlreadyExistsException("type", "identifier"); assertEquals("typeId:type, id:identifier", ex.getMessage()); }
|
### Question:
AclNotFoundException extends CodedRuntimeException { @Override public String getMessage() { return String.format("typeId:%s", typeId); } AclNotFoundException(String typeId); @Override String getMessage(); }### Answer:
@Test void testGetMessage() { CodedRuntimeException ex = new AclNotFoundException("type"); assertEquals("typeId:type", ex.getMessage()); }
|
### Question:
AttributeRepositorySecurityDecorator extends AbstractRepositoryDecorator<Attribute> { @Override public AggregateResult aggregate(AggregateQuery aggregateQuery) { if (currentUserIsSuOrSystem()) { return delegate().aggregate(aggregateQuery); } else { throw new MolgenisDataAccessException( format("Aggregation on entity [%s] not allowed", getName())); } } AttributeRepositorySecurityDecorator(
Repository<Attribute> delegateRepository,
SystemEntityTypeRegistry systemEntityTypeRegistry,
UserPermissionEvaluator permissionService); @Override long count(); @Override long count(Query<Attribute> q); @Override Stream<Attribute> findAll(Query<Attribute> q); @Override Iterator<Attribute> iterator(); @Override void forEachBatched(Fetch fetch, Consumer<List<Attribute>> consumer, int batchSize); @Override Attribute findOne(Query<Attribute> q); @Override Attribute findOneById(Object id); @Override Attribute findOneById(Object id, Fetch fetch); @Override Stream<Attribute> findAll(Stream<Object> ids); @Override Stream<Attribute> findAll(Stream<Object> ids, Fetch fetch); @Override AggregateResult aggregate(AggregateQuery aggregateQuery); @Override void update(Attribute attr); @Override void update(Stream<Attribute> attrs); @Override void delete(Attribute attr); @Override void delete(Stream<Attribute> attrs); @Override void deleteById(Object id); @Override void deleteAll(Stream<Object> ids); @Override void deleteAll(); @Override void add(Attribute attr); @Override Integer add(Stream<Attribute> attrs); }### Answer:
@SuppressWarnings("deprecation") @WithMockUser(username = USERNAME) @Test void aggregateUser() { AggregateQuery aggregateQuery = mock(AggregateQuery.class); assertThrows(MolgenisDataAccessException.class, () -> repo.aggregate(aggregateQuery)); }
|
### Question:
AttributeRepositorySecurityDecorator extends AbstractRepositoryDecorator<Attribute> { @Override public void update(Attribute attr) { validateUpdateAllowed(attr); delegate().update(attr); } AttributeRepositorySecurityDecorator(
Repository<Attribute> delegateRepository,
SystemEntityTypeRegistry systemEntityTypeRegistry,
UserPermissionEvaluator permissionService); @Override long count(); @Override long count(Query<Attribute> q); @Override Stream<Attribute> findAll(Query<Attribute> q); @Override Iterator<Attribute> iterator(); @Override void forEachBatched(Fetch fetch, Consumer<List<Attribute>> consumer, int batchSize); @Override Attribute findOne(Query<Attribute> q); @Override Attribute findOneById(Object id); @Override Attribute findOneById(Object id, Fetch fetch); @Override Stream<Attribute> findAll(Stream<Object> ids); @Override Stream<Attribute> findAll(Stream<Object> ids, Fetch fetch); @Override AggregateResult aggregate(AggregateQuery aggregateQuery); @Override void update(Attribute attr); @Override void update(Stream<Attribute> attrs); @Override void delete(Attribute attr); @Override void delete(Stream<Attribute> attrs); @Override void deleteById(Object id); @Override void deleteAll(Stream<Object> ids); @Override void deleteAll(); @Override void add(Attribute attr); @Override Integer add(Stream<Attribute> attrs); }### Answer:
@WithMockUser( username = USERNAME, roles = {ROLE_SU}) @Test void updateSystemEntity() { Attribute currentAttribute = mock(Attribute.class); when(systemEntityTypeRegistry.getSystemAttribute(attributeId)).thenReturn(currentAttribute); assertThrows(SystemMetadataModificationException.class, () -> repo.update(attribute)); }
|
### Question:
EntityTypeRepositorySecurityDecorator extends AbstractRowLevelSecurityRepositoryDecorator<EntityType> { @Override public void deleteAcl(EntityType entityType) { mutableAclService.deleteAcl(new EntityTypeIdentity(entityType), true); mutableAclClassService.deleteAclClass(EntityIdentityUtils.toType(entityType)); } EntityTypeRepositorySecurityDecorator(
Repository<EntityType> delegateRepository,
SystemEntityTypeRegistry systemEntityTypeRegistry,
UserPermissionEvaluator userPermissionEvaluator,
MutableAclService mutableAclService,
MutableAclClassService mutableAclClassService,
DataService dataService); @Override boolean isActionPermitted(EntityType entityType, Action action); @Override boolean isActionPermitted(Object id, Action action); @Override void createAcl(EntityType entityType); @Override void deleteAcl(EntityType entityType); @Override void deleteAcl(Object entityTypeId); @Override void updateAcl(EntityType entityType); @Override void throwPermissionException(EntityType entityType, Action action); }### Answer:
@WithMockUser(username = USERNAME) @Test void delete() { String entityTypeId = "entityTypeId"; when(userPermissionEvaluator.hasPermission( new EntityTypeIdentity(entityTypeId), EntityTypePermission.DELETE_METADATA)) .thenReturn(true); EntityType entityType = mock(EntityType.class); when(entityType.getId()).thenReturn("entityTypeId").getMock(); repo.delete(entityType); verify(mutableAclService).deleteAcl(new EntityTypeIdentity(entityTypeId), true); verify(mutableAclClassService).deleteAclClass("entity-" + entityTypeId); verify(delegateRepository).delete(entityType); }
|
### Question:
MolgenisRSQLVisitor extends NoArgRSQLVisitorAdapter<Query<Entity>> { @Override public Query<Entity> visit(AndNode node) { initQuery(); boolean nested = node.getChildren().size() > 1; if (nested) { q.nest(); } for (Iterator<Node> it = node.iterator(); it.hasNext(); ) { Node child = it.next(); child.accept(this); if (it.hasNext()) { q.and(); } } if (nested) { q.unnest(); } return q; } MolgenisRSQLVisitor(Repository<Entity> repository); MolgenisRSQLVisitor(Repository<Entity> repository, RSQLValueParser rsqlValueParser); @Override Query<Entity> visit(AndNode node); @Override Query<Entity> visit(OrNode node); @Override Query<Entity> visit(ComparisonNode node); }### Answer:
@Test void testVisitComparisonNodeFieldSearchQuery() { ComparisonOperator searchQuery = new ComparisonOperator("=sq="); ComparisonNode node = new ComparisonNode(searchQuery, "version", List.of("8.3.*")); Query actual = visitor.visit(node); Query expected = new QueryImpl().searchQuery("version", "8.3.*"); assertEquals(expected, actual); }
@Test void testVisitComparisonNodeAllFieldsSearchQuery() { ComparisonOperator searchQuery = new ComparisonOperator("=sq="); ComparisonNode node = new ComparisonNode(searchQuery, "*", List.of("8.3.*")); Query actual = visitor.visit(node); Query expected = new QueryImpl().searchQuery("8.3.*"); assertEquals(expected, actual); }
|
### Question:
PackageRepositorySecurityDecorator extends AbstractRowLevelSecurityRepositoryDecorator<Package> { @Override public void deleteAcl(Object id) { PackageIdentity packageIdentity = new PackageIdentity(id.toString()); mutableAclService.deleteAcl(packageIdentity, true); } PackageRepositorySecurityDecorator(
Repository<Package> delegateRepository,
MutableAclService mutableAclService,
UserPermissionEvaluator userPermissionEvaluator); @Override boolean isActionPermitted(Package updatedPack, Action action); @Override boolean isActionPermitted(Object id, Action action); @Override void throwPermissionException(Package pack, Action action); @Override Package findOneById(Object id); @Override void add(Package pack); @Override void update(Package pack); @Override Integer add(Stream<Package> packages); @Override void createAcl(Package pack); @Override void deleteAcl(Object id); @Override void deleteAcl(Package pack); @Override void updateAcl(Package pack); }### Answer:
@Test void testDelete() { Package package1 = mock(Package.class); Package package2 = mock(Package.class); when(package1.getId()).thenReturn("1"); when(package2.getId()).thenReturn("2"); when(package1.getParent()).thenReturn(package2); doReturn(true).when(userPermissionEvaluator).hasPermission(new PackageIdentity("2"), UPDATE); repo.delete(package1); verify(mutableAclService).deleteAcl(new PackageIdentity("1"), true); verify(delegateRepository).delete(package1); }
|
### Question:
UserServiceImpl implements UserService { @Override @RunAsSystem public @Nullable @CheckForNull User getUser(String username) { return dataService.findOne( USER, new QueryImpl<User>().eq(UserMetadata.USERNAME, username), User.class); } UserServiceImpl(DataService dataService); @Override @RunAsSystem List<User> getUsers(); @Override @RunAsSystem List<String> getSuEmailAddresses(); @Override @RunAsSystem @Nullable @CheckForNull User getUser(String username); @Override @RunAsSystem void update(User user); @Override @RunAsSystem User getUserByEmail(String email); }### Answer:
@Test void getUser() { String username = "username"; User existingUser = mock(User.class); when(dataService.findOne( USER, new QueryImpl<User>().eq(UserMetadata.USERNAME, username), User.class)) .thenReturn(existingUser); assertEquals(existingUser, molgenisUserServiceImpl.getUser(username)); }
|
### Question:
UserServiceImpl implements UserService { @Override @RunAsSystem public List<User> getUsers() { return dataService.findAll(USER, User.class).collect(toList()); } UserServiceImpl(DataService dataService); @Override @RunAsSystem List<User> getUsers(); @Override @RunAsSystem List<String> getSuEmailAddresses(); @Override @RunAsSystem @Nullable @CheckForNull User getUser(String username); @Override @RunAsSystem void update(User user); @Override @RunAsSystem User getUserByEmail(String email); }### Answer:
@Test void getUsers() { User existingUser = mock(User.class); when(dataService.findAll(USER, User.class)).thenReturn(Stream.of(existingUser)); assertEquals(singletonList(existingUser), molgenisUserServiceImpl.getUsers()); }
|
### Question:
SystemEntityTypeRegistryImpl implements SystemEntityTypeRegistry { SystemEntityTypeRegistryImpl(UserPermissionEvaluator permissionService) { this.permissionService = requireNonNull(permissionService); systemEntityTypeMap = Maps.newHashMap(); } SystemEntityTypeRegistryImpl(UserPermissionEvaluator permissionService); @Override SystemEntityType getSystemEntityType(String entityTypeId); @Override Stream<SystemEntityType> getSystemEntityTypes(); @Override boolean hasSystemEntityType(String entityTypeId); @Override void addSystemEntityType(SystemEntityType systemEntityType); @Override boolean hasSystemAttribute(String attrIdentifier); @Override Attribute getSystemAttribute(String attrIdentifier); }### Answer:
@Test void testSystemEntityTypeRegistryImpl() { assertThrows(NullPointerException.class, () -> new SystemEntityTypeRegistryImpl(null)); }
|
### Question:
SystemEntityTypeRegistryImpl implements SystemEntityTypeRegistry { @Override public SystemEntityType getSystemEntityType(String entityTypeId) { SystemEntityType systemEntityType = systemEntityTypeMap.get(entityTypeId); if (systemEntityType != null) { validateReadPermission(systemEntityType); } return systemEntityType; } SystemEntityTypeRegistryImpl(UserPermissionEvaluator permissionService); @Override SystemEntityType getSystemEntityType(String entityTypeId); @Override Stream<SystemEntityType> getSystemEntityTypes(); @Override boolean hasSystemEntityType(String entityTypeId); @Override void addSystemEntityType(SystemEntityType systemEntityType); @Override boolean hasSystemAttribute(String attrIdentifier); @Override Attribute getSystemAttribute(String attrIdentifier); }### Answer:
@Test void testGetSystemEntityTypeNotExists() { assertNull(systemEntityTypeRegistry.getSystemEntityType("unknownEntityTypeId")); }
|
### Question:
SystemEntityTypeRegistryImpl implements SystemEntityTypeRegistry { @Override public boolean hasSystemEntityType(String entityTypeId) { return systemEntityTypeMap.containsKey(entityTypeId); } SystemEntityTypeRegistryImpl(UserPermissionEvaluator permissionService); @Override SystemEntityType getSystemEntityType(String entityTypeId); @Override Stream<SystemEntityType> getSystemEntityTypes(); @Override boolean hasSystemEntityType(String entityTypeId); @Override void addSystemEntityType(SystemEntityType systemEntityType); @Override boolean hasSystemAttribute(String attrIdentifier); @Override Attribute getSystemAttribute(String attrIdentifier); }### Answer:
@Test void testHasSystemEntityTypeNotExists() { String entityTypeId = "unknownEntityType"; assertFalse(systemEntityTypeRegistry.hasSystemEntityType(entityTypeId)); }
|
### Question:
RowLevelSecurityRepositoryDecorator extends AbstractRowLevelSecurityRepositoryDecorator<Entity> { RowLevelSecurityRepositoryDecorator( Repository<Entity> delegateRepository, UserPermissionEvaluator userPermissionEvaluator, MutableAclService mutableAclService) { super(delegateRepository, mutableAclService); this.userPermissionEvaluator = requireNonNull(userPermissionEvaluator); this.mutableAclService = requireNonNull(mutableAclService); } RowLevelSecurityRepositoryDecorator(
Repository<Entity> delegateRepository,
UserPermissionEvaluator userPermissionEvaluator,
MutableAclService mutableAclService); @Override boolean isActionPermitted(Entity entity, Action operation); @Override boolean isActionPermitted(Object id, Action operation); @Override void throwPermissionException(Entity entity, Action action); @Override void createAcl(Entity entity); @Override void deleteAcl(Entity entity); @Override void deleteAcl(Object id); @Override void updateAcl(Entity entity); }### Answer:
@Test void testRowLevelSecurityRepositoryDecorator() { assertThrows( NullPointerException.class, () -> new RowLevelSecurityRepositoryDecorator(null, null, null)); }
|
### Question:
RowLevelSecurityRepositoryDecoratorFactory { RowLevelSecurityRepositoryDecoratorFactory( UserPermissionEvaluator userPermissionEvaluator, MutableAclService mutableAclService, MutableAclClassService mutableAclClassService) { this.userPermissionEvaluator = requireNonNull(userPermissionEvaluator); this.mutableAclService = requireNonNull(mutableAclService); this.mutableAclClassService = requireNonNull(mutableAclClassService); } RowLevelSecurityRepositoryDecoratorFactory(
UserPermissionEvaluator userPermissionEvaluator,
MutableAclService mutableAclService,
MutableAclClassService mutableAclClassService); Repository<Entity> createDecoratedRepository(Repository<Entity> repository); }### Answer:
@Test void testRowLevelSecurityRepositoryDecoratorFactory() { assertThrows( NullPointerException.class, () -> new RowLevelSecurityRepositoryDecoratorFactory(null, null, null)); }
|
### Question:
RowLevelSecurityRepositoryDecoratorFactory { public Repository<Entity> createDecoratedRepository(Repository<Entity> repository) { Repository<Entity> decoratedRepository; if (isRowLevelSecured(repository)) { decoratedRepository = new RowLevelSecurityRepositoryDecorator( repository, userPermissionEvaluator, mutableAclService); } else { decoratedRepository = repository; } return decoratedRepository; } RowLevelSecurityRepositoryDecoratorFactory(
UserPermissionEvaluator userPermissionEvaluator,
MutableAclService mutableAclService,
MutableAclClassService mutableAclClassService); Repository<Entity> createDecoratedRepository(Repository<Entity> repository); }### Answer:
@Test void testCreateDecoratedRepositoryRowLevelSecurityEnabled() { Repository<Entity> repository = getRepositoryMock(); when(mutableAclClassService.hasAclClass("entity-entityTypeId")).thenReturn(true); assertTrue( rowLevelSecurityRepositoryDecoratorFactory.createDecoratedRepository(repository) instanceof RowLevelSecurityRepositoryDecorator); }
@Test void testCreateDecoratedRepositoryRowLevelSecurityDisabled() { Repository<Entity> repository = getRepositoryMock(); assertEquals( repository, rowLevelSecurityRepositoryDecoratorFactory.createDecoratedRepository(repository)); }
|
### Question:
AggregateAnonymizerRepositoryDecorator extends AbstractRepositoryDecorator<E> { @Override public AggregateResult aggregate(AggregateQuery aggregateQuery) { AggregateResult result = delegate().aggregate(aggregateQuery); Integer threshold = appSettings.getAggregateThreshold(); if (threshold != null && threshold > 0) { result = aggregateAnonymizer.anonymize(result, threshold); } return result; } AggregateAnonymizerRepositoryDecorator(
Repository<E> delegateRepository,
AggregateAnonymizer aggregateAnonymizer,
AppSettings appSettings); @Override AggregateResult aggregate(AggregateQuery aggregateQuery); }### Answer:
@Test void aggregateNoThreshold() throws Exception { when(appSettings.getAggregateThreshold()).thenReturn(null); AggregateQuery aggregateQuery = mock(AggregateQuery.class); AggregateResult aggregateResult = mock(AggregateResult.class); when(delegateRepository.aggregate(aggregateQuery)).thenReturn(aggregateResult); assertEquals(aggregateAnonymizerRepoDecorator.aggregate(aggregateQuery), aggregateResult); verifyZeroInteractions(aggregateAnonymizer); verifyZeroInteractions(aggregateResult); }
@Test void aggregateThreshold() throws Exception { int threshold = 10; when(appSettings.getAggregateThreshold()).thenReturn(threshold); AggregateQuery aggregateQuery = mock(AggregateQuery.class); AggregateResult aggregateResult = mock(AggregateResult.class); when(delegateRepository.aggregate(aggregateQuery)).thenReturn(aggregateResult); AnonymizedAggregateResult anonymizedAggregateResult = mock(AnonymizedAggregateResult.class); when(aggregateAnonymizer.anonymize(aggregateResult, threshold)) .thenReturn(anonymizedAggregateResult); assertEquals( aggregateAnonymizerRepoDecorator.aggregate(aggregateQuery), anonymizedAggregateResult); }
|
### Question:
RepositorySecurityDecorator extends AbstractRepositoryDecorator<Entity> { public RepositorySecurityDecorator( Repository<Entity> delegateRepository, UserPermissionEvaluator permissionService) { super(delegateRepository); this.permissionService = requireNonNull(permissionService); } RepositorySecurityDecorator(
Repository<Entity> delegateRepository, UserPermissionEvaluator permissionService); @Override Iterator<Entity> iterator(); @Override void forEachBatched(Fetch fetch, Consumer<List<Entity>> consumer, int batchSize); @Override void close(); @Override long count(Query<Entity> q); @Override Stream<Entity> findAll(Query<Entity> q); @Override Entity findOne(Query<Entity> q); @Override Entity findOneById(Object id); @Override Entity findOneById(Object id, Fetch fetch); @Override Stream<Entity> findAll(Stream<Object> ids); @Override Stream<Entity> findAll(Stream<Object> ids, Fetch fetch); @Override long count(); @Override void update(Entity entity); @Override void update(Stream<Entity> entities); @Override void delete(Entity entity); @Override void delete(Stream<Entity> entities); @Override void deleteById(Object id); @Override void deleteAll(Stream<Object> ids); @Override void deleteAll(); @Override void add(Entity entity); @Override Integer add(Stream<Entity> entities); @Override AggregateResult aggregate(AggregateQuery aggregateQuery); }### Answer:
@Test void testRepositorySecurityDecorator() { assertThrows(NullPointerException.class, () -> new RepositorySecurityDecorator(null, null)); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.