com.castlemock.core.mock.rest.model.project.domain.RestMockResponse.getId java code examples

private Optional<RestMockResponse> getDefaultMockResponse(final RestMethod restMethod,
                        final List<RestMockResponse> mockResponses){
  final String defaultResponseId = restMethod.getDefaultMockResponseId();
  if(defaultResponseId != null && !defaultResponseId.isEmpty()){
    LOGGER.info("Use the default response");
    for (RestMockResponse tmpMockResponse : mockResponses) {
      if(defaultResponseId.equals(tmpMockResponse.getId())){
        return Optional.of(tmpMockResponse);
      }
    }
    LOGGER.error("Unable to find the default response");
  }
  return Optional.empty();
}

  /**
   * 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<DeleteRestMockResponsesOutput> process(final ServiceTask<DeleteRestMockResponsesInput> serviceTask) {
    final DeleteRestMockResponsesInput input = serviceTask.getInput();
    for(RestMockResponse restMockResponse : input.getRestMockResponses()){
      this.deleteMockResponse(restMockResponse.getId());
    }
    return createServiceResult(DeleteRestMockResponsesOutput.builder().build());
  }
}

if(this.mockResponseRepository.exists(mockResponse.getId())){
  throw new IllegalArgumentException("A mock response with the following key already exists: " + mockResponse.getId());

  @Test
  public void testProcess(){
    final String projectId = "ProjectId";
    final String applicationId = "ApplicationId";
    final RestResource resource = RestResourceGenerator.generateRestResource();
    final RestMethod method = RestMethodGenerator.generateRestMethod();
    final RestMockResponse mockResponse = RestMockResponseGenerator.generateRestMockResponse();

    Mockito.when(resourceRepository.findWithApplicationId(applicationId)).thenReturn(Arrays.asList(resource));
    Mockito.when(methodRepository.findWithResourceId(resource.getId())).thenReturn(Arrays.asList(method));
    Mockito.when(mockResponseRepository.findWithMethodId(method.getId())).thenReturn(Arrays.asList(mockResponse));

    final DeleteRestApplicationInput input = DeleteRestApplicationInput.builder()
        .restProjectId(projectId)
        .restApplicationId(applicationId)
        .build();
    final ServiceTask<DeleteRestApplicationInput> serviceTask = new ServiceTask<DeleteRestApplicationInput>(input);
    final ServiceResult<DeleteRestApplicationOutput> serviceResult = service.process(serviceTask);

    Mockito.verify(applicationRepository, Mockito.times(1)).delete(applicationId);
    Mockito.verify(resourceRepository, Mockito.times(1)).delete(resource.getId());
    Mockito.verify(methodRepository, Mockito.times(1)).delete(method.getId());
    Mockito.verify(mockResponseRepository, Mockito.times(1)).delete(mockResponse.getId());

    Mockito.verify(resourceRepository, Mockito.times(1)).findWithApplicationId(applicationId);
    Mockito.verify(methodRepository, Mockito.times(1)).findWithResourceId(resource.getId());
    Mockito.verify(mockResponseRepository, Mockito.times(1)).findWithMethodId(method.getId());
  }
}

  @Test
  public void testProcess(){
    final String projectId = "ProjectId";
    final String applicationId = "ApplicationId";
    final String resourceId = "ResourceId";
    final RestMethod method = RestMethodGenerator.generateRestMethod();
    final RestMockResponse mockResponse = RestMockResponseGenerator.generateRestMockResponse();

    Mockito.when(methodRepository.findWithResourceId(resourceId)).thenReturn(Arrays.asList(method));
    Mockito.when(mockResponseRepository.findWithMethodId(method.getId())).thenReturn(Arrays.asList(mockResponse));

    final DeleteRestResourceInput input = DeleteRestResourceInput.builder()
        .restProjectId(projectId)
        .restApplicationId(applicationId)
        .restResourceId(resourceId)
        .build();
    final ServiceTask<DeleteRestResourceInput> serviceTask = new ServiceTask<DeleteRestResourceInput>(input);
    final ServiceResult<DeleteRestResourceOutput> serviceResult = service.process(serviceTask);

    Mockito.verify(resourceRepository, Mockito.times(1)).delete(resourceId);
    Mockito.verify(methodRepository, Mockito.times(1)).delete(method.getId());
    Mockito.verify(mockResponseRepository, Mockito.times(1)).delete(mockResponse.getId());

    Mockito.verify(methodRepository, Mockito.times(1)).findWithResourceId(resourceId);
    Mockito.verify(mockResponseRepository, Mockito.times(1)).findWithMethodId(method.getId());
  }
}

  @Test
  public void testProcess(){
    final String projectId = "ProjectId";
    final String applicationId = "ApplicationId";
    final String resourceId = "ResourceId";
    final String methodId = "MethodId";
    final RestMockResponse mockResponse = RestMockResponseGenerator.generateRestMockResponse();

    Mockito.when(mockResponseRepository.findWithMethodId(methodId)).thenReturn(Arrays.asList(mockResponse));

    final DeleteRestMethodInput input = DeleteRestMethodInput.builder()
        .restProjectId(projectId)
        .restApplicationId(applicationId)
        .restResourceId(resourceId)
        .restMethodId(methodId)
        .build();
    final ServiceTask<DeleteRestMethodInput> serviceTask = new ServiceTask<DeleteRestMethodInput>(input);
    final ServiceResult<DeleteRestMethodOutput> serviceResult = service.process(serviceTask);

    Mockito.verify(methodRepository, Mockito.times(1)).delete(methodId);
    Mockito.verify(mockResponseRepository, Mockito.times(1)).delete(mockResponse.getId());

    Mockito.verify(mockResponseRepository, Mockito.times(1)).findWithMethodId(methodId);
  }
}

Mockito.verify(resourceRepository, Mockito.times(1)).delete(resource.getId());
Mockito.verify(methodRepository, Mockito.times(1)).delete(method.getId());
Mockito.verify(mockResponseRepository, Mockito.times(1)).delete(mockResponse.getId());

    + SLASH + RESOURCE + SLASH + resourceId
    + SLASH + METHOD + SLASH + mockResponse.getMethodId()
    + SLASH + RESPONSE + SLASH + mockResponse.getId());
searchResult.setDescription(REST_TYPE + COMMA + responseType);
searchResults.add(searchResult);

@Test
public void testProcess(){
  final String projectId = "ProjectId";
  final String applicationId = "ApplicationId";
  final String resourceId = "ResourceId";
  final String methodId = "MethodId";
  final RestMockResponse mockResponse = RestMockResponseGenerator.generateRestMockResponse();
  final ReadRestMockResponseInput input = ReadRestMockResponseInput.builder()
      .restProjectId(projectId)
      .restApplicationId(applicationId)
      .restResourceId(resourceId)
      .restMethodId(methodId)
      .restMockResponse(mockResponse.getId())
      .build();
  final ServiceTask<ReadRestMockResponseInput> serviceTask = new ServiceTask<ReadRestMockResponseInput>(input);
  Mockito.when(mockResponseRepository.findOne(mockResponse.getId())).thenReturn(mockResponse);
  final ServiceResult<ReadRestMockResponseOutput> result = service.process(serviceTask);
  Mockito.verify(mockResponseRepository, Mockito.times(1)).findOne(mockResponse.getId());
  Assert.assertNotNull(result.getOutput());
  Assert.assertEquals(mockResponse, result.getOutput().getRestMockResponse());
}

if(mockResponse.getId().equals(restMethod.getDefaultMockResponseId())){
  restMethod.setDefaultResponseName(mockResponse.getName());
  defaultQueryMockResponseId = true;

if(this.mockResponseRepository.exists(mockResponse.getId())){
  throw new IllegalArgumentException("A mocked response with the following key already exists: " + mockResponse.getId());

@Test
public void testDeleteMockResponseConfirm() throws Exception {
  final RestProject restProject = RestProjectGenerator.generateRestProject();
  final RestApplication restApplication = RestApplicationGenerator.generateRestApplication();
  final RestResource restResource = RestResourceGenerator.generateRestResource();
  final RestMethod restMethod = RestMethodGenerator.generateRestMethod();
  final RestMockResponse restMockResponse = RestMockResponseGenerator.generateRestMockResponse();
  when(serviceProcessor.process(any(DeleteRestMockResponseInput.class))).thenReturn(DeleteRestMockResponsesOutput.builder().build());
  final MockHttpServletRequestBuilder message = MockMvcRequestBuilders.get(SERVICE_URL + PROJECT +
      SLASH + restProject.getId() + SLASH + APPLICATION + SLASH + restApplication.getId() + SLASH +
      RESOURCE + SLASH + restResource.getId() + SLASH + METHOD + SLASH + restMethod.getId() + SLASH +
      RESPONSE + SLASH + restMockResponse.getId() + SLASH + DELETE + SLASH + CONFIRM);
  mockMvc.perform(message)
      .andExpect(MockMvcResultMatchers.status().isFound())
      .andExpect(MockMvcResultMatchers.model().size(0));
}

@Test
public void testUpdateMockResponse() throws Exception {
  final RestProject restProject = RestProjectGenerator.generateRestProject();
  final RestApplication restApplication = RestApplicationGenerator.generateRestApplication();
  final RestResource restResource = RestResourceGenerator.generateRestResource();
  final RestMethod restMethod = RestMethodGenerator.generateRestMethod();
  final RestMockResponse restMockResponse = RestMockResponseGenerator.generateRestMockResponse();
  when(serviceProcessor.process(any(UpdateRestMockResponseInput.class))).thenReturn(UpdateRestMockResponseOutput.builder()
      .updatedRestMockResponse(restMockResponse)
      .build());
  final MockHttpServletRequestBuilder message = MockMvcRequestBuilders.post(SERVICE_URL + PROJECT +
      SLASH + restProject.getId() + SLASH + APPLICATION + SLASH + restApplication.getId() +
      SLASH + RESOURCE + SLASH + restResource.getId() + SLASH + METHOD + SLASH + restMethod.getId() +
      SLASH + RESPONSE + SLASH + restMockResponse.getId() + SLASH + UPDATE);
  mockMvc.perform(message)
      .andExpect(MockMvcResultMatchers.status().isFound())
      .andExpect(MockMvcResultMatchers.model().size(1));
}

Assert.assertTrue(response200Xml.isUsingExpressions());
Assert.assertTrue(response200Xml.getContentEncodings().isEmpty());
Assert.assertNull(response200Xml.getId());
Assert.assertNull(response200Xml.getMethodId());
Assert.assertEquals(1, response200Xml.getHttpHeaders().size());
Assert.assertTrue(response200Json.isUsingExpressions());
Assert.assertTrue(response200Json.getContentEncodings().isEmpty());
Assert.assertNull(response200Json.getId());
Assert.assertNull(response200Json.getMethodId());
Assert.assertEquals(1, response200Json.getHttpHeaders().size());
Assert.assertTrue(invalidMockResponse.isUsingExpressions());
Assert.assertTrue(invalidMockResponse.getContentEncodings().isEmpty());
Assert.assertNull(invalidMockResponse.getId());
Assert.assertNull(invalidMockResponse.getMethodId());
Assert.assertEquals(0, invalidMockResponse.getHttpHeaders().size());
Assert.assertTrue(notFoundResponse.isUsingExpressions());
Assert.assertTrue(notFoundResponse.getContentEncodings().isEmpty());
Assert.assertNull(notFoundResponse.getId());
Assert.assertNull(notFoundResponse.getMethodId());
Assert.assertEquals(0, notFoundResponse.getHttpHeaders().size());
Assert.assertTrue(invalidMockResponse.isUsingExpressions());
Assert.assertTrue(invalidMockResponse.getContentEncodings().isEmpty());
Assert.assertNull(invalidMockResponse.getId());
Assert.assertNull(invalidMockResponse.getMethodId());
Assert.assertEquals(0, invalidMockResponse.getHttpHeaders().size());

Assert.assertTrue(restMockResponse.isUsingExpressions());
Assert.assertNull(restMockResponse.getId());
Assert.assertNull(restMockResponse.getMethodId());
Assert.assertNull(restMockResponse.getBody());

    SLASH + restProject.getId() + SLASH + APPLICATION + SLASH + restApplication.getId() + SLASH +
    RESOURCE + SLASH + restResource.getId() + SLASH + METHOD + SLASH + restMethod.getId() + SLASH +
    RESPONSE + SLASH + restMockResponse.getId());
mockMvc.perform(message)
    .andExpect(MockMvcResultMatchers.status().isOk())

@Test
public void testDeleteMockResponse() throws Exception {
  final RestProject restProject = RestProjectGenerator.generateRestProject();
  final RestApplication restApplication = RestApplicationGenerator.generateRestApplication();
  final RestResource restResource = RestResourceGenerator.generateRestResource();
  final RestMethod restMethod = RestMethodGenerator.generateRestMethod();
  final RestMockResponse restMockResponse = RestMockResponseGenerator.generateRestMockResponse();
  when(serviceProcessor.process(any(ReadRestMockResponseInput.class))).thenReturn(ReadRestMockResponseOutput.builder()
      .restMockResponse(restMockResponse)
      .build());
  final MockHttpServletRequestBuilder message = MockMvcRequestBuilders.get(SERVICE_URL + PROJECT +
      SLASH + restProject.getId() + SLASH + APPLICATION + SLASH + restApplication.getId() +
      SLASH + RESOURCE + SLASH + restResource.getId() + SLASH + METHOD + SLASH + restMethod.getId() +
      SLASH + RESPONSE + SLASH + restMockResponse.getId() + SLASH + DELETE);
  mockMvc.perform(message)
      .andExpect(MockMvcResultMatchers.status().isOk())
      .andExpect(MockMvcResultMatchers.model().size(5 + GLOBAL_VIEW_MODEL_COUNT))
      .andExpect(MockMvcResultMatchers.forwardedUrl(INDEX))
      .andExpect(MockMvcResultMatchers.model().attribute(PARTIAL, PAGE))
      .andExpect(MockMvcResultMatchers.model().attribute(REST_PROJECT_ID, restProject.getId()))
      .andExpect(MockMvcResultMatchers.model().attribute(REST_APPLICATION_ID, restApplication.getId()))
      .andExpect(MockMvcResultMatchers.model().attribute(REST_RESOURCE_ID, restResource.getId()))
      .andExpect(MockMvcResultMatchers.model().attribute(REST_METHOD_ID, restMethod.getId()))
      .andExpect(MockMvcResultMatchers.model().attribute(REST_MOCK_RESPONSE, restMockResponse));
}

Popular methods of RestMockResponse

Popular in Java

Running tasks concurrently on multiple threads
runOnUiThread (Activity)
addToBackStack (FragmentTransaction)
scheduleAtFixedRate (Timer)
BufferedWriter (java.io)
Wraps an existing Writer and buffers the output. Expensive interaction with the underlying reader is
FileInputStream (java.io)
An input stream that reads bytes from a file. File file = ...finally if (in != null) in.clos
LinkedList (java.util)
Doubly-linked list implementation of the List and Dequeinterfaces. Implements all optional list oper
Vector (java.util)
Vector is an implementation of List, backed by an array and synchronized. All optional operations in
Pattern (java.util.regex)
Patterns are compiled regular expressions. In many cases, convenience methods such as String#matches
DateTimeFormat (org.joda.time.format)
Factory that creates instances of DateTimeFormatter from patterns and styles. Datetime formatting i
Top Vim plugins

How to use getIdmethodin com.castlemock.core.mock.rest.model.project.domain.RestMockResponse

Best Java code snippets using com.castlemock.core.mock.rest.model.project.domain.RestMockResponse.getId (Showing top 17 results out of 315)

How to use
getId
method
in
com.castlemock.core.mock.rest.model.project.domain.RestMockResponse