iSharkFly-Docs/java-tutorials
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

minor cleanup

Browse Source
This commit is contained in:
eugenp 2015-09-18 16:27:13 +03:00
parent 1722004831
commit cd5d4527c5
1 changed files with 55 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

100
spring-security-rest-full/src/test/java/org/baeldung/client/RestTemplateLiveTest.java
View File

@ -53,7 +53,7 @@ public class RestTemplateLiveTest {
restTemplate = new RestTemplate(getClientHttpRequestFactory()); restTemplate = new RestTemplate(getClientHttpRequestFactory());
messageConverters = new ArrayList<>(); messageConverters = new ArrayList<>();
MappingJackson2HttpMessageConverter jsonMessageConverter = new MappingJackson2HttpMessageConverter(); final MappingJackson2HttpMessageConverter jsonMessageConverter = new MappingJackson2HttpMessageConverter();
jsonMessageConverter.setObjectMapper(new ObjectMapper()); jsonMessageConverter.setObjectMapper(new ObjectMapper());
messageConverters.add(jsonMessageConverter); messageConverters.add(jsonMessageConverter);
@ -62,45 +62,45 @@ public class RestTemplateLiveTest {
@Test @Test
public void givenResourceUrl_whenSendGetForRequestEntity_thenStatusOk() throws IOException { public void givenResourceUrl_whenSendGetForRequestEntity_thenStatusOk() throws IOException {
ResponseEntity<String> response = restTemplate.getForEntity(fooResourceUrl + "/1", String.class); final ResponseEntity<String> response = restTemplate.getForEntity(fooResourceUrl + "/1", String.class);
assertThat(response.getStatusCode(), is(HttpStatus.OK)); assertThat(response.getStatusCode(), is(HttpStatus.OK));
} }
@Test @Test
public void givenResourceUrl_whenSendGetForRestEntity_thenReceiveCorrectJson() throws IOException { public void givenResourceUrl_whenSendGetForRestEntity_thenReceiveCorrectJson() throws IOException {
ResponseEntity<String> response = restTemplate.getForEntity(fooResourceUrl + "/1", String.class); final ResponseEntity<String> response = restTemplate.getForEntity(fooResourceUrl + "/1", String.class);
ObjectMapper mapper = new ObjectMapper(); final ObjectMapper mapper = new ObjectMapper();
JsonNode root = mapper.readTree(response.getBody()); final JsonNode root = mapper.readTree(response.getBody());
JsonNode name = root.path("name"); final JsonNode name = root.path("name");
assertThat(name.asText(), is("bar")); assertThat(name.asText(), is("bar"));
JsonNode owner = root.path("id"); final JsonNode owner = root.path("id");
assertThat(owner.asText(), is("1")); assertThat(owner.asText(), is("1"));
} }
@Test @Test
public void givenResourceUrl_whenSendGetForObject_thenReturnsRepoObject() { public void givenResourceUrl_whenSendGetForObject_thenReturnsRepoObject() {
restTemplate.setMessageConverters(messageConverters); restTemplate.setMessageConverters(messageConverters);
Foo foo = restTemplate.getForObject(fooResourceUrl + "/1", Foo.class); final Foo foo = restTemplate.getForObject(fooResourceUrl + "/1", Foo.class);
assertThat(foo.getName(), is("bar")); assertThat(foo.getName(), is("bar"));
assertThat(foo.getId(), is(1L)); assertThat(foo.getId(), is(1L));
} }
@Test @Test
public void givenFooService_whenPostForObject_thenCreatedObjectIsReturned() { public void givenFooService_whenPostForObject_thenCreatedObjectIsReturned() {
HttpEntity<Foo> request = new HttpEntity<>(new Foo("bar")); final HttpEntity<Foo> request = new HttpEntity<>(new Foo("bar"));
Foo foo = restTemplate.postForObject(fooResourceUrl, request, Foo.class); final Foo foo = restTemplate.postForObject(fooResourceUrl, request, Foo.class);
assertThat(foo, notNullValue()); assertThat(foo, notNullValue());
assertThat(foo.getName(), is("bar")); assertThat(foo.getName(), is("bar"));
} }
@Test @Test
public void givenFooService_whenPostFor2Objects_thenNewObjectIsCreatedEachTime() { public void givenFooService_whenPostFor2Objects_thenNewObjectIsCreatedEachTime() {
HttpEntity<Foo> request = new HttpEntity<>(new Foo("bar")); final HttpEntity<Foo> request = new HttpEntity<>(new Foo("bar"));
Foo firstInstance = restTemplate.postForObject(fooResourceUrl, request, Foo.class); final Foo firstInstance = restTemplate.postForObject(fooResourceUrl, request, Foo.class);
Foo secondInstance = restTemplate.postForObject(fooResourceUrl, request, Foo.class); final Foo secondInstance = restTemplate.postForObject(fooResourceUrl, request, Foo.class);
assertThat(firstInstance, notNullValue()); assertThat(firstInstance, notNullValue());
assertThat(secondInstance, notNullValue()); assertThat(secondInstance, notNullValue());
assertThat(firstInstance.getId(), not(secondInstance.getId())); assertThat(firstInstance.getId(), not(secondInstance.getId()));
@ -108,77 +108,77 @@ public class RestTemplateLiveTest {
@Test @Test
public void givenFooService_whenCallHeadForHeaders_thenReceiveAllHeadersForThatResource() { public void givenFooService_whenCallHeadForHeaders_thenReceiveAllHeadersForThatResource() {
HttpHeaders httpHeaders = restTemplate.headForHeaders(fooResourceUrl); final HttpHeaders httpHeaders = restTemplate.headForHeaders(fooResourceUrl);
assertTrue(httpHeaders.getContentType().includes(MediaType.APPLICATION_JSON)); assertTrue(httpHeaders.getContentType().includes(MediaType.APPLICATION_JSON));
assertTrue(httpHeaders.get("bar").contains("baz")); assertTrue(httpHeaders.get("bar").contains("baz"));
} }
@Test @Test
public void givenFooService_whenCallOptionsForAllow_thenReceiveValueOfAllowHeader() { public void givenFooService_whenCallOptionsForAllow_thenReceiveValueOfAllowHeader() {
Set<HttpMethod> optionsForAllow = restTemplate.optionsForAllow(fooResourceUrl); final Set<HttpMethod> optionsForAllow = restTemplate.optionsForAllow(fooResourceUrl);
HttpMethod[] supportedMethods = {HttpMethod.GET, HttpMethod.POST, HttpMethod.PUT, HttpMethod.DELETE}; final HttpMethod[] supportedMethods = { HttpMethod.GET, HttpMethod.POST, HttpMethod.PUT, HttpMethod.DELETE };
assertTrue(optionsForAllow.containsAll(Arrays.asList(supportedMethods))); assertTrue(optionsForAllow.containsAll(Arrays.asList(supportedMethods)));
} }
@Test @Test
public void givenFooService_whenPostResource_thenResourceIsCreated() { public void givenFooService_whenPostResource_thenResourceIsCreated() {
RestTemplate template = new RestTemplate(); final RestTemplate template = new RestTemplate();
HttpHeaders headers = prepareBasicAuthHeaders(); final HttpHeaders headers = prepareBasicAuthHeaders();
HttpEntity<Foo> request = new HttpEntity<>(new Foo("bar"), headers); final HttpEntity<Foo> request = new HttpEntity<>(new Foo("bar"), headers);
ResponseEntity<Foo> response = template.exchange(fooResourceUrl, HttpMethod.POST, request, Foo.class); final ResponseEntity<Foo> response = template.exchange(fooResourceUrl, HttpMethod.POST, request, Foo.class);
assertThat(response.getStatusCode(), is(HttpStatus.CREATED)); assertThat(response.getStatusCode(), is(HttpStatus.CREATED));
Foo foo = response.getBody(); final Foo foo = response.getBody();
assertThat(foo, notNullValue()); assertThat(foo, notNullValue());
assertThat(foo.getName(), is("bar")); assertThat(foo.getName(), is("bar"));
} }
@Test @Test
public void givenFooService_whenPutExistingEntity_thenItIsUpdated() { public void givenFooService_whenPutExistingEntity_thenItIsUpdated() {
RestTemplate template = new RestTemplate(); final RestTemplate template = new RestTemplate();
HttpHeaders headers = prepareBasicAuthHeaders(); final HttpHeaders headers = prepareBasicAuthHeaders();
HttpEntity<Foo> request = new HttpEntity<>(new Foo("bar"), headers); final HttpEntity<Foo> request = new HttpEntity<>(new Foo("bar"), headers);
//Create entity // Create entity
ResponseEntity<Foo> response = template.exchange(fooResourceUrl, HttpMethod.POST, request, Foo.class); ResponseEntity<Foo> response = template.exchange(fooResourceUrl, HttpMethod.POST, request, Foo.class);
assertThat(response.getStatusCode(), is(HttpStatus.CREATED)); assertThat(response.getStatusCode(), is(HttpStatus.CREATED));
//Update entity // Update entity
Foo updatedInstance = new Foo("newName"); final Foo updatedInstance = new Foo("newName");
updatedInstance.setId(response.getBody().getId()); updatedInstance.setId(response.getBody().getId());
String resourceUrl = fooResourceUrl + '/' + response.getBody().getId(); final String resourceUrl = fooResourceUrl + '/' + response.getBody().getId();
template.execute(resourceUrl, HttpMethod.PUT, requestCallback(updatedInstance), clientHttpResponse -> null); template.execute(resourceUrl, HttpMethod.PUT, requestCallback(updatedInstance), clientHttpResponse -> null);
//Check that entity was updated // Check that entity was updated
response = template.exchange(resourceUrl, HttpMethod.GET, new HttpEntity<>(headers), Foo.class); response = template.exchange(resourceUrl, HttpMethod.GET, new HttpEntity<>(headers), Foo.class);
Foo foo = response.getBody(); final Foo foo = response.getBody();
assertThat(foo.getName(), is(updatedInstance.getName())); assertThat(foo.getName(), is(updatedInstance.getName()));
} }
@Test @Test
public void givenFooService_whenCallDelete_thenEntityIsRemoved() { public void givenFooService_whenCallDelete_thenEntityIsRemoved() {
Foo foo = new Foo("remove me"); final Foo foo = new Foo("remove me");
ResponseEntity<Foo> response = restTemplate.postForEntity(fooResourceUrl, foo, Foo.class); final ResponseEntity<Foo> response = restTemplate.postForEntity(fooResourceUrl, foo, Foo.class);
assertThat(response.getStatusCode(), is(HttpStatus.CREATED)); assertThat(response.getStatusCode(), is(HttpStatus.CREATED));
String entityUrl = fooResourceUrl + "/" + response.getBody().getId(); final String entityUrl = fooResourceUrl + "/" + response.getBody().getId();
restTemplate.delete(entityUrl); restTemplate.delete(entityUrl);
try { try {
restTemplate.getForEntity(entityUrl, Foo.class); restTemplate.getForEntity(entityUrl, Foo.class);
fail(); fail();
} catch (HttpClientErrorException ex) { } catch (final HttpClientErrorException ex) {
assertThat(ex.getStatusCode(), is(HttpStatus.NOT_FOUND)); assertThat(ex.getStatusCode(), is(HttpStatus.NOT_FOUND));
} }
} }
private void ensureOneEntityExists() { private void ensureOneEntityExists() {
Foo instance = new Foo("bar"); final Foo instance = new Foo("bar");
instance.setId(1L); instance.setId(1L);
try { try {
restTemplate.getForEntity(fooResourceUrl + "/1", Foo.class); restTemplate.getForEntity(fooResourceUrl + "/1", Foo.class);
} catch (HttpClientErrorException ex) { } catch (final HttpClientErrorException ex) {
if (ex.getStatusCode() == HttpStatus.NOT_FOUND) { if (ex.getStatusCode() == HttpStatus.NOT_FOUND) {
restTemplate.postForEntity(fooResourceUrl, instance, Foo.class); restTemplate.postForEntity(fooResourceUrl, instance, Foo.class);
} }
@ -187,39 +187,33 @@ public class RestTemplateLiveTest {
} }
private ClientHttpRequestFactory getClientHttpRequestFactory() { private ClientHttpRequestFactory getClientHttpRequestFactory() {
int timeout = 5; final int timeout = 5;
RequestConfig config = RequestConfig.custom() final RequestConfig config = RequestConfig.custom().setConnectTimeout(timeout * 1000).setConnectionRequestTimeout(timeout * 1000).setSocketTimeout(timeout * 1000).build();
.setConnectTimeout(timeout * 1000)
.setConnectionRequestTimeout(timeout * 1000)
.setSocketTimeout(timeout * 1000).build();
BasicCredentialsProvider credentialsProvider = new BasicCredentialsProvider(); final BasicCredentialsProvider credentialsProvider = new BasicCredentialsProvider();
credentialsProvider.setCredentials(new AuthScope("localhost", APPLICATION_PORT, AuthScope.ANY_REALM), credentialsProvider.setCredentials(new AuthScope("localhost", APPLICATION_PORT, AuthScope.ANY_REALM), new UsernamePasswordCredentials("user1", "user1Pass"));
new UsernamePasswordCredentials("user1", "user1Pass"));
CloseableHttpClient client = HttpClientBuilder.create() final CloseableHttpClient client = HttpClientBuilder.create().setDefaultRequestConfig(config).setDefaultCredentialsProvider(credentialsProvider).build();
.setDefaultRequestConfig(config)
.setDefaultCredentialsProvider(credentialsProvider).build();
return new HttpComponentsClientHttpRequestFactory(client); return new HttpComponentsClientHttpRequestFactory(client);
} }
private HttpHeaders prepareBasicAuthHeaders() { private HttpHeaders prepareBasicAuthHeaders() {
HttpHeaders headers = new HttpHeaders(); final HttpHeaders headers = new HttpHeaders();
String encodedLogPass = getBase64EncodedLogPass(); final String encodedLogPass = getBase64EncodedLogPass();
headers.add(HttpHeaders.AUTHORIZATION, "Basic " + encodedLogPass); headers.add(HttpHeaders.AUTHORIZATION, "Basic " + encodedLogPass);
return headers; return headers;
} }
private String getBase64EncodedLogPass() { private String getBase64EncodedLogPass() {
String logPass = "user1:user1Pass"; final String logPass = "user1:user1Pass";
byte[] authHeaderBytes = encodeBase64(logPass.getBytes(Charsets.US_ASCII)); final byte[] authHeaderBytes = encodeBase64(logPass.getBytes(Charsets.US_ASCII));
return new String(authHeaderBytes, Charsets.US_ASCII); return new String(authHeaderBytes, Charsets.US_ASCII);
} }
private RequestCallback requestCallback(Foo updatedInstance) { private RequestCallback requestCallback(final Foo updatedInstance) {
return clientHttpRequest -> { return clientHttpRequest -> {
ObjectMapper mapper = new ObjectMapper(); final ObjectMapper mapper = new ObjectMapper();
mapper.writeValue(clientHttpRequest.getBody(), updatedInstance); mapper.writeValue(clientHttpRequest.getBody(), updatedInstance);
clientHttpRequest.getHeaders().add(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE); clientHttpRequest.getHeaders().add(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE);
clientHttpRequest.getHeaders().add(HttpHeaders.AUTHORIZATION, "Basic " + getBase64EncodedLogPass()); clientHttpRequest.getHeaders().add(HttpHeaders.AUTHORIZATION, "Basic " + getBase64EncodedLogPass());