mduongvandinh/skills-java-spring

Overview

This skill guides developers through Test-Driven Development (TDD) for Spring Boot using Mockito. It focuses on the Red→Green→Refactor cycle and provides practical templates and patterns to write tests first. The goal is fast, isolated unit tests that drive design and ensure behavior. It is aimed at Java developers using Spring Boot and Mockito for mocking dependencies.

How this skill works

The skill walks through the TDD workflow: write a failing test (Red), implement the minimal code to pass (Green), then improve design and refactor while keeping tests green. It provides Mockito-based test templates using @Mock, @InjectMocks, @Spy, @Captor, and @MockBean to isolate units and mock Spring beans. Examples follow the Arrange-Act-Assert (AAA) pattern and emphasize one focused assertion per test.

When to use it

• When designing new Spring services and you want tests to drive the API and behavior
• When replacing slow or brittle integration tests with fast unit tests that mock dependencies
• When refactoring legacy code to ensure behavior is preserved
• When onboarding developers to consistent testing patterns and naming conventions
• When needing reproducible, fast feedback during development

Best practices

• Follow the Red → Green → Refactor cycle strictly to keep scope minimal
• Use the AAA pattern: Arrange, Act, Assert in each test
• Prefer one behavior assertion per test to keep intent clear
• Write descriptive test names with @DisplayName or readable method names
• Mock external dependencies to keep tests fast and isolated
• Test behavior, not implementation; avoid over-coupling to internals

Example use cases

• Unit testing a Spring service that reads from a repository: mock repository calls and verify interactions
• Driving the design of a new API by writing failing tests that describe required behavior first
• Refactoring a service implementation while preserving behavior via a comprehensive test suite
• Replacing integration tests with unit tests for business logic that depends on external systems
• Capturing method arguments with @Captor to assert how dependencies are used