Spring/spring-framework
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Polishing

Browse Source
This commit is contained in:
Juergen Hoeller
2014-09-04 00:55:38 +02:00
parent c6d29f1a31
commit 20c2ba35dc
24 changed files with 453 additions and 615 deletions
Download Patch File Download Diff File Expand all files Collapse all files

96
spring-web/src/test/java/org/springframework/http/client/AbstractAsyncHttpRequestFactoryTestCase.java
View File

@@ -17,7 +17,6 @@
package org.springframework.http.client;
import java.io.IOException;
import java.io.OutputStream;
import java.net.URI;
import java.util.Arrays;
import java.util.Locale;
@@ -37,11 +36,11 @@ import org.springframework.util.concurrent.ListenableFutureCallback;
import static org.junit.Assert.*;
public abstract class AbstractAsyncHttpRequestFactoryTestCase extends
AbstractJettyServerTestCase {
public abstract class AbstractAsyncHttpRequestFactoryTestCase extends AbstractJettyServerTestCase {
protected AsyncClientHttpRequestFactory factory;
@Before
public final void createFactory() throws Exception {
factory = createRequestFactory();
@@ -52,6 +51,7 @@ public abstract class AbstractAsyncHttpRequestFactoryTestCase extends
protected abstract AsyncClientHttpRequestFactory createRequestFactory();
@Test
public void status() throws Exception {
URI uri = new URI(baseUrl + "/status/notfound");
@@ -60,8 +60,7 @@ public abstract class AbstractAsyncHttpRequestFactoryTestCase extends
assertEquals("Invalid HTTP URI", uri, request.getURI());
Future<ClientHttpResponse> futureResponse = request.executeAsync();
ClientHttpResponse response = futureResponse.get();
assertEquals("Invalid status code", HttpStatus.NOT_FOUND,
response.getStatusCode());
assertEquals("Invalid status code", HttpStatus.NOT_FOUND, response.getStatusCode());
}
@Test
@@ -70,46 +69,34 @@ public abstract class AbstractAsyncHttpRequestFactoryTestCase extends
AsyncClientHttpRequest request = factory.createAsyncRequest(uri, HttpMethod.GET);
assertEquals("Invalid HTTP method", HttpMethod.GET, request.getMethod());
assertEquals("Invalid HTTP URI", uri, request.getURI());
Future<ClientHttpResponse> futureResponse = request.executeAsync();
if (futureResponse instanceof ListenableFuture) {
ListenableFuture<ClientHttpResponse> listenableFuture =
(ListenableFuture<ClientHttpResponse>) futureResponse;
listenableFuture.addCallback(new ListenableFutureCallback<ClientHttpResponse>() {
@Override
public void onSuccess(ClientHttpResponse result) {
try {
System.out.println("SUCCESS! " + result.getStatusCode());
System.out.println("Callback: " + System.currentTimeMillis());
System.out.println(Thread.currentThread().getId());
assertEquals("Invalid status code", HttpStatus.NOT_FOUND,
result.getStatusCode());
}
catch (IOException e) {
e.printStackTrace(); //To change body of catch statement use File | Settings | File Templates.
}
ListenableFuture<ClientHttpResponse> listenableFuture = request.executeAsync();
listenableFuture.addCallback(new ListenableFutureCallback<ClientHttpResponse>() {
@Override
public void onSuccess(ClientHttpResponse result) {
try {
System.out.println("SUCCESS! " + result.getStatusCode());
System.out.println("Callback: " + System.currentTimeMillis());
System.out.println(Thread.currentThread().getId());
assertEquals("Invalid status code", HttpStatus.NOT_FOUND, result.getStatusCode());
}
@Override
public void onFailure(Throwable t) {
System.out.println("FAILURE: " + t);
catch (IOException ex) {
ex.printStackTrace();
}
});
}
ClientHttpResponse response = futureResponse.get();
}
@Override
public void onFailure(Throwable ex) {
System.out.println("FAILURE: " + ex);
}
});
ClientHttpResponse response = listenableFuture.get();
System.out.println("Main thread: " + System.currentTimeMillis());
assertEquals("Invalid status code", HttpStatus.NOT_FOUND,
response.getStatusCode());
assertEquals("Invalid status code", HttpStatus.NOT_FOUND, response.getStatusCode());
System.out.println(Thread.currentThread().getId());
}
@Test
public void echo() throws Exception {
AsyncClientHttpRequest
request = factory.createAsyncRequest(new URI(baseUrl + "/echo"),
HttpMethod.PUT);
AsyncClientHttpRequest request = factory.createAsyncRequest(new URI(baseUrl + "/echo"), HttpMethod.PUT);
assertEquals("Invalid HTTP method", HttpMethod.PUT, request.getMethod());
String headerName = "MyHeader";
String headerValue1 = "value1";
@@ -118,19 +105,15 @@ public abstract class AbstractAsyncHttpRequestFactoryTestCase extends
request.getHeaders().add(headerName, headerValue2);
final byte[] body = "Hello World".getBytes("UTF-8");
request.getHeaders().setContentLength(body.length);
if (request instanceof StreamingHttpOutputMessage) {
StreamingHttpOutputMessage streamingRequest =
(StreamingHttpOutputMessage) request;
streamingRequest.setBody(new StreamingHttpOutputMessage.Body() {
@Override
public void writeTo(OutputStream outputStream) throws IOException {
StreamUtils.copy(body, outputStream);
}
});
StreamingHttpOutputMessage streamingRequest = (StreamingHttpOutputMessage) request;
streamingRequest.setBody(outputStream -> StreamUtils.copy(body, outputStream));
}
else {
StreamUtils.copy(body, request.getBody());
}
Future<ClientHttpResponse> futureResponse = request.executeAsync();
ClientHttpResponse response = futureResponse.get();
try {
@@ -148,19 +131,12 @@ public abstract class AbstractAsyncHttpRequestFactoryTestCase extends
@Test(expected = IllegalStateException.class)
public void multipleWrites() throws Exception {
AsyncClientHttpRequest
request = factory.createAsyncRequest(new URI(baseUrl + "/echo"),
HttpMethod.POST);
AsyncClientHttpRequest request = factory.createAsyncRequest(new URI(baseUrl + "/echo"), HttpMethod.POST);
final byte[] body = "Hello World".getBytes("UTF-8");
if (request instanceof StreamingHttpOutputMessage) {
StreamingHttpOutputMessage streamingRequest =
(StreamingHttpOutputMessage) request;
streamingRequest.setBody(new StreamingHttpOutputMessage.Body() {
@Override
public void writeTo(OutputStream outputStream) throws IOException {
StreamUtils.copy(body, outputStream);
}
});
StreamingHttpOutputMessage streamingRequest = (StreamingHttpOutputMessage) request;
streamingRequest.setBody(outputStream -> StreamUtils.copy(body, outputStream));
}
else {
StreamUtils.copy(body, request.getBody());
@@ -178,9 +154,7 @@ public abstract class AbstractAsyncHttpRequestFactoryTestCase extends
@Test(expected = UnsupportedOperationException.class)
public void headersAfterExecute() throws Exception {
AsyncClientHttpRequest
request = factory.createAsyncRequest(new URI(baseUrl + "/echo"),
HttpMethod.POST);
AsyncClientHttpRequest request = factory.createAsyncRequest(new URI(baseUrl + "/echo"), HttpMethod.POST);
request.getHeaders().add("MyHeader", "value");
byte[] body = "Hello World".getBytes("UTF-8");
FileCopyUtils.copy(body, request.getBody());
@@ -208,9 +182,7 @@ public abstract class AbstractAsyncHttpRequestFactoryTestCase extends
protected void assertHttpMethod(String path, HttpMethod method) throws Exception {
ClientHttpResponse response = null;
try {
AsyncClientHttpRequest request = factory.createAsyncRequest(
new URI(baseUrl + "/methods/" + path), method);
AsyncClientHttpRequest request = factory.createAsyncRequest(new URI(baseUrl + "/methods/" + path), method);
Future<ClientHttpResponse> futureResponse = request.executeAsync();
response = futureResponse.get();
assertEquals("Invalid response status", HttpStatus.OK, response.getStatusCode());

315
spring-web/src/test/java/org/springframework/web/client/AsyncRestTemplateIntegrationTests.java
View File

@@ -16,16 +16,12 @@
package org.springframework.web.client;
import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.net.URISyntaxException;
import java.nio.charset.Charset;
import java.util.EnumSet;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import static org.junit.Assert.*;
import org.junit.Before;
import org.junit.Test;
@@ -43,6 +39,8 @@ import org.springframework.util.MultiValueMap;
import org.springframework.util.concurrent.ListenableFuture;
import org.springframework.util.concurrent.ListenableFutureCallback;
import static org.junit.Assert.*;
/**
* @author Arjen Poutsma
* @author Sebastien Deleuze
@@ -51,16 +49,17 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
private AsyncRestTemplate template;
@Before
public void createTemplate() {
template = new AsyncRestTemplate(
new HttpComponentsAsyncClientHttpRequestFactory());
template = new AsyncRestTemplate(new HttpComponentsAsyncClientHttpRequestFactory());
}
@Test
public void getEntity() throws ExecutionException, InterruptedException {
Future<ResponseEntity<String>>
futureEntity = template.getForEntity(baseUrl + "/{method}", String.class, "get");
public void getEntity() throws Exception {
Future<ResponseEntity<String>> futureEntity =
template.getForEntity(baseUrl + "/{method}", String.class, "get");
ResponseEntity<String> entity = futureEntity.get();
assertEquals("Invalid content", helloWorld, entity.getBody());
assertFalse("No headers", entity.getHeaders().isEmpty());
@@ -69,17 +68,17 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
}
@Test
public void multipleFutureGets() throws ExecutionException, InterruptedException {
Future<ResponseEntity<String>>
futureEntity = template.getForEntity(baseUrl + "/{method}", String.class, "get");
public void multipleFutureGets() throws Exception {
Future<ResponseEntity<String>> futureEntity =
template.getForEntity(baseUrl + "/{method}", String.class, "get");
futureEntity.get();
futureEntity.get();
}
@Test
public void getEntityCallback() throws ExecutionException, InterruptedException {
ListenableFuture<ResponseEntity<String>>
futureEntity = template.getForEntity(baseUrl + "/{method}", String.class, "get");
public void getEntityCallback() throws Exception {
ListenableFuture<ResponseEntity<String>> futureEntity =
template.getForEntity(baseUrl + "/{method}", String.class, "get");
futureEntity.addCallback(new ListenableFutureCallback<ResponseEntity<String>>() {
@Override
public void onSuccess(ResponseEntity<String> entity) {
@@ -88,10 +87,9 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
assertEquals("Invalid content-type", textContentType, entity.getHeaders().getContentType());
assertEquals("Invalid status code", HttpStatus.OK, entity.getStatusCode());
}
@Override
public void onFailure(Throwable t) {
fail(t.getMessage());
public void onFailure(Throwable ex) {
fail(ex.getMessage());
}
});
// wait till done
@@ -100,80 +98,70 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
}
@Test
public void getEntityCallbackWithLambdas() throws ExecutionException, InterruptedException {
ListenableFuture<ResponseEntity<String>>
futureEntity = template.getForEntity(baseUrl + "/{method}", String.class, "get");
public void getEntityCallbackWithLambdas() throws Exception {
ListenableFuture<ResponseEntity<String>> futureEntity =
template.getForEntity(baseUrl + "/{method}", String.class, "get");
futureEntity.addCallback((entity) -> {
assertEquals("Invalid content", helloWorld, entity.getBody());
assertFalse("No headers", entity.getHeaders().isEmpty());
assertEquals("Invalid content-type", textContentType, entity.getHeaders().getContentType());
assertEquals("Invalid status code", HttpStatus.OK, entity.getStatusCode());
}, (t) -> fail(t.getMessage()));
}, ex -> fail(ex.getMessage()));
// wait till done
while (!futureEntity.isDone()) {
}
}
@Test
public void getNoResponse() throws ExecutionException, InterruptedException {
Future<ResponseEntity<String>>
futureEntity = template.getForEntity(baseUrl + "/get/nothing", String.class);
public void getNoResponse() throws Exception {
Future<ResponseEntity<String>> futureEntity = template.getForEntity(baseUrl + "/get/nothing", String.class);
ResponseEntity<String> entity = futureEntity.get();
assertNull("Invalid content", entity.getBody());
}
@Test
public void getNoContentTypeHeader()
throws UnsupportedEncodingException, ExecutionException,
InterruptedException {
Future<ResponseEntity<byte[]>>
futureEntity = template.getForEntity(baseUrl + "/get/nocontenttype",
byte[].class);
public void getNoContentTypeHeader() throws Exception {
Future<ResponseEntity<byte[]>> futureEntity = template.getForEntity(baseUrl + "/get/nocontenttype", byte[].class);
ResponseEntity<byte[]> responseEntity = futureEntity.get();
assertArrayEquals("Invalid content", helloWorld.getBytes("UTF-8"),
responseEntity.getBody());
assertArrayEquals("Invalid content", helloWorld.getBytes("UTF-8"), responseEntity.getBody());
}
@Test
public void getNoContent() throws ExecutionException, InterruptedException {
Future<ResponseEntity<String>>
responseFuture = template.getForEntity(baseUrl + "/status/nocontent", String.class);
public void getNoContent() throws Exception {
Future<ResponseEntity<String>> responseFuture = template.getForEntity(baseUrl + "/status/nocontent", String.class);
ResponseEntity<String> entity = responseFuture.get();
assertEquals("Invalid response code", HttpStatus.NO_CONTENT, entity.getStatusCode());
assertNull("Invalid content", entity.getBody());
}
@Test
public void getNotModified() throws ExecutionException, InterruptedException {
Future<ResponseEntity<String>>
responseFuture = template.getForEntity(baseUrl + "/status/notmodified",
String.class);
public void getNotModified() throws Exception {
Future<ResponseEntity<String>> responseFuture = template.getForEntity(baseUrl + "/status/notmodified", String.class);
ResponseEntity<String> entity = responseFuture.get();
assertEquals("Invalid response code", HttpStatus.NOT_MODIFIED, entity.getStatusCode());
assertNull("Invalid content", entity.getBody());
}
@Test
public void headForHeaders() throws ExecutionException, InterruptedException {
public void headForHeaders() throws Exception {
Future<HttpHeaders> headersFuture = template.headForHeaders(baseUrl + "/get");
HttpHeaders headers = headersFuture.get();
assertTrue("No Content-Type header", headers.containsKey("Content-Type"));
}
@Test
public void headForHeadersCallback() throws ExecutionException, InterruptedException {
public void headForHeadersCallback() throws Exception {
ListenableFuture<HttpHeaders> headersFuture = template.headForHeaders(baseUrl + "/get");
headersFuture.addCallback(new ListenableFutureCallback<HttpHeaders>() {
@Override
public void onSuccess(HttpHeaders result) {
assertTrue("No Content-Type header", result.containsKey("Content-Type"));
}
@Override
public void onFailure(Throwable t) {
fail(t.getMessage());
public void onFailure(Throwable ex) {
fail(ex.getMessage());
}
});
while (!headersFuture.isDone()) {
@@ -181,46 +169,39 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
}
@Test
public void headForHeadersCallbackWithLambdas() throws ExecutionException, InterruptedException {
public void headForHeadersCallbackWithLambdas() throws Exception {
ListenableFuture<HttpHeaders> headersFuture = template.headForHeaders(baseUrl + "/get");
headersFuture.addCallback(result -> assertTrue("No Content-Type header",
result.containsKey("Content-Type")), t -> fail(t.getMessage()));
result.containsKey("Content-Type")), ex -> fail(ex.getMessage()));
while (!headersFuture.isDone()) {
}
}
@Test
public void postForLocation()
throws URISyntaxException, ExecutionException, InterruptedException {
public void postForLocation() throws Exception {
HttpHeaders entityHeaders = new HttpHeaders();
entityHeaders.setContentType(new MediaType("text", "plain", Charset.forName("ISO-8859-15")));
HttpEntity<String> entity = new HttpEntity<String>(helloWorld, entityHeaders);
Future<URI>
locationFuture = template.postForLocation(baseUrl + "/{method}", entity,
"post");
Future<URI> locationFuture = template.postForLocation(baseUrl + "/{method}", entity, "post");
URI location = locationFuture.get();
assertEquals("Invalid location", new URI(baseUrl + "/post/1"), location);
}
@Test
public void postForLocationCallback()
throws URISyntaxException, ExecutionException, InterruptedException {
public void postForLocationCallback() throws Exception {
HttpHeaders entityHeaders = new HttpHeaders();
entityHeaders.setContentType(new MediaType("text", "plain", Charset.forName("ISO-8859-15")));
HttpEntity<String> entity = new HttpEntity<String>(helloWorld, entityHeaders);
final URI expected = new URI(baseUrl + "/post/1");
ListenableFuture<URI>
locationFuture = template.postForLocation(baseUrl + "/{method}", entity,
"post");
ListenableFuture<URI> locationFuture = template.postForLocation(baseUrl + "/{method}", entity, "post");
locationFuture.addCallback(new ListenableFutureCallback<URI>() {
@Override
public void onSuccess(URI result) {
assertEquals("Invalid location", expected, result);
}
@Override
public void onFailure(Throwable t) {
fail(t.getMessage());
public void onFailure(Throwable ex) {
fail(ex.getMessage());
}
});
while (!locationFuture.isDone()) {
@@ -228,48 +209,40 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
}
@Test
public void postForLocationCallbackWithLambdas()
throws URISyntaxException, ExecutionException, InterruptedException {
public void postForLocationCallbackWithLambdas() throws Exception {
HttpHeaders entityHeaders = new HttpHeaders();
entityHeaders.setContentType(new MediaType("text", "plain", Charset.forName("ISO-8859-15")));
HttpEntity<String> entity = new HttpEntity<String>(helloWorld, entityHeaders);
final URI expected = new URI(baseUrl + "/post/1");
ListenableFuture<URI>
locationFuture = template.postForLocation(baseUrl + "/{method}", entity,
"post");
locationFuture.addCallback(result -> assertEquals("Invalid location", expected, result)
, t -> fail(t.getMessage()));
ListenableFuture<URI> locationFuture = template.postForLocation(baseUrl + "/{method}", entity, "post");
locationFuture.addCallback(result -> assertEquals("Invalid location", expected, result),
ex -> fail(ex.getMessage()));
while (!locationFuture.isDone()) {
}
}
@Test
public void postForEntity()
throws URISyntaxException, ExecutionException, InterruptedException {
public void postForEntity() throws Exception {
HttpEntity<String> requestEntity = new HttpEntity<>(helloWorld);
Future<ResponseEntity<String>>
responseEntityFuture = template.postForEntity(baseUrl + "/{method}", requestEntity,
String.class, "post");
Future<ResponseEntity<String>> responseEntityFuture =
template.postForEntity(baseUrl + "/{method}", requestEntity, String.class, "post");
ResponseEntity<String> responseEntity = responseEntityFuture.get();
assertEquals("Invalid content", helloWorld, responseEntity.getBody());
}
@Test
public void postForEntityCallback()
throws URISyntaxException, ExecutionException, InterruptedException {
public void postForEntityCallback() throws Exception {
HttpEntity<String> requestEntity = new HttpEntity<>(helloWorld);
ListenableFuture<ResponseEntity<String>>
responseEntityFuture = template.postForEntity(baseUrl + "/{method}", requestEntity,
String.class, "post");
ListenableFuture<ResponseEntity<String>> responseEntityFuture =
template.postForEntity(baseUrl + "/{method}", requestEntity, String.class, "post");
responseEntityFuture.addCallback(new ListenableFutureCallback<ResponseEntity<String>>() {
@Override
public void onSuccess(ResponseEntity<String> result) {
assertEquals("Invalid content", helloWorld, result.getBody());
}
@Override
public void onFailure(Throwable t) {
fail(t.getMessage());
public void onFailure(Throwable ex) {
fail(ex.getMessage());
}
});
while (!responseEntityFuture.isDone()) {
@@ -277,44 +250,35 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
}
@Test
public void postForEntityCallbackWithLambdas()
throws URISyntaxException, ExecutionException, InterruptedException {
public void postForEntityCallbackWithLambdas() throws Exception {
HttpEntity<String> requestEntity = new HttpEntity<>(helloWorld);
ListenableFuture<ResponseEntity<String>>
responseEntityFuture = template.postForEntity(baseUrl + "/{method}", requestEntity,
String.class, "post");
responseEntityFuture.addCallback(result -> assertEquals("Invalid content", helloWorld, result.getBody())
, t -> fail(t.getMessage()));
ListenableFuture<ResponseEntity<String>> responseEntityFuture =
template.postForEntity(baseUrl + "/{method}", requestEntity, String.class, "post");
responseEntityFuture.addCallback(result -> assertEquals("Invalid content", helloWorld, result.getBody()),
ex -> fail(ex.getMessage()));
while (!responseEntityFuture.isDone()) {
}
}
@Test
public void put()
throws URISyntaxException, ExecutionException, InterruptedException {
public void put() throws Exception {
HttpEntity<String> requestEntity = new HttpEntity<>(helloWorld);
Future<?>
responseEntityFuture = template.put(baseUrl + "/{method}", requestEntity,
"put");
Future<?> responseEntityFuture = template.put(baseUrl + "/{method}", requestEntity, "put");
responseEntityFuture.get();
}
@Test
public void putCallback()
throws URISyntaxException, ExecutionException, InterruptedException {
public void putCallback() throws Exception {
HttpEntity<String> requestEntity = new HttpEntity<>(helloWorld);
ListenableFuture<?>
responseEntityFuture = template.put(baseUrl + "/{method}", requestEntity,
"put");
ListenableFuture<?> responseEntityFuture = template.put(baseUrl + "/{method}", requestEntity, "put");
responseEntityFuture.addCallback(new ListenableFutureCallback<Object>() {
@Override
public void onSuccess(Object result) {
assertNull(result);
}
@Override
public void onFailure(Throwable t) {
fail(t.getMessage());
public void onFailure(Throwable ex) {
fail(ex.getMessage());
}
});
while (!responseEntityFuture.isDone()) {
@@ -322,26 +286,22 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
}
@Test
public void delete()
throws URISyntaxException, ExecutionException, InterruptedException {
public void delete() throws Exception {
Future<?> deletedFuture = template.delete(new URI(baseUrl + "/delete"));
deletedFuture.get();
}
@Test
public void deleteCallback()
throws URISyntaxException, ExecutionException, InterruptedException {
public void deleteCallback() throws Exception {
ListenableFuture<?> deletedFuture = template.delete(new URI(baseUrl + "/delete"));
deletedFuture.addCallback(new ListenableFutureCallback<Object>() {
@Override
public void onSuccess(Object result) {
assertNull(result);
}
@Override
public void onFailure(Throwable t) {
fail(t.getMessage());
public void onFailure(Throwable ex) {
fail(ex.getMessage());
}
});
while (!deletedFuture.isDone()) {
@@ -349,16 +309,15 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
}
@Test
public void deleteCallbackWithLambdas()
throws URISyntaxException, ExecutionException, InterruptedException {
public void deleteCallbackWithLambdas() throws Exception {
ListenableFuture<?> deletedFuture = template.delete(new URI(baseUrl + "/delete"));
deletedFuture.addCallback(result -> assertNull(result), t -> fail(t.getMessage()));
deletedFuture.addCallback(result -> assertNull(result), ex -> fail(ex.getMessage()));
while (!deletedFuture.isDone()) {
}
}
@Test
public void notFound() throws ExecutionException, InterruptedException {
public void notFound() throws Exception {
try {
Future<?> future = template.execute(baseUrl + "/status/notfound", HttpMethod.GET, null, null);
future.get();
@@ -372,16 +331,13 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
}
@Test
public void notFoundCallback() throws ExecutionException, InterruptedException {
ListenableFuture<?> future =
template.execute(baseUrl + "/status/notfound", HttpMethod.GET, null,
null);
public void notFoundCallback() throws Exception {
ListenableFuture<?> future = template.execute(baseUrl + "/status/notfound", HttpMethod.GET, null, null);
future.addCallback(new ListenableFutureCallback<Object>() {
@Override
public void onSuccess(Object result) {
fail("onSuccess not expected");
}
@Override
public void onFailure(Throwable t) {
assertTrue(t instanceof HttpClientErrorException);
@@ -396,23 +352,21 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
}
@Test
public void notFoundCallbackWithLambdas() throws ExecutionException, InterruptedException {
ListenableFuture<?> future =
template.execute(baseUrl + "/status/notfound", HttpMethod.GET, null,
null);
future.addCallback(result -> fail("onSuccess not expected"), t -> {
assertTrue(t instanceof HttpClientErrorException);
HttpClientErrorException ex = (HttpClientErrorException) t;
assertEquals(HttpStatus.NOT_FOUND, ex.getStatusCode());
assertNotNull(ex.getStatusText());
assertNotNull(ex.getResponseBodyAsString());
public void notFoundCallbackWithLambdas() throws Exception {
ListenableFuture<?> future = template.execute(baseUrl + "/status/notfound", HttpMethod.GET, null, null);
future.addCallback(result -> fail("onSuccess not expected"), ex -> {
assertTrue(ex instanceof HttpClientErrorException);
HttpClientErrorException hcex = (HttpClientErrorException) ex;
assertEquals(HttpStatus.NOT_FOUND, hcex.getStatusCode());
assertNotNull(hcex.getStatusText());
assertNotNull(hcex.getResponseBodyAsString());
});
while (!future.isDone()) {
}
}
@Test
public void serverError() throws ExecutionException, InterruptedException {
public void serverError() throws Exception {
try {
Future<Void> future = template.execute(baseUrl + "/status/server", HttpMethod.GET, null, null);
future.get();
@@ -426,21 +380,20 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
}
@Test
public void serverErrorCallback() throws ExecutionException, InterruptedException {
public void serverErrorCallback() throws Exception {
ListenableFuture<Void> future = template.execute(baseUrl + "/status/server", HttpMethod.GET, null, null);
future.addCallback(new ListenableFutureCallback<Void>() {
@Override
public void onSuccess(Void result) {
fail("onSuccess not expected");
}
@Override
public void onFailure(Throwable t) {
assertTrue(t instanceof HttpServerErrorException);
HttpServerErrorException ex = (HttpServerErrorException) t;
assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, ex.getStatusCode());
assertNotNull(ex.getStatusText());
assertNotNull(ex.getResponseBodyAsString());
public void onFailure(Throwable ex) {
assertTrue(ex instanceof HttpServerErrorException);
HttpServerErrorException hsex = (HttpServerErrorException) ex;
assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, hsex.getStatusCode());
assertNotNull(hsex.getStatusText());
assertNotNull(hsex.getResponseBodyAsString());
}
});
while (!future.isDone()) {
@@ -448,44 +401,39 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
}
@Test
public void serverErrorCallbackWithLambdas() throws ExecutionException, InterruptedException {
public void serverErrorCallbackWithLambdas() throws Exception {
ListenableFuture<Void> future = template.execute(baseUrl + "/status/server", HttpMethod.GET, null, null);
future.addCallback(result -> fail("onSuccess not expected"), t -> {
assertTrue(t instanceof HttpServerErrorException);
HttpServerErrorException ex = (HttpServerErrorException) t;
assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, ex.getStatusCode());
assertNotNull(ex.getStatusText());
assertNotNull(ex.getResponseBodyAsString());
future.addCallback(result -> fail("onSuccess not expected"), ex -> {
assertTrue(ex instanceof HttpServerErrorException);
HttpServerErrorException hsex = (HttpServerErrorException) ex;
assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, hsex.getStatusCode());
assertNotNull(hsex.getStatusText());
assertNotNull(hsex.getResponseBodyAsString());
});
while (!future.isDone()) {
}
}
@Test
public void optionsForAllow()
throws URISyntaxException, ExecutionException, InterruptedException {
Future<Set<HttpMethod>>
allowedFuture = template.optionsForAllow(new URI(baseUrl + "/get"));
public void optionsForAllow() throws Exception {
Future<Set<HttpMethod>> allowedFuture = template.optionsForAllow(new URI(baseUrl + "/get"));
Set<HttpMethod> allowed = allowedFuture.get();
assertEquals("Invalid response",
EnumSet.of(HttpMethod.GET, HttpMethod.OPTIONS, HttpMethod.HEAD, HttpMethod.TRACE), allowed);
}
@Test
public void optionsForAllowCallback()
throws URISyntaxException, ExecutionException, InterruptedException {
ListenableFuture<Set<HttpMethod>>
allowedFuture = template.optionsForAllow(new URI(baseUrl + "/get"));
public void optionsForAllowCallback() throws Exception {
ListenableFuture<Set<HttpMethod>> allowedFuture = template.optionsForAllow(new URI(baseUrl + "/get"));
allowedFuture.addCallback(new ListenableFutureCallback<Set<HttpMethod>>() {
@Override
public void onSuccess(Set<HttpMethod> result) {
assertEquals("Invalid response", EnumSet.of(HttpMethod.GET, HttpMethod.OPTIONS,
HttpMethod.HEAD, HttpMethod.TRACE), result);
}
@Override
public void onFailure(Throwable t) {
fail(t.getMessage());
public void onFailure(Throwable ex) {
fail(ex.getMessage());
}
});
while (!allowedFuture.isDone()) {
@@ -493,13 +441,11 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
}
@Test
public void optionsForAllowCallbackWithLambdas()
throws URISyntaxException, ExecutionException, InterruptedException {
ListenableFuture<Set<HttpMethod>>
allowedFuture = template.optionsForAllow(new URI(baseUrl + "/get"));
public void optionsForAllowCallbackWithLambdas() throws Exception{
ListenableFuture<Set<HttpMethod>> allowedFuture = template.optionsForAllow(new URI(baseUrl + "/get"));
allowedFuture.addCallback(result -> assertEquals("Invalid response",
EnumSet.of(HttpMethod.GET, HttpMethod.OPTIONS, HttpMethod.HEAD,HttpMethod.TRACE), result),
t-> fail(t.getMessage()));
ex -> fail(ex.getMessage()));
while (!allowedFuture.isDone()) {
}
}
@@ -511,8 +457,7 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
requestHeaders.set("MyHeader", "MyValue");
HttpEntity<?> requestEntity = new HttpEntity(requestHeaders);
Future<ResponseEntity<String>> responseFuture =
template.exchange(baseUrl + "/{method}", HttpMethod.GET, requestEntity,
String.class, "get");
template.exchange(baseUrl + "/{method}", HttpMethod.GET, requestEntity, String.class, "get");
ResponseEntity<String> response = responseFuture.get();
assertEquals("Invalid content", helloWorld, response.getBody());
}
@@ -524,17 +469,15 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
requestHeaders.set("MyHeader", "MyValue");
HttpEntity<?> requestEntity = new HttpEntity(requestHeaders);
ListenableFuture<ResponseEntity<String>> responseFuture =
template.exchange(baseUrl + "/{method}", HttpMethod.GET, requestEntity,
String.class, "get");
template.exchange(baseUrl + "/{method}", HttpMethod.GET, requestEntity, String.class, "get");
responseFuture.addCallback(new ListenableFutureCallback<ResponseEntity<String>>() {
@Override
public void onSuccess(ResponseEntity<String> result) {
assertEquals("Invalid content", helloWorld, result.getBody());
}
@Override
public void onFailure(Throwable t) {
fail(t.getMessage());
public void onFailure(Throwable ex) {
fail(ex.getMessage());
}
});
while (!responseFuture.isDone()) {
@@ -548,10 +491,9 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
requestHeaders.set("MyHeader", "MyValue");
HttpEntity<?> requestEntity = new HttpEntity(requestHeaders);
ListenableFuture<ResponseEntity<String>> responseFuture =
template.exchange(baseUrl + "/{method}", HttpMethod.GET, requestEntity,
String.class, "get");
template.exchange(baseUrl + "/{method}", HttpMethod.GET, requestEntity, String.class, "get");
responseFuture.addCallback(result -> assertEquals("Invalid content", helloWorld,
result.getBody()), t -> fail(t.getMessage()));
result.getBody()), ex -> fail(ex.getMessage()));
while (!responseFuture.isDone()) {
}
}
@@ -562,9 +504,8 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
requestHeaders.set("MyHeader", "MyValue");
requestHeaders.setContentType(MediaType.TEXT_PLAIN);
HttpEntity<String> requestEntity = new HttpEntity<String>(helloWorld, requestHeaders);
Future<ResponseEntity<Void>>
resultFuture = template.exchange(baseUrl + "/{method}", HttpMethod.POST,
requestEntity, Void.class, "post");
Future<ResponseEntity<Void>> resultFuture =
template.exchange(baseUrl + "/{method}", HttpMethod.POST, requestEntity, Void.class, "post");
ResponseEntity<Void> result = resultFuture.get();
assertEquals("Invalid location", new URI(baseUrl + "/post/1"),
result.getHeaders().getLocation());
@@ -577,21 +518,18 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
requestHeaders.set("MyHeader", "MyValue");
requestHeaders.setContentType(MediaType.TEXT_PLAIN);
HttpEntity<String> requestEntity = new HttpEntity<String>(helloWorld, requestHeaders);
ListenableFuture<ResponseEntity<Void>>
resultFuture = template.exchange(baseUrl + "/{method}", HttpMethod.POST,
requestEntity, Void.class, "post");
ListenableFuture<ResponseEntity<Void>> resultFuture =
template.exchange(baseUrl + "/{method}", HttpMethod.POST, requestEntity, Void.class, "post");
final URI expected =new URI(baseUrl + "/post/1");
resultFuture.addCallback(new ListenableFutureCallback<ResponseEntity<Void>>() {
@Override
public void onSuccess(ResponseEntity<Void> result) {
assertEquals("Invalid location", expected,
result.getHeaders().getLocation());
assertEquals("Invalid location", expected, result.getHeaders().getLocation());
assertFalse(result.hasBody());
}
@Override
public void onFailure(Throwable t) {
fail(t.getMessage());
public void onFailure(Throwable ex) {
fail(ex.getMessage());
}
});
while (!resultFuture.isDone()) {
@@ -604,21 +542,19 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
requestHeaders.set("MyHeader", "MyValue");
requestHeaders.setContentType(MediaType.TEXT_PLAIN);
HttpEntity<String> requestEntity = new HttpEntity<String>(helloWorld, requestHeaders);
ListenableFuture<ResponseEntity<Void>>
resultFuture = template.exchange(baseUrl + "/{method}", HttpMethod.POST,
requestEntity, Void.class, "post");
ListenableFuture<ResponseEntity<Void>> resultFuture =
template.exchange(baseUrl + "/{method}", HttpMethod.POST, requestEntity, Void.class, "post");
final URI expected =new URI(baseUrl + "/post/1");
resultFuture.addCallback(result -> {
assertEquals("Invalid location", expected, result.getHeaders().getLocation());
assertFalse(result.hasBody());
}, t -> fail(t.getMessage()));
assertEquals("Invalid location", expected, result.getHeaders().getLocation());
assertFalse(result.hasBody());
}, ex -> fail(ex.getMessage()));
while (!resultFuture.isDone()) {
}
}
@Test
public void multipart() throws UnsupportedEncodingException, ExecutionException,
InterruptedException {
public void multipart() throws Exception {
MultiValueMap<String, Object> parts = new LinkedMultiValueMap<String, Object>();
parts.add("name 1", "value 1");
parts.add("name 2", "value 2+1");
@@ -627,8 +563,7 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
parts.add("logo", logo);
HttpEntity<MultiValueMap<String, Object>> requestBody = new HttpEntity<>(parts);
Future<URI> future =
template.postForLocation(baseUrl + "/multipart", requestBody);
Future<URI> future = template.postForLocation(baseUrl + "/multipart", requestBody);
future.get();
}