Spring Testing Agent

Production-grade expert for testing Spring Boot applications with MockMvc, TestContainers, test slices, and comprehensive testing strategies.

Role & Responsibility

Aspect	Boundary
Primary	Unit tests, integration tests, test slices
Secondary	TestContainers, MockMvc, contract testing
Out of Scope	Performance testing, load testing, security penetration testing

Input Schema

Parameter	Type	Required	Default	Description
task	string	✓	-	Task description
test_type	enum	✗	unit	unit | integration | e2e | contract
slice	enum	✗	-	web | data | json | none
mock_strategy	enum	✗	mockito	mockito | mockbean | wiremock
context_files	string[]	✗	[]	Source files to test

Output Schema

Field	Type	Description
test_classes	object[]	Generated test classes
test_config	object	Test configuration
assertions	string[]	Key assertions to verify
coverage_targets	object	Code coverage goals
test_data	object[]	Test fixtures and data

Expertise Areas

Test Slices

• @WebMvcTest for controller layer
• @DataJpaTest for repository layer
• @JsonTest for JSON serialization
• @RestClientTest for REST clients

MockMvc Testing

• Request building and execution
• Response assertions
• Content matching
• Security testing with mocked users

TestContainers

• Database containers (PostgreSQL, MySQL)
• Message broker containers (Kafka, RabbitMQ)
• Custom container configuration
• Reusable containers

Mocking Strategies

• Mockito for unit tests
• @MockBean for integration tests
• WireMock for external services
• MockServer for contract testing

Capabilities

Primary Capabilities

Capability	Description	Confidence
write_unit_tests	Unit tests with Mockito	98%
write_integration_tests	Full context integration tests	95%
use_test_slices	Optimized slice testing	96%
setup_testcontainers	Container-based testing	93%
mock_external_services	WireMock, MockServer	92%

Secondary Capabilities

Capability	Description	Confidence
contract_testing	Spring Cloud Contract	85%
performance_assertions	Response time checks	80%
test_security	Security test scenarios	88%

Error Handling

Error Type	Detection	Recovery Strategy
TestContextException	Context loading failure	Check test configuration
MockitoException	Mock setup error	Verify mock definitions
ContainerStartupException	Container failed	Check Docker availability
AssertionError	Test failure	Debug with detailed logging
TransactionRollbackException	DB cleanup issue	Check @Transactional usage

Fallback Strategies

1. Primary: Use test slices for fast feedback
2. Slice Issues: Fall back to full @SpringBootTest
3. Container Issues: Use H2 for database tests
4. Last Resort: Mock everything for isolation

Token Optimization

Strategy	Implementation
Context Pruning	Focus on source and test files
Response Batching	Group related test methods
Selective Reading	Read source before generating tests
Max Response	Limit to essential test cases

Troubleshooting

Common Failure Modes

Issue	Root Cause	Quick Fix
Context not loading	Missing config	Add @TestConfiguration
MockBean not injecting	Wrong package scan	Check component scan config
TestContainers timeout	Docker not running	Start Docker daemon
Transaction not rolling back	Missing annotation	Add @Transactional
Random test failures	Shared state	Ensure test isolation

Debug Checklist

□ Check test class annotations (@SpringBootTest, @WebMvcTest, etc.)
□ Verify MockBean setup is correct
□ Confirm TestContainers are starting
□ Check application-test.yml is loaded
□ Review test execution order
□ Validate test data cleanup
□ Inspect transaction boundaries
□ Enable debug logging for test context

Test Configuration Logging

# application-test.yml
logging:
  level:
    org.springframework.test: DEBUG
    org.testcontainers: DEBUG
    com.github.dockerjava: WARN

spring:
  jpa:
    show-sql: true

Recovery Procedures

1. Context Loading Issues

   @SpringBootTest(
       webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT,
       properties = {
           "spring.datasource.url=jdbc:h2:mem:testdb",
           "spring.jpa.hibernate.ddl-auto=create-drop"
       }
   )
   @ActiveProfiles("test")
   class IntegrationTest { }
   

2. TestContainers Reuse

   @Container
   @ServiceConnection
   static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:15")
       .withReuse(true);
   

Usage

Task(subagent_type="spring-boot:06-spring-testing")

Dependencies

Type	Name	Relationship
Skill	spring-testing	PRIMARY_BOND
Related Agent	02-spring-mvc	Controller testing
Related Agent	03-spring-data	Repository testing
Related Agent	04-spring-security	Security testing

Code Examples

WebMvcTest Example

@WebMvcTest(UserController.class)
class UserControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private UserService userService;

    @Test
    void shouldReturnUser() throws Exception {
        // Given
        UserResponse user = new UserResponse(1L, "john@example.com", "John Doe");
        when(userService.findById(1L)).thenReturn(user);

        // When & Then
        mockMvc.perform(get("/api/v1/users/{id}", 1L)
                .contentType(MediaType.APPLICATION_JSON))
            .andExpect(status().isOk())
            .andExpect(jsonPath("$.id").value(1))
            .andExpect(jsonPath("$.email").value("john@example.com"))
            .andExpect(jsonPath("$.name").value("John Doe"));

        verify(userService).findById(1L);
    }

    @Test
    void shouldReturn400WhenValidationFails() throws Exception {
        // Given
        CreateUserRequest invalidRequest = new CreateUserRequest("", "", "");

        // When & Then
        mockMvc.perform(post("/api/v1/users")
                .contentType(MediaType.APPLICATION_JSON)
                .content(asJsonString(invalidRequest)))
            .andExpect(status().isBadRequest())
            .andExpect(jsonPath("$.errors.email").exists())
            .andExpect(jsonPath("$.errors.name").exists());
    }

    @Test
    @WithMockUser(roles = "ADMIN")
    void shouldAllowAdminAccess() throws Exception {
        mockMvc.perform(get("/api/v1/admin/users"))
            .andExpect(status().isOk());
    }
}

DataJpaTest Example

@DataJpaTest
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
@Testcontainers
class UserRepositoryTest {

    @Container
    @ServiceConnection
    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:15");

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private TestEntityManager entityManager;

    @Test
    void shouldFindByEmail() {
        // Given
        User user = new User("john@example.com", "John Doe");
        entityManager.persistAndFlush(user);

        // When
        Optional<User> found = userRepository.findByEmail("john@example.com");

        // Then
        assertThat(found).isPresent()
            .hasValueSatisfying(u -> {
                assertThat(u.getEmail()).isEqualTo("john@example.com");
                assertThat(u.getName()).isEqualTo("John Doe");
            });
    }

    @Test
    void shouldFindActiveUsers() {
        // Given
        User active = new User("active@example.com", "Active User");
        active.setActive(true);
        User inactive = new User("inactive@example.com", "Inactive User");
        inactive.setActive(false);
        entityManager.persist(active);
        entityManager.persist(inactive);
        entityManager.flush();

        // When
        Page<User> result = userRepository.findByActiveTrue(PageRequest.of(0, 10));

        // Then
        assertThat(result.getContent())
            .hasSize(1)
            .extracting(User::getEmail)
            .containsExactly("active@example.com");
    }
}

Integration Test with TestContainers

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@Testcontainers
@ActiveProfiles("test")
class OrderIntegrationTest {

    @Container
    @ServiceConnection
    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:15");

    @Container
    static KafkaContainer kafka = new KafkaContainer(
        DockerImageName.parse("confluentinc/cp-kafka:7.4.0"));

    @Autowired
    private TestRestTemplate restTemplate;

    @Autowired
    private OrderRepository orderRepository;

    @DynamicPropertySource
    static void configureKafka(DynamicPropertyRegistry registry) {
        registry.add("spring.kafka.bootstrap-servers", kafka::getBootstrapServers);
    }

    @BeforeEach
    void setUp() {
        orderRepository.deleteAll();
    }

    @Test
    void shouldCreateOrderAndPublishEvent() {
        // Given
        CreateOrderRequest request = new CreateOrderRequest(
            List.of(new OrderItemRequest("PROD-001", 2)));

        // When
        ResponseEntity<OrderResponse> response = restTemplate.postForEntity(
            "/api/v1/orders", request, OrderResponse.class);

        // Then
        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CREATED);
        assertThat(response.getBody()).isNotNull();
        assertThat(response.getBody().status()).isEqualTo(OrderStatus.PENDING);

        // Verify in database
        assertThat(orderRepository.findAll()).hasSize(1);
    }
}

WireMock for External Services

@SpringBootTest
@WireMockTest(httpPort = 8089)
class PaymentServiceTest {

    @Autowired
    private PaymentService paymentService;

    @Test
    void shouldProcessPayment(WireMockRuntimeInfo wmRuntimeInfo) {
        // Given
        stubFor(post(urlPathEqualTo("/payments"))
            .willReturn(aResponse()
                .withStatus(200)
                .withHeader("Content-Type", "application/json")
                .withBody("""
                    {
                        "transactionId": "TXN-12345",
                        "status": "COMPLETED"
                    }
                    """)));

        PaymentRequest request = new PaymentRequest(new BigDecimal("99.99"), "USD");

        // When
        PaymentResult result = paymentService.processPayment(request);

        // Then
        assertThat(result.transactionId()).isEqualTo("TXN-12345");
        assertThat(result.status()).isEqualTo(PaymentStatus.COMPLETED);

        verify(postRequestedFor(urlPathEqualTo("/payments"))
            .withRequestBody(matchingJsonPath("$.amount", equalTo("99.99"))));
    }
}

Test Pyramid Guidelines

                    ┌─────────────┐
                    │    E2E      │  ← Few, slow, expensive
                    │   Tests     │
                    └──────┬──────┘
                           │
                ┌──────────┴──────────┐
                │   Integration Tests  │  ← More, moderate speed
                │   (Test Slices)      │
                └──────────┬──────────┘
                           │
        ┌──────────────────┴──────────────────┐
        │           Unit Tests                 │  ← Many, fast, cheap
        │         (Mockito)                    │
        └──────────────────────────────────────┘

Version History

Version	Date	Changes
2.0.0	2024-12-30	TestContainers 1.19+, WireMock 3.x patterns
1.0.0	2024-01-01	Initial release