TestRestTemplate for API testing in JUnit - Build an Automation Script

Verify GET /api/users returns list of users

Preconditions (2)

Step 1: Send a GET request to http://localhost:8080/api/users using TestRestTemplate

Step 2: Capture the response

Step 3: Verify the HTTP status code is 200

Step 4: Verify the response body is a JSON array

Step 5: Verify the first user object has 'id', 'name', and 'email' fields

✅ Expected Result: Response status is 200 OK and response body contains a JSON array with user objects having id, name, and email fields

Automation Requirements - JUnit 5 with Spring Boot Test

Assertions Needed:

HTTP status code is 200

Response body is not null

Response body contains expected JSON structure

Best Practices:

Use @SpringBootTest with webEnvironment RANDOM_PORT

Inject TestRestTemplate bean

Use ResponseEntity<T> to capture response

Use assertions from org.junit.jupiter.api.Assertions

Avoid hardcoding URLs, use @LocalServerPort for port

Automated Solution

JUnit

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.web.server.LocalServerPort;
import org.springframework.http.ResponseEntity;
import org.springframework.boot.test.web.client.TestRestTemplate;
import static org.junit.jupiter.api.Assertions.*;
import java.util.List;
import java.util.Map;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class UserApiTest {

    @LocalServerPort
    private int port;

    @Autowired
    private TestRestTemplate restTemplate;

    @Test
    public void testGetUsersReturnsList() {
        String url = "http://localhost:" + port + "/api/users";
        ResponseEntity<List> response = restTemplate.getForEntity(url, List.class);

        // Assert status code 200
        assertEquals(200, response.getStatusCodeValue(), "Status code should be 200");

        // Assert body is not null
        List<?> users = response.getBody();
        assertNotNull(users, "Response body should not be null");

        // Assert body is a list and has at least one user
        assertFalse(users.isEmpty(), "User list should not be empty");

        // Assert first user has keys id, name, email
        Object firstUser = users.get(0);
        assertTrue(firstUser instanceof Map, "User should be a Map");
        Map<?, ?> userMap = (Map<?, ?>) firstUser;
        assertTrue(userMap.containsKey("id"), "User should have 'id'");
        assertTrue(userMap.containsKey("name"), "User should have 'name'");
        assertTrue(userMap.containsKey("email"), "User should have 'email'");
    }
}

This test class uses @SpringBootTest with webEnvironment = RANDOM_PORT to start the server on a random port to avoid conflicts.

The @LocalServerPort injects the actual port number used, so the test builds the URL dynamically.

TestRestTemplate is injected to send HTTP requests easily.

The test method sends a GET request to /api/users and captures the response as a List of users.

Assertions check that the status code is 200, the response body is not null, the list is not empty, and the first user object contains the expected keys id, name, and email.

This approach ensures the test is reliable, readable, and follows Spring Boot testing best practices.

Common Mistakes - 4 Pitfalls

Hardcoding the server port instead of using @LocalServerPort

Not checking the HTTP status code before accessing the response body

Using raw Object or String for response body without proper type

Not using @SpringBootTest with webEnvironment RANDOM_PORT

Bonus Challenge

Now add data-driven testing to verify GET /api/users returns expected fields for 3 different endpoints: /api/users, /api/admins, /api/guests

Show Hint

Practice

1. What is the primary purpose of TestRestTemplate in JUnit testing?

easy

A. To mock database connections during tests

B. To send real HTTP requests to test REST APIs

C. To generate random test data for unit tests

D. To create UI components for testing

Solution

1. Step 1: Understand the role of TestRestTemplate

   TestRestTemplate is designed to send actual HTTP requests to REST APIs during integration tests.

2. Step 2: Compare with other options

   Mocking databases, generating test data, or creating UI components are unrelated to TestRestTemplate's purpose.

3. Final Answer:

   To send real HTTP requests to test REST APIs -> Option B

4. Quick Check:

   TestRestTemplate = Real HTTP requests [OK]

Hint: Remember: TestRestTemplate sends real HTTP calls [OK]

Common Mistakes:

• Confusing TestRestTemplate with mocking tools
• Thinking it generates test data
• Assuming it tests UI components

2. Which of the following is the correct way to autowire TestRestTemplate in a Spring Boot test class?

easy

A. @Autowired private TestRestTemplate restTemplate;

B. private TestRestTemplate restTemplate = new TestRestTemplate();

C. @InjectMocks private TestRestTemplate restTemplate;

D. private TestRestTemplate restTemplate = null;

Solution

1. Step 1: Identify correct Spring Boot injection

   In Spring Boot tests, @Autowired is used to inject TestRestTemplate automatically.

2. Step 2: Evaluate other options

   Creating a new instance manually or using @InjectMocks is incorrect for TestRestTemplate injection in Spring Boot tests.

3. Final Answer:

   @Autowired private TestRestTemplate restTemplate; -> Option A

4. Quick Check:

   Use @Autowired for TestRestTemplate injection [OK]

Hint: Use @Autowired to inject TestRestTemplate [OK]

Common Mistakes:

• Manually instantiating TestRestTemplate
• Using @InjectMocks instead of @Autowired
• Leaving the variable null without injection

3. Given the following test code snippet using TestRestTemplate:

ResponseEntity<String> response = restTemplate.getForEntity("/api/users/1", String.class);
int statusCode = response.getStatusCodeValue();
String body = response.getBody();

If the API returns HTTP 200 with body "User Found", what will be the values of statusCode and body?

medium

A. statusCode = 404, body = null

B. statusCode = 500, body = "Error"

C. statusCode = 200, body = "User Found"

D. statusCode = 200, body = null

Solution

1. Step 1: Understand getForEntity behavior

   getForEntity sends a GET request and returns the full response including status and body.

2. Step 2: Match API response to variables

   Since API returns 200 and "User Found", statusCode will be 200 and body will be "User Found".

3. Final Answer:

   statusCode = 200, body = "User Found" -> Option C

4. Quick Check:

   API 200 + body = statusCode 200 & body "User Found" [OK]

Hint: getForEntity returns status and body as received [OK]

Common Mistakes:

• Assuming body is null on success
• Confusing status codes with error codes
• Ignoring response body content

4. Consider this test code using TestRestTemplate:

@Autowired
private TestRestTemplate restTemplate;

@Test
public void testGetUser() {
    ResponseEntity<String> response = restTemplate.getForEntity("/api/users/", String.class);
    assertEquals(200, response.getStatusCodeValue());
}

What is the likely problem with this test?

medium

A. The URL is missing a user ID, causing a 404 error

B. The assertion should check for 404 instead of 200

C. TestRestTemplate cannot be autowired

D. ResponseEntity<String> is not a valid return type

Solution

1. Step 1: Analyze the request URL

   The URL "/api/users/" lacks a specific user ID, so the endpoint may not exist or return a list, not a single user.

2. Step 2: Understand the assertion failure cause

   Expecting status 200 for a missing user ID endpoint may cause a 404 error, failing the test.

3. Final Answer:

   The URL is missing a user ID, causing a 404 error -> Option A

4. Quick Check:

   Missing ID in URL causes 404, not 200 [OK]

Hint: Check URL completeness before asserting status [OK]

Common Mistakes:

• Assuming URL without ID returns 200
• Wrong assertion status code
• Thinking autowiring is the issue

5. You want to test a POST API endpoint /api/users that creates a user and returns HTTP 201 with the created user JSON. Which TestRestTemplate method and assertion combination correctly tests this?

hard

A. Use delete with user ID, then assert status 204

B. Use getForEntity with user ID, then assert status 200

C. Use exchange with GET method, then assert status 404

D. Use postForEntity with user object, then assert status 201 and response body contains user data

Solution

1. Step 1: Identify correct HTTP method for creation

   POST is used to create resources, so postForEntity is appropriate for sending the user object.

2. Step 2: Validate expected response and assertions

   The API returns 201 Created with user JSON, so assert status 201 and check response body contains user data.

3. Final Answer:

   Use postForEntity with user object, then assert status 201 and response body contains user data -> Option D

4. Quick Check:

   POST + postForEntity + assert 201 + check body [OK]

Hint: POST creation uses postForEntity and assert 201 [OK]

Common Mistakes:

• Using GET instead of POST for creation
• Asserting wrong status codes
• Ignoring response body validation