[RestTemplate] Create unit test for delete() method

- Refactor RestTemplateClientTest

Author: Dmitry Zinkevich

spring-security-rest-full/src/main/java/org/baeldung/persistence/model/Owner.java

@@ -1,9 +1,6 @@
 package org.baeldung.web.controller;
 
-import java.util.List;
-
-import javax.servlet.http.HttpServletResponse;
-
+import com.google.common.base.Preconditions;
 import org.baeldung.persistence.model.Foo;
 import org.baeldung.persistence.service.IFooService;
 import org.baeldung.web.exception.MyResourceNotFoundException;
@@ -15,17 +12,13 @@
 import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.data.domain.Page;
 import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
 import org.springframework.stereotype.Controller;
-import org.springframework.web.bind.annotation.PathVariable;
-import org.springframework.web.bind.annotation.RequestBody;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RequestMethod;
-import org.springframework.web.bind.annotation.RequestParam;
-import org.springframework.web.bind.annotation.ResponseBody;
-import org.springframework.web.bind.annotation.ResponseStatus;
+import org.springframework.web.bind.annotation.*;
 import org.springframework.web.util.UriComponentsBuilder;
 
-import com.google.common.base.Preconditions;
+import javax.servlet.http.HttpServletResponse;
+import java.util.List;
 
 @Controller
 @RequestMapping(value = "/foos")
@@ -110,4 +103,11 @@ public void delete(@PathVariable("id") final Long id) {
         service.deleteById(id);
     }
 
+    @RequestMapping(method = RequestMethod.HEAD)
+    @ResponseStatus(HttpStatus.OK)
+    public void head(HttpServletResponse resp) {
+        resp.setContentType(MediaType.APPLICATION_JSON_VALUE);
+        resp.setHeader("bar", "baz");
+    }
+
 }

spring-security-rest-full/src/main/java/org/baeldung/persistence/model/Repository.java

@@ -10,144 +10,119 @@
 import org.apache.http.impl.client.CloseableHttpClient;
 import org.apache.http.impl.client.HttpClientBuilder;
 import org.baeldung.persistence.model.Foo;
-import org.baeldung.persistence.model.Repository;
+import org.baeldung.persistence.service.IFooService;
 import org.baeldung.spring.PersistenceConfig;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.*;
 import org.springframework.http.client.ClientHttpRequestFactory;
 import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
 import org.springframework.http.converter.HttpMessageConverter;
 import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.web.client.HttpClientErrorException;
 import org.springframework.web.client.RequestCallback;
 import org.springframework.web.client.RestTemplate;
 
 import java.io.IOException;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Set;
 
 import static org.apache.commons.codec.binary.Base64.encodeBase64;
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.contains;
 import static org.hamcrest.Matchers.notNullValue;
 import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
 @RunWith(SpringJUnit4ClassRunner.class)
-@ContextConfiguration(classes = { PersistenceConfig.class })
+@ContextConfiguration(classes = {PersistenceConfig.class})
 public class RestTemplateLiveTest {
 
     RestTemplate restTemplate;
     private List<HttpMessageConverter<?>> messageConverters;
-    private final String userReposUrl = "https://api.github.com/users/eugenp/repos";
-    private final String repoUrl = "https://api.github.com/repos/eugenp/tutorials";
-    private final String fooService = "http://localhost:8080/spring-security-rest-full/foos";
+    private static final String fooResourceUrl = "http://localhost:8080/spring-security-rest-full/foos";
+
+    @Autowired
+    private IFooService fooService;
 
     @Before
     public void beforeTest() {
-        restTemplate = new RestTemplate();
+        restTemplate = new RestTemplate(getClientHttpRequestFactory());
 
         messageConverters = new ArrayList<>();
         MappingJackson2HttpMessageConverter jsonMessageConverter = new MappingJackson2HttpMessageConverter();
         jsonMessageConverter.setObjectMapper(new ObjectMapper());
         messageConverters.add(jsonMessageConverter);
+
+        ensureOneEntityExists();
     }
 
     @Test
     public void givenValidEndpoint_whenSendGetForRequestEntity_thenStatusOk() throws IOException {
-        ResponseEntity<String> response = restTemplate.getForEntity(userReposUrl, String.class);
+        ResponseEntity<String> response = restTemplate.getForEntity(fooResourceUrl + "/1", String.class);
         assertThat(response.getStatusCode(), is(HttpStatus.OK));
     }
 
     @Test
-    public void givenRepoEndpoint_whenSendGetForRestEntity_thenReceiveCorrectRepoJson() throws IOException {
-        ResponseEntity<String> response = restTemplate.getForEntity(repoUrl, String.class);
+    public void givenRepoEndpoint_whenSendGetForRestEntity_thenReceiveCorrectJson() throws IOException {
+        ResponseEntity<String> response = restTemplate.getForEntity(fooResourceUrl + "/1", String.class);
 
         ObjectMapper mapper = new ObjectMapper();
         JsonNode root = mapper.readTree(response.getBody());
 
         JsonNode name = root.path("name");
-        assertThat(name.asText(), is("tutorials"));
+        assertThat(name.asText(), is("bar"));
 
-        JsonNode owner = root.path("owner").path("login");
-        assertThat(owner.asText(), is("eugenp"));
+        JsonNode owner = root.path("id");
+        assertThat(owner.asText(), is("1"));
     }
 
     @Test
     public void givenRepoEndpoint_whenSendGetForObject_thenReturnsRepoObject() {
         restTemplate.setMessageConverters(messageConverters);
-        String repoUrl = "https://api.github.com/repos/eugenp/tutorials";
-        Repository repository = restTemplate.getForObject(repoUrl, Repository.class);
-
-        assertThat(repository.getName(), is("tutorials"));
-        assertThat(repository.getOwner().getLogin(), is("eugenp"));
+        Foo foo = restTemplate.getForObject(fooResourceUrl + "/1", Foo.class);
+        assertThat(foo.getName(), is("bar"));
+        assertThat(foo.getId(), is(1L));
     }
 
     @Test
     public void givenFooService_whenPostForObject_thenCreatedObjectIsReturned() {
-        String fooService = "http://localhost:8080/spring-security-rest-full/foos";
-
-        ClientHttpRequestFactory requestFactory = getClientHttpRequestFactory();
-        RestTemplate restTemplate = new RestTemplate(requestFactory);
-
         HttpEntity<Foo> request = new HttpEntity<>(new Foo("bar"));
-        Foo foo = restTemplate.postForObject(fooService, request, Foo.class);
+        Foo foo = restTemplate.postForObject(fooResourceUrl, request, Foo.class);
         assertThat(foo, notNullValue());
         assertThat(foo.getName(), is("bar"));
     }
 
     @Test
     public void givenFooService_whenPostFor2Objects_thenNewObjectIsCreatedEachTime() {
-        String fooService = "http://localhost:8080/spring-security-rest-full/foos";
-
         ClientHttpRequestFactory requestFactory = getClientHttpRequestFactory();
         RestTemplate restTemplate = new RestTemplate(requestFactory);
 
         HttpEntity<Foo> request = new HttpEntity<>(new Foo("bar"));
-        Foo firstInstance = restTemplate.postForObject(fooService, request, Foo.class);
-        Foo secondInstance = restTemplate.postForObject(fooService, request, Foo.class);
+        Foo firstInstance = restTemplate.postForObject(fooResourceUrl, request, Foo.class);
+        Foo secondInstance = restTemplate.postForObject(fooResourceUrl, request, Foo.class);
         assertThat(firstInstance, notNullValue());
         assertThat(secondInstance, notNullValue());
         assertThat(firstInstance.getId(), not(secondInstance.getId()));
     }
 
-    private ClientHttpRequestFactory getClientHttpRequestFactory() {
-        int timeout = 5;
-        RequestConfig config = RequestConfig.custom()
-                .setConnectTimeout(timeout * 1000)
-                .setConnectionRequestTimeout(timeout * 1000)
-                .setSocketTimeout(timeout * 1000).build();
-
-        BasicCredentialsProvider credentialsProvider = new BasicCredentialsProvider();
-        credentialsProvider.setCredentials(new AuthScope("localhost", 8080, AuthScope.ANY_REALM),
-                new UsernamePasswordCredentials("user1", "user1Pass"));
-
-        CloseableHttpClient client = HttpClientBuilder.create()
-                .setDefaultRequestConfig(config)
-                .setDefaultCredentialsProvider(credentialsProvider).build();
-
-        return new HttpComponentsClientHttpRequestFactory(client);
-    }
-
     @Test
     public void givenResource_whenCallHeadForHeaders_thenReceiveAllHeadersForThatResource() {
-        String repoUrl = "https://api.github.com/repos/eugenp/{repoName}";
-        RestTemplate template = new RestTemplate();
-
-        Map<String, Object> uriVariables = new HashMap<>();
-        uriVariables.put("repoName", "tutorials");
-
-        HttpHeaders httpHeaders = template.headForHeaders(repoUrl, uriVariables);
+        HttpHeaders httpHeaders = restTemplate.headForHeaders(fooResourceUrl);
         assertTrue(httpHeaders.getContentType().includes(MediaType.APPLICATION_JSON));
-        assertThat(httpHeaders.get("X-RateLimit-Limit"), contains("60"));
+        assertTrue(httpHeaders.get("foo").contains("bar"));
     }
 
     @Test
     public void givenResource_whenCallOptionsForAllow_thenReceiveValueOfAllowHeader() {
-        RestTemplate template = new RestTemplate(getClientHttpRequestFactory());
-        Set<HttpMethod> optionsForAllow = template.optionsForAllow(fooService);
+        Set<HttpMethod> optionsForAllow = restTemplate.optionsForAllow(fooResourceUrl);
         HttpMethod[] supportedMethods = {HttpMethod.GET, HttpMethod.POST, HttpMethod.PUT, HttpMethod.DELETE};
         assertTrue(optionsForAllow.containsAll(Arrays.asList(supportedMethods)));
     }
@@ -159,25 +134,11 @@ public void givenRestService_whenPostResource_thenResourceIsCreated() {
         HttpHeaders headers = prepareBasicAuthHeaders();
         HttpEntity<Foo> request = new HttpEntity<>(new Foo("bar"), headers);
 
-        ResponseEntity<Foo> response = restTemplate.exchange(fooService, HttpMethod.POST, request, Foo.class);
+        ResponseEntity<Foo> response = restTemplate.exchange(fooResourceUrl, HttpMethod.POST, request, Foo.class);
         assertThat(response.getStatusCode(), is(HttpStatus.CREATED));
         Foo foo = response.getBody();
         assertThat(foo, notNullValue());
         assertThat(foo.getName(), is("bar"));
-        assertThat(foo.getId(), is(1L));
-    }
-
-    private HttpHeaders prepareBasicAuthHeaders() {
-        HttpHeaders headers = new HttpHeaders();
-        String encodedLogPass = getBase64EncodedLogPass();
-        headers.add(HttpHeaders.AUTHORIZATION, "Basic " + encodedLogPass);
-        return headers;
-    }
-
-    private String getBase64EncodedLogPass() {
-        String logPass = "user1:user1Pass";
-        byte[] authHeaderBytes = encodeBase64(logPass.getBytes(Charsets.US_ASCII));
-        return new String(authHeaderBytes, Charsets.US_ASCII);
     }
 
     @Test
@@ -187,23 +148,71 @@ public void givenResource_whenPutExistingEntity_thenItIsUpdated() {
         HttpEntity<Foo> request = new HttpEntity<>(new Foo("bar"), headers);
 
         //Create entity
-        ResponseEntity<Foo> response = restTemplate.exchange(fooService, HttpMethod.POST, request, Foo.class);
+        ResponseEntity<Foo> response = restTemplate.exchange(fooResourceUrl, HttpMethod.POST, request, Foo.class);
         assertThat(response.getStatusCode(), is(HttpStatus.CREATED));
-        assertThat(response.getBody().getId(), is(1L));
 
         //Update entity
         Foo updatedInstance = new Foo("newName");
-        updatedInstance.setId(1);
-        String resourceUrl = fooService + "/1";
+        updatedInstance.setId(response.getBody().getId());
+        String resourceUrl = fooResourceUrl + '/' + response.getBody().getId();
         restTemplate.execute(resourceUrl, HttpMethod.PUT, requestCallback(updatedInstance), clientHttpResponse -> null);
 
         //Check that entity was updated
         response = restTemplate.exchange(resourceUrl, HttpMethod.GET, new HttpEntity<>(headers), Foo.class);
         Foo foo = response.getBody();
-        assertThat(foo.getId(), is(1L));
         assertThat(foo.getName(), is(updatedInstance.getName()));
     }
 
+    @Test
+    public void givenRestService_whenCallDelete_thenEntityIsRemoved() {
+        String entityUrl = fooResourceUrl + "/1";
+        restTemplate.delete(entityUrl);
+        try {
+            restTemplate.getForEntity(entityUrl, Foo.class);
+            fail();
+        } catch (HttpClientErrorException ex) {
+            assertThat(ex.getStatusCode(), is(HttpStatus.NOT_FOUND));
+        }
+    }
+
+    private void ensureOneEntityExists() {
+        Foo instance = new Foo("bar");
+        if (fooService.findOne(1L) == null) {
+            fooService.create(instance);
+        }
+    }
+
+    private ClientHttpRequestFactory getClientHttpRequestFactory() {
+        int timeout = 5;
+        RequestConfig config = RequestConfig.custom()
+                .setConnectTimeout(timeout * 1000)
+                .setConnectionRequestTimeout(timeout * 1000)
+                .setSocketTimeout(timeout * 1000).build();
+
+        BasicCredentialsProvider credentialsProvider = new BasicCredentialsProvider();
+        credentialsProvider.setCredentials(new AuthScope("localhost", 8080, AuthScope.ANY_REALM),
+                new UsernamePasswordCredentials("user1", "user1Pass"));
+
+        CloseableHttpClient client = HttpClientBuilder.create()
+                .setDefaultRequestConfig(config)
+                .setDefaultCredentialsProvider(credentialsProvider).build();
+
+        return new HttpComponentsClientHttpRequestFactory(client);
+    }
+
+    private HttpHeaders prepareBasicAuthHeaders() {
+        HttpHeaders headers = new HttpHeaders();
+        String encodedLogPass = getBase64EncodedLogPass();
+        headers.add(HttpHeaders.AUTHORIZATION, "Basic " + encodedLogPass);
+        return headers;
+    }
+
+    private String getBase64EncodedLogPass() {
+        String logPass = "user1:user1Pass";
+        byte[] authHeaderBytes = encodeBase64(logPass.getBytes(Charsets.US_ASCII));
+        return new String(authHeaderBytes, Charsets.US_ASCII);
+    }
+
     private RequestCallback requestCallback(Foo updatedInstace) {
         return clientHttpRequest -> {
             ObjectMapper mapper = new ObjectMapper();