Testing in Spring Boot: A Beginner-Friendly Guide
Learn to test Spring Boot apps: why testing matters, JUnit + Mockito + AssertJ, unit tests with Arrange-Act-Assert, mocking dependencies, and testing endpoints with MockMvc.
How do you know your code actually works — and keeps working after you change something? You test it. Automated tests are what separate hobby projects from professional software, and they're a skill employers specifically look for. The good news: Spring Boot has excellent, beginner-friendly testing support built right in. This lesson gives you the practical foundation.
Why bother writing tests?
- Confidence — change code freely, knowing tests will catch anything you break.
- Fewer bugs — problems are found on your machine, not by your users in production.
- Living documentation — a good test shows exactly how a piece of code is meant to behave.
- Employability — "writes tests" is a genuine differentiator for junior developers.
The tools: JUnit + Spring Boot Test
Spring Boot's spring-boot-starter-test (included by default in new projects) bundles everything you need: JUnit 5 (the test framework), Mockito (for fakes), and AssertJ (readable assertions). You write tests in src/test/java, mirroring your main code's package structure.
A basic unit test
A unit test checks one small piece of logic in isolation. The structure follows a simple, memorable pattern — Arrange, Act, Assert:
class CalculatorTest { @Test void adds_two_numbers() { Calculator calc = new Calculator(); // Arrange int result = calc.add(2, 3); // Act assertThat(result).isEqualTo(5); // Assert } }
@Test— marks a method as a test JUnit should run.- Arrange the objects, Act by calling the method, Assert the result is what you expect.
assertThat(...).isEqualTo(...)(AssertJ) reads almost like English — and fails the test loudly if it's wrong.
Testing a service with mocks
Services usually depend on other components (like a repository). In a unit test you don't want to hit a real database — so you use a mock: a fake stand-in you control. Mockito makes this clean:
@ExtendWith(MockitoExtension.class) class UserServiceTest { @Mock UserRepository repo; // a fake repository @InjectMocks UserService service; // real service, fake repo injected @Test void finds_user_by_id() { // tell the mock what to return when(repo.findById(1L)).thenReturn(Optional.of(new User("Alice"))); User user = service.findById(1L); // Act assertThat(user.getName()).isEqualTo("Alice"); // Assert } }
The mock lets you test your service's logic without a database, network, or any real dependency — fast and reliable. You say "when the repo is asked for id 1, pretend it returns Alice," then verify your service behaves correctly with that input.
Testing a web endpoint
To test controllers, Spring gives you MockMvc — it simulates HTTP requests without starting a real server:
@WebMvcTest(UserController.class) class UserControllerTest { @Autowired MockMvc mockMvc; @Test void returns_200_for_users() throws Exception { mockMvc.perform(get("/api/users")) .andExpect(status().isOk()); // expect HTTP 200 } }
@SpringBootTest), and only a handful of slow end-to-end tests. Most of your tests should be quick unit tests — they give the best return for the least time.
Start small — it's a habit, not a burden
You don't need 100% coverage or perfect tests to benefit. Start by testing your most important business logic — the calculations, the rules, the things that would hurt most if they broke. Even a handful of tests dramatically increases your confidence. The habit grows naturally from there.
I'll be honest: testing felt like a chore I could skip when I was starting out — until the first time a test caught a bug I'd have shipped straight to users. After that, I was converted. The mindset shift that helped me: a test isn't extra work, it's a tiny insurance policy that lets you change code fearlessly. You don't have to test everything at once; just start with your trickiest business logic and the Arrange-Act-Assert pattern above. Writing testable code (thanks to dependency injection — you can inject mocks!) also naturally makes your code cleaner. It's a skill that pays for itself quickly.
Key takeaways
- Automated tests give confidence, catch bugs early, document behaviour, and boost employability.
- Spring Boot bundles JUnit 5, Mockito, and AssertJ via
spring-boot-starter-test. - Write unit tests with Arrange-Act-Assert; use mocks to isolate a class from its dependencies.
- Test controllers with
MockMvc; follow the testing pyramid (mostly fast unit tests). Start small.
← Previous: Spring Lesson 10 — Security & JWT
Next: Spring Lesson 12 — Spring Boot with PostgreSQL →
↑ Back to the Spring Boot roadmap