public static RestProject generateRestProject(){ final RestProject project = new RestProject(); project.setId("REST PROJECT"); project.setName("Project name"); project.setDescription("Project description"); project.setCreated(new Date()); project.setUpdated(new Date()); project.setApplications(new ArrayList<RestApplication>()); return project; }
/** * Updates a project with new information * @param restProjectId The id of the project that will be updated * @param updatedProject The updated version of the project * @return The updated version project */ @Override protected RestProject update(final String restProjectId, final RestProject updatedProject){ Preconditions.checkNotNull(restProjectId, "Project id be null"); Preconditions.checkNotNull(updatedProject, "Project cannot be null"); Preconditions.checkArgument(!updatedProject.getName().isEmpty(), "Invalid project name. Project name cannot be empty"); final RestProject projectWithName = repository.findRestProjectWithName(updatedProject.getName()); Preconditions.checkArgument(projectWithName == null || projectWithName.getId().equals(restProjectId), "Project name is already taken"); final RestProject project = find(restProjectId); project.setName(updatedProject.getName()); project.setDescription(updatedProject.getDescription()); return super.save(project); }
private RestProject createRestProject(String name) { RestProject restProject = new RestProject(); restProject.setName(name); return restProject; } }
public static RestProject convert(RestProjectV1 projectV1){ RestProject project = new RestProject(); project.setCreated(projectV1.getCreated()); project.setUpdated(projectV1.getUpdated()); project.setDescription(projectV1.getDescription()); project.setId(projectV1.getId()); project.setName(projectV1.getName()); application.setId(applicationV1.getId()); application.setName(applicationV1.getName()); application.setProjectId(project.getId()); project.getApplications().add(application);
@Test public void testFindOne(){ final RestProject restProject = save(); final RestProject returnedRestEvent = repository.findOne(restProject.getId()); Assert.assertEquals(returnedRestEvent.getId(), restProject.getId()); Assert.assertEquals(returnedRestEvent.getDescription(), restProject.getDescription()); Assert.assertEquals(returnedRestEvent.getName(), restProject.getName()); }
@Test @Ignore public void testProcess(){ final RestProject restProject = new RestProject(); restProject.setApplications(new ArrayList<RestApplication>()); Mockito.when(repository.findOne(Mockito.anyString())).thenReturn(restProject); final List<RestApplication> restApplications = new ArrayList<RestApplication>(); for(int index = 0; index < 3; index++){ final RestApplication restApplication = RestApplicationGenerator.generateRestApplication(); restApplications.add(restApplication); } /* final CreateRestApplicationsInput input = new CreateRestApplicationsInput(restProject.getId(), restApplications); final ServiceTask<CreateRestApplicationsInput> serviceTask = new ServiceTask<CreateRestApplicationsInput>(input); service.process(serviceTask); Mockito.verify(repository, Mockito.timeout(1)).save(Mockito.any(RestProject.class)); */ }
RestProject project = convert(type); if(this.projectRepository.exists(project.getId())){ throw new IllegalArgumentException("A project with the following key already exists: " + project.getId()); for(RestApplication application : project.getApplications()) { if(this.applicationRepository.exists(application.getId())){ throw new IllegalArgumentException("An application with the following key already exists: " + application.getId());
/** * The method provides the functionality to convert an instance (parent) to an instance of a subclass to the * provided parent. * @param parent The parent that will be converted into a subtype of the provided parent * @return A new instance of the parent, but as a subtype of the parent */ @Override public RestProject convertType(Project parent) { return new RestProject(parent); }
/** * The process message is responsible for processing an incoming serviceTask and generate * a response based on the incoming serviceTask input * @param serviceTask The serviceTask that will be processed by the service * @return A result based on the processed incoming serviceTask * @see ServiceTask * @see ServiceResult */ @Override public ServiceResult<ReadRestProjectOutput> process(final ServiceTask<ReadRestProjectInput> serviceTask) { final ReadRestProjectInput input = serviceTask.getInput(); final RestProject restProject = find(input.getRestProjectId()); final List<RestApplication> applications = this.applicationRepository.findWithProjectId(input.getRestProjectId()); restProject.setApplications(applications); for(final RestApplication restApplication : restProject.getApplications()){ final Map<RestMethodStatus, Integer> soapOperationStatusCount = getRestMethodStatusCount(restApplication); restApplication.setStatusCount(soapOperationStatusCount); } return createServiceResult(ReadRestProjectOutput.builder() .restProject(restProject) .build()); } }
@Test public void testFindrestProjectWithName() { restProjectMongoRepository.save(createRestProject("xxAbcXX")); restProjectMongoRepository.save(createRestProject("abc")); restProjectMongoRepository.save(createRestProject("xAbc")); RestProject abc = restProjectMongoRepository.findRestProjectWithName("ABC"); assertThat(abc.getName()).isEqualTo("abc"); }
@Test public void testFindAll(){ final RestProject restProject = save(); final List<RestProject> restProjects = repository.findAll(); Assert.assertEquals(restProjects.size(), 1); Assert.assertEquals(restProjects.get(0).getId(), restProject.getId()); Assert.assertEquals(restProjects.get(0).getDescription(), restProject.getDescription()); Assert.assertEquals(restProjects.get(0).getName(), restProject.getName()); }
public static RestProject generateFullRestProject(){ final RestProject project = new RestProject(); project.setId("REST PROJECT"); project.setName("Project name"); project.setDescription("Project description"); project.setCreated(new Date()); project.setUpdated(new Date()); project.setApplications(new ArrayList<RestApplication>()); for(int applicationIndex = 0; applicationIndex < 3; applicationIndex++){ final RestApplication restApplication = RestApplicationGenerator.generateRestApplication(); restApplication.setResources(new ArrayList<RestResource>()); project.getApplications().add(restApplication); for(int resourceIndex = 0; resourceIndex < 3; resourceIndex++){ final RestResource restResource = RestResourceGenerator.generateRestResource(); restResource.setMethods(new ArrayList<RestMethod>()); restApplication.getResources().add(restResource); for(int methodIndex = 0; methodIndex < 3; methodIndex++){ final RestMethod restMethod = RestMethodGenerator.generateRestMethod(); restMethod.setMockResponses(new ArrayList<RestMockResponse>()); restResource.getMethods().add(restMethod); for(int responseIndex = 0; responseIndex < 3; responseIndex++){ final RestMockResponse restMockResponse = RestMockResponseGenerator.generateRestMockResponse(); restMethod.getMockResponses().add(restMockResponse); } } } } return project; }
@Test public void testExportProject(){ final RestProject project = RestProjectGenerator.generateRestProject(); final String exportedProject = "Exported project"; final ExportRestProjectOutput output = ExportRestProjectOutput.builder().exportedProject(exportedProject).build(); Mockito.when(serviceProcessor.process(Mockito.any(ExportRestProjectInput.class))).thenReturn(output); final String returnedExportedProject = adapter.exportProject(project.getId()); Assert.assertEquals(exportedProject, returnedExportedProject); Mockito.verify(serviceProcessor, Mockito.times(1)).process(Mockito.any(ExportRestProjectInput.class)); }
@Test public void testDelete(){ final RestProject project = RestProjectGenerator.generateRestProject(); final DeleteRestProjectOutput output = DeleteRestProjectOutput.builder().project(project).build(); Mockito.when(serviceProcessor.process(Mockito.any(DeleteRestProjectInput.class))).thenReturn(output); final RestProject returnedProject = adapter.delete(project.getId()); Assert.assertEquals(project, returnedProject); Mockito.verify(serviceProcessor, Mockito.times(1)).process(Mockito.any(DeleteRestProjectInput.class)); }
@Test public void testRead(){ final RestProject project = RestProjectGenerator.generateRestProject(); final ReadRestProjectOutput output = ReadRestProjectOutput.builder().restProject(project).build(); Mockito.when(serviceProcessor.process(Mockito.any(ReadRestProjectInput.class))).thenReturn(output); final RestProject returnedProject = adapter.read(project.getId()); Assert.assertEquals(project, returnedProject); Mockito.verify(serviceProcessor, Mockito.times(1)).process(Mockito.any(ReadRestProjectInput.class)); }
@Test public void testUpdate(){ final RestProject project = RestProjectGenerator.generateRestProject(); final UpdateRestProjectOutput output = UpdateRestProjectOutput.builder().updatedRestProject(project).build(); Mockito.when(serviceProcessor.process(Mockito.any(UpdateRestProjectInput.class))).thenReturn(output); final RestProject returnedProject = adapter.update(project.getId(), project); Assert.assertEquals(project, returnedProject); Mockito.verify(serviceProcessor, Mockito.times(1)).process(Mockito.any(UpdateRestProjectInput.class)); }
@Test public void testProcess(){ final RestProject project = RestProjectGenerator.generateRestProject(); final RestApplication application = RestApplicationGenerator.generateRestApplication(); final RestResource resource = RestResourceGenerator.generateRestResource(); final RestMethod method = RestMethodGenerator.generateRestMethod(); final ReadRestProjectInput input = ReadRestProjectInput.builder() .restProjectId(project.getId()) .build(); final ServiceTask<ReadRestProjectInput> serviceTask = new ServiceTask<ReadRestProjectInput>(input); Mockito.when(repository.findOne(project.getId())).thenReturn(project); Mockito.when(applicationRepository.findWithProjectId(project.getId())).thenReturn(Arrays.asList(application)); Mockito.when(resourceRepository.findIdsWithApplicationId(application.getId())).thenReturn(Arrays.asList(resource.getId())); Mockito.when(methodRepository.findWithResourceId(resource.getId())).thenReturn(Arrays.asList(method)); final ServiceResult<ReadRestProjectOutput> result = service.process(serviceTask); Mockito.verify(repository, Mockito.times(1)).findOne(project.getId()); Mockito.verify(applicationRepository, Mockito.times(1)).findWithProjectId(project.getId()); Mockito.verify(resourceRepository, Mockito.times(1)).findIdsWithApplicationId(application.getId()); Mockito.verify(methodRepository, Mockito.times(1)).findWithResourceId(resource.getId()); Assert.assertNotNull(result.getOutput()); Assert.assertEquals(project, result.getOutput().getRestProject()); }