method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
OidcClientRepositoryDecorator extends AbstractRepositoryDecorator<OidcClient> { @Override public void delete(OidcClient entity) { super.delete(entity); oAuth2AuthorizedClientService.reset(); } OidcClientRepositoryDecorator(
Repository<OidcClient> delegateRepository,
ResettableOAuth2AuthorizedClientService oAuth2AuthorizedClientService); @Override void update(OidcClient entity); @Override void update(Stream<OidcClient> entities); @Override void delete(OidcClient entity); @Override void deleteById(Object id); @Override void deleteAll(); @Override void delete(Stream<OidcClient> entities); @Override void deleteAll(Stream<Object> ids); }### Answer:
@Test void testDelete() { OidcClient oidcClient = mock(OidcClient.class); oidcClientRepositoryDecorator.delete(oidcClient); verify(delegateRepository).delete(oidcClient); verify(oAuth2AuthorizedClientService).reset(); }
@Test void testDeleteStream() { @SuppressWarnings("unchecked") Stream<OidcClient> oidcClientStream = mock(Stream.class); oidcClientRepositoryDecorator.delete(oidcClientStream); verify(delegateRepository).delete(oidcClientStream); verify(oAuth2AuthorizedClientService).reset(); }
|
### Question:
OidcClientRepositoryDecorator extends AbstractRepositoryDecorator<OidcClient> { @Override public void deleteById(Object id) { super.deleteById(id); oAuth2AuthorizedClientService.reset(); } OidcClientRepositoryDecorator(
Repository<OidcClient> delegateRepository,
ResettableOAuth2AuthorizedClientService oAuth2AuthorizedClientService); @Override void update(OidcClient entity); @Override void update(Stream<OidcClient> entities); @Override void delete(OidcClient entity); @Override void deleteById(Object id); @Override void deleteAll(); @Override void delete(Stream<OidcClient> entities); @Override void deleteAll(Stream<Object> ids); }### Answer:
@Test void testDeleteById() { String oidcClientId = "oidcClientId"; oidcClientRepositoryDecorator.deleteById(oidcClientId); verify(delegateRepository).deleteById(oidcClientId); verify(oAuth2AuthorizedClientService).reset(); }
|
### Question:
OidcClientRepositoryDecorator extends AbstractRepositoryDecorator<OidcClient> { @Override public void deleteAll() { super.deleteAll(); oAuth2AuthorizedClientService.reset(); } OidcClientRepositoryDecorator(
Repository<OidcClient> delegateRepository,
ResettableOAuth2AuthorizedClientService oAuth2AuthorizedClientService); @Override void update(OidcClient entity); @Override void update(Stream<OidcClient> entities); @Override void delete(OidcClient entity); @Override void deleteById(Object id); @Override void deleteAll(); @Override void delete(Stream<OidcClient> entities); @Override void deleteAll(Stream<Object> ids); }### Answer:
@Test void testDeleteAll() { oidcClientRepositoryDecorator.deleteAll(); verify(delegateRepository).deleteAll(); verify(oAuth2AuthorizedClientService).reset(); }
@Test void testDeleteAllStream() { @SuppressWarnings("unchecked") Stream<Object> oidcClientIdStream = mock(Stream.class); oidcClientRepositoryDecorator.deleteAll(oidcClientIdStream); verify(delegateRepository).deleteAll(oidcClientIdStream); verify(oAuth2AuthorizedClientService).reset(); }
|
### Question:
OidcUserMissingEmailException extends RuntimeException { @Override public String getMessage() { return "email claim missing for subject '" + oidcUser.getSubject() + '\''; } OidcUserMissingEmailException(OidcUser oidcUser); @Override String getMessage(); }### Answer:
@Test void testGetMessage() { when(oidcUser.getSubject()).thenReturn("userId"); assertEquals( "email claim missing for subject 'userId'", oidcUserMissingEmailException.getMessage()); }
|
### Question:
MappedOidcUserService extends OidcUserService { public MappedOidcUserService( OidcUserMapper oidcUserMapper, UserDetailsServiceImpl userDetailsServiceImpl) { this.oidcUserMapper = requireNonNull(oidcUserMapper); this.userDetailsServiceImpl = requireNonNull(userDetailsServiceImpl); } MappedOidcUserService(
OidcUserMapper oidcUserMapper, UserDetailsServiceImpl userDetailsServiceImpl); @Override MappedOidcUser loadUser(OidcUserRequest userRequest); }### Answer:
@Test void testMappedOidcUserService() { assertThrows(NullPointerException.class, () -> new MappedOidcUserService(null, null)); }
|
### Question:
DataServiceClientRegistrationRepository implements ClientRegistrationRepository { public DataServiceClientRegistrationRepository(AuthenticationSettings authenticationSettings) { this.authenticationSettings = requireNonNull(authenticationSettings); } DataServiceClientRegistrationRepository(AuthenticationSettings authenticationSettings); @Override ClientRegistration findByRegistrationId(String registrationId); }### Answer:
@Test void testDataServiceClientRegistrationRepository() { assertThrows( NullPointerException.class, () -> new DataServiceClientRegistrationRepository(null)); }
|
### Question:
OidcUserEmailVerificationException extends RuntimeException { @Override public String getMessage() { return "email verification claim exists but evaluates to false for subject '" + oidcUser.getSubject() + '\''; } OidcUserEmailVerificationException(OidcUser oidcUser); @Override String getMessage(); }### Answer:
@Test void testGetMessage() { when(oidcUser.getSubject()).thenReturn("userId"); assertEquals( "email verification claim exists but evaluates to false for subject 'userId'", oidcUserEmailVerificationException.getMessage()); }
|
### Question:
ResettableOAuth2AuthorizedClientService implements OAuth2AuthorizedClientService { public void reset() { authorizedClients.clear(); } ResettableOAuth2AuthorizedClientService(
ClientRegistrationRepository clientRegistrationRepository); @SuppressWarnings("unchecked") @Override T loadAuthorizedClient(
String clientRegistrationId, String principalName); @Override void saveAuthorizedClient(
OAuth2AuthorizedClient authorizedClient, Authentication principal); @Override void removeAuthorizedClient(String clientRegistrationId, String principalName); void reset(); }### Answer:
@Test void testReset() { oAuth2AuthorizedClientService.reset(); assertEquals(emptyMap(), oAuth2AuthorizedClientService.getAuthorizedClients()); }
|
### Question:
TokenAwareSecurityContextRepository implements SecurityContextRepository { TokenAwareSecurityContextRepository( SecurityContextRepository tokenSecurityContextRepository, SecurityContextRepository defaultSecurityContextRepository) { this.tokenSecurityContextRepository = requireNonNull(tokenSecurityContextRepository); this.defaultSecurityContextRepository = requireNonNull(defaultSecurityContextRepository); } TokenAwareSecurityContextRepository(
SecurityContextRepository tokenSecurityContextRepository,
SecurityContextRepository defaultSecurityContextRepository); @Override SecurityContext loadContext(HttpRequestResponseHolder requestResponseHolder); @Override void saveContext(
SecurityContext context, HttpServletRequest request, HttpServletResponse response); @Override boolean containsContext(HttpServletRequest request); }### Answer:
@Test void testTokenAwareSecurityContextRepository() { assertThrows( NullPointerException.class, () -> new TokenAwareSecurityContextRepository(null, null)); }
|
### Question:
TokenAwareSecurityContextRepository implements SecurityContextRepository { @Override public SecurityContext loadContext(HttpRequestResponseHolder requestResponseHolder) { HttpServletRequest request = requestResponseHolder.getRequest(); return getSecurityContextRepository(request).loadContext(requestResponseHolder); } TokenAwareSecurityContextRepository(
SecurityContextRepository tokenSecurityContextRepository,
SecurityContextRepository defaultSecurityContextRepository); @Override SecurityContext loadContext(HttpRequestResponseHolder requestResponseHolder); @Override void saveContext(
SecurityContext context, HttpServletRequest request, HttpServletResponse response); @Override boolean containsContext(HttpServletRequest request); }### Answer:
@Test void testLoadContext() { MockHttpServletRequest request = new MockHttpServletRequest(); MockHttpServletResponse response = new MockHttpServletResponse(); HttpRequestResponseHolder holder = new HttpRequestResponseHolder(request, response); SecurityContext securityContext = mock(SecurityContext.class); when(defaultSecurityContextRepository.loadContext(holder)).thenReturn(securityContext); assertEquals(securityContext, tokenAwareSecurityContextRepository.loadContext(holder)); }
@Test void testLoadContextTokenRequest() { MockHttpServletRequest request = new MockHttpServletRequest(); request.setParameter("molgenis-token", "my_token"); MockHttpServletResponse response = new MockHttpServletResponse(); HttpRequestResponseHolder holder = new HttpRequestResponseHolder(request, response); SecurityContext securityContext = mock(SecurityContext.class); when(tokenSecurityContextRepository.loadContext(holder)).thenReturn(securityContext); assertEquals(securityContext, tokenAwareSecurityContextRepository.loadContext(holder)); }
|
### Question:
TokenAwareSecurityContextRepository implements SecurityContextRepository { @Override public void saveContext( SecurityContext context, HttpServletRequest request, HttpServletResponse response) { getSecurityContextRepository(request).saveContext(context, request, response); } TokenAwareSecurityContextRepository(
SecurityContextRepository tokenSecurityContextRepository,
SecurityContextRepository defaultSecurityContextRepository); @Override SecurityContext loadContext(HttpRequestResponseHolder requestResponseHolder); @Override void saveContext(
SecurityContext context, HttpServletRequest request, HttpServletResponse response); @Override boolean containsContext(HttpServletRequest request); }### Answer:
@Test void testSaveContext() { SecurityContext securityContext = mock(SecurityContext.class); MockHttpServletRequest request = new MockHttpServletRequest(); MockHttpServletResponse response = new MockHttpServletResponse(); tokenAwareSecurityContextRepository.saveContext(securityContext, request, response); verify(defaultSecurityContextRepository).saveContext(securityContext, request, response); }
@Test void testSaveContextTokenRequest() { SecurityContext securityContext = mock(SecurityContext.class); MockHttpServletRequest request = new MockHttpServletRequest(); request.setParameter("molgenis-token", "my_token"); MockHttpServletResponse response = new MockHttpServletResponse(); tokenAwareSecurityContextRepository.saveContext(securityContext, request, response); verify(tokenSecurityContextRepository).saveContext(securityContext, request, response); }
|
### Question:
TokenAwareSecurityContextRepository implements SecurityContextRepository { @Override public boolean containsContext(HttpServletRequest request) { return getSecurityContextRepository(request).containsContext(request); } TokenAwareSecurityContextRepository(
SecurityContextRepository tokenSecurityContextRepository,
SecurityContextRepository defaultSecurityContextRepository); @Override SecurityContext loadContext(HttpRequestResponseHolder requestResponseHolder); @Override void saveContext(
SecurityContext context, HttpServletRequest request, HttpServletResponse response); @Override boolean containsContext(HttpServletRequest request); }### Answer:
@Test void testContainsContext() { MockHttpServletRequest request = new MockHttpServletRequest(); when(defaultSecurityContextRepository.containsContext(request)).thenReturn(true); assertTrue(tokenAwareSecurityContextRepository.containsContext(request)); }
@Test void testContainsContextTokenRequest() { MockHttpServletRequest request = new MockHttpServletRequest(); request.setParameter("molgenis-token", "my_token"); when(tokenSecurityContextRepository.containsContext(request)).thenReturn(true); assertTrue(tokenAwareSecurityContextRepository.containsContext(request)); }
|
### Question:
ReCaptchaHttpPostFactory { HttpPost create(String uri) { if (uri.isEmpty()) { LOG.error("No valid verification url provided"); } return new HttpPost(URI.create(uri)); } }### Answer:
@Test void testHttpPostCreate() { HttpPost post = factory.create("http: assertEquals(create("http: }
@Test void testHttpPostCreateEmptyURI() { assertDoesNotThrow(() -> factory.create("")); }
|
### Question:
HasPermissionDirective extends PermissionDirective { @Override protected void execute(boolean hasPermission, Environment env, TemplateDirectiveBody body) throws TemplateException, IOException { if (hasPermission) { body.render(env.getOut()); } } HasPermissionDirective(UserPermissionEvaluator permissionService); }### Answer:
@Test void executeWithPermission() throws TemplateException, IOException { when(permissionService.hasPermission( new EntityTypeIdentity("entity"), newArrayList(EntityTypePermission.COUNT_DATA))) .thenReturn(true); Map<String, Object> params = Maps.newHashMap(); params.put("entityTypeId", "entity"); params.put("permission", "COUNT"); directive.execute( new Environment(fakeTemplate, null, envWriter), params, new TemplateModel[0], out -> out.write("PERMISSION")); assertEquals("PERMISSION", envWriter.toString()); }
@Test void executeWithoutPermission() throws TemplateException, IOException { when(permissionService.hasPermission( new EntityTypeIdentity("entity"), EntityTypePermission.UPDATE_DATA)) .thenReturn(false); Map<String, Object> params = Maps.newHashMap(); params.put("entityTypeId", "entity"); params.put("permission", "WRITE"); directive.execute( new Environment(fakeTemplate, null, envWriter), params, new TemplateModel[0], out -> out.write("PERMISSION")); assertEquals("", envWriter.toString()); }
|
### Question:
EntityReferenceResolverDecorator extends AbstractRepositoryDecorator<Entity> { @Override public void forEachBatched(Fetch fetch, Consumer<List<Entity>> consumer, int batchSize) { delegate() .forEachBatched( fetch, entities -> { List<Entity> resolvedEntities = resolveEntityReferences(entities.stream(), fetch).collect(Collectors.toList()); consumer.accept(resolvedEntities); }, batchSize); } EntityReferenceResolverDecorator(
Repository<Entity> delegateRepository, EntityManager entityManager); @Override Stream<Entity> findAll(Query<Entity> q); @Override Entity findOne(Query<Entity> q); @Override Iterator<Entity> iterator(); @Override void forEachBatched(Fetch fetch, Consumer<List<Entity>> consumer, int batchSize); @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); }### Answer:
@Test void streamFetch() { when(delegateRepository.getEntityType()).thenReturn(entityType); Fetch fetch = new Fetch(); Entity entity0 = mock(Entity.class); Entity entity1 = mock(Entity.class); Entity entity0WithRefs = mock(Entity.class); Entity entity1WithRefs = mock(Entity.class); List<Entity> entities = Arrays.asList(entity0, entity1); List<Entity> entitiesWithRefs = Arrays.asList(entity0WithRefs, entity1WithRefs); when(entityManager.resolveReferences(eq(entityType), streamArgumentCaptor.capture(), eq(fetch))) .thenReturn(entitiesWithRefs.stream()); entityReferenceResolverDecorator.forEachBatched(fetch, consumer, 123); verify(delegateRepository).forEachBatched(eq(fetch), consumerArgumentCaptor.capture(), eq(123)); consumerArgumentCaptor.getValue().accept(entities); Stream<Entity> entitiesToDecorate = streamArgumentCaptor.getValue(); assertEquals(entities, entitiesToDecorate.collect(toList())); verify(consumer).accept(entitiesWithRefs); }
|
### Question:
FileStore { public boolean createDirectory(String dirName) { validatePathname(dirName); return new File(storageDir + separator + dirName).mkdirs(); } FileStore(String storageDir); FileStore inSubdir(String subdir); boolean createDirectory(String dirName); void deleteDirectory(String dirName); File store(InputStream is, String fileName); void move(String sourceDir, String targetDir); File getFile(String fileName); File getFileUnchecked(String fileName); void delete(String fileName); String getStorageDir(); }### Answer:
@Test void testCreateDirectory() { assertTrue(fileStore.createDirectory("testDir")); assertTrue(fileStore.getFileUnchecked("testDir").isDirectory()); fileStore.delete("testDir"); }
|
### Question:
FileStore { public File store(InputStream is, String fileName) throws IOException { validatePathname(fileName); File file = new File(storageDir + separator + fileName); try (FileOutputStream fos = new FileOutputStream(file)) { IOUtils.copy(is, fos); } return file; } FileStore(String storageDir); FileStore inSubdir(String subdir); boolean createDirectory(String dirName); void deleteDirectory(String dirName); File store(InputStream is, String fileName); void move(String sourceDir, String targetDir); File getFile(String fileName); File getFileUnchecked(String fileName); void delete(String fileName); String getStorageDir(); }### Answer:
@Test void testStore() throws IOException { File file = fileStore.store(new ByteArrayInputStream(new byte[] {1, 2, 3}), "bytes.bin"); assertArrayEquals(new byte[] {1, 2, 3}, readFileToByteArray(file)); }
@Test void testGetFileUncheckedDirectoryTraversal() { String fileName = "../../bytes.bin"; assertThrows( UncheckedIOException.class, () -> fileStore.store(new ByteArrayInputStream(new byte[] {1, 2, 3}), fileName)); }
|
### Question:
FileStore { public File getFileUnchecked(String fileName) { validatePathname(fileName); return new File(storageDir + separator + fileName); } FileStore(String storageDir); FileStore inSubdir(String subdir); boolean createDirectory(String dirName); void deleteDirectory(String dirName); File store(InputStream is, String fileName); void move(String sourceDir, String targetDir); File getFile(String fileName); File getFileUnchecked(String fileName); void delete(String fileName); String getStorageDir(); }### Answer:
@Test void testGetFileUnchecked() throws IOException { String fileName = "bytes.bin"; File file = fileStore.store(new ByteArrayInputStream(new byte[] {1, 2, 3}), fileName); assertEquals(file.getAbsolutePath(), fileStore.getFileUnchecked(fileName).getAbsolutePath()); }
|
### Question:
FileStore { public File getFile(String fileName) throws IOException { validatePathname(fileName); String pathname = storageDir + separator + fileName; File file = new File(pathname); if (!file.exists()) { throw new FileNotFoundException(pathname); } if (!file.isFile()) { throw new IOException('\'' + pathname + '\'' + " is not a file"); } return file; } FileStore(String storageDir); FileStore inSubdir(String subdir); boolean createDirectory(String dirName); void deleteDirectory(String dirName); File store(InputStream is, String fileName); void move(String sourceDir, String targetDir); File getFile(String fileName); File getFileUnchecked(String fileName); void delete(String fileName); String getStorageDir(); }### Answer:
@Test void testGetFileNotExists() { String fileName = "unknownFile"; assertThrows(FileNotFoundException.class, () -> fileStore.getFile(fileName)); }
|
### Question:
LowerCaseProcessor extends AbstractCellProcessor { public LowerCaseProcessor() { super(); } LowerCaseProcessor(); LowerCaseProcessor(boolean processHeader, boolean processData); @Override String process(String value); }### Answer:
@Test void testLowerCaseProcessor() { LowerCaseProcessor lowerCaseProcessor = new LowerCaseProcessor(true, false); assertAll( () -> assertTrue(lowerCaseProcessor.processHeader()), () -> assertFalse(lowerCaseProcessor.processData())); }
|
### Question:
LowerCaseProcessor extends AbstractCellProcessor { @Override public String process(String value) { return value != null ? value.toLowerCase() : null; } LowerCaseProcessor(); LowerCaseProcessor(boolean processHeader, boolean processData); @Override String process(String value); }### Answer:
@Test void process() { assertEquals("a", new LowerCaseProcessor().process("A")); }
@Test void processNull() { assertNull(new LowerCaseProcessor().process(null)); }
|
### Question:
AbstractCellProcessor implements CellProcessor { public static String processCell( String value, boolean isHeader, List<CellProcessor> cellProcessors) { if (cellProcessors != null) { for (CellProcessor cellProcessor : cellProcessors) { boolean process = (isHeader && cellProcessor.processHeader()) || (!isHeader && cellProcessor.processData()); if (process) value = cellProcessor.process(value); } } return value; } AbstractCellProcessor(); AbstractCellProcessor(boolean processHeader, boolean processData); @Override boolean processHeader(); @Override boolean processData(); static String processCell(
String value, boolean isHeader, List<CellProcessor> cellProcessors); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test void processCell_null() { assertEquals("val", processCell("val", false, null)); }
@Test void processCell_header() { assertEquals("COL", processCell("col", true, processors)); }
@Test void processCell_data() { assertEquals("VAL", processCell("val", false, processors)); }
|
### Question:
EntityReferenceResolverDecorator extends AbstractRepositoryDecorator<Entity> { @Override public Entity findOne(Query<Entity> q) { Entity entity = delegate().findOne(q); return entity != null ? resolveEntityReferences(entity, q.getFetch()) : null; } EntityReferenceResolverDecorator(
Repository<Entity> delegateRepository, EntityManager entityManager); @Override Stream<Entity> findAll(Query<Entity> q); @Override Entity findOne(Query<Entity> q); @Override Iterator<Entity> iterator(); @Override void forEachBatched(Fetch fetch, Consumer<List<Entity>> consumer, int batchSize); @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); }### Answer:
@Test void findOneQueryEntity() { when(delegateRepository.getEntityType()).thenReturn(entityType); Fetch fetch = new Fetch(); @SuppressWarnings("unchecked") Query<Entity> q = mock(Query.class); when(q.getFetch()).thenReturn(fetch); Entity entity = mock(Entity.class); when(delegateRepository.findOne(q)).thenReturn(entity); entityReferenceResolverDecorator.findOne(q); verify(delegateRepository, times(1)).findOne(q); verify(entityManager).resolveReferences(entityType, entity, fetch); }
@Test void findOneQueryEntityNull() { @SuppressWarnings("unchecked") Query<Entity> q = mock(Query.class); entityReferenceResolverDecorator.findOne(q); verify(delegateRepository, times(1)).findOne(q); verifyZeroInteractions(entityManager); }
|
### Question:
GlobalControllerExceptionHandler extends SpringExceptionHandler { @ExceptionHandler(PermissionDeniedException.class) public Object handleUnauthorizedException(Exception e, HandlerMethod handlerMethod) { return logAndHandleException(e, UNAUTHORIZED, handlerMethod); } GlobalControllerExceptionHandler(ExceptionHandlerFacade exceptionHandlerFacade); @ExceptionHandler(UnknownDataException.class) Object handleNotFoundException(Exception e, HandlerMethod handlerMethod); @ExceptionHandler(DataAlreadyExistsException.class) Object handleConflictException(Exception e, HandlerMethod handlerMethod); @ExceptionHandler({ BadRequestException.class, DataConstraintViolationException.class, RepositoryConstraintViolationException.class }) Object handleBadRequestException(Exception e, HandlerMethod handlerMethod); @ExceptionHandler(ForbiddenException.class) Object handleForbiddenException(Exception e, HandlerMethod handlerMethod); @ExceptionHandler(PermissionDeniedException.class) Object handleUnauthorizedException(Exception e, HandlerMethod handlerMethod); }### Answer:
@Test void testHandleUnauthorizedException() { Exception e = mock(Exception.class); HandlerMethod method = mock(HandlerMethod.class); globalControllerExceptionHandler.handleUnauthorizedException(e, method); verify(exceptionHandlerFacade).logAndHandleException(e, UNAUTHORIZED, method); }
|
### Question:
TrimProcessor extends AbstractCellProcessor { @Override public String process(String value) { return value != null ? value.trim() : null; } TrimProcessor(); @Override String process(String value); }### Answer:
@Test void process() { assertEquals("val", new TrimProcessor().process(" val ")); }
@Test void processNull() { assertNull(new TrimProcessor().process(null)); }
|
### Question:
MissingValueProcessor extends AbstractCellProcessor { @Override public String process(String value) { if (value == null) { return missingValue; } else { return emptyIsMissing && value.isEmpty() ? missingValue : value; } } MissingValueProcessor(String missingValue, boolean emptyIsMissing); @Override String process(String value); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test void processNull() { assertEquals("unknown", new MissingValueProcessor("unknown", false).process(null)); }
@Test void processNull_processEmpty() { assertEquals("unknown", new MissingValueProcessor("unknown", true).process(null)); }
@Test void processEmpty() { assertEquals("unknown", new MissingValueProcessor("unknown", true).process("")); }
@Test void processEmpty_processEmpty() { assertEquals("", new MissingValueProcessor("unknown", false).process("")); }
@Test void process() { assertEquals("value", new MissingValueProcessor("unknown", true).process("value")); }
@Test void process_processEmpty() { assertEquals("value", new MissingValueProcessor("unknown", true).process("value")); }
|
### Question:
MissingValueProcessor extends AbstractCellProcessor { @Override public boolean equals(Object obj) { if (this == obj) return true; if (!super.equals(obj)) return false; if (getClass() != obj.getClass()) return false; MissingValueProcessor other = (MissingValueProcessor) obj; if (emptyIsMissing != other.emptyIsMissing) return false; if (missingValue == null) { if (other.missingValue != null) return false; } else if (!missingValue.equals(other.missingValue)) return false; return true; } MissingValueProcessor(String missingValue, boolean emptyIsMissing); @Override String process(String value); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test void equals() { assertEquals( new MissingValueProcessor("unknown", true), new MissingValueProcessor("unknown", true)); }
|
### Question:
TransactionalBlobStoreDecorator extends BlobStoreDecorator implements TransactionListener { public TransactionalBlobStoreDecorator(BlobStore delegateBlobStore) { super(delegateBlobStore); this.transactionBlobMap = ArrayListMultimap.create(); } TransactionalBlobStoreDecorator(BlobStore delegateBlobStore); @Override BlobMetadata store(ReadableByteChannel fromChannel); @Override void delete(String blobId); @Override void rollbackTransaction(String transactionId); @Override void doCleanupAfterCompletion(String transactionId); }### Answer:
@Test void testTransactionalBlobStoreDecorator() { assertThrows(NullPointerException.class, () -> new TransactionalBlobStoreDecorator(null)); }
|
### Question:
TransactionalBlobStoreDecorator extends BlobStoreDecorator implements TransactionListener { @Override public BlobMetadata store(ReadableByteChannel fromChannel) { BlobMetadata blobMetadata = super.store(fromChannel); String transactionId = (String) getResource(TRANSACTION_ID_RESOURCE_NAME); transactionBlobMap.put(transactionId, blobMetadata.getId()); return blobMetadata; } TransactionalBlobStoreDecorator(BlobStore delegateBlobStore); @Override BlobMetadata store(ReadableByteChannel fromChannel); @Override void delete(String blobId); @Override void rollbackTransaction(String transactionId); @Override void doCleanupAfterCompletion(String transactionId); }### Answer:
@Test void testStore() { BlobMetadata blobMetadata = mock(BlobMetadata.class); ReadableByteChannel readableByteChannel = mock(ReadableByteChannel.class); when(blobStore.store(readableByteChannel)).thenReturn(blobMetadata); assertEquals(blobMetadata, transactionalBlobStoreDecorator.store(readableByteChannel)); }
|
### Question:
TransactionalBlobStoreDecorator extends BlobStoreDecorator implements TransactionListener { @Override public void delete(String blobId) { super.delete(blobId); String transactionId = (String) getResource(TRANSACTION_ID_RESOURCE_NAME); transactionBlobMap.remove(transactionId, blobId); } TransactionalBlobStoreDecorator(BlobStore delegateBlobStore); @Override BlobMetadata store(ReadableByteChannel fromChannel); @Override void delete(String blobId); @Override void rollbackTransaction(String transactionId); @Override void doCleanupAfterCompletion(String transactionId); }### Answer:
@Test void testDelete() { String blobId = "MyBlobId"; transactionalBlobStoreDecorator.delete(blobId); verify(blobStore).delete(blobId); }
|
### Question:
TransactionalBlobStoreDecorator extends BlobStoreDecorator implements TransactionListener { @Override public void rollbackTransaction(String transactionId) { List<String> blobIds = new ArrayList<>(transactionBlobMap.get(transactionId)); blobIds.forEach(this::delete); } TransactionalBlobStoreDecorator(BlobStore delegateBlobStore); @Override BlobMetadata store(ReadableByteChannel fromChannel); @Override void delete(String blobId); @Override void rollbackTransaction(String transactionId); @Override void doCleanupAfterCompletion(String transactionId); }### Answer:
@Test void testRollbackTransaction() { String blobId = "MyBlobId"; BlobMetadata blobMetadata = mock(BlobMetadata.class); when(blobMetadata.getId()).thenReturn(blobId); ReadableByteChannel readableByteChannel = mock(ReadableByteChannel.class); when(blobStore.store(readableByteChannel)).thenReturn(blobMetadata); transactionalBlobStoreDecorator.store(readableByteChannel); transactionalBlobStoreDecorator.rollbackTransaction(TRANSACTION_ID); verify(blobStore).delete(blobId); }
|
### Question:
TransactionalBlobStoreDecorator extends BlobStoreDecorator implements TransactionListener { @Override public void doCleanupAfterCompletion(String transactionId) { transactionBlobMap.removeAll(transactionId); } TransactionalBlobStoreDecorator(BlobStore delegateBlobStore); @Override BlobMetadata store(ReadableByteChannel fromChannel); @Override void delete(String blobId); @Override void rollbackTransaction(String transactionId); @Override void doCleanupAfterCompletion(String transactionId); }### Answer:
@Test void testDoCleanupAfterCompletion() { assertDoesNotThrow( () -> transactionalBlobStoreDecorator.doCleanupAfterCompletion(TRANSACTION_ID)); }
|
### Question:
FileMetaRepositoryDecorator extends AbstractRepositoryDecorator<FileMeta> { @Override public void delete(FileMeta fileMeta) { deleteFile(fileMeta); super.delete(fileMeta); } FileMetaRepositoryDecorator(
Repository<FileMeta> delegateRepository, FileStore fileStore, BlobStore blobStore); @Override void delete(FileMeta fileMeta); @Override void deleteById(Object id); @Override void deleteAll(); @Override void delete(Stream<FileMeta> fileMetaStream); @Override void deleteAll(Stream<Object> ids); }### Answer:
@Test void testDelete() { FileMeta fileMeta = getMockFileMeta("id"); fileMetaRepositoryDecorator.delete(fileMeta); verify(delegateRepository).delete(fileMeta); verify(fileStore).delete("id"); }
@Test void testDeleteStream() { FileMeta fileMeta0 = getMockFileMeta("id0"); FileMeta fileMeta1 = getMockFileMeta("id1"); fileMetaRepositoryDecorator.delete(Stream.of(fileMeta0, fileMeta1)); @SuppressWarnings("unchecked") ArgumentCaptor<Stream<FileMeta>> captor = ArgumentCaptor.forClass(Stream.class); verify(delegateRepository).delete(captor.capture()); assertEquals(asList(fileMeta0, fileMeta1), captor.getValue().collect(toList())); verify(fileStore).delete("id0"); verify(fileStore).delete("id1"); }
@Test void testDeleteBlobStore() { FileMeta fileMeta = getMockFileMeta("id"); when(fileMeta.getUrl()).thenReturn("/api/files/v1/id?alt=media"); fileMetaRepositoryDecorator.delete(fileMeta); verify(delegateRepository).delete(fileMeta); verify(blobStore).delete("id"); }
|
### Question:
FileMetaRepositoryDecorator extends AbstractRepositoryDecorator<FileMeta> { @Override public void deleteById(Object id) { deleteFile(getFileMeta(id)); super.deleteById(id); } FileMetaRepositoryDecorator(
Repository<FileMeta> delegateRepository, FileStore fileStore, BlobStore blobStore); @Override void delete(FileMeta fileMeta); @Override void deleteById(Object id); @Override void deleteAll(); @Override void delete(Stream<FileMeta> fileMetaStream); @Override void deleteAll(Stream<Object> ids); }### Answer:
@Test void testDeleteById() { FileMeta fileMeta = getMockFileMeta("id"); when(delegateRepository.findOneById("id")).thenReturn(fileMeta); fileMetaRepositoryDecorator.deleteById("id"); verify(delegateRepository).deleteById("id"); verify(fileStore).delete("id"); }
@Test void testDeleteByIdUnknownId() { Attribute idAttribute = when(mock(Attribute.class).getName()).thenReturn("idAttribute").getMock(); EntityType entityType = when(mock(EntityType.class).getId()).thenReturn("sys_file_FileMeta").getMock(); when(entityType.getIdAttribute()).thenReturn(idAttribute); when(delegateRepository.getEntityType()).thenReturn(entityType); when(delegateRepository.findOneById("id")).thenReturn(null); Exception exception = assertThrows( UnknownEntityException.class, () -> fileMetaRepositoryDecorator.deleteById("id")); assertThat(exception.getMessage()) .containsPattern("type:sys_file_FileMeta id:id attribute:idAttribute"); }
|
### Question:
FileMetaRepositoryDecorator extends AbstractRepositoryDecorator<FileMeta> { @Override public void deleteAll() { query().findAll().forEach(this::deleteFile); super.deleteAll(); } FileMetaRepositoryDecorator(
Repository<FileMeta> delegateRepository, FileStore fileStore, BlobStore blobStore); @Override void delete(FileMeta fileMeta); @Override void deleteById(Object id); @Override void deleteAll(); @Override void delete(Stream<FileMeta> fileMetaStream); @Override void deleteAll(Stream<Object> ids); }### Answer:
@SuppressWarnings("unchecked") @Test void testDeleteAll() { FileMeta fileMeta0 = getMockFileMeta("id0"); FileMeta fileMeta1 = getMockFileMeta("id1"); when(delegateRepository.findAll(any(Query.class))).thenReturn(Stream.of(fileMeta0, fileMeta1)); fileMetaRepositoryDecorator.deleteAll(); verify(delegateRepository).deleteAll(); verify(fileStore).delete("id0"); verify(fileStore).delete("id1"); }
|
### Question:
EntityReferenceResolverDecorator extends AbstractRepositoryDecorator<Entity> { @Override public Entity findOneById(Object id) { Entity entity = delegate().findOneById(id); return entity != null ? resolveEntityReferences(entity) : null; } EntityReferenceResolverDecorator(
Repository<Entity> delegateRepository, EntityManager entityManager); @Override Stream<Entity> findAll(Query<Entity> q); @Override Entity findOne(Query<Entity> q); @Override Iterator<Entity> iterator(); @Override void forEachBatched(Fetch fetch, Consumer<List<Entity>> consumer, int batchSize); @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); }### Answer:
@Test void findOneObject() { Object id = mock(Object.class); entityReferenceResolverDecorator.findOneById(id); verify(delegateRepository, times(1)).findOneById(id); verifyZeroInteractions(entityManager); }
@Test void findOneObjectFetch() { when(delegateRepository.getEntityType()).thenReturn(entityType); Object id = 1; Fetch fetch = new Fetch(); Entity entity = mock(Entity.class); when(delegateRepository.findOneById(id, fetch)).thenReturn(entity); entityReferenceResolverDecorator.findOneById(id, fetch); verify(delegateRepository, times(1)).findOneById(id, fetch); verify(entityManager).resolveReferences(entityType, entity, fetch); }
@Test void findOneObjectFetchNull() { Object id = 1; entityReferenceResolverDecorator.findOneById(id, null); verify(delegateRepository, times(1)).findOneById(id, null); verifyZeroInteractions(entityManager); }
|
### Question:
MinioClientFacade { void putObject(String objectName, InputStream stream, String contentType) throws InvalidBucketNameException, NoSuchAlgorithmException, IOException, InvalidKeyException, NoResponseException, XmlPullParserException, ErrorResponseException, InternalException, InvalidArgumentException, InsufficientDataException { LOG.trace("Putting object '{}' in bucket '{}' ...", objectName, bucketName); minioClient.putObject(bucketName, objectName, stream, contentType); LOG.debug("Put object '{}' in bucket '{}'", objectName, bucketName); } MinioClientFacade(MinioClient minioClient, String bucketName); }### Answer:
@Test void testPutObject() throws IOException, XmlPullParserException, NoSuchAlgorithmException, InvalidKeyException, InvalidArgumentException, InternalException, NoResponseException, InvalidBucketNameException, InsufficientDataException, ErrorResponseException { String objectName = "MyObjectName"; InputStream inputStream = mock(InputStream.class); String contentType = "application/octet-stream"; minioClientFacade.putObject(objectName, inputStream, contentType); verify(minioClient).putObject(bucketName, objectName, inputStream, contentType); }
|
### Question:
MinioClientFacade { ObjectStat statObject(String objectName) throws InvalidBucketNameException, NoSuchAlgorithmException, InsufficientDataException, IOException, InvalidKeyException, NoResponseException, XmlPullParserException, ErrorResponseException, InternalException { LOG.trace("Retrieving metadata for object '{}' in bucket '{}' ...", objectName, bucketName); ObjectStat objectStat = minioClient.statObject(bucketName, objectName); LOG.debug("Retrieved metadata for object '{}' in bucket '{}'", objectName, bucketName); return objectStat; } MinioClientFacade(MinioClient minioClient, String bucketName); }### Answer:
@Test void testStatObject() throws IOException, InvalidKeyException, NoSuchAlgorithmException, InsufficientDataException, InternalException, NoResponseException, InvalidBucketNameException, XmlPullParserException, ErrorResponseException { String objectName = "MyObjectName"; ObjectStat objectStat = mock(ObjectStat.class); when(minioClient.statObject(bucketName, objectName)).thenReturn(objectStat); assertEquals(objectStat, minioClientFacade.statObject(objectName)); }
|
### Question:
MinioClientFacade { void removeObject(String objectName) throws InvalidBucketNameException, NoSuchAlgorithmException, InsufficientDataException, IOException, InvalidKeyException, NoResponseException, XmlPullParserException, ErrorResponseException, InternalException, InvalidArgumentException { LOG.trace("Removing object '{}' in bucket '{}' ...", objectName, bucketName); minioClient.removeObject(bucketName, objectName); LOG.debug("Removed object '{}' in bucket '{}'", objectName, bucketName); } MinioClientFacade(MinioClient minioClient, String bucketName); }### Answer:
@Test void testRemoveObject() throws IOException, InvalidKeyException, NoSuchAlgorithmException, InsufficientDataException, InvalidArgumentException, InternalException, NoResponseException, InvalidBucketNameException, XmlPullParserException, ErrorResponseException { String objectName = "MyObjectName"; minioClientFacade.removeObject(objectName); verify(minioClient).removeObject(bucketName, objectName); }
|
### Question:
MinioClientFacade { InputStream getObject(String objectName) throws InvalidBucketNameException, NoSuchAlgorithmException, InsufficientDataException, IOException, InvalidKeyException, NoResponseException, XmlPullParserException, ErrorResponseException, InternalException, InvalidArgumentException { LOG.trace("Streaming object '{}' in bucket '{}' ...", objectName, bucketName); return minioClient.getObject(bucketName, objectName); } MinioClientFacade(MinioClient minioClient, String bucketName); }### Answer:
@Test void testGetObject() throws IOException, InvalidKeyException, NoSuchAlgorithmException, InsufficientDataException, InvalidArgumentException, InternalException, NoResponseException, InvalidBucketNameException, XmlPullParserException, ErrorResponseException { String objectName = "MyObjectName"; InputStream inputStream = mock(InputStream.class); when(minioClient.getObject(bucketName, objectName)).thenReturn(inputStream); assertEquals(inputStream, minioClientFacade.getObject(objectName)); }
|
### Question:
MinioBlobStore implements BlobStore { MinioBlobStore(MinioClientFacade minioClientFacade, IdGenerator idGenerator) { this.minioClientFacade = requireNonNull(minioClientFacade); this.idGenerator = requireNonNull(idGenerator); } MinioBlobStore(MinioClientFacade minioClientFacade, IdGenerator idGenerator); @Override BlobMetadata store(ReadableByteChannel fromChannel); @Override void delete(String blobId); @Override ReadableByteChannel newChannel(String blobId); }### Answer:
@Test void testMinioBlobStore() { assertThrows(NullPointerException.class, () -> new MinioBlobStore(null, null)); }
|
### Question:
MinioBlobStore implements BlobStore { @Override public void delete(String blobId) { try { minioClientFacade.removeObject(blobId); } catch (IOException e) { throw new UncheckedIOException(e); } catch (InvalidBucketNameException | NoSuchAlgorithmException | InsufficientDataException | InvalidKeyException | NoResponseException | XmlPullParserException | ErrorResponseException | InternalException | InvalidArgumentException e) { throw new UncheckedIOException(new IOException(e)); } } MinioBlobStore(MinioClientFacade minioClientFacade, IdGenerator idGenerator); @Override BlobMetadata store(ReadableByteChannel fromChannel); @Override void delete(String blobId); @Override ReadableByteChannel newChannel(String blobId); }### Answer:
@Test void testDelete() throws IOException, InvalidKeyException, NoSuchAlgorithmException, InsufficientDataException, InvalidArgumentException, InternalException, NoResponseException, InvalidBucketNameException, XmlPullParserException, ErrorResponseException { String blobId = "MyBlobId"; minioBlobStore.delete(blobId); verify(minioClientFacade).removeObject(blobId); }
|
### Question:
MinioBlobStore implements BlobStore { @Override public ReadableByteChannel newChannel(String blobId) { InputStream inputStream; try { inputStream = minioClientFacade.getObject(blobId); } catch (InvalidBucketNameException | NoSuchAlgorithmException | InsufficientDataException | InvalidKeyException | NoResponseException | XmlPullParserException | ErrorResponseException | InternalException | InvalidArgumentException e) { throw new UncheckedIOException(new IOException(e)); } catch (IOException e) { throw new UncheckedIOException(e); } return Channels.newChannel(inputStream); } MinioBlobStore(MinioClientFacade minioClientFacade, IdGenerator idGenerator); @Override BlobMetadata store(ReadableByteChannel fromChannel); @Override void delete(String blobId); @Override ReadableByteChannel newChannel(String blobId); }### Answer:
@Test void testNewChannel() throws IOException, InvalidKeyException, NoSuchAlgorithmException, InsufficientDataException, InvalidArgumentException, InternalException, NoResponseException, InvalidBucketNameException, XmlPullParserException, ErrorResponseException { String blobId = "MyBlobId"; InputStream inputStream = mock(InputStream.class); when(minioClientFacade.getObject(blobId)).thenReturn(inputStream); assertDoesNotThrow(() -> minioBlobStore.newChannel(blobId)); }
|
### Question:
MinioClientFactoryImpl implements MinioClientFactory { MinioClientFactoryImpl( String bucketName, String endpoint, String accessKey, String secretKey, @Nullable String region) { this.bucketName = requireNonNull(bucketName); this.minioEndpoint = requireNonNull(endpoint); this.minioAccessKey = requireNonNull(accessKey); this.minioSecretKey = requireNonNull(secretKey); this.region = region; } MinioClientFactoryImpl(
String bucketName,
String endpoint,
String accessKey,
String secretKey,
@Nullable String region); @Override @Retryable( value = {IOException.class}, maxAttempts = 10, backoff = @Backoff(delay = 1000, multiplier = 2.0)) MinioClient createClient(); }### Answer:
@Test void testMinioClientFactoryImpl() { assertThrows( NullPointerException.class, () -> new MinioClientFactoryImpl(null, null, null, null, null)); }
|
### Question:
MinioClientFactoryImpl implements MinioClientFactory { @Override @Retryable( value = {IOException.class}, maxAttempts = 10, backoff = @Backoff(delay = 1000, multiplier = 2.0)) public MinioClient createClient() throws IOException { MinioClient minioClient; try { minioClient = new MinioClient(minioEndpoint, minioAccessKey, minioSecretKey, region); } catch (InvalidEndpointException | InvalidPortException e) { throw new IllegalArgumentException(e); } LOG.debug("Connecting to Minio on '{}' ...", minioEndpoint); createBucketIfNotExists(minioClient, bucketName, region); LOG.info("Connected to Minio on '{}'", minioEndpoint); return minioClient; } MinioClientFactoryImpl(
String bucketName,
String endpoint,
String accessKey,
String secretKey,
@Nullable String region); @Override @Retryable( value = {IOException.class}, maxAttempts = 10, backoff = @Backoff(delay = 1000, multiplier = 2.0)) MinioClient createClient(); }### Answer:
@Test void testCreateClient() { assertThrows(IOException.class, () -> minioClientFactoryImpl.createClient()); }
|
### Question:
JsonValidator { public Schema loadSchema(String schema) { try { JSONObject rawSchema = new JSONObject(new JSONTokener(schema)); return SchemaLoader.load(rawSchema); } catch (JSONException | SchemaException e) { throw new InvalidJsonSchemaException(e); } } Schema loadSchema(String schema); void validate(String json, Schema schema); void validate(String json, String schemaJson); }### Answer:
@Test void testLoadSchemaInvalid() { assertThrows(InvalidJsonSchemaException.class, () -> jsonValidator.loadSchema("")); }
|
### Question:
UriValidator { public static URI getSafeUri(String fileLocation) throws UnknownHostException, URISyntaxException { URI uri = new URI(fileLocation); InetAddress inetAddress = InetAddress.getByName(uri.getHost()); if (!uri.isAbsolute()) { throw new RelativePathNotAllowedException(); } if (inetAddress.isAnyLocalAddress() || inetAddress.isLoopbackAddress() || inetAddress.isLinkLocalAddress()) { throw new LocalhostNotAllowedException(); } return uri; } private UriValidator(); static URI getSafeUri(String fileLocation); }### Answer:
@Test void testIllegalPath() { assertThrows( RelativePathNotAllowedException.class, () -> UriValidator.getSafeUri("/path/to/file1.txt")); }
@Test void testIllegalPath2() { assertThrows( RelativePathNotAllowedException.class, () -> UriValidator.getSafeUri("../path/to/file1.txt")); }
@Test void testIllegalPath3() { assertThrows( RelativePathNotAllowedException.class, () -> UriValidator.getSafeUri("/path/to/../../../file1.txt")); }
@Test void testLocalhost() { assertThrows( LocalhostNotAllowedException.class, () -> UriValidator.getSafeUri("http: }
@Test void testLocalhost2() { assertThrows( LocalhostNotAllowedException.class, () -> UriValidator.getSafeUri("https: }
@Test void testValid1() throws UnknownHostException, URISyntaxException { URI actual = UriValidator.getSafeUri("ftp: URI expected = new URI("ftp: assertEquals(expected, actual); }
@Test void testValid2() throws URISyntaxException, UnknownHostException { URI actual = UriValidator.getSafeUri("https: URI expected = new URI("https: assertEquals(expected, actual); }
@Test void testValid3() throws URISyntaxException, UnknownHostException { URI actual = UriValidator.getSafeUri("http: URI expected = new URI("http: assertEquals(expected, actual); }
|
### Question:
ScheduledJobRepositoryDecorator extends AbstractRepositoryDecorator<ScheduledJob> { @Override public void update(ScheduledJob scheduledJob) { validateJobParameters(scheduledJob); setUsername(scheduledJob); delegate().update(scheduledJob); scheduler.schedule(scheduledJob); } ScheduledJobRepositoryDecorator(
Repository<ScheduledJob> delegateRepository,
JobScheduler scheduler,
JsonValidator jsonValidator); @Override void update(ScheduledJob scheduledJob); @Override void update(Stream<ScheduledJob> scheduledJobs); @Override void delete(ScheduledJob scheduledJob); @Override void delete(Stream<ScheduledJob> jobs); @Override void deleteById(Object id); @Override void deleteAll(Stream<Object> ids); @Override void deleteAll(); @Override void add(ScheduledJob scheduledJob); @Override Integer add(Stream<ScheduledJob> jobs); }### Answer:
@Test void testUpdate() { ScheduledJobType scheduledJobType = mock(ScheduledJobType.class); when(scheduledJobType.getSchema()).thenReturn(SCHEMA); when(scheduledJob.getParameters()).thenReturn(PARAMETERS); when(scheduledJob.getType()).thenReturn(scheduledJobType); scheduledJobRepositoryDecorator.update(scheduledJob); verify(jsonValidator).validate(PARAMETERS, SCHEMA); verify(delegateRepository).update(scheduledJob); verify(jobScheduler).schedule(scheduledJob); }
@Test @WithMockUser("other_user") void testSetUsernameUpdate() { ScheduledJobType scheduledJobType = mock(ScheduledJobType.class); when(scheduledJobType.getSchema()).thenReturn(SCHEMA); when(scheduledJob.getParameters()).thenReturn(PARAMETERS); when(scheduledJob.getType()).thenReturn(scheduledJobType); scheduledJobRepositoryDecorator.update(scheduledJob); verify(scheduledJob).setUser("other_user"); }
|
### Question:
ScheduledJobRepositoryDecorator extends AbstractRepositoryDecorator<ScheduledJob> { @Override public void add(ScheduledJob scheduledJob) { validateJobParameters(scheduledJob); setUsername(scheduledJob); delegate().add(scheduledJob); scheduler.schedule(scheduledJob); } ScheduledJobRepositoryDecorator(
Repository<ScheduledJob> delegateRepository,
JobScheduler scheduler,
JsonValidator jsonValidator); @Override void update(ScheduledJob scheduledJob); @Override void update(Stream<ScheduledJob> scheduledJobs); @Override void delete(ScheduledJob scheduledJob); @Override void delete(Stream<ScheduledJob> jobs); @Override void deleteById(Object id); @Override void deleteAll(Stream<Object> ids); @Override void deleteAll(); @Override void add(ScheduledJob scheduledJob); @Override Integer add(Stream<ScheduledJob> jobs); }### Answer:
@Test @WithMockUser("admin") void testSetUsernameAdd() { ScheduledJobType scheduledJobType = mock(ScheduledJobType.class); when(scheduledJobType.getSchema()).thenReturn(SCHEMA); when(scheduledJob.getParameters()).thenReturn(PARAMETERS); when(scheduledJob.getType()).thenReturn(scheduledJobType); scheduledJobRepositoryDecorator.add(scheduledJob); verify(scheduledJob).setUser("admin"); }
|
### Question:
JobScheduler { public synchronized void runNow(String scheduledJobId) { ScheduledJob scheduledJob = getJob(scheduledJobId); try { JobKey jobKey = new JobKey(scheduledJobId, SCHEDULED_JOB_GROUP); if (quartzScheduler.checkExists(jobKey)) { quartzScheduler.triggerJob(jobKey); } else { Trigger trigger = newTrigger().withIdentity(scheduledJobId, SCHEDULED_JOB_GROUP).startNow().build(); schedule(scheduledJob, trigger); } } catch (SchedulerException e) { LOG.error("Error runNow ScheduledJob", e); throw new MolgenisDataException("Error job runNow", e); } } JobScheduler(Scheduler quartzScheduler, DataService dataService); synchronized void runNow(String scheduledJobId); synchronized void schedule(ScheduledJob scheduledJob); void scheduleJobs(); }### Answer:
@Test void runNow() throws SchedulerException { when(dataService.findOneById(SCHEDULED_JOB, id, ScheduledJob.class)).thenReturn(scheduledJob); when(quartzScheduler.checkExists(jobKey)).thenReturn(false); jobScheduler.runNow(id); verify(quartzScheduler) .scheduleJob(ArgumentMatchers.any(JobDetail.class), ArgumentMatchers.any(Trigger.class)); }
@Test void runNowUnknownEntity() { when(dataService.findOneById(SCHEDULED_JOB, id)).thenReturn(null); Exception exception = assertThrows(UnknownEntityException.class, () -> jobScheduler.runNow(id)); assertThat(exception.getMessage()) .containsPattern("type:sys_job_ScheduledJob id:id attribute:null"); }
@Test void runNowExists() throws SchedulerException { when(dataService.findOneById(SCHEDULED_JOB, id, ScheduledJob.class)).thenReturn(scheduledJob); when(quartzScheduler.checkExists(jobKey)).thenReturn(true); jobScheduler.runNow(id); verify(quartzScheduler).triggerJob(jobKey); }
|
### Question:
EntityReferenceResolverDecorator extends AbstractRepositoryDecorator<Entity> { @Override public Iterator<Entity> iterator() { Stream<Entity> entities = delegate().findAll(new QueryImpl<>()); return resolveEntityReferences(entities).iterator(); } EntityReferenceResolverDecorator(
Repository<Entity> delegateRepository, EntityManager entityManager); @Override Stream<Entity> findAll(Query<Entity> q); @Override Entity findOne(Query<Entity> q); @Override Iterator<Entity> iterator(); @Override void forEachBatched(Fetch fetch, Consumer<List<Entity>> consumer, int batchSize); @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); }### Answer:
@Test void iterator() { when(delegateRepository.getEntityType()).thenReturn(entityType); QueryImpl<Entity> q = new QueryImpl<>(); Stream<Entity> entities = Stream.of(mock(Entity.class)); when(delegateRepository.findAll(q)).thenReturn(entities); when(entityManager.resolveReferences(entityType, entities, null)).thenReturn(entities); entityReferenceResolverDecorator.iterator(); verify(delegateRepository, times(1)).findAll(q); verify(entityManager).resolveReferences(entityType, entities, null); }
|
### Question:
JobScheduler { synchronized void unschedule(String scheduledJobId) { try { quartzScheduler.deleteJob(new JobKey(scheduledJobId, SCHEDULED_JOB_GROUP)); } catch (SchedulerException e) { String message = format("Error deleting ScheduledJob ''{0}''", scheduledJobId); LOG.error(message, e); throw new ScheduledJobException(message, e); } } JobScheduler(Scheduler quartzScheduler, DataService dataService); synchronized void runNow(String scheduledJobId); synchronized void schedule(ScheduledJob scheduledJob); void scheduleJobs(); }### Answer:
@Test void unschedule() throws SchedulerException { String id = "id"; when(dataService.findOneById(SCHEDULED_JOB, id, ScheduledJob.class)).thenReturn(scheduledJob); jobScheduler.unschedule(id); verify(quartzScheduler).deleteJob((jobKey)); }
|
### Question:
JobExecutor { public JobExecutor( DataService dataService, EntityManager entityManager, ExecutorService executorService, JobFactoryRegistry jobFactoryRegistry, JobExecutionContextFactory jobExecutionContextFactory, JobExecutionRegistry jobExecutionRegistry) { this.dataService = requireNonNull(dataService); this.entityManager = requireNonNull(entityManager); this.executorService = requireNonNull(executorService); this.jobFactoryRegistry = requireNonNull(jobFactoryRegistry); this.jobExecutionContextFactory = requireNonNull(jobExecutionContextFactory); this.jobExecutionRegistry = requireNonNull(jobExecutionRegistry); this.jobExecutionTemplate = new JobExecutionTemplate(); this.gson = new Gson(); } JobExecutor(
DataService dataService,
EntityManager entityManager,
ExecutorService executorService,
JobFactoryRegistry jobFactoryRegistry,
JobExecutionContextFactory jobExecutionContextFactory,
JobExecutionRegistry jobExecutionRegistry); @RunAsSystem void executeScheduledJob(String scheduledJobId); CompletableFuture<Void> submit(JobExecution jobExecution); CompletableFuture<Void> submit(
JobExecution jobExecution, ExecutorService executorService); void cancel(JobExecution jobExecution); }### Answer:
@Test void testJobExecutor() { assertThrows( NullPointerException.class, () -> new JobExecutor(null, null, null, null, null, null)); }
|
### Question:
JobExecutor { public void cancel(JobExecution jobExecution) { Progress progress = jobExecutionRegistry.getJobExecutionProgress(jobExecution); progress.canceling(); } JobExecutor(
DataService dataService,
EntityManager entityManager,
ExecutorService executorService,
JobFactoryRegistry jobFactoryRegistry,
JobExecutionContextFactory jobExecutionContextFactory,
JobExecutionRegistry jobExecutionRegistry); @RunAsSystem void executeScheduledJob(String scheduledJobId); CompletableFuture<Void> submit(JobExecution jobExecution); CompletableFuture<Void> submit(
JobExecution jobExecution, ExecutorService executorService); void cancel(JobExecution jobExecution); }### Answer:
@Test void testCancel() { JobExecution jobExecution = mock(JobExecution.class); Progress progress = mock(Progress.class); when(jobExecutionRegistry.getJobExecutionProgress(jobExecution)).thenReturn(progress); jobExecutor.cancel(jobExecution); verify(progress).canceling(); }
|
### Question:
JobExecutorLocaleServiceImpl implements JobExecutorLocaleService { JobExecutorLocaleServiceImpl(UserLocaleResolver userLocaleResolver) { this.userLocaleResolver = requireNonNull(userLocaleResolver); } JobExecutorLocaleServiceImpl(UserLocaleResolver userLocaleResolver); @Override Locale createLocale(JobExecution jobExecution); }### Answer:
@Test void testJobExecutorLocaleServiceImpl() { assertThrows(NullPointerException.class, () -> new JobExecutorLocaleServiceImpl(null)); }
|
### Question:
JobExecutorLocaleServiceImpl implements JobExecutorLocaleService { @Override public Locale createLocale(JobExecution jobExecution) { return jobExecution .getUser() .map(userLocaleResolver::resolveLocale) .orElseGet(Locale::getDefault); } JobExecutorLocaleServiceImpl(UserLocaleResolver userLocaleResolver); @Override Locale createLocale(JobExecution jobExecution); }### Answer:
@Test void testCreateLocaleUser() { String username = "MyUsername"; JobExecution jobExecution = when(mock(JobExecution.class).getUser()).thenReturn(Optional.of(username)).getMock(); Locale locale = Locale.getDefault(); when(userLocaleResolver.resolveLocale(username)).thenReturn(locale); assertEquals(locale, jobExecutorLocaleServiceImpl.createLocale(jobExecution)); }
@Test void testCreateLocaleSystem() { Locale locale = Locale.getDefault(); JobExecution jobExecution = mock(JobExecution.class); assertEquals(locale, jobExecutorLocaleServiceImpl.createLocale(jobExecution)); }
|
### Question:
JobExecutionRepositoryDecorator extends AbstractRepositoryDecorator<JobExecution> { JobExecutionRepositoryDecorator(Repository<JobExecution> delegateRepository) { super(delegateRepository); } JobExecutionRepositoryDecorator(Repository<JobExecution> delegateRepository); @Override void delete(JobExecution jobExecution); @Override void deleteById(Object id); @Override void deleteAll(); @Override void delete(Stream<JobExecution> jobExecutionStream); @Override void deleteAll(Stream<Object> ids); }### Answer:
@Test void testJobExecutionRepositoryDecorator() { assertThrows(NullPointerException.class, () -> new JobExecutionRepositoryDecorator(null)); }
|
### Question:
JobExecutionRepositoryDecorator extends AbstractRepositoryDecorator<JobExecution> { @Override public void deleteById(Object id) { validateDeleteAllowedById(id); super.deleteById(id); } JobExecutionRepositoryDecorator(Repository<JobExecution> delegateRepository); @Override void delete(JobExecution jobExecution); @Override void deleteById(Object id); @Override void deleteAll(); @Override void delete(Stream<JobExecution> jobExecutionStream); @Override void deleteAll(Stream<Object> ids); }### Answer:
@Test void testDeleteByIdAllowed() { Object jobExecutionId = "myJobExecutionId"; JobExecution jobExecution = mock(JobExecution.class); when(jobExecution.getStatus()).thenReturn(Status.FAILED).getMock(); when(delegateRepository.findOneById(jobExecutionId)).thenReturn(jobExecution); jobExecutionRepositoryDecorator.deleteById(jobExecutionId); verify(delegateRepository).deleteById(jobExecutionId); }
@Test void testDeleteByIdForbidden() { Object jobExecutionId = "myJobExecutionId"; JobExecution jobExecution = mock(JobExecution.class); when(jobExecution.getStatus()).thenReturn(Status.RUNNING).getMock(); when(delegateRepository.findOneById(jobExecutionId)).thenReturn(jobExecution); assertThrows( ActiveJobExecutionDeleteForbiddenException.class, () -> jobExecutionRepositoryDecorator.deleteById(jobExecutionId)); }
@Test void testDeleteByIdUnknownJobExecution() { EntityType entityType = mock(EntityType.class); when(delegateRepository.getEntityType()).thenReturn(entityType); Object jobExecutionId = "unknownJobExecutionId"; assertThrows( UnknownEntityException.class, () -> jobExecutionRepositoryDecorator.deleteById(jobExecutionId)); }
|
### Question:
JobUtils { public static void cleanupAfterRunJob(long callingThreadId) { if (Thread.currentThread().getId() == callingThreadId) { return; } SecurityContextHolder.clearContext(); LocaleContextHolder.resetLocaleContext(); } private JobUtils(); static void cleanupAfterRunJob(long callingThreadId); }### Answer:
@Test @WithMockUser void cleanupAfterRunJobCallingThreadId() { JobUtils.cleanupAfterRunJob(Thread.currentThread().getId()); assertNotNull(SecurityContextHolder.getContext().getAuthentication()); }
@Test @WithMockUser void cleanupAfterRunJobNonCallingThreadId() { JobUtils.cleanupAfterRunJob(Thread.currentThread().getId() + 1); assertNull(SecurityContextHolder.getContext().getAuthentication()); }
|
### Question:
JobExecutionUriUtils { public static String getUriPath(JobExecution jobExecution) { return ServletUriComponentsBuilder.fromCurrentRequestUri() .encode() .replacePath(null) .pathSegment( "api", "v2", jobExecution.getEntityType().getId(), jobExecution.getIdValue().toString()) .build() .getPath(); } private JobExecutionUriUtils(); static String getUriPath(JobExecution jobExecution); }### Answer:
@Test void testGetUriPath() { EntityType entityType = mock(EntityType.class); when(entityType.getId()).thenReturn("MyJobExecutionEntityType"); JobExecution jobExecution = mock(JobExecution.class); when(jobExecution.getEntityType()).thenReturn(entityType); when(jobExecution.getIdValue()).thenReturn("MyJobExecutionId"); assertEquals("/api/v2/MyJobExecutionEntityType/MyJobExecutionId", getUriPath(jobExecution)); }
|
### Question:
ProgressCancellationDecorator extends ForwardingObject implements Progress { ProgressCancellationDecorator(Progress delegateProgress) { this.delegateProgress = requireNonNull(delegateProgress); } ProgressCancellationDecorator(Progress delegateProgress); @Override void start(); @Override void setProgressMax(int max); @Override void progress(int progress, String message); @Override void increment(int amount); @Override void status(String message); @Override void failed(String message, @CheckForNull @Nullable Throwable throwable); @Override void canceled(); @Override void success(); @Override Long timeRunning(); @Override void setResultUrl(String string); @Override JobExecution getJobExecution(); @Override void canceling(); }### Answer:
@Test void testProgressCancellationDecorator() { assertThrows(NullPointerException.class, () -> new ProgressCancellationDecorator(null)); }
|
### Question:
ProgressCancellationDecorator extends ForwardingObject implements Progress { @Override protected Object delegate() { return delegateProgress; } ProgressCancellationDecorator(Progress delegateProgress); @Override void start(); @Override void setProgressMax(int max); @Override void progress(int progress, String message); @Override void increment(int amount); @Override void status(String message); @Override void failed(String message, @CheckForNull @Nullable Throwable throwable); @Override void canceled(); @Override void success(); @Override Long timeRunning(); @Override void setResultUrl(String string); @Override JobExecution getJobExecution(); @Override void canceling(); }### Answer:
@Test void testDelegate() { assertEquals(delegateProgress, progressCancellationDecorator.delegate()); }
|
### Question:
ProgressCancellationDecorator extends ForwardingObject implements Progress { @Override public void start() { delegateProgress.start(); verifyCancelJob(); } ProgressCancellationDecorator(Progress delegateProgress); @Override void start(); @Override void setProgressMax(int max); @Override void progress(int progress, String message); @Override void increment(int amount); @Override void status(String message); @Override void failed(String message, @CheckForNull @Nullable Throwable throwable); @Override void canceled(); @Override void success(); @Override Long timeRunning(); @Override void setResultUrl(String string); @Override JobExecution getJobExecution(); @Override void canceling(); }### Answer:
@Test void testStart() { progressCancellationDecorator.start(); verify(delegateProgress).start(); }
|
### Question:
ProgressCancellationDecorator extends ForwardingObject implements Progress { @Override public void setProgressMax(int max) { delegateProgress.setProgressMax(max); verifyCancelJob(); } ProgressCancellationDecorator(Progress delegateProgress); @Override void start(); @Override void setProgressMax(int max); @Override void progress(int progress, String message); @Override void increment(int amount); @Override void status(String message); @Override void failed(String message, @CheckForNull @Nullable Throwable throwable); @Override void canceled(); @Override void success(); @Override Long timeRunning(); @Override void setResultUrl(String string); @Override JobExecution getJobExecution(); @Override void canceling(); }### Answer:
@Test void testSetProgressMax() { progressCancellationDecorator.setProgressMax(123); verify(delegateProgress).setProgressMax(123); }
|
### Question:
ProgressCancellationDecorator extends ForwardingObject implements Progress { @Override public void progress(int progress, String message) { verifyCancelJob(); delegateProgress.progress(progress, message); } ProgressCancellationDecorator(Progress delegateProgress); @Override void start(); @Override void setProgressMax(int max); @Override void progress(int progress, String message); @Override void increment(int amount); @Override void status(String message); @Override void failed(String message, @CheckForNull @Nullable Throwable throwable); @Override void canceled(); @Override void success(); @Override Long timeRunning(); @Override void setResultUrl(String string); @Override JobExecution getJobExecution(); @Override void canceling(); }### Answer:
@Test void testProgress() { progressCancellationDecorator.progress(123, "message"); verify(delegateProgress).progress(123, "message"); }
|
### Question:
ProgressCancellationDecorator extends ForwardingObject implements Progress { @Override public void increment(int amount) { verifyCancelJob(); delegateProgress.increment(amount); } ProgressCancellationDecorator(Progress delegateProgress); @Override void start(); @Override void setProgressMax(int max); @Override void progress(int progress, String message); @Override void increment(int amount); @Override void status(String message); @Override void failed(String message, @CheckForNull @Nullable Throwable throwable); @Override void canceled(); @Override void success(); @Override Long timeRunning(); @Override void setResultUrl(String string); @Override JobExecution getJobExecution(); @Override void canceling(); }### Answer:
@Test void testIncrement() { progressCancellationDecorator.increment(123); verify(delegateProgress).increment(123); }
|
### Question:
ProgressCancellationDecorator extends ForwardingObject implements Progress { @Override public void status(String message) { verifyCancelJob(); delegateProgress.status(message); } ProgressCancellationDecorator(Progress delegateProgress); @Override void start(); @Override void setProgressMax(int max); @Override void progress(int progress, String message); @Override void increment(int amount); @Override void status(String message); @Override void failed(String message, @CheckForNull @Nullable Throwable throwable); @Override void canceled(); @Override void success(); @Override Long timeRunning(); @Override void setResultUrl(String string); @Override JobExecution getJobExecution(); @Override void canceling(); }### Answer:
@Test void testStatus() { progressCancellationDecorator.status("message"); verify(delegateProgress).status("message"); }
|
### Question:
ProgressCancellationDecorator extends ForwardingObject implements Progress { @Override public void failed(String message, @CheckForNull @Nullable Throwable throwable) { verifyCancelJob(); delegateProgress.failed(message, throwable); } ProgressCancellationDecorator(Progress delegateProgress); @Override void start(); @Override void setProgressMax(int max); @Override void progress(int progress, String message); @Override void increment(int amount); @Override void status(String message); @Override void failed(String message, @CheckForNull @Nullable Throwable throwable); @Override void canceled(); @Override void success(); @Override Long timeRunning(); @Override void setResultUrl(String string); @Override JobExecution getJobExecution(); @Override void canceling(); }### Answer:
@Test void testFailed() { Throwable throwable = mock(Throwable.class); progressCancellationDecorator.failed("message", throwable); verify(delegateProgress).failed("message", throwable); }
|
### Question:
ProgressCancellationDecorator extends ForwardingObject implements Progress { @Override public void canceled() { delegateProgress.canceled(); } ProgressCancellationDecorator(Progress delegateProgress); @Override void start(); @Override void setProgressMax(int max); @Override void progress(int progress, String message); @Override void increment(int amount); @Override void status(String message); @Override void failed(String message, @CheckForNull @Nullable Throwable throwable); @Override void canceled(); @Override void success(); @Override Long timeRunning(); @Override void setResultUrl(String string); @Override JobExecution getJobExecution(); @Override void canceling(); }### Answer:
@Test void testCanceled() { progressCancellationDecorator.canceled(); verify(delegateProgress).canceled(); }
|
### Question:
ProgressCancellationDecorator extends ForwardingObject implements Progress { @Override public void success() { verifyCancelJob(); delegateProgress.success(); } ProgressCancellationDecorator(Progress delegateProgress); @Override void start(); @Override void setProgressMax(int max); @Override void progress(int progress, String message); @Override void increment(int amount); @Override void status(String message); @Override void failed(String message, @CheckForNull @Nullable Throwable throwable); @Override void canceled(); @Override void success(); @Override Long timeRunning(); @Override void setResultUrl(String string); @Override JobExecution getJobExecution(); @Override void canceling(); }### Answer:
@Test void testSuccess() { progressCancellationDecorator.success(); verify(delegateProgress).success(); }
|
### Question:
ProgressCancellationDecorator extends ForwardingObject implements Progress { @Override public Long timeRunning() { return delegateProgress.timeRunning(); } ProgressCancellationDecorator(Progress delegateProgress); @Override void start(); @Override void setProgressMax(int max); @Override void progress(int progress, String message); @Override void increment(int amount); @Override void status(String message); @Override void failed(String message, @CheckForNull @Nullable Throwable throwable); @Override void canceled(); @Override void success(); @Override Long timeRunning(); @Override void setResultUrl(String string); @Override JobExecution getJobExecution(); @Override void canceling(); }### Answer:
@Test void testTimeRunning() { when(delegateProgress.timeRunning()).thenReturn(123L); assertEquals(valueOf(123L), progressCancellationDecorator.timeRunning()); }
|
### Question:
ProgressCancellationDecorator extends ForwardingObject implements Progress { @Override public void setResultUrl(String string) { delegateProgress.setResultUrl(string); } ProgressCancellationDecorator(Progress delegateProgress); @Override void start(); @Override void setProgressMax(int max); @Override void progress(int progress, String message); @Override void increment(int amount); @Override void status(String message); @Override void failed(String message, @CheckForNull @Nullable Throwable throwable); @Override void canceled(); @Override void success(); @Override Long timeRunning(); @Override void setResultUrl(String string); @Override JobExecution getJobExecution(); @Override void canceling(); }### Answer:
@Test void testSetResultUrl() { progressCancellationDecorator.setResultUrl("https: verify(delegateProgress).setResultUrl("https: }
|
### Question:
ProgressCancellationDecorator extends ForwardingObject implements Progress { @Override public JobExecution getJobExecution() { return delegateProgress.getJobExecution(); } ProgressCancellationDecorator(Progress delegateProgress); @Override void start(); @Override void setProgressMax(int max); @Override void progress(int progress, String message); @Override void increment(int amount); @Override void status(String message); @Override void failed(String message, @CheckForNull @Nullable Throwable throwable); @Override void canceled(); @Override void success(); @Override Long timeRunning(); @Override void setResultUrl(String string); @Override JobExecution getJobExecution(); @Override void canceling(); }### Answer:
@Test void testGetJobExecution() { JobExecution jobExecution = mock(JobExecution.class); when(delegateProgress.getJobExecution()).thenReturn(jobExecution); assertEquals(jobExecution, progressCancellationDecorator.getJobExecution()); }
|
### Question:
ProgressCancellationDecorator extends ForwardingObject implements Progress { @Override public void canceling() { delegateProgress.canceling(); cancelOnNextProgressChange = true; } ProgressCancellationDecorator(Progress delegateProgress); @Override void start(); @Override void setProgressMax(int max); @Override void progress(int progress, String message); @Override void increment(int amount); @Override void status(String message); @Override void failed(String message, @CheckForNull @Nullable Throwable throwable); @Override void canceled(); @Override void success(); @Override Long timeRunning(); @Override void setResultUrl(String string); @Override JobExecution getJobExecution(); @Override void canceling(); }### Answer:
@Test void testCanceling() { progressCancellationDecorator.canceling(); verify(delegateProgress).canceling(); }
|
### Question:
JobExecutionTemplate { <T> T call(Job<T> job, Progress progress, JobExecutionContext jobExecutionContext) { return runWithContext(jobExecutionContext, () -> tryCall(job, progress)); } }### Answer:
@Test void testCall() { JobExecutionContext jobExecutionContext = JobExecutionContext.builder().setAuthentication(authentication).setLocale(locale).build(); new JobExecutionTemplate().call(job, progress, jobExecutionContext); verify(progress).start(); verify(progress).success(); }
@SuppressWarnings("deprecation") @Test void testCallCancellation() throws Exception { JobExecutionContext jobExecutionContext = JobExecutionContext.builder().setAuthentication(authentication).setLocale(locale).build(); doThrow(new CancellationException()).when(job).call(progress); assertThrows( JobExecutionException.class, () -> new JobExecutionTemplate().call(job, progress, jobExecutionContext)); verify(progress).canceled(); }
@SuppressWarnings("deprecation") @Test void testCallException() throws Exception { JobExecutionContext jobExecutionContext = JobExecutionContext.builder().setAuthentication(authentication).setLocale(locale).build(); String message = "MyMessage"; Exception exception = new Exception(message); doThrow(exception).when(job).call(progress); assertThrows( JobExecutionException.class, () -> new JobExecutionTemplate().call(job, progress, jobExecutionContext)); verify(progress).start(); verify(progress).failed(message, exception); }
@SuppressWarnings("deprecation") @Test void testCallCodedException() throws Exception { JobExecutionContext jobExecutionContext = JobExecutionContext.builder().setAuthentication(authentication).setLocale(locale).build(); String message = "MyMessage"; String errorCode = "M01"; CodedRuntimeException codedRuntimeException = mock(CodedRuntimeException.class); when(codedRuntimeException.getLocalizedMessage()).thenReturn(message); when(codedRuntimeException.getErrorCode()).thenReturn(errorCode); doThrow(codedRuntimeException).when(job).call(progress); assertThrows( JobExecutionException.class, () -> new JobExecutionTemplate().call(job, progress, jobExecutionContext)); verify(progress).start(); verify(progress).failed("MyMessage (M01)", codedRuntimeException); }
|
### Question:
ProblemExceptionResponseGenerator implements ExceptionResponseGenerator<ResponseEntity<Problem>> { @Override public ExceptionResponseType getType() { return ExceptionResponseType.PROBLEM; } ProblemExceptionResponseGenerator(ContextMessageSource contextMessageSource); @Override ExceptionResponseType getType(); @Override ResponseEntity<Problem> createExceptionResponse(
Exception exception, HttpStatus httpStatus, boolean isDevEnvironment); }### Answer:
@Test void testGetType() { assertEquals(PROBLEM, problemExceptionResponseGenerator.getType()); }
|
### Question:
JobExecutorTokenServiceImpl implements JobExecutorTokenService { JobExecutorTokenServiceImpl( UserDetailsServiceImpl userDetailsServiceImpl, RunAsUserTokenFactory runAsUserTokenFactory) { this.userDetailsServiceImpl = requireNonNull(userDetailsServiceImpl); this.runAsUserTokenFactory = requireNonNull(runAsUserTokenFactory); } JobExecutorTokenServiceImpl(
UserDetailsServiceImpl userDetailsServiceImpl, RunAsUserTokenFactory runAsUserTokenFactory); @Override AbstractAuthenticationToken createToken(JobExecution jobExecution); }### Answer:
@Test void testJobExecutorTokenServiceImpl() { assertThrows(NullPointerException.class, () -> new JobExecutorTokenServiceImpl(null, null)); }
|
### Question:
JobExecutorTokenServiceImpl implements JobExecutorTokenService { @Override public AbstractAuthenticationToken createToken(JobExecution jobExecution) { return jobExecution .getUser() .map(this::createRunAsUsertoken) .orElseGet(SystemSecurityToken::getInstance); } JobExecutorTokenServiceImpl(
UserDetailsServiceImpl userDetailsServiceImpl, RunAsUserTokenFactory runAsUserTokenFactory); @Override AbstractAuthenticationToken createToken(JobExecution jobExecution); }### Answer:
@Test void testCreateTokenUser() { String username = "user"; JobExecution jobExecution = when(mock(JobExecution.class).getUser()).thenReturn(Optional.of(username)).getMock(); UserDetails userDetails = mock(UserDetails.class); when(userDetailsService.loadUserByUsername(username)).thenReturn(userDetails); RunAsUserToken runAsUserToken = mock(RunAsUserToken.class); when(runAsUserTokenFactory.create("Job Execution", userDetails, null)) .thenReturn(runAsUserToken); assertEquals(runAsUserToken, jobExecutorTokenServiceImpl.createToken(jobExecution)); }
@Test void testCreateTokenSystem() { JobExecution jobExecution = mock(JobExecution.class); assertTrue( jobExecutorTokenServiceImpl.createToken(jobExecution) instanceof SystemSecurityToken); }
|
### Question:
ProgressImpl implements Progress { @Override public void canceling() { synchronized (this) { JobExecution currentJobExecution = JobExecutionHolder.get(); if (currentJobExecution == null) { JobExecutionHolder.set(this.jobExecution); } JOB_EXECUTION_LOG.warn("Canceling ..."); if (currentJobExecution == null) { JobExecutionHolder.unset(); } } jobExecution.setStatus(Status.CANCELING); update(); } ProgressImpl(JobExecution jobExecution, JobExecutionUpdater updater, MailSender mailSender); @Override void start(); @Override void progress(int progress, String message); @Override void increment(int amount); @Override void success(); @SuppressWarnings( "java:S2629") // "Preconditions" and logging arguments should not require evaluation @Override void failed(String message, @Nullable @CheckForNull Throwable throwable); @Override void canceling(); @Override void canceled(); @Override Long timeRunning(); @Override void setProgressMax(int max); @Override void status(String message); @Override void setResultUrl(String string); @Override JobExecution getJobExecution(); }### Answer:
@Test void testCanceling() { JobExecution mockJobExecution = mock(JobExecution.class); ProgressImpl progressImpl = new ProgressImpl(mockJobExecution, updater, mailSender); progressImpl.canceling(); verify(mockJobExecution).setStatus(Status.CANCELING); verify(updater).update(mockJobExecution); }
|
### Question:
TagPopulator { public void populate() { Tag isAToken = tagFactory.create("token"); isAToken.setLabel("Token"); isAToken.setObjectIri(TOKEN.toString()); isAToken.setRelationIri(type.getIRI()); isAToken.setRelationLabel(type.getLabel()); Tag isCaseSensitive = tagFactory.create("case-sensitive"); isCaseSensitive.setLabel("Case Sensitive"); isCaseSensitive.setObjectIri(CASE_SENSITIVE.toString()); isCaseSensitive.setRelationIri(type.getIRI()); isCaseSensitive.setRelationLabel(type.getLabel()); dataService.getRepository(TAG, Tag.class).upsertBatch(List.of(isAToken, isCaseSensitive)); } TagPopulator(TagFactory tagFactory, DataService dataService); void populate(); }### Answer:
@Test public void testPopulate() { when(tagFactory.create("token")).thenReturn(token); when(tagFactory.create("case-sensitive")).thenReturn(caseSensitive); when(dataService.getRepository(TagMetadata.TAG, Tag.class)).thenReturn(tagRepository); tagPopulator.populate(); verify(tagRepository).upsertBatch(List.of(token, caseSensitive)); verify(token).setRelationIri(RDF.TYPE.toString()); verify(token).setObjectIri(XMLSchema.TOKEN.toString()); verify(caseSensitive).setRelationIri(RDF.TYPE.toString()); verify(caseSensitive).setObjectIri(Vocabulary.CASE_SENSITIVE.toString()); }
|
### Question:
PermissionPopulator { PermissionPopulator(PermissionService permissionService) { this.permissionService = requireNonNull(permissionService); } PermissionPopulator(PermissionService permissionService); @Transactional void populate(ApplicationContext applicationContext); }### Answer:
@Test void testPermissionPopulator() { assertThrows(NullPointerException.class, () -> new PermissionPopulator(null)); }
|
### Question:
PermissionPopulator { @Transactional public void populate(ApplicationContext applicationContext) { Collection<PermissionRegistry> registries = applicationContext.getBeansOfType(PermissionRegistry.class).values(); registries.forEach(this::populate); } PermissionPopulator(PermissionService permissionService); @Transactional void populate(ApplicationContext applicationContext); }### Answer:
@Test void testPopulate() { ApplicationContext applicationContext = mock(ApplicationContext.class); ObjectIdentity objectIdentity0 = new ObjectIdentityImpl("type", "id0"); PermissionRegistry permissionRegistry0 = mock(PermissionRegistry.class); Multimap<ObjectIdentity, Pair<PermissionSet, Sid>> registry0Permissions = ArrayListMultimap.create(); Sid sid0 = mock(Sid.class); registry0Permissions.put(objectIdentity0, new Pair<>(PermissionSet.COUNT, sid0)); when(permissionRegistry0.getPermissions()).thenReturn(registry0Permissions); ObjectIdentity objectIdentity1 = new ObjectIdentityImpl("type", "id1"); Multimap<ObjectIdentity, Pair<PermissionSet, Sid>> registry1Permissions = ArrayListMultimap.create(); Sid sid1 = mock(Sid.class); registry1Permissions.put(objectIdentity1, new Pair<>(PermissionSet.READ, sid1)); PermissionRegistry permissionRegistry1 = mock(PermissionRegistry.class); when(permissionRegistry1.getPermissions()).thenReturn(registry1Permissions); Map<String, PermissionRegistry> registryMap = new LinkedHashMap<>(); registryMap.put("registry0", permissionRegistry0); registryMap.put("registry1", permissionRegistry1); when(applicationContext.getBeansOfType(PermissionRegistry.class)).thenReturn(registryMap); permissionPopulator.populate(applicationContext); verify(permissionService) .createPermission(Permission.create(objectIdentity0, sid0, PermissionSet.COUNT)); verify(permissionService) .createPermission(Permission.create(objectIdentity1, sid1, PermissionSet.READ)); }
|
### Question:
BootstrapperListener implements ApplicationListener<ContextRefreshedEvent>, PriorityOrdered { @Timed(value = "bootstrap", description = "Timing information for the bootstrapping event.") @Override public void onApplicationEvent(ContextRefreshedEvent event) { if (event.getApplicationContext().getParent() != null) { return; } bootstrapper.bootstrap(event); SecurityContextHolder.clearContext(); } BootstrapperListener(Bootstrapper bootstrapper); @Timed(value = "bootstrap", description = "Timing information for the bootstrapping event.") @Override void onApplicationEvent(ContextRefreshedEvent event); @Override int getOrder(); }### Answer:
@Test void testOnApplicationEventParent() { ApplicationContext applicationContext = mock(ApplicationContext.class); ContextRefreshedEvent contextRefreshedEvent = mock(ContextRefreshedEvent.class); when(contextRefreshedEvent.getApplicationContext()).thenReturn(applicationContext); bootstrapperListener.onApplicationEvent(contextRefreshedEvent); verify(bootstrapper).bootstrap(contextRefreshedEvent); }
@Test void testOnApplicationEventChild() { ApplicationContext parentApplicationContext = mock(ApplicationContext.class); ApplicationContext applicationContext = mock(ApplicationContext.class); when(applicationContext.getParent()).thenReturn(parentApplicationContext); ContextRefreshedEvent contextRefreshedEvent = mock(ContextRefreshedEvent.class); when(contextRefreshedEvent.getApplicationContext()).thenReturn(applicationContext); bootstrapperListener.onApplicationEvent(contextRefreshedEvent); verifyNoInteractions(bootstrapper); }
|
### Question:
BootstrapperListener implements ApplicationListener<ContextRefreshedEvent>, PriorityOrdered { @Override public int getOrder() { return HIGHEST_PRECEDENCE; } BootstrapperListener(Bootstrapper bootstrapper); @Timed(value = "bootstrap", description = "Timing information for the bootstrapping event.") @Override void onApplicationEvent(ContextRefreshedEvent event); @Override int getOrder(); }### Answer:
@Test void testGetOrder() { assertEquals(Ordered.HIGHEST_PRECEDENCE, bootstrapperListener.getOrder()); }
|
### Question:
AlgorithmTemplateServiceImpl implements AlgorithmTemplateService { @Override public Stream<AlgorithmTemplate> find(Hits<ExplainedAttribute> attrMatches) { Stream<Script> jsScripts = dataService.findAll( SCRIPT, new QueryImpl<Script>().eq(TYPE, JsMagmaScriptRunner.NAME), Script.class); return jsScripts.flatMap(script -> toAlgorithmTemplate(script, attrMatches)); } AlgorithmTemplateServiceImpl(DataService dataService); @Override Stream<AlgorithmTemplate> find(Hits<ExplainedAttribute> attrMatches); }### Answer:
@Test public void find() { String sourceAttr0Name = "sourceAttr0"; String sourceAttr1Name = "sourceAttr1"; EntityType sourceEntityMeta = entityTypeFactory.create("source"); Attribute sourceAttr0 = attrMetaFactory.create().setName(sourceAttr0Name); Attribute sourceAttr1 = attrMetaFactory.create().setName(sourceAttr1Name); sourceEntityMeta.addAttribute(sourceAttr0); sourceEntityMeta.addAttribute(sourceAttr1); ExplainedQueryString sourceAttr0Explain = ExplainedQueryString.create("a", "b", param0Name, 1.0); ExplainedQueryString sourceAttr1Explain = ExplainedQueryString.create("a", "b", param1Name, 0.5); Hits<ExplainedAttribute> attrResults = Hits.create( Hit.create( ExplainedAttribute.create(sourceAttr0, singleton(sourceAttr0Explain), false), 1f), Hit.create( ExplainedAttribute.create(sourceAttr1, singleton(sourceAttr1Explain), false), 1f)); Stream<AlgorithmTemplate> templateStream = algorithmTemplateServiceImpl.find(attrResults); Map<String, String> model = Maps.newHashMap(); model.put(param0Name, sourceAttr0Name); model.put(param1Name, sourceAttr1Name); AlgorithmTemplate expectedAlgorithmTemplate = new AlgorithmTemplate(script0, model); assertEquals(of(expectedAlgorithmTemplate).collect(toList()), templateStream.collect(toList())); }
|
### Question:
UnitResolverImpl implements UnitResolver { String convertNumberToOntologyTermStyle(String term) { term = UnitHelper.superscriptToNumber(term.replaceAll("\\^", StringUtils.EMPTY)); Pattern pattern = Pattern.compile("\\w+(\\d+)"); Matcher matcher = pattern.matcher(term); if (matcher.find()) { String group = matcher.group(1); String modifiedPart = group.trim(); modifiedPart = "^[" + modifiedPart + "]"; term = term.replaceAll(group, modifiedPart); } return QueryParser.escape(term); } UnitResolverImpl(OntologyService ontologyService); @Override Unit<? extends Quantity> resolveUnit(Attribute attr); }### Answer:
@Test void testConvertNumberToOntologyTermStyle() { assertEquals("kg\\/m\\^\\[2\\]", unitResolverImpl.convertNumberToOntologyTermStyle("kg/m^2")); assertEquals("kg\\/m\\^\\[2\\]", unitResolverImpl.convertNumberToOntologyTermStyle("kg/m^²")); assertEquals("kg\\/m\\^\\[2\\]", unitResolverImpl.convertNumberToOntologyTermStyle("kg/m²")); }
|
### Question:
UnitResolverImpl implements UnitResolver { Set<String> tokenize(String... terms) { Set<String> tokens = new HashSet<>(); if (terms != null && terms.length > 0) { Sets.newHashSet(terms).stream() .filter(StringUtils::isNotBlank) .map(StringUtils::lowerCase) .map(this::replaceIllegalChars) .forEach( term -> tokens.addAll( Sets.newHashSet(term.split("\\s+")).stream() .filter(this::notPureNumberExpression) .map(UnitHelper::numberToSuperscript) .collect(Collectors.toSet()))); tokens.removeAll(NGramDistanceAlgorithm.STOPWORDSLIST); } return tokens; } UnitResolverImpl(OntologyService ontologyService); @Override Unit<? extends Quantity> resolveUnit(Attribute attr); }### Answer:
@Test void testTokenize() { Set<String> tokenize = unitResolverImpl.tokenize("area density (kg/m^²)"); assertTrue(newHashSet("area", "density", "kg/m^²").containsAll(tokenize)); Set<String> tokenize1 = unitResolverImpl.tokenize("area density (kg/m^2)"); assertTrue(newHashSet("area", "density", "kg/m^²").containsAll(tokenize1)); Set<String> tokenize2 = unitResolverImpl.tokenize("area density (kg/m2)"); assertTrue(newHashSet("area", "density", "kg/m²").containsAll(tokenize2)); Set<String> tokenize3 = unitResolverImpl.tokenize("area 2 density2 (kg/m2)"); assertTrue(newHashSet("area", "density²", "kg/m²").containsAll(tokenize3)); Set<String> tokenize4 = unitResolverImpl.tokenize("area 2 density 2 (kg/m2)"); assertEquals(3, tokenize4.size()); assertFalse(tokenize4.containsAll(newHashSet("area", "density", "²", "kg/m²"))); }
|
### Question:
UnitResolverImpl implements UnitResolver { boolean isUnitEmpty(Unit<? extends Quantity> unit) { return unit == null || StringUtils.isBlank(unit.toString()); } UnitResolverImpl(OntologyService ontologyService); @Override Unit<? extends Quantity> resolveUnit(Attribute attr); }### Answer:
@Test void testIsUnitEmpty() { Unit<?> unit = Unit.valueOf(""); Unit<?> unit1 = Unit.valueOf("¹"); Unit<?> unitKg = Unit.valueOf("kg"); assertTrue(unitResolverImpl.isUnitEmpty(null)); assertTrue(unitResolverImpl.isUnitEmpty(unit)); assertTrue(unitResolverImpl.isUnitEmpty(unit1)); assertFalse(unitResolverImpl.isUnitEmpty(unitKg)); }
|
### Question:
UnitResolverImpl implements UnitResolver { String replaceIllegalChars(String term) { return UnitHelper.superscriptToNumber(term).replaceAll("[^a-zA-Z0-9 /\\^]", " "); } UnitResolverImpl(OntologyService ontologyService); @Override Unit<? extends Quantity> resolveUnit(Attribute attr); }### Answer:
@Test void testReplaceIllegalChars() { assertEquals( "area density kg/m^2 ", unitResolverImpl.replaceIllegalChars("area density (kg/m^2)")); assertEquals( "area density kg/m2 ", unitResolverImpl.replaceIllegalChars("area density (kg/m²)")); }
|
### Question:
AlgorithmServiceImpl implements AlgorithmService { public AlgorithmServiceImpl( SemanticSearchService semanticSearchService, AlgorithmGeneratorService algorithmGeneratorService, EntityManager entityManager, JsMagmaScriptEvaluator jsMagmaScriptEvaluator) { this.semanticSearchService = requireNonNull(semanticSearchService); this.algorithmGeneratorService = requireNonNull(algorithmGeneratorService); this.entityManager = requireNonNull(entityManager); this.jsMagmaScriptEvaluator = requireNonNull(jsMagmaScriptEvaluator); } AlgorithmServiceImpl(
SemanticSearchService semanticSearchService,
AlgorithmGeneratorService algorithmGeneratorService,
EntityManager entityManager,
JsMagmaScriptEvaluator jsMagmaScriptEvaluator); @Override String generateAlgorithm(
Attribute targetAttribute,
EntityType targetEntityType,
List<Attribute> sourceAttributes,
EntityType sourceEntityType); @Override void copyAlgorithms(EntityMapping sourceEntityMapping, EntityMapping targetEntityMapping); @Override @RunAsSystem void autoGenerateAlgorithm(
EntityType sourceEntityType, EntityType targetEntityType, EntityMapping mapping); @Override Iterable<AlgorithmEvaluation> applyAlgorithm(
Attribute targetAttribute, String algorithm, Iterable<Entity> sourceEntities, int depth); @Override Object apply(AttributeMapping attributeMapping, Entity sourceEntity, int depth); @Override Collection<String> getSourceAttributeNames(String algorithmScript); }### Answer:
@Test void testAlgorithmServiceImpl() { assertThrows( NullPointerException.class, () -> new AlgorithmServiceImpl(null, null, null, null)); }
|
### Question:
AlgorithmServiceImpl implements AlgorithmService { @Override public Object apply(AttributeMapping attributeMapping, Entity sourceEntity, int depth) { String algorithm = attributeMapping.getAlgorithm(); if (isEmpty(algorithm)) { return null; } Object result = jsMagmaScriptEvaluator.eval(algorithm, sourceEntity, depth); if (result instanceof Throwable) { throw new AlgorithmException((Throwable) result); } return convert(result, attributeMapping.getTargetAttribute()); } AlgorithmServiceImpl(
SemanticSearchService semanticSearchService,
AlgorithmGeneratorService algorithmGeneratorService,
EntityManager entityManager,
JsMagmaScriptEvaluator jsMagmaScriptEvaluator); @Override String generateAlgorithm(
Attribute targetAttribute,
EntityType targetEntityType,
List<Attribute> sourceAttributes,
EntityType sourceEntityType); @Override void copyAlgorithms(EntityMapping sourceEntityMapping, EntityMapping targetEntityMapping); @Override @RunAsSystem void autoGenerateAlgorithm(
EntityType sourceEntityType, EntityType targetEntityType, EntityMapping mapping); @Override Iterable<AlgorithmEvaluation> applyAlgorithm(
Attribute targetAttribute, String algorithm, Iterable<Entity> sourceEntities, int depth); @Override Object apply(AttributeMapping attributeMapping, Entity sourceEntity, int depth); @Override Collection<String> getSourceAttributeNames(String algorithmScript); }### Answer:
@Test void testApplyWithInvalidScript() { AttributeMapping attributeMapping = mock(AttributeMapping.class); String algorithm = "algorithm"; when(attributeMapping.getAlgorithm()).thenReturn(algorithm); Entity sourceEntity = mock(Entity.class); when(jsMagmaScriptEvaluator.eval(algorithm, sourceEntity, 3)) .thenReturn(new ScriptException("algorithm is not defined")); Exception exception = assertThrows( AlgorithmException.class, () -> algorithmServiceImpl.apply(attributeMapping, sourceEntity, 3)); assertThat(exception.getMessage()) .containsPattern("org.molgenis.script.core.ScriptException: algorithm is not defined"); }
|
### Question:
AlgorithmServiceImpl implements AlgorithmService { @Override public void copyAlgorithms(EntityMapping sourceEntityMapping, EntityMapping targetEntityMapping) { sourceEntityMapping .getAttributeMappings() .forEach(attributeMapping -> copyAlgorithm(attributeMapping, targetEntityMapping)); } AlgorithmServiceImpl(
SemanticSearchService semanticSearchService,
AlgorithmGeneratorService algorithmGeneratorService,
EntityManager entityManager,
JsMagmaScriptEvaluator jsMagmaScriptEvaluator); @Override String generateAlgorithm(
Attribute targetAttribute,
EntityType targetEntityType,
List<Attribute> sourceAttributes,
EntityType sourceEntityType); @Override void copyAlgorithms(EntityMapping sourceEntityMapping, EntityMapping targetEntityMapping); @Override @RunAsSystem void autoGenerateAlgorithm(
EntityType sourceEntityType, EntityType targetEntityType, EntityMapping mapping); @Override Iterable<AlgorithmEvaluation> applyAlgorithm(
Attribute targetAttribute, String algorithm, Iterable<Entity> sourceEntities, int depth); @Override Object apply(AttributeMapping attributeMapping, Entity sourceEntity, int depth); @Override Collection<String> getSourceAttributeNames(String algorithmScript); }### Answer:
@Test void testCopyAlgorithms() { EntityMapping sourceEntityMapping = mock(EntityMapping.class); AttributeMapping attributeMapping = mock(AttributeMapping.class); when(attributeMapping.getIdentifier()).thenReturn("MyIdentifier"); when(attributeMapping.getAlgorithmState()).thenReturn(AlgorithmState.CURATED); when(sourceEntityMapping.getAttributeMappings()) .thenReturn(Collections.singletonList(attributeMapping)); EntityMapping targetEntityMapping = mock(EntityMapping.class); algorithmServiceImpl.copyAlgorithms(sourceEntityMapping, targetEntityMapping); ArgumentCaptor<AttributeMapping> attributeMappingCaptor = ArgumentCaptor.forClass(AttributeMapping.class); verify(targetEntityMapping).addAttributeMapping(attributeMappingCaptor.capture()); AttributeMapping attributeMappingCopy = attributeMappingCaptor.getValue(); assertNull(attributeMappingCopy.getIdentifier()); assertEquals(DISCUSS, attributeMappingCopy.getAlgorithmState()); }
|
### Question:
MappingServiceImpl implements MappingService { Entity applyMappingToEntity( EntityMapping sourceMapping, Entity sourceEntity, EntityType targetMetaData, int depth) { Entity target = entityManager.create(targetMetaData, POPULATE); if (targetMetaData.getAttribute(SOURCE) != null) { target.set(SOURCE, sourceMapping.getName()); } sourceMapping .getAttributeMappings() .forEach( attributeMapping -> applyMappingToAttribute(attributeMapping, sourceEntity, target, depth)); return target; } MappingServiceImpl(
DataService dataService,
AlgorithmService algorithmService,
MappingProjectRepository mappingProjectRepository,
PermissionSystemService permissionSystemService,
AttributeFactory attrMetaFactory,
EntityManager entityManager); @Override @Transactional MappingProject addMappingProject(String projectName, String target, int depth); @Override @Transactional void deleteMappingProject(String mappingProjectId); @Override @Transactional MappingProject cloneMappingProject(String mappingProjectId); @Override @Transactional MappingProject cloneMappingProject(
String mappingProjectId, String clonedMappingProjectName); @Override List<MappingProject> getAllMappingProjects(); @Override @Transactional void updateMappingProject(MappingProject mappingProject); @Override MappingProject getMappingProject(String identifier); @Override @Transactional long applyMappings(
String mappingProjectId,
String entityTypeId,
Boolean addSourceAttribute,
String packageId,
String label,
Progress progress); Stream<EntityType> getCompatibleEntityTypes(EntityType target); static final int MAPPING_BATCH_SIZE; }### Answer:
@Test void testApplyMappingToEntity() { EntityMapping entityMapping = mock(EntityMapping.class); Entity sourceEntity = mock(Entity.class); EntityType targetMetaData = mock(EntityType.class); Entity mappedEntity = mock(Entity.class); when(entityManager.create(targetMetaData, EntityManager.CreationMode.POPULATE)) .thenReturn(mappedEntity); assertEquals( mappedEntity, mappingService.applyMappingToEntity(entityMapping, sourceEntity, targetMetaData, 3)); }
|
### Question:
MappingServiceImpl implements MappingService { @Override @Transactional public void updateMappingProject(MappingProject mappingProject) { mappingProjectRepository.update(mappingProject); } MappingServiceImpl(
DataService dataService,
AlgorithmService algorithmService,
MappingProjectRepository mappingProjectRepository,
PermissionSystemService permissionSystemService,
AttributeFactory attrMetaFactory,
EntityManager entityManager); @Override @Transactional MappingProject addMappingProject(String projectName, String target, int depth); @Override @Transactional void deleteMappingProject(String mappingProjectId); @Override @Transactional MappingProject cloneMappingProject(String mappingProjectId); @Override @Transactional MappingProject cloneMappingProject(
String mappingProjectId, String clonedMappingProjectName); @Override List<MappingProject> getAllMappingProjects(); @Override @Transactional void updateMappingProject(MappingProject mappingProject); @Override MappingProject getMappingProject(String identifier); @Override @Transactional long applyMappings(
String mappingProjectId,
String entityTypeId,
Boolean addSourceAttribute,
String packageId,
String label,
Progress progress); Stream<EntityType> getCompatibleEntityTypes(EntityType target); static final int MAPPING_BATCH_SIZE; }### Answer:
@Test void testUpdateMappingProject() { MappingProject mappingProject = mock(MappingProject.class); mappingService.updateMappingProject(mappingProject); Mockito.verifyZeroInteractions(mappingProject); Mockito.verify(mappingProjectRepo).update(mappingProject); }
|
### Question:
UniqueId { public byte[] getId() { if (seq == MAX_SHORT) { throw new RuntimeException("Too fast"); } long time; synchronized (lock) { time = System.currentTimeMillis(); if (time != lastTimestamp) { lastTimestamp = time; seq = 0; } seq++; ByteBuffer bb = ByteBuffer.allocate(16); bb.putLong(time); bb.put(NODE); bb.putShort((short) seq); return bb.array(); } } byte[] getId(); }### Answer:
@Test void testGetId() { UniqueId uniqueId = new UniqueId(); assertNotEquals(uniqueId.getId(), uniqueId.getId()); }
|
### Question:
MappingServiceImpl implements MappingService { public Stream<EntityType> getCompatibleEntityTypes(EntityType target) { return dataService .getMeta() .getEntityTypes() .filter(candidate -> !candidate.isAbstract()) .filter(isCompatible(target)); } MappingServiceImpl(
DataService dataService,
AlgorithmService algorithmService,
MappingProjectRepository mappingProjectRepository,
PermissionSystemService permissionSystemService,
AttributeFactory attrMetaFactory,
EntityManager entityManager); @Override @Transactional MappingProject addMappingProject(String projectName, String target, int depth); @Override @Transactional void deleteMappingProject(String mappingProjectId); @Override @Transactional MappingProject cloneMappingProject(String mappingProjectId); @Override @Transactional MappingProject cloneMappingProject(
String mappingProjectId, String clonedMappingProjectName); @Override List<MappingProject> getAllMappingProjects(); @Override @Transactional void updateMappingProject(MappingProject mappingProject); @Override MappingProject getMappingProject(String identifier); @Override @Transactional long applyMappings(
String mappingProjectId,
String entityTypeId,
Boolean addSourceAttribute,
String packageId,
String label,
Progress progress); Stream<EntityType> getCompatibleEntityTypes(EntityType target); static final int MAPPING_BATCH_SIZE; }### Answer:
@Test void testGetCompatibleEntityTypes() { when(metaDataService.getEntityTypes()).thenReturn(Stream.of(hopMetaData, geneMetaData)); Set<Entity> compatibleEntityTypes = mappingService.getCompatibleEntityTypes(hopMetaData).collect(toSet()); assertEquals(newHashSet(hopMetaData), compatibleEntityTypes); }
|
### Question:
PackageUtils { public static boolean isSystemPackage(@Nullable @CheckForNull Package aPackage) { if (aPackage == null) { return false; } return runAsSystem( () -> aPackage.getId().equals(PACKAGE_SYSTEM) || (aPackage.getRootPackage() != null && aPackage.getRootPackage().getId().equals(PACKAGE_SYSTEM))); } private PackageUtils(); static boolean isSystemPackage(@Nullable @CheckForNull Package aPackage); static boolean contains(Package pack, Package wantedPackage); }### Answer:
@Test void isSystemPackageFalse() { Package package_ = mock(Package.class); when(package_.getId()).thenReturn("notSystem"); assertFalse(PackageUtils.isSystemPackage(package_)); }
@Test void isSystemPackageTrue() { Package package_ = mock(Package.class); when(package_.getId()).thenReturn(PACKAGE_SYSTEM); assertTrue(PackageUtils.isSystemPackage(package_)); }
@Test void isSystemPackageTrueNested() { Package rootPackage_ = mock(Package.class); when(rootPackage_.getId()).thenReturn(PACKAGE_SYSTEM); Package package_ = mock(Package.class); when(package_.getId()).thenReturn("systemChild"); when(package_.getRootPackage()).thenReturn(rootPackage_); assertTrue(PackageUtils.isSystemPackage(package_)); }
|
### Question:
NumericAlgorithmGenerator implements AlgorithmGenerator { String generateUnitConversionAlgorithm(Attribute targetAttribute, Attribute sourceAttribute) { String algorithm = null; Unit<? extends Quantity> targetUnit = unitResolver.resolveUnit(targetAttribute); Unit<? extends Quantity> sourceUnit = unitResolver.resolveUnit(sourceAttribute); if (sourceUnit != null) { if (targetUnit != null && !sourceUnit.equals(targetUnit)) { UnitConverter unitConverter; try { unitConverter = sourceUnit.getConverterTo(targetUnit); } catch (ConversionException e) { unitConverter = null; algorithm = String.format( "$('%s').unit('%s').value();", sourceAttribute.getName(), sourceUnit.toString()); } if (unitConverter != null) { algorithm = String.format( "$('%s').unit('%s').toUnit('%s').value();", sourceAttribute.getName(), sourceUnit.toString(), targetUnit.toString()); } } else { algorithm = String.format( "$('%s').unit('%s').value();", sourceAttribute.getName(), sourceUnit.toString()); } } if (algorithm == null) { algorithm = String.format("$('%s').value();", sourceAttribute.getName()); } return algorithm; } NumericAlgorithmGenerator(UnitResolver unitResolver); String generate(
Attribute targetAttribute,
List<Attribute> sourceAttributes,
EntityType targetEntityType,
EntityType sourceEntityType); boolean isSuitable(Attribute targetAttribute, List<Attribute> sourceAttributes); }### Answer:
@Test void generateUnitConversionAlgorithm() { String generateUnitConversionAlgorithm = numericAlgorithmGenerator.generateUnitConversionAlgorithm(targetAttribute, sourceAttribute); assertEquals( "$('sourceHeight').unit('cm').toUnit('m').value();", generateUnitConversionAlgorithm); }
|
### Question:
NumericAlgorithmGenerator implements AlgorithmGenerator { public boolean isSuitable(Attribute targetAttribute, List<Attribute> sourceAttributes) { return isNumericDataType(targetAttribute) && (sourceAttributes.stream().allMatch(this::isNumericDataType)); } NumericAlgorithmGenerator(UnitResolver unitResolver); String generate(
Attribute targetAttribute,
List<Attribute> sourceAttributes,
EntityType targetEntityType,
EntityType sourceEntityType); boolean isSuitable(Attribute targetAttribute, List<Attribute> sourceAttributes); }### Answer:
@Test void isSuitable() { Attribute stringAttribute = attrMetaFactory.create().setName("source_string"); assertTrue( numericAlgorithmGenerator.isSuitable(targetAttribute, singletonList(sourceAttribute))); assertFalse( numericAlgorithmGenerator.isSuitable( targetAttribute, asList(sourceAttribute, stringAttribute))); }
|
### Question:
OneToOneCategoryAlgorithmGenerator extends AbstractCategoryAlgorithmGenerator { @Override public boolean isSuitable(Attribute targetAttribute, List<Attribute> sourceAttributes) { return isXrefOrCategorialDataType(targetAttribute) && (sourceAttributes.stream().allMatch(this::isXrefOrCategorialDataType)) && sourceAttributes.size() == 1; } OneToOneCategoryAlgorithmGenerator(DataService dataService); @Override boolean isSuitable(Attribute targetAttribute, List<Attribute> sourceAttributes); @Override String generate(
Attribute targetAttribute,
List<Attribute> sourceAttributes,
EntityType targetEntityType,
EntityType sourceEntityType); }### Answer:
@Test void testIsSuitable() { assertTrue( categoryAlgorithmGenerator.isSuitable(targetAttribute, singletonList(sourceAttribute))); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.