Spring Boot Testing — Flaky CI/CD from Mockito Static Leaks

package io.thecodeforge.controller;

import io.thecodeforge.model.Product;
import io.thecodeforge.service.ProductService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;

import java.math.BigDecimal;
import java.util.NoSuchElementException;

import static org.mockito.BDDMockito.given;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

/**
 * @WebMvcTest loads only the web layer:
 *   - The specified controller
 *   - Spring MVC infrastructure and MockMvc
 *   - Jackson for JSON serialisation
 *
 * It does NOT load:
 *   - Service beans (provide via @MockBean)
 *   - Repository beans
 *   - Security configuration by default
 *
 * This makes it 10-50x faster than @SpringBootTest for controller testing.
 */
@WebMvcTest(ProductController.class)
class ProductControllerTest {

    @Autowired
    private MockMvc mockMvc;

    // @MockBean replaces the real ProductService bean in the Spring context
    // @Mock would not work here — there is no @InjectMocks in a Spring slice test
    @MockBean
    private ProductService productService;

    @Test
    void shouldReturnOkStatusAndProductJson() throws Exception {
        // Arrange — BDD style: given a product exists
        Product forgeItem = new Product(1L, "Cloud Core", new BigDecimal("45.00"));
        given(productService.getProductById(1L)).willReturn(forgeItem);

        // Act + Assert
        mockMvc.perform(get("/api/v1/products/1")
                       .accept(MediaType.APPLICATION_JSON))
               .andExpect(status().isOk())
               .andExpect(content().contentType(MediaType.APPLICATION_JSON))
               .andExpect(jsonPath("$.name").value("Cloud Core"))
               .andExpect(jsonPath("$.price").value(45.00));
    }

    @Test
    void shouldReturn404WhenProductDoesNotExist() throws Exception {
        // Arrange — stub the failure path
        given(productService.getProductById(99L))
                .willThrow(new NoSuchElementException("Product not found: 99"));

        // Act + Assert — verifies that the controller maps the exception to 404
        // This test only passes if GlobalExceptionHandler is loaded in the slice
        mockMvc.perform(get("/api/v1/products/99")
                       .accept(MediaType.APPLICATION_JSON))
               .andExpect(status().isNotFound());
    }
}

package io.thecodeforge.controller;

import io.thecodeforge.model.Product;
import io.thecodeforge.service.ProductService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;

import java.math.BigDecimal;
import java.util.List;

import static org.mockito.BDDMockito.given;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

@WebMvcTest(ProductController.class)
class ProductControllerJsonPathTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private ProductService productService;

    @Test
    void shouldReturnProductWithJsonPathAssertions() throws Exception {
        // Arrange
        Product product = new Product(1L, "Forge Blade", new BigDecimal("99.99"));
        given(productService.getProductById(1L)).willReturn(product);

        // Act & Assert
        mockMvc.perform(get("/api/v1/products/1")
                       .accept(MediaType.APPLICATION_JSON))
               .andExpect(status().isOk())                          // Status code assertion
               .andExpect(content().contentType(MediaType.APPLICATION_JSON)) // Content type assertion
               .andExpect(jsonPath("$.id").value(1))                // Top-level field
               .andExpect(jsonPath("$.name").value("Forge Blade")) // String field
               .andExpect(jsonPath("$.price").value(99.99));        // Numeric field
    }

    @Test
    void shouldReturnListOfProducts() throws Exception {
        // Arrange
        List<Product> products = List.of(
            new Product(1L, "Forge Blade", new BigDecimal("99.99")),
            new Product(2L, "Cloud Core", new BigDecimal("45.00"))
        );
        given(productService.getAllProducts()).willReturn(products);

        // Act & Assert
        mockMvc.perform(get("/api/v1/products")
                       .accept(MediaType.APPLICATION_JSON))
               .andExpect(status().isOk())
               .andExpect(jsonPath("$.length()").value(2))          // Array length
               .andExpect(jsonPath("$[0].name").value("Forge Blade")) // First element
               .andExpect(jsonPath("$[1].price").value(45.00));      // Second element price
    }

    @Test
    void shouldReturnErrorJsonWhenNotFound() throws Exception {
        // Arrange
        given(productService.getProductById(99L))
                .willThrow(new RuntimeException("Not found"));

        // Act & Assert
        mockMvc.perform(get("/api/v1/products/99")
                       .accept(MediaType.APPLICATION_JSON))
               .andExpect(status().isInternalServerError())
               .andExpect(jsonPath("$.error").exists());           // Check field exists, but not value
    }
}

package io.thecodeforge.service;

import io.thecodeforge.model.Product;
import io.thecodeforge.repository.ProductRepository;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;

import java.math.BigDecimal;

import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.STRICT_STUBS)
class ProductServiceCaptorTest {

    @Mock
    private ProductRepository repository;

    @InjectMocks
    private ProductService productService;

    // Declare the captor as a field — @Captor initializes it via MockitoExtension
    @Captor
    private ArgumentCaptor<Product> productCaptor;

    @Test
    @org.junit.jupiter.api.DisplayName("save: persists product with correct name and price")
    void shouldPersistProductWithCorrectFields() {
        // Arrange
        Product input = new Product(null, "  Forge Blade  ", new BigDecimal("99.99"));
        Product savedProduct = new Product(1L, "Forge Blade", new BigDecimal("99.99"));
        when(repository.save(org.mockito.ArgumentMatchers.any(Product.class)))
                .thenReturn(savedProduct);

        // Act
        productService.save(input);

        // Assert — capture what actually reached the repository
        // verify() MUST come before getValue() — the captor populates during verify
        verify(repository).save(productCaptor.capture());
        Product captured = productCaptor.getValue();

        // Now inspect the object that the service passed to the repository
        // This tests the transformation logic, not just that save() was called
        assertThat(captured.name()).isEqualTo("Forge Blade");
        assertThat(captured.price()).isEqualByComparingTo("99.99");
    }

    @Test
    @org.junit.jupiter.api.DisplayName("save: ID is null on the entity passed to repository")
    void shouldPassNullIdToRepository() {
        // Arrange — ID generation is the database's job, not the service's
        Product input = new Product(null, "Forge Blade", new BigDecimal("99.99"));
        when(repository.save(org.mockito.ArgumentMatchers.any(Product.class)))
                .thenReturn(new Product(1L, "Forge Blade", new BigDecimal("99.99")));

        // Act
        productService.save(input);

        // Assert
        verify(repository).save(productCaptor.capture());
        assertThat(productCaptor.getValue().id()).isNull();
    }
}

package io.thecodeforge.service;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;

import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.Mockito.*;

/**
 * NotificationService.java (referenced by tests below)
 *
 * @Service
 * public class NotificationService {
 *     private final EmailClient emailClient;
 *
 *     public NotificationService(EmailClient emailClient) {
 *         this.emailClient = emailClient;
 *     }
 *
 *     public void notifyUser(String email, String message) {\n *         try {\n *             emailClient.send(email, message);\n *         } catch (EmailDeliveryException e) {
 *             throw new RuntimeException("Notification failed for: " + email, e);
 *         }
 *     }
 * }
 */
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.STRICT_STUBS)
class NotificationServiceTest {

    @Mock
    private EmailClient emailClient; // EmailClient.send() is a void method

    @InjectMocks
    private NotificationService notificationService;

    @Test
    @DisplayName("notifyUser: delegates to emailClient with correct arguments")
    void shouldDelegateToEmailClientWithCorrectArgs() {
        // Arrange — void methods do nothing by default; doNothing() makes intent explicit
        doNothing().when(emailClient).send("user@forge.io", "Welcome!");

        // Act
        notificationService.notifyUser("user@forge.io", "Welcome!");

        // Assert — verify the side effect occurred with the right arguments
        verify(emailClient, times(1)).send("user@forge.io", "Welcome!");
    }

    @Test
    @DisplayName("notifyUser: wraps EmailDeliveryException in RuntimeException")
    void shouldWrapEmailClientExceptionInRuntimeException() {
        // Arrange — use doThrow().when() syntax for void methods
        // NOT when(emailClient.send(...)).thenThrow() — that syntax does not work on void methods
        doThrow(new EmailDeliveryException("SMTP connection refused"))
                .when(emailClient).send(anyString(), anyString());

        // Act + Assert — verify that the service wraps and rethrows correctly
        assertThatThrownBy(() -> notificationService.notifyUser("user@forge.io", "Welcome!"))
                .isInstanceOf(RuntimeException.class)
                .hasMessageContaining("Notification failed for: user@forge.io")
                .hasCauseInstanceOf(EmailDeliveryException.class);
    }

    @Test
    @DisplayName("notifyUser: does not call emailClient when email is blank")
    void shouldNotCallEmailClientWhenEmailIsBlank() {
        // Act — call with empty email (assumes service has a guard clause)
        // notificationService.notifyUser("", "Welcome!");

        // If the guard clause exists, emailClient.send() should never be called
        // verifyNoInteractions() confirms the mock was untouched
        // This test would be enabled once the guard clause is implemented
        verifyNoInteractions(emailClient);
    }
}

package io.thecodeforge.repository;

import io.thecodeforge.model.Product;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
import org.springframework.test.context.ActiveProfiles;

import java.math.BigDecimal;
import java.util.List;
import java.util.Optional;

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

/**
 * @DataJpaTest loads:
 *   - JPA infrastructure (Hibernate, EntityManager)
 *   - Embedded H2 database configured to replace your real datasource
 *   - Your @Repository beans
 *   - Flyway/Liquibase migrations if present
 *
 * @DataJpaTest does NOT load:
 *   - @Service, @Controller, @Component beans
 *   - Security configuration
 *   - The full application context
 *
 * Each test runs in a transaction rolled back on completion — no cleanup needed.
 * To test with a real PostgreSQL database instead of H2, add:
 *   @AutoConfigureTestDatabase(replace = Replace.NONE)
 *   @Testcontainers with a static @Container PostgreSQLContainer
 */
@DataJpaTest
class ProductRepositoryTest {

    @Autowired
    private ProductRepository repository;

    @BeforeEach
    void setUp() {
        // Each test gets a clean, rolled-back transaction.
        // setUp() here demonstrates @BeforeEach placement — use it for
        // test data that every test in this class needs.
        repository.deleteAll();
    }

    @Test
    @DisplayName("findById: returns product when it exists")
    void shouldFindProductById() {
        // Arrange — save a product to the embedded H2
        Product saved = repository.save(
                new Product(null, "Forge Blade", new BigDecimal("99.99")));

        // Act
        Optional<Product> found = repository.findById(saved.id());

        // Assert
        assertThat(found).isPresent();
        assertThat(found.get().name()).isEqualTo("Forge Blade");
    }

    @Test
    @DisplayName("findAll: returns all persisted products")
    void shouldReturnAllProducts() {
        // Arrange
        repository.save(new Product(null, "Forge Blade", new BigDecimal("99.99")));
        repository.save(new Product(null, "Cloud Core", new BigDecimal("45.00")));

        // Act
        List<Product> products = repository.findAll();

        // Assert
        assertThat(products).hasSize(2);
        assertThat(products).extracting(Product::name)
                            .containsExactlyInAnyOrder("Forge Blade", "Cloud Core");
    }

    @Test
    @DisplayName("save: persists product and generates ID")
    void shouldGenerateIdOnSave() {
        // Arrange
        Product newProduct = new Product(null, "Anvil Pro", new BigDecimal("199.00"));

        // Act
        Product saved = repository.save(newProduct);

        // Assert — ID is assigned by the database, not the application
        assertThat(saved.id()).isNotNull();
        assertThat(saved.id()).isGreaterThan(0L);
    }

    @Test
    @DisplayName("delete: removes product from database")
    void shouldDeleteProduct() {
        // Arrange
        Product saved = repository.save(
                new Product(null, "Deprecated Blade", new BigDecimal("1.00")));

        // Act
        repository.deleteById(saved.id());

        // Assert
        assertThat(repository.findById(saved.id())).isEmpty();
    }
}

package io.thecodeforge.repository;

import io.thecodeforge.model.Product;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
import org.springframework.test.context.DynamicPropertyRegistry;
import org.springframework.test.context.DynamicPropertySource;
import org.testcontainers.containers.PostgreSQLContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;

import java.math.BigDecimal;
import java.util.List;
import java.util.Optional;

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

/**
 * This test class demonstrates using Testcontainers with @DataJpaTest.
 * - @Testcontainers enables lifecycle management of containers
 * - @Container marks the container to start before tests and stop after
 * - @DynamicPropertySource overrides Spring Boot datasource properties
 * - @AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE) 
 *   tells Spring not to replace the real datasource with H2
 *
 * In a real project you'd also add:
 *   @AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
 * right below @DataJpaTest.
 */
@Testcontainers
@DataJpaTest
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
class ProductRepositoryTestcontainersTest {

    @Container
    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:15")
            .withDatabaseName("testdb")
            .withUsername("test")
            .withPassword("test");

    @DynamicPropertySource
    static void configureProperties(DynamicPropertyRegistry registry) {
        registry.add("spring.datasource.url", postgres::getJdbcUrl);
        registry.add("spring.datasource.username", postgres::getUsername);
        registry.add("spring.datasource.password", postgres::getPassword);
        // Ensure Hibernate uses PostgreSQL dialect
        registry.add("spring.jpa.properties.hibernate.dialect", 
                     () -> "org.hibernate.dialect.PostgreSQLDialect");
    }

    @Autowired
    private ProductRepository repository;

    @Test
    @DisplayName("should persist and find product using real PostgreSQL")
    void shouldPersistAndFind() {
        // Arrange
        Product product = new Product(null, "PG Blade", new BigDecimal("99.99"));
        Product saved = repository.save(product);

        // Act
        Optional<Product> found = repository.findById(saved.id());

        // Assert
        assertThat(found).isPresent();
        assertThat(found.get().name()).isEqualTo("PG Blade");
    }

    @Test
    @DisplayName("should enforce unique constraint (real DB only)")
    void shouldEnforceUniqueConstraint() {
        // Assumes a unique constraint exists on name
        // This test would pass on H2 but catch real constraint violations on PostgreSQL
        repository.save(new Product(null, "UniqueName", new BigDecimal("10.00")));
        org.junit.jupiter.api.Assertions.assertThrows(
                org.springframework.dao.DataIntegrityViolationException.class,
                () -> repository.save(new Product(null, "UniqueName", new BigDecimal("20.00")))
        );
    }
}

// For this to compile, add these dependencies to your pom.xml:
// <dependency>
//     <groupId>org.testcontainers</groupId>
//     <artifactId>testcontainers</artifactId>
//     <scope>test</scope>
// </dependency>
// <dependency>
//     <groupId>org.testcontainers</groupId>
//     <artifactId>postgresql</artifactId>
//     <scope>test</scope>
// </dependency>
// <dependency>
//     <groupId>org.testcontainers</groupId>
//     <artifactId>junit-jupiter</artifactId>
//     <scope>test</scope>
// </dependency>

// io.thecodeforge
class UserServiceTest {

    @Mock
    private UserRepository userRepository;

    @InjectMocks
    private UserService userService;

    @Test
    void shouldReturnUserWhenFound() {
        User mockUser = new User(1L, "Alice");
        when(userRepository.findById(1L)).thenReturn(Optional.of(mockUser));

        User result = userService.getUserById(1L);

        assertEquals("Alice", result.name());
        // Mockito.verify() ensures the interaction happened
        verify(userRepository).findById(1L);
    }
}

// io.thecodeforge
class OrderServiceTest {

    @Mock
    private PaymentGateway paymentGateway;

    @InjectMocks
    private OrderService orderService;

    @Test
    void shouldProcessPayment() {
        when(paymentGateway.charge(100.0)).thenReturn(true);

        boolean result = orderService.submitOrder(100.0);

        assertTrue(result);
        verify(paymentGateway).charge(100.0);
    }

    // Bad: hidden behavior in test setup
    // given(paymentGateway.charge(100.0)).willReturn(true);
}