src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
EuGrantTransferController { @GetMapping(value = "/grant-agreement-details/{applicationId}", produces = "application/json") public RestResult<FileEntryResource> findGrantAgreement(@PathVariable("applicationId") long applicationId) { return euGrantTransferService.findGrantAgreement(applicationId).toGetResponse(); } @GetMapping(value = "{applicationId}", produces = "application/json") RestResult<EuGrantTransferResource> getGrantTransferByApplicationId(@PathVariable("applicationId") long applicationId); @PostMapping(value = "{applicationId}", produces = "application/json") RestResult<Void> getGrantTransferByApplicationId(@PathVariable("applicationId") long applicationId,
@RequestBody EuGrantTransferResource euGrantTransferResource); @PostMapping(value = "/grant-agreement/{applicationId}", produces = "application/json") RestResult<Void> uploadGrantAgreement(@RequestHeader(value = "Content-Type", required = false) String contentType,
@RequestHeader(value = "Content-Length", required = false) String contentLength,
@RequestParam(value = "filename", required = false) String originalFilename,
@PathVariable("applicationId") long applicationId,
HttpServletRequest request); @DeleteMapping(value = "/grant-agreement/{applicationId}", produces = "application/json") RestResult<Void> deleteGrantAgreement(@PathVariable("applicationId") long applicationId); @GetMapping(value = "/grant-agreement/{applicationId}", produces = "application/json") @ResponseBody ResponseEntity<Object> downloadGrantAgreement(@PathVariable("applicationId") long applicationId); @GetMapping(value = "/grant-agreement-details/{applicationId}", produces = "application/json") RestResult<FileEntryResource> findGrantAgreement(@PathVariable("applicationId") long applicationId); } | @Test public void findGrantAgreement() throws Exception { final long applicationId = 22L; FileEntryResource fileEntryResource = new FileEntryResource(1L, "name", "application/pdf", 1234); when(euGrantTransferService.findGrantAgreement(applicationId)).thenReturn(serviceSuccess(fileEntryResource)); mockMvc.perform(get("/eu-grant-transfer/grant-agreement-details/{applicationId}", applicationId)) .andExpect(status().isOk()) .andExpect(content().json(toJson(fileEntryResource))); verify(euGrantTransferService).findGrantAgreement(applicationId); } |
EuGrantTransferController { @GetMapping(value = "{applicationId}", produces = "application/json") public RestResult<EuGrantTransferResource> getGrantTransferByApplicationId(@PathVariable("applicationId") long applicationId) { return euGrantTransferService.getGrantTransferByApplicationId(applicationId).toGetResponse(); } @GetMapping(value = "{applicationId}", produces = "application/json") RestResult<EuGrantTransferResource> getGrantTransferByApplicationId(@PathVariable("applicationId") long applicationId); @PostMapping(value = "{applicationId}", produces = "application/json") RestResult<Void> getGrantTransferByApplicationId(@PathVariable("applicationId") long applicationId,
@RequestBody EuGrantTransferResource euGrantTransferResource); @PostMapping(value = "/grant-agreement/{applicationId}", produces = "application/json") RestResult<Void> uploadGrantAgreement(@RequestHeader(value = "Content-Type", required = false) String contentType,
@RequestHeader(value = "Content-Length", required = false) String contentLength,
@RequestParam(value = "filename", required = false) String originalFilename,
@PathVariable("applicationId") long applicationId,
HttpServletRequest request); @DeleteMapping(value = "/grant-agreement/{applicationId}", produces = "application/json") RestResult<Void> deleteGrantAgreement(@PathVariable("applicationId") long applicationId); @GetMapping(value = "/grant-agreement/{applicationId}", produces = "application/json") @ResponseBody ResponseEntity<Object> downloadGrantAgreement(@PathVariable("applicationId") long applicationId); @GetMapping(value = "/grant-agreement-details/{applicationId}", produces = "application/json") RestResult<FileEntryResource> findGrantAgreement(@PathVariable("applicationId") long applicationId); } | @Test public void getGrantTransferByApplicationId() throws Exception { final long applicationId = 22L; EuGrantTransferResource grantTransferResource = newEuGrantTransferResource().build(); when(euGrantTransferService.getGrantTransferByApplicationId(applicationId)).thenReturn(serviceSuccess(grantTransferResource)); mockMvc.perform(get("/eu-grant-transfer/{applicationId}", applicationId)) .andExpect(status().isOk()) .andExpect(content().json(toJson(grantTransferResource))); verify(euGrantTransferService).getGrantTransferByApplicationId(applicationId); } |
EuGrantTransferServiceImpl implements EuGrantTransferService { @Override public ServiceResult<FileEntryResource> findGrantAgreement(long applicationId) { return findGrantTransferByApplicationId(applicationId).andOnSuccess(grantTransfer -> ofNullable(grantTransfer.getGrantAgreement()) .map(FileEntry::getId) .map(fileEntryService::findOne) .orElse(serviceFailure(notFoundError(FileEntryResource.class, applicationId)))); } @Override @Transactional ServiceResult<Void> uploadGrantAgreement(String contentType, String contentLength, String originalFilename, long applicationId, HttpServletRequest request); @Override @Transactional ServiceResult<Void> deleteGrantAgreement(long applicationId); @Override ServiceResult<FileAndContents> downloadGrantAgreement(long applicationId); @Override ServiceResult<FileEntryResource> findGrantAgreement(long applicationId); @Override ServiceResult<EuGrantTransferResource> getGrantTransferByApplicationId(long applicationId); @Override @Transactional ServiceResult<Void> updateGrantTransferByApplicationId(EuGrantTransferResource euGrantTransferResource, long applicationId); } | @Test public void findGrantAgreement() { long applicationId = 1L; FileEntry fileEntry = newFileEntry().build(); EuGrantTransfer grantTransfer = newEuGrantTransfer() .withGrantAgreement(fileEntry) .build(); FileEntryResource fileEntryResource = newFileEntryResource().build(); when(euGrantTransferRepository.findByApplicationId(applicationId)).thenReturn(grantTransfer); when(fileEntryServiceMock.findOne(fileEntry.getId())).thenReturn(serviceSuccess(fileEntryResource)); FileEntryResource response = service.findGrantAgreement(applicationId).getSuccess(); assertEquals(fileEntryResource, response); } |
EuGrantTransferServiceImpl implements EuGrantTransferService { @Override public ServiceResult<FileAndContents> downloadGrantAgreement(long applicationId) { return findGrantTransferByApplicationId(applicationId).andOnSuccess(grantTransfer -> fileEntryService.findOne(grantTransfer.getGrantAgreement().getId()) .andOnSuccess(this::getFileAndContents)); } @Override @Transactional ServiceResult<Void> uploadGrantAgreement(String contentType, String contentLength, String originalFilename, long applicationId, HttpServletRequest request); @Override @Transactional ServiceResult<Void> deleteGrantAgreement(long applicationId); @Override ServiceResult<FileAndContents> downloadGrantAgreement(long applicationId); @Override ServiceResult<FileEntryResource> findGrantAgreement(long applicationId); @Override ServiceResult<EuGrantTransferResource> getGrantTransferByApplicationId(long applicationId); @Override @Transactional ServiceResult<Void> updateGrantTransferByApplicationId(EuGrantTransferResource euGrantTransferResource, long applicationId); } | @Test public void downloadGrantAgreement() { final long applicationId = 1L; final long fileId = 2L; final FileEntry fileEntry = new FileEntry(fileId, "somefile.pdf", MediaType.APPLICATION_PDF, 1111L); EuGrantTransfer grantTransfer = newEuGrantTransfer() .withGrantAgreement(fileEntry) .build(); FileEntryResource fileEntryResource = new FileEntryResource(); fileEntryResource.setId(fileId); when(euGrantTransferRepository.findByApplicationId(applicationId)).thenReturn(grantTransfer); when(fileEntryServiceMock.findOne(fileId)).thenReturn(serviceSuccess(fileEntryResource)); final Supplier<InputStream> contentSupplier = () -> null; when(fileServiceMock.getFileByFileEntryId(fileEntry.getId())).thenReturn(ServiceResult.serviceSuccess(contentSupplier)); FileAndContents fileAndContents = service.downloadGrantAgreement(applicationId).getSuccess(); assertEquals(fileAndContents.getContentsSupplier(), contentSupplier); assertEquals(fileAndContents.getFileEntry(), fileEntryResource); } |
EuGrantTransferServiceImpl implements EuGrantTransferService { @Override @Transactional public ServiceResult<Void> deleteGrantAgreement(long applicationId) { return findGrantTransferByApplicationId(applicationId).andOnSuccess(grantTransfer -> { long fileId = grantTransfer.getGrantAgreement().getId(); return fileService.deleteFileIgnoreNotFound(fileId).andOnSuccessReturnVoid(() -> grantTransfer.setGrantAgreement(null) ); }); } @Override @Transactional ServiceResult<Void> uploadGrantAgreement(String contentType, String contentLength, String originalFilename, long applicationId, HttpServletRequest request); @Override @Transactional ServiceResult<Void> deleteGrantAgreement(long applicationId); @Override ServiceResult<FileAndContents> downloadGrantAgreement(long applicationId); @Override ServiceResult<FileEntryResource> findGrantAgreement(long applicationId); @Override ServiceResult<EuGrantTransferResource> getGrantTransferByApplicationId(long applicationId); @Override @Transactional ServiceResult<Void> updateGrantTransferByApplicationId(EuGrantTransferResource euGrantTransferResource, long applicationId); } | @Test public void deleteGrantAgreement() { final long applicationId = 1L; final long fileId = 101L; final FileEntry fileEntry = new FileEntry(fileId, "somefile.pdf", MediaType.APPLICATION_PDF, 1111L); EuGrantTransfer grantTransfer = newEuGrantTransfer() .withGrantAgreement(fileEntry) .build(); when(euGrantTransferRepository.findByApplicationId(applicationId)).thenReturn(grantTransfer); when(fileServiceMock.deleteFileIgnoreNotFound(fileId)).thenReturn(ServiceResult.serviceSuccess(fileEntry)); ServiceResult<Void> response = service.deleteGrantAgreement(applicationId); assertTrue(response.isSuccess()); assertNull(grantTransfer.getGrantAgreement()); verify(fileServiceMock).deleteFileIgnoreNotFound(fileId); } |
EuGrantTransferServiceImpl implements EuGrantTransferService { @Override @Transactional public ServiceResult<Void> uploadGrantAgreement(String contentType, String contentLength, String originalFilename, long applicationId, HttpServletRequest request) { return findGrantTransferByApplicationIdCreateIfNotExists(applicationId).andOnSuccess(grantTransfer -> fileControllerUtils.handleFileUpload(contentType, contentLength, originalFilename, fileValidator, validMediaTypes, maxFileSize, request, (fileAttributes, inputStreamSupplier) -> fileService.createFile(fileAttributes.toFileEntryResource(), inputStreamSupplier) .andOnSuccessReturnVoid(created -> grantTransfer.setGrantAgreement(created.getRight()) )).toServiceResult()); } @Override @Transactional ServiceResult<Void> uploadGrantAgreement(String contentType, String contentLength, String originalFilename, long applicationId, HttpServletRequest request); @Override @Transactional ServiceResult<Void> deleteGrantAgreement(long applicationId); @Override ServiceResult<FileAndContents> downloadGrantAgreement(long applicationId); @Override ServiceResult<FileEntryResource> findGrantAgreement(long applicationId); @Override ServiceResult<EuGrantTransferResource> getGrantTransferByApplicationId(long applicationId); @Override @Transactional ServiceResult<Void> updateGrantTransferByApplicationId(EuGrantTransferResource euGrantTransferResource, long applicationId); } | @Test public void uploadGrantAgreement() { FileControllerUtils fileControllerUtils = mock(FileControllerUtils.class); Long maxFileSize = 2L; List<String> validMediaTypes = asList("PDF"); setField(service, "fileControllerUtils", fileControllerUtils); setField(service, "maxFileSize", maxFileSize); setField(service, "validMediaTypes", validMediaTypes); String contentType = "contentType"; String contentLength = "1"; String originalFilename = "filename"; long applicationId = 1L; HttpServletRequest request = mock(HttpServletRequest.class); EuGrantTransfer grantTransfer = newEuGrantTransfer() .build(); FileEntry created = newFileEntry().build(); Pair<File, FileEntry> result = ImmutablePair.of(mock(File.class), created); when(euGrantTransferRepository.findByApplicationId(applicationId)).thenReturn(grantTransfer); when(fileControllerUtils.handleFileUpload(eq(contentType), eq(contentLength), eq(originalFilename), eq(fileValidator), eq(validMediaTypes), eq(maxFileSize), eq(request), any())) .thenReturn(restSuccess(Void.class)); FileHeaderAttributes attributes = mock(FileHeaderAttributes.class); Supplier<InputStream> inputStreamSupplier = mock(Supplier.class); FileEntryResource fileEntryResource = newFileEntryResource().build(); when(attributes.toFileEntryResource()).thenReturn(fileEntryResource); ServiceResult<Void> response = service.uploadGrantAgreement(contentType, contentLength, originalFilename, applicationId, request); assertTrue(response.isSuccess()); ArgumentCaptor<BiFunction<FileHeaderAttributes, Supplier<InputStream>, ServiceResult<Void>>> argument = ArgumentCaptor.forClass(BiFunction.class); verify(fileControllerUtils).handleFileUpload(eq(contentType), eq(contentLength), eq(originalFilename), eq(fileValidator), eq(validMediaTypes), eq(maxFileSize), eq(request), argument.capture()); when(fileServiceMock.createFile(fileEntryResource, inputStreamSupplier)).thenReturn(serviceSuccess(result)); argument.getValue().apply(attributes, inputStreamSupplier); assertEquals(created, grantTransfer.getGrantAgreement()); } |
EuGrantTransferServiceImpl implements EuGrantTransferService { @Override public ServiceResult<EuGrantTransferResource> getGrantTransferByApplicationId(long applicationId) { return findGrantTransferByApplicationId(applicationId).andOnSuccessReturn(mapper::mapToResource); } @Override @Transactional ServiceResult<Void> uploadGrantAgreement(String contentType, String contentLength, String originalFilename, long applicationId, HttpServletRequest request); @Override @Transactional ServiceResult<Void> deleteGrantAgreement(long applicationId); @Override ServiceResult<FileAndContents> downloadGrantAgreement(long applicationId); @Override ServiceResult<FileEntryResource> findGrantAgreement(long applicationId); @Override ServiceResult<EuGrantTransferResource> getGrantTransferByApplicationId(long applicationId); @Override @Transactional ServiceResult<Void> updateGrantTransferByApplicationId(EuGrantTransferResource euGrantTransferResource, long applicationId); } | @Test public void getGrantTransferByApplicationId() { long applicationId = 1L; EuGrantTransfer grantTransfer = newEuGrantTransfer() .build(); EuGrantTransferResource grantTransferResource = newEuGrantTransferResource().build(); when(euGrantTransferRepository.findByApplicationId(applicationId)).thenReturn(grantTransfer); when(mapper.mapToResource(grantTransfer)).thenReturn(grantTransferResource); ServiceResult<EuGrantTransferResource> result = service.getGrantTransferByApplicationId(applicationId); assertTrue(result.isSuccess()); assertEquals(result.getSuccess(), grantTransferResource); } |
EuGrantTransferServiceImpl implements EuGrantTransferService { @Override @Transactional public ServiceResult<Void> updateGrantTransferByApplicationId(EuGrantTransferResource euGrantTransferResource, long applicationId) { return findGrantTransferByApplicationIdCreateIfNotExists(applicationId).andOnSuccessReturnVoid(domain -> { domain.setGrantAgreementNumber(euGrantTransferResource.getGrantAgreementNumber()); domain.setParticipantId(euGrantTransferResource.getParticipantId()); domain.setProjectStartDate(euGrantTransferResource.getProjectStartDate()); domain.setProjectEndDate(euGrantTransferResource.getProjectEndDate()); domain.setFundingContribution(euGrantTransferResource.getFundingContribution()); domain.setProjectCoordinator(euGrantTransferResource.getProjectCoordinator()); ofNullable(euGrantTransferResource.getProjectEndDate()).ifPresent(endDate -> { long duration = Period.between(horizon2020StartDate, endDate).toTotalMonths(); domain.getApplication().setDurationInMonths(max(duration, 1L)); domain.getApplication().setStartDate(horizon2020StartDate); }); ofNullable(euGrantTransferResource.getActionType()) .map(EuActionTypeResource::getId) .ifPresent(id -> { EuActionType type = new EuActionType(); type.setId(id); domain.setActionType(type); }); domain.getApplication().setName(euGrantTransferResource.getProjectName()); }); } @Override @Transactional ServiceResult<Void> uploadGrantAgreement(String contentType, String contentLength, String originalFilename, long applicationId, HttpServletRequest request); @Override @Transactional ServiceResult<Void> deleteGrantAgreement(long applicationId); @Override ServiceResult<FileAndContents> downloadGrantAgreement(long applicationId); @Override ServiceResult<FileEntryResource> findGrantAgreement(long applicationId); @Override ServiceResult<EuGrantTransferResource> getGrantTransferByApplicationId(long applicationId); @Override @Transactional ServiceResult<Void> updateGrantTransferByApplicationId(EuGrantTransferResource euGrantTransferResource, long applicationId); } | @Test public void updateGrantTransferByApplicationId() { LocalDate start = LocalDate.of(2021, 4, 5); setField(service, "horizon2020StartDate", start); long applicationId = 1L; EuActionTypeResource euActionTypeResource = new EuActionTypeResource(); euActionTypeResource.setId(2L); EuGrantTransferResource grantTransferResource = newEuGrantTransferResource() .withActionType(euActionTypeResource) .withFundingContribution(BigDecimal.TEN) .withGrantAgreementNumber("123456") .withParticipantId("987654321") .withProjectCoordinator(true) .withProjectEndDate(start.plusMonths(13)) .withProjectStartDate(start) .withProjectName("Project name") .build(); Application application = newApplication().build(); EuGrantTransfer grantTransfer = newEuGrantTransfer() .withApplication(application) .build(); when(euGrantTransferRepository.findByApplicationId(applicationId)).thenReturn(grantTransfer); ServiceResult<Void> result = service.updateGrantTransferByApplicationId(grantTransferResource, applicationId); assertTrue(result.isSuccess()); assertEquals(grantTransfer.getActionType().getId(), euActionTypeResource.getId()); assertEquals(grantTransfer.getGrantAgreementNumber(), grantTransferResource.getGrantAgreementNumber()); assertEquals(grantTransfer.getFundingContribution(), grantTransferResource.getFundingContribution()); assertEquals(grantTransfer.getParticipantId(), grantTransferResource.getParticipantId()); assertEquals(grantTransfer.getProjectEndDate(), grantTransferResource.getProjectEndDate()); assertEquals(grantTransfer.getProjectStartDate(), grantTransferResource.getProjectStartDate()); assertEquals(grantTransfer.getProjectCoordinator(), grantTransferResource.getProjectCoordinator()); assertEquals(application.getName(), grantTransferResource.getProjectName()); assertEquals(application.getStartDate(), start); assertEquals(application.getDurationInMonths(), (Long) 13L); } |
ApplicantController { @GetMapping("/{userId}/{applicationId}/question/{questionId}") public RestResult<ApplicantQuestionResource> getQuestion(@PathVariable("userId") final Long userId, @PathVariable("applicationId") final Long applicationId, @PathVariable("questionId") final Long questionId) { return applicantService.getQuestion(userId, questionId, applicationId).toGetResponse(); } ApplicantController(); @Autowired ApplicantController(ApplicantService applicantService, ApplicationDashboardService applicationDashboardService); @GetMapping("/{userId}/{applicationId}/question/{questionId}") RestResult<ApplicantQuestionResource> getQuestion(@PathVariable("userId") final Long userId,
@PathVariable("applicationId") final Long applicationId,
@PathVariable("questionId") final Long questionId); @GetMapping("/{userId}/{applicationId}/section/{sectionId}") RestResult<ApplicantSectionResource> getSection(@PathVariable("userId") final Long userId,
@PathVariable("applicationId") final Long applicationId,
@PathVariable("sectionId") final Long sectionId); @GetMapping("/{userId}/applications/dashboard" ) RestResult<ApplicantDashboardResource> getApplicantDashboard(@PathVariable("userId") final long userId); } | @Test public void getQuestion() throws Exception { when(applicationService.getQuestion(USER_ID, QUESTION_ID, APPLICATION_ID)).thenReturn(serviceSuccess(applicantQuestionResource().build())); mockMvc.perform(get("/applicant/{user}/{application}/question/{question}", USER_ID, APPLICATION_ID, QUESTION_ID) .header("IFS_AUTH_TOKEN", "123abc")) .andExpect(status().isOk()) .andDo(document("applicant/{method-name}", pathParameters( parameterWithName("user").description("Id of the user"), parameterWithName("application").description("Id of the application"), parameterWithName("question").description("Id of the question") ), responseFields(questionFields) .andWithPrefix("application.", ApplicationDocs.applicationResourceFields) .andWithPrefix("competition.", CompetitionResourceDocs.competitionResourceFields) .andWithPrefix("currentApplicant.", ApplicantDocs.applicantResourceFields) .andWithPrefix("currentApplicant.processRole.", ProcessRoleDocs.processRoleResourceFields) .andWithPrefix("currentApplicant.organisation.", OrganisationDocs.organisationResourceFields) .andWithPrefix("currentUser.", UserDocs.userResourceFields) .andWithPrefix("applicants[].", ApplicantDocs.applicantResourceFields) .andWithPrefix("applicants[].processRole.", ProcessRoleDocs.processRoleResourceFields) .andWithPrefix("applicants[].organisation.", OrganisationDocs.organisationResourceFields) .andWithPrefix("question.", QuestionDocs.questionFields) .andWithPrefix("applicantFormInputs[].", ApplicationFormInputDocs.applicationFormResourceFields) .andWithPrefix("applicantFormInputs[].formInput.", FormInputResourceDocs.formInputResourceFields) .andWithPrefix("applicantFormInputs[].applicantResponses[].", ApplicantFormInputResponseResourceDocs.applicantFormInputResponseResourceFields) .andWithPrefix("applicantFormInputs[].applicantResponses[].applicant.", ApplicantDocs.applicantResourceFields) .andWithPrefix("applicantFormInputs[].applicantResponses[].applicant.processRole.", ProcessRoleDocs.processRoleResourceFields) .andWithPrefix("applicantFormInputs[].applicantResponses[].applicant.organisation.", OrganisationDocs.organisationResourceFields) .andWithPrefix("applicantFormInputs[].applicantResponses[].response.", FormInputResponseResourceDocs.formInputResponseResourceFields) .andWithPrefix("applicantQuestionStatuses[].", ApplicantQuestionStatusResourceDocs.applicantQuestionStatusResourceFields) .andWithPrefix("applicantQuestionStatuses[].status.", QuestionStatusResourceDocs.questionStatusResourceFields) .andWithPrefix("applicantQuestionStatuses[].markedAsCompleteBy.", ApplicantDocs.applicantResourceFields) .andWithPrefix("applicantQuestionStatuses[].markedAsCompleteBy.processRole.", ProcessRoleDocs.processRoleResourceFields) .andWithPrefix("applicantQuestionStatuses[].markedAsCompleteBy.organisation.", OrganisationDocs.organisationResourceFields) .andWithPrefix("applicantQuestionStatuses[].assignee.", ApplicantDocs.applicantResourceFields) .andWithPrefix("applicantQuestionStatuses[].assignee.processRole.", ProcessRoleDocs.processRoleResourceFields) .andWithPrefix("applicantQuestionStatuses[].assignee.organisation.", OrganisationDocs.organisationResourceFields) .andWithPrefix("applicantQuestionStatuses[].assignedBy.", ApplicantDocs.applicantResourceFields) .andWithPrefix("applicantQuestionStatuses[].assignedBy.processRole.", ProcessRoleDocs.processRoleResourceFields) .andWithPrefix("applicantQuestionStatuses[].assignedBy.organisation.", OrganisationDocs.organisationResourceFields) )); } |
ApplicantController { @GetMapping("/{userId}/{applicationId}/section/{sectionId}") public RestResult<ApplicantSectionResource> getSection(@PathVariable("userId") final Long userId, @PathVariable("applicationId") final Long applicationId, @PathVariable("sectionId") final Long sectionId) { return applicantService.getSection(userId, sectionId, applicationId).toGetResponse(); } ApplicantController(); @Autowired ApplicantController(ApplicantService applicantService, ApplicationDashboardService applicationDashboardService); @GetMapping("/{userId}/{applicationId}/question/{questionId}") RestResult<ApplicantQuestionResource> getQuestion(@PathVariable("userId") final Long userId,
@PathVariable("applicationId") final Long applicationId,
@PathVariable("questionId") final Long questionId); @GetMapping("/{userId}/{applicationId}/section/{sectionId}") RestResult<ApplicantSectionResource> getSection(@PathVariable("userId") final Long userId,
@PathVariable("applicationId") final Long applicationId,
@PathVariable("sectionId") final Long sectionId); @GetMapping("/{userId}/applications/dashboard" ) RestResult<ApplicantDashboardResource> getApplicantDashboard(@PathVariable("userId") final long userId); } | @Test public void getSection() throws Exception { when(applicationService.getSection(USER_ID, SECTION_ID, APPLICATION_ID)).thenReturn(serviceSuccess(applicantSectionResource().build())); mockMvc.perform(get("/applicant/{user}/{application}/section/{section}", USER_ID, APPLICATION_ID, QUESTION_ID) .header("IFS_AUTH_TOKEN", "123abc")) .andExpect(status().isOk()) .andDo(document("applicant/{method-name}", pathParameters( parameterWithName("user").description("Id of the user"), parameterWithName("application").description("Id of the application"), parameterWithName("section").description("Id of the section") ), responseFields(sectionFields) .andWithPrefix("application.", ApplicationDocs.applicationResourceFields) .andWithPrefix("competition.", CompetitionResourceDocs.competitionResourceFields) .andWithPrefix("currentApplicant.", ApplicantDocs.applicantResourceFields) .andWithPrefix("currentApplicant.processRole.", ProcessRoleDocs.processRoleResourceFields) .andWithPrefix("currentApplicant.organisation.", OrganisationDocs.organisationResourceFields) .andWithPrefix("currentUser.", UserDocs.userResourceFields) .andWithPrefix("applicants[].", ApplicantDocs.applicantResourceFields) .andWithPrefix("applicants[].processRole.", ProcessRoleDocs.processRoleResourceFields) .andWithPrefix("applicants[].organisation.", OrganisationDocs.organisationResourceFields) .andWithPrefix("section.", SectionDocs.sectionResourceFields) .andWithPrefix("applicantQuestions[].application.", ApplicationDocs.applicationResourceFields) .andWithPrefix("applicantQuestions[].competition.", CompetitionResourceDocs.competitionResourceFields) .andWithPrefix("applicantQuestions[].currentApplicant.", ApplicantDocs.applicantResourceFields) .andWithPrefix("applicantQuestions[].currentApplicant.processRole.", ProcessRoleDocs.processRoleResourceFields) .andWithPrefix("applicantQuestions[].currentApplicant.organisation.", OrganisationDocs.organisationResourceFields) .andWithPrefix("applicantQuestions[].currentUser.", UserDocs.userResourceFields) .andWithPrefix("applicantQuestions[].applicants[].", ApplicantDocs.applicantResourceFields) .andWithPrefix("applicantQuestions[].applicants[].processRole.", ProcessRoleDocs.processRoleResourceFields) .andWithPrefix("applicantQuestions[].applicants[].organisation.", OrganisationDocs.organisationResourceFields) .andWithPrefix("applicantQuestions[].question.", QuestionDocs.questionFields) .andWithPrefix("applicantQuestions[].applicantFormInputs[].", ApplicationFormInputDocs.applicationFormResourceFields) .andWithPrefix("applicantQuestions[].applicantFormInputs[].formInput.", FormInputResourceDocs.formInputResourceFields) .andWithPrefix("applicantQuestions[].applicantFormInputs[].applicantResponses[].", ApplicantFormInputResponseResourceDocs.applicantFormInputResponseResourceFields) .andWithPrefix("applicantQuestions[].applicantFormInputs[].applicantResponses[].applicant.", ApplicantDocs.applicantResourceFields) .andWithPrefix("applicantQuestions[].applicantFormInputs[].applicantResponses[].applicant.processRole.", ProcessRoleDocs.processRoleResourceFields) .andWithPrefix("applicantQuestions[].applicantFormInputs[].applicantResponses[].applicant.organisation.", OrganisationDocs.organisationResourceFields) .andWithPrefix("applicantQuestions[].applicantFormInputs[].applicantResponses[].response.", FormInputResponseResourceDocs.formInputResponseResourceFields) .andWithPrefix("applicantQuestions[].applicantQuestionStatuses[].", ApplicantQuestionStatusResourceDocs.applicantQuestionStatusResourceFields) .andWithPrefix("applicantQuestions[].applicantQuestionStatuses[].status.", QuestionStatusResourceDocs.questionStatusResourceFields) .andWithPrefix("applicantQuestions[].applicantQuestionStatuses[].markedAsCompleteBy.", ApplicantDocs.applicantResourceFields) .andWithPrefix("applicantQuestions[].applicantQuestionStatuses[].markedAsCompleteBy.processRole.", ProcessRoleDocs.processRoleResourceFields) .andWithPrefix("applicantQuestions[].applicantQuestionStatuses[].markedAsCompleteBy.organisation.", OrganisationDocs.organisationResourceFields) .andWithPrefix("applicantQuestions[].applicantQuestionStatuses[].assignee.", ApplicantDocs.applicantResourceFields) .andWithPrefix("applicantQuestions[].applicantQuestionStatuses[].assignee.processRole.", ProcessRoleDocs.processRoleResourceFields) .andWithPrefix("applicantQuestions[].applicantQuestionStatuses[].assignee.organisation.", OrganisationDocs.organisationResourceFields) .andWithPrefix("applicantQuestions[].applicantQuestionStatuses[].assignedBy.", ApplicantDocs.applicantResourceFields) .andWithPrefix("applicantQuestions[].applicantQuestionStatuses[].assignedBy.processRole.", ProcessRoleDocs.processRoleResourceFields) .andWithPrefix("applicantQuestions[].applicantQuestionStatuses[].assignedBy.organisation.", OrganisationDocs.organisationResourceFields) .andWithPrefix("applicantParentSection.", sectionFieldsWithoutCurrentApplicant) .andWithPrefix("applicantChildrenSections[].", sectionFieldsWithoutCurrentApplicant) )); } |
ApplicantController { @GetMapping("/{userId}/applications/dashboard" ) public RestResult<ApplicantDashboardResource> getApplicantDashboard(@PathVariable("userId") final long userId) { return applicationDashboardService.getApplicantDashboard(userId).toGetResponse(); } ApplicantController(); @Autowired ApplicantController(ApplicantService applicantService, ApplicationDashboardService applicationDashboardService); @GetMapping("/{userId}/{applicationId}/question/{questionId}") RestResult<ApplicantQuestionResource> getQuestion(@PathVariable("userId") final Long userId,
@PathVariable("applicationId") final Long applicationId,
@PathVariable("questionId") final Long questionId); @GetMapping("/{userId}/{applicationId}/section/{sectionId}") RestResult<ApplicantSectionResource> getSection(@PathVariable("userId") final Long userId,
@PathVariable("applicationId") final Long applicationId,
@PathVariable("sectionId") final Long sectionId); @GetMapping("/{userId}/applications/dashboard" ) RestResult<ApplicantDashboardResource> getApplicantDashboard(@PathVariable("userId") final long userId); } | @Test public void getApplicantDashboard() throws Exception { long euGrantTransferId = 1L; long inProgressId = 2L; long inSetupId = 3L; long previousId = 4L; DashboardEuGrantTransferRowResource euGrantTransfer = new DashboardApplicationForEuGrantTransferResourceBuilder().withApplicationId(euGrantTransferId).build(); DashboardInProgressRowResource inProgress = new DashboardApplicationInProgressResourceBuilder().withApplicationId(inProgressId).build(); DashboardInSetupRowResource inSetup = aDashboardInSetupRowResource().withApplicationId(inSetupId).build(); DashboardPreviousRowResource previous = new DashboardPreviousApplicationResourceBuilder().withApplicationId(previousId).build(); when(applicationDashboardService.getApplicantDashboard(USER_ID)).thenReturn(serviceSuccess(new ApplicantDashboardResourceBuilder() .withEuGrantTransfer(singletonList(euGrantTransfer)) .withInProgress(singletonList(inProgress)) .withInSetup(singletonList(inSetup)) .withPrevious(singletonList(previous)) .build())); MvcResult mvcResult = mockMvc.perform(get("/applicant/{user}/applications/dashboard", USER_ID) .header("IFS_AUTH_TOKEN", "123abc")) .andExpect(status().isOk()) .andReturn(); ApplicantDashboardResource result = objectMapper.readValue(mvcResult.getResponse().getContentAsString(), ApplicantDashboardResource.class); assertEquals(euGrantTransferId, result.getEuGrantTransfer().get(0).getApplicationId()); assertEquals(inProgressId, result.getInProgress().get(0).getApplicationId()); assertEquals(inSetupId, result.getInSetup().get(0).getApplicationId()); assertEquals(previousId, result.getPrevious().get(0).getApplicationId()); } |
CrmServiceImpl implements CrmService { @Override public ServiceResult<Void> syncCrmContact(long userId) { return userService.getUserById(userId).andOnSuccess(user -> { syncExternalUser(user); syncMonitoringOfficer(user); return serviceSuccess(); }); } @Override ServiceResult<Void> syncCrmContact(long userId); } | @Test public void syncExternalCrmContact() { long userId = 1L; UserResource user = newUserResource().withRoleGlobal(APPLICANT).build(); List<OrganisationResource> organisations = newOrganisationResource().withCompaniesHouseNumber("Something", "Else").build(2); when(baseUserService.getUserById(userId)).thenReturn(serviceSuccess(user)); when(organisationService.getAllByUserId(userId)).thenReturn(serviceSuccess(organisations)); when(silCrmEndpoint.updateContact(any(SilContact.class))).thenReturn(serviceSuccess()); ServiceResult<Void> result = service.syncCrmContact(userId); assertThat(result.isSuccess(), equalTo(true)); verify(silCrmEndpoint).updateContact(LambdaMatcher.createLambdaMatcher(matchExternalSilContact(user, organisations.get(0)))); verify(silCrmEndpoint).updateContact(LambdaMatcher.createLambdaMatcher(matchExternalSilContact(user, organisations.get(1)))); }
@Test public void syncMonitoringOfficerOnlyCrmContact() { long userId = 1L; UserResource user = newUserResource().withRoleGlobal(MONITORING_OFFICER).build(); when(baseUserService.getUserById(userId)).thenReturn(serviceSuccess(user)); when(organisationService.getAllByUserId(userId)).thenReturn(serviceSuccess(Collections.emptyList())); when(silCrmEndpoint.updateContact(any(SilContact.class))).thenReturn(serviceSuccess()); ServiceResult<Void> result = service.syncCrmContact(userId); assertThat(result.isSuccess(), equalTo(true)); verify(silCrmEndpoint).updateContact(LambdaMatcher.createLambdaMatcher(matchMonitoringOfficerSilContact(user))); }
@Test public void syncMonitoringOfficerAndExternalCrmContact() { long userId = 1L; UserResource user = newUserResource().withRolesGlobal(asList(APPLICANT,MONITORING_OFFICER)).build(); List<OrganisationResource> organisations = newOrganisationResource().withCompaniesHouseNumber("Something", "Else").build(2); when(baseUserService.getUserById(userId)).thenReturn(serviceSuccess(user)); when(organisationService.getAllByUserId(userId)).thenReturn(serviceSuccess(organisations)); when(silCrmEndpoint.updateContact(any(SilContact.class))).thenReturn(serviceSuccess()); ServiceResult<Void> result = service.syncCrmContact(userId); assertThat(result.isSuccess(), equalTo(true)); verify(silCrmEndpoint).updateContact(LambdaMatcher.createLambdaMatcher(matchExternalSilContact(user, organisations.get(0)))); verify(silCrmEndpoint).updateContact(LambdaMatcher.createLambdaMatcher(matchExternalSilContact(user, organisations.get(1)))); verify(silCrmEndpoint).updateContact(LambdaMatcher.createLambdaMatcher(matchMonitoringOfficerSilContact(user))); } |
AuthenticationRequestWrapper extends HttpServletRequestWrapper { @Override public ServletInputStream getInputStream() throws IOException { ByteArrayInputStream inputStream = new ByteArrayInputStream(body.getBytes()); return new ServletInputStream() { @Override public boolean isFinished() { return inputStream.available() == 0; } @Override public boolean isReady() { return true; } @Override public void setReadListener(ReadListener listener) { throw new IllegalStateException("Not implemented"); } @Override public int read() throws IOException { return inputStream.read(); } }; } AuthenticationRequestWrapper(HttpServletRequest request); @Override ServletInputStream getInputStream(); @Override BufferedReader getReader(); } | @Test public void getInputStream() throws Exception { ServletInputStream first = authenticationRequestWrapper.getInputStream(); assertEquals("First call to getInputStream should match request content", content, IOUtils.toString(first, "UTF-8")); ServletInputStream second = authenticationRequestWrapper.getInputStream(); assertEquals("Subsequent calls to getInputStream should match request content", content, IOUtils.toString(second, "UTF-8")); } |
AuthenticationRequestWrapper extends HttpServletRequestWrapper { @Override public BufferedReader getReader() throws IOException { return new BufferedReader(new InputStreamReader(this.getInputStream())); } AuthenticationRequestWrapper(HttpServletRequest request); @Override ServletInputStream getInputStream(); @Override BufferedReader getReader(); } | @Test public void getReader() throws Exception { Reader first = authenticationRequestWrapper.getReader(); assertEquals("First call to getInputStream should match request content", content, IOUtils.toString(first)); Reader second = authenticationRequestWrapper.getReader(); assertEquals("Subsequent calls to getInputStream should match request content", content, IOUtils.toString(second)); } |
RegistrationServiceImpl extends BaseTransactionalService implements RegistrationService { @Override @Transactional @UserUpdate public ServiceResult<UserResource> activateUser(long userId) { return getUser(userId).andOnSuccess(this::activateUser) .andOnSuccessReturn(userMapper::mapToResource); } @Override @Transactional ServiceResult<UserResource> createUser(UserCreationResource user); @Override @Transactional ServiceResult<Void> resendUserVerificationEmail(final UserResource user); @Override @Transactional @UserUpdate ServiceResult<UserResource> activateUser(long userId); @Override @Transactional @UserUpdate ServiceResult<UserResource> deactivateUser(long userId); @Override @Transactional ServiceResult<User> activatePendingUser(User user,
String password,
String hash); @Override @Transactional ServiceResult<Void> activateApplicantAndSendDiversitySurvey(long userId); @Override @Transactional ServiceResult<Void> activateAssessorAndSendDiversitySurvey(long userId); @Override @Transactional @UserUpdate ServiceResult<UserResource> editInternalUser(UserResource userToEdit, Role userRoleType); } | @Test public void activateUser_success() { setUpUsersForEditInternalUserSuccess(); when(userRepositoryMock.findById(userToEdit.getId())).thenReturn(Optional.of(userInDB)); when(idpServiceMock.activateUser(userToEdit.getUid())).thenReturn(ServiceResult.serviceSuccess("")); userInDB.setStatus(UserStatus.ACTIVE); when(userRepositoryMock.save(userInDB)).thenReturn(updatedUserInDB); ServiceResult<UserResource> result = service.activateUser(userToEdit.getId()); verify(userRepositoryMock).save(userInDB); assertTrue(result.isSuccess()); }
@Test public void activateUser_idpFails() { setUpUsersForEditInternalUserSuccess(); when(userRepositoryMock.findById(userToEdit.getId())).thenReturn(Optional.of(userInDB)); when(idpServiceMock.activateUser(userToEdit.getUid())).thenReturn(ServiceResult.serviceFailure(GENERAL_NOT_FOUND)); ServiceResult<UserResource> result = service.activateUser(userToEdit.getId()); assertTrue(result.isFailure()); }
@Test public void activateUser_noUser() { setUpUsersForEditInternalUserSuccess(); when(userRepositoryMock.findById(userToEdit.getId())).thenReturn(Optional.empty()); ServiceResult<UserResource> result = service.activateUser(userToEdit.getId()); assertTrue(result.isFailure()); } |
TokenAuthenticationService { public AuthenticationToken getAuthentication(HttpServletRequest request) { if (isHashValidForRequest(request)) { return new AuthenticationToken(); } return null; } @Autowired TokenAuthenticationService(@Value("${ifs.finance-totals.authSecretKey}") String secretKey,
HashBasedMacTokenHandler tokenHandler); AuthenticationToken getAuthentication(HttpServletRequest request); } | @Test public void getAuthentication() throws Exception { String token = "f6d99caceac489fd2d4ba8106d15e64bd7455fd83305f13a7faa32fb3b02fa28"; MockHttpServletRequest httpServletRequest = new MockHttpServletRequest(); httpServletRequest.addHeader("X-AUTH-TOKEN", token); httpServletRequest.setContent("input".getBytes()); assertNotNull(tokenAuthenticationService.getAuthentication(httpServletRequest)); }
@Test public void getAuthentication_notAuthenticated() throws Exception { String token = "incorrect-hash"; MockHttpServletRequest httpServletRequest = new MockHttpServletRequest(); httpServletRequest.addHeader("X-AUTH-TOKEN", token); httpServletRequest.setContent("input".getBytes()); assertNull(tokenAuthenticationService.getAuthentication(httpServletRequest)); }
@Test public void getAuthentication_missingContent() throws Exception { MockHttpServletRequest httpServletRequest = new MockHttpServletRequest(); assertNull(tokenAuthenticationService.getAuthentication(httpServletRequest)); } |
CostTotalController { @PostMapping("/cost-total") public RestResult<Void> addCostTotal(@NotNull @RequestBody FinanceCostTotalResource financeCostTotalResource) { return costTotalService.saveCostTotal(financeCostTotalResource).toPostCreateResponse(); } @Autowired CostTotalController(CostTotalService costTotalService); @PostMapping("/cost-total") RestResult<Void> addCostTotal(@NotNull @RequestBody FinanceCostTotalResource financeCostTotalResource); @PostMapping("/cost-totals") RestResult<Void> addCostTotals(@NotNull @RequestBody List<FinanceCostTotalResource>
financeCostTotalResources); } | @Test public void addCostTotal() throws Exception { FinanceCostTotalResource financeCostTotalResource = new FinanceCostTotalResource( FinanceType.APPLICATION, FinanceRowType.LABOUR, new BigDecimal("999999999.999999"), 1L ); Consumer<FinanceCostTotalResource> matchesExpectedResource = (resource) -> { assertThat(resource).isEqualToComparingFieldByField(financeCostTotalResource); }; when(costTotalService.saveCostTotal(createLambdaMatcher(matchesExpectedResource))).thenReturn(serviceSuccess()); mockMvc.perform( post("/cost-total") .content(json(financeCostTotalResource)) .contentType(MediaType.APPLICATION_JSON) ) .andExpect(status().isCreated()); verify(costTotalService).saveCostTotal(createLambdaMatcher(matchesExpectedResource)); } |
CostTotalController { @PostMapping("/cost-totals") public RestResult<Void> addCostTotals(@NotNull @RequestBody List<FinanceCostTotalResource> financeCostTotalResources) { LOG.debug("Initiating addCostTotals for financeIds: {}", financeCostTotalResources.stream().map(financeCostTotalResource -> String.valueOf(financeCostTotalResource.getFinanceId())) .collect(Collectors.joining(", "))); return costTotalService.saveCostTotals(financeCostTotalResources).toPostCreateResponse(); } @Autowired CostTotalController(CostTotalService costTotalService); @PostMapping("/cost-total") RestResult<Void> addCostTotal(@NotNull @RequestBody FinanceCostTotalResource financeCostTotalResource); @PostMapping("/cost-totals") RestResult<Void> addCostTotals(@NotNull @RequestBody List<FinanceCostTotalResource>
financeCostTotalResources); } | @Test public void addCostTotals() throws Exception { List<FinanceCostTotalResource> financeCostTotalResources = newFinanceCostTotalResource() .withFinanceType(FinanceType.APPLICATION) .withFinanceRowType(FinanceRowType.LABOUR, FinanceRowType.MATERIALS) .withFinanceId(1L, 2L) .withTotal(new BigDecimal("999.999999"), new BigDecimal("1999.999999")) .build(2); Consumer<List<FinanceCostTotalResource>> matchesExpectedResources = (resources) -> { assertThat(resources).usingFieldByFieldElementComparator().containsAll(financeCostTotalResources); }; when(costTotalService.saveCostTotals(createLambdaMatcher(matchesExpectedResources))).thenReturn(serviceSuccess()); mockMvc.perform( post("/cost-totals") .content(json(financeCostTotalResources)) .contentType(MediaType.APPLICATION_JSON) ) .andExpect(status().isCreated()); verify(costTotalService).saveCostTotals(createLambdaMatcher(matchesExpectedResources)); } |
HashBasedMacTokenHandler { public String calculateHash(String key, String input) throws InvalidKeyException { Mac mac; try { mac = Mac.getInstance(ALGORITHM); } catch (NoSuchAlgorithmException e) { throw new IllegalStateException("Failed to initialise MAC object: " + e.getMessage(), e); } mac.init(getKey(key)); return Hex.encodeHexString(mac.doFinal(getInputAsByteArray(input))); } String calculateHash(String key, String input); } | @Test public void calculateHash() throws Exception { assertEquals("f6d99caceac489fd2d4ba8106d15e64bd7455fd83305f13a7faa32fb3b02fa28", hashBasedMacTokenHandler.calculateHash("supersecretkey", "input")); }
@Test(expected = IllegalArgumentException.class) public void calculateHash_nullKey() throws Exception { hashBasedMacTokenHandler.calculateHash(null, "input"); }
@Test(expected = IllegalArgumentException.class) public void calculateHash_emptyKey() throws Exception { hashBasedMacTokenHandler.calculateHash("", "input"); }
@Test public void calculateHash_nullData() throws Exception { assertEquals("c46ebcad47b875a746029ac6c2f8636ffd012d2b3cd524d77f2d813b5b74f589", hashBasedMacTokenHandler.calculateHash("supersecretkey", null)); }
@Test public void calculateHash_emptyData() throws Exception { assertEquals("c46ebcad47b875a746029ac6c2f8636ffd012d2b3cd524d77f2d813b5b74f589", hashBasedMacTokenHandler.calculateHash("supersecretkey", "")); } |
AlertPermissionRules { @PermissionRule(value = "CREATE", description = "System maintentenance users can create Alerts") public boolean systemMaintenanceUserCanCreateAlerts(final AlertResource alertResource, final UserResource user) { return isSystemMaintenanceUser(user); } @PermissionRule(value = "CREATE", description = "System maintentenance users can create Alerts") boolean systemMaintenanceUserCanCreateAlerts(final AlertResource alertResource, final UserResource user); @PermissionRule(value = "DELETE", description = "System maintentenance users can delete Alerts") boolean systemMaintenanceUserCanDeleteAlerts(final AlertResource alertResource, final UserResource user); } | @Test public void systemMaintenanceUserCanCreateAlerts() throws Exception { assertTrue(rules.systemMaintenanceUserCanCreateAlerts(alertResource, systemMaintenanceUser())); }
@Test public void systemMaintenanceUserCanCreateAlerts_anonymous() throws Exception { assertFalse(rules.systemMaintenanceUserCanCreateAlerts(alertResource, anonymousUser())); } |
AlertPermissionRules { @PermissionRule(value = "DELETE", description = "System maintentenance users can delete Alerts") public boolean systemMaintenanceUserCanDeleteAlerts(final AlertResource alertResource, final UserResource user) { return isSystemMaintenanceUser(user); } @PermissionRule(value = "CREATE", description = "System maintentenance users can create Alerts") boolean systemMaintenanceUserCanCreateAlerts(final AlertResource alertResource, final UserResource user); @PermissionRule(value = "DELETE", description = "System maintentenance users can delete Alerts") boolean systemMaintenanceUserCanDeleteAlerts(final AlertResource alertResource, final UserResource user); } | @Test public void systemMaintenanceUserCanDeleteAlerts() throws Exception { assertTrue(rules.systemMaintenanceUserCanDeleteAlerts(alertResource, systemMaintenanceUser())); }
@Test public void systemMaintenanceUserCanDeleteAlerts_anonymous() throws Exception { assertFalse(rules.systemMaintenanceUserCanDeleteAlerts(alertResource, anonymousUser())); } |
AlertController { @GetMapping("/find-all-visible") public RestResult<List<AlertResource>> findAllVisible() { return alertService.findAllVisible().toGetResponse(); } @GetMapping("/find-all-visible") RestResult<List<AlertResource>> findAllVisible(); @GetMapping("/find-all-visible/{type}") RestResult<List<AlertResource>> findAllVisibleByType(@PathVariable("type") AlertType type); @GetMapping("/{id}") RestResult<AlertResource> findById(@PathVariable("id") Long id); @PostMapping("/") RestResult<AlertResource> create(@RequestBody AlertResource alertResource); @DeleteMapping("/{id}") RestResult<Void> delete(@PathVariable("id") Long id); @DeleteMapping("/delete/{type}") RestResult<Void> deleteAllByType(@PathVariable("type") AlertType type); } | @Test public void test_findAllVisible() throws Exception { final AlertResource expected1 = AlertResourceBuilder.newAlertResource() .withId(8888L) .build(); final AlertResource expected2 = AlertResourceBuilder.newAlertResource() .withId(9999L) .build(); final List<AlertResource> expected = new ArrayList<>(asList(expected1, expected2)); when(alertServiceMock.findAllVisible()).thenReturn(serviceSuccess(expected)); mockMvc.perform(get("/alert/find-all-visible")) .andExpect(status().isOk()) .andExpect(jsonPath("[0]id", is(8888))) .andExpect(jsonPath("[1]id", is(9999))) .andDo(document("alert/find-all-visible", pathParameters( ), responseFields( fieldWithPath("[]").description("An array of the alerts which are visible") ).andWithPrefix("[].", AlertDocs.alertResourceFields)) ); } |
AlertController { @GetMapping("/find-all-visible/{type}") public RestResult<List<AlertResource>> findAllVisibleByType(@PathVariable("type") AlertType type) { return alertService.findAllVisibleByType(type).toGetResponse(); } @GetMapping("/find-all-visible") RestResult<List<AlertResource>> findAllVisible(); @GetMapping("/find-all-visible/{type}") RestResult<List<AlertResource>> findAllVisibleByType(@PathVariable("type") AlertType type); @GetMapping("/{id}") RestResult<AlertResource> findById(@PathVariable("id") Long id); @PostMapping("/") RestResult<AlertResource> create(@RequestBody AlertResource alertResource); @DeleteMapping("/{id}") RestResult<Void> delete(@PathVariable("id") Long id); @DeleteMapping("/delete/{type}") RestResult<Void> deleteAllByType(@PathVariable("type") AlertType type); } | @Test public void test_findAllVisibleByType() throws Exception { final AlertResource expected1 = AlertResourceBuilder.newAlertResource() .withId(8888L) .build(); final AlertResource expected2 = AlertResourceBuilder.newAlertResource() .withId(9999L) .build(); final List<AlertResource> expected = new ArrayList<>(asList(expected1, expected2)); when(alertServiceMock.findAllVisibleByType(MAINTENANCE)).thenReturn(serviceSuccess(expected)); mockMvc.perform(get("/alert/find-all-visible/{type}", MAINTENANCE.name())) .andExpect(status().isOk()) .andExpect(jsonPath("[0]id", is(8888))) .andExpect(jsonPath("[1]id", is(9999))) .andDo(document("alert/find-all-visible-by-type", pathParameters( parameterWithName("type").description("Type of alert to find") ),responseFields( fieldWithPath("[]").description("An array of the alerts of the specified type which are visible") ).andWithPrefix("[].", AlertDocs.alertResourceFields)) ); } |
AlertController { @GetMapping("/{id}") public RestResult<AlertResource> findById(@PathVariable("id") Long id) { return alertService.findById(id).toGetResponse(); } @GetMapping("/find-all-visible") RestResult<List<AlertResource>> findAllVisible(); @GetMapping("/find-all-visible/{type}") RestResult<List<AlertResource>> findAllVisibleByType(@PathVariable("type") AlertType type); @GetMapping("/{id}") RestResult<AlertResource> findById(@PathVariable("id") Long id); @PostMapping("/") RestResult<AlertResource> create(@RequestBody AlertResource alertResource); @DeleteMapping("/{id}") RestResult<Void> delete(@PathVariable("id") Long id); @DeleteMapping("/delete/{type}") RestResult<Void> deleteAllByType(@PathVariable("type") AlertType type); } | @Test public void test_getById() throws Exception { final AlertResource expected = AlertResourceBuilder.newAlertResource() .withId(9999L) .build(); when(alertServiceMock.findById(9999L)).thenReturn(serviceSuccess(expected)); mockMvc.perform(get("/alert/{id}", 9999L)) .andExpect(status().isOk()) .andExpect(content().string(objectMapper.writeValueAsString(expected))) .andDo(document("alert/find-by-id", pathParameters( parameterWithName("id").description("Id of the alert to find") ), PayloadDocumentation.responseFields(AlertDocs.alertResourceFields)) ); } |
AlertController { @PostMapping("/") public RestResult<AlertResource> create(@RequestBody AlertResource alertResource) { return alertService.create(alertResource).toPostCreateResponse(); } @GetMapping("/find-all-visible") RestResult<List<AlertResource>> findAllVisible(); @GetMapping("/find-all-visible/{type}") RestResult<List<AlertResource>> findAllVisibleByType(@PathVariable("type") AlertType type); @GetMapping("/{id}") RestResult<AlertResource> findById(@PathVariable("id") Long id); @PostMapping("/") RestResult<AlertResource> create(@RequestBody AlertResource alertResource); @DeleteMapping("/{id}") RestResult<Void> delete(@PathVariable("id") Long id); @DeleteMapping("/delete/{type}") RestResult<Void> deleteAllByType(@PathVariable("type") AlertType type); } | @Test public void test_create() throws Exception { final AlertResource alertResource = AlertResourceBuilder.newAlertResource() .build(); final AlertResource expected = AlertResourceBuilder.newAlertResource() .withId(9999L) .build(); when(alertServiceMock.create(alertResource)).thenReturn(serviceSuccess(expected)); mockMvc.perform(post("/alert/") .contentType(APPLICATION_JSON) .content(objectMapper.writeValueAsString(alertResource))) .andExpect(status().isCreated()) .andExpect(content().string(objectMapper.writeValueAsString(expected))) .andDo(document("alert/create", PayloadDocumentation.requestFields(AlertDocs.alertResourceFields), PayloadDocumentation.responseFields(AlertDocs.alertResourceFields)) ); } |
AlertController { @DeleteMapping("/{id}") public RestResult<Void> delete(@PathVariable("id") Long id) { return alertService.delete(id).toDeleteResponse(); } @GetMapping("/find-all-visible") RestResult<List<AlertResource>> findAllVisible(); @GetMapping("/find-all-visible/{type}") RestResult<List<AlertResource>> findAllVisibleByType(@PathVariable("type") AlertType type); @GetMapping("/{id}") RestResult<AlertResource> findById(@PathVariable("id") Long id); @PostMapping("/") RestResult<AlertResource> create(@RequestBody AlertResource alertResource); @DeleteMapping("/{id}") RestResult<Void> delete(@PathVariable("id") Long id); @DeleteMapping("/delete/{type}") RestResult<Void> deleteAllByType(@PathVariable("type") AlertType type); } | @Test public void test_delete() throws Exception { when(alertServiceMock.delete(9999L)).thenReturn(serviceSuccess()); mockMvc.perform(delete("/alert/{id}", 9999L)) .andExpect(status().isNoContent()) .andExpect(content().string(isEmptyString())) .andDo(document("alert/delete", pathParameters( parameterWithName("id").description("Id of the alert to be deleted") )) ); } |
AlertServiceImpl extends RootTransactionalService implements AlertService { @Override public ServiceResult<List<AlertResource>> findAllVisible() { return serviceSuccess(simpleMap(alertRepository.findAllVisible(now()), alertMapper::mapToResource)); } @Override ServiceResult<List<AlertResource>> findAllVisible(); @Override ServiceResult<List<AlertResource>> findAllVisibleByType(AlertType type); @Override ServiceResult<AlertResource> findById(Long id); @Override @Transactional ServiceResult<AlertResource> create(AlertResource alertResource); @Override @Transactional ServiceResult<Void> delete(Long id); @Override @Transactional ServiceResult<Void> deleteAllByType(AlertType type); } | @Test public void findAllVisible() throws Exception { final Alert alert1 = new Alert(); final Alert alert2 = new Alert(); final List<Alert> alerts = new ArrayList<>(asList(alert1, alert2)); final AlertResource expected1 = AlertResourceBuilder.newAlertResource() .build(); final AlertResource expected2 = AlertResourceBuilder.newAlertResource() .build(); when(alertRepositoryMock.findAllVisible(isA(ZonedDateTime.class))).thenReturn(alerts); when(alertMapperMock.mapToResource(same(alert1))).thenReturn(expected1); when(alertMapperMock.mapToResource(same(alert2))).thenReturn(expected2); final List<AlertResource> found = alertService.findAllVisible().getSuccess(); assertSame(expected1, found.get(0)); assertSame(expected2, found.get(1)); verify(alertRepositoryMock, only()).findAllVisible(isA(ZonedDateTime.class)); } |
EmailNotificationSender implements NotificationSender { @Override public ServiceResult<Notification> sendNotification(Notification notification) { return renderTemplates(notification).andOnSuccess(templates -> { List<ServiceResult<List<EmailAddress>>> results = simpleMap(templates, (target, content) -> sendEmailWithContent(notification, target, content)); return processAnyFailuresOrSucceed(results, failures -> { Error error = new Error(NOTIFICATIONS_UNABLE_TO_SEND_SINGLE, findStatusCode(failures)); return serviceFailure(error); }, serviceSuccess(notification)); }); } @Override NotificationMedium getNotificationMedium(); @Override ServiceResult<Notification> sendNotification(Notification notification); @Override @Transactional(propagation = Propagation.MANDATORY) ServiceResult<Notification> sendNotificationWithFlush(Notification notification); } | @Test public void testSendNotification() { when(notificationTemplateRendererMock.renderTemplate(sender, recipient1, EMAIL_NOTIFICATION_TEMPLATES_PATH + "dummy_message_key_subject.txt", notification.getGlobalArguments())).thenReturn(serviceSuccess("My subject")); when(notificationTemplateRendererMock.renderTemplate(sender, recipient1, EMAIL_NOTIFICATION_TEMPLATES_PATH + "dummy_message_key_text_plain.txt", notification.getGlobalArguments())).thenReturn(serviceSuccess("Plain text body")); when(notificationTemplateRendererMock.renderTemplate(sender, recipient1, EMAIL_NOTIFICATION_TEMPLATES_PATH + "dummy_message_key_text_html.html", notification.getGlobalArguments())).thenReturn(serviceSuccess("HTML body")); when(notificationTemplateRendererMock.renderTemplate(sender, recipient2, EMAIL_NOTIFICATION_TEMPLATES_PATH + "dummy_message_key_subject.txt", notification.getGlobalArguments())).thenReturn(serviceSuccess("My subject 2")); when(notificationTemplateRendererMock.renderTemplate(sender, recipient2, EMAIL_NOTIFICATION_TEMPLATES_PATH + "dummy_message_key_text_plain.txt", notification.getGlobalArguments())).thenReturn(serviceSuccess("Plain text body 2")); when(notificationTemplateRendererMock.renderTemplate(sender, recipient2, EMAIL_NOTIFICATION_TEMPLATES_PATH + "dummy_message_key_text_html.html", notification.getGlobalArguments())).thenReturn(serviceSuccess("HTML body 2")); when(emailServiceMock.sendEmail(senderEmail, singletonList(recipient1Email), "My subject", "Plain text body", "HTML body")).thenReturn(serviceSuccess(singletonList(recipient1Email))); when(emailServiceMock.sendEmail(senderEmail, singletonList(recipient2Email), "My subject 2", "Plain text body 2", "HTML body 2")).thenReturn(serviceSuccess(singletonList(recipient2Email))); ServiceResult<Notification> results = notificationSender.sendNotification(notification); assertTrue(results.isSuccess()); verify(emailServiceMock).sendEmail(senderEmail, singletonList(recipient1Email), "My subject", "Plain text body", "HTML body"); verify(emailServiceMock).sendEmail(senderEmail, singletonList(recipient2Email), "My subject 2", "Plain text body 2", "HTML body 2"); }
@Test public void testSendNotificationButEmailServiceFails() { when(notificationTemplateRendererMock.renderTemplate(sender, recipient1, EMAIL_NOTIFICATION_TEMPLATES_PATH + "dummy_message_key_subject.txt", notification.getGlobalArguments())).thenReturn(serviceSuccess("My subject")); when(notificationTemplateRendererMock.renderTemplate(sender, recipient1, EMAIL_NOTIFICATION_TEMPLATES_PATH + "dummy_message_key_text_plain.txt", notification.getGlobalArguments())).thenReturn(serviceSuccess("Plain text body")); when(notificationTemplateRendererMock.renderTemplate(sender, recipient1, EMAIL_NOTIFICATION_TEMPLATES_PATH + "dummy_message_key_text_html.html", notification.getGlobalArguments())).thenReturn(serviceSuccess("HTML body")); when(notificationTemplateRendererMock.renderTemplate(sender, recipient2, EMAIL_NOTIFICATION_TEMPLATES_PATH + "dummy_message_key_subject.txt", notification.getGlobalArguments())).thenReturn(serviceSuccess("My subject 2")); when(notificationTemplateRendererMock.renderTemplate(sender, recipient2, EMAIL_NOTIFICATION_TEMPLATES_PATH + "dummy_message_key_text_plain.txt", notification.getGlobalArguments())).thenReturn(serviceSuccess("Plain text body 2")); when(notificationTemplateRendererMock.renderTemplate(sender, recipient2, EMAIL_NOTIFICATION_TEMPLATES_PATH + "dummy_message_key_text_html.html", notification.getGlobalArguments())).thenReturn(serviceSuccess("HTML body 2")); when(emailServiceMock.sendEmail(senderEmail, singletonList(recipient1Email), "My subject", "Plain text body", "HTML body")).thenReturn(serviceFailure(new Error(EMAILS_NOT_SENT_MULTIPLE, INTERNAL_SERVER_ERROR))); when(emailServiceMock.sendEmail(senderEmail, singletonList(recipient2Email), "My subject 2", "Plain text body 2", "HTML body 2")).thenReturn(serviceFailure(new Error(EMAILS_NOT_SENT_MULTIPLE, INTERNAL_SERVER_ERROR))); ServiceResult<Notification> results = notificationSender.sendNotification(notification); assertTrue(results.isFailure()); assertTrue(results.getFailure().is(NOTIFICATIONS_UNABLE_TO_SEND_SINGLE)); verify(emailServiceMock).sendEmail(senderEmail, singletonList(recipient1Email), "My subject", "Plain text body", "HTML body"); verify(emailServiceMock).sendEmail(senderEmail, singletonList(recipient2Email), "My subject 2", "Plain text body 2", "HTML body 2"); }
@Test public void testSendNotificationButEmailServiceFailsPartially() { when(notificationTemplateRendererMock.renderTemplate(sender, recipient1, EMAIL_NOTIFICATION_TEMPLATES_PATH + "dummy_message_key_subject.txt", notification.getGlobalArguments())).thenReturn(serviceSuccess("My subject")); when(notificationTemplateRendererMock.renderTemplate(sender, recipient1, EMAIL_NOTIFICATION_TEMPLATES_PATH + "dummy_message_key_text_plain.txt", notification.getGlobalArguments())).thenReturn(serviceSuccess("Plain text body")); when(notificationTemplateRendererMock.renderTemplate(sender, recipient1, EMAIL_NOTIFICATION_TEMPLATES_PATH + "dummy_message_key_text_html.html", notification.getGlobalArguments())).thenReturn(serviceSuccess("HTML body")); when(notificationTemplateRendererMock.renderTemplate(sender, recipient2, EMAIL_NOTIFICATION_TEMPLATES_PATH + "dummy_message_key_subject.txt", notification.getGlobalArguments())).thenReturn(serviceSuccess("My subject 2")); when(notificationTemplateRendererMock.renderTemplate(sender, recipient2, EMAIL_NOTIFICATION_TEMPLATES_PATH + "dummy_message_key_text_plain.txt", notification.getGlobalArguments())).thenReturn(serviceSuccess("Plain text body 2")); when(notificationTemplateRendererMock.renderTemplate(sender, recipient2, EMAIL_NOTIFICATION_TEMPLATES_PATH + "dummy_message_key_text_html.html", notification.getGlobalArguments())).thenReturn(serviceSuccess("HTML body 2")); when(emailServiceMock.sendEmail(senderEmail, singletonList(recipient1Email), "My subject", "Plain text body", "HTML body")).thenReturn(serviceFailure(new Error(NOTIFICATIONS_UNABLE_TO_SEND_SINGLE, INTERNAL_SERVER_ERROR))); when(emailServiceMock.sendEmail(senderEmail, singletonList(recipient2Email), "My subject 2", "Plain text body 2", "HTML body 2")).thenReturn(serviceSuccess(singletonList(recipient2Email))); ServiceResult<Notification> results = notificationSender.sendNotification(notification); assertTrue(results.isFailure()); assertTrue(results.getFailure().is(NOTIFICATIONS_UNABLE_TO_SEND_SINGLE)); verify(emailServiceMock).sendEmail(senderEmail, singletonList(recipient1Email), "My subject", "Plain text body", "HTML body"); verify(emailServiceMock).sendEmail(senderEmail, singletonList(recipient2Email), "My subject 2", "Plain text body 2", "HTML body 2"); }
@Test public void testSendNotificationButRenderTemplateFails() { when(notificationTemplateRendererMock.renderTemplate(sender, recipient1, EMAIL_NOTIFICATION_TEMPLATES_PATH + "dummy_message_key_subject.txt", notification.getGlobalArguments())).thenReturn(serviceFailure(new Error(NOTIFICATIONS_UNABLE_TO_RENDER_TEMPLATE, "subject"))); when(notificationTemplateRendererMock.renderTemplate(sender, recipient2, EMAIL_NOTIFICATION_TEMPLATES_PATH + "dummy_message_key_subject.txt", notification.getGlobalArguments())).thenReturn(serviceSuccess("My subject 2")); when(notificationTemplateRendererMock.renderTemplate(sender, recipient2, EMAIL_NOTIFICATION_TEMPLATES_PATH + "dummy_message_key_text_plain.txt", notification.getGlobalArguments())).thenReturn(serviceFailure(new Error(NOTIFICATIONS_UNABLE_TO_RENDER_TEMPLATE, "text"))); ServiceResult<Notification> results = notificationSender.sendNotification(notification); assertTrue(results.isFailure()); assertEquals(NOTIFICATIONS_UNABLE_TO_RENDER_TEMPLATE.name(), results.getFailure().getErrors().get(0).getErrorKey()); assertEquals("subject", results.getFailure().getErrors().get(0).getArguments().get(0)); assertEquals(NOTIFICATIONS_UNABLE_TO_RENDER_TEMPLATE.name(), results.getFailure().getErrors().get(1).getErrorKey()); assertEquals("text", results.getFailure().getErrors().get(1).getArguments().get(0)); verify(emailServiceMock, never()).sendEmail(senderEmail, singletonList(recipient1Email), "My subject", "Plain text body", "HTML body"); verify(emailServiceMock, never()).sendEmail(senderEmail, singletonList(recipient2Email), "My subject 2", "Plain text body 2", "HTML body 2"); } |
AlertServiceImpl extends RootTransactionalService implements AlertService { @Override public ServiceResult<List<AlertResource>> findAllVisibleByType(AlertType type) { return serviceSuccess(simpleMap(alertRepository.findAllVisibleByType(type, now()), alertMapper::mapToResource)); } @Override ServiceResult<List<AlertResource>> findAllVisible(); @Override ServiceResult<List<AlertResource>> findAllVisibleByType(AlertType type); @Override ServiceResult<AlertResource> findById(Long id); @Override @Transactional ServiceResult<AlertResource> create(AlertResource alertResource); @Override @Transactional ServiceResult<Void> delete(Long id); @Override @Transactional ServiceResult<Void> deleteAllByType(AlertType type); } | @Test public void findAllVisibleByType() throws Exception { final Alert alert1 = new Alert(); final Alert alert2 = new Alert(); final List<Alert> alerts = new ArrayList<>(asList(alert1, alert2)); final AlertResource expected1 = AlertResourceBuilder.newAlertResource() .build(); final AlertResource expected2 = AlertResourceBuilder.newAlertResource() .build(); when(alertRepositoryMock.findAllVisibleByType(same(MAINTENANCE), isA(ZonedDateTime.class))).thenReturn(alerts); when(alertMapperMock.mapToResource(same(alert1))).thenReturn(expected1); when(alertMapperMock.mapToResource(same(alert2))).thenReturn(expected2); final List<AlertResource> found = alertService.findAllVisibleByType(MAINTENANCE).getSuccess(); assertSame(expected1, found.get(0)); assertSame(expected2, found.get(1)); verify(alertRepositoryMock, only()).findAllVisibleByType(same(MAINTENANCE), isA(ZonedDateTime.class)); } |
AlertServiceImpl extends RootTransactionalService implements AlertService { @Override public ServiceResult<AlertResource> findById(Long id) { return find(alertRepository.findById(id), notFoundError(Alert.class, id)).andOnSuccessReturn(alertMapper::mapToResource); } @Override ServiceResult<List<AlertResource>> findAllVisible(); @Override ServiceResult<List<AlertResource>> findAllVisibleByType(AlertType type); @Override ServiceResult<AlertResource> findById(Long id); @Override @Transactional ServiceResult<AlertResource> create(AlertResource alertResource); @Override @Transactional ServiceResult<Void> delete(Long id); @Override @Transactional ServiceResult<Void> deleteAllByType(AlertType type); } | @Test public void findById() throws Exception { final AlertResource expected = AlertResourceBuilder.newAlertResource() .build(); final Alert alert = new Alert(); when(alertRepositoryMock.findById(9999L)).thenReturn(Optional.of(alert)); when(alertMapperMock.mapToResource(same(alert))).thenReturn(expected); assertSame(expected, alertService.findById(9999L).getSuccess()); verify(alertRepositoryMock, only()).findById(9999L); } |
AlertServiceImpl extends RootTransactionalService implements AlertService { @Override @Transactional public ServiceResult<AlertResource> create(AlertResource alertResource) { Alert saved = alertRepository.save(alertMapper.mapToDomain(alertResource)); return serviceSuccess(alertMapper.mapToResource(saved)); } @Override ServiceResult<List<AlertResource>> findAllVisible(); @Override ServiceResult<List<AlertResource>> findAllVisibleByType(AlertType type); @Override ServiceResult<AlertResource> findById(Long id); @Override @Transactional ServiceResult<AlertResource> create(AlertResource alertResource); @Override @Transactional ServiceResult<Void> delete(Long id); @Override @Transactional ServiceResult<Void> deleteAllByType(AlertType type); } | @Test public void create() throws Exception { final AlertResource alertResource = AlertResourceBuilder.newAlertResource() .build(); final AlertResource expected = AlertResourceBuilder.newAlertResource() .build(); final Alert alert = new Alert(); when(alertMapperMock.mapToDomain(same(alertResource))).thenReturn(alert); when(alertRepositoryMock.save(same(alert))).thenReturn(alert); when(alertMapperMock.mapToResource(same(alert))).thenReturn(expected); assertSame(expected, alertService.create(alertResource).getSuccess()); verify(alertRepositoryMock, only()).save(alert); } |
AlertServiceImpl extends RootTransactionalService implements AlertService { @Override @Transactional public ServiceResult<Void> delete(Long id) { alertRepository.deleteById(id); return serviceSuccess(); } @Override ServiceResult<List<AlertResource>> findAllVisible(); @Override ServiceResult<List<AlertResource>> findAllVisibleByType(AlertType type); @Override ServiceResult<AlertResource> findById(Long id); @Override @Transactional ServiceResult<AlertResource> create(AlertResource alertResource); @Override @Transactional ServiceResult<Void> delete(Long id); @Override @Transactional ServiceResult<Void> deleteAllByType(AlertType type); } | @Test public void delete() throws Exception { assertTrue(alertService.delete(9999L).isSuccess()); verify(alertRepositoryMock, only()).deleteById(9999L); } |
AlertServiceImpl extends RootTransactionalService implements AlertService { @Override @Transactional public ServiceResult<Void> deleteAllByType(AlertType type) { alertRepository.deleteByType(type); return serviceSuccess(); } @Override ServiceResult<List<AlertResource>> findAllVisible(); @Override ServiceResult<List<AlertResource>> findAllVisibleByType(AlertType type); @Override ServiceResult<AlertResource> findById(Long id); @Override @Transactional ServiceResult<AlertResource> create(AlertResource alertResource); @Override @Transactional ServiceResult<Void> delete(Long id); @Override @Transactional ServiceResult<Void> deleteAllByType(AlertType type); } | @Test public void deleteAllByType() throws Exception { assertTrue(alertService.delete(9999L).isSuccess()); } |
PasswordValidator implements Validator<String, InvalidPasswordException> { @Override public void validate(final String password) throws InvalidPasswordException { final String passwordLowerCase = password.toLowerCase(); if(passwordPolicy.getBlacklist().stream().anyMatch(passwordLowerCase::contains)) { throw new InvalidPasswordException(singletonList(InvalidPasswordException.ERROR_KEY)); } } PasswordValidator(final PasswordPolicyProperties passwordPolicy); @Override void validate(final String password); } | @Test public void shouldAcceptValidPasswords() throws InvalidPasswordException { validator.validate("valid-password"); }
@Test public void shouldRejectDuplicateEmails() { try { validator.validate("invalid-password"); assertThat("Service failed to throw expected exception.", false); } catch (final InvalidPasswordException exception) { assertThat(exception.toErrorResponse().getKey(), is(equalTo(InvalidPasswordException.ERROR_KEY))); assertThat(exception.toErrorResponse().getArguments(), hasItem(equalTo(InvalidPasswordException.ERROR_KEY))); } } |
EmailValidator implements Validator<String, DuplicateEmailException> { @Override public void validate(final String email) throws DuplicateEmailException { final Optional<Identity> byEmail = findIdentityService.findByEmail(email); if (byEmail.isPresent()) { throw new DuplicateEmailException(); } } EmailValidator(final FindIdentityService findIdentityService); @Override void validate(final String email); } | @Test public void shouldAcceptValidEmails() throws DuplicateEmailException { when(findIdentityService.findByEmail(eq("[email protected]"))).thenReturn(Optional.empty()); validator.validate("[email protected]"); verify(findIdentityService).findByEmail(eq("[email protected]")); verifyNoMoreInteractions(findIdentityService); }
@Test public void shouldRejectDuplicateEmails() { when(findIdentityService.findByEmail(eq("[email protected]"))).thenReturn(Optional.of(new Identity())); try { validator.validate("[email protected]"); assertThat("Service failed to throw expected exception.", false); } catch (final DuplicateEmailException exception) { assertThat(exception.toErrorResponse().getKey(), is(equalTo("DUPLICATE_EMAIL_ADDRESS"))); assertThat(exception.toErrorResponse().getArguments(), is(emptyCollectionOf(String.class))); } verify(findIdentityService).findByEmail(eq("[email protected]")); verifyNoMoreInteractions(findIdentityService); } |
AgreementRestServiceImpl extends BaseRestService implements AgreementRestService { @Override public RestResult<AgreementResource> getCurrentAgreement() { return getWithRestResult(agreementRestURL + "/find-current", AgreementResource.class); } @Override RestResult<AgreementResource> getCurrentAgreement(); } | @Test public void getCurrentContract() { AgreementResource agreementResource = new AgreementResource(); setupGetWithRestResultExpectations(agreementUrl + "/find-current", AgreementResource.class, agreementResource, OK); RestResult<AgreementResource> result = service.getCurrentAgreement(); assertEquals(agreementResource, result.getSuccess()); } |
KnowledgeBaseRestServiceImpl extends BaseRestService implements KnowledgeBaseRestService { @Override public RestResult<List<String>> getKnowledgeBases() { return getWithRestResultAnonymous(ORGANISATION_BASE_URL, stringsListType()); } @Override RestResult<List<String>> getKnowledgeBases(); @Override RestResult<KnowledgeBaseResource> getKnowledgeBaseByName(String knowledgeBaseName); } | @Test public void getKnowledgeBases() { String expected = "KnowledgeBase 1"; setupGetWithRestResultAnonymousExpectations(ORGANISATION_BASE_URL, stringsListType(), Collections.singletonList(expected), OK); RestResult<List<String>> result = service.getKnowledgeBases(); assertEquals(expected, result.getSuccess().get(0)); } |
KnowledgeBaseRestServiceImpl extends BaseRestService implements KnowledgeBaseRestService { @Override public RestResult<KnowledgeBaseResource> getKnowledgeBaseByName(String knowledgeBaseName) { return getWithRestResultAnonymous(ORGANISATION_BASE_URL + "/find-by-name/" + knowledgeBaseName, KnowledgeBaseResource.class); } @Override RestResult<List<String>> getKnowledgeBases(); @Override RestResult<KnowledgeBaseResource> getKnowledgeBaseByName(String knowledgeBaseName); } | @Test public void getKnowledgeBaseByName() { String expected = "KnowledgeBase 1"; KnowledgeBaseResource knowledgeBaseResource = new KnowledgeBaseResource(); knowledgeBaseResource.setName(expected); setupGetWithRestResultAnonymousExpectations(ORGANISATION_BASE_URL + "/find-by-name/" + expected, KnowledgeBaseResource.class, knowledgeBaseResource, OK); RestResult<KnowledgeBaseResource> result = service.getKnowledgeBaseByName(expected); assertEquals(expected, result.getSuccess().getName()); } |
FormInputRestServiceImpl extends BaseRestService implements FormInputRestService { @Override public RestResult<List<FormInputResource>> getByQuestionIdAndScope(Long questionId, FormInputScope scope) { return getWithRestResult(formInputRestURL + "/find-by-question-id/" + questionId + "/scope/" + scope, formInputResourceListType()); } @Override RestResult<FormInputResource> getById(Long formInputId); @Override RestResult<List<FormInputResource>> getByQuestionId(Long questionId); @Override RestResult<List<FormInputResource>> getByQuestionIdAndScope(Long questionId, FormInputScope scope); @Override RestResult<List<FormInputResource>> getByCompetitionId(Long competitionId); @Override RestResult<List<FormInputResource>> getByCompetitionIdAndScope(Long competitionId, FormInputScope scope); @Override RestResult<Void> delete(Long formInputId); @Override RestResult<ByteArrayResource> downloadFile(long formInputId); @Override RestResult<FileEntryResource> findFile(long formInputId); } | @Test public void testGetByQuestionIdAndScope() throws Exception { List<FormInputResource> expected = Stream.of(1, 2, 3).map(i -> new FormInputResource()).collect(Collectors.toList()); Long questionId = 1L; FormInputScope scope = FormInputScope.APPLICATION; setupGetWithRestResultExpectations(String.format("%s/find-by-question-id/%s/scope/%s", formInputRestUrl, questionId, scope), formInputResourceListType(), expected, OK); List<FormInputResource> response = service.getByQuestionIdAndScope(questionId, scope).getSuccess(); assertSame(expected, response); } |
FormInputRestServiceImpl extends BaseRestService implements FormInputRestService { @Override public RestResult<List<FormInputResource>> getByCompetitionIdAndScope(Long competitionId, FormInputScope scope) { return getWithRestResult(formInputRestURL + "/find-by-competition-id/" + competitionId + "/scope/" + scope, formInputResourceListType()); } @Override RestResult<FormInputResource> getById(Long formInputId); @Override RestResult<List<FormInputResource>> getByQuestionId(Long questionId); @Override RestResult<List<FormInputResource>> getByQuestionIdAndScope(Long questionId, FormInputScope scope); @Override RestResult<List<FormInputResource>> getByCompetitionId(Long competitionId); @Override RestResult<List<FormInputResource>> getByCompetitionIdAndScope(Long competitionId, FormInputScope scope); @Override RestResult<Void> delete(Long formInputId); @Override RestResult<ByteArrayResource> downloadFile(long formInputId); @Override RestResult<FileEntryResource> findFile(long formInputId); } | @Test public void testGetByCompetitionIdAndScope() throws Exception { List<FormInputResource> expected = Stream.of(1, 2, 3).map(i -> new FormInputResource()).collect(Collectors.toList()); Long competitionId = 1L; FormInputScope scope = FormInputScope.APPLICATION; setupGetWithRestResultExpectations(String.format("%s/find-by-competition-id/%s/scope/%s", formInputRestUrl, competitionId, scope), formInputResourceListType(), expected, OK); List<FormInputResource> response = service.getByCompetitionIdAndScope(competitionId, scope).getSuccess(); assertSame(expected, response); } |
FormInputRestServiceImpl extends BaseRestService implements FormInputRestService { @Override public RestResult<Void> delete(Long formInputId) { return deleteWithRestResult(formInputRestURL + "/" + formInputId, Void.class) ; } @Override RestResult<FormInputResource> getById(Long formInputId); @Override RestResult<List<FormInputResource>> getByQuestionId(Long questionId); @Override RestResult<List<FormInputResource>> getByQuestionIdAndScope(Long questionId, FormInputScope scope); @Override RestResult<List<FormInputResource>> getByCompetitionId(Long competitionId); @Override RestResult<List<FormInputResource>> getByCompetitionIdAndScope(Long competitionId, FormInputScope scope); @Override RestResult<Void> delete(Long formInputId); @Override RestResult<ByteArrayResource> downloadFile(long formInputId); @Override RestResult<FileEntryResource> findFile(long formInputId); } | @Test public void testDelete() throws Exception { Long formInputId = 1L; ResponseEntity<Void> result = setupDeleteWithRestResultExpectations(formInputRestUrl + "/" + formInputId); assertEquals(NO_CONTENT, result.getStatusCode()); } |
GoogleAnalyticsDataLayerRestServiceImpl extends BaseRestService implements GoogleAnalyticsDataLayerRestService { @Override public RestResult<String> getCompetitionNameForApplication(long applicationId) { return getWithRestResult(format("%s/application/%d/competition-name", ANALYTICS_BASE_URL, applicationId), String.class ); } @Override RestResult<String> getCompetitionNameForInvite(String inviteHash); @Override RestResult<String> getCompetitionNameForApplication(long applicationId); @Override RestResult<String> getCompetitionName(long competitionId); @Override RestResult<String> getCompetitionNameForProject(long projectId); @Override RestResult<String> getCompetitionNameForAssessment(long assessmentId); @Override RestResult<List<Role>> getRolesByApplicationId(long applicationId); @Override RestResult<List<Role>> getRolesByProjectId(long projectId); @Override RestResult<Long> getApplicationIdForProject(long projectId); @Override RestResult<Long> getApplicationIdForAssessment(long assessmentId); } | @Test public void getCompetitionNameForApplication() { long applicationId = 5L; String expected = "competition name"; setupGetWithRestResultExpectations( format("%s/%s/%d/competition-name", restUrl, "application", applicationId), String.class, expected ); String actual = service.getCompetitionNameForApplication(applicationId).getSuccess(); assertEquals(expected, actual); } |
GoogleAnalyticsDataLayerRestServiceImpl extends BaseRestService implements GoogleAnalyticsDataLayerRestService { @Override public RestResult<String> getCompetitionName(long competitionId) { return getWithRestResultAnonymous(format("%s/competition/%d/competition-name", ANALYTICS_BASE_URL, competitionId), String.class); } @Override RestResult<String> getCompetitionNameForInvite(String inviteHash); @Override RestResult<String> getCompetitionNameForApplication(long applicationId); @Override RestResult<String> getCompetitionName(long competitionId); @Override RestResult<String> getCompetitionNameForProject(long projectId); @Override RestResult<String> getCompetitionNameForAssessment(long assessmentId); @Override RestResult<List<Role>> getRolesByApplicationId(long applicationId); @Override RestResult<List<Role>> getRolesByProjectId(long projectId); @Override RestResult<Long> getApplicationIdForProject(long projectId); @Override RestResult<Long> getApplicationIdForAssessment(long assessmentId); } | @Test public void getCompetitionName() { long competitionId = 7L; String expected = "competition name"; setupGetWithRestResultAnonymousExpectations( format("%s/%s/%d/competition-name", restUrl, "competition", competitionId), String.class, expected ); String actual = service.getCompetitionName(competitionId).getSuccess(); assertEquals(expected, actual); } |
GoogleAnalyticsDataLayerRestServiceImpl extends BaseRestService implements GoogleAnalyticsDataLayerRestService { @Override public RestResult<String> getCompetitionNameForProject(long projectId) { return getWithRestResult(format("%s/project/%d/competition-name", ANALYTICS_BASE_URL, projectId), String.class); } @Override RestResult<String> getCompetitionNameForInvite(String inviteHash); @Override RestResult<String> getCompetitionNameForApplication(long applicationId); @Override RestResult<String> getCompetitionName(long competitionId); @Override RestResult<String> getCompetitionNameForProject(long projectId); @Override RestResult<String> getCompetitionNameForAssessment(long assessmentId); @Override RestResult<List<Role>> getRolesByApplicationId(long applicationId); @Override RestResult<List<Role>> getRolesByProjectId(long projectId); @Override RestResult<Long> getApplicationIdForProject(long projectId); @Override RestResult<Long> getApplicationIdForAssessment(long assessmentId); } | @Test public void getCompetitionNameForProject() { long projectId = 11L; String expected = "competition name"; setupGetWithRestResultExpectations( format("%s/%s/%d/competition-name", restUrl, "project", projectId), String.class, expected ); String actual = service.getCompetitionNameForProject(projectId).getSuccess(); assertEquals(expected, actual); } |
GoogleAnalyticsDataLayerRestServiceImpl extends BaseRestService implements GoogleAnalyticsDataLayerRestService { @Override public RestResult<String> getCompetitionNameForAssessment(long assessmentId) { return getWithRestResult(format("%s/assessment/%d/competition-name", ANALYTICS_BASE_URL, assessmentId), String.class ); } @Override RestResult<String> getCompetitionNameForInvite(String inviteHash); @Override RestResult<String> getCompetitionNameForApplication(long applicationId); @Override RestResult<String> getCompetitionName(long competitionId); @Override RestResult<String> getCompetitionNameForProject(long projectId); @Override RestResult<String> getCompetitionNameForAssessment(long assessmentId); @Override RestResult<List<Role>> getRolesByApplicationId(long applicationId); @Override RestResult<List<Role>> getRolesByProjectId(long projectId); @Override RestResult<Long> getApplicationIdForProject(long projectId); @Override RestResult<Long> getApplicationIdForAssessment(long assessmentId); } | @Test public void getCompetitionNameForAssessment() { long assessmentId = 13L; String expected = "competition name"; setupGetWithRestResultExpectations( format("%s/%s/%d/competition-name", restUrl, "assessment", assessmentId), String.class, expected ); String actual = service.getCompetitionNameForAssessment(assessmentId).getSuccess(); assertEquals(expected, actual); } |
GoogleAnalyticsDataLayerRestServiceImpl extends BaseRestService implements GoogleAnalyticsDataLayerRestService { @Override public RestResult<List<Role>> getRolesByApplicationId(long applicationId) { return getWithRestResult(format("%s/application/%d/user-roles", ANALYTICS_BASE_URL, applicationId), roleListType() ); } @Override RestResult<String> getCompetitionNameForInvite(String inviteHash); @Override RestResult<String> getCompetitionNameForApplication(long applicationId); @Override RestResult<String> getCompetitionName(long competitionId); @Override RestResult<String> getCompetitionNameForProject(long projectId); @Override RestResult<String> getCompetitionNameForAssessment(long assessmentId); @Override RestResult<List<Role>> getRolesByApplicationId(long applicationId); @Override RestResult<List<Role>> getRolesByProjectId(long projectId); @Override RestResult<Long> getApplicationIdForProject(long projectId); @Override RestResult<Long> getApplicationIdForAssessment(long assessmentId); } | @Test public void getApplicationRolesById() { long applicationId = 123L; List<Role> expectedRoles = singletonList(Role.COLLABORATOR); setupGetWithRestResultExpectations( format("%s/%s/%d/user-roles", restUrl, "application", applicationId), roleListType(), expectedRoles ); List<Role> roles = service.getRolesByApplicationId(applicationId).getSuccess(); assertEquals(expectedRoles, roles); } |
RegistrationServiceImpl extends BaseTransactionalService implements RegistrationService { @Override @Transactional public ServiceResult<User> activatePendingUser(User user, String password, String hash) { if(monitoringOfficerInviteRepository.existsByHash(hash)) { return activateUser(user) .andOnSuccess(activatedUser -> idpService.updateUserPassword(activatedUser.getUid(), password)) .andOnSuccessReturn(() -> user); } return serviceFailure(GENERAL_NOT_FOUND); } @Override @Transactional ServiceResult<UserResource> createUser(UserCreationResource user); @Override @Transactional ServiceResult<Void> resendUserVerificationEmail(final UserResource user); @Override @Transactional @UserUpdate ServiceResult<UserResource> activateUser(long userId); @Override @Transactional @UserUpdate ServiceResult<UserResource> deactivateUser(long userId); @Override @Transactional ServiceResult<User> activatePendingUser(User user,
String password,
String hash); @Override @Transactional ServiceResult<Void> activateApplicantAndSendDiversitySurvey(long userId); @Override @Transactional ServiceResult<Void> activateAssessorAndSendDiversitySurvey(long userId); @Override @Transactional @UserUpdate ServiceResult<UserResource> editInternalUser(UserResource userToEdit, Role userRoleType); } | @Test public void activatePendingUser() { User user = newUser().withUid("uid").build(); when(monitoringOfficerInviteRepositoryMock.existsByHash("hash")).thenReturn(true); when(idpServiceMock.activateUser(anyString())).thenReturn(serviceSuccess("uid")); when(userRepositoryMock.save(any(User.class))).thenReturn(user); when(idpServiceMock.updateUserPassword("uid", "password")).thenReturn(serviceSuccess("uid")); service.activatePendingUser(user, "password", "hash").getSuccess(); verify(monitoringOfficerInviteRepositoryMock).existsByHash("hash"); verify(idpServiceMock).activateUser(anyString()); verify(userRepositoryMock).save(any(User.class)); verify(idpServiceMock).updateUserPassword("uid", "password"); } |
GoogleAnalyticsDataLayerRestServiceImpl extends BaseRestService implements GoogleAnalyticsDataLayerRestService { @Override public RestResult<List<Role>> getRolesByProjectId(long projectId) { return getWithRestResult(format("%s/project/%d/user-roles", ANALYTICS_BASE_URL, projectId), roleListType()); } @Override RestResult<String> getCompetitionNameForInvite(String inviteHash); @Override RestResult<String> getCompetitionNameForApplication(long applicationId); @Override RestResult<String> getCompetitionName(long competitionId); @Override RestResult<String> getCompetitionNameForProject(long projectId); @Override RestResult<String> getCompetitionNameForAssessment(long assessmentId); @Override RestResult<List<Role>> getRolesByApplicationId(long applicationId); @Override RestResult<List<Role>> getRolesByProjectId(long projectId); @Override RestResult<Long> getApplicationIdForProject(long projectId); @Override RestResult<Long> getApplicationIdForAssessment(long assessmentId); } | @Test public void getProjectRolesById() { long projectId = 999L; List<Role> expectedRoles = asList(Role.PARTNER, Role.PROJECT_MANAGER); setupGetWithRestResultExpectations( format("%s/%s/%d/user-roles", restUrl, "project", projectId), roleListType(), expectedRoles ); List<Role> roles = service.getRolesByProjectId(projectId).getSuccess(); assertEquals(expectedRoles, roles); } |
GoogleAnalyticsDataLayerRestServiceImpl extends BaseRestService implements GoogleAnalyticsDataLayerRestService { @Override public RestResult<Long> getApplicationIdForProject(long projectId) { return getWithRestResult(format("%s/project/%d/application-id", ANALYTICS_BASE_URL, projectId), Long.class); } @Override RestResult<String> getCompetitionNameForInvite(String inviteHash); @Override RestResult<String> getCompetitionNameForApplication(long applicationId); @Override RestResult<String> getCompetitionName(long competitionId); @Override RestResult<String> getCompetitionNameForProject(long projectId); @Override RestResult<String> getCompetitionNameForAssessment(long assessmentId); @Override RestResult<List<Role>> getRolesByApplicationId(long applicationId); @Override RestResult<List<Role>> getRolesByProjectId(long projectId); @Override RestResult<Long> getApplicationIdForProject(long projectId); @Override RestResult<Long> getApplicationIdForAssessment(long assessmentId); } | @Test public void getApplicationIdForProject() { long projectId = 987L; long applicationId = 654L; setupGetWithRestResultExpectations( format("%s/%s/%d/application-id", restUrl, "project", projectId), Long.class, applicationId ); long expectedApplicationId = service.getApplicationIdForProject(projectId).getSuccess(); assertEquals(expectedApplicationId, applicationId); } |
SectionStatusRestServiceImpl extends BaseRestService implements SectionStatusRestService { @Override public RestResult<ValidationMessages> markAsComplete(long sectionId, long applicationId, long markedAsCompleteById) { return postWithRestResult(sectionRestURL + "/mark-as-complete/" + sectionId + "/" + applicationId + "/" + markedAsCompleteById, ValidationMessages.class); } @Override RestResult<ValidationMessages> markAsComplete(long sectionId, long applicationId, long markedAsCompleteById); @Override RestResult<Void> markAsNotRequired(long sectionId, long applicationId, long markedAsCompleteById); @Override RestResult<Void> markAsInComplete(long sectionId, long applicationId, long markedAsInCompleteById); @Override RestResult<Map<Long, Set<Long>>> getCompletedSectionsByOrganisation(long applicationId); @Override RestResult<List<Long>> getCompletedSectionIds(long applicationId, long organisationId); @Override RestResult<Boolean> allSectionsMarkedAsComplete(long applicationId); } | @Test public void markAsComplete() { long sectionId = 123L; long applicationId = 234L; long markedAsCompleteById = 345L; String expectedUrl = sectionRestUrl + "/mark-as-complete/" + sectionId + "/" + applicationId + "/" + markedAsCompleteById; ValidationMessages messages = new ValidationMessages(); setupPostWithRestResultExpectations(expectedUrl, ValidationMessages.class, null, messages, HttpStatus.OK); RestResult<ValidationMessages> result = service.markAsComplete(sectionId, applicationId, markedAsCompleteById); assertEquals(messages, result.getSuccess()); } |
SectionStatusRestServiceImpl extends BaseRestService implements SectionStatusRestService { @Override public RestResult<Void> markAsNotRequired(long sectionId, long applicationId, long markedAsCompleteById) { return postWithRestResult(sectionRestURL + "/mark-as-not-required/" + sectionId + "/" + applicationId + "/" + markedAsCompleteById, Void.class); } @Override RestResult<ValidationMessages> markAsComplete(long sectionId, long applicationId, long markedAsCompleteById); @Override RestResult<Void> markAsNotRequired(long sectionId, long applicationId, long markedAsCompleteById); @Override RestResult<Void> markAsInComplete(long sectionId, long applicationId, long markedAsInCompleteById); @Override RestResult<Map<Long, Set<Long>>> getCompletedSectionsByOrganisation(long applicationId); @Override RestResult<List<Long>> getCompletedSectionIds(long applicationId, long organisationId); @Override RestResult<Boolean> allSectionsMarkedAsComplete(long applicationId); } | @Test public void markAsNotRequired() { long sectionId = 123L; long applicationId = 234L; long markedAsCompleteById = 345L; String expectedUrl = sectionRestUrl + "/mark-as-not-required/" + sectionId + "/" + applicationId + "/" + markedAsCompleteById; setupPostWithRestResultExpectations(expectedUrl, HttpStatus.OK); RestResult<Void> result = service.markAsNotRequired(sectionId, applicationId, markedAsCompleteById); assertTrue(result.isSuccess()); } |
SectionStatusRestServiceImpl extends BaseRestService implements SectionStatusRestService { @Override public RestResult<Void> markAsInComplete(long sectionId, long applicationId, long markedAsInCompleteById) { return postWithRestResult(sectionRestURL + "/mark-as-in-complete/" + sectionId + "/" + applicationId + "/" + markedAsInCompleteById, Void.class); } @Override RestResult<ValidationMessages> markAsComplete(long sectionId, long applicationId, long markedAsCompleteById); @Override RestResult<Void> markAsNotRequired(long sectionId, long applicationId, long markedAsCompleteById); @Override RestResult<Void> markAsInComplete(long sectionId, long applicationId, long markedAsInCompleteById); @Override RestResult<Map<Long, Set<Long>>> getCompletedSectionsByOrganisation(long applicationId); @Override RestResult<List<Long>> getCompletedSectionIds(long applicationId, long organisationId); @Override RestResult<Boolean> allSectionsMarkedAsComplete(long applicationId); } | @Test public void markAsInComplete() { long sectionId = 123L; long applicationId = 234L; long markedAsCompleteById = 345L; String expectedUrl = sectionRestUrl + "/mark-as-in-complete/" + sectionId + "/" + applicationId + "/" + markedAsCompleteById; setupPostWithRestResultExpectations(expectedUrl, HttpStatus.OK); RestResult<Void> result = service.markAsInComplete(sectionId, applicationId, markedAsCompleteById); assertTrue(result.isSuccess()); } |
SectionStatusRestServiceImpl extends BaseRestService implements SectionStatusRestService { @Override public RestResult<Map<Long, Set<Long>>> getCompletedSectionsByOrganisation(long applicationId) { return getWithRestResult(sectionRestURL + "/get-completed-sections-by-organisation/" + applicationId, mapOfLongToLongsSetType()); } @Override RestResult<ValidationMessages> markAsComplete(long sectionId, long applicationId, long markedAsCompleteById); @Override RestResult<Void> markAsNotRequired(long sectionId, long applicationId, long markedAsCompleteById); @Override RestResult<Void> markAsInComplete(long sectionId, long applicationId, long markedAsInCompleteById); @Override RestResult<Map<Long, Set<Long>>> getCompletedSectionsByOrganisation(long applicationId); @Override RestResult<List<Long>> getCompletedSectionIds(long applicationId, long organisationId); @Override RestResult<Boolean> allSectionsMarkedAsComplete(long applicationId); } | @Test public void getCompletedSectionsByOrganisation() { long applicationId = 123L; String expectedUrl = sectionRestUrl + "/get-completed-sections-by-organisation/" + applicationId; Map<Long, Set<Long>> expectedResult = new HashMap<>(); setupGetWithRestResultExpectations(expectedUrl, mapOfLongToLongsSetType(), expectedResult); RestResult<Map<Long, Set<Long>>> result = service.getCompletedSectionsByOrganisation(applicationId); assertEquals(expectedResult, result.getSuccess()); } |
SectionStatusRestServiceImpl extends BaseRestService implements SectionStatusRestService { @Override public RestResult<List<Long>> getCompletedSectionIds(long applicationId, long organisationId) { return getWithRestResult(sectionRestURL + "/get-completed-sections/" + applicationId + "/" + organisationId, longsListType()); } @Override RestResult<ValidationMessages> markAsComplete(long sectionId, long applicationId, long markedAsCompleteById); @Override RestResult<Void> markAsNotRequired(long sectionId, long applicationId, long markedAsCompleteById); @Override RestResult<Void> markAsInComplete(long sectionId, long applicationId, long markedAsInCompleteById); @Override RestResult<Map<Long, Set<Long>>> getCompletedSectionsByOrganisation(long applicationId); @Override RestResult<List<Long>> getCompletedSectionIds(long applicationId, long organisationId); @Override RestResult<Boolean> allSectionsMarkedAsComplete(long applicationId); } | @Test public void getCompletedSectionIds() { String expectedUrl = sectionRestUrl + "/get-completed-sections/123/456"; List<Long> returnedResponse = asList(1L, 2L, 3L); setupGetWithRestResultExpectations(expectedUrl, longsListType(), returnedResponse); List<Long> response = service.getCompletedSectionIds(123L, 456L).getSuccess(); assertEquals(returnedResponse, response); } |
ApplicationNotificationTemplateRestServiceImpl extends BaseRestService implements ApplicationNotificationTemplateRestService { @Override public RestResult<ApplicationNotificationTemplateResource> getSuccessfulNotificationTemplate(long competitionId) { return getWithRestResult(String.format("%s/%s/%s", baseUrl, "successful", competitionId), ApplicationNotificationTemplateResource.class); } @Override RestResult<ApplicationNotificationTemplateResource> getSuccessfulNotificationTemplate(long competitionId); @Override RestResult<ApplicationNotificationTemplateResource> getUnsuccessfulNotificationTemplate(long competitionId); @Override RestResult<ApplicationNotificationTemplateResource> getIneligibleNotificationTemplate(long competitionId); } | @Test public void getSuccessfulNotificationTemplate() { Long competitionId = 123L; String expectedUrl = baseUrl + "/successful/" + competitionId; ApplicationNotificationTemplateResource applicationNotificationTemplateResource = new ApplicationNotificationTemplateResource(); setupGetWithRestResultExpectations(expectedUrl, ApplicationNotificationTemplateResource.class, applicationNotificationTemplateResource); RestResult<ApplicationNotificationTemplateResource> result = service.getSuccessfulNotificationTemplate(competitionId); assertEquals(HttpStatus.OK, result.getStatusCode()); assertEquals(applicationNotificationTemplateResource, result.getSuccess()); } |
ApplicationNotificationTemplateRestServiceImpl extends BaseRestService implements ApplicationNotificationTemplateRestService { @Override public RestResult<ApplicationNotificationTemplateResource> getUnsuccessfulNotificationTemplate(long competitionId) { return getWithRestResult(String.format("%s/%s/%s", baseUrl, "unsuccessful", competitionId), ApplicationNotificationTemplateResource.class); } @Override RestResult<ApplicationNotificationTemplateResource> getSuccessfulNotificationTemplate(long competitionId); @Override RestResult<ApplicationNotificationTemplateResource> getUnsuccessfulNotificationTemplate(long competitionId); @Override RestResult<ApplicationNotificationTemplateResource> getIneligibleNotificationTemplate(long competitionId); } | @Test public void getUnsuccessfulNotificationTemplate() { Long competitionId = 123L; String expectedUrl = baseUrl + "/unsuccessful/" + competitionId; ApplicationNotificationTemplateResource applicationNotificationTemplateResource = new ApplicationNotificationTemplateResource(); setupGetWithRestResultExpectations(expectedUrl, ApplicationNotificationTemplateResource.class, applicationNotificationTemplateResource); RestResult<ApplicationNotificationTemplateResource> result = service.getUnsuccessfulNotificationTemplate(competitionId); assertEquals(HttpStatus.OK, result.getStatusCode()); assertEquals(applicationNotificationTemplateResource, result.getSuccess()); } |
ApplicationNotificationTemplateRestServiceImpl extends BaseRestService implements ApplicationNotificationTemplateRestService { @Override public RestResult<ApplicationNotificationTemplateResource> getIneligibleNotificationTemplate(long competitionId) { return getWithRestResult(String.format("%s/%s/%s", baseUrl, "ineligible", competitionId), ApplicationNotificationTemplateResource.class); } @Override RestResult<ApplicationNotificationTemplateResource> getSuccessfulNotificationTemplate(long competitionId); @Override RestResult<ApplicationNotificationTemplateResource> getUnsuccessfulNotificationTemplate(long competitionId); @Override RestResult<ApplicationNotificationTemplateResource> getIneligibleNotificationTemplate(long competitionId); } | @Test public void getIneligibleNotificationTemplate() { long competitionId = 1L; String expectedUrl = baseUrl + "/ineligible/" + competitionId; ApplicationNotificationTemplateResource applicationNotificationTemplateResource = new ApplicationNotificationTemplateResource(); setupGetWithRestResultExpectations(expectedUrl, ApplicationNotificationTemplateResource.class, applicationNotificationTemplateResource); RestResult<ApplicationNotificationTemplateResource> result = service.getIneligibleNotificationTemplate(competitionId); assertEquals(HttpStatus.OK, result.getStatusCode()); assertEquals(applicationNotificationTemplateResource, result.getSuccess()); } |
RegistrationNotificationService { ServiceResult<Void> sendUserVerificationEmail(final UserResource user, final Optional<Long> competitionId, final Optional<Long> organisationId) { final Token token = createEmailVerificationToken(user, competitionId, organisationId); final Notification notification = getEmailVerificationNotification(user, token); return notificationService.sendNotificationWithFlush(notification, EMAIL); } } | @Test public void testSendUserVerificationEmailNoCompetitionId() { final UserResource userResource = newUserResource() .withId(1L) .withFirstName("Sample") .withLastName("User") .withEmail("[email protected]") .build(); final String hash = "1e627a59879066b44781ca584a23be742d3197dff291245150e62f3d4d3d303e1a87d34fc8a3a2e0"; ReflectionTestUtils.setField(service, "passwordEncoder", passwordEncoder); when(passwordEncoder.encode("[email protected]==700")).thenReturn(hash); final Token newToken = new Token(TokenType.VERIFY_EMAIL_ADDRESS, User.class.getName(), userResource.getId(), hash, now(), JsonNodeFactory.instance.objectNode()); final String verificationLink = String.format("%s/registration/verify-email/%s", webBaseUrl, hash); final Map<String, Object> expectedNotificationArguments = asMap("verificationLink", verificationLink); final NotificationSource from = systemNotificationSourceMock; final NotificationTarget to = new UserNotificationTarget(userResource.getName(), userResource.getEmail()); final Notification notification = new Notification(from, singletonList(to), RegistrationNotificationService.Notifications.VERIFY_EMAIL_ADDRESS, expectedNotificationArguments); when(tokenRepositoryMock.findByTypeAndClassNameAndClassPk(TokenType.VERIFY_EMAIL_ADDRESS, User.class.getName(), 1L)).thenReturn(empty()); when(tokenRepositoryMock.save(isA(Token.class))).thenReturn(newToken); when(notificationServiceMock.sendNotificationWithFlush(notification, EMAIL)).thenReturn(serviceSuccess()); final ServiceResult<Void> result = service.sendUserVerificationEmail(userResource, empty(), empty()); assertTrue(result.isSuccess()); verify(tokenRepositoryMock).save(isA(Token.class)); verify(notificationServiceMock).sendNotificationWithFlush(notification, EMAIL); }
@Test public void testSendUserVerificationEmailWithCompetitionId() { final UserResource userResource = newUserResource() .withId(1L) .withFirstName("Sample") .withLastName("User") .withEmail("[email protected]") .build(); final String hash = "1e627a59879066b44781ca584a23be742d3197dff291245150e62f3d4d3d303e1a87d34fc8a3a2e0"; ReflectionTestUtils.setField(service, "passwordEncoder", passwordEncoder); when(passwordEncoder.encode("[email protected]==700")).thenReturn(hash); final Token newToken = new Token(TokenType.VERIFY_EMAIL_ADDRESS, User.class.getName(), userResource.getId(), hash, now(), JsonNodeFactory.instance.objectNode()); final String verificationLink = String.format("%s/registration/verify-email/%s", webBaseUrl, hash); final Map<String, Object> expectedNotificationArguments = asMap("verificationLink", verificationLink); final NotificationSource from = systemNotificationSourceMock; final NotificationTarget to = new UserNotificationTarget(userResource.getName(), userResource.getEmail()); final Notification notification = new Notification(from, singletonList(to), RegistrationNotificationService.Notifications.VERIFY_EMAIL_ADDRESS, expectedNotificationArguments); when(tokenRepositoryMock.findByTypeAndClassNameAndClassPk(TokenType.VERIFY_EMAIL_ADDRESS, User.class.getName(), 1L)).thenReturn(empty()); when(tokenRepositoryMock.save(isA(Token.class))).thenReturn(newToken); when(notificationServiceMock.sendNotificationWithFlush(notification, EMAIL)).thenReturn(serviceSuccess()); final ServiceResult<Void> result = service.sendUserVerificationEmail(userResource, of(456L), of(123L)); assertTrue(result.isSuccess()); verify(tokenRepositoryMock).save(isA(Token.class)); verify(notificationServiceMock).sendNotificationWithFlush(notification, EMAIL); } |
SectionRestServiceImpl extends BaseRestService implements SectionRestService { @Override public RestResult<SectionResource> getById(Long sectionId) { return getWithRestResult(sectionRestURL + "/" + sectionId, SectionResource.class); } @Override RestResult<SectionResource> getById(Long sectionId); @Override RestResult<List<SectionResource>> getChildSectionsByParentId(long parentId); @Override RestResult<List<SectionResource>> getByCompetition(final Long competitionId); @Override RestResult<SectionResource> getSectionByQuestionId(Long questionId); @Override RestResult<Set<Long>> getQuestionsForSectionAndSubsections(Long sectionId); @Override RestResult<List<SectionResource>> getSectionsByCompetitionIdAndType(Long competitionId, SectionType type); @Override RestResult<List<SectionResource>> getByCompetitionIdVisibleForAssessment(Long competitionId); } | @Test public void getById() { long sectionId = 123L; String expectedUrl = sectionRestUrl + "/" + sectionId; SectionResource sectionResource = newSectionResource().build(); setupGetWithRestResultExpectations(expectedUrl, SectionResource.class, sectionResource); RestResult<SectionResource> result = service.getById(sectionId); assertEquals(sectionResource, result.getSuccess()); } |
SectionRestServiceImpl extends BaseRestService implements SectionRestService { @Override public RestResult<List<SectionResource>> getByCompetition(final Long competitionId) { return getWithRestResult(sectionRestURL + "/get-by-competition/" + competitionId, sectionResourceListType()); } @Override RestResult<SectionResource> getById(Long sectionId); @Override RestResult<List<SectionResource>> getChildSectionsByParentId(long parentId); @Override RestResult<List<SectionResource>> getByCompetition(final Long competitionId); @Override RestResult<SectionResource> getSectionByQuestionId(Long questionId); @Override RestResult<Set<Long>> getQuestionsForSectionAndSubsections(Long sectionId); @Override RestResult<List<SectionResource>> getSectionsByCompetitionIdAndType(Long competitionId, SectionType type); @Override RestResult<List<SectionResource>> getByCompetitionIdVisibleForAssessment(Long competitionId); } | @Test public void getByCompetition() { long competitionId = 123L; String expectedUrl = sectionRestUrl + "/get-by-competition/" + competitionId; List<SectionResource> sectionResources = newSectionResource().build(2); setupGetWithRestResultExpectations(expectedUrl, sectionResourceListType(), sectionResources); RestResult<List<SectionResource>> result = service.getByCompetition(competitionId); assertEquals(sectionResources, result.getSuccess()); } |
SectionRestServiceImpl extends BaseRestService implements SectionRestService { @Override public RestResult<SectionResource> getSectionByQuestionId(Long questionId) { return getWithRestResult(sectionRestURL + "/get-section-by-question-id/" + questionId, SectionResource.class); } @Override RestResult<SectionResource> getById(Long sectionId); @Override RestResult<List<SectionResource>> getChildSectionsByParentId(long parentId); @Override RestResult<List<SectionResource>> getByCompetition(final Long competitionId); @Override RestResult<SectionResource> getSectionByQuestionId(Long questionId); @Override RestResult<Set<Long>> getQuestionsForSectionAndSubsections(Long sectionId); @Override RestResult<List<SectionResource>> getSectionsByCompetitionIdAndType(Long competitionId, SectionType type); @Override RestResult<List<SectionResource>> getByCompetitionIdVisibleForAssessment(Long competitionId); } | @Test public void getSectionByQuestionId() { long questionId = 1L; String expectedUrl = sectionRestUrl + "/get-section-by-question-id/" + questionId; SectionResource sectionResource = newSectionResource().build(); setupGetWithRestResultExpectations(expectedUrl, SectionResource.class, sectionResource); RestResult<SectionResource> result = service.getSectionByQuestionId(questionId); assertEquals(sectionResource, result.getSuccess()); } |
SectionRestServiceImpl extends BaseRestService implements SectionRestService { @Override public RestResult<Set<Long>> getQuestionsForSectionAndSubsections(Long sectionId) { return getWithRestResult(sectionRestURL + "/get-questions-for-section-and-subsections/" + sectionId, longsSetType()); } @Override RestResult<SectionResource> getById(Long sectionId); @Override RestResult<List<SectionResource>> getChildSectionsByParentId(long parentId); @Override RestResult<List<SectionResource>> getByCompetition(final Long competitionId); @Override RestResult<SectionResource> getSectionByQuestionId(Long questionId); @Override RestResult<Set<Long>> getQuestionsForSectionAndSubsections(Long sectionId); @Override RestResult<List<SectionResource>> getSectionsByCompetitionIdAndType(Long competitionId, SectionType type); @Override RestResult<List<SectionResource>> getByCompetitionIdVisibleForAssessment(Long competitionId); } | @Test public void getQuestionForSectionAndSubsections() { long sectionId = 1L; String expectedUrl = sectionRestUrl + "/get-questions-for-section-and-subsections/" + sectionId; Set<Long> questions = new HashSet<>(); setupGetWithRestResultExpectations(expectedUrl, longsSetType(), questions); RestResult<Set<Long>> result = service.getQuestionsForSectionAndSubsections(sectionId); assertEquals(questions, result.getSuccess()); } |
SectionRestServiceImpl extends BaseRestService implements SectionRestService { @Override public RestResult<List<SectionResource>> getSectionsByCompetitionIdAndType(Long competitionId, SectionType type) { return getWithRestResult(sectionRestURL + "/get-sections-by-competition-id-and-type/" + competitionId + "/" + type.name(), sectionResourceListType()); } @Override RestResult<SectionResource> getById(Long sectionId); @Override RestResult<List<SectionResource>> getChildSectionsByParentId(long parentId); @Override RestResult<List<SectionResource>> getByCompetition(final Long competitionId); @Override RestResult<SectionResource> getSectionByQuestionId(Long questionId); @Override RestResult<Set<Long>> getQuestionsForSectionAndSubsections(Long sectionId); @Override RestResult<List<SectionResource>> getSectionsByCompetitionIdAndType(Long competitionId, SectionType type); @Override RestResult<List<SectionResource>> getByCompetitionIdVisibleForAssessment(Long competitionId); } | @Test public void getSectionsForCompetitionByType() { String expectedUrl = sectionRestUrl + "/get-sections-by-competition-id-and-type/123/FINANCE"; List<SectionResource> returnedResponse = singletonList(new SectionResource()); setupGetWithRestResultExpectations(expectedUrl, sectionResourceListType(), returnedResponse); List<SectionResource> response = service.getSectionsByCompetitionIdAndType(123L, SectionType.FINANCE).getSuccess(); assertEquals(returnedResponse, response); } |
SectionRestServiceImpl extends BaseRestService implements SectionRestService { @Override public RestResult<List<SectionResource>> getByCompetitionIdVisibleForAssessment(Long competitionId) { return getWithRestResult(sectionRestURL + "/get-by-competition-id-visible-for-assessment/" + competitionId, sectionResourceListType()); } @Override RestResult<SectionResource> getById(Long sectionId); @Override RestResult<List<SectionResource>> getChildSectionsByParentId(long parentId); @Override RestResult<List<SectionResource>> getByCompetition(final Long competitionId); @Override RestResult<SectionResource> getSectionByQuestionId(Long questionId); @Override RestResult<Set<Long>> getQuestionsForSectionAndSubsections(Long sectionId); @Override RestResult<List<SectionResource>> getSectionsByCompetitionIdAndType(Long competitionId, SectionType type); @Override RestResult<List<SectionResource>> getByCompetitionIdVisibleForAssessment(Long competitionId); } | @Test public void getByCompetitionIdVisibleForAssessment() throws Exception { List<SectionResource> expected = newSectionResource().build(2); long competitionId = 1L; setupGetWithRestResultExpectations(format("%s/get-by-competition-id-visible-for-assessment/%s", sectionRestUrl, competitionId), sectionResourceListType(), expected); assertSame(expected, service.getByCompetitionIdVisibleForAssessment(competitionId).getSuccess()); } |
SectionRestServiceImpl extends BaseRestService implements SectionRestService { @Override public RestResult<List<SectionResource>> getChildSectionsByParentId(long parentId) { return getWithRestResult(sectionRestURL + "/get-child-sections/" + parentId, sectionResourceListType()); } @Override RestResult<SectionResource> getById(Long sectionId); @Override RestResult<List<SectionResource>> getChildSectionsByParentId(long parentId); @Override RestResult<List<SectionResource>> getByCompetition(final Long competitionId); @Override RestResult<SectionResource> getSectionByQuestionId(Long questionId); @Override RestResult<Set<Long>> getQuestionsForSectionAndSubsections(Long sectionId); @Override RestResult<List<SectionResource>> getSectionsByCompetitionIdAndType(Long competitionId, SectionType type); @Override RestResult<List<SectionResource>> getByCompetitionIdVisibleForAssessment(Long competitionId); } | @Test public void getChildSectionsByParentId() { long parentId = 12L; String expectedUrl = sectionRestUrl + "/get-child-sections/" + parentId; SectionResource parentSectionResource = newSectionResource().withId(parentId).build(); List<SectionResource> childSectionResources = newSectionResource().withParentSection(parentSectionResource.getId()).build(4); setupGetWithRestResultExpectations(expectedUrl, sectionResourceListType(), childSectionResources); RestResult<List<SectionResource>> result = service.getChildSectionsByParentId(parentId); assertEquals(childSectionResources, result.getSuccess()); } |
ApplicationAssessmentSummaryRestServiceImpl extends BaseRestService implements ApplicationAssessmentSummaryRestService { @Override public RestResult<ApplicationAvailableAssessorPageResource> getAvailableAssessors(long applicationId, Integer pageIndex, Integer pageSize, String assessorNameFilter, Sort sort) { String uriWithParams = buildUri(applicationAssessmentSummaryRestURL + "/{applicationId}/available-assessors",pageIndex, pageSize, assessorNameFilter, sort, applicationId); return getWithRestResult(uriWithParams, ApplicationAvailableAssessorPageResource.class); } @Override RestResult<List<ApplicationAssessorResource>> getAssignedAssessors(long applicationId); @Override RestResult<ApplicationAvailableAssessorPageResource> getAvailableAssessors(long applicationId, Integer pageIndex, Integer pageSize, String assessorNameFilter, Sort sort); @Override RestResult<List<Long>> getAvailableAssessorsIds(long applicationId, String assessorName); @Override RestResult<ApplicationAssessmentSummaryResource> getApplicationAssessmentSummary(long applicationId); } | @Test public void getAvailableAssessors() { ApplicationAvailableAssessorPageResource expected = new ApplicationAvailableAssessorPageResource(); Long applicationId = 1L; int page = 2; int size = 3; String assessorNameFilter = "Name"; Sort sort = Sort.ASSESSOR; setupGetWithRestResultExpectations(format("%s/%s/available-assessors?page=%s&size=%s&assessorNameFilter=%s&sort=%s", applicationAssessmentSummaryRestUrl, applicationId, page, size, assessorNameFilter, sort), ApplicationAvailableAssessorPageResource.class, expected); assertSame(expected, service.getAvailableAssessors(applicationId, page, size, assessorNameFilter, sort).getSuccess()); } |
ApplicationAssessmentSummaryRestServiceImpl extends BaseRestService implements ApplicationAssessmentSummaryRestService { @Override public RestResult<List<ApplicationAssessorResource>> getAssignedAssessors(long applicationId) { return getWithRestResult(format("%s/%s/assigned-assessors", applicationAssessmentSummaryRestURL, applicationId), ParameterizedTypeReferences.applicationAssessorResourceListType()); } @Override RestResult<List<ApplicationAssessorResource>> getAssignedAssessors(long applicationId); @Override RestResult<ApplicationAvailableAssessorPageResource> getAvailableAssessors(long applicationId, Integer pageIndex, Integer pageSize, String assessorNameFilter, Sort sort); @Override RestResult<List<Long>> getAvailableAssessorsIds(long applicationId, String assessorName); @Override RestResult<ApplicationAssessmentSummaryResource> getApplicationAssessmentSummary(long applicationId); } | @Test public void getAssignedAssessors() { List<ApplicationAssessorResource> expected = newApplicationAssessorResource().build(2); Long applicationId = 1L; setupGetWithRestResultExpectations( format("%s/%s/assigned-assessors", applicationAssessmentSummaryRestUrl, applicationId), ParameterizedTypeReferences.applicationAssessorResourceListType(), expected); assertSame(expected, service.getAssignedAssessors(applicationId).getSuccess()); } |
ApplicationAssessmentSummaryRestServiceImpl extends BaseRestService implements ApplicationAssessmentSummaryRestService { @Override public RestResult<ApplicationAssessmentSummaryResource> getApplicationAssessmentSummary(long applicationId) { return getWithRestResult(format("%s/%s", applicationAssessmentSummaryRestURL, applicationId), ApplicationAssessmentSummaryResource.class); } @Override RestResult<List<ApplicationAssessorResource>> getAssignedAssessors(long applicationId); @Override RestResult<ApplicationAvailableAssessorPageResource> getAvailableAssessors(long applicationId, Integer pageIndex, Integer pageSize, String assessorNameFilter, Sort sort); @Override RestResult<List<Long>> getAvailableAssessorsIds(long applicationId, String assessorName); @Override RestResult<ApplicationAssessmentSummaryResource> getApplicationAssessmentSummary(long applicationId); } | @Test public void getApplicationAssessmentSummary() { ApplicationAssessmentSummaryResource expected = newApplicationAssessmentSummaryResource().build(); Long applicationId = 1L; setupGetWithRestResultExpectations( format("%s/%s", applicationAssessmentSummaryRestUrl, applicationId), ApplicationAssessmentSummaryResource.class, expected); assertSame(expected, service.getApplicationAssessmentSummary(applicationId).getSuccess()); } |
ApplicationAssessmentSummaryRestServiceImpl extends BaseRestService implements ApplicationAssessmentSummaryRestService { @Override public RestResult<List<Long>> getAvailableAssessorsIds(long applicationId, String assessorName) { String uriWithParams = buildUri(applicationAssessmentSummaryRestURL + "/{applicationId}/available-assessors-ids", null, null, assessorName, null, applicationId); return getWithRestResult(uriWithParams, longsListType()); } @Override RestResult<List<ApplicationAssessorResource>> getAssignedAssessors(long applicationId); @Override RestResult<ApplicationAvailableAssessorPageResource> getAvailableAssessors(long applicationId, Integer pageIndex, Integer pageSize, String assessorNameFilter, Sort sort); @Override RestResult<List<Long>> getAvailableAssessorsIds(long applicationId, String assessorName); @Override RestResult<ApplicationAssessmentSummaryResource> getApplicationAssessmentSummary(long applicationId); } | @Test public void getAvailableAssessorIds() { List<Long> expected = asList(1L, 2L); long applicationId = 1L; String assessorNameFilter = "Name"; setupGetWithRestResultExpectations(format("%s/%s/available-assessors-ids?assessorNameFilter=%s", applicationAssessmentSummaryRestUrl, applicationId, assessorNameFilter), longsListType(), expected); assertSame(expected, service.getAvailableAssessorsIds(applicationId, assessorNameFilter).getSuccess()); } |
AssessorCompetitionSummaryRestServiceImpl extends BaseRestService implements AssessorCompetitionSummaryRestService { @Override public RestResult<AssessorCompetitionSummaryResource> getAssessorSummary(long assessorId, long competitionId) { return getWithRestResult(format(baseUrl + "/summary", assessorId, competitionId), AssessorCompetitionSummaryResource.class); } @Override RestResult<AssessorCompetitionSummaryResource> getAssessorSummary(long assessorId, long competitionId); } | @Test public void getAssessorSummary() throws Exception { long assessorId = 1L; long competitionId = 2L; AssessorCompetitionSummaryResource expected = newAssessorCompetitionSummaryResource() .withCompetitionId(competitionId) .withCompetitionName("Test Competition") .build(); setupGetWithRestResultExpectations(format("/assessor/%s/competition/%s/summary", assessorId, competitionId), AssessorCompetitionSummaryResource.class, expected); AssessorCompetitionSummaryResource actual = service.getAssessorSummary(assessorId, competitionId).getSuccess(); assertEquals(expected, actual); } |
AssessorFormInputResponseRestServiceImpl extends BaseRestService implements AssessorFormInputResponseRestService { @Override public RestResult<List<AssessorFormInputResponseResource>> getAllAssessorFormInputResponses(long assessmentId) { return getWithRestResult(format("%s/assessment/%s", assessorFormInputResponseRestUrl, assessmentId), assessorFormInputResponseResourceListType()); } @Override RestResult<List<AssessorFormInputResponseResource>> getAllAssessorFormInputResponses(long assessmentId); @Override RestResult<List<AssessorFormInputResponseResource>> getAllAssessorFormInputResponsesByAssessmentAndQuestion(long assessmentId, long questionId); @Override RestResult<Void> updateFormInputResponse(long assessmentId, long formInputId, String value); @Override RestResult<Void> updateFormInputResponses(AssessorFormInputResponsesResource assessorFormInputResponseResources); @Override RestResult<ApplicationAssessmentsResource> getApplicationAssessments(long applicationId); @Override RestResult<ApplicationAssessmentResource> getApplicationAssessment(long applicationId, long assessment); @Override RestResult<ApplicationAssessmentAggregateResource> getApplicationAssessmentAggregate(long applicationId); @Override RestResult<AssessmentFeedbackAggregateResource> getAssessmentAggregateFeedback(long applicationId, long questionId); @Override RestResult<AssessmentDetailsResource> getAssessmentDetails(long assessmentId); } | @Test public void getAllAssessorFormInputResponses() { List<AssessorFormInputResponseResource> expected = Stream.of(1, 2, 3).map(i -> new AssessorFormInputResponseResource()).collect(Collectors.toList()); long assessmentId = 1L; setupGetWithRestResultExpectations(format("%s/assessment/%s", assessorFormInputResponseRestUrl, assessmentId), assessorFormInputResponseResourceListType(), expected, OK); List<AssessorFormInputResponseResource> response = service.getAllAssessorFormInputResponses(assessmentId).getSuccess(); assertSame(expected, response); } |
AssessorFormInputResponseRestServiceImpl extends BaseRestService implements AssessorFormInputResponseRestService { @Override public RestResult<List<AssessorFormInputResponseResource>> getAllAssessorFormInputResponsesByAssessmentAndQuestion(long assessmentId, long questionId) { return getWithRestResult(format("%s/assessment/%s/question/%s", assessorFormInputResponseRestUrl, assessmentId, questionId), assessorFormInputResponseResourceListType()); } @Override RestResult<List<AssessorFormInputResponseResource>> getAllAssessorFormInputResponses(long assessmentId); @Override RestResult<List<AssessorFormInputResponseResource>> getAllAssessorFormInputResponsesByAssessmentAndQuestion(long assessmentId, long questionId); @Override RestResult<Void> updateFormInputResponse(long assessmentId, long formInputId, String value); @Override RestResult<Void> updateFormInputResponses(AssessorFormInputResponsesResource assessorFormInputResponseResources); @Override RestResult<ApplicationAssessmentsResource> getApplicationAssessments(long applicationId); @Override RestResult<ApplicationAssessmentResource> getApplicationAssessment(long applicationId, long assessment); @Override RestResult<ApplicationAssessmentAggregateResource> getApplicationAssessmentAggregate(long applicationId); @Override RestResult<AssessmentFeedbackAggregateResource> getAssessmentAggregateFeedback(long applicationId, long questionId); @Override RestResult<AssessmentDetailsResource> getAssessmentDetails(long assessmentId); } | @Test public void getAllAssessorFormInputResponsesByAssessmentAndQuestion() { List<AssessorFormInputResponseResource> expected = Stream.of(1, 2, 3).map(i -> new AssessorFormInputResponseResource()).collect(Collectors.toList()); long assessmentId = 1L; long questionId = 2L; setupGetWithRestResultExpectations(format("%s/assessment/%s/question/%s", assessorFormInputResponseRestUrl, assessmentId, questionId), assessorFormInputResponseResourceListType(), expected, OK); List<AssessorFormInputResponseResource> response = service.getAllAssessorFormInputResponsesByAssessmentAndQuestion(assessmentId, questionId).getSuccess(); assertSame(expected, response); } |
AssessorFormInputResponseRestServiceImpl extends BaseRestService implements AssessorFormInputResponseRestService { @Override public RestResult<Void> updateFormInputResponse(long assessmentId, long formInputId, String value) { return updateFormInputResponses(new AssessorFormInputResponsesResource( new AssessorFormInputResponseResource(assessmentId, formInputId, value))); } @Override RestResult<List<AssessorFormInputResponseResource>> getAllAssessorFormInputResponses(long assessmentId); @Override RestResult<List<AssessorFormInputResponseResource>> getAllAssessorFormInputResponsesByAssessmentAndQuestion(long assessmentId, long questionId); @Override RestResult<Void> updateFormInputResponse(long assessmentId, long formInputId, String value); @Override RestResult<Void> updateFormInputResponses(AssessorFormInputResponsesResource assessorFormInputResponseResources); @Override RestResult<ApplicationAssessmentsResource> getApplicationAssessments(long applicationId); @Override RestResult<ApplicationAssessmentResource> getApplicationAssessment(long applicationId, long assessment); @Override RestResult<ApplicationAssessmentAggregateResource> getApplicationAssessmentAggregate(long applicationId); @Override RestResult<AssessmentFeedbackAggregateResource> getAssessmentAggregateFeedback(long applicationId, long questionId); @Override RestResult<AssessmentDetailsResource> getAssessmentDetails(long assessmentId); } | @Test public void updateFormInputResponse() { long assessmentId = 1L; long formInputId = 2L; String value = "Response"; AssessorFormInputResponsesResource responses = new AssessorFormInputResponsesResource( newAssessorFormInputResponseResource() .with(id(null)) .withAssessment(assessmentId) .withFormInput(formInputId) .withValue(value) .build()); setupPutWithRestResultExpectations(format("%s", assessorFormInputResponseRestUrl), responses, OK); RestResult<Void> response = service.updateFormInputResponse(assessmentId, formInputId, value); assertTrue(response.isSuccess()); } |
AssessorFormInputResponseRestServiceImpl extends BaseRestService implements AssessorFormInputResponseRestService { @Override public RestResult<Void> updateFormInputResponses(AssessorFormInputResponsesResource assessorFormInputResponseResources) { return putWithRestResult(format("%s", assessorFormInputResponseRestUrl), assessorFormInputResponseResources, Void.class); } @Override RestResult<List<AssessorFormInputResponseResource>> getAllAssessorFormInputResponses(long assessmentId); @Override RestResult<List<AssessorFormInputResponseResource>> getAllAssessorFormInputResponsesByAssessmentAndQuestion(long assessmentId, long questionId); @Override RestResult<Void> updateFormInputResponse(long assessmentId, long formInputId, String value); @Override RestResult<Void> updateFormInputResponses(AssessorFormInputResponsesResource assessorFormInputResponseResources); @Override RestResult<ApplicationAssessmentsResource> getApplicationAssessments(long applicationId); @Override RestResult<ApplicationAssessmentResource> getApplicationAssessment(long applicationId, long assessment); @Override RestResult<ApplicationAssessmentAggregateResource> getApplicationAssessmentAggregate(long applicationId); @Override RestResult<AssessmentFeedbackAggregateResource> getAssessmentAggregateFeedback(long applicationId, long questionId); @Override RestResult<AssessmentDetailsResource> getAssessmentDetails(long assessmentId); } | @Test public void updateFormInputResponses() { AssessorFormInputResponsesResource responses = new AssessorFormInputResponsesResource( newAssessorFormInputResponseResource() .with(id(null)) .withAssessment(1L) .withFormInput(2L, 3L) .withValue("Response 1", "Response 2") .build(2)); setupPutWithRestResultExpectations(format("%s", assessorFormInputResponseRestUrl), responses, OK); RestResult<Void> response = service.updateFormInputResponses(responses); assertTrue(response.isSuccess()); } |
AssessorFormInputResponseRestServiceImpl extends BaseRestService implements AssessorFormInputResponseRestService { @Override public RestResult<ApplicationAssessmentAggregateResource> getApplicationAssessmentAggregate(long applicationId) { return getWithRestResult(format("%s/application/%s/scores", assessorFormInputResponseRestUrl, applicationId), ApplicationAssessmentAggregateResource.class); } @Override RestResult<List<AssessorFormInputResponseResource>> getAllAssessorFormInputResponses(long assessmentId); @Override RestResult<List<AssessorFormInputResponseResource>> getAllAssessorFormInputResponsesByAssessmentAndQuestion(long assessmentId, long questionId); @Override RestResult<Void> updateFormInputResponse(long assessmentId, long formInputId, String value); @Override RestResult<Void> updateFormInputResponses(AssessorFormInputResponsesResource assessorFormInputResponseResources); @Override RestResult<ApplicationAssessmentsResource> getApplicationAssessments(long applicationId); @Override RestResult<ApplicationAssessmentResource> getApplicationAssessment(long applicationId, long assessment); @Override RestResult<ApplicationAssessmentAggregateResource> getApplicationAssessmentAggregate(long applicationId); @Override RestResult<AssessmentFeedbackAggregateResource> getAssessmentAggregateFeedback(long applicationId, long questionId); @Override RestResult<AssessmentDetailsResource> getAssessmentDetails(long assessmentId); } | @Test public void getApplicationAssessmentAggregate() { long applicationId = 7; Map<Long, BigDecimal> expectedScores = new HashMap<>(); expectedScores.put(17L, new BigDecimal(20)); ApplicationAssessmentAggregateResource expected = new ApplicationAssessmentAggregateResource(true, 13, 11, expectedScores, BigDecimal.valueOf(17)); setupGetWithRestResultExpectations(format("%s/application/%s/scores", assessorFormInputResponseRestUrl, applicationId), ApplicationAssessmentAggregateResource.class, expected, OK); ApplicationAssessmentAggregateResource response = service.getApplicationAssessmentAggregate(applicationId).getSuccess(); assertSame(expected, response); } |
AssessorFormInputResponseRestServiceImpl extends BaseRestService implements AssessorFormInputResponseRestService { @Override public RestResult<AssessmentFeedbackAggregateResource> getAssessmentAggregateFeedback(long applicationId, long questionId) { return getWithRestResult(format("%s/application/%s/question/%s/feedback", assessorFormInputResponseRestUrl, applicationId, questionId), AssessmentFeedbackAggregateResource.class); } @Override RestResult<List<AssessorFormInputResponseResource>> getAllAssessorFormInputResponses(long assessmentId); @Override RestResult<List<AssessorFormInputResponseResource>> getAllAssessorFormInputResponsesByAssessmentAndQuestion(long assessmentId, long questionId); @Override RestResult<Void> updateFormInputResponse(long assessmentId, long formInputId, String value); @Override RestResult<Void> updateFormInputResponses(AssessorFormInputResponsesResource assessorFormInputResponseResources); @Override RestResult<ApplicationAssessmentsResource> getApplicationAssessments(long applicationId); @Override RestResult<ApplicationAssessmentResource> getApplicationAssessment(long applicationId, long assessment); @Override RestResult<ApplicationAssessmentAggregateResource> getApplicationAssessmentAggregate(long applicationId); @Override RestResult<AssessmentFeedbackAggregateResource> getAssessmentAggregateFeedback(long applicationId, long questionId); @Override RestResult<AssessmentDetailsResource> getAssessmentDetails(long assessmentId); } | @Test public void getAssessmentAggregateFeedback() { long applicationId = 1L; long questionId = 2L; AssessmentFeedbackAggregateResource expected = newAssessmentFeedbackAggregateResource().build(); setupGetWithRestResultExpectations(format("%s/application/%s/question/%s/feedback", assessorFormInputResponseRestUrl, applicationId, questionId), AssessmentFeedbackAggregateResource.class, expected, OK); AssessmentFeedbackAggregateResource response = service.getAssessmentAggregateFeedback(applicationId, questionId).getSuccess(); assertSame(expected, response); } |
CompetitionInviteRestServiceImpl extends BaseRestService implements CompetitionInviteRestService { @Override public RestResult<AssessorInvitesToSendResource> getAllInvitesToSend(long competitionId) { return getWithRestResult(format("%s/%s/%s", COMPETITION_INVITE_REST_URL, "get-all-invites-to-send", competitionId), AssessorInvitesToSendResource.class); } @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToSend(long competitionId); @Override RestResult<AssessorInvitesToSendResource> getInviteToSend(long inviteId); @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToResend(long competitionId, List<Long> inviteIds); @Override RestResult<CompetitionInviteResource> getInvite(String inviteHash); @Override RestResult<CompetitionInviteResource> openInvite(String inviteHash); @Override RestResult<Void> acceptInvite(String inviteHash); @Override RestResult<Void> rejectInvite(String inviteHash, CompetitionRejectionResource rejectionReason); @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<AvailableAssessorPageResource> getAvailableAssessors(long competitionId, int page, String assessorNameFilter); @Override RestResult<List<Long>> getAvailableAssessorIds(long competitionId, String assessorNameFilter); @Override RestResult<List<Long>> getAssessorsNotAcceptedInviteIds(long competitionId,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<AssessorCreatedInvitePageResource> getCreatedInvites(long competitionId, int page); @Override RestResult<AssessorInviteOverviewPageResource> getInvitationOverview(long competitionId,
int page,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<CompetitionInviteStatisticsResource> getInviteStatistics(long competitionId); @Override RestResult<CompetitionInviteResource> inviteUser(ExistingUserStagedInviteResource existingUserStagedInvite); @Override RestResult<Void> inviteUsers(ExistingUserStagedInviteListResource existingUserStagedInvites); @Override RestResult<Void> inviteNewUsers(NewUserStagedInviteListResource newUserStagedInvites, long competitionId); @Override RestResult<Void> deleteInvite(String email, long competitionId); @Override RestResult<Void> deleteAllInvites(long competitionId); @Override RestResult<Void> sendAllInvites(long competitionId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvite(long inviteId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvites(List<Long> inviteIds, AssessorInviteSendResource assessorInviteSendResource); } | @Test public void getAllInvitesToSend() { long competitionId = 1L; AssessorInvitesToSendResource expected = newAssessorInvitesToSendResource() .withRecipients(asList("James", "John")) .build(); setupGetWithRestResultExpectations(format("%s/%s/%s", restUrl, "get-all-invites-to-send", competitionId), AssessorInvitesToSendResource.class, expected); AssessorInvitesToSendResource actual = service.getAllInvitesToSend(competitionId).getSuccess(); assertEquals(expected, actual); } |
CompetitionInviteRestServiceImpl extends BaseRestService implements CompetitionInviteRestService { @Override public RestResult<AssessorInvitesToSendResource> getAllInvitesToResend(long competitionId, List<Long> inviteIds) { String baseUrl = format("%s/%s/%s", COMPETITION_INVITE_REST_URL, "get-all-invites-to-resend", competitionId); UriComponentsBuilder builder = UriComponentsBuilder.fromPath(baseUrl) .queryParam("inviteIds", simpleJoiner(inviteIds, ",")); return getWithRestResult(builder.toUriString(), AssessorInvitesToSendResource.class); } @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToSend(long competitionId); @Override RestResult<AssessorInvitesToSendResource> getInviteToSend(long inviteId); @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToResend(long competitionId, List<Long> inviteIds); @Override RestResult<CompetitionInviteResource> getInvite(String inviteHash); @Override RestResult<CompetitionInviteResource> openInvite(String inviteHash); @Override RestResult<Void> acceptInvite(String inviteHash); @Override RestResult<Void> rejectInvite(String inviteHash, CompetitionRejectionResource rejectionReason); @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<AvailableAssessorPageResource> getAvailableAssessors(long competitionId, int page, String assessorNameFilter); @Override RestResult<List<Long>> getAvailableAssessorIds(long competitionId, String assessorNameFilter); @Override RestResult<List<Long>> getAssessorsNotAcceptedInviteIds(long competitionId,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<AssessorCreatedInvitePageResource> getCreatedInvites(long competitionId, int page); @Override RestResult<AssessorInviteOverviewPageResource> getInvitationOverview(long competitionId,
int page,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<CompetitionInviteStatisticsResource> getInviteStatistics(long competitionId); @Override RestResult<CompetitionInviteResource> inviteUser(ExistingUserStagedInviteResource existingUserStagedInvite); @Override RestResult<Void> inviteUsers(ExistingUserStagedInviteListResource existingUserStagedInvites); @Override RestResult<Void> inviteNewUsers(NewUserStagedInviteListResource newUserStagedInvites, long competitionId); @Override RestResult<Void> deleteInvite(String email, long competitionId); @Override RestResult<Void> deleteAllInvites(long competitionId); @Override RestResult<Void> sendAllInvites(long competitionId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvite(long inviteId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvites(List<Long> inviteIds, AssessorInviteSendResource assessorInviteSendResource); } | @Test public void getAllInvitesToResend() { long competitionId = 1L; List<Long> inviteIds = asList(1L, 2L); AssessorInvitesToSendResource expected = newAssessorInvitesToSendResource() .withRecipients(asList("James", "John")) .build(); setupGetWithRestResultExpectations(format("%s/%s/%s%s", restUrl, "get-all-invites-to-resend", competitionId, "?inviteIds=1,2"), AssessorInvitesToSendResource.class, expected); AssessorInvitesToSendResource actual = service.getAllInvitesToResend(competitionId, inviteIds).getSuccess(); assertEquals(expected, actual); } |
RegistrationNotificationService { ServiceResult<Void> resendUserVerificationEmail(final UserResource user) { final Token token = refreshEmailVerificationToken(user); final Notification notification = getEmailVerificationNotification(user, token); return notificationService.sendNotificationWithFlush(notification, EMAIL); } } | @Test public void testResendUserVerificationEmail() { final UserResource userResource = newUserResource() .withId(1L) .withFirstName("Sample") .withLastName("User") .withEmail("[email protected]") .build(); final String hash = "1e627a59879066b44781ca584a23be742d3197dff291245150e62f3d4d3d303e1a87d34fc8a3a2e0"; ReflectionTestUtils.setField(service, "passwordEncoder", passwordEncoder); when(passwordEncoder.encode("[email protected]==700")).thenReturn(hash); final Token existingToken = new Token(TokenType.VERIFY_EMAIL_ADDRESS, User.class.getName(), userResource.getId(), "existing-token", now(), JsonNodeFactory.instance.objectNode()); final Token newToken = new Token(TokenType.VERIFY_EMAIL_ADDRESS, User.class.getName(), userResource.getId(), hash, now(), JsonNodeFactory.instance.objectNode()); final String verificationLink = String.format("%s/registration/verify-email/%s", webBaseUrl, hash); final Map<String, Object> expectedNotificationArguments = asMap("verificationLink", verificationLink); final NotificationSource from = systemNotificationSourceMock; final NotificationTarget to = new UserNotificationTarget(userResource.getName(), userResource.getEmail()); final Notification notification = new Notification(from, singletonList(to), RegistrationNotificationService.Notifications.VERIFY_EMAIL_ADDRESS, expectedNotificationArguments); when(tokenRepositoryMock.findByTypeAndClassNameAndClassPk(TokenType.VERIFY_EMAIL_ADDRESS, User.class.getName(), 1L)).thenReturn(of(existingToken)); when(tokenRepositoryMock.save(isA(Token.class))).thenReturn(newToken); when(notificationServiceMock.sendNotificationWithFlush(notification, EMAIL)).thenReturn(serviceSuccess()); final ServiceResult<Void> result = service.resendUserVerificationEmail(userResource); assertTrue(result.isSuccess()); verify(tokenRepositoryMock).save(isA(Token.class)); verify(notificationServiceMock).sendNotificationWithFlush(notification, EMAIL); } |
CompetitionInviteRestServiceImpl extends BaseRestService implements CompetitionInviteRestService { @Override public RestResult<AssessorInvitesToSendResource> getInviteToSend(long inviteId) { return getWithRestResult(format("%s/%s/%s", COMPETITION_INVITE_REST_URL, "get-invite-to-send", inviteId), AssessorInvitesToSendResource.class); } @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToSend(long competitionId); @Override RestResult<AssessorInvitesToSendResource> getInviteToSend(long inviteId); @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToResend(long competitionId, List<Long> inviteIds); @Override RestResult<CompetitionInviteResource> getInvite(String inviteHash); @Override RestResult<CompetitionInviteResource> openInvite(String inviteHash); @Override RestResult<Void> acceptInvite(String inviteHash); @Override RestResult<Void> rejectInvite(String inviteHash, CompetitionRejectionResource rejectionReason); @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<AvailableAssessorPageResource> getAvailableAssessors(long competitionId, int page, String assessorNameFilter); @Override RestResult<List<Long>> getAvailableAssessorIds(long competitionId, String assessorNameFilter); @Override RestResult<List<Long>> getAssessorsNotAcceptedInviteIds(long competitionId,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<AssessorCreatedInvitePageResource> getCreatedInvites(long competitionId, int page); @Override RestResult<AssessorInviteOverviewPageResource> getInvitationOverview(long competitionId,
int page,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<CompetitionInviteStatisticsResource> getInviteStatistics(long competitionId); @Override RestResult<CompetitionInviteResource> inviteUser(ExistingUserStagedInviteResource existingUserStagedInvite); @Override RestResult<Void> inviteUsers(ExistingUserStagedInviteListResource existingUserStagedInvites); @Override RestResult<Void> inviteNewUsers(NewUserStagedInviteListResource newUserStagedInvites, long competitionId); @Override RestResult<Void> deleteInvite(String email, long competitionId); @Override RestResult<Void> deleteAllInvites(long competitionId); @Override RestResult<Void> sendAllInvites(long competitionId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvite(long inviteId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvites(List<Long> inviteIds, AssessorInviteSendResource assessorInviteSendResource); } | @Test public void getInviteToSend() { long inviteId = 1L; AssessorInvitesToSendResource expected = newAssessorInvitesToSendResource().build(); setupGetWithRestResultExpectations(format("%s/%s/%s", restUrl, "get-invite-to-send", inviteId), AssessorInvitesToSendResource.class, expected); AssessorInvitesToSendResource actual = service.getInviteToSend(inviteId).getSuccess(); assertEquals(expected, actual); } |
CompetitionInviteRestServiceImpl extends BaseRestService implements CompetitionInviteRestService { @Override public RestResult<CompetitionInviteResource> getInvite(String inviteHash) { return getWithRestResultAnonymous(format("%s/%s/%s", COMPETITION_INVITE_REST_URL, "get-invite", inviteHash), CompetitionInviteResource.class); } @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToSend(long competitionId); @Override RestResult<AssessorInvitesToSendResource> getInviteToSend(long inviteId); @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToResend(long competitionId, List<Long> inviteIds); @Override RestResult<CompetitionInviteResource> getInvite(String inviteHash); @Override RestResult<CompetitionInviteResource> openInvite(String inviteHash); @Override RestResult<Void> acceptInvite(String inviteHash); @Override RestResult<Void> rejectInvite(String inviteHash, CompetitionRejectionResource rejectionReason); @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<AvailableAssessorPageResource> getAvailableAssessors(long competitionId, int page, String assessorNameFilter); @Override RestResult<List<Long>> getAvailableAssessorIds(long competitionId, String assessorNameFilter); @Override RestResult<List<Long>> getAssessorsNotAcceptedInviteIds(long competitionId,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<AssessorCreatedInvitePageResource> getCreatedInvites(long competitionId, int page); @Override RestResult<AssessorInviteOverviewPageResource> getInvitationOverview(long competitionId,
int page,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<CompetitionInviteStatisticsResource> getInviteStatistics(long competitionId); @Override RestResult<CompetitionInviteResource> inviteUser(ExistingUserStagedInviteResource existingUserStagedInvite); @Override RestResult<Void> inviteUsers(ExistingUserStagedInviteListResource existingUserStagedInvites); @Override RestResult<Void> inviteNewUsers(NewUserStagedInviteListResource newUserStagedInvites, long competitionId); @Override RestResult<Void> deleteInvite(String email, long competitionId); @Override RestResult<Void> deleteAllInvites(long competitionId); @Override RestResult<Void> sendAllInvites(long competitionId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvite(long inviteId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvites(List<Long> inviteIds, AssessorInviteSendResource assessorInviteSendResource); } | @Test public void getInvite() { CompetitionInviteResource expected = new CompetitionInviteResource(); expected.setCompetitionName("my competition"); setupGetWithRestResultAnonymousExpectations(format("%s/%s/%s", restUrl, "get-invite", "hash"), CompetitionInviteResource.class, expected); CompetitionInviteResource actual = service.getInvite("hash").getSuccess(); assertEquals(expected, actual); } |
CompetitionInviteRestServiceImpl extends BaseRestService implements CompetitionInviteRestService { @Override public RestResult<CompetitionInviteResource> openInvite(String inviteHash) { return postWithRestResultAnonymous(format("%s/%s/%s", COMPETITION_INVITE_REST_URL, "open-invite", inviteHash), CompetitionInviteResource.class); } @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToSend(long competitionId); @Override RestResult<AssessorInvitesToSendResource> getInviteToSend(long inviteId); @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToResend(long competitionId, List<Long> inviteIds); @Override RestResult<CompetitionInviteResource> getInvite(String inviteHash); @Override RestResult<CompetitionInviteResource> openInvite(String inviteHash); @Override RestResult<Void> acceptInvite(String inviteHash); @Override RestResult<Void> rejectInvite(String inviteHash, CompetitionRejectionResource rejectionReason); @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<AvailableAssessorPageResource> getAvailableAssessors(long competitionId, int page, String assessorNameFilter); @Override RestResult<List<Long>> getAvailableAssessorIds(long competitionId, String assessorNameFilter); @Override RestResult<List<Long>> getAssessorsNotAcceptedInviteIds(long competitionId,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<AssessorCreatedInvitePageResource> getCreatedInvites(long competitionId, int page); @Override RestResult<AssessorInviteOverviewPageResource> getInvitationOverview(long competitionId,
int page,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<CompetitionInviteStatisticsResource> getInviteStatistics(long competitionId); @Override RestResult<CompetitionInviteResource> inviteUser(ExistingUserStagedInviteResource existingUserStagedInvite); @Override RestResult<Void> inviteUsers(ExistingUserStagedInviteListResource existingUserStagedInvites); @Override RestResult<Void> inviteNewUsers(NewUserStagedInviteListResource newUserStagedInvites, long competitionId); @Override RestResult<Void> deleteInvite(String email, long competitionId); @Override RestResult<Void> deleteAllInvites(long competitionId); @Override RestResult<Void> sendAllInvites(long competitionId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvite(long inviteId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvites(List<Long> inviteIds, AssessorInviteSendResource assessorInviteSendResource); } | @Test public void openInvite() { CompetitionInviteResource expected = new CompetitionInviteResource(); expected.setCompetitionName("my competition"); setupPostWithRestResultAnonymousExpectations(format("%s/%s/%s", restUrl, "open-invite", "hash"), CompetitionInviteResource.class, null, expected, OK); CompetitionInviteResource actual = service.openInvite("hash").getSuccess(); assertEquals(expected, actual); }
@Test public void openInvite_hashNotExists() { setupPostWithRestResultAnonymousExpectations(format("%s/%s/%s", restUrl, "open-invite", "hashNotExists"), CompetitionInviteResource.class, null, null, NOT_FOUND); RestResult<CompetitionInviteResource> restResult = service.openInvite("hashNotExists"); assertTrue(restResult.isFailure()); } |
CompetitionInviteRestServiceImpl extends BaseRestService implements CompetitionInviteRestService { @Override public RestResult<Void> acceptInvite(String inviteHash) { return postWithRestResult(format("%s/%s/%s", COMPETITION_INVITE_REST_URL, "accept-invite", inviteHash), Void.class); } @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToSend(long competitionId); @Override RestResult<AssessorInvitesToSendResource> getInviteToSend(long inviteId); @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToResend(long competitionId, List<Long> inviteIds); @Override RestResult<CompetitionInviteResource> getInvite(String inviteHash); @Override RestResult<CompetitionInviteResource> openInvite(String inviteHash); @Override RestResult<Void> acceptInvite(String inviteHash); @Override RestResult<Void> rejectInvite(String inviteHash, CompetitionRejectionResource rejectionReason); @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<AvailableAssessorPageResource> getAvailableAssessors(long competitionId, int page, String assessorNameFilter); @Override RestResult<List<Long>> getAvailableAssessorIds(long competitionId, String assessorNameFilter); @Override RestResult<List<Long>> getAssessorsNotAcceptedInviteIds(long competitionId,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<AssessorCreatedInvitePageResource> getCreatedInvites(long competitionId, int page); @Override RestResult<AssessorInviteOverviewPageResource> getInvitationOverview(long competitionId,
int page,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<CompetitionInviteStatisticsResource> getInviteStatistics(long competitionId); @Override RestResult<CompetitionInviteResource> inviteUser(ExistingUserStagedInviteResource existingUserStagedInvite); @Override RestResult<Void> inviteUsers(ExistingUserStagedInviteListResource existingUserStagedInvites); @Override RestResult<Void> inviteNewUsers(NewUserStagedInviteListResource newUserStagedInvites, long competitionId); @Override RestResult<Void> deleteInvite(String email, long competitionId); @Override RestResult<Void> deleteAllInvites(long competitionId); @Override RestResult<Void> sendAllInvites(long competitionId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvite(long inviteId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvites(List<Long> inviteIds, AssessorInviteSendResource assessorInviteSendResource); } | @Test public void acceptInvite() { setupPostWithRestResultExpectations(format("%s/%s/%s", restUrl, "accept-invite", "hash"), OK); RestResult<Void> restResult = service.acceptInvite("hash"); assertTrue(restResult.isSuccess()); } |
CompetitionInviteRestServiceImpl extends BaseRestService implements CompetitionInviteRestService { @Override public RestResult<Void> rejectInvite(String inviteHash, CompetitionRejectionResource rejectionReason) { return postWithRestResultAnonymous(format("%s/%s/%s", COMPETITION_INVITE_REST_URL, "reject-invite", inviteHash), rejectionReason, Void.class); } @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToSend(long competitionId); @Override RestResult<AssessorInvitesToSendResource> getInviteToSend(long inviteId); @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToResend(long competitionId, List<Long> inviteIds); @Override RestResult<CompetitionInviteResource> getInvite(String inviteHash); @Override RestResult<CompetitionInviteResource> openInvite(String inviteHash); @Override RestResult<Void> acceptInvite(String inviteHash); @Override RestResult<Void> rejectInvite(String inviteHash, CompetitionRejectionResource rejectionReason); @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<AvailableAssessorPageResource> getAvailableAssessors(long competitionId, int page, String assessorNameFilter); @Override RestResult<List<Long>> getAvailableAssessorIds(long competitionId, String assessorNameFilter); @Override RestResult<List<Long>> getAssessorsNotAcceptedInviteIds(long competitionId,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<AssessorCreatedInvitePageResource> getCreatedInvites(long competitionId, int page); @Override RestResult<AssessorInviteOverviewPageResource> getInvitationOverview(long competitionId,
int page,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<CompetitionInviteStatisticsResource> getInviteStatistics(long competitionId); @Override RestResult<CompetitionInviteResource> inviteUser(ExistingUserStagedInviteResource existingUserStagedInvite); @Override RestResult<Void> inviteUsers(ExistingUserStagedInviteListResource existingUserStagedInvites); @Override RestResult<Void> inviteNewUsers(NewUserStagedInviteListResource newUserStagedInvites, long competitionId); @Override RestResult<Void> deleteInvite(String email, long competitionId); @Override RestResult<Void> deleteAllInvites(long competitionId); @Override RestResult<Void> sendAllInvites(long competitionId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvite(long inviteId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvites(List<Long> inviteIds, AssessorInviteSendResource assessorInviteSendResource); } | @Test public void rejectInvite() { RejectionReasonResource rejectionReasonResource = new RejectionReasonResource(); rejectionReasonResource.setId(1L); CompetitionRejectionResource rejectionResource = new CompetitionRejectionResource(rejectionReasonResource, "too busy"); setupPostWithRestResultAnonymousExpectations(format("%s/%s/%s", restUrl, "reject-invite", "hash"), Void.class, rejectionResource, null, OK); RestResult<Void> restResult = service.rejectInvite("hash", rejectionResource); assertTrue(restResult.isSuccess()); } |
CompetitionInviteRestServiceImpl extends BaseRestService implements CompetitionInviteRestService { @Override public RestResult<Boolean> checkExistingUser(String inviteHash) { return getWithRestResultAnonymous(format("%s/%s/%s", COMPETITION_INVITE_REST_URL, "check-existing-user", inviteHash), Boolean.class); } @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToSend(long competitionId); @Override RestResult<AssessorInvitesToSendResource> getInviteToSend(long inviteId); @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToResend(long competitionId, List<Long> inviteIds); @Override RestResult<CompetitionInviteResource> getInvite(String inviteHash); @Override RestResult<CompetitionInviteResource> openInvite(String inviteHash); @Override RestResult<Void> acceptInvite(String inviteHash); @Override RestResult<Void> rejectInvite(String inviteHash, CompetitionRejectionResource rejectionReason); @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<AvailableAssessorPageResource> getAvailableAssessors(long competitionId, int page, String assessorNameFilter); @Override RestResult<List<Long>> getAvailableAssessorIds(long competitionId, String assessorNameFilter); @Override RestResult<List<Long>> getAssessorsNotAcceptedInviteIds(long competitionId,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<AssessorCreatedInvitePageResource> getCreatedInvites(long competitionId, int page); @Override RestResult<AssessorInviteOverviewPageResource> getInvitationOverview(long competitionId,
int page,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<CompetitionInviteStatisticsResource> getInviteStatistics(long competitionId); @Override RestResult<CompetitionInviteResource> inviteUser(ExistingUserStagedInviteResource existingUserStagedInvite); @Override RestResult<Void> inviteUsers(ExistingUserStagedInviteListResource existingUserStagedInvites); @Override RestResult<Void> inviteNewUsers(NewUserStagedInviteListResource newUserStagedInvites, long competitionId); @Override RestResult<Void> deleteInvite(String email, long competitionId); @Override RestResult<Void> deleteAllInvites(long competitionId); @Override RestResult<Void> sendAllInvites(long competitionId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvite(long inviteId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvites(List<Long> inviteIds, AssessorInviteSendResource assessorInviteSendResource); } | @Test public void checkExistingUser() { setupGetWithRestResultAnonymousExpectations(format("%s/%s/%s", restUrl, "check-existing-user", "hash"), Boolean.class, TRUE); assertTrue(service.checkExistingUser("hash").getSuccess()); } |
CompetitionInviteRestServiceImpl extends BaseRestService implements CompetitionInviteRestService { @Override public RestResult<AvailableAssessorPageResource> getAvailableAssessors(long competitionId, int page, String assessorNameFilter) { String baseUrl = format("%s/%s/%s", COMPETITION_INVITE_REST_URL, "get-available-assessors", competitionId); UriComponentsBuilder builder = UriComponentsBuilder.fromPath(baseUrl) .queryParam("page", page) .queryParam("assessorNameFilter", assessorNameFilter); return getWithRestResult(builder.toUriString(), AvailableAssessorPageResource.class); } @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToSend(long competitionId); @Override RestResult<AssessorInvitesToSendResource> getInviteToSend(long inviteId); @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToResend(long competitionId, List<Long> inviteIds); @Override RestResult<CompetitionInviteResource> getInvite(String inviteHash); @Override RestResult<CompetitionInviteResource> openInvite(String inviteHash); @Override RestResult<Void> acceptInvite(String inviteHash); @Override RestResult<Void> rejectInvite(String inviteHash, CompetitionRejectionResource rejectionReason); @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<AvailableAssessorPageResource> getAvailableAssessors(long competitionId, int page, String assessorNameFilter); @Override RestResult<List<Long>> getAvailableAssessorIds(long competitionId, String assessorNameFilter); @Override RestResult<List<Long>> getAssessorsNotAcceptedInviteIds(long competitionId,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<AssessorCreatedInvitePageResource> getCreatedInvites(long competitionId, int page); @Override RestResult<AssessorInviteOverviewPageResource> getInvitationOverview(long competitionId,
int page,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<CompetitionInviteStatisticsResource> getInviteStatistics(long competitionId); @Override RestResult<CompetitionInviteResource> inviteUser(ExistingUserStagedInviteResource existingUserStagedInvite); @Override RestResult<Void> inviteUsers(ExistingUserStagedInviteListResource existingUserStagedInvites); @Override RestResult<Void> inviteNewUsers(NewUserStagedInviteListResource newUserStagedInvites, long competitionId); @Override RestResult<Void> deleteInvite(String email, long competitionId); @Override RestResult<Void> deleteAllInvites(long competitionId); @Override RestResult<Void> sendAllInvites(long competitionId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvite(long inviteId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvites(List<Long> inviteIds, AssessorInviteSendResource assessorInviteSendResource); } | @Test public void getAvailableAssessors() { long competitionId = 1L; int page = 1; String assessorNameFilter = "name"; List<AvailableAssessorResource> assessorItems = newAvailableAssessorResource() .withName("Test") .build(2); AvailableAssessorPageResource expected = newAvailableAssessorPageResource() .withContent(assessorItems) .build(); setupGetWithRestResultExpectations( format("%s/%s/%s?page=1&assessorNameFilter=name", restUrl, "get-available-assessors", competitionId), AvailableAssessorPageResource.class, expected ); AvailableAssessorPageResource actual = service.getAvailableAssessors(competitionId, page, assessorNameFilter).getSuccess(); assertEquals(expected, actual); }
@Test public void getAvailableAssessors_noAssessorNameFilter() { long competitionId = 1L; int page = 1; String assessorNameFilter = "name"; List<AvailableAssessorResource> assessorItems = newAvailableAssessorResource().build(2); AvailableAssessorPageResource expected = newAvailableAssessorPageResource() .withContent(assessorItems) .build(); setupGetWithRestResultExpectations( format("%s/%s/%s?page=1&assessorNameFilter=name", restUrl, "get-available-assessors", competitionId), AvailableAssessorPageResource.class, expected ); AvailableAssessorPageResource actual = service.getAvailableAssessors(competitionId, page, assessorNameFilter).getSuccess(); assertEquals(expected, actual); } |
CompetitionInviteRestServiceImpl extends BaseRestService implements CompetitionInviteRestService { @Override public RestResult<List<Long>> getAvailableAssessorIds(long competitionId, String assessorNameFilter) { String baseUrl = format("%s/%s/%s", COMPETITION_INVITE_REST_URL, "get-available-assessors", competitionId); UriComponentsBuilder builder = UriComponentsBuilder .fromPath(baseUrl) .queryParam("all") .queryParam("assessorNameFilter", assessorNameFilter); return getWithRestResult(builder.toUriString(), ParameterizedTypeReferences.longsListType()); } @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToSend(long competitionId); @Override RestResult<AssessorInvitesToSendResource> getInviteToSend(long inviteId); @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToResend(long competitionId, List<Long> inviteIds); @Override RestResult<CompetitionInviteResource> getInvite(String inviteHash); @Override RestResult<CompetitionInviteResource> openInvite(String inviteHash); @Override RestResult<Void> acceptInvite(String inviteHash); @Override RestResult<Void> rejectInvite(String inviteHash, CompetitionRejectionResource rejectionReason); @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<AvailableAssessorPageResource> getAvailableAssessors(long competitionId, int page, String assessorNameFilter); @Override RestResult<List<Long>> getAvailableAssessorIds(long competitionId, String assessorNameFilter); @Override RestResult<List<Long>> getAssessorsNotAcceptedInviteIds(long competitionId,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<AssessorCreatedInvitePageResource> getCreatedInvites(long competitionId, int page); @Override RestResult<AssessorInviteOverviewPageResource> getInvitationOverview(long competitionId,
int page,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<CompetitionInviteStatisticsResource> getInviteStatistics(long competitionId); @Override RestResult<CompetitionInviteResource> inviteUser(ExistingUserStagedInviteResource existingUserStagedInvite); @Override RestResult<Void> inviteUsers(ExistingUserStagedInviteListResource existingUserStagedInvites); @Override RestResult<Void> inviteNewUsers(NewUserStagedInviteListResource newUserStagedInvites, long competitionId); @Override RestResult<Void> deleteInvite(String email, long competitionId); @Override RestResult<Void> deleteAllInvites(long competitionId); @Override RestResult<Void> sendAllInvites(long competitionId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvite(long inviteId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvites(List<Long> inviteIds, AssessorInviteSendResource assessorInviteSendResource); } | @Test public void getAvailableAssessors_all() { long competitionId = 1L; String assessorNameFilter = "name"; List<Long> assessorItems = asList(1L, 2L); setupGetWithRestResultExpectations( format("%s/%s/%s?all&assessorNameFilter=name", restUrl, "get-available-assessors", competitionId), ParameterizedTypeReferences.longsListType(), assessorItems ); List<Long> actual = service.getAvailableAssessorIds(competitionId, assessorNameFilter).getSuccess(); assertEquals(assessorItems, actual); } |
RoleProfileStatusServiceImpl implements RoleProfileStatusService { @Override public ServiceResult<List<RoleProfileStatusResource>> findByUserId(long userId) { return find(roleProfileStatusRepository.findByUserId(userId), notFoundError(RoleProfileStatus.class, userId)) .andOnSuccessReturn(rp -> rp.stream() .map(roleProfileStatusMapper::mapToResource) .collect(toList())); } @Override @Transactional ServiceResult<Void> updateUserStatus(long userId, RoleProfileStatusResource roleProfileStatusResource); @Override ServiceResult<List<RoleProfileStatusResource>> findByUserId(long userId); @Override ServiceResult<RoleProfileStatusResource> findByUserIdAndProfileRole(long userId, ProfileRole profileRole); @Override @Transactional ServiceResult<UserPageResource> findByRoleProfile(RoleProfileState state, ProfileRole profileRole, String filter, Pageable pageable); } | @Test public void findByUserId() { long userId = 1l; User user = newUser().withId(userId).build(); List<RoleProfileStatus> roleProfileStatus = newRoleProfileStatus().withUser(user).build(1); RoleProfileStatusResource roleProfileStatusResource = newRoleProfileStatusResource().withUserId(userId).build(); when(roleProfileStatusRepositoryMock.findByUserId(userId)).thenReturn(roleProfileStatus); when(roleProfileStatusMapper.mapToResource(roleProfileStatus.get(0))).thenReturn(roleProfileStatusResource); ServiceResult<List<RoleProfileStatusResource>> result = service.findByUserId(userId); assertTrue(result.isSuccess()); assertEquals(roleProfileStatusResource, result.getSuccess().get(0)); } |
CompetitionInviteRestServiceImpl extends BaseRestService implements CompetitionInviteRestService { @Override public RestResult<AssessorCreatedInvitePageResource> getCreatedInvites(long competitionId, int page) { String baseUrl = format("%s/%s/%s", COMPETITION_INVITE_REST_URL, "get-created-invites", competitionId); UriComponentsBuilder builder = UriComponentsBuilder.fromPath(baseUrl) .queryParam("page", page); return getWithRestResult(builder.toUriString(), AssessorCreatedInvitePageResource.class); } @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToSend(long competitionId); @Override RestResult<AssessorInvitesToSendResource> getInviteToSend(long inviteId); @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToResend(long competitionId, List<Long> inviteIds); @Override RestResult<CompetitionInviteResource> getInvite(String inviteHash); @Override RestResult<CompetitionInviteResource> openInvite(String inviteHash); @Override RestResult<Void> acceptInvite(String inviteHash); @Override RestResult<Void> rejectInvite(String inviteHash, CompetitionRejectionResource rejectionReason); @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<AvailableAssessorPageResource> getAvailableAssessors(long competitionId, int page, String assessorNameFilter); @Override RestResult<List<Long>> getAvailableAssessorIds(long competitionId, String assessorNameFilter); @Override RestResult<List<Long>> getAssessorsNotAcceptedInviteIds(long competitionId,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<AssessorCreatedInvitePageResource> getCreatedInvites(long competitionId, int page); @Override RestResult<AssessorInviteOverviewPageResource> getInvitationOverview(long competitionId,
int page,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<CompetitionInviteStatisticsResource> getInviteStatistics(long competitionId); @Override RestResult<CompetitionInviteResource> inviteUser(ExistingUserStagedInviteResource existingUserStagedInvite); @Override RestResult<Void> inviteUsers(ExistingUserStagedInviteListResource existingUserStagedInvites); @Override RestResult<Void> inviteNewUsers(NewUserStagedInviteListResource newUserStagedInvites, long competitionId); @Override RestResult<Void> deleteInvite(String email, long competitionId); @Override RestResult<Void> deleteAllInvites(long competitionId); @Override RestResult<Void> sendAllInvites(long competitionId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvite(long inviteId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvites(List<Long> inviteIds, AssessorInviteSendResource assessorInviteSendResource); } | @Test public void getCreatedInvites() { long competitionId = 1L; int page = 1; AssessorCreatedInvitePageResource expected = newAssessorCreatedInvitePageResource() .withContent(newAssessorCreatedInviteResource().build(2)) .build(); setupGetWithRestResultExpectations(format("%s/%s/%s?page=1", restUrl, "get-created-invites", competitionId), AssessorCreatedInvitePageResource.class, expected); AssessorCreatedInvitePageResource actual = service.getCreatedInvites(competitionId, page).getSuccess(); assertEquals(expected, actual); } |
CompetitionInviteRestServiceImpl extends BaseRestService implements CompetitionInviteRestService { @Override public RestResult<AssessorInviteOverviewPageResource> getInvitationOverview(long competitionId, int page, List<ParticipantStatusResource> participantStatuses, Optional<Boolean> compliant, Optional<String> assessorName) { String baseUrl = format("%s/%s/%s", COMPETITION_INVITE_REST_URL, "get-invitation-overview", competitionId); UriComponentsBuilder builder = UriComponentsBuilder.fromPath(baseUrl) .queryParam("page", page); String convertedStatusesList = simpleJoiner(participantStatuses, ","); builder.queryParam("statuses", convertedStatusesList); compliant.ifPresent(hasContract -> builder.queryParam("compliant", hasContract)); assessorName.ifPresent(hasContract -> builder.queryParam("assessorName", hasContract)); return getWithRestResult(builder.toUriString(), AssessorInviteOverviewPageResource.class); } @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToSend(long competitionId); @Override RestResult<AssessorInvitesToSendResource> getInviteToSend(long inviteId); @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToResend(long competitionId, List<Long> inviteIds); @Override RestResult<CompetitionInviteResource> getInvite(String inviteHash); @Override RestResult<CompetitionInviteResource> openInvite(String inviteHash); @Override RestResult<Void> acceptInvite(String inviteHash); @Override RestResult<Void> rejectInvite(String inviteHash, CompetitionRejectionResource rejectionReason); @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<AvailableAssessorPageResource> getAvailableAssessors(long competitionId, int page, String assessorNameFilter); @Override RestResult<List<Long>> getAvailableAssessorIds(long competitionId, String assessorNameFilter); @Override RestResult<List<Long>> getAssessorsNotAcceptedInviteIds(long competitionId,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<AssessorCreatedInvitePageResource> getCreatedInvites(long competitionId, int page); @Override RestResult<AssessorInviteOverviewPageResource> getInvitationOverview(long competitionId,
int page,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<CompetitionInviteStatisticsResource> getInviteStatistics(long competitionId); @Override RestResult<CompetitionInviteResource> inviteUser(ExistingUserStagedInviteResource existingUserStagedInvite); @Override RestResult<Void> inviteUsers(ExistingUserStagedInviteListResource existingUserStagedInvites); @Override RestResult<Void> inviteNewUsers(NewUserStagedInviteListResource newUserStagedInvites, long competitionId); @Override RestResult<Void> deleteInvite(String email, long competitionId); @Override RestResult<Void> deleteAllInvites(long competitionId); @Override RestResult<Void> sendAllInvites(long competitionId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvite(long inviteId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvites(List<Long> inviteIds, AssessorInviteSendResource assessorInviteSendResource); } | @Test public void getInvitationOverview() { long competitionId = 1L; int page = 1; List<ParticipantStatusResource> participantStatus = Collections.singletonList(ACCEPTED); Optional<Boolean> compliant = of(TRUE); Optional<String> assessorName = of("name"); AssessorInviteOverviewPageResource expected = newAssessorInviteOverviewPageResource().build(); String expectedUrl = format("%s/%s/%s?page=1&statuses=ACCEPTED&compliant=true&assessorName=name", restUrl, "get-invitation-overview", competitionId); setupGetWithRestResultExpectations(expectedUrl, AssessorInviteOverviewPageResource.class, expected); AssessorInviteOverviewPageResource actual = service.getInvitationOverview(competitionId, page, participantStatus, compliant, assessorName) .getSuccess(); assertEquals(expected, actual); }
@Test public void getInvitationOverview_noExtraParams() { long competitionId = 1L; int page = 1; AssessorInviteOverviewPageResource expected = newAssessorInviteOverviewPageResource().build(); String expectedUrl = format("%s/%s/%s?page=1&statuses=ACCEPTED,PENDING", restUrl, "get-invitation-overview", competitionId); setupGetWithRestResultExpectations(expectedUrl, AssessorInviteOverviewPageResource.class, expected); AssessorInviteOverviewPageResource actual = service.getInvitationOverview(competitionId, page, Arrays.asList(ACCEPTED, PENDING), empty(), empty()) .getSuccess(); assertEquals(expected, actual); } |
CompetitionInviteRestServiceImpl extends BaseRestService implements CompetitionInviteRestService { @Override public RestResult<List<Long>> getAssessorsNotAcceptedInviteIds(long competitionId, List<ParticipantStatusResource> participantStatuses, Optional<Boolean> compliant, Optional<String> assessorName) { String baseUrl = format("%s/%s/%s", COMPETITION_INVITE_REST_URL, "get-assessors-not-accepted-invite-ids", competitionId); UriComponentsBuilder builder = UriComponentsBuilder.fromPath(baseUrl); builder.queryParam("statuses", simpleJoiner(participantStatuses, ",")); compliant.ifPresent(hasContract -> builder.queryParam("compliant", hasContract)); assessorName.ifPresent(hasContract -> builder.queryParam("assessorName", hasContract)); return getWithRestResult(builder.toUriString(), ParameterizedTypeReferences.longsListType()); } @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToSend(long competitionId); @Override RestResult<AssessorInvitesToSendResource> getInviteToSend(long inviteId); @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToResend(long competitionId, List<Long> inviteIds); @Override RestResult<CompetitionInviteResource> getInvite(String inviteHash); @Override RestResult<CompetitionInviteResource> openInvite(String inviteHash); @Override RestResult<Void> acceptInvite(String inviteHash); @Override RestResult<Void> rejectInvite(String inviteHash, CompetitionRejectionResource rejectionReason); @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<AvailableAssessorPageResource> getAvailableAssessors(long competitionId, int page, String assessorNameFilter); @Override RestResult<List<Long>> getAvailableAssessorIds(long competitionId, String assessorNameFilter); @Override RestResult<List<Long>> getAssessorsNotAcceptedInviteIds(long competitionId,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<AssessorCreatedInvitePageResource> getCreatedInvites(long competitionId, int page); @Override RestResult<AssessorInviteOverviewPageResource> getInvitationOverview(long competitionId,
int page,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<CompetitionInviteStatisticsResource> getInviteStatistics(long competitionId); @Override RestResult<CompetitionInviteResource> inviteUser(ExistingUserStagedInviteResource existingUserStagedInvite); @Override RestResult<Void> inviteUsers(ExistingUserStagedInviteListResource existingUserStagedInvites); @Override RestResult<Void> inviteNewUsers(NewUserStagedInviteListResource newUserStagedInvites, long competitionId); @Override RestResult<Void> deleteInvite(String email, long competitionId); @Override RestResult<Void> deleteAllInvites(long competitionId); @Override RestResult<Void> sendAllInvites(long competitionId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvite(long inviteId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvites(List<Long> inviteIds, AssessorInviteSendResource assessorInviteSendResource); } | @Test public void getAssessorsNotAcceptedInviteIds() { long competitionId = 1L; List<Long> expected = asList(1L, 2L); List<ParticipantStatusResource> statuses = Arrays.asList(PENDING, REJECTED); String expectedUrl = format("%s/%s/%s?statuses=%s", restUrl, "get-assessors-not-accepted-invite-ids", competitionId, "PENDING,REJECTED"); setupGetWithRestResultExpectations(expectedUrl, ParameterizedTypeReferences.longsListType(), expected); List<Long> actual = service.getAssessorsNotAcceptedInviteIds(competitionId, statuses, empty(), empty()) .getSuccess(); assertEquals(expected, actual); } |
CompetitionInviteRestServiceImpl extends BaseRestService implements CompetitionInviteRestService { @Override public RestResult<CompetitionInviteStatisticsResource> getInviteStatistics(long competitionId) { return getWithRestResult(format("%s/%s/%s", COMPETITION_INVITE_REST_URL, "get-invite-statistics", competitionId), CompetitionInviteStatisticsResource.class); } @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToSend(long competitionId); @Override RestResult<AssessorInvitesToSendResource> getInviteToSend(long inviteId); @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToResend(long competitionId, List<Long> inviteIds); @Override RestResult<CompetitionInviteResource> getInvite(String inviteHash); @Override RestResult<CompetitionInviteResource> openInvite(String inviteHash); @Override RestResult<Void> acceptInvite(String inviteHash); @Override RestResult<Void> rejectInvite(String inviteHash, CompetitionRejectionResource rejectionReason); @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<AvailableAssessorPageResource> getAvailableAssessors(long competitionId, int page, String assessorNameFilter); @Override RestResult<List<Long>> getAvailableAssessorIds(long competitionId, String assessorNameFilter); @Override RestResult<List<Long>> getAssessorsNotAcceptedInviteIds(long competitionId,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<AssessorCreatedInvitePageResource> getCreatedInvites(long competitionId, int page); @Override RestResult<AssessorInviteOverviewPageResource> getInvitationOverview(long competitionId,
int page,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<CompetitionInviteStatisticsResource> getInviteStatistics(long competitionId); @Override RestResult<CompetitionInviteResource> inviteUser(ExistingUserStagedInviteResource existingUserStagedInvite); @Override RestResult<Void> inviteUsers(ExistingUserStagedInviteListResource existingUserStagedInvites); @Override RestResult<Void> inviteNewUsers(NewUserStagedInviteListResource newUserStagedInvites, long competitionId); @Override RestResult<Void> deleteInvite(String email, long competitionId); @Override RestResult<Void> deleteAllInvites(long competitionId); @Override RestResult<Void> sendAllInvites(long competitionId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvite(long inviteId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvites(List<Long> inviteIds, AssessorInviteSendResource assessorInviteSendResource); } | @Test public void getInviteStatistics() { long competitionId = 1L; CompetitionInviteStatisticsResource expected = newCompetitionInviteStatisticsResource().build(); setupGetWithRestResultExpectations(format("%s/%s/%s", restUrl, "get-invite-statistics", competitionId), CompetitionInviteStatisticsResource.class, expected); CompetitionInviteStatisticsResource actual = service.getInviteStatistics(competitionId).getSuccess(); assertEquals(expected, actual); } |
CompetitionInviteRestServiceImpl extends BaseRestService implements CompetitionInviteRestService { @Override public RestResult<CompetitionInviteResource> inviteUser(ExistingUserStagedInviteResource existingUserStagedInvite) { return postWithRestResult(format("%s/%s", COMPETITION_INVITE_REST_URL, "invite-user"), existingUserStagedInvite, CompetitionInviteResource.class); } @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToSend(long competitionId); @Override RestResult<AssessorInvitesToSendResource> getInviteToSend(long inviteId); @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToResend(long competitionId, List<Long> inviteIds); @Override RestResult<CompetitionInviteResource> getInvite(String inviteHash); @Override RestResult<CompetitionInviteResource> openInvite(String inviteHash); @Override RestResult<Void> acceptInvite(String inviteHash); @Override RestResult<Void> rejectInvite(String inviteHash, CompetitionRejectionResource rejectionReason); @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<AvailableAssessorPageResource> getAvailableAssessors(long competitionId, int page, String assessorNameFilter); @Override RestResult<List<Long>> getAvailableAssessorIds(long competitionId, String assessorNameFilter); @Override RestResult<List<Long>> getAssessorsNotAcceptedInviteIds(long competitionId,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<AssessorCreatedInvitePageResource> getCreatedInvites(long competitionId, int page); @Override RestResult<AssessorInviteOverviewPageResource> getInvitationOverview(long competitionId,
int page,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<CompetitionInviteStatisticsResource> getInviteStatistics(long competitionId); @Override RestResult<CompetitionInviteResource> inviteUser(ExistingUserStagedInviteResource existingUserStagedInvite); @Override RestResult<Void> inviteUsers(ExistingUserStagedInviteListResource existingUserStagedInvites); @Override RestResult<Void> inviteNewUsers(NewUserStagedInviteListResource newUserStagedInvites, long competitionId); @Override RestResult<Void> deleteInvite(String email, long competitionId); @Override RestResult<Void> deleteAllInvites(long competitionId); @Override RestResult<Void> sendAllInvites(long competitionId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvite(long inviteId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvites(List<Long> inviteIds, AssessorInviteSendResource assessorInviteSendResource); } | @Test public void inviteUser() { ExistingUserStagedInviteResource existingUserStagesInviteResource = new ExistingUserStagedInviteResource(2L, 1L); CompetitionInviteResource expected = newCompetitionInviteResource().build(); setupPostWithRestResultExpectations(format("%s/%s", restUrl, "invite-user"), CompetitionInviteResource.class, existingUserStagesInviteResource, expected, OK); CompetitionInviteResource actual = service.inviteUser(existingUserStagesInviteResource).getSuccess(); assertEquals(expected, actual); } |
CompetitionInviteRestServiceImpl extends BaseRestService implements CompetitionInviteRestService { @Override public RestResult<Void> inviteNewUsers(NewUserStagedInviteListResource newUserStagedInvites, long competitionId) { return postWithRestResult(format("%s/%s/%s", COMPETITION_INVITE_REST_URL, "invite-new-users", competitionId), newUserStagedInvites, Void.class); } @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToSend(long competitionId); @Override RestResult<AssessorInvitesToSendResource> getInviteToSend(long inviteId); @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToResend(long competitionId, List<Long> inviteIds); @Override RestResult<CompetitionInviteResource> getInvite(String inviteHash); @Override RestResult<CompetitionInviteResource> openInvite(String inviteHash); @Override RestResult<Void> acceptInvite(String inviteHash); @Override RestResult<Void> rejectInvite(String inviteHash, CompetitionRejectionResource rejectionReason); @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<AvailableAssessorPageResource> getAvailableAssessors(long competitionId, int page, String assessorNameFilter); @Override RestResult<List<Long>> getAvailableAssessorIds(long competitionId, String assessorNameFilter); @Override RestResult<List<Long>> getAssessorsNotAcceptedInviteIds(long competitionId,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<AssessorCreatedInvitePageResource> getCreatedInvites(long competitionId, int page); @Override RestResult<AssessorInviteOverviewPageResource> getInvitationOverview(long competitionId,
int page,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<CompetitionInviteStatisticsResource> getInviteStatistics(long competitionId); @Override RestResult<CompetitionInviteResource> inviteUser(ExistingUserStagedInviteResource existingUserStagedInvite); @Override RestResult<Void> inviteUsers(ExistingUserStagedInviteListResource existingUserStagedInvites); @Override RestResult<Void> inviteNewUsers(NewUserStagedInviteListResource newUserStagedInvites, long competitionId); @Override RestResult<Void> deleteInvite(String email, long competitionId); @Override RestResult<Void> deleteAllInvites(long competitionId); @Override RestResult<Void> sendAllInvites(long competitionId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvite(long inviteId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvites(List<Long> inviteIds, AssessorInviteSendResource assessorInviteSendResource); } | @Test public void inviteNewUsers() { long competitionId = 1L; NewUserStagedInviteListResource newUserStagedInviteListResource = newNewUserStagedInviteListResource() .withInvites( newNewUserStagedInviteResource() .withName("Tester 1", "Tester 2") .withEmail("[email protected]", "[email protected]") .withInnovationAreaId(1L) .build(2) ) .build(); setupPostWithRestResultExpectations(format("%s/%s/%s", restUrl, "invite-new-users", competitionId), newUserStagedInviteListResource, OK); RestResult<Void> restResult = service.inviteNewUsers(newUserStagedInviteListResource, competitionId); assertTrue(restResult.isSuccess()); } |
CompetitionInviteRestServiceImpl extends BaseRestService implements CompetitionInviteRestService { @Override public RestResult<Void> inviteUsers(ExistingUserStagedInviteListResource existingUserStagedInvites) { return postWithRestResult(format("%s/%s", COMPETITION_INVITE_REST_URL, "invite-users"), existingUserStagedInvites, Void.class); } @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToSend(long competitionId); @Override RestResult<AssessorInvitesToSendResource> getInviteToSend(long inviteId); @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToResend(long competitionId, List<Long> inviteIds); @Override RestResult<CompetitionInviteResource> getInvite(String inviteHash); @Override RestResult<CompetitionInviteResource> openInvite(String inviteHash); @Override RestResult<Void> acceptInvite(String inviteHash); @Override RestResult<Void> rejectInvite(String inviteHash, CompetitionRejectionResource rejectionReason); @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<AvailableAssessorPageResource> getAvailableAssessors(long competitionId, int page, String assessorNameFilter); @Override RestResult<List<Long>> getAvailableAssessorIds(long competitionId, String assessorNameFilter); @Override RestResult<List<Long>> getAssessorsNotAcceptedInviteIds(long competitionId,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<AssessorCreatedInvitePageResource> getCreatedInvites(long competitionId, int page); @Override RestResult<AssessorInviteOverviewPageResource> getInvitationOverview(long competitionId,
int page,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<CompetitionInviteStatisticsResource> getInviteStatistics(long competitionId); @Override RestResult<CompetitionInviteResource> inviteUser(ExistingUserStagedInviteResource existingUserStagedInvite); @Override RestResult<Void> inviteUsers(ExistingUserStagedInviteListResource existingUserStagedInvites); @Override RestResult<Void> inviteNewUsers(NewUserStagedInviteListResource newUserStagedInvites, long competitionId); @Override RestResult<Void> deleteInvite(String email, long competitionId); @Override RestResult<Void> deleteAllInvites(long competitionId); @Override RestResult<Void> sendAllInvites(long competitionId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvite(long inviteId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvites(List<Long> inviteIds, AssessorInviteSendResource assessorInviteSendResource); } | @Test public void inviteUsers() { long competitionId = 1L; ExistingUserStagedInviteListResource existingUserStagedInviteListResource = newExistingUserStagedInviteListResource() .withInvites( newExistingUserStagedInviteResource() .withUserId(1L, 2L) .withCompetitionId(competitionId) .build(2) ) .build(); setupPostWithRestResultExpectations(format("%s/%s", restUrl, "invite-users"), existingUserStagedInviteListResource, OK); RestResult<Void> restResult = service.inviteUsers(existingUserStagedInviteListResource); assertTrue(restResult.isSuccess()); } |
CompetitionInviteRestServiceImpl extends BaseRestService implements CompetitionInviteRestService { @Override public RestResult<Void> deleteInvite(String email, long competitionId) { return deleteWithRestResult(format("%s/%s?competitionId=%s&email=%s", COMPETITION_INVITE_REST_URL, "delete-invite", competitionId, email), Void.class); } @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToSend(long competitionId); @Override RestResult<AssessorInvitesToSendResource> getInviteToSend(long inviteId); @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToResend(long competitionId, List<Long> inviteIds); @Override RestResult<CompetitionInviteResource> getInvite(String inviteHash); @Override RestResult<CompetitionInviteResource> openInvite(String inviteHash); @Override RestResult<Void> acceptInvite(String inviteHash); @Override RestResult<Void> rejectInvite(String inviteHash, CompetitionRejectionResource rejectionReason); @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<AvailableAssessorPageResource> getAvailableAssessors(long competitionId, int page, String assessorNameFilter); @Override RestResult<List<Long>> getAvailableAssessorIds(long competitionId, String assessorNameFilter); @Override RestResult<List<Long>> getAssessorsNotAcceptedInviteIds(long competitionId,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<AssessorCreatedInvitePageResource> getCreatedInvites(long competitionId, int page); @Override RestResult<AssessorInviteOverviewPageResource> getInvitationOverview(long competitionId,
int page,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<CompetitionInviteStatisticsResource> getInviteStatistics(long competitionId); @Override RestResult<CompetitionInviteResource> inviteUser(ExistingUserStagedInviteResource existingUserStagedInvite); @Override RestResult<Void> inviteUsers(ExistingUserStagedInviteListResource existingUserStagedInvites); @Override RestResult<Void> inviteNewUsers(NewUserStagedInviteListResource newUserStagedInvites, long competitionId); @Override RestResult<Void> deleteInvite(String email, long competitionId); @Override RestResult<Void> deleteAllInvites(long competitionId); @Override RestResult<Void> sendAllInvites(long competitionId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvite(long inviteId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvites(List<Long> inviteIds, AssessorInviteSendResource assessorInviteSendResource); } | @Test public void deleteInvite() { String email = "[email protected]"; long competitionId = 1L; setupDeleteWithRestResultExpectations(format("%s/%s?competitionId=%s&email=%s", restUrl, "delete-invite", competitionId, email)); RestResult<Void> resultResult = service.deleteInvite(email, competitionId); assertTrue(resultResult.isSuccess()); } |
CompetitionInviteRestServiceImpl extends BaseRestService implements CompetitionInviteRestService { @Override public RestResult<Void> deleteAllInvites(long competitionId) { return deleteWithRestResult(format("%s/%s?competitionId=%s", COMPETITION_INVITE_REST_URL, "delete-all-invites", competitionId), Void.class); } @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToSend(long competitionId); @Override RestResult<AssessorInvitesToSendResource> getInviteToSend(long inviteId); @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToResend(long competitionId, List<Long> inviteIds); @Override RestResult<CompetitionInviteResource> getInvite(String inviteHash); @Override RestResult<CompetitionInviteResource> openInvite(String inviteHash); @Override RestResult<Void> acceptInvite(String inviteHash); @Override RestResult<Void> rejectInvite(String inviteHash, CompetitionRejectionResource rejectionReason); @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<AvailableAssessorPageResource> getAvailableAssessors(long competitionId, int page, String assessorNameFilter); @Override RestResult<List<Long>> getAvailableAssessorIds(long competitionId, String assessorNameFilter); @Override RestResult<List<Long>> getAssessorsNotAcceptedInviteIds(long competitionId,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<AssessorCreatedInvitePageResource> getCreatedInvites(long competitionId, int page); @Override RestResult<AssessorInviteOverviewPageResource> getInvitationOverview(long competitionId,
int page,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<CompetitionInviteStatisticsResource> getInviteStatistics(long competitionId); @Override RestResult<CompetitionInviteResource> inviteUser(ExistingUserStagedInviteResource existingUserStagedInvite); @Override RestResult<Void> inviteUsers(ExistingUserStagedInviteListResource existingUserStagedInvites); @Override RestResult<Void> inviteNewUsers(NewUserStagedInviteListResource newUserStagedInvites, long competitionId); @Override RestResult<Void> deleteInvite(String email, long competitionId); @Override RestResult<Void> deleteAllInvites(long competitionId); @Override RestResult<Void> sendAllInvites(long competitionId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvite(long inviteId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvites(List<Long> inviteIds, AssessorInviteSendResource assessorInviteSendResource); } | @Test public void deleteAllInvites() { long competitionId = 1L; setupDeleteWithRestResultExpectations(format("%s/%s?competitionId=%s", restUrl, "delete-all-invites", competitionId)); RestResult<Void> resultResult = service.deleteAllInvites(competitionId); assertTrue(resultResult.isSuccess()); } |
RoleProfileStatusServiceImpl implements RoleProfileStatusService { @Override public ServiceResult<RoleProfileStatusResource> findByUserIdAndProfileRole(long userId, ProfileRole profileRole) { return find(roleProfileStatusRepository.findByUserIdAndProfileRole(userId, profileRole), notFoundError(RoleProfileStatus.class, userId)) .andOnSuccessReturn(roleProfileStatusMapper::mapToResource); } @Override @Transactional ServiceResult<Void> updateUserStatus(long userId, RoleProfileStatusResource roleProfileStatusResource); @Override ServiceResult<List<RoleProfileStatusResource>> findByUserId(long userId); @Override ServiceResult<RoleProfileStatusResource> findByUserIdAndProfileRole(long userId, ProfileRole profileRole); @Override @Transactional ServiceResult<UserPageResource> findByRoleProfile(RoleProfileState state, ProfileRole profileRole, String filter, Pageable pageable); } | @Test public void findByUserIdAndProfileRole() { long userId = 1l; ProfileRole profileRole = ProfileRole.ASSESSOR; User user = newUser().withId(userId).build(); RoleProfileStatus roleProfileStatus = newRoleProfileStatus().withUser(user).build(); RoleProfileStatusResource roleProfileStatusResource = newRoleProfileStatusResource().withUserId(userId).build(); when(roleProfileStatusRepositoryMock.findByUserIdAndProfileRole(userId, profileRole)).thenReturn(Optional.of(roleProfileStatus)); when(roleProfileStatusMapper.mapToResource(roleProfileStatus)).thenReturn(roleProfileStatusResource); ServiceResult<RoleProfileStatusResource> result = service.findByUserIdAndProfileRole(userId, profileRole); assertTrue(result.isSuccess()); assertEquals(roleProfileStatusResource, result.getSuccess()); } |
CompetitionInviteRestServiceImpl extends BaseRestService implements CompetitionInviteRestService { @Override public RestResult<Void> sendAllInvites(long competitionId, AssessorInviteSendResource assessorInviteSendResource) { return postWithRestResult(format("%s/%s/%s", COMPETITION_INVITE_REST_URL, "send-all-invites", competitionId), assessorInviteSendResource, Void.class); } @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToSend(long competitionId); @Override RestResult<AssessorInvitesToSendResource> getInviteToSend(long inviteId); @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToResend(long competitionId, List<Long> inviteIds); @Override RestResult<CompetitionInviteResource> getInvite(String inviteHash); @Override RestResult<CompetitionInviteResource> openInvite(String inviteHash); @Override RestResult<Void> acceptInvite(String inviteHash); @Override RestResult<Void> rejectInvite(String inviteHash, CompetitionRejectionResource rejectionReason); @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<AvailableAssessorPageResource> getAvailableAssessors(long competitionId, int page, String assessorNameFilter); @Override RestResult<List<Long>> getAvailableAssessorIds(long competitionId, String assessorNameFilter); @Override RestResult<List<Long>> getAssessorsNotAcceptedInviteIds(long competitionId,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<AssessorCreatedInvitePageResource> getCreatedInvites(long competitionId, int page); @Override RestResult<AssessorInviteOverviewPageResource> getInvitationOverview(long competitionId,
int page,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<CompetitionInviteStatisticsResource> getInviteStatistics(long competitionId); @Override RestResult<CompetitionInviteResource> inviteUser(ExistingUserStagedInviteResource existingUserStagedInvite); @Override RestResult<Void> inviteUsers(ExistingUserStagedInviteListResource existingUserStagedInvites); @Override RestResult<Void> inviteNewUsers(NewUserStagedInviteListResource newUserStagedInvites, long competitionId); @Override RestResult<Void> deleteInvite(String email, long competitionId); @Override RestResult<Void> deleteAllInvites(long competitionId); @Override RestResult<Void> sendAllInvites(long competitionId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvite(long inviteId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvites(List<Long> inviteIds, AssessorInviteSendResource assessorInviteSendResource); } | @Test public void sendAllInvites() { long competitionId = 1L; AssessorInviteSendResource assessorInviteSendResource = newAssessorInviteSendResource() .withSubject("subject") .withContent("content") .build(); setupPostWithRestResultExpectations(format("%s/%s/%s", restUrl, "send-all-invites", competitionId), assessorInviteSendResource, OK); assertTrue(service.sendAllInvites(competitionId, assessorInviteSendResource).isSuccess()); } |
CompetitionInviteRestServiceImpl extends BaseRestService implements CompetitionInviteRestService { @Override public RestResult<Void> resendInvite(long inviteId, AssessorInviteSendResource assessorInviteSendResource) { return postWithRestResult(format("%s/%s/%s", COMPETITION_INVITE_REST_URL, "resend-invite", inviteId), assessorInviteSendResource, Void.class); } @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToSend(long competitionId); @Override RestResult<AssessorInvitesToSendResource> getInviteToSend(long inviteId); @Override RestResult<AssessorInvitesToSendResource> getAllInvitesToResend(long competitionId, List<Long> inviteIds); @Override RestResult<CompetitionInviteResource> getInvite(String inviteHash); @Override RestResult<CompetitionInviteResource> openInvite(String inviteHash); @Override RestResult<Void> acceptInvite(String inviteHash); @Override RestResult<Void> rejectInvite(String inviteHash, CompetitionRejectionResource rejectionReason); @Override RestResult<Boolean> checkExistingUser(String inviteHash); @Override RestResult<AvailableAssessorPageResource> getAvailableAssessors(long competitionId, int page, String assessorNameFilter); @Override RestResult<List<Long>> getAvailableAssessorIds(long competitionId, String assessorNameFilter); @Override RestResult<List<Long>> getAssessorsNotAcceptedInviteIds(long competitionId,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<AssessorCreatedInvitePageResource> getCreatedInvites(long competitionId, int page); @Override RestResult<AssessorInviteOverviewPageResource> getInvitationOverview(long competitionId,
int page,
List<ParticipantStatusResource> participantStatuses,
Optional<Boolean> compliant,
Optional<String> assessorName); @Override RestResult<CompetitionInviteStatisticsResource> getInviteStatistics(long competitionId); @Override RestResult<CompetitionInviteResource> inviteUser(ExistingUserStagedInviteResource existingUserStagedInvite); @Override RestResult<Void> inviteUsers(ExistingUserStagedInviteListResource existingUserStagedInvites); @Override RestResult<Void> inviteNewUsers(NewUserStagedInviteListResource newUserStagedInvites, long competitionId); @Override RestResult<Void> deleteInvite(String email, long competitionId); @Override RestResult<Void> deleteAllInvites(long competitionId); @Override RestResult<Void> sendAllInvites(long competitionId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvite(long inviteId, AssessorInviteSendResource assessorInviteSendResource); @Override RestResult<Void> resendInvites(List<Long> inviteIds, AssessorInviteSendResource assessorInviteSendResource); } | @Test public void resendInvite() { long inviteId = 5L; AssessorInviteSendResource assessorInviteSendResource = newAssessorInviteSendResource() .withSubject("subject") .withContent("content") .build(); setupPostWithRestResultExpectations(format("%s/%s/%s", restUrl, "resend-invite", inviteId), assessorInviteSendResource, OK); assertTrue(service.resendInvite(inviteId, assessorInviteSendResource).isSuccess()); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.