Example usage for org.springframework.http.client ClientHttpRequestFactory createRequest

List of usage examples for org.springframework.http.client ClientHttpRequestFactory createRequest

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.http.client.*
  5. ClientHttpRequestFactory
  6. createRequest

Introduction

In this page you can find the example usage for org.springframework.http.client ClientHttpRequestFactory createRequest.

Prototype

ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod) throws IOException;

Source Link

Document

Create a new ClientHttpRequest for the specified URI and HTTP method.

Usage

From source file:com.miserablemind.api.consumer.tradeking.api.impl.StreamingTemplate.java

private ClientHttpResponse executeRequest(HttpMethod method, String url, MultiValueMap<String, String> body)
        throws IOException {
    ClientHttpRequestFactory requestFactory = this.getRestTemplate().getRequestFactory();
    ClientHttpRequest request = requestFactory.createRequest(URI.create(url), method);
    OutputStreamWriter writer = new OutputStreamWriter(request.getBody());
    writer.write(createFormUrlEncodedBodyString(body));
    writer.flush();/*from   w  ww  .  j  av a 2  s. c o  m*/
    return request.execute();
}

From source file:org.eclipse.cft.server.core.internal.client.CFClientV1Support.java

protected ClientHttpRequestFactory authorize(final ClientHttpRequestFactory delegate) {
    return new ClientHttpRequestFactory() {

        public ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod) throws IOException {
            ClientHttpRequest request = delegate.createRequest(uri, httpMethod);
            request.getHeaders().add("Authorization", oauth.getAuthorizationHeader()); //$NON-NLS-1$
            return request;
        }/*from w  ww .  ja va2  s.c om*/
    };
}

From source file:org.eclipse.cft.server.core.internal.ssh.SshClientSupport.java

private ClientHttpRequestFactory authorize(final ClientHttpRequestFactory delegate) {
    return new ClientHttpRequestFactory() {

        public ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod) throws IOException {
            ClientHttpRequest request = delegate.createRequest(uri, httpMethod);
            request.getHeaders().add("Authorization", oauth.getAuthorizationHeader()); //$NON-NLS-1$
            return request;
        }// w w  w .  j a va2  s.c o  m
    };
}

From source file:nl.flotsam.calendar.core.CalendarClient.java

public CalendarClient(URI baseURI) {
    this.baseURI = baseURI;
    template = new RestTemplate();
    template.setMessageConverters(/* w  w  w.  j av a  2  s  . c o  m*/
            Arrays.asList(new HttpMessageConverter<?>[] { new UriListHttpMessageConverter(),
                    new CalendarAsStringHttpMessageConverter(), new StringHttpMessageConverter() }));
    final ClientHttpRequestFactory factory = template.getRequestFactory();
    template.setRequestFactory(new ClientHttpRequestFactory() {

        @Override
        public ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod) throws IOException {
            logger.info("Sending " + httpMethod.name() + " to " + uri.toASCIIString());
            return factory.createRequest(uri, httpMethod);
        }
    });
}

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/*from   www .java 2  s  . c o 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.cruk.genologics.api.GenologicsAPIPaginatedBatchTest.java

@Test
public void testMultipageFetchListSome() throws Exception {
    // Note - reusing the files from above means that the subsequent pages
    // with have "&projectname=Run+1030" as part of the URL. This can be ignored
    // for this test.

    // Part one - mock the rest template to return the already parsed objects.

    RestOperations restMock = EasyMock.createStrictMock(RestOperations.class);

    EasyMock.expect(restMock.getForEntity("http://lims.cri.camres.org:8080/api/v2/samples?start-index=0",
            Samples.class)).andReturn(response1).once();
    EasyMock.expect(restMock.getForEntity(
            new URI("http://lims.cri.camres.org:8080/api/v2/samples?start-index=500&projectname=Run+1030"),
            Samples.class)).andReturn(response2).once();
    // Should get as far as response 3 in this test.

    GenologicsAPIImpl localApi = context.getBean("genologicsAPI", GenologicsAPIImpl.class);
    localApi.setRestClient(restMock);//from  w  ww . j a  v a2 s .c o  m
    localApi.setServer(new URL("http://lims.cri.camres.org:8080"));

    EasyMock.replay(restMock);

    List<LimsLink<Sample>> links = localApi.listSome(Sample.class, 0, 750);

    EasyMock.verify(restMock);

    assertEquals("Expected 750 sample links returned", 750, links.size());

    // Part two - mock the HTTP client and request factory to ensure that the URIs are
    // being presented as expected without character cludging.

    HttpContext httpContext = HttpClientContext.create();
    HttpClient mockHttpClient = EasyMock.createMock(HttpClient.class);
    ClientHttpRequestFactory mockRequestFactory = EasyMock.createMock(ClientHttpRequestFactory.class);

    RestTemplate restTemplate = context.getBean("genologicsRestTemplate", RestTemplate.class);
    restTemplate.setRequestFactory(mockRequestFactory);

    localApi.setHttpClient(mockHttpClient);
    localApi.setRestClient(restTemplate);

    URI pageOne = new URI("http://lims.cri.camres.org:8080/api/v2/samples?start-index=0");
    URI pageTwo = new URI(
            "http://lims.cri.camres.org:8080/api/v2/samples?start-index=500&projectname=Run+1030");

    HttpGet getOne = new HttpGet(pageOne);
    HttpGet getTwo = new HttpGet(pageTwo);

    HttpResponse responseOne = createMultipageFetchResponse(pageFiles[0]);
    HttpResponse responseTwo = createMultipageFetchResponse(pageFiles[1]);

    Class<?> requestClass = Class.forName("org.springframework.http.client.HttpComponentsClientHttpRequest");
    Constructor<?> constructor = requestClass.getDeclaredConstructor(HttpClient.class, HttpUriRequest.class,
            HttpContext.class);
    constructor.setAccessible(true);

    ClientHttpRequest reqOne = (ClientHttpRequest) constructor.newInstance(mockHttpClient, getOne, httpContext);
    ClientHttpRequest reqTwo = (ClientHttpRequest) constructor.newInstance(mockHttpClient, getTwo, httpContext);

    EasyMock.expect(mockRequestFactory.createRequest(pageOne, HttpMethod.GET)).andReturn(reqOne).once();
    EasyMock.expect(mockRequestFactory.createRequest(pageTwo, HttpMethod.GET)).andReturn(reqTwo).once();

    EasyMock.expect(mockHttpClient.execute(getOne, httpContext)).andReturn(responseOne).once();
    EasyMock.expect(mockHttpClient.execute(getTwo, httpContext)).andReturn(responseTwo).once();

    EasyMock.replay(mockHttpClient, mockRequestFactory);

    links = localApi.listSome(Sample.class, 0, 750);

    EasyMock.verify(mockHttpClient, mockRequestFactory);

    assertEquals("Expected 750 sample links returned", 750, links.size());
}

From source file:org.cruk.genologics.api.GenologicsAPIBatchOperationTest.java

@Test
public void testArtifactBatchFetch() throws Exception {
    List<LimsLink<Artifact>> links = new ArrayList<LimsLink<Artifact>>();

    links.add(new ArtifactLink(new URI("http://limsdev.cri.camres.org:8080/api/v2/artifacts/2-1000624")));
    links.add(new ArtifactLink(new URI("http://limsdev.cri.camres.org:8080/api/v2/artifacts/2-1000622")));
    links.add(new ArtifactLink(new URI("http://limsdev.cri.camres.org:8080/api/v2/artifacts/2-1000605")));
    links.add(new ArtifactLink(new URI("http://limsdev.cri.camres.org:8080/api/v2/artifacts/2-1000623")));
    links.add(new ArtifactLink(new URI("http://limsdev.cri.camres.org:8080/api/v2/artifacts/2-1000625")));

    File expectedResultFile = new File("src/test/xml/batchtestreordering-artifacts.xml");
    String expectedReply = FileUtils.readFileToString(expectedResultFile);

    URI uri = new URI("http://limsdev.cri.camres.org:8080/api/v2/artifacts/batch/retrieve");

    // Note: need PushbackInputStream to prevent the call to getBody() being made more than once.
    // See MessageBodyClientHttpResponseWrapper.

    InputStream responseStream = new PushbackInputStream(new ByteArrayInputStream(expectedReply.getBytes()));

    HttpHeaders headers = new HttpHeaders();

    ClientHttpResponse httpResponse = EasyMock.createMock(ClientHttpResponse.class);
    EasyMock.expect(httpResponse.getStatusCode()).andReturn(HttpStatus.OK).anyTimes();
    EasyMock.expect(httpResponse.getRawStatusCode()).andReturn(HttpStatus.OK.value()).anyTimes();
    EasyMock.expect(httpResponse.getHeaders()).andReturn(headers).anyTimes();
    EasyMock.expect(httpResponse.getBody()).andReturn(responseStream).once();
    httpResponse.close();//  ww w  .  ja v a2s.c  o  m
    EasyMock.expectLastCall().once();

    ClientHttpRequest httpRequest = EasyMock.createMock(ClientHttpRequest.class);
    EasyMock.expect(httpRequest.getHeaders()).andReturn(headers).anyTimes();
    EasyMock.expect(httpRequest.getBody()).andReturn(new NullOutputStream()).times(0, 2);
    EasyMock.expect(httpRequest.execute()).andReturn(httpResponse).once();

    ClientHttpRequestFactory mockFactory = EasyMock.createStrictMock(ClientHttpRequestFactory.class);
    EasyMock.expect(mockFactory.createRequest(uri, HttpMethod.POST)).andReturn(httpRequest).once();

    restTemplate.setRequestFactory(mockFactory);

    EasyMock.replay(httpResponse, httpRequest, mockFactory);

    List<Artifact> artifacts = api.loadAll(links);

    assertEquals("Wrong number of artifacts", links.size(), artifacts.size());

    for (int i = 0; i < links.size(); i++) {
        assertTrue("Artifact " + i + " wrong: " + artifacts.get(i).getUri(),
                artifacts.get(i).getUri().toString().startsWith(links.get(i).getUri().toString()));
    }

    EasyMock.verify(httpResponse, httpRequest, mockFactory);
}

From source file:org.cruk.genologics.api.GenologicsAPIBatchOperationTest.java

@Test
public void testArtifactBatchUpdate() throws Exception {
    File expectedResultFile = new File("src/test/xml/batchtestreordering-artifacts.xml");
    String expectedReply = FileUtils.readFileToString(expectedResultFile);

    ArtifactBatchFetchResult updateArtifactsFetch = (ArtifactBatchFetchResult) marshaller
            .unmarshal(new StreamSource(expectedResultFile));

    List<Artifact> artifacts = updateArtifactsFetch.getArtifacts();

    // Rearrange these to a different order to that in the file.
    // This means the original XML file loaded above will return in an order
    // not matching either the Links object (below) or the original order
    // of the artifacts.
    Collections.shuffle(artifacts, new Random(997));

    // Copy the URI order as it is now to make sure it doesn't differ
    // after updating the artifacts.
    List<URI> uriOrder = new ArrayList<URI>();

    Links confirmLinks = new Links();
    for (Artifact a : artifacts) {
        uriOrder.add(a.getUri());/* w  w  w  .j  a va2s .  co m*/
        confirmLinks.getLinks().add(new Link(a));
    }

    // The Links object that (would) come back should be in a different order.
    Collections.shuffle(confirmLinks.getLinks(), new Random(1024));

    StringWriter linksXML = new StringWriter();
    marshaller.marshal(confirmLinks, new StreamResult(linksXML));

    // Two calls to make here.

    URI updateUri = new URI("http://limsdev.cri.camres.org:8080/api/v2/artifacts/batch/update");
    URI retrieveUri = new URI("http://limsdev.cri.camres.org:8080/api/v2/artifacts/batch/retrieve");

    // Note: need PushbackInputStream to prevent the call to getBody() being made more than once.
    // See MessageBodyClientHttpResponseWrapper.

    InputStream response1Stream = new PushbackInputStream(
            new ByteArrayInputStream(linksXML.toString().getBytes()));
    InputStream response2Stream = new PushbackInputStream(new ByteArrayInputStream(expectedReply.getBytes()));

    HttpHeaders headers = new HttpHeaders();

    ClientHttpResponse httpResponse1 = EasyMock.createMock(ClientHttpResponse.class);
    EasyMock.expect(httpResponse1.getStatusCode()).andReturn(HttpStatus.OK).anyTimes();
    EasyMock.expect(httpResponse1.getRawStatusCode()).andReturn(HttpStatus.OK.value()).anyTimes();
    EasyMock.expect(httpResponse1.getHeaders()).andReturn(headers).anyTimes();
    EasyMock.expect(httpResponse1.getBody()).andReturn(response1Stream).once();
    httpResponse1.close();
    EasyMock.expectLastCall().once();

    ClientHttpRequest httpRequest1 = EasyMock.createMock(ClientHttpRequest.class);
    EasyMock.expect(httpRequest1.getHeaders()).andReturn(headers).anyTimes();
    EasyMock.expect(httpRequest1.getBody()).andReturn(new NullOutputStream()).times(0, 2);
    EasyMock.expect(httpRequest1.execute()).andReturn(httpResponse1).once();

    ClientHttpResponse httpResponse2 = EasyMock.createMock(ClientHttpResponse.class);
    EasyMock.expect(httpResponse2.getStatusCode()).andReturn(HttpStatus.OK).anyTimes();
    EasyMock.expect(httpResponse2.getRawStatusCode()).andReturn(HttpStatus.OK.value()).anyTimes();
    EasyMock.expect(httpResponse2.getHeaders()).andReturn(headers).anyTimes();
    EasyMock.expect(httpResponse2.getBody()).andReturn(response2Stream).once();
    httpResponse2.close();
    EasyMock.expectLastCall().once();

    ClientHttpRequest httpRequest2 = EasyMock.createMock(ClientHttpRequest.class);
    EasyMock.expect(httpRequest2.getHeaders()).andReturn(headers).anyTimes();
    EasyMock.expect(httpRequest2.getBody()).andReturn(new NullOutputStream()).times(0, 2);
    EasyMock.expect(httpRequest2.execute()).andReturn(httpResponse2).once();

    ClientHttpRequestFactory mockFactory = EasyMock.createStrictMock(ClientHttpRequestFactory.class);
    EasyMock.expect(mockFactory.createRequest(updateUri, HttpMethod.POST)).andReturn(httpRequest1).once();
    EasyMock.expect(mockFactory.createRequest(retrieveUri, HttpMethod.POST)).andReturn(httpRequest2).once();

    restTemplate.setRequestFactory(mockFactory);

    EasyMock.replay(httpResponse1, httpRequest1, httpResponse2, httpRequest2, mockFactory);

    api.updateAll(artifacts);

    assertEquals("Wrong number of artifacts", uriOrder.size(), artifacts.size());

    for (int i = 0; i < uriOrder.size(); i++) {
        assertEquals("Artifact " + i + " wrong:", uriOrder.get(i), artifacts.get(i).getUri());
    }

    EasyMock.verify(httpResponse2, httpRequest2, mockFactory);
}