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.