Example usage for org.springframework.mock.http.client MockClientHttpResponse MockClientHttpResponse

List of usage examples for org.springframework.mock.http.client MockClientHttpResponse MockClientHttpResponse

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.mock.http.client.*
  5. MockClientHttpResponse
  6. MockClientHttpResponse

Introduction

In this page you can find the example usage for org.springframework.mock.http.client MockClientHttpResponse MockClientHttpResponse.

Prototype

public MockClientHttpResponse(InputStream body, HttpStatus statusCode)

Source Link

Document

Constructor with response body as InputStream.

Usage

From source file:org.fao.geonet.MockRequestFactoryGeonet.java

@Override
public ClientHttpResponse execute(HttpUriRequest request, Function<HttpClientBuilder, Void> configurator)
        throws IOException {
    final URI uri = request.getURI();
    final Request key = new Request(uri.getHost(), uri.getPort(), uri.getScheme(), null);
    final XmlRequest xmlRequest = (XmlRequest) getRequest(key);
    return new MockClientHttpResponse(Xml.getString(xmlRequest.execute()).getBytes(Constants.CHARSET),
            HttpStatus.OK);//  w  w  w  . ja va 2s .  co  m
}

From source file:com.neiljbrown.brighttalk.channels.reportingapi.client.spring.ApiResponseErrorHandlerTest.java

/**
 * Tests {@link ApiResponseErrorHandler#hasError} in the case where the response has an HTTP status code in the client
 * error (4xx) series, specifically HTTP 400 Bad Request.
 * /*  www  . j a va  2  s .  c  o  m*/
 * @throws Exception If an unexpected error occurs.
 */
@Test
public void testHasErrorWhenHttpStatusBadRequest() throws Exception {
    byte[] body = null;
    ClientHttpResponse response = new MockClientHttpResponse(body, HttpStatus.BAD_REQUEST);
    assertThat(this.errorHandler.hasError(response), CoreMatchers.is(true));
}

From source file:io.spring.initializr.web.test.MockMvcClientHttpRequestFactory.java

@Override
public ClientHttpRequest createRequest(final URI uri, final HttpMethod httpMethod) throws IOException {
    return new MockClientHttpRequest(httpMethod, uri) {
        @Override//from   w ww  .j  a v a2 s.c  o  m
        public ClientHttpResponse executeInternal() throws IOException {
            try {
                MockHttpServletRequestBuilder requestBuilder = request(httpMethod, uri.toString());
                requestBuilder.content(getBodyAsBytes());
                requestBuilder.headers(getHeaders());
                MockHttpServletResponse servletResponse = actions(requestBuilder).andReturn().getResponse();
                HttpStatus status = HttpStatus.valueOf(servletResponse.getStatus());
                if (status.value() >= 400) {
                    requestBuilder = request(HttpMethod.GET, "/error")
                            .requestAttr(RequestDispatcher.ERROR_STATUS_CODE, status.value())
                            .requestAttr(RequestDispatcher.ERROR_REQUEST_URI, uri.toString());
                    if (servletResponse.getErrorMessage() != null) {
                        requestBuilder.requestAttr(RequestDispatcher.ERROR_MESSAGE,
                                servletResponse.getErrorMessage());
                    }
                    // Overwrites the snippets from the first request
                    servletResponse = actions(requestBuilder).andReturn().getResponse();
                }
                byte[] body = servletResponse.getContentAsByteArray();
                HttpHeaders headers = getResponseHeaders(servletResponse);
                MockClientHttpResponse clientResponse = new MockClientHttpResponse(body, status);
                clientResponse.getHeaders().putAll(headers);
                return clientResponse;
            } catch (Exception ex) {
                throw new IllegalStateException(ex);
            }
        }

    };
}

From source file:com.neiljbrown.brighttalk.channels.reportingapi.client.spring.ApiResponseErrorHandlerTest.java

/**
 * Tests {@link ApiResponseErrorHandler#hasError} in the case where the response has an HTTP status code in the server
 * error (5xx) series, specifically HTTP 500 Internal Server Error.
 * // ww w .  j a v  a 2s . c o m
 * @throws Exception If an unexpected error occurs.
 */
@Test
public void testHasErrorWhenHttpStatusInternalServerError() throws Exception {
    byte[] body = null;
    ClientHttpResponse response = new MockClientHttpResponse(body, HttpStatus.INTERNAL_SERVER_ERROR);
    assertThat(this.errorHandler.hasError(response), CoreMatchers.is(true));
}

From source file:com.neiljbrown.brighttalk.channels.reportingapi.client.spring.ApiResponseErrorHandlerTest.java

/**
 * Tests {@link ApiResponseErrorHandler#hasError} in the case where the response has an HTTP status code in the
 * success (2xx) series, specifically HTTP 200 OK.
 * /*from  w  ww .j a v a 2 s  .c om*/
 * @throws Exception If an unexpected error occurs.
 */
@Test
public void testHasErrorWhenHttpStatusOK() throws Exception {
    byte[] body = null;
    ClientHttpResponse response = new MockClientHttpResponse(body, HttpStatus.OK);
    assertThat(this.errorHandler.hasError(response), CoreMatchers.is(false));
}

From source file:org.cloudfoundry.identity.uaa.login.EmailResetPasswordServiceTests.java

@Test
public void testForgotPasswordWhenConflictIsReturnedByTheUaa() throws Exception {
    mockUaaServer.expect(requestTo("http://uaa.example.com/uaa/password_resets")).andExpect(method(POST))
            .andRespond(new ResponseCreator() {
                @Override/*from  www .j a  v  a 2s .c o  m*/
                public ClientHttpResponse createResponse(ClientHttpRequest request) throws IOException {
                    return new MockClientHttpResponse("{\"user_id\":\"user-id-001\"}".getBytes(), CONFLICT);
                }
            });

    MockHttpServletRequest request = new MockHttpServletRequest();
    request.setProtocol("http");
    request.setContextPath("/login");
    RequestContextHolder.setRequestAttributes(new ServletRequestAttributes(request));

    emailResetPasswordService.forgotPassword("user@example.com");

    mockUaaServer.verify();

    Mockito.verify(messageService).sendMessage(eq("user-id-001"), eq("user@example.com"),
            eq(MessageType.PASSWORD_RESET), eq("Pivotal account password reset request"), contains(
                    "Your account credentials for localhost are managed by an external service. Please contact your administrator for password recovery requests."));
}

From source file:org.springframework.boot.test.web.client.TestRestTemplateTests.java

private void verifyRelativeUriHandling(TestRestTemplateCallback callback) throws IOException {
    ClientHttpRequestFactory requestFactory = mock(ClientHttpRequestFactory.class);
    MockClientHttpRequest request = new MockClientHttpRequest();
    request.setResponse(new MockClientHttpResponse(new byte[0], HttpStatus.OK));
    URI absoluteUri = URI.create("http://localhost:8080/a/b/c.txt?param=%7Bsomething%7D");
    given(requestFactory.createRequest(eq(absoluteUri), (HttpMethod) any())).willReturn(request);
    RestTemplate delegate = new RestTemplate();
    TestRestTemplate template = new TestRestTemplate(delegate);
    delegate.setRequestFactory(requestFactory);
    LocalHostUriTemplateHandler uriTemplateHandler = new LocalHostUriTemplateHandler(new MockEnvironment());
    template.setUriTemplateHandler(uriTemplateHandler);
    callback.doWithTestRestTemplate(template, URI.create("/a/b/c.txt?param=%7Bsomething%7D"));
    verify(requestFactory).createRequest(eq(absoluteUri), (HttpMethod) any());
}

From source file:com.netflix.genie.web.controllers.JobRestControllerUnitTests.java

/**
 * Make sure directory forwarding happens when all conditions are met.
 *
 * @throws IOException      on error/*w  w  w. j  av a  2  s . co  m*/
 * @throws ServletException on error
 * @throws GenieException   on error
 */
@Test
public void canHandleForwardJobOutputRequestWithSuccess() throws IOException, ServletException, GenieException {
    this.jobsProperties.getForwarding().setEnabled(true);
    final String jobId = UUID.randomUUID().toString();
    final String forwardedFrom = null;
    final HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
    final HttpServletResponse response = Mockito.mock(HttpServletResponse.class);

    Mockito.doNothing().when(this.genieResourceHttpRequestHandler).handleRequest(request, response);

    final String jobHostName = UUID.randomUUID().toString();
    Mockito.when(this.jobSearchService.getJobHost(jobId)).thenReturn(jobHostName);

    //Mock parts of the http request
    final String http = "http";
    Mockito.when(request.getScheme()).thenReturn(http);
    final int port = 8080;
    Mockito.when(request.getServerPort()).thenReturn(port);
    final String requestURI = "/" + jobId + "/" + UUID.randomUUID().toString();
    Mockito.when(request.getRequestURI()).thenReturn(requestURI);

    final Set<String> headerNames = Sets.newHashSet(HttpHeaders.ACCEPT);
    Mockito.when(request.getHeaderNames()).thenReturn(Collections.enumeration(headerNames));
    Mockito.when(request.getHeader(HttpHeaders.ACCEPT)).thenReturn(MediaType.APPLICATION_JSON_VALUE);

    final String requestUrl = UUID.randomUUID().toString();
    Mockito.when(request.getRequestURL()).thenReturn(new StringBuffer(requestUrl));

    //Mock parts of forward response
    final HttpResponse forwardResponse = Mockito.mock(HttpResponse.class);
    final StatusLine statusLine = Mockito.mock(StatusLine.class);
    Mockito.when(forwardResponse.getStatusLine()).thenReturn(statusLine);
    final int successCode = 200;
    Mockito.when(statusLine.getStatusCode()).thenReturn(successCode);
    final Header contentTypeHeader = Mockito.mock(Header.class);
    Mockito.when(contentTypeHeader.getName()).thenReturn(HttpHeaders.CONTENT_TYPE);
    Mockito.when(contentTypeHeader.getValue()).thenReturn(MediaType.TEXT_PLAIN_VALUE);
    Mockito.when(forwardResponse.getAllHeaders()).thenReturn(new Header[] { contentTypeHeader });

    final String text = UUID.randomUUID().toString() + UUID.randomUUID().toString()
            + UUID.randomUUID().toString();
    final ByteArrayInputStream bis = new ByteArrayInputStream(text.getBytes(UTF_8));
    final HttpEntity entity = Mockito.mock(HttpEntity.class);
    Mockito.when(entity.getContent()).thenReturn(bis);
    Mockito.when(forwardResponse.getEntity()).thenReturn(entity);

    final ByteArrayServletOutputStream bos = new ByteArrayServletOutputStream();
    Mockito.when(response.getOutputStream()).thenReturn(bos);

    final ClientHttpRequestFactory factory = Mockito.mock(ClientHttpRequestFactory.class);
    final ClientHttpRequest clientHttpRequest = Mockito.mock(ClientHttpRequest.class);
    Mockito.when(clientHttpRequest.execute())
            .thenReturn(new MockClientHttpResponse(text.getBytes(UTF_8), HttpStatus.OK));
    Mockito.when(clientHttpRequest.getHeaders()).thenReturn(new HttpHeaders());
    Mockito.when(factory.createRequest(Mockito.any(), Mockito.any())).thenReturn(clientHttpRequest);
    final RestTemplate template = new RestTemplate(factory);
    final Registry registry = Mockito.mock(Registry.class);
    final Counter counter = Mockito.mock(Counter.class);
    Mockito.when(registry.counter(Mockito.anyString())).thenReturn(counter);

    final JobRestController jobController = new JobRestController(Mockito.mock(JobCoordinatorService.class),
            this.jobSearchService, Mockito.mock(AttachmentService.class),
            Mockito.mock(ApplicationResourceAssembler.class), Mockito.mock(ClusterResourceAssembler.class),
            Mockito.mock(CommandResourceAssembler.class), Mockito.mock(JobResourceAssembler.class),
            Mockito.mock(JobRequestResourceAssembler.class), Mockito.mock(JobExecutionResourceAssembler.class),
            Mockito.mock(JobSearchResultResourceAssembler.class), this.hostname, template,
            this.genieResourceHttpRequestHandler, this.jobsProperties, registry);
    jobController.getJobOutput(jobId, forwardedFrom, request, response);

    Assert.assertThat(new String(bos.toByteArray(), UTF_8), Matchers.is(text));
    Mockito.verify(request, Mockito.times(1)).getHeader(HttpHeaders.ACCEPT);
    Mockito.verify(this.jobSearchService, Mockito.times(1)).getJobHost(Mockito.eq(jobId));
    Mockito.verify(response, Mockito.never()).sendError(Mockito.anyInt());
    Mockito.verify(this.genieResourceHttpRequestHandler, Mockito.never()).handleRequest(request, response);
}

From source file:org.apache.geode.management.internal.web.http.support.HttpRequesterTest.java

@Test
public void extractResponseOfJsonString() throws Exception {
    String responseString = "my response";
    requester = new HttpRequester();
    response = new MockClientHttpResponse(IOUtils.toInputStream(responseString, "UTF-8"), HttpStatus.OK);

    response.getHeaders().add(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE);
    Object result = requester.extractResponse(response);
    assertThat(result).isEqualTo(responseString);
}

From source file:org.apache.geode.management.internal.web.http.support.HttpRequesterTest.java

@Test
public void extractResponseOfFileDownload() throws Exception {
    File responseFile = temporaryFolder.newFile();
    FileUtils.writeStringToFile(responseFile, "some file contents", "UTF-8");
    requester = new HttpRequester();
    response = new MockClientHttpResponse(new FileInputStream(responseFile), HttpStatus.OK);
    response.getHeaders().add(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_OCTET_STREAM_VALUE);
    Object result = requester.extractResponse(response);
    Path fileResult = (Path) result;
    assertThat(fileResult).hasSameContentAs(responseFile.toPath());
}