Datasets:

Minata
/

512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 184k rows

method2testcases stringlengths 118 3.08k
### Question: ProjectRestServiceImpl extends BaseRestService implements ProjectRestService { @Override public RestResult<OrganisationResource> getLeadOrganisationByProject(long projectId) { return getWithRestResult(format(PROJECT_REST_URL + "%d/lead-organisation", projectId), OrganisationResource.class); } @Override RestResult<ProjectResource> getProjectById(long projectId); RestResult<List<ProjectResource>> findByUserId(long userId); @Override RestResult<List<ProjectUserResource>> getProjectUsersForProject(long projectId); @Override RestResult<List<ProjectUserResource>> getDisplayProjectUsersForProject(long projectId); @Override RestResult<ProjectResource> getByApplicationId(long applicationId); @Override RestResult<OrganisationResource> getOrganisationByProjectAndUser(long projectId, long userId); @Override RestResult<ProjectUserResource> getProjectManager(long projectId); @Override RestResult<List<ProjectUserResource>> getProjectFinanceContacts(long projectId); @Override RestResult<ProjectResource> createProjectFromApplicationId(long applicationId); @Override RestResult<OrganisationResource> getLeadOrganisationByProject(long projectId); @Override RestResult<Boolean> existsOnApplication(long projectId, long organisationId); }### Answer: @Test public void getLeadOrganisationByProject() { long projectId = 17; OrganisationResource organisation = newOrganisationResource().build(); setupGetWithRestResultExpectations(format(PROJECT_REST_URL + "/%d/lead-organisation", projectId), OrganisationResource.class, organisation); OrganisationResource result = service.getLeadOrganisationByProject(projectId).getSuccess(); assertEquals(organisation, result); }
### Question: ProjectStateRestServiceImpl extends BaseRestService implements ProjectStateRestService { @Override public RestResult<Void> withdrawProject(long projectId) { return postWithRestResult(projectRestURL + "/" + projectId + "/withdraw"); } @Override RestResult<Void> withdrawProject(long projectId); @Override RestResult<Void> handleProjectOffline(long projectId); @Override RestResult<Void> completeProjectOffline(long projectId); @Override RestResult<Void> putProjectOnHold(long projectId, OnHoldReasonResource reason); @Override RestResult<Void> resumeProject(long projectId); @Override RestResult<Void> markAsSuccessful(long projectId); @Override RestResult<Void> markAsUnsuccessful(long projectId); @Override RestResult<ProjectStateCommentsResource> findOpenComments(long projectId); @Override RestResult<Void> addPost(PostResource post, long projectId, long threadId); }### Answer: @Test public void withdrawProject() { long projectId = 123L; setupPostWithRestResultExpectations(projectRestURL + "/" + projectId + "/withdraw", null, OK ); RestResult<Void> result = service.withdrawProject(projectId); setupPostWithRestResultVerifications(projectRestURL + "/" + projectId + "/withdraw", Void.class); assertTrue(result.isSuccess()); }
### Question: UsersRolesServiceImpl extends BaseTransactionalService implements UsersRolesService { @Override public ServiceResult<List<ProcessRoleResource>> getProcessRolesByApplicationId(long applicationId) { return serviceSuccess(processRolesToResources(processRoleRepository.findByApplicationId(applicationId))); } @Override ServiceResult<ProcessRoleResource> getProcessRoleById(long id); @Override ServiceResult<List<ProcessRoleResource>> getProcessRolesByIds(Long[] ids); @Override ServiceResult<List<ProcessRoleResource>> getProcessRolesByApplicationId(long applicationId); @Override ServiceResult<ProcessRoleResource> getProcessRoleByUserIdAndApplicationId(long userId, long applicationId); @Override ServiceResult<List<ProcessRoleResource>> getProcessRolesByUserId(long userId); @Override ServiceResult<List<ProcessRoleResource>> getAssignableProcessRolesByApplicationId(long applicationId); @Override ServiceResult<Boolean> userHasApplicationForCompetition(long userId, long competitionId); }### Answer: @Test public void getProcessRolesByApplicationId() { List<ProcessRole> processRoles = newProcessRole().build(2); List<ProcessRoleResource> processRoleResources = newProcessRoleResource().build(2); when(processRoleRepositoryMock.findByApplicationId(1L)).thenReturn(processRoles); zip(processRoles, processRoleResources, (pr, prr) -> when(processRoleMapperMock.mapToResource(same(pr))).thenReturn(prr)); ServiceResult<List<ProcessRoleResource>> result = service.getProcessRolesByApplicationId(1L); assertTrue(result.isSuccess()); assertEquals(processRoleResources, result.getSuccess()); verify(processRoleRepositoryMock, only()).findByApplicationId(1L); }
### Question: ProjectStateRestServiceImpl extends BaseRestService implements ProjectStateRestService { @Override public RestResult<Void> handleProjectOffline(long projectId) { return postWithRestResult(projectRestURL + "/" + projectId + "/handle-offline"); } @Override RestResult<Void> withdrawProject(long projectId); @Override RestResult<Void> handleProjectOffline(long projectId); @Override RestResult<Void> completeProjectOffline(long projectId); @Override RestResult<Void> putProjectOnHold(long projectId, OnHoldReasonResource reason); @Override RestResult<Void> resumeProject(long projectId); @Override RestResult<Void> markAsSuccessful(long projectId); @Override RestResult<Void> markAsUnsuccessful(long projectId); @Override RestResult<ProjectStateCommentsResource> findOpenComments(long projectId); @Override RestResult<Void> addPost(PostResource post, long projectId, long threadId); }### Answer: @Test public void handleProjectOffline() { long projectId = 123L; setupPostWithRestResultExpectations(projectRestURL + "/" + projectId + "/handle-offline", null, OK ); RestResult<Void> result = service.handleProjectOffline(projectId); setupPostWithRestResultVerifications(projectRestURL + "/" + projectId + "/handle-offline", Void.class); assertTrue(result.isSuccess()); }
### Question: ProjectStateRestServiceImpl extends BaseRestService implements ProjectStateRestService { @Override public RestResult<Void> completeProjectOffline(long projectId) { return postWithRestResult(projectRestURL + "/" + projectId + "/complete-offline"); } @Override RestResult<Void> withdrawProject(long projectId); @Override RestResult<Void> handleProjectOffline(long projectId); @Override RestResult<Void> completeProjectOffline(long projectId); @Override RestResult<Void> putProjectOnHold(long projectId, OnHoldReasonResource reason); @Override RestResult<Void> resumeProject(long projectId); @Override RestResult<Void> markAsSuccessful(long projectId); @Override RestResult<Void> markAsUnsuccessful(long projectId); @Override RestResult<ProjectStateCommentsResource> findOpenComments(long projectId); @Override RestResult<Void> addPost(PostResource post, long projectId, long threadId); }### Answer: @Test public void completeProjectOffline() { long projectId = 123L; setupPostWithRestResultExpectations(projectRestURL + "/" + projectId + "/complete-offline", null, OK ); RestResult<Void> result = service.completeProjectOffline(projectId); setupPostWithRestResultVerifications(projectRestURL + "/" + projectId + "/complete-offline", Void.class); assertTrue(result.isSuccess()); }
### Question: ProjectStateRestServiceImpl extends BaseRestService implements ProjectStateRestService { @Override public RestResult<Void> putProjectOnHold(long projectId, OnHoldReasonResource reason) { return postWithRestResult(projectRestURL + "/" + projectId + "/on-hold", reason, Void.class); } @Override RestResult<Void> withdrawProject(long projectId); @Override RestResult<Void> handleProjectOffline(long projectId); @Override RestResult<Void> completeProjectOffline(long projectId); @Override RestResult<Void> putProjectOnHold(long projectId, OnHoldReasonResource reason); @Override RestResult<Void> resumeProject(long projectId); @Override RestResult<Void> markAsSuccessful(long projectId); @Override RestResult<Void> markAsUnsuccessful(long projectId); @Override RestResult<ProjectStateCommentsResource> findOpenComments(long projectId); @Override RestResult<Void> addPost(PostResource post, long projectId, long threadId); }### Answer: @Test public void putProjectOnHold() { long projectId = 123L; OnHoldReasonResource onHoldReasonResource = new OnHoldReasonResource("something", "else"); setupPostWithRestResultExpectations(projectRestURL + "/" + projectId + "/on-hold", onHoldReasonResource, OK ); RestResult<Void> result = service.putProjectOnHold(projectId, onHoldReasonResource); setupPostWithRestResultVerifications(projectRestURL + "/" + projectId + "/on-hold", Void.class, onHoldReasonResource); assertTrue(result.isSuccess()); }
### Question: ProjectStateRestServiceImpl extends BaseRestService implements ProjectStateRestService { @Override public RestResult<Void> resumeProject(long projectId) { return postWithRestResult(projectRestURL + "/" + projectId + "/resume"); } @Override RestResult<Void> withdrawProject(long projectId); @Override RestResult<Void> handleProjectOffline(long projectId); @Override RestResult<Void> completeProjectOffline(long projectId); @Override RestResult<Void> putProjectOnHold(long projectId, OnHoldReasonResource reason); @Override RestResult<Void> resumeProject(long projectId); @Override RestResult<Void> markAsSuccessful(long projectId); @Override RestResult<Void> markAsUnsuccessful(long projectId); @Override RestResult<ProjectStateCommentsResource> findOpenComments(long projectId); @Override RestResult<Void> addPost(PostResource post, long projectId, long threadId); }### Answer: @Test public void resumeProject() { long projectId = 123L; setupPostWithRestResultExpectations(projectRestURL + "/" + projectId + "/resume", null, OK ); RestResult<Void> result = service.resumeProject(projectId); setupPostWithRestResultVerifications(projectRestURL + "/" + projectId + "/resume", Void.class); assertTrue(result.isSuccess()); }
### Question: ProjectStateRestServiceImpl extends BaseRestService implements ProjectStateRestService { @Override public RestResult<Void> markAsSuccessful(long projectId) { return postWithRestResult(projectRestURL + "/" + projectId + "/successful"); } @Override RestResult<Void> withdrawProject(long projectId); @Override RestResult<Void> handleProjectOffline(long projectId); @Override RestResult<Void> completeProjectOffline(long projectId); @Override RestResult<Void> putProjectOnHold(long projectId, OnHoldReasonResource reason); @Override RestResult<Void> resumeProject(long projectId); @Override RestResult<Void> markAsSuccessful(long projectId); @Override RestResult<Void> markAsUnsuccessful(long projectId); @Override RestResult<ProjectStateCommentsResource> findOpenComments(long projectId); @Override RestResult<Void> addPost(PostResource post, long projectId, long threadId); }### Answer: @Test public void markAsSuccessful() { long projectId = 123L; setupPostWithRestResultExpectations(projectRestURL + "/" + projectId + "/successful", null, OK ); RestResult<Void> result = service.markAsSuccessful(projectId); setupPostWithRestResultVerifications(projectRestURL + "/" + projectId + "/successful", Void.class); assertTrue(result.isSuccess()); }
### Question: ProjectStateRestServiceImpl extends BaseRestService implements ProjectStateRestService { @Override public RestResult<Void> markAsUnsuccessful(long projectId) { return postWithRestResult(projectRestURL + "/" + projectId + "/unsuccessful"); } @Override RestResult<Void> withdrawProject(long projectId); @Override RestResult<Void> handleProjectOffline(long projectId); @Override RestResult<Void> completeProjectOffline(long projectId); @Override RestResult<Void> putProjectOnHold(long projectId, OnHoldReasonResource reason); @Override RestResult<Void> resumeProject(long projectId); @Override RestResult<Void> markAsSuccessful(long projectId); @Override RestResult<Void> markAsUnsuccessful(long projectId); @Override RestResult<ProjectStateCommentsResource> findOpenComments(long projectId); @Override RestResult<Void> addPost(PostResource post, long projectId, long threadId); }### Answer: @Test public void markAsUnsuccessful() { long projectId = 123L; setupPostWithRestResultExpectations(projectRestURL + "/" + projectId + "/unsuccessful", null, OK ); RestResult<Void> result = service.markAsUnsuccessful(projectId); setupPostWithRestResultVerifications(projectRestURL + "/" + projectId + "/unsuccessful", Void.class); assertTrue(result.isSuccess()); }
### Question: PartnerOrganisationRestServiceImpl extends BaseRestService implements PartnerOrganisationRestService { public RestResult<List<PartnerOrganisationResource>> getProjectPartnerOrganisations(Long projectId) { return getWithRestResult(projectRestURL + "/" + projectId + "/partner-organisation", partnerOrganisationResourceList()); } RestResult<List<PartnerOrganisationResource>> getProjectPartnerOrganisations(Long projectId); @Override RestResult<PartnerOrganisationResource> getPartnerOrganisation(long projectId, long organisationId); @Override RestResult<Void> removePartnerOrganisation(long projectId, long organisationId); }### Answer: @Test public void testGetProjectPartnerOrganisations(){ Long projectId = 123L; List<PartnerOrganisationResource> partnerOrganisations = Arrays.asList(1,2,3).stream().map(i -> { PartnerOrganisationResource x = new PartnerOrganisationResource(); x.setProject(projectId); return x; }).collect(Collectors.toList()); setupGetWithRestResultExpectations(projectRestURL + "/123/partner-organisation", partnerOrganisationResourceList(), partnerOrganisations); RestResult result = service.getProjectPartnerOrganisations(projectId); assertTrue(result.isSuccess()); }
### Question: PartnerOrganisationRestServiceImpl extends BaseRestService implements PartnerOrganisationRestService { @Override public RestResult<PartnerOrganisationResource> getPartnerOrganisation(long projectId, long organisationId) { return getWithRestResult(projectRestURL + "/" + projectId + "/partner/" + organisationId, PartnerOrganisationResource.class); } RestResult<List<PartnerOrganisationResource>> getProjectPartnerOrganisations(Long projectId); @Override RestResult<PartnerOrganisationResource> getPartnerOrganisation(long projectId, long organisationId); @Override RestResult<Void> removePartnerOrganisation(long projectId, long organisationId); }### Answer: @Test public void testGetPartnerOrganisation() { long projectId = 1L; long organisationId = 2L; PartnerOrganisationResource partnerOrganisationResource = PartnerOrganisationResourceBuilder.newPartnerOrganisationResource().build(); setupGetWithRestResultExpectations(projectRestURL + "/" + projectId + "/partner/" + organisationId, PartnerOrganisationResource.class, partnerOrganisationResource); RestResult<PartnerOrganisationResource> result = service.getPartnerOrganisation(projectId, organisationId); assertTrue(result.isSuccess()); assertEquals(partnerOrganisationResource, result.getSuccess()); setupGetWithRestResultVerifications(projectRestURL + "/" + projectId + "/partner/" + organisationId, null, PartnerOrganisationResource.class); }
### Question: PartnerOrganisationRestServiceImpl extends BaseRestService implements PartnerOrganisationRestService { @Override public RestResult<Void> removePartnerOrganisation(long projectId, long organisationId) { return postWithRestResult(projectRestURL + "/" + projectId + "/remove-organisation/" + organisationId, Void.class); } RestResult<List<PartnerOrganisationResource>> getProjectPartnerOrganisations(Long projectId); @Override RestResult<PartnerOrganisationResource> getPartnerOrganisation(long projectId, long organisationId); @Override RestResult<Void> removePartnerOrganisation(long projectId, long organisationId); }### Answer: @Test public void removePartnerOrganisation() { long projectId = 1L; long organisationId = 2L; setupPostWithRestResultExpectations(projectRestURL + "/" + projectId + "/remove-organisation/" + organisationId, HttpStatus.OK); RestResult<Void> result = service.removePartnerOrganisation(projectId, organisationId); assertTrue(result.isSuccess()); }
### Question: ProjectDetailsRestServiceImpl extends BaseRestService implements ProjectDetailsRestService { @Override public RestResult<Void> updateProjectDuration(long projectId, long durationInMonths) { return postWithRestResult(projectRestURL + "/" + projectId + "/duration/" + durationInMonths, Void.class); } @Override RestResult<Void> updateProjectManager(Long projectId, Long projectManagerUserId); @Override RestResult<Void> updateProjectStartDate(Long projectId, LocalDate projectStartDate); @Override RestResult<Void> updateProjectDuration(long projectId, long durationInMonths); @Override RestResult<Void> updateProjectAddress(long projectId, AddressResource address); @Override RestResult<Void> updateFinanceContact(ProjectOrganisationCompositeId composite, Long financeContactUserId); @Override RestResult<Void> updatePartnerProjectLocation(long projectId, long organisationId, PostcodeAndTownResource postcodeAndTown); }### Answer: @Test public void testUpdateProjectDuration() { long projectId = 3L; long durationInMonths = 18L; setupPostWithRestResultExpectations(projectRestURL + "/" + projectId + "/duration/" + durationInMonths, null, OK); RestResult<Void> result = service.updateProjectDuration(projectId, durationInMonths); assertTrue(result.isSuccess()); setupPostWithRestResultVerifications(projectRestURL + "/" + projectId + "/duration/" + durationInMonths, Void.class, null); }
### Question: UsersRolesServiceImpl extends BaseTransactionalService implements UsersRolesService { @Override public ServiceResult<ProcessRoleResource> getProcessRoleByUserIdAndApplicationId(long userId, long applicationId) { return find(processRoleRepository.findOneByUserIdAndRoleInAndApplicationId(userId, applicantProcessRoles(), applicationId), notFoundError(ProcessRole.class, "User", userId, "Application", applicationId)) .andOnSuccessReturn(processRoleMapper::mapToResource); } @Override ServiceResult<ProcessRoleResource> getProcessRoleById(long id); @Override ServiceResult<List<ProcessRoleResource>> getProcessRolesByIds(Long[] ids); @Override ServiceResult<List<ProcessRoleResource>> getProcessRolesByApplicationId(long applicationId); @Override ServiceResult<ProcessRoleResource> getProcessRoleByUserIdAndApplicationId(long userId, long applicationId); @Override ServiceResult<List<ProcessRoleResource>> getProcessRolesByUserId(long userId); @Override ServiceResult<List<ProcessRoleResource>> getAssignableProcessRolesByApplicationId(long applicationId); @Override ServiceResult<Boolean> userHasApplicationForCompetition(long userId, long competitionId); }### Answer: @Test public void getProcessRoleByUserIdAndApplicationId() { ProcessRole processRole = newProcessRole().build(); ProcessRoleResource processRoleResource = newProcessRoleResource().build(); when(processRoleRepositoryMock.findOneByUserIdAndRoleInAndApplicationId(1L, applicantProcessRoles(), 1L)).thenReturn(processRole); when(processRoleMapperMock.mapToResource(same(processRole))).thenReturn(processRoleResource); ServiceResult<ProcessRoleResource> result = service.getProcessRoleByUserIdAndApplicationId(1L, 1L); assertTrue(result.isSuccess()); assertEquals(processRoleResource, result.getSuccess()); verify(processRoleRepositoryMock, only()).findOneByUserIdAndRoleInAndApplicationId(1L, applicantProcessRoles(), 1L); }
### Question: ProjectDetailsRestServiceImpl extends BaseRestService implements ProjectDetailsRestService { @Override public RestResult<Void> updateFinanceContact(ProjectOrganisationCompositeId composite, Long financeContactUserId) { return postWithRestResult(projectRestURL + "/" + composite.getProjectId() + "/organisation/" + composite.getOrganisationId() + "/finance-contact?financeContact=" + financeContactUserId, Void.class); } @Override RestResult<Void> updateProjectManager(Long projectId, Long projectManagerUserId); @Override RestResult<Void> updateProjectStartDate(Long projectId, LocalDate projectStartDate); @Override RestResult<Void> updateProjectDuration(long projectId, long durationInMonths); @Override RestResult<Void> updateProjectAddress(long projectId, AddressResource address); @Override RestResult<Void> updateFinanceContact(ProjectOrganisationCompositeId composite, Long financeContactUserId); @Override RestResult<Void> updatePartnerProjectLocation(long projectId, long organisationId, PostcodeAndTownResource postcodeAndTown); }### Answer: @Test public void testUpdateFinanceContact() { setupPostWithRestResultExpectations(projectRestURL + "/123/organisation/5/finance-contact?financeContact=6", null, OK); RestResult<Void> result = service.updateFinanceContact(new ProjectOrganisationCompositeId(123L, 5L), 6L); assertTrue(result.isSuccess()); }
### Question: ProjectDetailsRestServiceImpl extends BaseRestService implements ProjectDetailsRestService { @Override public RestResult<Void> updatePartnerProjectLocation(long projectId, long organisationId, PostcodeAndTownResource postcodeAndTown) { return postWithRestResult(projectRestURL + "/" + projectId + "/organisation/" + organisationId + "/partner-project-location", postcodeAndTown, Void.class); } @Override RestResult<Void> updateProjectManager(Long projectId, Long projectManagerUserId); @Override RestResult<Void> updateProjectStartDate(Long projectId, LocalDate projectStartDate); @Override RestResult<Void> updateProjectDuration(long projectId, long durationInMonths); @Override RestResult<Void> updateProjectAddress(long projectId, AddressResource address); @Override RestResult<Void> updateFinanceContact(ProjectOrganisationCompositeId composite, Long financeContactUserId); @Override RestResult<Void> updatePartnerProjectLocation(long projectId, long organisationId, PostcodeAndTownResource postcodeAndTown); }### Answer: @Test public void testUpdatePartnerProjectLocation() { long projectId = 1L; long organisationId = 2L; PostcodeAndTownResource postcodeAndTown = new PostcodeAndTownResource("TW14 9QG", null); setupPostWithRestResultExpectations(projectRestURL + "/" + projectId + "/organisation/" + organisationId + "/partner-project-location", postcodeAndTown, OK); RestResult<Void> result = service.updatePartnerProjectLocation(projectId, organisationId, postcodeAndTown); assertTrue(result.isSuccess()); setupPostWithRestResultVerifications(projectRestURL + "/" + projectId + "/organisation/" + organisationId + "/partner-project-location", Void.class, postcodeAndTown); }
### Question: ProjectDetailsRestServiceImpl extends BaseRestService implements ProjectDetailsRestService { @Override public RestResult<Void> updateProjectAddress(long projectId, AddressResource address) { return postWithRestResult(projectRestURL + "/" + projectId + "/address", address, Void.class); } @Override RestResult<Void> updateProjectManager(Long projectId, Long projectManagerUserId); @Override RestResult<Void> updateProjectStartDate(Long projectId, LocalDate projectStartDate); @Override RestResult<Void> updateProjectDuration(long projectId, long durationInMonths); @Override RestResult<Void> updateProjectAddress(long projectId, AddressResource address); @Override RestResult<Void> updateFinanceContact(ProjectOrganisationCompositeId composite, Long financeContactUserId); @Override RestResult<Void> updatePartnerProjectLocation(long projectId, long organisationId, PostcodeAndTownResource postcodeAndTown); }### Answer: @Test public void testUpdateProjectAddress() { long projectId = 456L; AddressResource addressResource = new AddressResource(); setupPostWithRestResultExpectations(projectRestURL + "/" + projectId + "/address", addressResource, OK); RestResult<Void> result = service.updateProjectAddress(projectId, addressResource); assertTrue(result.isSuccess()); }
### Question: DocumentsRestServiceImpl extends BaseRestService implements DocumentsRestService { @Override public RestResult<FileEntryResource> uploadDocument(long projectId, long documentConfigId, String contentType, long contentLength, String originalFilename, byte[] bytes) { String url = String.format("%s/%s/document/config/%s/upload?filename=%s", projectRestURL, projectId, documentConfigId, originalFilename); return postWithRestResult(url, bytes, createFileUploadHeader(contentType, contentLength), FileEntryResource.class); } @Override RestResult<FileEntryResource> uploadDocument(long projectId, long documentConfigId, String contentType, long contentLength, String originalFilename, byte[] bytes); @Override RestResult<Optional<ByteArrayResource>> getFileContents(long projectId, long documentConfigId); @Override RestResult<Optional<FileEntryResource>> getFileEntryDetails(long projectId, long documentConfigId); @Override RestResult<Void> deleteDocument(long projectId, long documentConfigId); @Override RestResult<Void> submitDocument(long projectId, long documentConfigId); @Override RestResult<Void> documentDecision(long projectId, long documentConfigId, ProjectDocumentDecision decision); }### Answer: @Test public void uploadDocument() { String fileName = "filename.txt"; String url = String.format("%s/%s/document/config/%s/upload?filename=%s", projectRestURL, projectId, documentConfigId, fileName); String fileContentString = "12345678901234567"; byte[] fileContent = fileContentString.getBytes(); FileEntryResource response = new FileEntryResource(); setupFileUploadWithRestResultExpectations(url, FileEntryResource.class, fileContentString, "text/plain", 17, response, CREATED); RestResult<FileEntryResource> result = service.uploadDocument(projectId, documentConfigId, "text/plain", 17, fileName, fileContent); assertTrue(result.isSuccess()); assertEquals(response, result.getSuccess()); }
### Question: DocumentsRestServiceImpl extends BaseRestService implements DocumentsRestService { @Override public RestResult<Optional<ByteArrayResource>> getFileContents(long projectId, long documentConfigId) { String url = String.format("%s/%s/document/config/%s/file-contents", projectRestURL, projectId, documentConfigId); return getWithRestResult(url, ByteArrayResource.class).toOptionalIfNotFound(); } @Override RestResult<FileEntryResource> uploadDocument(long projectId, long documentConfigId, String contentType, long contentLength, String originalFilename, byte[] bytes); @Override RestResult<Optional<ByteArrayResource>> getFileContents(long projectId, long documentConfigId); @Override RestResult<Optional<FileEntryResource>> getFileEntryDetails(long projectId, long documentConfigId); @Override RestResult<Void> deleteDocument(long projectId, long documentConfigId); @Override RestResult<Void> submitDocument(long projectId, long documentConfigId); @Override RestResult<Void> documentDecision(long projectId, long documentConfigId, ProjectDocumentDecision decision); }### Answer: @Test public void getFileContents() { String url = String.format("%s/%s/document/config/%s/file-contents", projectRestURL, projectId, documentConfigId); ByteArrayResource expectedFileContents = new ByteArrayResource("Retrieved content".getBytes()); setupGetWithRestResultExpectations(url, ByteArrayResource.class, expectedFileContents, OK); ByteArrayResource retrievedFileContents = service.getFileContents(projectId, documentConfigId).getSuccess().get(); assertEquals(expectedFileContents, retrievedFileContents); }
### Question: DocumentsRestServiceImpl extends BaseRestService implements DocumentsRestService { @Override public RestResult<Optional<FileEntryResource>> getFileEntryDetails(long projectId, long documentConfigId) { String url = String.format("%s/%s/document/config/%s/file-entry-details", projectRestURL, projectId, documentConfigId); return getWithRestResult(url, FileEntryResource.class).toOptionalIfNotFound(); } @Override RestResult<FileEntryResource> uploadDocument(long projectId, long documentConfigId, String contentType, long contentLength, String originalFilename, byte[] bytes); @Override RestResult<Optional<ByteArrayResource>> getFileContents(long projectId, long documentConfigId); @Override RestResult<Optional<FileEntryResource>> getFileEntryDetails(long projectId, long documentConfigId); @Override RestResult<Void> deleteDocument(long projectId, long documentConfigId); @Override RestResult<Void> submitDocument(long projectId, long documentConfigId); @Override RestResult<Void> documentDecision(long projectId, long documentConfigId, ProjectDocumentDecision decision); }### Answer: @Test public void getFileEntryDetails() { String url = String.format("%s/%s/document/config/%s/file-entry-details", projectRestURL, projectId, documentConfigId); FileEntryResource expectedFileEntry = new FileEntryResource(); setupGetWithRestResultExpectations(url, FileEntryResource.class, expectedFileEntry, OK); FileEntryResource retrievedFileEntry = service.getFileEntryDetails(projectId, documentConfigId).getSuccess().get(); Assert.assertEquals(expectedFileEntry, retrievedFileEntry); }
### Question: DocumentsRestServiceImpl extends BaseRestService implements DocumentsRestService { @Override public RestResult<Void> deleteDocument(long projectId, long documentConfigId) { String url = String.format("%s/%s/document/config/%s/delete", projectRestURL, projectId, documentConfigId); return deleteWithRestResult(url); } @Override RestResult<FileEntryResource> uploadDocument(long projectId, long documentConfigId, String contentType, long contentLength, String originalFilename, byte[] bytes); @Override RestResult<Optional<ByteArrayResource>> getFileContents(long projectId, long documentConfigId); @Override RestResult<Optional<FileEntryResource>> getFileEntryDetails(long projectId, long documentConfigId); @Override RestResult<Void> deleteDocument(long projectId, long documentConfigId); @Override RestResult<Void> submitDocument(long projectId, long documentConfigId); @Override RestResult<Void> documentDecision(long projectId, long documentConfigId, ProjectDocumentDecision decision); }### Answer: @Test public void deleteDocument() { String url = String.format("%s/%s/document/config/%s/delete", projectRestURL, projectId, documentConfigId); setupDeleteWithRestResultExpectations(url); service.deleteDocument(projectId, documentConfigId); setupDeleteWithRestResultVerifications(url); }
### Question: DocumentsRestServiceImpl extends BaseRestService implements DocumentsRestService { @Override public RestResult<Void> submitDocument(long projectId, long documentConfigId) { String url = String.format("%s/%s/document/config/%s/submit", projectRestURL, projectId, documentConfigId); return postWithRestResult(url); } @Override RestResult<FileEntryResource> uploadDocument(long projectId, long documentConfigId, String contentType, long contentLength, String originalFilename, byte[] bytes); @Override RestResult<Optional<ByteArrayResource>> getFileContents(long projectId, long documentConfigId); @Override RestResult<Optional<FileEntryResource>> getFileEntryDetails(long projectId, long documentConfigId); @Override RestResult<Void> deleteDocument(long projectId, long documentConfigId); @Override RestResult<Void> submitDocument(long projectId, long documentConfigId); @Override RestResult<Void> documentDecision(long projectId, long documentConfigId, ProjectDocumentDecision decision); }### Answer: @Test public void submitDocument() { String url = String.format("%s/%s/document/config/%s/submit", projectRestURL, projectId, documentConfigId); setupPostWithRestResultExpectations(url, null, OK); RestResult<Void> result = service.submitDocument(projectId, documentConfigId); assertTrue(result.isSuccess()); }
### Question: DocumentsRestServiceImpl extends BaseRestService implements DocumentsRestService { @Override public RestResult<Void> documentDecision(long projectId, long documentConfigId, ProjectDocumentDecision decision) { String url = String.format("%s/%s/document/config/%s/decision", projectRestURL, projectId, documentConfigId); return postWithRestResult(url, decision, Void.class); } @Override RestResult<FileEntryResource> uploadDocument(long projectId, long documentConfigId, String contentType, long contentLength, String originalFilename, byte[] bytes); @Override RestResult<Optional<ByteArrayResource>> getFileContents(long projectId, long documentConfigId); @Override RestResult<Optional<FileEntryResource>> getFileEntryDetails(long projectId, long documentConfigId); @Override RestResult<Void> deleteDocument(long projectId, long documentConfigId); @Override RestResult<Void> submitDocument(long projectId, long documentConfigId); @Override RestResult<Void> documentDecision(long projectId, long documentConfigId, ProjectDocumentDecision decision); }### Answer: @Test public void documentDecision() { String url = String.format("%s/%s/document/config/%s/decision", projectRestURL, projectId, documentConfigId); ProjectDocumentDecision decision = new ProjectDocumentDecision(true, null); setupPostWithRestResultExpectations(url, decision, OK); RestResult<Void> result = service.documentDecision(projectId, documentConfigId, decision); setupPostWithRestResultVerifications(url, Void.class, decision); assertTrue(result.isSuccess()); }
### Question: BankDetailsRestServiceImpl extends BaseRestService implements BankDetailsRestService { @Override public RestResult<BankDetailsResource> getByProjectIdAndBankDetailsId(final Long projectId, final Long bankDetailsId){ return getWithRestResult(projectRestURL + "/" + projectId + "/bank-details?bankDetailsId=" + bankDetailsId, BankDetailsResource.class); } @Override RestResult<BankDetailsResource> getByProjectIdAndBankDetailsId(final Long projectId, final Long bankDetailsId); @Override RestResult<Void> submitBankDetails(final Long projectId, final BankDetailsResource bankDetailsResource); @Override RestResult<Void> updateBankDetails(final Long projectId, final BankDetailsResource bankDetailsResource); @Override RestResult<BankDetailsResource> getBankDetailsByProjectAndOrganisation(Long projectId, Long organisationId); @Override RestResult<ProjectBankDetailsStatusSummary> getBankDetailsStatusSummaryByProject(Long projectId); @Override RestResult<ByteArrayResource> downloadByCompetition(Long competitionId); @Override RestResult<List<BankDetailsReviewResource>> getPendingBankDetailsApprovals(); @Override RestResult<Long> countPendingBankDetailsApprovals(); }### Answer: @Test public void testGetById(){ Long projectId = 123L; Long bankDetailsId = 1L; BankDetailsResource returnedResponse = newBankDetailsResource().build(); setupGetWithRestResultExpectations(projectRestURL + "/" + projectId + "/bank-details?bankDetailsId=" + bankDetailsId, BankDetailsResource.class, returnedResponse); BankDetailsResource response = service.getByProjectIdAndBankDetailsId(projectId, bankDetailsId).getSuccess(); assertEquals(response, returnedResponse); }
### Question: UsersRolesServiceImpl extends BaseTransactionalService implements UsersRolesService { @Override public ServiceResult<List<ProcessRoleResource>> getProcessRolesByUserId(long userId) { return serviceSuccess(processRolesToResources(processRoleRepository.findByUserId(userId))); } @Override ServiceResult<ProcessRoleResource> getProcessRoleById(long id); @Override ServiceResult<List<ProcessRoleResource>> getProcessRolesByIds(Long[] ids); @Override ServiceResult<List<ProcessRoleResource>> getProcessRolesByApplicationId(long applicationId); @Override ServiceResult<ProcessRoleResource> getProcessRoleByUserIdAndApplicationId(long userId, long applicationId); @Override ServiceResult<List<ProcessRoleResource>> getProcessRolesByUserId(long userId); @Override ServiceResult<List<ProcessRoleResource>> getAssignableProcessRolesByApplicationId(long applicationId); @Override ServiceResult<Boolean> userHasApplicationForCompetition(long userId, long competitionId); }### Answer: @Test public void getProcessRolesByUserId() { List<ProcessRole> processRoles = newProcessRole().build(2); List<ProcessRoleResource> processRoleResources = newProcessRoleResource().build(2); when(processRoleRepositoryMock.findByUserId(1L)).thenReturn(processRoles); zip(processRoles, processRoleResources, (pr, prr) -> when(processRoleMapperMock.mapToResource(same(pr))).thenReturn(prr)); ServiceResult<List<ProcessRoleResource>> result = service.getProcessRolesByUserId(1L); assertTrue(result.isSuccess()); assertEquals(processRoleResources, result.getSuccess()); verify(processRoleRepositoryMock, only()).findByUserId(1L); }
### Question: BankDetailsRestServiceImpl extends BaseRestService implements BankDetailsRestService { @Override public RestResult<Void> updateBankDetails(final Long projectId, final BankDetailsResource bankDetailsResource){ return postWithRestResult(projectRestURL + "/" + projectId + "/bank-details", bankDetailsResource, Void.class); } @Override RestResult<BankDetailsResource> getByProjectIdAndBankDetailsId(final Long projectId, final Long bankDetailsId); @Override RestResult<Void> submitBankDetails(final Long projectId, final BankDetailsResource bankDetailsResource); @Override RestResult<Void> updateBankDetails(final Long projectId, final BankDetailsResource bankDetailsResource); @Override RestResult<BankDetailsResource> getBankDetailsByProjectAndOrganisation(Long projectId, Long organisationId); @Override RestResult<ProjectBankDetailsStatusSummary> getBankDetailsStatusSummaryByProject(Long projectId); @Override RestResult<ByteArrayResource> downloadByCompetition(Long competitionId); @Override RestResult<List<BankDetailsReviewResource>> getPendingBankDetailsApprovals(); @Override RestResult<Long> countPendingBankDetailsApprovals(); }### Answer: @Test public void testUpdateBankDetails(){ Long projectId = 123L; BankDetailsResource bankDetailsResource = newBankDetailsResource().build(); setupPostWithRestResultExpectations(projectRestURL + "/" + projectId + "/bank-details", bankDetailsResource, OK); RestResult result = service.updateBankDetails(projectId, bankDetailsResource); assertTrue(result.isSuccess()); }
### Question: BankDetailsRestServiceImpl extends BaseRestService implements BankDetailsRestService { @Override public RestResult<Void> submitBankDetails(final Long projectId, final BankDetailsResource bankDetailsResource){ return putWithRestResult(projectRestURL + "/" + projectId + "/bank-details", bankDetailsResource, Void.class); } @Override RestResult<BankDetailsResource> getByProjectIdAndBankDetailsId(final Long projectId, final Long bankDetailsId); @Override RestResult<Void> submitBankDetails(final Long projectId, final BankDetailsResource bankDetailsResource); @Override RestResult<Void> updateBankDetails(final Long projectId, final BankDetailsResource bankDetailsResource); @Override RestResult<BankDetailsResource> getBankDetailsByProjectAndOrganisation(Long projectId, Long organisationId); @Override RestResult<ProjectBankDetailsStatusSummary> getBankDetailsStatusSummaryByProject(Long projectId); @Override RestResult<ByteArrayResource> downloadByCompetition(Long competitionId); @Override RestResult<List<BankDetailsReviewResource>> getPendingBankDetailsApprovals(); @Override RestResult<Long> countPendingBankDetailsApprovals(); }### Answer: @Test public void testSubmitBankDetails(){ Long projectId = 123L; BankDetailsResource bankDetailsResource = newBankDetailsResource().build(); setupPutWithRestResultExpectations(projectRestURL + "/" + projectId + "/bank-details", bankDetailsResource, OK); RestResult result = service.submitBankDetails(projectId, bankDetailsResource); assertTrue(result.isSuccess()); }
### Question: BankDetailsRestServiceImpl extends BaseRestService implements BankDetailsRestService { @Override public RestResult<ProjectBankDetailsStatusSummary> getBankDetailsStatusSummaryByProject(Long projectId) { return getWithRestResult(projectRestURL + "/" + projectId + "/bank-details/status-summary", ProjectBankDetailsStatusSummary.class); } @Override RestResult<BankDetailsResource> getByProjectIdAndBankDetailsId(final Long projectId, final Long bankDetailsId); @Override RestResult<Void> submitBankDetails(final Long projectId, final BankDetailsResource bankDetailsResource); @Override RestResult<Void> updateBankDetails(final Long projectId, final BankDetailsResource bankDetailsResource); @Override RestResult<BankDetailsResource> getBankDetailsByProjectAndOrganisation(Long projectId, Long organisationId); @Override RestResult<ProjectBankDetailsStatusSummary> getBankDetailsStatusSummaryByProject(Long projectId); @Override RestResult<ByteArrayResource> downloadByCompetition(Long competitionId); @Override RestResult<List<BankDetailsReviewResource>> getPendingBankDetailsApprovals(); @Override RestResult<Long> countPendingBankDetailsApprovals(); }### Answer: @Test public void testgetBankDetailsByProject(){ Long projectId = 123L; ProjectBankDetailsStatusSummary projectBankDetailsStatusSummary = newProjectBankDetailsStatusSummary().build(); setupGetWithRestResultExpectations(projectRestURL + "/" + projectId + "/bank-details/status-summary", ProjectBankDetailsStatusSummary.class, projectBankDetailsStatusSummary, OK); RestResult<ProjectBankDetailsStatusSummary> response = service.getBankDetailsStatusSummaryByProject(projectId); assertTrue(response.isSuccess()); assertEquals(projectBankDetailsStatusSummary, response.getSuccess()); }
### Question: BankDetailsRestServiceImpl extends BaseRestService implements BankDetailsRestService { @Override public RestResult<ByteArrayResource> downloadByCompetition(Long competitionId) { String url = competitionRestURL + "/" + competitionId + "/bank-details/export"; return getWithRestResult(url, ByteArrayResource.class); } @Override RestResult<BankDetailsResource> getByProjectIdAndBankDetailsId(final Long projectId, final Long bankDetailsId); @Override RestResult<Void> submitBankDetails(final Long projectId, final BankDetailsResource bankDetailsResource); @Override RestResult<Void> updateBankDetails(final Long projectId, final BankDetailsResource bankDetailsResource); @Override RestResult<BankDetailsResource> getBankDetailsByProjectAndOrganisation(Long projectId, Long organisationId); @Override RestResult<ProjectBankDetailsStatusSummary> getBankDetailsStatusSummaryByProject(Long projectId); @Override RestResult<ByteArrayResource> downloadByCompetition(Long competitionId); @Override RestResult<List<BankDetailsReviewResource>> getPendingBankDetailsApprovals(); @Override RestResult<Long> countPendingBankDetailsApprovals(); }### Answer: @Test public void testDownloadByCompetition() { Long competitionId = 123L; ByteArrayResource returnedFileContents = new ByteArrayResource("Retrieved content".getBytes()); String url = competitionRestURL + "/" + competitionId + "/bank-details/export"; setupGetWithRestResultExpectations(url, ByteArrayResource.class, returnedFileContents, OK); ByteArrayResource retrievedFileEntry = service.downloadByCompetition(123L).getSuccess(); assertEquals(returnedFileContents, retrievedFileEntry); }
### Question: BankDetailsRestServiceImpl extends BaseRestService implements BankDetailsRestService { @Override public RestResult<List<BankDetailsReviewResource>> getPendingBankDetailsApprovals() { return getWithRestResult(competitionsRestURL + "/pending-bank-details-approvals", bankDetailsReviewResourceListType()); } @Override RestResult<BankDetailsResource> getByProjectIdAndBankDetailsId(final Long projectId, final Long bankDetailsId); @Override RestResult<Void> submitBankDetails(final Long projectId, final BankDetailsResource bankDetailsResource); @Override RestResult<Void> updateBankDetails(final Long projectId, final BankDetailsResource bankDetailsResource); @Override RestResult<BankDetailsResource> getBankDetailsByProjectAndOrganisation(Long projectId, Long organisationId); @Override RestResult<ProjectBankDetailsStatusSummary> getBankDetailsStatusSummaryByProject(Long projectId); @Override RestResult<ByteArrayResource> downloadByCompetition(Long competitionId); @Override RestResult<List<BankDetailsReviewResource>> getPendingBankDetailsApprovals(); @Override RestResult<Long> countPendingBankDetailsApprovals(); }### Answer: @Test public void getPendingBankDetailsApprovals() { List<BankDetailsReviewResource> returnedResponse = singletonList(new BankDetailsReviewResource()); setupGetWithRestResultExpectations(competitionsRestURL + "/pending-bank-details-approvals", bankDetailsReviewResourceListType(), returnedResponse); List<BankDetailsReviewResource> response = service.getPendingBankDetailsApprovals().getSuccess(); assertNotNull(response); Assert.assertEquals(returnedResponse, response); }
### Question: BankDetailsRestServiceImpl extends BaseRestService implements BankDetailsRestService { @Override public RestResult<Long> countPendingBankDetailsApprovals() { return getWithRestResult(competitionsRestURL + "/count-pending-bank-details-approvals", Long.class); } @Override RestResult<BankDetailsResource> getByProjectIdAndBankDetailsId(final Long projectId, final Long bankDetailsId); @Override RestResult<Void> submitBankDetails(final Long projectId, final BankDetailsResource bankDetailsResource); @Override RestResult<Void> updateBankDetails(final Long projectId, final BankDetailsResource bankDetailsResource); @Override RestResult<BankDetailsResource> getBankDetailsByProjectAndOrganisation(Long projectId, Long organisationId); @Override RestResult<ProjectBankDetailsStatusSummary> getBankDetailsStatusSummaryByProject(Long projectId); @Override RestResult<ByteArrayResource> downloadByCompetition(Long competitionId); @Override RestResult<List<BankDetailsReviewResource>> getPendingBankDetailsApprovals(); @Override RestResult<Long> countPendingBankDetailsApprovals(); }### Answer: @Test public void countPendingBankDetailsApprovals() { Long pendingBankDetailsCount = 8L; setupGetWithRestResultExpectations(competitionsRestURL + "/count-pending-bank-details-approvals", Long.class, pendingBankDetailsCount); Long response = service.countPendingBankDetailsApprovals().getSuccess(); assertNotNull(response); Assert.assertEquals(pendingBankDetailsCount, response); }
### Question: FinanceCheckRestServiceImpl extends BaseRestService implements FinanceCheckRestService { @Override public RestResult<Void> approveFinanceCheck(Long projectId, Long organisationId) { String url = FinanceCheckURIs.BASE_URL + "/" + projectId + FinanceCheckURIs.ORGANISATION_PATH + "/" + organisationId + FinanceCheckURIs.PATH + "/approve"; return postWithRestResult(url, Void.class); } @Override RestResult<FinanceCheckResource> getByProjectAndOrganisation(Long projectId, Long organisationId); @Override RestResult<Void> update(FinanceCheckResource financeCheckResource); @Override RestResult<FinanceCheckSummaryResource> getFinanceCheckSummary(Long projectId); @Override RestResult<FinanceCheckOverviewResource> getFinanceCheckOverview(Long projectId); @Override RestResult<Void> approveFinanceCheck(Long projectId, Long organisationId); @Override RestResult<FinanceCheckEligibilityResource> getFinanceCheckEligibilityDetails(Long projectId, Long organisationId); }### Answer: @Test public void testApprove() { setupPostWithRestResultExpectations("/project/123/partner-organisation/456/finance-check/approve", OK); service.approveFinanceCheck(123L, 456L); setupPostWithRestResultVerifications("/project/123/partner-organisation/456/finance-check/approve", Void.class); }
### Question: FinanceCheckRestServiceImpl extends BaseRestService implements FinanceCheckRestService { @Override public RestResult<FinanceCheckEligibilityResource> getFinanceCheckEligibilityDetails(Long projectId, Long organisationId) { String url = FinanceCheckURIs.BASE_URL + "/" + projectId + FinanceCheckURIs.ORGANISATION_PATH + "/" + organisationId + FinanceCheckURIs.PATH + "/eligibility"; return getWithRestResult(url, FinanceCheckEligibilityResource.class); } @Override RestResult<FinanceCheckResource> getByProjectAndOrganisation(Long projectId, Long organisationId); @Override RestResult<Void> update(FinanceCheckResource financeCheckResource); @Override RestResult<FinanceCheckSummaryResource> getFinanceCheckSummary(Long projectId); @Override RestResult<FinanceCheckOverviewResource> getFinanceCheckOverview(Long projectId); @Override RestResult<Void> approveFinanceCheck(Long projectId, Long organisationId); @Override RestResult<FinanceCheckEligibilityResource> getFinanceCheckEligibilityDetails(Long projectId, Long organisationId); }### Answer: @Test public void testGetFinanceCheckEligibility() { FinanceCheckEligibilityResource processStatus = new FinanceCheckEligibilityResource(); setupGetWithRestResultExpectations("/project/123/partner-organisation/456/finance-check/eligibility", FinanceCheckEligibilityResource.class, processStatus); Assert.assertEquals(processStatus, service.getFinanceCheckEligibilityDetails(123L, 456L).getSuccess()); }
### Question: FinanceCheckRestServiceImpl extends BaseRestService implements FinanceCheckRestService { @Override public RestResult<FinanceCheckOverviewResource> getFinanceCheckOverview(Long projectId) { String url = FinanceCheckURIs.BASE_URL + "/" + projectId + FinanceCheckURIs.PATH + "/overview"; return getWithRestResult(url, FinanceCheckOverviewResource.class); } @Override RestResult<FinanceCheckResource> getByProjectAndOrganisation(Long projectId, Long organisationId); @Override RestResult<Void> update(FinanceCheckResource financeCheckResource); @Override RestResult<FinanceCheckSummaryResource> getFinanceCheckSummary(Long projectId); @Override RestResult<FinanceCheckOverviewResource> getFinanceCheckOverview(Long projectId); @Override RestResult<Void> approveFinanceCheck(Long projectId, Long organisationId); @Override RestResult<FinanceCheckEligibilityResource> getFinanceCheckEligibilityDetails(Long projectId, Long organisationId); }### Answer: @Test public void testGetFinanceCheckOverview() { FinanceCheckOverviewResource processStatus = new FinanceCheckOverviewResource(); setupGetWithRestResultExpectations("/project/123/finance-check/overview", FinanceCheckOverviewResource.class, processStatus); Assert.assertEquals(processStatus, service.getFinanceCheckOverview(123L).getSuccess()); }
### Question: ProjectFinanceRestServiceImpl extends BaseRestService implements ProjectFinanceRestService { @Override public RestResult<List<ProjectFinanceResource>> getProjectFinances(Long projectId) { return getWithRestResult(PROJECT_FINANCE_REST_URL + "/" + projectId + "/project-finances", projectFinanceResourceListType()); } @Override RestResult<List<ProjectFinanceResource>> getProjectFinances(Long projectId); @Override RestResult<ProjectFinanceResource> getProjectFinance(Long projectId, Long organisationId); @Override RestResult<ViabilityResource> getViability(Long projectId, Long organisationId); @PostMapping("/{projectId}/partner-organisation/{organisationId}/viability/{viability}") RestResult<Void> saveViability(Long projectId, Long organisationId, ViabilityState viability, ViabilityRagStatus viabilityRagStatus); @Override RestResult<EligibilityResource> getEligibility(Long projectId, Long organisationId); @Override RestResult<Void> saveEligibility(Long projectId, Long organisationId, EligibilityState eligibility, EligibilityRagStatus eligibilityRagStatus); @Override RestResult<Boolean> isCreditReportConfirmed(Long projectId, Long organisationId); @Override RestResult<Void> saveCreditReportConfirmed(Long projectId, Long organisationId, boolean confirmed); @Override RestResult<List<ProjectFinanceResource>> getFinanceTotals(Long applicationId); @Override RestResult<ProjectFinanceResource> addProjectFinanceForOrganisation(Long projectId, Long organisationId); @Override RestResult<Boolean> hasAnyProjectOrganisationSizeChangedFromApplication(long projectId); }### Answer: @Test public void getProjectFinances() { Long projectId = 123L; List<ProjectFinanceResource> results = newProjectFinanceResource().build(2); setupGetWithRestResultExpectations(projectFinanceRestURL + "/" + projectId + "/project-finances", projectFinanceResourceListType(), results); RestResult<List<ProjectFinanceResource>> result = service.getProjectFinances(projectId); assertEquals(results, result.getSuccess()); }
### Question: ProjectFinanceRestServiceImpl extends BaseRestService implements ProjectFinanceRestService { @Override public RestResult<Boolean> isCreditReportConfirmed(Long projectId, Long organisationId) { String url = PROJECT_FINANCE_REST_URL + "/" + projectId + "/partner-organisation/" + organisationId + "/credit-report"; return getWithRestResult(url, Boolean.class); } @Override RestResult<List<ProjectFinanceResource>> getProjectFinances(Long projectId); @Override RestResult<ProjectFinanceResource> getProjectFinance(Long projectId, Long organisationId); @Override RestResult<ViabilityResource> getViability(Long projectId, Long organisationId); @PostMapping("/{projectId}/partner-organisation/{organisationId}/viability/{viability}") RestResult<Void> saveViability(Long projectId, Long organisationId, ViabilityState viability, ViabilityRagStatus viabilityRagStatus); @Override RestResult<EligibilityResource> getEligibility(Long projectId, Long organisationId); @Override RestResult<Void> saveEligibility(Long projectId, Long organisationId, EligibilityState eligibility, EligibilityRagStatus eligibilityRagStatus); @Override RestResult<Boolean> isCreditReportConfirmed(Long projectId, Long organisationId); @Override RestResult<Void> saveCreditReportConfirmed(Long projectId, Long organisationId, boolean confirmed); @Override RestResult<List<ProjectFinanceResource>> getFinanceTotals(Long applicationId); @Override RestResult<ProjectFinanceResource> addProjectFinanceForOrganisation(Long projectId, Long organisationId); @Override RestResult<Boolean> hasAnyProjectOrganisationSizeChangedFromApplication(long projectId); }### Answer: @Test public void isCreditReportConfirmed() { setupGetWithRestResultExpectations(projectFinanceRestURL + "/123/partner-organisation/456/credit-report", Boolean.class, true); RestResult<Boolean> results = service.isCreditReportConfirmed(123L, 456L); assertTrue(results.getSuccess()); }
### Question: ScheduledJesOrganisationListImporterOrganisationExtractor { ServiceResult<List<String>> extractOrganisationsFromFile(File downloadedFile) { try { List<String> organisationNames = FileUtils.readLines(downloadedFile, Charset.defaultCharset()); return serviceSuccess(organisationNames.subList(1, organisationNames.size())); } catch (IOException e) { return createServiceFailureFromIoException(e); } } }### Answer: @Test public void extractOrganisationsFromFile() throws IOException { ScheduledJesOrganisationListImporterOrganisationExtractor extractor = new ScheduledJesOrganisationListImporterOrganisationExtractor(); File testFile = File.createTempFile("jestest", "jestest"); FileUtils.writeLines(testFile, asList("Organisation names", "Org 1", "Org 2", "Org 3")); ServiceResult<List<String>> organisationExtractionResult = extractor.extractOrganisationsFromFile(testFile); assertThat(organisationExtractionResult.isSuccess()).isTrue(); List<String> organisationNames = organisationExtractionResult.getSuccess(); assertThat(organisationNames).containsExactly("Org 1", "Org 2", "Org 3"); }
### Question: ProjectFinanceRestServiceImpl extends BaseRestService implements ProjectFinanceRestService { @Override public RestResult<Boolean> hasAnyProjectOrganisationSizeChangedFromApplication(long projectId) { return getWithRestResult(format(PROJECT_FINANCE_REST_URL + "/" + projectId + "/finance/has-organisation-size-changed"), Boolean.class); } @Override RestResult<List<ProjectFinanceResource>> getProjectFinances(Long projectId); @Override RestResult<ProjectFinanceResource> getProjectFinance(Long projectId, Long organisationId); @Override RestResult<ViabilityResource> getViability(Long projectId, Long organisationId); @PostMapping("/{projectId}/partner-organisation/{organisationId}/viability/{viability}") RestResult<Void> saveViability(Long projectId, Long organisationId, ViabilityState viability, ViabilityRagStatus viabilityRagStatus); @Override RestResult<EligibilityResource> getEligibility(Long projectId, Long organisationId); @Override RestResult<Void> saveEligibility(Long projectId, Long organisationId, EligibilityState eligibility, EligibilityRagStatus eligibilityRagStatus); @Override RestResult<Boolean> isCreditReportConfirmed(Long projectId, Long organisationId); @Override RestResult<Void> saveCreditReportConfirmed(Long projectId, Long organisationId, boolean confirmed); @Override RestResult<List<ProjectFinanceResource>> getFinanceTotals(Long applicationId); @Override RestResult<ProjectFinanceResource> addProjectFinanceForOrganisation(Long projectId, Long organisationId); @Override RestResult<Boolean> hasAnyProjectOrganisationSizeChangedFromApplication(long projectId); }### Answer: @Test public void hasAnyProjectOrganisationSizeChangedFromApplication() { long projectId = 123L; setupGetWithRestResultExpectations(projectFinanceRestURL + "/" + projectId + "/finance/has-organisation-size-changed", Boolean.class, true); RestResult<Boolean> results = service.hasAnyProjectOrganisationSizeChangedFromApplication(projectId); assertTrue(results.getSuccess()); }
### Question: SpendProfileRestServiceImpl extends BaseRestService implements SpendProfileRestService { @Override public RestResult<Void> generateSpendProfile(Long projectId) { String url = PROJECT_REST_URL + "/" + projectId + "/spend-profile/generate"; return postWithRestResult(url, Void.class); } @Override RestResult<Void> generateSpendProfile(Long projectId); @Override RestResult<Void> acceptOrRejectSpendProfile(Long projectId, ApprovalType approvalType); @Override RestResult<ApprovalType> getSpendProfileStatusByProjectId(Long projectId); @Override RestResult<SpendProfileTableResource> getSpendProfileTable(Long projectId, Long organisationId); @Override RestResult<SpendProfileCSVResource> getSpendProfileCSV(Long projectId, Long organisationId); @Override RestResult<SpendProfileResource> getSpendProfile(Long projectId, Long organisationId); @Override RestResult<Void> saveSpendProfile(Long projectId, Long organisationId, SpendProfileTableResource table); @Override RestResult<Void> markSpendProfileComplete(Long projectId, Long organisationId); @Override RestResult<Void> markSpendProfileIncomplete(Long projectId, Long organisationId); @Override RestResult<Void> completeSpendProfilesReview(Long projectId); }### Answer: @Test public void testGenerateSpendProfile() { setupPostWithRestResultExpectations("/project/123/spend-profile/generate", Void.class, null, null, CREATED); service.generateSpendProfile(123L); setupPostWithRestResultVerifications("/project/123/spend-profile/generate", Void.class, null); }
### Question: SpendProfileRestServiceImpl extends BaseRestService implements SpendProfileRestService { @Override public RestResult<Void> saveSpendProfile(Long projectId, Long organisationId, SpendProfileTableResource table) { return postWithRestResult(PROJECT_REST_URL + "/" + projectId + "/partner-organisation/" + organisationId + "/spend-profile", table, Void.class); } @Override RestResult<Void> generateSpendProfile(Long projectId); @Override RestResult<Void> acceptOrRejectSpendProfile(Long projectId, ApprovalType approvalType); @Override RestResult<ApprovalType> getSpendProfileStatusByProjectId(Long projectId); @Override RestResult<SpendProfileTableResource> getSpendProfileTable(Long projectId, Long organisationId); @Override RestResult<SpendProfileCSVResource> getSpendProfileCSV(Long projectId, Long organisationId); @Override RestResult<SpendProfileResource> getSpendProfile(Long projectId, Long organisationId); @Override RestResult<Void> saveSpendProfile(Long projectId, Long organisationId, SpendProfileTableResource table); @Override RestResult<Void> markSpendProfileComplete(Long projectId, Long organisationId); @Override RestResult<Void> markSpendProfileIncomplete(Long projectId, Long organisationId); @Override RestResult<Void> completeSpendProfilesReview(Long projectId); }### Answer: @Test public void saveSpendProfile() { Long projectId = 1L; Long organisationId = 2L; SpendProfileTableResource table = new SpendProfileTableResource(); setupPostWithRestResultExpectations(projectRestURL + "/" + projectId + "/partner-organisation/" + organisationId + "/spend-profile", table, OK); RestResult<Void> result = service.saveSpendProfile(projectId, organisationId, table); setupPostWithRestResultVerifications("/project/1/partner-organisation/2/spend-profile", Void.class, table); assertTrue(result.isSuccess()); }
### Question: SpendProfileRestServiceImpl extends BaseRestService implements SpendProfileRestService { @Override public RestResult<Void> markSpendProfileComplete(Long projectId, Long organisationId) { return postWithRestResult(PROJECT_REST_URL + "/" + projectId + "/partner-organisation/" + organisationId + "/spend-profile/complete", Void.class); } @Override RestResult<Void> generateSpendProfile(Long projectId); @Override RestResult<Void> acceptOrRejectSpendProfile(Long projectId, ApprovalType approvalType); @Override RestResult<ApprovalType> getSpendProfileStatusByProjectId(Long projectId); @Override RestResult<SpendProfileTableResource> getSpendProfileTable(Long projectId, Long organisationId); @Override RestResult<SpendProfileCSVResource> getSpendProfileCSV(Long projectId, Long organisationId); @Override RestResult<SpendProfileResource> getSpendProfile(Long projectId, Long organisationId); @Override RestResult<Void> saveSpendProfile(Long projectId, Long organisationId, SpendProfileTableResource table); @Override RestResult<Void> markSpendProfileComplete(Long projectId, Long organisationId); @Override RestResult<Void> markSpendProfileIncomplete(Long projectId, Long organisationId); @Override RestResult<Void> completeSpendProfilesReview(Long projectId); }### Answer: @Test public void markSpendProfileComplete() { Long projectId = 1L; Long organisationId = 2L; setupPostWithRestResultExpectations(projectRestURL + "/" + projectId + "/partner-organisation/" + organisationId + "/spend-profile/complete", OK); RestResult<Void> result = service.markSpendProfileComplete(projectId, organisationId); setupPostWithRestResultVerifications("/project/1/partner-organisation/2/spend-profile/complete", Void.class, null); assertTrue(result.isSuccess()); }
### Question: SpendProfileRestServiceImpl extends BaseRestService implements SpendProfileRestService { @Override public RestResult<Void> markSpendProfileIncomplete(Long projectId, Long organisationId) { return postWithRestResult(PROJECT_REST_URL + "/" + projectId + "/partner-organisation/" + organisationId + "/spend-profile/incomplete", Void.class); } @Override RestResult<Void> generateSpendProfile(Long projectId); @Override RestResult<Void> acceptOrRejectSpendProfile(Long projectId, ApprovalType approvalType); @Override RestResult<ApprovalType> getSpendProfileStatusByProjectId(Long projectId); @Override RestResult<SpendProfileTableResource> getSpendProfileTable(Long projectId, Long organisationId); @Override RestResult<SpendProfileCSVResource> getSpendProfileCSV(Long projectId, Long organisationId); @Override RestResult<SpendProfileResource> getSpendProfile(Long projectId, Long organisationId); @Override RestResult<Void> saveSpendProfile(Long projectId, Long organisationId, SpendProfileTableResource table); @Override RestResult<Void> markSpendProfileComplete(Long projectId, Long organisationId); @Override RestResult<Void> markSpendProfileIncomplete(Long projectId, Long organisationId); @Override RestResult<Void> completeSpendProfilesReview(Long projectId); }### Answer: @Test public void markSpendProfileIncomplete() { Long projectId = 1L; Long organisationId = 2L; setupPostWithRestResultExpectations(projectRestURL + "/" + projectId + "/partner-organisation/" + organisationId + "/spend-profile/incomplete", OK); RestResult<Void> result = service.markSpendProfileIncomplete(projectId, organisationId); setupPostWithRestResultVerifications("/project/1/partner-organisation/2/spend-profile/incomplete", Void.class, null); assertTrue(result.isSuccess()); }
### Question: SpendProfileRestServiceImpl extends BaseRestService implements SpendProfileRestService { @Override public RestResult<Void> completeSpendProfilesReview(Long projectId) { return postWithRestResult(PROJECT_REST_URL + "/" + projectId + "/complete-spend-profiles-review/", Void.class); } @Override RestResult<Void> generateSpendProfile(Long projectId); @Override RestResult<Void> acceptOrRejectSpendProfile(Long projectId, ApprovalType approvalType); @Override RestResult<ApprovalType> getSpendProfileStatusByProjectId(Long projectId); @Override RestResult<SpendProfileTableResource> getSpendProfileTable(Long projectId, Long organisationId); @Override RestResult<SpendProfileCSVResource> getSpendProfileCSV(Long projectId, Long organisationId); @Override RestResult<SpendProfileResource> getSpendProfile(Long projectId, Long organisationId); @Override RestResult<Void> saveSpendProfile(Long projectId, Long organisationId, SpendProfileTableResource table); @Override RestResult<Void> markSpendProfileComplete(Long projectId, Long organisationId); @Override RestResult<Void> markSpendProfileIncomplete(Long projectId, Long organisationId); @Override RestResult<Void> completeSpendProfilesReview(Long projectId); }### Answer: @Test public void testCompleteSpendProfilesReview() { Long projectId = 1L; setupPostWithRestResultExpectations(projectRestURL + "/" + projectId + "/complete-spend-profiles-review/", OK); RestResult<Void> result = service.completeSpendProfilesReview(projectId); setupPostWithRestResultVerifications("/project/1/complete-spend-profiles-review/", Void.class, null); assertTrue(result.isSuccess()); }
### Question: SpendProfileRestServiceImpl extends BaseRestService implements SpendProfileRestService { @Override public RestResult<SpendProfileCSVResource> getSpendProfileCSV(Long projectId, Long organisationId) { String url = PROJECT_REST_URL + "/" + projectId + "/partner-organisation/" + organisationId + "/spend-profile-csv"; return getWithRestResult(url, SpendProfileCSVResource.class); } @Override RestResult<Void> generateSpendProfile(Long projectId); @Override RestResult<Void> acceptOrRejectSpendProfile(Long projectId, ApprovalType approvalType); @Override RestResult<ApprovalType> getSpendProfileStatusByProjectId(Long projectId); @Override RestResult<SpendProfileTableResource> getSpendProfileTable(Long projectId, Long organisationId); @Override RestResult<SpendProfileCSVResource> getSpendProfileCSV(Long projectId, Long organisationId); @Override RestResult<SpendProfileResource> getSpendProfile(Long projectId, Long organisationId); @Override RestResult<Void> saveSpendProfile(Long projectId, Long organisationId, SpendProfileTableResource table); @Override RestResult<Void> markSpendProfileComplete(Long projectId, Long organisationId); @Override RestResult<Void> markSpendProfileIncomplete(Long projectId, Long organisationId); @Override RestResult<Void> completeSpendProfilesReview(Long projectId); }### Answer: @Test public void getSpendProfileCSV() { Long projectId = 1L; Long organisationId = 1L; setupGetWithRestResultExpectations(projectRestURL + "/" + projectId + "/partner-organisation/" + organisationId + "/spend-profile-csv", SpendProfileCSVResource.class, null); RestResult<SpendProfileCSVResource> result = service.getSpendProfileCSV(projectId, organisationId); assertTrue(result.isSuccess()); }
### Question: SpendProfileRestServiceImpl extends BaseRestService implements SpendProfileRestService { @Override public RestResult<Void> acceptOrRejectSpendProfile(Long projectId, ApprovalType approvalType) { return postWithRestResult(PROJECT_REST_URL + "/" + projectId + "/spend-profile/approval/" + approvalType, Void.class); } @Override RestResult<Void> generateSpendProfile(Long projectId); @Override RestResult<Void> acceptOrRejectSpendProfile(Long projectId, ApprovalType approvalType); @Override RestResult<ApprovalType> getSpendProfileStatusByProjectId(Long projectId); @Override RestResult<SpendProfileTableResource> getSpendProfileTable(Long projectId, Long organisationId); @Override RestResult<SpendProfileCSVResource> getSpendProfileCSV(Long projectId, Long organisationId); @Override RestResult<SpendProfileResource> getSpendProfile(Long projectId, Long organisationId); @Override RestResult<Void> saveSpendProfile(Long projectId, Long organisationId, SpendProfileTableResource table); @Override RestResult<Void> markSpendProfileComplete(Long projectId, Long organisationId); @Override RestResult<Void> markSpendProfileIncomplete(Long projectId, Long organisationId); @Override RestResult<Void> completeSpendProfilesReview(Long projectId); }### Answer: @Test public void acceptOrRejectSpendProfile() { Long projectId = 1L; setupPostWithRestResultExpectations(projectRestURL + "/" + projectId + "/spend-profile/approval/" + ApprovalType.APPROVED, OK); RestResult<Void> result = service.acceptOrRejectSpendProfile(projectId, ApprovalType.APPROVED); setupPostWithRestResultVerifications("/project/1/spend-profile/approval/APPROVED", Void.class, null); assertTrue(result.isSuccess()); }
### Question: SpendProfileRestServiceImpl extends BaseRestService implements SpendProfileRestService { @Override public RestResult<ApprovalType> getSpendProfileStatusByProjectId(Long projectId) { return getWithRestResult(PROJECT_REST_URL + "/" + projectId + "/spend-profile/approval", ApprovalType.class); } @Override RestResult<Void> generateSpendProfile(Long projectId); @Override RestResult<Void> acceptOrRejectSpendProfile(Long projectId, ApprovalType approvalType); @Override RestResult<ApprovalType> getSpendProfileStatusByProjectId(Long projectId); @Override RestResult<SpendProfileTableResource> getSpendProfileTable(Long projectId, Long organisationId); @Override RestResult<SpendProfileCSVResource> getSpendProfileCSV(Long projectId, Long organisationId); @Override RestResult<SpendProfileResource> getSpendProfile(Long projectId, Long organisationId); @Override RestResult<Void> saveSpendProfile(Long projectId, Long organisationId, SpendProfileTableResource table); @Override RestResult<Void> markSpendProfileComplete(Long projectId, Long organisationId); @Override RestResult<Void> markSpendProfileIncomplete(Long projectId, Long organisationId); @Override RestResult<Void> completeSpendProfilesReview(Long projectId); }### Answer: @Test public void getSpendProfileStatusByProjectId() { Long projectId = 1L; setupGetWithRestResultExpectations(projectRestURL + "/" + projectId + "/spend-profile/approval", ApprovalType.class, ApprovalType.APPROVED, OK); RestResult<ApprovalType> result = service.getSpendProfileStatusByProjectId(projectId); assertTrue(result.isSuccess()); assertEquals(ApprovalType.APPROVED, result.getSuccess()); }
### Question: ProjectPartnerInviteRestServiceImpl extends BaseRestService implements ProjectPartnerInviteRestService { @Override public RestResult<Void> invitePartnerOrganisation(long projectId, SendProjectPartnerInviteResource invite) { return postWithRestResult(format(baseUrl, projectId), invite, Void.class); } @Override RestResult<Void> invitePartnerOrganisation(long projectId, SendProjectPartnerInviteResource invite); @Override RestResult<List<SentProjectPartnerInviteResource>> getPartnerInvites(long projectId); @Override RestResult<Void> resendInvite(long projectId, long inviteId); @Override RestResult<Void> deleteInvite(long projectId, long inviteId); @Override RestResult<SentProjectPartnerInviteResource> getInviteByHash(long projectId, String hash); @Override RestResult<Void> acceptInvite(long projectId, long inviteId, long organisationId); }### Answer: @Test public void invitePartnerOrganisation() { long projectId = 1L; SendProjectPartnerInviteResource invite = new SendProjectPartnerInviteResource("", "", ""); setupPostWithRestResultExpectations(format("/project/%d/project-partner-invite", projectId), invite, HttpStatus.OK); RestResult<Void> result = service.invitePartnerOrganisation(projectId, invite); assertTrue(result.isSuccess()); setupPostWithRestResulVerifications(format("/project/%d/project-partner-invite", projectId), invite); }
### Question: ScheduledJesOrganisationListImporterFileDownloader { ServiceResult<File> copyJesSourceFile(URL jesSourceFile, int connectionTimeoutMillis, int readTimeoutMillis) { return createTemporaryDownloadFile().andOnSuccess(temporaryDownloadFile -> { try { FileUtils.copyURLToFile(jesSourceFile, temporaryDownloadFile, connectionTimeoutMillis, readTimeoutMillis); return serviceSuccess(temporaryDownloadFile); } catch (IOException e) { return createServiceFailureFromIoException(e); } }); } }### Answer: @Test public void downloadFile() throws IOException { ScheduledJesOrganisationListImporterFileDownloader fileDownloader = new ScheduledJesOrganisationListImporterFileDownloader(); URL dummyFileUrl = currentThread().getContextClassLoader().getResource("test-jes-download.csv"); ServiceResult<File> fileDownloadResult = fileDownloader.copyJesSourceFile(dummyFileUrl, 5000, 500); assertThat(fileDownloadResult.isSuccess()).isTrue(); File dummyFile = fileDownloadResult.getSuccess(); List<String> fileContents = FileUtils.readLines(dummyFile, Charset.defaultCharset()); assertThat(fileContents).containsExactly( "Organisation name", "AB Agri Ltd", "Aberystwyth University", "Abriachan Forest Trust"); } @Test public void downloadFileWhenFileNotFound() throws IOException { ScheduledJesOrganisationListImporterFileDownloader fileDownloader = new ScheduledJesOrganisationListImporterFileDownloader(); String nonExistentFileUrl = File.createTempFile("jestest", "jestest").getAbsolutePath() + "does-not-exist"; URL dummyFileUrl = new File(nonExistentFileUrl).toURI().toURL(); ServiceResult<File> fileDownloadResult = fileDownloader.copyJesSourceFile(dummyFileUrl, 5000, 500); assertThat(fileDownloadResult.isFailure()).isTrue(); List<Error> errors = fileDownloadResult.getFailure().getErrors(); assertThat(errors).hasSize(1); assertThat(errors.get(0).getStatusCode()).isEqualTo(BAD_REQUEST); }
### Question: ProjectPartnerInviteRestServiceImpl extends BaseRestService implements ProjectPartnerInviteRestService { @Override public RestResult<List<SentProjectPartnerInviteResource>> getPartnerInvites(long projectId) { return getWithRestResult(format(baseUrl, projectId), sentProjectPartnerInviteResourceListType()); } @Override RestResult<Void> invitePartnerOrganisation(long projectId, SendProjectPartnerInviteResource invite); @Override RestResult<List<SentProjectPartnerInviteResource>> getPartnerInvites(long projectId); @Override RestResult<Void> resendInvite(long projectId, long inviteId); @Override RestResult<Void> deleteInvite(long projectId, long inviteId); @Override RestResult<SentProjectPartnerInviteResource> getInviteByHash(long projectId, String hash); @Override RestResult<Void> acceptInvite(long projectId, long inviteId, long organisationId); }### Answer: @Test public void getPartnerInvites() { long projectId = 1L; List<SentProjectPartnerInviteResource> invites = newSentProjectPartnerInviteResource().build(1); setupGetWithRestResultExpectations(format("/project/%d/project-partner-invite", projectId), sentProjectPartnerInviteResourceListType(), invites); RestResult<List<SentProjectPartnerInviteResource>> result = service.getPartnerInvites(projectId); assertTrue(result.isSuccess()); assertEquals(invites, result.getSuccess()); }
### Question: ProjectPartnerInviteRestServiceImpl extends BaseRestService implements ProjectPartnerInviteRestService { @Override public RestResult<Void> resendInvite(long projectId, long inviteId) { return postWithRestResult(format(inviteIdUrl, projectId, inviteId) + "/resend", Void.class); } @Override RestResult<Void> invitePartnerOrganisation(long projectId, SendProjectPartnerInviteResource invite); @Override RestResult<List<SentProjectPartnerInviteResource>> getPartnerInvites(long projectId); @Override RestResult<Void> resendInvite(long projectId, long inviteId); @Override RestResult<Void> deleteInvite(long projectId, long inviteId); @Override RestResult<SentProjectPartnerInviteResource> getInviteByHash(long projectId, String hash); @Override RestResult<Void> acceptInvite(long projectId, long inviteId, long organisationId); }### Answer: @Test public void resendInvite() { long projectId = 1L; long inviteId = 2L; setupPostWithRestResultExpectations(format("/project/%d/project-partner-invite/%d/resend", projectId, inviteId), HttpStatus.OK); RestResult<Void> result = service.resendInvite(projectId, inviteId); assertTrue(result.isSuccess()); }
### Question: ProjectPartnerInviteRestServiceImpl extends BaseRestService implements ProjectPartnerInviteRestService { @Override public RestResult<Void> deleteInvite(long projectId, long inviteId) { return deleteWithRestResult(format(inviteIdUrl, projectId, inviteId), Void.class); } @Override RestResult<Void> invitePartnerOrganisation(long projectId, SendProjectPartnerInviteResource invite); @Override RestResult<List<SentProjectPartnerInviteResource>> getPartnerInvites(long projectId); @Override RestResult<Void> resendInvite(long projectId, long inviteId); @Override RestResult<Void> deleteInvite(long projectId, long inviteId); @Override RestResult<SentProjectPartnerInviteResource> getInviteByHash(long projectId, String hash); @Override RestResult<Void> acceptInvite(long projectId, long inviteId, long organisationId); }### Answer: @Test public void deleteInvite() { long projectId = 1L; long inviteId = 2L; setupDeleteWithRestResultExpectations(format("/project/%d/project-partner-invite/%d", projectId, inviteId), HttpStatus.OK); RestResult<Void> result = service.deleteInvite(projectId, inviteId); assertTrue(result.isSuccess()); }
### Question: ProjectPartnerInviteRestServiceImpl extends BaseRestService implements ProjectPartnerInviteRestService { @Override public RestResult<SentProjectPartnerInviteResource> getInviteByHash(long projectId, String hash) { return getWithRestResultAnonymous(format(inviteIdUrl, projectId, hash), SentProjectPartnerInviteResource.class); } @Override RestResult<Void> invitePartnerOrganisation(long projectId, SendProjectPartnerInviteResource invite); @Override RestResult<List<SentProjectPartnerInviteResource>> getPartnerInvites(long projectId); @Override RestResult<Void> resendInvite(long projectId, long inviteId); @Override RestResult<Void> deleteInvite(long projectId, long inviteId); @Override RestResult<SentProjectPartnerInviteResource> getInviteByHash(long projectId, String hash); @Override RestResult<Void> acceptInvite(long projectId, long inviteId, long organisationId); }### Answer: @Test public void getInviteByHash() { long projectId = 1L; String hash = "hash"; SentProjectPartnerInviteResource resource = newSentProjectPartnerInviteResource().build(); setupGetWithRestResultAnonymousExpectations(format("/project/%d/project-partner-invite/%s", projectId, hash), SentProjectPartnerInviteResource.class, resource); RestResult<SentProjectPartnerInviteResource> result = service.getInviteByHash(projectId, hash); assertEquals(resource, result.getSuccess()); }
### Question: ProjectPartnerInviteRestServiceImpl extends BaseRestService implements ProjectPartnerInviteRestService { @Override public RestResult<Void> acceptInvite(long projectId, long inviteId, long organisationId) { return postWithRestResultAnonymous(format(inviteIdUrl + "/organisation/%d/accept", projectId, inviteId, organisationId), Void.class); } @Override RestResult<Void> invitePartnerOrganisation(long projectId, SendProjectPartnerInviteResource invite); @Override RestResult<List<SentProjectPartnerInviteResource>> getPartnerInvites(long projectId); @Override RestResult<Void> resendInvite(long projectId, long inviteId); @Override RestResult<Void> deleteInvite(long projectId, long inviteId); @Override RestResult<SentProjectPartnerInviteResource> getInviteByHash(long projectId, String hash); @Override RestResult<Void> acceptInvite(long projectId, long inviteId, long organisationId); }### Answer: @Test public void acceptInvite() { long projectId = 1L; long inviteId = 2L; long organisationId = 3L; setupPostWithRestResultAnonymousExpectations(format("/project/%d/project-partner-invite/%d/organisation/%d/accept", projectId, inviteId, organisationId), Void.class, null, null, HttpStatus.OK); RestResult<Void> result = service.acceptInvite(projectId, inviteId, organisationId); assertTrue(result.isSuccess()); }
### Question: AffiliationRestServiceImpl extends BaseRestService implements AffiliationRestService { @Override public RestResult<AffiliationListResource> getUserAffiliations(long userId) { return getWithRestResult(format("%s/id/%s/get-user-affiliations", profileRestURL, userId), AffiliationListResource.class); } @Override RestResult<AffiliationListResource> getUserAffiliations(long userId); @Override RestResult<Void> updateUserAffiliations(long userId, AffiliationListResource affiliations); }### Answer: @Test public void getUserAffiliations() { Long userId = 1L; List<AffiliationResource> affiliationResources = newAffiliationResource().build(2); AffiliationListResource expected = newAffiliationListResource() .withAffiliationList(affiliationResources) .build(); setupGetWithRestResultExpectations(format("%s/id/%s/get-user-affiliations", affiliationUrl, userId), AffiliationListResource.class, expected); AffiliationListResource response = service.getUserAffiliations(userId).getSuccess(); assertEquals(expected, response); }
### Question: AffiliationRestServiceImpl extends BaseRestService implements AffiliationRestService { @Override public RestResult<Void> updateUserAffiliations(long userId, AffiliationListResource affiliations) { return putWithRestResult(format("%s/id/%s/update-user-affiliations", profileRestURL, userId), affiliations, Void.class); } @Override RestResult<AffiliationListResource> getUserAffiliations(long userId); @Override RestResult<Void> updateUserAffiliations(long userId, AffiliationListResource affiliations); }### Answer: @Test public void updateUserAffiliations() { Long userId = 1L; List<AffiliationResource> affiliationResources = newAffiliationResource().build(2); AffiliationListResource expected = newAffiliationListResource() .withAffiliationList(affiliationResources) .build(); setupPutWithRestResultExpectations(format("%s/id/%s/update-user-affiliations", affiliationUrl, userId), expected, OK); RestResult<Void> response = service.updateUserAffiliations(userId, expected); assertTrue(response.isSuccess()); }
### Question: ApplicationKtaInviteRestServiceImpl extends BaseRestService implements ApplicationKtaInviteRestService { @Override public RestResult<Void> saveKtaInvite(ApplicationKtaInviteResource inviteResource) { String url = KTA_INVITE_REST_URL + "/save-kta-invite"; return postWithRestResult(url, inviteResource, Void.class); } @Override RestResult<Void> saveKtaInvite(ApplicationKtaInviteResource inviteResource); @Override RestResult<ApplicationKtaInviteResource> getKtaInviteByApplication(long applicationId); @Override RestResult<Void> removeKtaInviteByApplication(long applicationId); @Override RestResult<Void> resendKtaInvite(ApplicationKtaInviteResource inviteResource); @Override RestResult<ApplicationKtaInviteResource> getKtaInviteByHash(String hash); @Override RestResult<Void> acceptInvite(String hash); }### Answer: @Test public void saveKtaInvite() { final ApplicationKtaInviteResource invite = newApplicationKtaInviteResource().build(); setupPostWithRestResultExpectations(inviteKtaRestURL + "/save-kta-invite", invite, OK); RestResult<Void> response = service.saveKtaInvite(invite); assertTrue(response.isSuccess()); setupPostWithRestResultVerifications(inviteKtaRestURL + "/save-kta-invite", Void.class, invite); }
### Question: ApplicationKtaInviteRestServiceImpl extends BaseRestService implements ApplicationKtaInviteRestService { @Override public RestResult<Void> resendKtaInvite(ApplicationKtaInviteResource inviteResource) { String url = KTA_INVITE_REST_URL + "/resend-kta-invite"; return postWithRestResult(url, inviteResource, Void.class); } @Override RestResult<Void> saveKtaInvite(ApplicationKtaInviteResource inviteResource); @Override RestResult<ApplicationKtaInviteResource> getKtaInviteByApplication(long applicationId); @Override RestResult<Void> removeKtaInviteByApplication(long applicationId); @Override RestResult<Void> resendKtaInvite(ApplicationKtaInviteResource inviteResource); @Override RestResult<ApplicationKtaInviteResource> getKtaInviteByHash(String hash); @Override RestResult<Void> acceptInvite(String hash); }### Answer: @Test public void resendKtaInvite() { final ApplicationKtaInviteResource invite = newApplicationKtaInviteResource().build(); setupPostWithRestResultExpectations(inviteKtaRestURL + "/resend-kta-invite", invite, OK); RestResult<Void> response = service.resendKtaInvite(invite); assertTrue(response.isSuccess()); setupPostWithRestResultVerifications(inviteKtaRestURL + "/resend-kta-invite", Void.class, invite); }
### Question: ApplicationKtaInviteRestServiceImpl extends BaseRestService implements ApplicationKtaInviteRestService { @Override public RestResult<Void> removeKtaInviteByApplication(long applicationId) { String url = KTA_INVITE_REST_URL + String.format("/remove-kta-invite-by-application/%s", applicationId); return deleteWithRestResult(url); } @Override RestResult<Void> saveKtaInvite(ApplicationKtaInviteResource inviteResource); @Override RestResult<ApplicationKtaInviteResource> getKtaInviteByApplication(long applicationId); @Override RestResult<Void> removeKtaInviteByApplication(long applicationId); @Override RestResult<Void> resendKtaInvite(ApplicationKtaInviteResource inviteResource); @Override RestResult<ApplicationKtaInviteResource> getKtaInviteByHash(String hash); @Override RestResult<Void> acceptInvite(String hash); }### Answer: @Test public void removeKtaInvite() { final Long applicationId = 20310L; setupDeleteWithRestResultExpectations(inviteKtaRestURL + String.format("/remove-kta-invite-by-application/%s", applicationId), OK); RestResult<Void> response = service.removeKtaInviteByApplication(applicationId); assertTrue(response.isSuccess()); }
### Question: ApplicationKtaInviteRestServiceImpl extends BaseRestService implements ApplicationKtaInviteRestService { @Override public RestResult<ApplicationKtaInviteResource> getKtaInviteByApplication(long applicationId) { String url = KTA_INVITE_REST_URL + "/get-kta-invite-by-application-id/"+ applicationId; return getWithRestResult(url, ApplicationKtaInviteResource.class); } @Override RestResult<Void> saveKtaInvite(ApplicationKtaInviteResource inviteResource); @Override RestResult<ApplicationKtaInviteResource> getKtaInviteByApplication(long applicationId); @Override RestResult<Void> removeKtaInviteByApplication(long applicationId); @Override RestResult<Void> resendKtaInvite(ApplicationKtaInviteResource inviteResource); @Override RestResult<ApplicationKtaInviteResource> getKtaInviteByHash(String hash); @Override RestResult<Void> acceptInvite(String hash); }### Answer: @Test public void getKtaInvitesByApplication() { Long applicationId = 2341L; ApplicationKtaInviteResource expected = newApplicationKtaInviteResource().build(); String url = inviteKtaRestURL + "/get-kta-invite-by-application-id/" + applicationId; setupGetWithRestResultExpectations(url, ApplicationKtaInviteResource.class, expected, OK); RestResult<ApplicationKtaInviteResource> response = service.getKtaInviteByApplication(applicationId); assertTrue(response.isSuccess()); assertEquals(expected, response.getSuccess()); }
### Question: ApplicationKtaInviteRestServiceImpl extends BaseRestService implements ApplicationKtaInviteRestService { @Override public RestResult<ApplicationKtaInviteResource> getKtaInviteByHash(String hash) { String url = KTA_INVITE_REST_URL + "/hash/" + hash; return getWithRestResultAnonymous(url, ApplicationKtaInviteResource.class); } @Override RestResult<Void> saveKtaInvite(ApplicationKtaInviteResource inviteResource); @Override RestResult<ApplicationKtaInviteResource> getKtaInviteByApplication(long applicationId); @Override RestResult<Void> removeKtaInviteByApplication(long applicationId); @Override RestResult<Void> resendKtaInvite(ApplicationKtaInviteResource inviteResource); @Override RestResult<ApplicationKtaInviteResource> getKtaInviteByHash(String hash); @Override RestResult<Void> acceptInvite(String hash); }### Answer: @Test public void getKtaInviteByHash() { String hash = "hash"; ApplicationKtaInviteResource expected = newApplicationKtaInviteResource().build(); String url = inviteKtaRestURL + "/hash/" + hash; setupGetWithRestResultAnonymousExpectations(url, ApplicationKtaInviteResource.class, expected, OK); RestResult<ApplicationKtaInviteResource> response = service.getKtaInviteByHash(hash); assertTrue(response.isSuccess()); assertEquals(expected, response.getSuccess()); }
### Question: ApplicationKtaInviteRestServiceImpl extends BaseRestService implements ApplicationKtaInviteRestService { @Override public RestResult<Void> acceptInvite(String hash) { String url = KTA_INVITE_REST_URL + "/hash/" + hash; return postWithRestResult(url, Void.class); } @Override RestResult<Void> saveKtaInvite(ApplicationKtaInviteResource inviteResource); @Override RestResult<ApplicationKtaInviteResource> getKtaInviteByApplication(long applicationId); @Override RestResult<Void> removeKtaInviteByApplication(long applicationId); @Override RestResult<Void> resendKtaInvite(ApplicationKtaInviteResource inviteResource); @Override RestResult<ApplicationKtaInviteResource> getKtaInviteByHash(String hash); @Override RestResult<Void> acceptInvite(String hash); }### Answer: @Test public void acceptInvite() { final String hash = "Hash"; setupPostWithRestResultExpectations(inviteKtaRestURL + "/hash/" + hash, OK); RestResult<Void> response = service.acceptInvite(hash); assertTrue(response.isSuccess()); setupPostWithRestResultVerifications(inviteKtaRestURL + "/hash/" + hash, Void.class); }
### Question: InviteUserRestServiceImpl extends BaseRestService implements InviteUserRestService { @Override public RestResult<Void> saveUserInvite(InviteUserResource inviteUserResource) { String url = INVITE_REST_URL + "/save-invite"; return postWithRestResult(url, inviteUserResource, Void.class); } @Override RestResult<Void> saveUserInvite(InviteUserResource inviteUserResource); @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<RoleInviteResource> getInvite(String inviteHash); @Override RestResult<RoleInvitePageResource> getPendingInternalUserInvites(String filter, int pageNumber, int pageSize); @Override RestResult<List<ExternalInviteResource>> findExternalInvites(String searchString, SearchCategory searchCategory); @Override RestResult<Void> resendInternalUserInvite(long inviteId); }### Answer: @Test public void saveUserInvite() { InviteUserResource inviteUserResource = new InviteUserResource(); String url = inviteRestBaseUrl + "/save-invite"; setupPostWithRestResultExpectations(url, inviteUserResource, HttpStatus.OK); RestResult<Void> result = service.saveUserInvite(inviteUserResource); assertTrue(result.isSuccess()); }
### Question: InviteUserRestServiceImpl extends BaseRestService implements InviteUserRestService { @Override public RestResult<RoleInviteResource> getInvite(String inviteHash) { return getWithRestResultAnonymous(format("%s/%s/%s", INVITE_REST_URL, "get-invite", inviteHash), RoleInviteResource.class); } @Override RestResult<Void> saveUserInvite(InviteUserResource inviteUserResource); @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<RoleInviteResource> getInvite(String inviteHash); @Override RestResult<RoleInvitePageResource> getPendingInternalUserInvites(String filter, int pageNumber, int pageSize); @Override RestResult<List<ExternalInviteResource>> findExternalInvites(String searchString, SearchCategory searchCategory); @Override RestResult<Void> resendInternalUserInvite(long inviteId); }### Answer: @Test public void getInvite() { RoleInviteResource roleInviteResource = new RoleInviteResource(); String url = inviteRestBaseUrl + "/get-invite/"; String inviteHash = "hash"; setupGetWithRestResultAnonymousExpectations(url + inviteHash, RoleInviteResource.class, roleInviteResource); RestResult<RoleInviteResource> result = service.getInvite(inviteHash); assertTrue(result.isSuccess()); assertEquals(roleInviteResource, result.getSuccess()); }
### Question: InviteUserRestServiceImpl extends BaseRestService implements InviteUserRestService { @Override public RestResult<Boolean> checkExistingUser(String inviteHash) { return getWithRestResultAnonymous(format("%s/%s/%s", INVITE_REST_URL, "check-existing-user", inviteHash), Boolean.class); } @Override RestResult<Void> saveUserInvite(InviteUserResource inviteUserResource); @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<RoleInviteResource> getInvite(String inviteHash); @Override RestResult<RoleInvitePageResource> getPendingInternalUserInvites(String filter, int pageNumber, int pageSize); @Override RestResult<List<ExternalInviteResource>> findExternalInvites(String searchString, SearchCategory searchCategory); @Override RestResult<Void> resendInternalUserInvite(long inviteId); }### Answer: @Test public void checkExistingUser() { String url = inviteRestBaseUrl + "/check-existing-user/"; String inviteHash = "hash"; setupGetWithRestResultAnonymousExpectations(url + inviteHash, Boolean.class, true); RestResult<Boolean> returnedResponse = service.checkExistingUser(inviteHash); assertTrue(returnedResponse.isSuccess()); assertTrue(returnedResponse.getSuccess()); }
### Question: InviteUserRestServiceImpl extends BaseRestService implements InviteUserRestService { @Override public RestResult<RoleInvitePageResource> getPendingInternalUserInvites(String filter, int pageNumber, int pageSize) { MultiValueMap<String, String> params = new LinkedMultiValueMap<>(); params.add("filter", filter); String uriWithParams = buildPaginationUri(INVITE_REST_URL + "/internal/pending", pageNumber, pageSize, null, params); return getWithRestResult(uriWithParams, RoleInvitePageResource.class); } @Override RestResult<Void> saveUserInvite(InviteUserResource inviteUserResource); @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<RoleInviteResource> getInvite(String inviteHash); @Override RestResult<RoleInvitePageResource> getPendingInternalUserInvites(String filter, int pageNumber, int pageSize); @Override RestResult<List<ExternalInviteResource>> findExternalInvites(String searchString, SearchCategory searchCategory); @Override RestResult<Void> resendInternalUserInvite(long inviteId); }### Answer: @Test public void getPendingInternalUsers() { RoleInvitePageResource expected = new RoleInvitePageResource(); MultiValueMap<String, String> params = new LinkedMultiValueMap<>(); params.add("filter", ""); setupGetWithRestResultExpectations(buildPaginationUri(inviteRestBaseUrl + "/internal/pending", 0, 5, null, params), RoleInvitePageResource.class, expected, OK); RoleInvitePageResource result = service.getPendingInternalUserInvites("", 0, 5).getSuccess(); assertEquals(expected, result); }
### Question: InviteUserRestServiceImpl extends BaseRestService implements InviteUserRestService { @Override public RestResult<List<ExternalInviteResource>> findExternalInvites(String searchString, SearchCategory searchCategory) { return getWithRestResult(INVITE_REST_URL + "/find-external-invites?searchString=" + searchString + "&searchCategory=" + searchCategory.name(), externalInviteResourceListType()); } @Override RestResult<Void> saveUserInvite(InviteUserResource inviteUserResource); @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<RoleInviteResource> getInvite(String inviteHash); @Override RestResult<RoleInvitePageResource> getPendingInternalUserInvites(String filter, int pageNumber, int pageSize); @Override RestResult<List<ExternalInviteResource>> findExternalInvites(String searchString, SearchCategory searchCategory); @Override RestResult<Void> resendInternalUserInvite(long inviteId); }### Answer: @Test public void findExternalInvites() { String searchString = "%a%"; SearchCategory searchCategory = SearchCategory.NAME; List<ExternalInviteResource> expected = Collections.singletonList(new ExternalInviteResource()); setupGetWithRestResultExpectations(inviteRestBaseUrl + "/find-external-invites?searchString=" + searchString + "&searchCategory=" + searchCategory.name(), externalInviteResourceListType(), expected, OK); List<ExternalInviteResource> result = service.findExternalInvites(searchString, searchCategory).getSuccess(); assertEquals(expected, result); }
### Question: InviteUserRestServiceImpl extends BaseRestService implements InviteUserRestService { @Override public RestResult<Void> resendInternalUserInvite(long inviteId) { return putWithRestResult(INVITE_REST_URL + "/internal/pending/" + inviteId + "/resend", Void.class); } @Override RestResult<Void> saveUserInvite(InviteUserResource inviteUserResource); @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<RoleInviteResource> getInvite(String inviteHash); @Override RestResult<RoleInvitePageResource> getPendingInternalUserInvites(String filter, int pageNumber, int pageSize); @Override RestResult<List<ExternalInviteResource>> findExternalInvites(String searchString, SearchCategory searchCategory); @Override RestResult<Void> resendInternalUserInvite(long inviteId); }### Answer: @Test public void resendInternalUserInvite() { setupPutWithRestResultExpectations(inviteRestBaseUrl + "/internal/pending/123/resend", OK); RestResult<Void> result = service.resendInternalUserInvite(123L); assertTrue(result.isSuccess()); setupPutWithRestResultVerifications(inviteRestBaseUrl + "/internal/pending/123/resend"); }
### Question: RejectionReasonRestServiceImpl extends BaseRestService implements RejectionReasonRestService { @Override public RestResult<List<RejectionReasonResource>> findAllActive() { return getWithRestResultAnonymous(format("%s/find-all-active", rejectionReasonRestUrl), rejectionReasonResourceListType()); } @Override RestResult<List<RejectionReasonResource>> findAllActive(); }### Answer: @Test public void findAllActive() throws Exception { List<RejectionReasonResource> expected = Stream.of(1, 2).map(i -> new RejectionReasonResource()).collect(Collectors.toList()); setupGetWithRestResultAnonymousExpectations(format("%s/find-all-active", rejectionReasonRestUrl), rejectionReasonResourceListType(), expected, OK); List<RejectionReasonResource> response = service.findAllActive().getSuccess(); assertSame(expected, response); }
### Question: InviteRestServiceImpl extends BaseRestService implements InviteRestService { @Override public RestResult<Void> saveInvites(List<ApplicationInviteResource> inviteResources) { String url = inviteRestUrl + "/save-invites"; return postWithRestResult(url, inviteResources, Void.class); } @Override RestResult<Void> createInvitesByInviteOrganisation(String organisationName, List<ApplicationInviteResource> invites); @Override RestResult<Void> createInvitesByOrganisation(Long organisationId, List<ApplicationInviteResource> invites); @Override RestResult<Void> createInvitesByOrganisationForApplication(Long applicationId, Long organisationId, List<ApplicationInviteResource> invites); @Override RestResult<Void> saveInvites(List<ApplicationInviteResource> inviteResources); @Override RestResult<Void> resendInvite(ApplicationInviteResource inviteResource); @Override RestResult<Void> acceptInvite(String inviteHash, long userId); @Override RestResult<Void> acceptInvite(String inviteHash, long userId, long organisationId); @Override RestResult<Void> removeApplicationInvite(Long inviteId); @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<UserResource> getUser(String inviteHash); @Override RestResult<ApplicationInviteResource> getInviteByHash(String hash); @Override RestResult<InviteOrganisationResource> getInviteOrganisationByHash(String hash); @Override RestResult<List<InviteOrganisationResource>> getInvitesByApplication(Long applicationId); }### Answer: @Test public void saveInvites() { final List<ApplicationInviteResource> invites = newApplicationInviteResource().build(42); setupPostWithRestResultExpectations(inviteRestURL + "/save-invites", invites, OK); RestResult<Void> response = service.saveInvites(invites); assertTrue(response.isSuccess()); setupPostWithRestResultVerifications(inviteRestURL + "/save-invites", Void.class, invites); }
### Question: InviteRestServiceImpl extends BaseRestService implements InviteRestService { @Override public RestResult<Void> resendInvite(ApplicationInviteResource inviteResource) { String url = inviteRestUrl + "/resend-invite"; return postWithRestResult(url, inviteResource, Void.class); } @Override RestResult<Void> createInvitesByInviteOrganisation(String organisationName, List<ApplicationInviteResource> invites); @Override RestResult<Void> createInvitesByOrganisation(Long organisationId, List<ApplicationInviteResource> invites); @Override RestResult<Void> createInvitesByOrganisationForApplication(Long applicationId, Long organisationId, List<ApplicationInviteResource> invites); @Override RestResult<Void> saveInvites(List<ApplicationInviteResource> inviteResources); @Override RestResult<Void> resendInvite(ApplicationInviteResource inviteResource); @Override RestResult<Void> acceptInvite(String inviteHash, long userId); @Override RestResult<Void> acceptInvite(String inviteHash, long userId, long organisationId); @Override RestResult<Void> removeApplicationInvite(Long inviteId); @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<UserResource> getUser(String inviteHash); @Override RestResult<ApplicationInviteResource> getInviteByHash(String hash); @Override RestResult<InviteOrganisationResource> getInviteOrganisationByHash(String hash); @Override RestResult<List<InviteOrganisationResource>> getInvitesByApplication(Long applicationId); }### Answer: @Test public void resendInvites() { final ApplicationInviteResource invite = newApplicationInviteResource().build(); setupPostWithRestResultExpectations(inviteRestURL + "/resend-invite", invite, OK); RestResult<Void> response = service.resendInvite(invite); assertTrue(response.isSuccess()); setupPostWithRestResultVerifications(inviteRestURL + "/resend-invite", Void.class, invite); }
### Question: InviteRestServiceImpl extends BaseRestService implements InviteRestService { @Override public RestResult<Void> removeApplicationInvite(Long inviteId) { String url = inviteRestUrl + String.format("/remove-invite/%s", inviteId); return deleteWithRestResult(url); } @Override RestResult<Void> createInvitesByInviteOrganisation(String organisationName, List<ApplicationInviteResource> invites); @Override RestResult<Void> createInvitesByOrganisation(Long organisationId, List<ApplicationInviteResource> invites); @Override RestResult<Void> createInvitesByOrganisationForApplication(Long applicationId, Long organisationId, List<ApplicationInviteResource> invites); @Override RestResult<Void> saveInvites(List<ApplicationInviteResource> inviteResources); @Override RestResult<Void> resendInvite(ApplicationInviteResource inviteResource); @Override RestResult<Void> acceptInvite(String inviteHash, long userId); @Override RestResult<Void> acceptInvite(String inviteHash, long userId, long organisationId); @Override RestResult<Void> removeApplicationInvite(Long inviteId); @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<UserResource> getUser(String inviteHash); @Override RestResult<ApplicationInviteResource> getInviteByHash(String hash); @Override RestResult<InviteOrganisationResource> getInviteOrganisationByHash(String hash); @Override RestResult<List<InviteOrganisationResource>> getInvitesByApplication(Long applicationId); }### Answer: @Test public void removeApplicationInvite() { final Long inviteId = 20310L; setupDeleteWithRestResultExpectations(inviteRestURL + String.format("/remove-invite/%s", inviteId), OK); RestResult<Void> response = service.removeApplicationInvite(inviteId); assertTrue(response.isSuccess()); }
### Question: InviteRestServiceImpl extends BaseRestService implements InviteRestService { @Override public RestResult<Boolean> checkExistingUser(String inviteHash) { String url = inviteRestUrl + String.format("/check-existing-user/%s", inviteHash); return getWithRestResultAnonymous(url, Boolean.class); } @Override RestResult<Void> createInvitesByInviteOrganisation(String organisationName, List<ApplicationInviteResource> invites); @Override RestResult<Void> createInvitesByOrganisation(Long organisationId, List<ApplicationInviteResource> invites); @Override RestResult<Void> createInvitesByOrganisationForApplication(Long applicationId, Long organisationId, List<ApplicationInviteResource> invites); @Override RestResult<Void> saveInvites(List<ApplicationInviteResource> inviteResources); @Override RestResult<Void> resendInvite(ApplicationInviteResource inviteResource); @Override RestResult<Void> acceptInvite(String inviteHash, long userId); @Override RestResult<Void> acceptInvite(String inviteHash, long userId, long organisationId); @Override RestResult<Void> removeApplicationInvite(Long inviteId); @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<UserResource> getUser(String inviteHash); @Override RestResult<ApplicationInviteResource> getInviteByHash(String hash); @Override RestResult<InviteOrganisationResource> getInviteOrganisationByHash(String hash); @Override RestResult<List<InviteOrganisationResource>> getInvitesByApplication(Long applicationId); }### Answer: @Test public void checkExistingUser() { String url = inviteRestURL + String.format("/check-existing-user/%s", inviteHash); setupGetWithRestResultAnonymousExpectations(url, Boolean.class, TRUE); RestResult<Boolean> response = service.checkExistingUser(inviteHash); assertTrue(response.isSuccess()); assertEquals(TRUE, response.getSuccess()); }
### Question: InviteRestServiceImpl extends BaseRestService implements InviteRestService { @Override public RestResult<UserResource> getUser(String inviteHash) { String url = inviteRestUrl + String.format(GET_USER_BY_HASH_MAPPING + "%s", inviteHash); return getWithRestResultAnonymous(url, UserResource.class); } @Override RestResult<Void> createInvitesByInviteOrganisation(String organisationName, List<ApplicationInviteResource> invites); @Override RestResult<Void> createInvitesByOrganisation(Long organisationId, List<ApplicationInviteResource> invites); @Override RestResult<Void> createInvitesByOrganisationForApplication(Long applicationId, Long organisationId, List<ApplicationInviteResource> invites); @Override RestResult<Void> saveInvites(List<ApplicationInviteResource> inviteResources); @Override RestResult<Void> resendInvite(ApplicationInviteResource inviteResource); @Override RestResult<Void> acceptInvite(String inviteHash, long userId); @Override RestResult<Void> acceptInvite(String inviteHash, long userId, long organisationId); @Override RestResult<Void> removeApplicationInvite(Long inviteId); @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<UserResource> getUser(String inviteHash); @Override RestResult<ApplicationInviteResource> getInviteByHash(String hash); @Override RestResult<InviteOrganisationResource> getInviteOrganisationByHash(String hash); @Override RestResult<List<InviteOrganisationResource>> getInvitesByApplication(Long applicationId); }### Answer: @Test public void getUser() { UserResource expected = new UserResource(); String url = inviteRestURL + String.format("/get-user/" + "%s", inviteHash); setupGetWithRestResultAnonymousExpectations(url, UserResource.class, expected); RestResult<UserResource> response = service.getUser(inviteHash); assertTrue(response.isSuccess()); assertEquals(expected, response.getSuccess()); }
### Question: InviteRestServiceImpl extends BaseRestService implements InviteRestService { @Override public RestResult<ApplicationInviteResource> getInviteByHash(String hash) { return getWithRestResultAnonymous(inviteRestUrl + "/get-invite-by-hash/" + hash, ApplicationInviteResource.class); } @Override RestResult<Void> createInvitesByInviteOrganisation(String organisationName, List<ApplicationInviteResource> invites); @Override RestResult<Void> createInvitesByOrganisation(Long organisationId, List<ApplicationInviteResource> invites); @Override RestResult<Void> createInvitesByOrganisationForApplication(Long applicationId, Long organisationId, List<ApplicationInviteResource> invites); @Override RestResult<Void> saveInvites(List<ApplicationInviteResource> inviteResources); @Override RestResult<Void> resendInvite(ApplicationInviteResource inviteResource); @Override RestResult<Void> acceptInvite(String inviteHash, long userId); @Override RestResult<Void> acceptInvite(String inviteHash, long userId, long organisationId); @Override RestResult<Void> removeApplicationInvite(Long inviteId); @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<UserResource> getUser(String inviteHash); @Override RestResult<ApplicationInviteResource> getInviteByHash(String hash); @Override RestResult<InviteOrganisationResource> getInviteOrganisationByHash(String hash); @Override RestResult<List<InviteOrganisationResource>> getInvitesByApplication(Long applicationId); }### Answer: @Test public void getInviteByHash() { ApplicationInviteResource expected = new ApplicationInviteResource(); String url = inviteRestURL + "/get-invite-by-hash/" + inviteHash; setupGetWithRestResultAnonymousExpectations(url, ApplicationInviteResource.class, expected); RestResult<ApplicationInviteResource> response = service.getInviteByHash(inviteHash); assertTrue(response.isSuccess()); assertEquals(expected, response.getSuccess()); }
### Question: InviteRestServiceImpl extends BaseRestService implements InviteRestService { @Override public RestResult<InviteOrganisationResource> getInviteOrganisationByHash(String hash) { return getWithRestResultAnonymous(inviteRestUrl + "/get-invite-organisation-by-hash/" + hash, InviteOrganisationResource.class); } @Override RestResult<Void> createInvitesByInviteOrganisation(String organisationName, List<ApplicationInviteResource> invites); @Override RestResult<Void> createInvitesByOrganisation(Long organisationId, List<ApplicationInviteResource> invites); @Override RestResult<Void> createInvitesByOrganisationForApplication(Long applicationId, Long organisationId, List<ApplicationInviteResource> invites); @Override RestResult<Void> saveInvites(List<ApplicationInviteResource> inviteResources); @Override RestResult<Void> resendInvite(ApplicationInviteResource inviteResource); @Override RestResult<Void> acceptInvite(String inviteHash, long userId); @Override RestResult<Void> acceptInvite(String inviteHash, long userId, long organisationId); @Override RestResult<Void> removeApplicationInvite(Long inviteId); @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<UserResource> getUser(String inviteHash); @Override RestResult<ApplicationInviteResource> getInviteByHash(String hash); @Override RestResult<InviteOrganisationResource> getInviteOrganisationByHash(String hash); @Override RestResult<List<InviteOrganisationResource>> getInvitesByApplication(Long applicationId); }### Answer: @Test public void getInviteOrganisationByHash() { InviteOrganisationResource expected = new InviteOrganisationResource(); expected.setId(1234L); String url = inviteRestURL + "/get-invite-organisation-by-hash/" + inviteHash; setupGetWithRestResultAnonymousExpectations(url, InviteOrganisationResource.class, expected); RestResult<InviteOrganisationResource> response = service.getInviteOrganisationByHash(inviteHash); assertTrue(response.isSuccess()); assertEquals(expected, response.getSuccess()); }
### Question: InviteRestServiceImpl extends BaseRestService implements InviteRestService { @Override public RestResult<List<InviteOrganisationResource>> getInvitesByApplication(Long applicationId) { String url = inviteRestUrl + "/get-invites-by-application-id/"+ applicationId; return getWithRestResult(url, inviteOrganisationResourceListType()); } @Override RestResult<Void> createInvitesByInviteOrganisation(String organisationName, List<ApplicationInviteResource> invites); @Override RestResult<Void> createInvitesByOrganisation(Long organisationId, List<ApplicationInviteResource> invites); @Override RestResult<Void> createInvitesByOrganisationForApplication(Long applicationId, Long organisationId, List<ApplicationInviteResource> invites); @Override RestResult<Void> saveInvites(List<ApplicationInviteResource> inviteResources); @Override RestResult<Void> resendInvite(ApplicationInviteResource inviteResource); @Override RestResult<Void> acceptInvite(String inviteHash, long userId); @Override RestResult<Void> acceptInvite(String inviteHash, long userId, long organisationId); @Override RestResult<Void> removeApplicationInvite(Long inviteId); @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<UserResource> getUser(String inviteHash); @Override RestResult<ApplicationInviteResource> getInviteByHash(String hash); @Override RestResult<InviteOrganisationResource> getInviteOrganisationByHash(String hash); @Override RestResult<List<InviteOrganisationResource>> getInvitesByApplication(Long applicationId); }### Answer: @Test public void getInvitesByApplication() { Long applicationId = 2341L; List<InviteOrganisationResource> expected = newInviteOrganisationResource().build(2); String url = inviteRestURL + "/get-invites-by-application-id/" + applicationId; setupGetWithRestResultExpectations(url, inviteOrganisationResourceListType(), expected, OK); RestResult<List<InviteOrganisationResource>> response = service.getInvitesByApplication(applicationId); assertTrue(response.isSuccess()); assertEquals(expected, response.getSuccess()); }
### Question: ProjectInviteRestServiceImpl extends BaseRestService implements ProjectInviteRestService { @Override public RestResult<Void> acceptInvite(String inviteHash, Long userId) { String url = PROJECT_INVITE_BASE_URL + ACCEPT_INVITE + inviteHash + "/" + userId; return putWithRestResultAnonymous(url, Void.class); } @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<UserResource> getUser(String inviteHash); @Override RestResult<ProjectUserInviteResource> getInviteByHash(String hash); @Override RestResult<Void> acceptInvite(String inviteHash, Long userId); @Override RestResult<List<ProjectUserInviteResource>> getInvitesByProject(Long projectId); }### Answer: @Test public void testGetProjectById() { String inviteHash = "hash"; Long userId = 1L; setupPutWithRestResultAnonymousExpectations(PROJECT_INVITE_BASE_URL + ACCEPT_INVITE + inviteHash + "/" + userId, null, OK); RestResult<Void> returnedResponse = service.acceptInvite(inviteHash, userId); assertTrue(returnedResponse.isSuccess()); }
### Question: ProjectInviteRestServiceImpl extends BaseRestService implements ProjectInviteRestService { @Override public RestResult<Boolean> checkExistingUser(String inviteHash) { String url = PROJECT_INVITE_BASE_URL + CHECK_EXISTING_USER_URL + inviteHash; return getWithRestResultAnonymous(url, Boolean.class); } @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<UserResource> getUser(String inviteHash); @Override RestResult<ProjectUserInviteResource> getInviteByHash(String hash); @Override RestResult<Void> acceptInvite(String inviteHash, Long userId); @Override RestResult<List<ProjectUserInviteResource>> getInvitesByProject(Long projectId); }### Answer: @Test public void testCheckExistingUser() { String inviteHash = "hash"; setupGetWithRestResultAnonymousExpectations(PROJECT_INVITE_BASE_URL + CHECK_EXISTING_USER_URL + inviteHash, Boolean.class, true); RestResult<Boolean> returnedResponse = service.checkExistingUser(inviteHash); assertTrue(returnedResponse.isSuccess()); assertTrue(returnedResponse.getSuccess()); }
### Question: ProjectInviteRestServiceImpl extends BaseRestService implements ProjectInviteRestService { @Override public RestResult<ProjectUserInviteResource> getInviteByHash(String hash) { String url = PROJECT_INVITE_BASE_URL + GET_INVITE_BY_HASH + hash; return getWithRestResultAnonymous(url, ProjectUserInviteResource.class); } @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<UserResource> getUser(String inviteHash); @Override RestResult<ProjectUserInviteResource> getInviteByHash(String hash); @Override RestResult<Void> acceptInvite(String inviteHash, Long userId); @Override RestResult<List<ProjectUserInviteResource>> getInvitesByProject(Long projectId); }### Answer: @Test public void testGetInviteByHash() { ProjectUserInviteResource invite = new ProjectUserInviteResource(); invite.setHash("hash"); setupGetWithRestResultAnonymousExpectations(PROJECT_INVITE_BASE_URL + GET_INVITE_BY_HASH + invite.getHash(), ProjectUserInviteResource.class, invite); RestResult<ProjectUserInviteResource> returnedResponse = service.getInviteByHash(invite.getHash()); assertTrue(returnedResponse.isSuccess()); assertEquals(invite, returnedResponse.getSuccess()); }
### Question: ProjectInviteRestServiceImpl extends BaseRestService implements ProjectInviteRestService { @Override public RestResult<UserResource> getUser(String inviteHash) { String url = PROJECT_INVITE_BASE_URL + GET_USER_BY_HASH_MAPPING + inviteHash; return getWithRestResultAnonymous(url, UserResource.class); } @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<UserResource> getUser(String inviteHash); @Override RestResult<ProjectUserInviteResource> getInviteByHash(String hash); @Override RestResult<Void> acceptInvite(String inviteHash, Long userId); @Override RestResult<List<ProjectUserInviteResource>> getInvitesByProject(Long projectId); }### Answer: @Test public void testGetUser() { UserResource user = new UserResource(); String inviteHash = "hash"; setupGetWithRestResultAnonymousExpectations(PROJECT_INVITE_BASE_URL + GET_USER_BY_HASH_MAPPING + inviteHash, UserResource.class, user); RestResult<UserResource> returnedResponse = service.getUser(inviteHash); assertTrue(returnedResponse.isSuccess()); assertEquals(user, returnedResponse.getSuccess()); }
### Question: InviteOrganisationRestServiceImpl extends BaseRestService implements InviteOrganisationRestService { @Override public RestResult<InviteOrganisationResource> getById(long id) { return getWithRestResult(format("%s/%s", restUrl, id), InviteOrganisationResource.class); } @Override RestResult<InviteOrganisationResource> getById(long id); @Override RestResult<InviteOrganisationResource> getByIdForAnonymousUserFlow(long id); @Override RestResult<InviteOrganisationResource> getByOrganisationIdWithInvitesForApplication(long organisationId, long applicationId); @Override RestResult<Void> put(InviteOrganisationResource inviteOrganisation); }### Answer: @Test public void getById() throws Exception { long inviteOrganisationId = 1L; InviteOrganisationResource expected = newInviteOrganisationResource().build(); setupGetWithRestResultExpectations(format("%s/%s", restUrl, inviteOrganisationId), InviteOrganisationResource.class, expected); InviteOrganisationResource actual = service.getById(inviteOrganisationId).getSuccess(); assertEquals(expected, actual); }
### Question: InviteOrganisationRestServiceImpl extends BaseRestService implements InviteOrganisationRestService { @Override public RestResult<InviteOrganisationResource> getByIdForAnonymousUserFlow(long id) { return getWithRestResultAnonymous(format("%s/%s", restUrl, id), InviteOrganisationResource.class); } @Override RestResult<InviteOrganisationResource> getById(long id); @Override RestResult<InviteOrganisationResource> getByIdForAnonymousUserFlow(long id); @Override RestResult<InviteOrganisationResource> getByOrganisationIdWithInvitesForApplication(long organisationId, long applicationId); @Override RestResult<Void> put(InviteOrganisationResource inviteOrganisation); }### Answer: @Test public void getByIdForAnonymousUserFlow() throws Exception { long inviteOrganisationId = 1L; InviteOrganisationResource expected = newInviteOrganisationResource().build(); setupGetWithRestResultAnonymousExpectations(format("%s/%s", restUrl, inviteOrganisationId), InviteOrganisationResource.class, expected); InviteOrganisationResource actual = service.getByIdForAnonymousUserFlow(inviteOrganisationId).getSuccess(); assertEquals(expected, actual); }
### Question: InviteOrganisationRestServiceImpl extends BaseRestService implements InviteOrganisationRestService { @Override public RestResult<InviteOrganisationResource> getByOrganisationIdWithInvitesForApplication(long organisationId, long applicationId) { return getWithRestResult(format("%s/organisation/%s/application/%s", restUrl, organisationId, applicationId), InviteOrganisationResource.class); } @Override RestResult<InviteOrganisationResource> getById(long id); @Override RestResult<InviteOrganisationResource> getByIdForAnonymousUserFlow(long id); @Override RestResult<InviteOrganisationResource> getByOrganisationIdWithInvitesForApplication(long organisationId, long applicationId); @Override RestResult<Void> put(InviteOrganisationResource inviteOrganisation); }### Answer: @Test public void getByOrganisationIdWithInvitesForApplication() throws Exception { long organisationId = 1L; long applicationId = 2L; InviteOrganisationResource expected = newInviteOrganisationResource().build(); setupGetWithRestResultExpectations(format("%s/organisation/%s/application/%s", restUrl, organisationId, applicationId), InviteOrganisationResource.class, expected); InviteOrganisationResource actual = service.getByOrganisationIdWithInvitesForApplication(organisationId, applicationId) .getSuccess(); assertEquals(expected, actual); }
### Question: InviteOrganisationRestServiceImpl extends BaseRestService implements InviteOrganisationRestService { @Override public RestResult<Void> put(InviteOrganisationResource inviteOrganisation) { return putWithRestResult(restUrl + "/save", inviteOrganisation, Void.class); } @Override RestResult<InviteOrganisationResource> getById(long id); @Override RestResult<InviteOrganisationResource> getByIdForAnonymousUserFlow(long id); @Override RestResult<InviteOrganisationResource> getByOrganisationIdWithInvitesForApplication(long organisationId, long applicationId); @Override RestResult<Void> put(InviteOrganisationResource inviteOrganisation); }### Answer: @Test public void put() throws Exception { InviteOrganisationResource inviteOrganisationResource = newInviteOrganisationResource().build(); setupPutWithRestResultExpectations(format("%s/save", restUrl), inviteOrganisationResource, OK); RestResult<Void> result = service.put(inviteOrganisationResource); assertTrue(result.isSuccess()); }
### Question: ActionTypeRestServiceImpl extends BaseRestService implements ActionTypeRestService { @Override public RestResult<List<EuActionTypeResource>> findAll() { return getWithRestResult(baseURL + "/find-all", euActionTypeResourceListType()); } @Override RestResult<List<EuActionTypeResource>> findAll(); @Override RestResult<EuActionTypeResource> getById(long id); static ParameterizedTypeReference<List<EuActionTypeResource>> euActionTypeResourceListType(); }### Answer: @Test public void findAll() { List<EuActionTypeResource> expected = emptyList(); setupGetWithRestResultExpectations(format("%s/%s", REST_URL, "find-all"), euActionTypeResourceListType(), expected, OK); List<EuActionTypeResource> response = service.findAll().getSuccess(); assertSame(expected, response); }
### Question: ActionTypeRestServiceImpl extends BaseRestService implements ActionTypeRestService { @Override public RestResult<EuActionTypeResource> getById(long id) { return getWithRestResult(baseURL + "/get-by-id/" + id, EuActionTypeResource.class); } @Override RestResult<List<EuActionTypeResource>> findAll(); @Override RestResult<EuActionTypeResource> getById(long id); static ParameterizedTypeReference<List<EuActionTypeResource>> euActionTypeResourceListType(); }### Answer: @Test public void getById() { long id = 1L; EuActionTypeResource expected = new EuActionTypeResource(); setupGetWithRestResultExpectations(format("%s/%s/%d", REST_URL, "get-by-id", id), EuActionTypeResource.class, expected, OK); EuActionTypeResource response = service.getById(id).getSuccess(); assertSame(expected, response); }
### Question: EuGrantTransferRestServiceImpl extends BaseRestService implements EuGrantTransferRestService { @Override public RestResult<FileEntryResource> findGrantAgreement(long applicationId) { String url = format("%s/%s/%s", REST_URL, "grant-agreement-details", applicationId); return getWithRestResult(url, FileEntryResource.class); } @Override RestResult<Void> uploadGrantAgreement(long applicationId, String contentType, long size, String originalFilename, byte[] multipartFileBytes); @Override RestResult<Void> deleteGrantAgreement(long applicationId); @Override RestResult<ByteArrayResource> downloadGrantAgreement(long applicationId); @Override RestResult<FileEntryResource> findGrantAgreement(long applicationId); @Override RestResult<EuGrantTransferResource> findDetailsByApplicationId(long applicationId); @Override RestResult<Void> updateGrantTransferDetails(EuGrantTransferResource euGrantResource, long applicationId); }### Answer: @Test public void findGrantAgreement() { long applicationId = 1L; FileEntryResource expected = new FileEntryResource(); setupGetWithRestResultExpectations(format("%s/%s/%s", REST_URL, "grant-agreement-details", applicationId), FileEntryResource.class, expected, OK); final FileEntryResource response = service.findGrantAgreement(applicationId).getSuccess(); assertSame(expected, response); }
### Question: EuGrantTransferRestServiceImpl extends BaseRestService implements EuGrantTransferRestService { @Override public RestResult<Void> uploadGrantAgreement(long applicationId, String contentType, long size, String originalFilename, byte[] multipartFileBytes) { String url = format("%s/%s/%s?filename=%s", REST_URL, "grant-agreement", applicationId, originalFilename); return postWithRestResult(url, multipartFileBytes, createFileUploadHeader(contentType, size), Void.class); } @Override RestResult<Void> uploadGrantAgreement(long applicationId, String contentType, long size, String originalFilename, byte[] multipartFileBytes); @Override RestResult<Void> deleteGrantAgreement(long applicationId); @Override RestResult<ByteArrayResource> downloadGrantAgreement(long applicationId); @Override RestResult<FileEntryResource> findGrantAgreement(long applicationId); @Override RestResult<EuGrantTransferResource> findDetailsByApplicationId(long applicationId); @Override RestResult<Void> updateGrantTransferDetails(EuGrantTransferResource euGrantResource, long applicationId); }### Answer: @Test public void uploadGrantAgreement() { String fileContentString = "keDFjFGrueurFGy3456efhjdg3"; byte[] fileContent = fileContentString.getBytes(); final String originalFilename = "testFile.pdf"; final String contentType = "text/pdf"; final long applicationId = 77L; setupFileUploadWithRestResultExpectations(format("%s/%s/%s?filename=%s", REST_URL, "grant-agreement", applicationId, originalFilename), fileContentString, contentType, fileContent.length, CREATED); RestResult<Void> result = service.uploadGrantAgreement(applicationId, contentType, fileContent.length, originalFilename, fileContent); assertTrue(result.isSuccess()); }
### Question: EuGrantTransferRestServiceImpl extends BaseRestService implements EuGrantTransferRestService { @Override public RestResult<Void> deleteGrantAgreement(long applicationId) { String url = format("%s/%s/%s", REST_URL, "grant-agreement", applicationId); return deleteWithRestResult(url); } @Override RestResult<Void> uploadGrantAgreement(long applicationId, String contentType, long size, String originalFilename, byte[] multipartFileBytes); @Override RestResult<Void> deleteGrantAgreement(long applicationId); @Override RestResult<ByteArrayResource> downloadGrantAgreement(long applicationId); @Override RestResult<FileEntryResource> findGrantAgreement(long applicationId); @Override RestResult<EuGrantTransferResource> findDetailsByApplicationId(long applicationId); @Override RestResult<Void> updateGrantTransferDetails(EuGrantTransferResource euGrantResource, long applicationId); }### Answer: @Test public void deleteGrantAgreement() { long applicationId = 78L; setupDeleteWithRestResultExpectations(format("%s/%s/%s", REST_URL, "grant-agreement", applicationId)); service.deleteGrantAgreement(applicationId); setupDeleteWithRestResultVerifications(format("%s/%s/%s", REST_URL, "grant-agreement", applicationId)); }
### Question: EuGrantTransferRestServiceImpl extends BaseRestService implements EuGrantTransferRestService { @Override public RestResult<ByteArrayResource> downloadGrantAgreement(long applicationId) { String url = format("%s/%s/%s", REST_URL, "grant-agreement", applicationId); return getWithRestResult(url, ByteArrayResource.class); } @Override RestResult<Void> uploadGrantAgreement(long applicationId, String contentType, long size, String originalFilename, byte[] multipartFileBytes); @Override RestResult<Void> deleteGrantAgreement(long applicationId); @Override RestResult<ByteArrayResource> downloadGrantAgreement(long applicationId); @Override RestResult<FileEntryResource> findGrantAgreement(long applicationId); @Override RestResult<EuGrantTransferResource> findDetailsByApplicationId(long applicationId); @Override RestResult<Void> updateGrantTransferDetails(EuGrantTransferResource euGrantResource, long applicationId); }### Answer: @Test public void downloadGrantAgreement() { final long applicationId = 912L; ByteArrayResource expected = new ByteArrayResource("1u6536748".getBytes()); setupGetWithRestResultExpectations(format("%s/%s/%s", REST_URL, "grant-agreement", applicationId), ByteArrayResource.class, expected, OK); final ByteArrayResource response = service.downloadGrantAgreement(applicationId).getSuccess(); assertSame(expected, response); }
### Question: EuGrantTransferRestServiceImpl extends BaseRestService implements EuGrantTransferRestService { @Override public RestResult<EuGrantTransferResource> findDetailsByApplicationId(long applicationId) { String url = format("%s/%d", REST_URL, applicationId); return getWithRestResult(url, EuGrantTransferResource.class); } @Override RestResult<Void> uploadGrantAgreement(long applicationId, String contentType, long size, String originalFilename, byte[] multipartFileBytes); @Override RestResult<Void> deleteGrantAgreement(long applicationId); @Override RestResult<ByteArrayResource> downloadGrantAgreement(long applicationId); @Override RestResult<FileEntryResource> findGrantAgreement(long applicationId); @Override RestResult<EuGrantTransferResource> findDetailsByApplicationId(long applicationId); @Override RestResult<Void> updateGrantTransferDetails(EuGrantTransferResource euGrantResource, long applicationId); }### Answer: @Test public void findDetailsByApplicationId() { final long applicationId = 912L; EuGrantTransferResource euGrantTransferResource = newEuGrantTransferResource().build(); setupGetWithRestResultExpectations(format("%s/%s", REST_URL, applicationId), EuGrantTransferResource.class, euGrantTransferResource, OK); RestResult<EuGrantTransferResource> result = service.findDetailsByApplicationId(applicationId); assertSame(euGrantTransferResource, result.getSuccess()); }
### Question: EuGrantTransferRestServiceImpl extends BaseRestService implements EuGrantTransferRestService { @Override public RestResult<Void> updateGrantTransferDetails(EuGrantTransferResource euGrantResource, long applicationId) { String url = format("%s/%d", REST_URL, applicationId); return postWithRestResult(url, euGrantResource, Void.class); } @Override RestResult<Void> uploadGrantAgreement(long applicationId, String contentType, long size, String originalFilename, byte[] multipartFileBytes); @Override RestResult<Void> deleteGrantAgreement(long applicationId); @Override RestResult<ByteArrayResource> downloadGrantAgreement(long applicationId); @Override RestResult<FileEntryResource> findGrantAgreement(long applicationId); @Override RestResult<EuGrantTransferResource> findDetailsByApplicationId(long applicationId); @Override RestResult<Void> updateGrantTransferDetails(EuGrantTransferResource euGrantResource, long applicationId); }### Answer: @Test public void updateGrantTransferDetails() { final long applicationId = 912L; EuGrantTransferResource euGrantTransferResource = newEuGrantTransferResource().build(); setupPostWithRestResultExpectations(format("%s/%s", REST_URL, applicationId), euGrantTransferResource, OK); RestResult<Void> result = service.updateGrantTransferDetails(euGrantTransferResource, applicationId); assertTrue(result.isSuccess()); }
### Question: SurveyRestServiceImpl extends BaseRestService implements SurveyRestService { @Override @HystrixCommand(fallbackMethod = "saveFallback") public RestResult<Void> save(SurveyResource surveyResource) { return postWithRestResultAnonymous( "/survey", surveyResource, Void.class); } @Override @Value("${ifs.survey.data.service.baseURL}") void setServiceUrl(String serviceUrl); @Override @HystrixCommand(fallbackMethod = "saveFallback") RestResult<Void> save(SurveyResource surveyResource); RestResult<Void> saveFallback(SurveyResource surveyResource, Throwable e); }### Answer: @Test public void save() { String baseUrl = "base"; surveyRestService.setServiceUrl(baseUrl); SurveyResource surveyResource = newSurveyResource().build(); RestResult<Void> expected = mock(RestResult.class); when(rootAnonymousUserRestTemplateAdaptor.postWithRestResult(baseUrl + "/survey", surveyResource, Void.class)).thenReturn(expected); RestResult<Void> result = surveyRestService.save(surveyResource); assertEquals(result, expected); }
### Question: PrioritySorting { public List<T> unwrap() { return sortedList; } <E extends Comparable<? super E>> PrioritySorting(List<T> list, T priority, Function<T, E> field); List<T> unwrap(); }### Answer: @Test public void sortingEmptyListReturnsEmptyList() { List<String> list = new PrioritySorting<>(new ArrayList<String>(), "exceptionElement", Function.identity()).unwrap(); assertTrue(list.isEmpty()); } @Test public void sortingListWorksAsExpectedWithIdentity() { List<String> list = new PrioritySorting<>(asList("C", "A", "exceptionElement"), "exceptionElement", Function.identity()).unwrap(); assertEquals(3, list.size()); assertEquals(list, asList("exceptionElement", "A", "C")); } @Test public void sortingListWorksAsExpectedWithFunction() { List<TestResource> orgs = createResources("C", "A", "exceptionElement"); List<TestResource> list = new PrioritySorting<>(orgs, createResource("exceptionElement"), TestResource::getName).unwrap(); assertEquals(3, list.size()); Assert.assertEquals(CollectionFunctions.simpleMap(list, TestResource::getName), CollectionFunctions.simpleMap(createResources("exceptionElement", "A", "C"), TestResource::getName)); } @Test public void sortingListWithoutPriorityStillSortsElementsByField() { List<TestResource> orgs = createResources("C", "A", "exceptionElement"); List<TestResource> list = new PrioritySorting<>(orgs, null, TestResource::getName).unwrap(); assertEquals(3, list.size()); Assert.assertEquals(CollectionFunctions.simpleMap(list, TestResource::getName), CollectionFunctions.simpleMap(createResources("A", "C", "exceptionElement"), TestResource::getName)); }
### Question: OrganisationPatternMatcher { @NotSecured(value = "Is a 'static' comparison function", mustBeSecuredByOtherServices = false) public boolean organisationTypeIsResearch(Organisation organisation) { try { return OrganisationTypeEnum.isResearch(organisation.getOrganisationType().getId()); } catch(NullPointerException e) { LOG.trace("NPE when checking organisation type is research", e); return false; } } @NotSecured(value = "Is a 'static' comparison function", mustBeSecuredByOtherServices = false) boolean organisationTypeMatches(Organisation organisation, OrganisationResource organisationResource); @NotSecured(value = "Is a 'static' comparison function", mustBeSecuredByOtherServices = false) boolean organisationTypeIsResearch(Organisation organisation); }### Answer: @Test public void organisationTypeIsResearch() throws Exception { Organisation organisation = newOrganisation().withOrganisationType(OrganisationTypeEnum.RESEARCH).build(); boolean result = service.organisationTypeIsResearch(organisation); assertTrue(result); } @Test public void organisationTypeIsResearch_noMatchIfTypeIsNotResearch() throws Exception { Organisation organisation = newOrganisation().withOrganisationType(OrganisationTypeEnum.BUSINESS).build(); boolean result = service.organisationTypeIsResearch(organisation); assertFalse(result); } @Test public void organisationTypeIsResearch_noMatchIfTypeIsMissing() throws Exception { Organisation organisation = newOrganisation().build(); boolean result = service.organisationTypeIsResearch(organisation); assertFalse(result); }
### Question: StringFunctions { public static int countWords(String content) { return ofNullable(stripToNull(stripHtml(content))).map(contentValue -> contentValue.split("\\s+").length).orElse(0); } private StringFunctions(); static int countWords(String content); static String stripHtml(String content); static String plainTextToHtml(String content); }### Answer: @Test public void countWords() throws Exception { assertEquals(15, StringFunctions.countWords(join(" ", nCopies(15, "content")))); } @Test public void countWords_valueWithHtml() throws Exception { assertEquals(15, StringFunctions.countWords("<td><p style=\"font-variant: small-caps\">This value is made up of fifteen words even though it is wrapped within HTML.</p></td>")); } @Test public void countWords_noContent() throws Exception { assertEquals(0, StringFunctions.countWords(null)); } @Test public void countWords_emptyContent() throws Exception { assertEquals(0, StringFunctions.countWords("")); }
### Question: StringFunctions { public static String stripHtml(String content) { return ofNullable(content).map(contentValue -> { String cleaned = Jsoup.clean(content, "", Whitelist.none(), new Document.OutputSettings().prettyPrint(false)); return cleaned.trim().replaceAll("[ \t]+", " "); } ).orElse(null); } private StringFunctions(); static int countWords(String content); static String stripHtml(String content); static String plainTextToHtml(String content); }### Answer: @Test public void stripHtml() throws Exception { assertEquals("This value is made up of: a table cell a paragraph and a list.", StringFunctions.stripHtml( "<tr>" + " <td>" + " <p style=\"font-variant: small-caps\">This value is made up of:</p>" + " </td>" + " <td>" + " <ul>" + " <li>a table cell</li>" + " <li>a paragraph</li>" + " <li>and a list.</li>" + " </ul>" + " </td>" + "</tr>")); } @Test public void stripHtml_noHtml() throws Exception { String content = "This value does not contain HTML markup.\n It should remain untouched."; assertEquals(content, StringFunctions.stripHtml(content)); } @Test public void stripHtml_noContent() throws Exception { assertNull(StringFunctions.stripHtml(null)); } @Test public void stripHtml_emptyContent() throws Exception { assertEquals("", StringFunctions.stripHtml("")); }
### Question: StringFunctions { public static String plainTextToHtml(String content) { String escaped = StringEscapeUtils.escapeHtml4(content); if (escaped != null) { return escaped.replaceAll("\\R", "<br/>"); } return escaped; } private StringFunctions(); static int countWords(String content); static String stripHtml(String content); static String plainTextToHtml(String content); }### Answer: @Test public void plainTextToHtml() throws Exception { assertEquals("This text is split<br/>over several<br/>lines.<br/><br/>It contains characters < > & " which need escaping.", StringFunctions.plainTextToHtml("This text is split\nover several\nlines.\n\nIt contains characters < > & \" which need escaping.")); } @Test public void plainTextToHtml_newlines() throws Exception { String content = "Line 1\nLine 2\fLine 3\r\nLine 4\rLine 5"; assertEquals("Line 1<br/>Line 2<br/>Line 3<br/>Line 4<br/>Line 5", StringFunctions.plainTextToHtml(content)); } @Test public void plainTextToHtml_noContent() throws Exception { assertNull(StringFunctions.plainTextToHtml(null)); } @Test public void plainTextToHtml_emptyContent() throws Exception { assertEquals("", StringFunctions.plainTextToHtml("")); }
### Question: MathFunctions { public static BigDecimal percentage(long numerator, long denominator) { int scale = 2; if (denominator != 0) { return valueOf(numerator).multiply(valueOf(100)).divide(valueOf(denominator), scale, HALF_UP); } else { return ZERO.setScale(scale); } } private MathFunctions(); static BigDecimal percentage(long numerator, long denominator); }### Answer: @Test public void testPercentage() { assertEquals(percentage(0, 10), new BigDecimal("0.00")); assertEquals(percentage(10, 10), new BigDecimal("100.00")); assertEquals(percentage(1, 3), new BigDecimal("33.33")); assertEquals(percentage(2, 3), new BigDecimal("66.67")); assertEquals(percentage(2, 1), new BigDecimal("200.00")); assertEquals(percentage(-1, 10), new BigDecimal("-10.00")); assertNotEquals(percentage(0, 10), new BigDecimal("0")); assertEquals(percentage(0, 0), new BigDecimal("0.00")); }
### Question: MapFunctions { public static <T, R> Map<T, R> asMap(Object... nameValuePairs) { if (nameValuePairs.length % 2 != 0) { throw new IllegalArgumentException("Should have an even number of names and values in list"); } Map<T, R> map = new HashMap<>(); for (int i = 0; i < nameValuePairs.length; i += 2) { T key = (T) nameValuePairs[i]; R value = (R) nameValuePairs[i + 1]; map.put(key, value); } return map; } private MapFunctions(); static Map<T, R> asMap(Object... nameValuePairs); static LinkedHashMap<R, Integer> getSortedGroupingCounts(List<T> list, Function<T, R> groupFn); static List<Pair<T, R>> toListOfPairs(Map<T, R> map); static Map<T, R> toMap(List<Pair<T, R>> list); static Map<T, R> combineMaps(Map<T, R> map1, Map<T, R> map2); static Pair<Map<T, S>, Map<T, S>> simplePartition(Map<T, S> map, Predicate<Entry<T, S>> test); }### Answer: @Test public void testAsMap() { Map<Long, String> map = asMap(1L, "String 1", 2L, "String 2"); assertEquals(2, map.size()); assertTrue(map.containsKey(1L)); assertTrue(map.containsKey(2L)); assertEquals("String 1", map.get(1L)); assertEquals("String 2", map.get(2L)); } @Test(expected = IllegalArgumentException.class) public void testAsMapWithUnevenNamesAndValues() { asMap(1L, "String 1", 2L); } @Test public void testAsMapEmptyNameValuePairs() { Map<Long, String> map = asMap(); assertTrue(map.isEmpty()); }

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.