Spring Boot Application Testing : Introduction

Testing is a crucial aspect of any software development lifecycle. With Spring Boot, testing becomes easier thanks to its robust testing support out-of-the-box. In this post, we’ll cover the essentials of Spring Boot application testing, including how to write unit tests, integration tests, and utilize the Spring TestContext framework effectively.

Whether you’re new to testing or just new to Spring Boot, this guide will help you set up and write your first test cases quickly and cleanly.

📦 Maven Dependencies

To get started make sure your pom.xml includes the following dependencies:

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-test</artifactId>

</dependency>

<groupId>org.mockito</groupId>

<artifactId>mockito-core</artifactId>

</dependency>

</dependencies>

The spring-boot-starter-test includes JUnit 5, Hamcrest, Mockito, AssertJ, and Spring Test libraries, which are all commonly used for application testing.

🧩 Project Structure

src

├── main

│ └── java

│ └── com

│ └── kscodes

│ └── springboot

│ ├── controller

│ ├── service

│ └── model

└── test

└── java

└── com

└── kscodes

└── springboot

├── controller

├── service

🧪 Unit Testing with JUnit 5 and Mockito

Let’s test a simple service method using Mockito.

👨‍💻 Example Service Class

package com.kscodes.springboot.service;

import org.springframework.stereotype.Service;

@Service

public class CalculatorService {

public int add(int a, int b) {

return a + b;

}

✅ Test Class for CalculatorService

package com.kscodes.springboot.service;

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;

public class CalculatorServiceTest {

private final CalculatorService calculatorService = new CalculatorService();

@Test

public void testAdd() {

int result = calculatorService.add(2, 3);

assertEquals(5, result);

}

This is a basic unit test with JUnit 5, part of Spring Boot testing best practices. It tests individual components without requiring Spring’s ApplicationContext.

🔄 Integration Testing with @SpringBootTest

When you want to test your full application context, use @SpringBootTest.

📁 Controller Example

package com.kscodes.springboot.controller;

import com.kscodes.springboot.service.CalculatorService;

import org.springframework.web.bind.annotation.*;

@RestController

@RequestMapping("/api")

public class CalculatorController {

private final CalculatorService calculatorService;

public CalculatorController(CalculatorService calculatorService) {

this.calculatorService = calculatorService;

}

@GetMapping("/add")

public int add(@RequestParam int a, @RequestParam int b) {

return calculatorService.add(a, b);

}

🧪 Test Using TestRestTemplate

package com.kscodes.springboot.controller;

import org.junit.jupiter.api.Test;

import org.springframework.boot.test.context.SpringBootTest;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.boot.test.web.client.TestRestTemplate;

import static org.assertj.core.api.Assertions.assertThat;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)

public class CalculatorControllerIntegrationTest {

@Autowired

private TestRestTemplate restTemplate;

@Test

public void testAddEndpoint() {

int result = this.restTemplate.getForObject("/api/add?a=5&b=10", Integer.class);

assertThat(result).isEqualTo(15);

}

Using TestRestTemplate allows you to test REST endpoints end-to-end, a powerful part of Spring Boot application testing strategies.

🎯 Best Practices for Spring Boot Application Testing

Use @MockBean to mock dependencies inside integration tests.
Prefer unit tests for logic-heavy components and services.
Use @WebMvcTest when you want to test controllers without loading the full Spring context.
Group tests by feature or module.
Avoid testing framework-specific behavior unless absolutely necessary.

📚 Summary

In this post, we introduced the basics of Spring Boot application testing, including:

Adding the right test dependencies.
Writing unit tests with JUnit 5.
Mocking components with Mockito.
Writing integration tests with @SpringBootTest and TestRestTemplate.

Testing is not just about coverage—it’s about confidence in your application. The better your tests, the faster you can iterate and deploy.

Stay tuned for our upcoming deep-dives into mocking, testcontainers, and performance testing in Spring Boot!