TestRestTemplate for full integration in Spring Boot - Step-by-Step Execution

Concept Flow - TestRestTemplate for full integration

Start Spring Boot Test Context

↓

Inject TestRestTemplate

↓

Send HTTP Request to API

↓

API Controller Handles Request

↓

Process Business Logic

↓

Return Response

↓

TestRestTemplate Receives Response

↓

Assert Response in Test

↓

End Test

Shows how TestRestTemplate sends a real HTTP request to the running Spring Boot app and verifies the response.

Execution Sample

Spring Boot

  @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
  class MyApiIntegrationTest {
    @Autowired
    private TestRestTemplate restTemplate;

    @Test
    void testGetHello() {
      var response = restTemplate.getForEntity("/hello", String.class);
    }
  }

This test starts the app on a random port, sends a GET request to /hello, and stores the response.

Execution Table

Step	Action	Input/Request	Internal Process	Output/Response
1	Start Spring Boot Test Context	N/A	App context loads, server starts on random port	Ready to accept HTTP requests
2	Inject TestRestTemplate	N/A	TestRestTemplate bean injected with base URL	restTemplate ready
3	Send GET request	GET /hello	Request routed to HelloController	Controller method invoked
4	Process request	N/A	HelloController returns "Hello World"	Response body: "Hello World"
5	Receive response	HTTP 200 OK, body "Hello World"	TestRestTemplate captures response	ResponseEntity with status 200 and body
6	Assert response	ResponseEntity	Test checks status == 200 and body == "Hello World"	Test passes if assertions true
7	End test	N/A	Test completes	Test result reported

💡 Test ends after assertions verify the HTTP response matches expectations

Variable Tracker

Variable	Start	After Step 3	After Step 5	Final
restTemplate	null	Injected TestRestTemplate instance	Same instance	Same instance
response	null	null	ResponseEntity(status=200, body="Hello World")	Same ResponseEntity

Key Moments - 3 Insights

Why does the test need @SpringBootTest with webEnvironment.RANDOM_PORT?

Because TestRestTemplate sends real HTTP requests, the app must run on a server port. RANDOM_PORT starts the server on a free port for isolation, as shown in execution_table step 1.

How does TestRestTemplate know the server URL to send requests?

Spring injects TestRestTemplate configured with the random server port automatically, so it targets the running app, as seen in execution_table step 2.

What happens if the controller returns a different response than expected?

The assertion in step 6 will fail, causing the test to fail. This ensures the integration test verifies the full request-response cycle.

Visual Quiz - 3 Questions

Look at the execution_table, what is the response body received at step 5?

A "Goodbye"

B "Hello World"

C null

D "Error"

💡 Hint

Check the Output/Response column at step 5 in the execution_table

At which step does the TestRestTemplate send the HTTP request?

A Step 3

B Step 4

C Step 2

D Step 5

💡 Hint

Look at the Action column describing sending GET /hello

If the @SpringBootTest annotation did not specify webEnvironment.RANDOM_PORT, what would happen?

A The test would run but with default port 8080

B TestRestTemplate would still send requests successfully

C The test would fail because no server port is started

D The test would ignore HTTP requests

💡 Hint

Refer to key_moments about why RANDOM_PORT is needed for TestRestTemplate

Concept Snapshot

TestRestTemplate for full integration:
- Use @SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
- Inject TestRestTemplate to send real HTTP requests
- Send requests like restTemplate.getForEntity("/path", Class.class)
- Controller handles request, returns response
- Assert response status and body in test
- Tests full app stack including HTTP layer

Full Transcript

This visual execution shows how TestRestTemplate works in a full integration test with Spring Boot. First, the test context starts the app on a random port. Then, TestRestTemplate is injected and configured to send HTTP requests to that port. When the test calls restTemplate.getForEntity("/hello", String.class), it sends a real HTTP GET request to the running app. The request is routed to the controller, which processes it and returns "Hello World". TestRestTemplate receives the HTTP 200 response with the body. The test then asserts the response status and body to verify correctness. This approach tests the full stack including HTTP, controller, and business logic layers. Key points include the need for @SpringBootTest with webEnvironment.RANDOM_PORT to start the server and how TestRestTemplate automatically targets the running app. If the response differs from expected, the test fails, ensuring integration correctness.

Practice

1. What is the main purpose of TestRestTemplate in a Spring Boot application?

easy

A. To perform real HTTP requests for full integration testing

B. To mock database calls during unit tests

C. To replace the main application context

D. To generate API documentation automatically

Solution

1. Step 1: Understand TestRestTemplate's role

   TestRestTemplate is designed to send HTTP requests to the running Spring Boot app during tests.

2. Step 2: Compare with other testing tools

   Unlike mocks or stubs, it tests the full app stack by making real HTTP calls.

3. Final Answer:

   To perform real HTTP requests for full integration testing -> Option A

4. Quick Check:

   TestRestTemplate = real HTTP requests [OK]

Hint: Remember: TestRestTemplate tests full app via HTTP [OK]

Common Mistakes:

• Confusing TestRestTemplate with mocking tools
• Thinking it replaces application context
• Assuming it auto-generates docs

2. Which annotation combination is correct to enable TestRestTemplate with a random port in a Spring Boot test?

easy

A. @SpringBootTest(webEnvironment = WebEnvironment.MOCK)

B. @SpringBootTest(webEnvironment = WebEnvironment.NONE)

C. @SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)

D. @SpringBootTest(webEnvironment = WebEnvironment.DEFINED_PORT)

Solution

1. Step 1: Identify webEnvironment for real HTTP tests

   Using RANDOM_PORT starts the server on a random port for real HTTP calls.

2. Step 2: Understand other options

   NONE disables web environment, MOCK uses mock servlet environment, DEFINED_PORT uses fixed port.

3. Final Answer:

   @SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT) -> Option C

4. Quick Check:

   RANDOM_PORT enables real HTTP server [OK]

Hint: Use RANDOM_PORT for real HTTP server in tests [OK]

Common Mistakes:

• Using MOCK disables real HTTP server
• Choosing NONE disables web environment
• Assuming DEFINED_PORT is random

3. Given this test snippet using TestRestTemplate:

var response = restTemplate.getForEntity("/api/greet", String.class);
System.out.println(response.getStatusCodeValue());
System.out.println(response.getBody());

If the endpoint /api/greet returns HTTP 200 and body "Hello!", what will be printed?

medium

A. 200\nnull

B. 404\nNot Found

C. 500\nInternal Server Error

D. 200\nHello!

Solution

1. Step 1: Understand getForEntity behavior

   It sends GET request and returns response with status and body.

2. Step 2: Match expected endpoint response

   The endpoint returns 200 status and "Hello!" body, so these print exactly.

3. Final Answer:

   200\nHello! -> Option D

4. Quick Check:

   Status 200 and body "Hello!" printed [OK]

Hint: Response status and body print as returned by endpoint [OK]

Common Mistakes:

• Assuming 404 if endpoint not found in test
• Expecting null body when response is valid
• Confusing status code with body content

4. Consider this test code snippet:

@Autowired
private TestRestTemplate restTemplate;

@Test
public void testGetUser() {
  var response = restTemplate.getForEntity("/users/1", User.class);
  assertEquals(200, response.getStatusCodeValue());
}

If the test fails with a NullPointerException on restTemplate.getForEntity, what is the most likely cause?

medium

A. The test method is missing @Test annotation

B. TestRestTemplate was not injected because @SpringBootTest annotation is missing

C. User class is not serializable

D. The endpoint /users/1 does not exist

Solution

1. Step 1: Identify cause of NullPointerException

   NullPointerException on restTemplate means it was never set (null).

2. Step 2: Check test setup annotations

   Without @SpringBootTest, Spring does not create context or inject beans like TestRestTemplate.

3. Final Answer:

   TestRestTemplate was not injected because @SpringBootTest annotation is missing -> Option B

4. Quick Check:

   Missing @SpringBootTest causes null injection [OK]

Hint: NullPointer on restTemplate means missing @SpringBootTest [OK]

Common Mistakes:

• Blaming missing endpoint for NullPointerException
• Assuming serialization error causes NPE
• Forgetting to add @Test annotation

5. You want to write a full integration test using TestRestTemplate that posts JSON data to /api/items and verifies the created item's ID is returned. Which code snippet correctly performs this test?

hard

A. var item = new Item(null, "Book");
var response = restTemplate.postForEntity("/api/items", item, Item.class);
assertEquals(201, response.getStatusCodeValue());
assertNotNull(response.getBody().getId());

B. var item = new Item(null, "Book");
var response = restTemplate.getForEntity("/api/items", Item.class);
assertEquals(201, response.getStatusCodeValue());

C. var item = new Item(null, "Book");
var response = restTemplate.postForObject("/api/items", item, Item.class);
assertEquals(404, response.getStatusCodeValue());

D. var item = new Item(null, "Book");
var response = restTemplate.exchange("/api/items", HttpMethod.GET, null, Item.class);
assertEquals(201, response.getStatusCodeValue());

Solution

1. Step 1: Identify correct HTTP method for creating resource

   POST is used to create new items, so postForEntity is appropriate.

2. Step 2: Verify response status and body

   201 status means created; response body should contain new item's ID, so assertNotNull on getId() is correct.

3. Final Answer:

   Code snippet using postForEntity with POST and checking 201 and ID -> Option A

4. Quick Check:

   POST + 201 + returned ID = correct test [OK]

Hint: Use postForEntity and check 201 plus returned ID [OK]

Common Mistakes:

• Using GET instead of POST for creation
• Expecting 404 instead of 201 status
• Using postForObject without status check