[BAEL-18364] move spring-rest-*** articles - 1

spring-resttemplate/src/test/java/com/baeldung/pact/PactProviderLiveTest.java

@@ -0,0 +1,41 @@
+package com.baeldung.pact;
+
+import org.junit.BeforeClass;
+import org.junit.runner.RunWith;
+import org.springframework.boot.SpringApplication;
+import org.springframework.web.context.ConfigurableWebApplicationContext;
+
+import com.baeldung.sampleapp.config.MainApplication;
+
+import au.com.dius.pact.provider.junit.PactRunner;
+import au.com.dius.pact.provider.junit.Provider;
+import au.com.dius.pact.provider.junit.State;
+import au.com.dius.pact.provider.junit.loader.PactFolder;
+import au.com.dius.pact.provider.junit.target.HttpTarget;
+import au.com.dius.pact.provider.junit.target.Target;
+import au.com.dius.pact.provider.junit.target.TestTarget;
+
+@RunWith(PactRunner.class)
+@Provider("test_provider")
+@PactFolder("pacts")
+public class PactProviderLiveTest {
+
+    @TestTarget
+    public final Target target = new HttpTarget("http", "localhost", 8082, "/spring-rest");
+
+    private static ConfigurableWebApplicationContext application;
+
+    @BeforeClass
+    public static void start() {
+        application = (ConfigurableWebApplicationContext) SpringApplication.run(MainApplication.class);
+    }
+
+    @State("test GET")
+    public void toGetState() {
+    }
+
+    @State("test POST")
+    public void toPostState() {
+    }
+
+}

spring-resttemplate/src/test/java/com/baeldung/propertyeditor/creditcard/CreditCardEditorUnitTest.java

@@ -0,0 +1,41 @@
+package com.baeldung.propertyeditor.creditcard;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class CreditCardEditorUnitTest {
+    
+    private CreditCardEditor creditCardEditor;
+    
+    @Before
+    public void setup() {
+        creditCardEditor = new CreditCardEditor();
+    }
+    
+    @Test(expected=IllegalArgumentException.class)
+    public void whenInvalidCardNoWithLessDigits_thenThrowsException() {
+        creditCardEditor.setAsText("123-123-123-123");
+    }
+    
+    @Test(expected=IllegalArgumentException.class)
+    public void whenInvalidCardNoWithNonDigits_thenThrowsException() {
+        creditCardEditor.setAsText("1234-1234-xxxx-yyyy");
+    }
+    
+    @Test
+    public void whenCardNoWithNonDigits_parseCreditCard() {
+        creditCardEditor.setAsText("1234-5678-9123-4560");
+        
+        CreditCard creditCard = (CreditCard) creditCardEditor.getValue();
+        Assert.assertNotNull(creditCard);
+        
+        Assert.assertEquals(123456, creditCard.getBankIdNo().intValue());
+        Assert.assertEquals(789123456, creditCard.getAccountNo().intValue());
+        Assert.assertEquals(0, creditCard.getCheckCode().intValue());
+    }
+
+}

spring-resttemplate/src/test/java/com/baeldung/resttemplate/RestTemplateLiveTest.java

@@ -0,0 +1,43 @@
+package com.baeldung.resttemplate;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.web.client.RestTemplate;
+
+import com.baeldung.sampleapp.config.RestClientConfig;
+import com.baeldung.transfer.LoginForm;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = RestClientConfig.class)
+public class RestTemplateLiveTest {
+
+    @Autowired
+    RestTemplate restTemplate;
+
+    @Test
+    public void givenRestTemplate_whenRequested_thenLogAndModifyResponse() {
+        LoginForm loginForm = new LoginForm("userName", "password");
+        HttpHeaders headers = new HttpHeaders();
+        headers.setContentType(MediaType.APPLICATION_JSON);
+        HttpEntity<LoginForm> requestEntity = new HttpEntity<LoginForm>(loginForm, headers);
+
+        ResponseEntity<String> responseEntity = restTemplate.postForEntity("http://httpbin.org/post", requestEntity, String.class);
+
+        assertThat(responseEntity.getStatusCode(), is(equalTo(HttpStatus.OK)));
+        assertThat(responseEntity.getHeaders()
+            .get("Foo")
+            .get(0), is(equalTo("bar")));
+    }
+}

spring-resttemplate/src/test/java/com/baeldung/web/controller/HeavyResourceControllerIntegrationTest.java

@@ -0,0 +1,71 @@
+package com.baeldung.web.controller;
+
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.patch;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+import java.util.HashMap;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.MediaType;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.web.WebAppConfiguration;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.test.web.servlet.setup.MockMvcBuilders;
+import org.springframework.web.context.WebApplicationContext;
+
+import com.baeldung.sampleapp.config.WebConfig;
+import com.baeldung.sampleapp.web.dto.HeavyResource;
+import com.baeldung.sampleapp.web.dto.HeavyResourceAddressOnly;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = WebConfig.class)
+@WebAppConfiguration
+public class HeavyResourceControllerIntegrationTest {
+
+    private MockMvc mockMvc;
+
+    @Autowired
+    private WebApplicationContext webApplicationContext;
+
+    private final ObjectMapper objectMapper = new ObjectMapper();
+
+    @Before
+    public void setUp() {
+        mockMvc = MockMvcBuilders.webAppContextSetup(webApplicationContext).build();
+    }
+
+    @Test
+    public void givenHeavyResource_whenSendPutRequest_thenCreateResource() throws Exception {
+        mockMvc.perform(put("/heavyresource/1")
+                .contentType(MediaType.APPLICATION_JSON_VALUE)
+                .content(objectMapper.writeValueAsString(new HeavyResource(1, "Tom", "Jackson", 12, "heaven street")))
+        ).andExpect(status().isOk());
+    }
+
+    @Test
+    public void givenNewAddressOfResource_whenExecutePatchRequest_thenUpdateResourcePartially() throws Exception {
+        mockMvc.perform(patch("/heavyresource/1")
+                .contentType(MediaType.APPLICATION_JSON_VALUE)
+                .content(objectMapper.writeValueAsString(new HeavyResourceAddressOnly(1, "5th avenue")))
+        ).andExpect(status().isOk());
+    }
+
+    @Test
+    public void givenNewAddressOfResource_whenExecutePatchGeneric_thenUpdateResourcePartially() throws Exception {
+        HashMap<String, Object> updates = new HashMap<>();
+        updates.put("address", "5th avenue");
+
+        mockMvc.perform(patch("/heavyresource/1")
+                .contentType(MediaType.APPLICATION_JSON_VALUE)
+                .content(objectMapper.writeValueAsString(updates))
+        ).andExpect(status().isOk());
+    }
+
+}

spring-resttemplate/src/test/java/com/baeldung/web/controller/TaxiFareControllerIntegrationTest.java

@@ -0,0 +1,35 @@
+package com.baeldung.web.controller;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.web.client.TestRestTemplate;
+import org.springframework.boot.web.server.LocalServerPort;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import com.baeldung.web.log.app.Application;
+import com.baeldung.web.log.data.TaxiRide;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = { Application.class}, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+public class TaxiFareControllerIntegrationTest {
+    
+    @LocalServerPort
+    private int port;
+    
+    @Test
+    public void givenRequest_whenFetchTaxiFareRateCard_thanOK() {
+        
+        String URL = "http://localhost:" + port + "/spring-rest";
+        TestRestTemplate testRestTemplate = new TestRestTemplate();
+        TaxiRide taxiRide = new TaxiRide(true, 10l);
+        String fare = testRestTemplate.postForObject(
+          URL + "/taxifare/calculate/", 
+          taxiRide, String.class);
+      
+        assertThat(fare, equalTo("200"));
+    }
+}

spring-resttemplate/src/test/java/com/baeldung/web/controller/mediatypes/CustomMediaTypeControllerIntegrationTest.java

@@ -0,0 +1,43 @@
+package com.baeldung.web.controller.mediatypes;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.web.WebAppConfiguration;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.test.web.servlet.setup.MockMvcBuilders;
+import org.springframework.web.context.WebApplicationContext;
+
+import com.baeldung.sampleapp.config.WebConfig;
+
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = WebConfig.class)
+@WebAppConfiguration
+public class CustomMediaTypeControllerIntegrationTest {
+
+    private MockMvc mockMvc;
+
+    @Autowired
+    private WebApplicationContext webApplicationContext;
+
+    @Before
+    public void setUp() {
+        mockMvc = MockMvcBuilders.webAppContextSetup(webApplicationContext).build();
+    }
+
+    @Test
+    public void givenServiceUrl_whenGetWithProperAcceptHeaderFirstAPIVersion_thenReturn200() throws Exception {
+        mockMvc.perform(get("/public/api/items/1").accept("application/vnd.baeldung.api.v1+json")).andExpect(status().isOk());
+    }
+
+    @Test
+    public void givenServiceUrl_whenGetWithProperAcceptHeaderSecondVersion_thenReturn200() throws Exception {
+        mockMvc.perform(get("/public/api/items/2").accept("application/vnd.baeldung.api.v2+json")).andExpect(status().isOk());
+    }
+}

spring-resttemplate/src/test/java/com/baeldung/web/controller/mediatypes/CustomMediaTypeControllerLiveTest.java

@@ -0,0 +1,37 @@
+package com.baeldung.web.controller.mediatypes;
+
+import io.restassured.http.ContentType;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+
+import static io.restassured.RestAssured.given;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = {TestConfig.class}, loader = AnnotationConfigContextLoader.class)
+public class CustomMediaTypeControllerLiveTest {
+    private static final String URL_PREFIX = "http://localhost:8082/spring-rest";
+
+    @Test
+    public void givenServiceEndpoint_whenGetRequestFirstAPIVersion_thenShouldReturn200() {
+        given()
+                .accept("application/vnd.baeldung.api.v1+json")
+        .when()
+                .get(URL_PREFIX + "/public/api/items/1")
+        .then()
+                .contentType(ContentType.JSON).and().statusCode(200);
+    }
+
+
+    @Test
+    public void givenServiceEndpoint_whenGetRequestSecondAPIVersion_thenShouldReturn200() {
+        given()
+                .accept("application/vnd.baeldung.api.v2+json")
+        .when()
+                .get(URL_PREFIX + "/public/api/items/2")
+        .then()
+                .contentType(ContentType.JSON).and().statusCode(200);
+    }
+}

spring-resttemplate/src/test/java/com/baeldung/web/controller/mediatypes/TestConfig.java

@@ -0,0 +1,11 @@
+package com.baeldung.web.controller.mediatypes;
+
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+
+
+@Configuration
+@ComponentScan({ "com.baeldung.web" })
+public class TestConfig {
+
+}

spring-resttemplate/src/test/java/com/baeldung/web/controller/redirect/RedirectControllerIntegrationTest.java

@@ -0,0 +1,66 @@
+package com.baeldung.web.controller.redirect;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.flash;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.forwardedUrl;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.model;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.redirectedUrl;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.view;
+import static org.springframework.test.web.servlet.setup.MockMvcBuilders.webAppContextSetup;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.web.WebAppConfiguration;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.web.context.WebApplicationContext;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration("file:src/main/webapp/WEB-INF/api-servlet.xml")
+@WebAppConfiguration
+public class RedirectControllerIntegrationTest {
+
+    private MockMvc mockMvc;
+
+    @Autowired
+    protected WebApplicationContext wac;
+
+    @Before
+    public void setup() {
+        mockMvc = webAppContextSetup(wac).build();
+    }
+
+    @Test
+    public void whenRedirectOnUrlWithUsingXMLConfig_thenStatusRedirectionAndRedirectedOnUrl() throws Exception {
+        mockMvc.perform(get("/redirectWithXMLConfig")).andExpect(status().is3xxRedirection()).andExpect(view().name("RedirectedUrl")).andExpect(model().attribute("attribute", equalTo("redirectWithXMLConfig")))
+                .andExpect(redirectedUrl("redirectedUrl?attribute=redirectWithXMLConfig"));
+    }
+
+    @Test
+    public void whenRedirectOnUrlWithUsingRedirectPrefix_thenStatusRedirectionAndRedirectedOnUrl() throws Exception {
+        mockMvc.perform(get("/redirectWithRedirectPrefix")).andExpect(status().is3xxRedirection()).andExpect(view().name("redirect:/redirectedUrl")).andExpect(model().attribute("attribute", equalTo("redirectWithRedirectPrefix")))
+                .andExpect(redirectedUrl("/redirectedUrl?attribute=redirectWithRedirectPrefix"));
+    }
+
+    @Test
+    public void whenRedirectOnUrlWithUsingRedirectAttributes_thenStatusRedirectionAndRedirectedOnUrlAndAddedAttributeToFlashScope() throws Exception {
+        mockMvc.perform(get("/redirectWithRedirectAttributes")).andExpect(status().is3xxRedirection()).andExpect(flash().attribute("flashAttribute", equalTo("redirectWithRedirectAttributes")))
+                .andExpect(model().attribute("attribute", equalTo("redirectWithRedirectAttributes"))).andExpect(model().attribute("flashAttribute", equalTo(null))).andExpect(redirectedUrl("redirectedUrl?attribute=redirectWithRedirectAttributes"));
+    }
+
+    @Test
+    public void whenRedirectOnUrlWithUsingRedirectView_thenStatusRedirectionAndRedirectedOnUrlAndAddedAttributeToFlashScope() throws Exception {
+        mockMvc.perform(get("/redirectWithRedirectView")).andExpect(status().is3xxRedirection()).andExpect(model().attribute("attribute", equalTo("redirectWithRedirectView"))).andExpect(redirectedUrl("redirectedUrl?attribute=redirectWithRedirectView"));
+    }
+
+    @Test
+    public void whenRedirectOnUrlWithUsingForwardPrefix_thenStatusOkAndForwardedOnUrl() throws Exception {
+        mockMvc.perform(get("/forwardWithForwardPrefix")).andExpect(status().isOk()).andExpect(view().name("forward:/redirectedUrl")).andExpect(model().attribute("attribute", equalTo("redirectWithForwardPrefix"))).andExpect(forwardedUrl("/redirectedUrl"));
+    }
+
+}

spring-resttemplate/src/test/java/org/baeldung/SpringContextIntegrationTest.java

@@ -0,0 +1,16 @@
+package org.baeldung;
+
+import org.baeldung.resttemplate.RestTemplateConfigurationApplication;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = RestTemplateConfigurationApplication.class)
+public class SpringContextIntegrationTest {
+
+    @Test
+    public void whenSpringContextIsBootstrapped_thenNoExceptions() {
+    }
+}

spring-resttemplate/src/test/java/org/baeldung/SpringContextTest.java

@@ -0,0 +1,16 @@
+package org.baeldung;
+
+import org.baeldung.resttemplate.RestTemplateConfigurationApplication;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = RestTemplateConfigurationApplication.class)
+public class SpringContextTest {
+
+    @Test
+    public void whenSpringContextIsBootstrapped_thenNoExceptions() {
+    }
+}

spring-resttemplate/src/test/java/org/baeldung/SpringTestConfig.java

@@ -0,0 +1,19 @@
+package org.baeldung;
+
+import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.client.RestTemplate;
+
+@Configuration
+@EnableAutoConfiguration
+@ComponentScan("org.baeldung")
+public class SpringTestConfig {
+
+    @Bean
+    public RestTemplate restTemplate() {
+        return new RestTemplate();
+    }
+
+}

spring-resttemplate/src/test/java/org/baeldung/client/Consts.java

@@ -0,0 +1,5 @@
+package org.baeldung.client;
+
+public interface Consts {
+    int APPLICATION_PORT = 8082;
+}

spring-resttemplate/src/test/java/org/baeldung/client/TestRestTemplateBasicLiveTest.java

@@ -0,0 +1,123 @@
+package org.baeldung.client;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+import org.baeldung.resttemplate.web.dto.Foo;
+import org.junit.Before;
+import org.junit.Test;
+import org.springframework.boot.test.web.client.TestRestTemplate;
+import org.springframework.boot.web.client.RestTemplateBuilder;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.client.RestTemplate;
+
+import okhttp3.Request;
+import okhttp3.RequestBody;
+
+public class TestRestTemplateBasicLiveTest {
+
+    private RestTemplate restTemplate;
+
+    private static final String FOO_RESOURCE_URL = "http://localhost:" + 8082 + "/spring-rest/foos";
+    private static final String URL_SECURED_BY_AUTHENTICATION = "http://httpbin.org/basic-auth/user/passwd";
+    private static final String BASE_URL = "http://localhost:" + 8082 + "/spring-rest";
+
+    @Before
+    public void beforeTest() {
+        restTemplate = new RestTemplate();
+    }
+
+    // GET
+    @Test
+    public void givenTestRestTemplate_whenSendGetForEntity_thenStatusOk() {
+        TestRestTemplate testRestTemplate = new TestRestTemplate();
+        ResponseEntity<Foo> response = testRestTemplate.getForEntity(FOO_RESOURCE_URL + "/1", Foo.class);
+        assertThat(response.getStatusCode(), equalTo(HttpStatus.OK));
+    }
+
+    @Test
+    public void givenRestTemplateWrapper_whenSendGetForEntity_thenStatusOk() {
+        RestTemplateBuilder restTemplateBuilder = new RestTemplateBuilder();
+        restTemplateBuilder.configure(restTemplate);
+        TestRestTemplate testRestTemplate = new TestRestTemplate(restTemplateBuilder);
+        ResponseEntity<Foo> response = testRestTemplate.getForEntity(FOO_RESOURCE_URL + "/1", Foo.class);
+        assertThat(response.getStatusCode(), equalTo(HttpStatus.OK));
+    }
+
+    @Test
+    public void givenRestTemplateBuilderWrapper_whenSendGetForEntity_thenStatusOk() {
+        RestTemplateBuilder restTemplateBuilder = new RestTemplateBuilder();
+        restTemplateBuilder.build();
+        TestRestTemplate testRestTemplate = new TestRestTemplate(restTemplateBuilder);
+        ResponseEntity<Foo> response = testRestTemplate.getForEntity(FOO_RESOURCE_URL + "/1", Foo.class);
+        assertThat(response.getStatusCode(), equalTo(HttpStatus.OK));
+    }
+
+    @Test
+    public void givenRestTemplateWrapperWithCredentials_whenSendGetForEntity_thenStatusOk() {
+        RestTemplateBuilder restTemplateBuilder = new RestTemplateBuilder();
+        restTemplateBuilder.configure(restTemplate);
+        TestRestTemplate testRestTemplate = new TestRestTemplate(restTemplateBuilder, "user", "passwd");
+        ResponseEntity<String> response = testRestTemplate.getForEntity(URL_SECURED_BY_AUTHENTICATION,
+                String.class);
+        assertThat(response.getStatusCode(), equalTo(HttpStatus.OK));
+    }
+
+    @Test
+    public void givenTestRestTemplateWithCredentials_whenSendGetForEntity_thenStatusOk() {
+        TestRestTemplate testRestTemplate = new TestRestTemplate("user", "passwd");
+        ResponseEntity<String> response = testRestTemplate.getForEntity(URL_SECURED_BY_AUTHENTICATION,
+                String.class);
+        assertThat(response.getStatusCode(), equalTo(HttpStatus.OK));
+    }
+
+    @Test
+    public void givenTestRestTemplateWithBasicAuth_whenSendGetForEntity_thenStatusOk() {
+        TestRestTemplate testRestTemplate = new TestRestTemplate();
+        ResponseEntity<String> response = testRestTemplate.withBasicAuth("user", "passwd").
+                getForEntity(URL_SECURED_BY_AUTHENTICATION, String.class);
+        assertThat(response.getStatusCode(), equalTo(HttpStatus.OK));
+    }
+
+    @Test
+    public void givenTestRestTemplateWithCredentialsAndEnabledCookies_whenSendGetForEntity_thenStatusOk() {
+        TestRestTemplate testRestTemplate = new TestRestTemplate("user", "passwd", TestRestTemplate.
+                HttpClientOption.ENABLE_COOKIES);
+        ResponseEntity<String> response = testRestTemplate.getForEntity(URL_SECURED_BY_AUTHENTICATION,
+                String.class);
+        assertThat(response.getStatusCode(), equalTo(HttpStatus.OK));
+    }
+
+    // HEAD
+    @Test
+    public void givenFooService_whenCallHeadForHeaders_thenReceiveAllHeaders() {
+        TestRestTemplate testRestTemplate = new TestRestTemplate();
+        final HttpHeaders httpHeaders = testRestTemplate.headForHeaders(FOO_RESOURCE_URL);
+        assertTrue(httpHeaders.getContentType().includes(MediaType.APPLICATION_JSON));
+    }
+
+    // POST
+    @Test
+    public void givenService_whenPostForObject_thenCreatedObjectIsReturned() {
+        TestRestTemplate testRestTemplate = new TestRestTemplate("user", "passwd");
+        final RequestBody body = RequestBody.create(okhttp3.MediaType.parse("text/html; charset=utf-8"),
+                "{\"id\":1,\"name\":\"Jim\"}");
+        final Request request = new Request.Builder().url(BASE_URL + "/users/detail").post(body).build();
+        testRestTemplate.postForObject(URL_SECURED_BY_AUTHENTICATION, request, String.class);
+    }
+
+    // PUT
+    @Test
+    public void givenService_whenPutForObject_thenCreatedObjectIsReturned() {
+        TestRestTemplate testRestTemplate = new TestRestTemplate("user", "passwd");
+        final RequestBody body = RequestBody.create(okhttp3.MediaType.parse("text/html; charset=utf-8"),
+                "{\"id\":1,\"name\":\"Jim\"}");
+        final Request request = new Request.Builder().url(BASE_URL + "/users/detail").post(body).build();
+        testRestTemplate.put(URL_SECURED_BY_AUTHENTICATION, request, String.class);
+    }
+
+}

spring-resttemplate/src/test/java/org/baeldung/resttemplate/LargeFileDownloadIntegrationTest.java

@@ -0,0 +1,109 @@
+package org.baeldung.resttemplate;
+
+import org.assertj.core.api.Assertions;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.springframework.core.io.FileSystemResource;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.converter.HttpMessageConverter;
+import org.springframework.util.StreamUtils;
+import org.springframework.web.client.RestTemplate;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.util.ArrayList;
+import java.util.List;
+
+public class LargeFileDownloadIntegrationTest {
+
+    static String FILE_URL = "http://ovh.net/files/1Mio.dat";
+
+    RestTemplate restTemplate;
+
+    @Before
+    public void setUp() {
+        restTemplate = new RestTemplate();
+    }
+
+    @Test
+    public void givenResumableUrl_whenUrlCalledByHeadOption_thenExpectHeadersAvailable() {
+        HttpHeaders headers = restTemplate.headForHeaders(FILE_URL);
+        Assertions
+          .assertThat(headers.get("Accept-Ranges"))
+          .contains("bytes");
+        Assertions
+          .assertThat(headers.getContentLength())
+          .isGreaterThan(0);
+    }
+
+    @Test
+    public void givenResumableUrl_whenDownloadCompletely_thenExpectCorrectFileSize() {
+        HttpHeaders headers = restTemplate.headForHeaders(FILE_URL);
+        long contentLength = headers.getContentLength();
+        File file = restTemplate.execute(FILE_URL, HttpMethod.GET, null, clientHttpResponse -> {
+            File ret = File.createTempFile("download", "tmp");
+            StreamUtils.copy(clientHttpResponse.getBody(), new FileOutputStream(ret));
+            return ret;
+        });
+
+        Assert.assertNotNull(file);
+        Assertions
+          .assertThat(file.length())
+          .isEqualTo(contentLength);
+    }
+
+    @Test
+    public void givenResumableUrl_whenDownloadRange_thenExpectFileSizeEqualOrLessThanRange() {
+        int range = 10;
+        File file = restTemplate.execute(FILE_URL, HttpMethod.GET, clientHttpRequest -> clientHttpRequest
+          .getHeaders()
+          .set("Range", String.format("bytes=0-%d", range - 1)), clientHttpResponse -> {
+            File ret = File.createTempFile("download", "tmp");
+            StreamUtils.copy(clientHttpResponse.getBody(), new FileOutputStream(ret));
+            return ret;
+        });
+
+        Assert.assertNotNull(file);
+        Assertions
+          .assertThat(file.length())
+          .isLessThanOrEqualTo(range);
+    }
+
+    @Test
+    public void givenResumableUrl_whenPauseDownloadAndResume_thenExpectCorrectFileSize() {
+
+        int range = 10;
+
+        HttpHeaders headers = restTemplate.headForHeaders(FILE_URL);
+        long contentLength = headers.getContentLength();
+
+        File file = restTemplate.execute(FILE_URL, HttpMethod.GET, clientHttpRequest -> clientHttpRequest
+          .getHeaders()
+          .set("Range", String.format("bytes=0-%d", range - 1)), clientHttpResponse -> {
+            File ret = File.createTempFile("download", "tmp");
+            StreamUtils.copy(clientHttpResponse.getBody(), new FileOutputStream(ret));
+            return ret;
+        });
+
+        Assert.assertNotNull(file);
+
+        Assertions
+          .assertThat(file.length())
+          .isLessThanOrEqualTo(range);
+
+        restTemplate.execute(FILE_URL, HttpMethod.GET, clientHttpRequest -> clientHttpRequest
+          .getHeaders()
+          .set("Range", String.format("bytes=%d-%d", file.length(), contentLength)), clientHttpResponse -> {
+            StreamUtils.copy(clientHttpResponse.getBody(), new FileOutputStream(file, true));
+            return file;
+        });
+
+        Assertions
+          .assertThat(file.length())
+          .isEqualTo(contentLength);
+
+    }
+
+}

spring-resttemplate/src/test/java/org/baeldung/resttemplate/RestTemplateBasicLiveTest.java

@@ -0,0 +1,272 @@
+package org.baeldung.resttemplate;
+
+import static org.apache.commons.codec.binary.Base64.encodeBase64;
+import static org.baeldung.client.Consts.APPLICATION_PORT;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.notNullValue;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.io.IOException;
+import java.net.URI;
+import java.util.Arrays;
+import java.util.Set;
+
+import org.baeldung.resttemplate.web.dto.Foo;
+import org.baeldung.resttemplate.web.handler.RestTemplateResponseErrorHandler;
+import org.junit.Before;
+import org.junit.Test;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.http.client.ClientHttpRequestFactory;
+import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
+import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
+import org.springframework.util.LinkedMultiValueMap;
+import org.springframework.util.MultiValueMap;
+import org.springframework.web.client.HttpClientErrorException;
+import org.springframework.web.client.RequestCallback;
+import org.springframework.web.client.RestTemplate;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.dataformat.xml.XmlMapper;
+import com.google.common.base.Charsets;
+
+public class RestTemplateBasicLiveTest {
+
+    private RestTemplate restTemplate;
+    private static final String fooResourceUrl = "http://localhost:" + APPLICATION_PORT + "/spring-rest/foos";
+
+    @Before
+    public void beforeTest() {
+        restTemplate = new RestTemplate();
+        restTemplate.setErrorHandler(new RestTemplateResponseErrorHandler());
+        // restTemplate.setMessageConverters(Arrays.asList(new MappingJackson2HttpMessageConverter()));
+    }
+
+    // GET
+
+    @Test
+    public void givenResourceUrl_whenSendGetForRequestEntity_thenStatusOk() throws IOException {
+        final ResponseEntity<Foo> response = restTemplate.getForEntity(fooResourceUrl + "/1", Foo.class);
+
+        assertThat(response.getStatusCode(), equalTo(HttpStatus.OK));
+    }
+
+    @Test
+    public void givenResourceUrl_whenSendGetForRequestEntity_thenBodyCorrect() throws IOException {
+        final RestTemplate template = new RestTemplate();
+        final ResponseEntity<String> response = template.getForEntity(fooResourceUrl + "/1", String.class);
+
+        final ObjectMapper mapper = new XmlMapper();
+        final JsonNode root = mapper.readTree(response.getBody());
+        final JsonNode name = root.path("name");
+        assertThat(name.asText(), notNullValue());
+    }
+
+    @Test
+    public void givenResourceUrl_whenRetrievingResource_thenCorrect() throws IOException {
+        final Foo foo = restTemplate.getForObject(fooResourceUrl + "/1", Foo.class);
+
+        assertThat(foo.getName(), notNullValue());
+        assertThat(foo.getId(), is(1L));
+    }
+
+    // HEAD, OPTIONS
+
+    @Test
+    public void givenFooService_whenCallHeadForHeaders_thenReceiveAllHeadersForThatResource() {
+        final HttpHeaders httpHeaders = restTemplate.headForHeaders(fooResourceUrl);
+        assertTrue(httpHeaders.getContentType()
+            .includes(MediaType.APPLICATION_JSON));
+    }
+
+    // POST
+
+    @Test
+    public void givenFooService_whenPostForObject_thenCreatedObjectIsReturned() {
+        final HttpEntity<Foo> request = new HttpEntity<>(new Foo("bar"));
+        final Foo foo = restTemplate.postForObject(fooResourceUrl, request, Foo.class);
+        assertThat(foo, notNullValue());
+        assertThat(foo.getName(), is("bar"));
+    }
+
+    @Test
+    public void givenFooService_whenPostForLocation_thenCreatedLocationIsReturned() {
+        final HttpEntity<Foo> request = new HttpEntity<>(new Foo("bar"));
+        final URI location = restTemplate.postForLocation(fooResourceUrl, request, Foo.class);
+        assertThat(location, notNullValue());
+    }
+
+    @Test
+    public void givenFooService_whenPostResource_thenResourceIsCreated() {
+        final Foo foo = new Foo("bar");
+        final ResponseEntity<Foo> response = restTemplate.postForEntity(fooResourceUrl, foo, Foo.class);
+
+        assertThat(response.getStatusCode(), is(HttpStatus.CREATED));
+        final Foo fooResponse = response.getBody();
+        assertThat(fooResponse, notNullValue());
+        assertThat(fooResponse.getName(), is("bar"));
+    }
+
+    @Test
+    public void givenFooService_whenCallOptionsForAllow_thenReceiveValueOfAllowHeader() {
+        final Set<HttpMethod> optionsForAllow = restTemplate.optionsForAllow(fooResourceUrl);
+        final HttpMethod[] supportedMethods = { HttpMethod.GET, HttpMethod.POST, HttpMethod.HEAD };
+
+        assertTrue(optionsForAllow.containsAll(Arrays.asList(supportedMethods)));
+    }
+
+    // PUT
+
+    @Test
+    public void givenFooService_whenPutExistingEntity_thenItIsUpdated() {
+        final HttpHeaders headers = prepareBasicAuthHeaders();
+        final HttpEntity<Foo> request = new HttpEntity<>(new Foo("bar"), headers);
+
+        // Create Resource
+        final ResponseEntity<Foo> createResponse = restTemplate.exchange(fooResourceUrl, HttpMethod.POST, request, Foo.class);
+
+        // Update Resource
+        final Foo updatedInstance = new Foo("newName");
+        updatedInstance.setId(createResponse.getBody()
+            .getId());
+        final String resourceUrl = fooResourceUrl + '/' + createResponse.getBody()
+            .getId();
+        final HttpEntity<Foo> requestUpdate = new HttpEntity<>(updatedInstance, headers);
+        restTemplate.exchange(resourceUrl, HttpMethod.PUT, requestUpdate, Void.class);
+
+        // Check that Resource was updated
+        final ResponseEntity<Foo> updateResponse = restTemplate.exchange(resourceUrl, HttpMethod.GET, new HttpEntity<>(headers), Foo.class);
+        final Foo foo = updateResponse.getBody();
+        assertThat(foo.getName(), is(updatedInstance.getName()));
+    }
+
+    @Test
+    public void givenFooService_whenPutExistingEntityWithCallback_thenItIsUpdated() {
+        final HttpHeaders headers = prepareBasicAuthHeaders();
+        final HttpEntity<Foo> request = new HttpEntity<>(new Foo("bar"), headers);
+
+        // Create entity
+        ResponseEntity<Foo> response = restTemplate.exchange(fooResourceUrl, HttpMethod.POST, request, Foo.class);
+        assertThat(response.getStatusCode(), is(HttpStatus.CREATED));
+
+        // Update entity
+        final Foo updatedInstance = new Foo("newName");
+        updatedInstance.setId(response.getBody()
+            .getId());
+        final 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);
+        final Foo foo = response.getBody();
+        assertThat(foo.getName(), is(updatedInstance.getName()));
+    }
+
+    // PATCH
+
+    @Test
+    public void givenFooService_whenPatchExistingEntity_thenItIsUpdated() {
+        final HttpHeaders headers = prepareBasicAuthHeaders();
+        final HttpEntity<Foo> request = new HttpEntity<>(new Foo("bar"), headers);
+
+        // Create Resource
+        final ResponseEntity<Foo> createResponse = restTemplate.exchange(fooResourceUrl, HttpMethod.POST, request, Foo.class);
+
+        // Update Resource
+        final Foo updatedResource = new Foo("newName");
+        updatedResource.setId(createResponse.getBody()
+            .getId());
+        final String resourceUrl = fooResourceUrl + '/' + createResponse.getBody()
+            .getId();
+        final HttpEntity<Foo> requestUpdate = new HttpEntity<>(updatedResource, headers);
+        final ClientHttpRequestFactory requestFactory = getClientHttpRequestFactory();
+        final RestTemplate template = new RestTemplate(requestFactory);
+        template.setMessageConverters(Arrays.asList(new MappingJackson2HttpMessageConverter()));
+        template.patchForObject(resourceUrl, requestUpdate, Void.class);
+
+        // Check that Resource was updated
+        final ResponseEntity<Foo> updateResponse = restTemplate.exchange(resourceUrl, HttpMethod.GET, new HttpEntity<>(headers), Foo.class);
+        final Foo foo = updateResponse.getBody();
+        assertThat(foo.getName(), is(updatedResource.getName()));
+    }
+
+    // DELETE
+
+    @Test
+    public void givenFooService_whenCallDelete_thenEntityIsRemoved() {
+        final Foo foo = new Foo("remove me");
+        final ResponseEntity<Foo> response = restTemplate.postForEntity(fooResourceUrl, foo, Foo.class);
+        assertThat(response.getStatusCode(), is(HttpStatus.CREATED));
+
+        final String entityUrl = fooResourceUrl + "/" + response.getBody()
+            .getId();
+        restTemplate.delete(entityUrl);
+        try {
+            restTemplate.getForEntity(entityUrl, Foo.class);
+            fail();
+        } catch (final HttpClientErrorException ex) {
+            assertThat(ex.getStatusCode(), is(HttpStatus.INTERNAL_SERVER_ERROR));
+        }
+    }
+
+    @Test
+    public void givenFooService_whenFormSubmit_thenResourceIsCreated() {
+        HttpHeaders headers = new HttpHeaders();
+        headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
+
+        MultiValueMap<String, String> map= new LinkedMultiValueMap<>();
+        map.add("id", "10");
+
+        HttpEntity<MultiValueMap<String, String>> request = new HttpEntity<>(map, headers);
+
+        ResponseEntity<String> response = restTemplate.postForEntity( fooResourceUrl+"/form", request , String.class);
+
+        assertThat(response.getStatusCode(), is(HttpStatus.CREATED));
+        final String fooResponse = response.getBody();
+        assertThat(fooResponse, notNullValue());
+        assertThat(fooResponse, is("10"));
+    }
+
+    private HttpHeaders prepareBasicAuthHeaders() {
+        final HttpHeaders headers = new HttpHeaders();
+        final String encodedLogPass = getBase64EncodedLogPass();
+        headers.add(HttpHeaders.AUTHORIZATION, "Basic " + encodedLogPass);
+        return headers;
+    }
+
+    private String getBase64EncodedLogPass() {
+        final String logPass = "user1:user1Pass";
+        final byte[] authHeaderBytes = encodeBase64(logPass.getBytes(Charsets.US_ASCII));
+        return new String(authHeaderBytes, Charsets.US_ASCII);
+    }
+
+    private RequestCallback requestCallback(final Foo updatedInstance) {
+        return clientHttpRequest -> {
+            final ObjectMapper mapper = new ObjectMapper();
+            mapper.writeValue(clientHttpRequest.getBody(), updatedInstance);
+            clientHttpRequest.getHeaders()
+                .add(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE);
+            clientHttpRequest.getHeaders()
+                .add(HttpHeaders.AUTHORIZATION, "Basic " + getBase64EncodedLogPass());
+        };
+    }
+
+    // Simply setting restTemplate timeout using ClientHttpRequestFactory
+
+    ClientHttpRequestFactory getClientHttpRequestFactory() {
+        final int timeout = 5;
+        final HttpComponentsClientHttpRequestFactory clientHttpRequestFactory = new HttpComponentsClientHttpRequestFactory();
+        clientHttpRequestFactory.setConnectTimeout(timeout * 1000);
+        return clientHttpRequestFactory;
+    }
+
+}

spring-resttemplate/src/test/java/org/baeldung/resttemplate/postjson/PersonAPILiveTest.java

@@ -0,0 +1,97 @@
+package org.baeldung.resttemplate.postjson;
+
+import static org.junit.Assert.assertNotNull;
+
+import java.io.IOException;
+import java.net.URI;
+
+import org.baeldung.resttemplate.RestTemplateConfigurationApplication;
+import org.baeldung.resttemplate.web.dto.Person;
+import org.json.JSONException;
+import org.json.JSONObject;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.test.context.junit4.SpringRunner;
+import org.springframework.web.client.RestTemplate;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = RestTemplateConfigurationApplication.class)
+public class PersonAPILiveTest {
+
+    private static String createPersonUrl;
+    private static String updatePersonUrl;
+
+    private static RestTemplate restTemplate;
+
+    private static HttpHeaders headers;
+
+    private final ObjectMapper objectMapper = new ObjectMapper();
+
+    private static JSONObject personJsonObject;
+
+    @BeforeClass
+    public static void runBeforeAllTestMethods() throws JSONException {
+        createPersonUrl = "http://localhost:8082/spring-rest/createPerson";
+        updatePersonUrl = "http://localhost:8082/spring-rest/updatePerson";
+
+        restTemplate = new RestTemplate();
+
+        headers = new HttpHeaders();
+        headers.setContentType(MediaType.APPLICATION_JSON);
+        personJsonObject = new JSONObject();
+        personJsonObject.put("id", 1);
+        personJsonObject.put("name", "John");
+    }
+
+    @Test
+    public void givenDataIsJson_whenDataIsPostedByPostForObject_thenResponseBodyIsNotNull() throws IOException {
+        HttpEntity<String> request = new HttpEntity<String>(personJsonObject.toString(), headers);
+        String personResultAsJsonStr = restTemplate.postForObject(createPersonUrl, request, String.class);
+        JsonNode root = objectMapper.readTree(personResultAsJsonStr);
+
+        Person person = restTemplate.postForObject(createPersonUrl, request, Person.class);
+
+        assertNotNull(personResultAsJsonStr);
+        assertNotNull(root);
+        assertNotNull(root.path("name")
+            .asText());
+
+        assertNotNull(person);
+        assertNotNull(person.getName());
+    }
+
+    @Test
+    public void givenDataIsJson_whenDataIsPostedByPostForEntity_thenResponseBodyIsNotNull() throws IOException {
+        HttpEntity<String> request = new HttpEntity<String>(personJsonObject.toString(), headers);
+        ResponseEntity<String> responseEntityStr = restTemplate.postForEntity(createPersonUrl, request, String.class);
+        JsonNode root = objectMapper.readTree(responseEntityStr.getBody());
+
+        ResponseEntity<Person> responseEntityPerson = restTemplate.postForEntity(createPersonUrl, request, Person.class);
+
+        assertNotNull(responseEntityStr.getBody());
+        assertNotNull(root.path("name")
+            .asText());
+
+        assertNotNull(responseEntityPerson.getBody());
+        assertNotNull(responseEntityPerson.getBody()
+            .getName());
+    }
+
+    @Test
+    public void givenDataIsJson_whenDataIsPostedByPostForLocation_thenResponseBodyIsTheLocationHeader() throws JsonProcessingException {
+        HttpEntity<String> request = new HttpEntity<String>(personJsonObject.toString(), headers);
+        URI locationHeader = restTemplate.postForLocation(updatePersonUrl, request);
+
+        assertNotNull(locationHeader);
+    }
+}

spring-resttemplate/src/test/java/org/baeldung/web/handler/RestTemplateResponseErrorHandlerIntegrationTest.java

@@ -0,0 +1,49 @@
+package org.baeldung.web.handler;
+
+import org.baeldung.resttemplate.web.exception.NotFoundException;
+import org.baeldung.resttemplate.web.handler.RestTemplateResponseErrorHandler;
+import org.baeldung.resttemplate.web.model.Bar;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.client.RestClientTest;
+import org.springframework.boot.web.client.RestTemplateBuilder;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.HttpStatus;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringRunner;
+import org.springframework.test.web.client.ExpectedCount;
+import org.springframework.test.web.client.MockRestServiceServer;
+import org.springframework.web.client.RestTemplate;
+
+import static org.springframework.test.web.client.match.MockRestRequestMatchers.method;
+import static org.springframework.test.web.client.match.MockRestRequestMatchers.requestTo;
+import static org.springframework.test.web.client.response.MockRestResponseCreators.withStatus;
+
+@RunWith(SpringRunner.class)
+@ContextConfiguration(classes = { NotFoundException.class, Bar.class })
+@RestClientTest
+public class RestTemplateResponseErrorHandlerIntegrationTest {
+
+    @Autowired private MockRestServiceServer server;
+    @Autowired private RestTemplateBuilder builder;
+
+    @Test(expected = NotFoundException.class)
+    public void givenRemoteApiCall_when404Error_thenThrowNotFound() {
+        Assert.assertNotNull(this.builder);
+        Assert.assertNotNull(this.server);
+
+        RestTemplate restTemplate = this.builder
+          .errorHandler(new RestTemplateResponseErrorHandler())
+          .build();
+
+        this.server
+          .expect(ExpectedCount.once(), requestTo("/bars/4242"))
+          .andExpect(method(HttpMethod.GET))
+          .andRespond(withStatus(HttpStatus.NOT_FOUND));
+
+        Bar response = restTemplate.getForObject("/bars/4242", Bar.class);
+        this.server.verify();
+    }
+}

spring-resttemplate/src/test/java/org/baeldung/web/service/EmployeeServiceMockRestServiceServerUnitTest.java

@@ -0,0 +1,67 @@
+package org.baeldung.web.service;
+
+import static org.springframework.test.web.client.match.MockRestRequestMatchers.method;
+import static org.springframework.test.web.client.match.MockRestRequestMatchers.requestTo;
+import static org.springframework.test.web.client.response.MockRestResponseCreators.withStatus;
+
+import java.net.URI;
+
+import org.baeldung.SpringTestConfig;
+import org.baeldung.resttemplate.web.model.Employee;
+import org.baeldung.resttemplate.web.service.EmployeeService;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringRunner;
+import org.springframework.test.web.client.ExpectedCount;
+import org.springframework.test.web.client.MockRestServiceServer;
+import org.springframework.web.client.RestTemplate;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+@RunWith(SpringRunner.class)
+@ContextConfiguration(classes = SpringTestConfig.class)
+public class EmployeeServiceMockRestServiceServerUnitTest {
+
+    private static final Logger logger = LoggerFactory.getLogger(EmployeeServiceMockRestServiceServerUnitTest.class);
+
+    @Autowired
+    private EmployeeService empService;
+
+    @Autowired
+    private RestTemplate restTemplate;
+
+    private MockRestServiceServer mockServer;
+
+    private ObjectMapper mapper = new ObjectMapper();
+
+    @Before
+    public void init() {
+        mockServer = MockRestServiceServer.createServer(restTemplate);
+    }
+
+    @Test
+    public void givenMockingIsDoneByMockRestServiceServer_whenGetIsCalled_shouldReturnMockedObject() throws Exception {
+        Employee emp = new Employee("E001", "Eric Simmons");
+
+        mockServer.expect(ExpectedCount.once(),
+          requestTo(new URI("http://localhost:8080/employee/E001")))
+            .andExpect(method(HttpMethod.GET))
+            .andRespond(withStatus(HttpStatus.OK)
+              .contentType(MediaType.APPLICATION_JSON)
+              .body(mapper.writeValueAsString(emp)));
+
+        Employee employee = empService.getEmployee("E001");
+        mockServer.verify();
+        Assert.assertEquals(emp, employee);
+    }
+
+}

spring-resttemplate/src/test/java/org/baeldung/web/service/EmployeeServiceUnitTest.java

@@ -0,0 +1,42 @@
+package org.baeldung.web.service;
+
+import org.baeldung.resttemplate.web.model.Employee;
+import org.baeldung.resttemplate.web.service.EmployeeService;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.client.RestTemplate;
+
+@RunWith(MockitoJUnitRunner.class)
+public class EmployeeServiceUnitTest {
+
+    private static final Logger logger = LoggerFactory.getLogger(EmployeeServiceUnitTest.class);
+
+    @Mock
+    private RestTemplate restTemplate;
+
+    @InjectMocks
+    private EmployeeService empService = new EmployeeService();
+
+    @Test
+    public void givenMockingIsDoneByMockito_whenGetIsCalled_shouldReturnMockedObject() throws Exception {
+        Employee emp = new Employee("E001", "Eric Simmons");
+        Mockito.when(restTemplate.getForEntity("http://localhost:8080/employee/E001", Employee.class))
+          .thenReturn(new ResponseEntity(emp, HttpStatus.OK));
+
+        Employee employee = empService.getEmployee("E001");
+
+        Assert.assertEquals(emp, employee);
+    }
+
+}