[Spring Boot Basics] Unit test trong Spring Boot: JUnit 6, AssertJ và Mockito cho tầng Service

package com.example.demo.product;
 
import java.math.BigDecimal;
 
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
 
@Entity
@Table(name = "products")
public class Product {
 
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
 
    @Column(nullable = false)
    private String name;
 
    @Column(nullable = false, unique = true)
    private String sku;
 
    @Column(nullable = false, precision = 12, scale = 2)
    private BigDecimal price;
 
    @Column(nullable = false)
    private int stock;
 
    protected Product() {
    }
 
    public Product(String name, String sku, BigDecimal price, int stock) {
        this.name = name;
        this.sku = sku;
        this.price = price;
        this.stock = stock;
    }
 
    public void decreaseStock(int quantity) {
        if (quantity <= 0) {
            throw new IllegalArgumentException("Quantity must be positive, was " + quantity);
        }
        if (quantity > stock) {
            throw new InsufficientStockException(sku, stock, quantity);
        }
        stock -= quantity;
    }
 
    // getters for id, name, sku, price and stock
}

package com.example.demo.product;
 
public class InsufficientStockException extends RuntimeException {
 
    public InsufficientStockException(String sku, int available, int requested) {
        super("Only " + available + " of " + sku + " in stock, " + requested + " requested");
    }
}

package com.example.demo.product;
 
import org.springframework.data.jpa.repository.JpaRepository;
 
public interface ProductRepository extends JpaRepository<Product, Long> {
 
    boolean existsBySku(String sku);
}

package com.example.demo.product;
 
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
@Service
@Transactional(readOnly = true)
public class ProductService {
 
    private final ProductRepository products;
 
    public ProductService(ProductRepository products) {
        this.products = products;
    }
 
    public Product findById(Long id) {
        return products.findById(id).orElseThrow(() -> new ProductNotFoundException(id));
    }
 
    @Transactional
    public Product create(Product product) {
        if (products.existsBySku(product.getSku())) {
            throw new DuplicateSkuException(product.getSku());
        }
        return products.save(product);
    }
}

package com.example.demo.order;
 
import java.math.BigDecimal;
import java.time.Instant;
import java.util.ArrayList;
import java.util.List;
 
import jakarta.persistence.CascadeType;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.OneToMany;
import jakarta.persistence.Table;
 
@Entity
@Table(name = "orders")
public class Order {
 
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
 
    @Column(nullable = false)
    private Instant placedAt;
 
    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL)
    private List<OrderLine> lines = new ArrayList<>();
 
    protected Order() {
    }
 
    public Order(Instant placedAt) {
        this.placedAt = placedAt;
    }
 
    public void addLine(OrderLine line) {
        lines.add(line);
        line.setOrder(this);
    }
 
    public BigDecimal total() {
        return lines.stream()
                .map(OrderLine::lineTotal)
                .reduce(BigDecimal.ZERO, BigDecimal::add);
    }
 
    // getters for id, placedAt and lines
}

package com.example.demo.order;
 
import java.math.BigDecimal;
 
import com.example.demo.product.Product;
 
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.Table;
 
@Entity
@Table(name = "order_lines")
public class OrderLine {
 
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
 
    @ManyToOne
    @JoinColumn(name = "order_id")
    private Order order;
 
    @ManyToOne
    @JoinColumn(name = "product_id")
    private Product product;
 
    @Column(nullable = false)
    private int quantity;
 
    @Column(nullable = false, precision = 12, scale = 2)
    private BigDecimal unitPrice;
 
    protected OrderLine() {
    }
 
    public OrderLine(Product product, int quantity) {
        this.product = product;
        this.quantity = quantity;
        this.unitPrice = product.getPrice();
    }
 
    public BigDecimal lineTotal() {
        return unitPrice.multiply(BigDecimal.valueOf(quantity));
    }
 
    void setOrder(Order order) {
        this.order = order;
    }
 
    // getters for product, quantity and unitPrice
}

package com.example.demo.order;
 
public record OrderItem(Long productId, int quantity) {
}

package com.example.demo.order;
 
import org.springframework.data.jpa.repository.JpaRepository;
 
public interface OrderRepository extends JpaRepository<Order, Long> {
}

package com.example.demo.order;
 
import java.time.Clock;
import java.util.List;
 
import com.example.demo.product.Product;
import com.example.demo.product.ProductNotFoundException;
import com.example.demo.product.ProductRepository;
 
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
@Service
public class OrderService {
 
    private final ProductRepository products;
    private final OrderRepository orders;
    private final Clock clock;
 
    public OrderService(ProductRepository products, OrderRepository orders, Clock clock) {
        this.products = products;
        this.orders = orders;
        this.clock = clock;
    }
 
    @Transactional
    public Order placeOrder(List<OrderItem> items) {
        Order order = new Order(clock.instant());
        for (OrderItem item : items) {
            Product product = products.findById(item.productId())
                    .orElseThrow(() -> new ProductNotFoundException(item.productId()));
            product.decreaseStock(item.quantity());
            order.addLine(new OrderLine(product, item.quantity()));
        }
        return orders.save(order);
    }
}

package com.example.demo.common;
 
import java.time.Clock;
 
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
@Configuration
public class ClockConfig {
 
    @Bean
    Clock clock() {
        return Clock.systemUTC();
    }
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-h2console'
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    implementation 'org.springframework.boot:spring-boot-starter-validation'
    implementation 'org.springframework.boot:spring-boot-starter-webmvc'
    runtimeOnly 'com.h2database:h2'
    testImplementation 'org.springframework.boot:spring-boot-starter-data-jpa-test'
    testImplementation 'org.springframework.boot:spring-boot-starter-validation-test'
    testImplementation 'org.springframework.boot:spring-boot-starter-webmvc-test'
    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
}
 
tasks.named('test') {
    useJUnitPlatform()
}

> Task :test FAILED
 
FAILURE: Build failed with an exception.
 
* What went wrong:
Execution failed for task ':test'.
> There are test sources present and no filters are applied, but the test task did not discover any tests to execute. This is likely due to a misconfiguration. Please check your test configuration. If this is not a misconfiguration, this error can be disabled by setting the 'failOnNoDiscoveredTests' property to false.

> Failed to load JUnit Platform.  Please ensure that all JUnit Platform dependencies are available on the test's runtime classpath, including the JUnit Platform launcher.

./gradlew -q dependencies --configuration testRuntimeClasspath | grep -E -- '--- (org.springframework.boot:spring-boot-starter-test|org.junit.jupiter:junit-jupiter|org.junit.platform:junit-platform-launcher|org.assertj:assertj-core|org.mockito:mockito-core|org.mockito:mockito-junit-jupiter)(:| ->) ?[0-9.]+$'

|    +--- org.springframework.boot:spring-boot-starter-test:4.1.1
|    |    +--- org.assertj:assertj-core:3.27.7
|    |    +--- org.junit.jupiter:junit-jupiter:6.0.3
|    |    +--- org.mockito:mockito-core:5.23.0
|    |    +--- org.mockito:mockito-junit-jupiter:5.23.0
|    |    \--- org.junit.platform:junit-platform-launcher -> 6.0.3

./gradlew test

> Task :compileJava
> Task :processResources
> Task :classes
> Task :compileTestJava
> Task :processTestResources NO-SOURCE
> Task :testClasses
OpenJDK 64-Bit Server VM warning: Sharing is only supported for boot loader classes because bootstrap classpath has been appended
2026-09-16T14:11:24.974+07:00  INFO 92746 --- [demo] [ionShutdownHook] j.LocalContainerEntityManagerFactoryBean : Closing JPA EntityManagerFactory for persistence unit 'default'
2026-09-16T14:11:24.979+07:00  INFO 92746 --- [demo] [ionShutdownHook] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Shutdown initiated...
2026-09-16T14:11:24.981+07:00  INFO 92746 --- [demo] [ionShutdownHook] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Shutdown completed.
> Task :test
 
BUILD SUCCESSFUL in 8s
4 actionable tasks: 4 executed
Consider enabling configuration cache to speed up this build: https://docs.gradle.org/9.7.1/userguide/configuration_cache_enabling.html

> Task :test
 
OrderLineTest > multipliesUnitPriceByQuantity() FAILED
    org.opentest4j.AssertionFailedError at OrderLineTest.java:18
 
2026-09-16T14:12:12.662+07:00  INFO 94022 --- [demo] [ionShutdownHook] j.LocalContainerEntityManagerFactoryBean : Closing JPA EntityManagerFactory for persistence unit 'default'
2026-09-16T14:12:12.667+07:00  INFO 94022 --- [demo] [ionShutdownHook] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Shutdown initiated...
2026-09-16T14:12:12.669+07:00  INFO 94022 --- [demo] [ionShutdownHook] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Shutdown completed.
 
> Task :test FAILED
 
16 tests completed, 1 failed, 1 skipped
 
FAILURE: Build failed with an exception.
 
* What went wrong:
Execution failed for task ':test'.
> There were failing tests. See the report at: file:///.../demo/build/reports/tests/test/index.html

tasks.named('test') {
    useJUnitPlatform()
    testLogging { 
        events 'passed', 'skipped', 'failed'
        showStandardStreams = true
        exceptionFormat = 'full'
    } 
}

./gradlew test --tests OrderLineTest

> Task :test FAILED
 
OrderLineTest > multipliesUnitPriceByQuantity() FAILED
    org.opentest4j.AssertionFailedError: 
    expected: 10.0
     but was: 10.00
        at app//com.example.demo.order.OrderLineTest.multipliesUnitPriceByQuantity(OrderLineTest.java:18)
 
1 test completed, 1 failed

./gradlew test --tests 'OrderServiceTest.savesNothingWhenALineHasTooLittleStock'

OrderServiceTest > savesNothingWhenALineHasTooLittleStock() PASSED
 
BUILD SUCCESSFUL in 1s

./gradlew test --tests '*ServiceTest'

OrderServiceTest > decrementsStockAndSavesTheOrder() PASSED
 
OrderServiceTest > savesNothingWhenALineHasTooLittleStock() PASSED
 
ProductServiceTest > findById > throws ProductNotFoundException for an unknown id PASSED
 
ProductServiceTest > create > rejects a duplicate SKU and never saves PASSED
 
ProductServiceTest > create > saves a product whose SKU is free PASSED
 
BUILD SUCCESSFUL in 1s

package com.example.demo.lab;
 
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
 
class LifecycleTest {
 
    private static int instances = 0;
 
    private final int number;
    private int counter = 0;
 
    LifecycleTest() {
        number = ++instances;
        log("constructor");
    }
 
    @BeforeAll
    static void beforeAll() {
        System.out.println("@BeforeAll   instances so far: " + instances);
    }
 
    @BeforeEach
    void beforeEach() {
        log("@BeforeEach");
    }
 
    @Test
    void incrementsTheCounter() {
        counter++;
        log("test");
    }
 
    @Test
    void incrementsTheCounterAgain() {
        counter++;
        log("test");
    }
 
    @AfterEach
    void afterEach() {
        log("@AfterEach");
    }
 
    @AfterAll
    static void afterAll() {
        System.out.println("@AfterAll    instances created: " + instances);
    }
 
    private void log(String step) {
        System.out.println(step + "  instance #" + number
                + " @" + Integer.toHexString(System.identityHashCode(this))
                + " counter=" + counter);
    }
}

./gradlew test --tests LifecycleTest

LifecycleTest STANDARD_OUT
    @BeforeAll   instances so far: 0
    constructor  instance #1 @590adb41 counter=0
 
LifecycleTest > incrementsTheCounter() STANDARD_OUT
    @BeforeEach  instance #1 @590adb41 counter=0
    test  instance #1 @590adb41 counter=1
    @AfterEach  instance #1 @590adb41 counter=1
 
LifecycleTest > incrementsTheCounter() PASSED
 
LifecycleTest STANDARD_OUT
    constructor  instance #2 @2daf06fc counter=0
 
LifecycleTest > incrementsTheCounterAgain() STANDARD_OUT
    @BeforeEach  instance #2 @2daf06fc counter=0
    test  instance #2 @2daf06fc counter=1
    @AfterEach  instance #2 @2daf06fc counter=1
 
LifecycleTest > incrementsTheCounterAgain() PASSED
 
LifecycleTest STANDARD_OUT
    @AfterAll    instances created: 2

package com.example.demo.lab;
 
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestInstance;
 
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
class PerClassLifecycleTest {
 
    private int counter = 0;
 
    @BeforeAll
    void beforeAll() {
        System.out.println("@BeforeAll  @" + Integer.toHexString(System.identityHashCode(this)));
    }
 
    @Test
    void incrementsTheCounter() {
        counter++;
        System.out.println("test  @" + Integer.toHexString(System.identityHashCode(this)) + " counter=" + counter);
    }
 
    @Test
    void incrementsTheCounterAgain() {
        counter++;
        System.out.println("test  @" + Integer.toHexString(System.identityHashCode(this)) + " counter=" + counter);
    }
}

PerClassLifecycleTest STANDARD_OUT
    @BeforeAll  @f1f7db2
 
PerClassLifecycleTest > incrementsTheCounter() STANDARD_OUT
    test  @f1f7db2 counter=1
 
PerClassLifecycleTest > incrementsTheCounter() PASSED
 
PerClassLifecycleTest > incrementsTheCounterAgain() STANDARD_OUT
    test  @f1f7db2 counter=2
 
PerClassLifecycleTest > incrementsTheCounterAgain() PASSED

@ExtendWith(MockitoExtension.class)
class ProductServiceTest {
 
    // @Mock field and @BeforeEach setUp()
 
    @Nested
    @DisplayName("create")
    class Create {
 
        @Test
        @DisplayName("saves a product whose SKU is free")
        void savesANewProduct() {
            // ...
        }
 
        @Test
        @DisplayName("rejects a duplicate SKU and never saves")
        void rejectsADuplicateSku() {
            // ...
        }
    }
 
    @Nested
    @DisplayName("findById")
    class FindById {
 
        @Test
        @DisplayName("throws ProductNotFoundException for an unknown id")
        void throwsForAnUnknownId() {
            // ...
        }
    }
}

ProductServiceTest > findById > throws ProductNotFoundException for an unknown id PASSED
 
ProductServiceTest > create > rejects a duplicate SKU and never saves PASSED
 
ProductServiceTest > create > saves a product whose SKU is free PASSED

package com.example.demo.product;
 
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.junit.jupiter.params.provider.Arguments.arguments;
 
import java.math.BigDecimal;
import java.util.stream.Stream;
 
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.CsvSource;
import org.junit.jupiter.params.provider.MethodSource;
import org.junit.jupiter.params.provider.ValueSource;
 
class ProductTest {
 
    private static Product keyboardWithStock(int stock) {
        return new Product("Mechanical keyboard", "KB-01", new BigDecimal("89.90"), stock);
    }
 
    @ParameterizedTest
    @ValueSource(ints = {0, -1, -10})
    void rejectsANonPositiveQuantity(int quantity) {
        assertThatIllegalArgumentException()
                .isThrownBy(() -> keyboardWithStock(10).decreaseStock(quantity))
                .withMessage("Quantity must be positive, was " + quantity);
    }
 
    @ParameterizedTest(name = "stock {0} minus {1} leaves {2}")
    @CsvSource({
            "10, 1, 9",
            "10, 10, 0",
            "1, 1, 0"
    })
    void decreasesStock(int stock, int quantity, int remaining) {
        Product keyboard = keyboardWithStock(stock);
        keyboard.decreaseStock(quantity);
        assertThat(keyboard.getStock()).isEqualTo(remaining);
    }
 
    @ParameterizedTest
    @MethodSource("tooLargeQuantities")
    void rejectsMoreThanTheStock(int stock, int quantity, String message) {
        assertThatThrownBy(() -> keyboardWithStock(stock).decreaseStock(quantity))
                .isInstanceOf(InsufficientStockException.class)
                .hasMessage(message);
    }
 
    static Stream<Arguments> tooLargeQuantities() {
        return Stream.of(
                arguments(0, 1, "Only 0 of KB-01 in stock, 1 requested"),
                arguments(3, 4, "Only 3 of KB-01 in stock, 4 requested"));
    }
 
    @Test
    @Disabled("Restocking arrives with the purchasing feature")
    void increasesStockOnRestock() {
    }
}

./gradlew test --tests ProductTest

ProductTest > rejectsMoreThanTheStock(int, int, String) > [1] stock = 0, quantity = 1, message = "Only 0 of KB-01 in stock, 1 requested" PASSED
 
ProductTest > rejectsMoreThanTheStock(int, int, String) > [2] stock = 3, quantity = 4, message = "Only 3 of KB-01 in stock, 4 requested" PASSED
 
ProductTest > increasesStockOnRestock() SKIPPED
 
ProductTest > rejectsANonPositiveQuantity(int) > [1] quantity = 0 PASSED
 
ProductTest > rejectsANonPositiveQuantity(int) > [2] quantity = -1 PASSED
 
ProductTest > rejectsANonPositiveQuantity(int) > [3] quantity = -10 PASSED
 
ProductTest > decreasesStock(int, int, int) > stock "10" minus "1" leaves "9" PASSED
 
ProductTest > decreasesStock(int, int, int) > stock "10" minus "10" leaves "0" PASSED
 
ProductTest > decreasesStock(int, int, int) > stock "1" minus "1" leaves "0" PASSED

    @ParameterizedTest(name = "stock {0} minus {1} leaves {2}") 
    @ParameterizedTest(name = "stock {0} minus {1} leaves {2}", quoteTextArguments = false) 
    @CsvSource({

ProductTest > decreasesStock(int, int, int) > stock 10 minus 1 leaves 9 PASSED
 
ProductTest > decreasesStock(int, int, int) > stock 10 minus 10 leaves 0 PASSED
 
ProductTest > decreasesStock(int, int, int) > stock 1 minus 1 leaves 0 PASSED

package com.example.demo.order;
 
import static org.assertj.core.api.Assertions.assertThat;
 
import java.math.BigDecimal;
 
import com.example.demo.product.Product;
 
import org.junit.jupiter.api.Test;
 
class OrderLineTest {
 
    @Test
    void multipliesUnitPriceByQuantity() {
        Product cable = new Product("USB-C cable", "CB-02", new BigDecimal("5.00"), 50);
        OrderLine line = new OrderLine(cable, 2);
 
        assertThat(line.lineTotal()).isEqualTo(new BigDecimal("10.0"));
    }
}

OrderLineTest > multipliesUnitPriceByQuantity() FAILED
    org.opentest4j.AssertionFailedError: 
    expected: 10.0
     but was: 10.00
        at app//com.example.demo.order.OrderLineTest.multipliesUnitPriceByQuantity(OrderLineTest.java:18)

        assertThat(line.lineTotal()).isEqualTo(new BigDecimal("10.0")); 
        assertThat(line.lineTotal()).isEqualByComparingTo(new BigDecimal("10.0")); 

OrderLineTest > multipliesUnitPriceByQuantity() PASSED

assertThat(order.getLines())
        .extracting(line -> line.getProduct().getStock(), OrderLine::getQuantity)
        .containsExactly(tuple(8, 2), tuple(0, 1));

assertThatThrownBy(() -> service.create(copy))
        .isInstanceOf(DuplicateSkuException.class)
        .hasMessage("SKU KB-01 already exists");

assertThatExceptionOfType(ProductNotFoundException.class)
        .isThrownBy(() -> service.findById(99L))
        .withMessage("Product 99 not found");

package com.example.demo.lab;
 
import static org.assertj.core.api.SoftAssertions.assertSoftly;
 
import java.math.BigDecimal;
import java.time.Instant;
 
import com.example.demo.order.Order;
import com.example.demo.order.OrderLine;
import com.example.demo.product.Product;
 
import org.junit.jupiter.api.Test;
 
class SoftAssertionsTest {
 
    @Test
    void checksTheWholeOrder() {
        Product keyboard = new Product("Mechanical keyboard", "KB-01", new BigDecimal("89.90"), 10);
        Order order = new Order(Instant.parse("2026-11-05T09:00:00Z"));
        order.addLine(new OrderLine(keyboard, 2));
 
        assertSoftly(softly -> {
            softly.assertThat(order.getPlacedAt()).isEqualTo("2026-11-05T10:00:00Z");
            softly.assertThat(order.getLines()).extracting(OrderLine::getQuantity).containsExactly(3);
            softly.assertThat(order.total()).isEqualByComparingTo("179.80");
            softly.assertThat(order.getLines()).hasSize(2);
        });
    }
}

SoftAssertionsTest > checksTheWholeOrder() FAILED
    org.assertj.core.error.AssertJMultipleFailuresError: 
    Multiple Failures (3 failures)
    -- failure 1 --
    expected: 2026-11-05T10:00:00Z
     but was: 2026-11-05T09:00:00Z
    at SoftAssertionsTest.lambda$checksTheWholeOrder$0(SoftAssertionsTest.java:23)
    -- failure 2 --
    Expecting actual:
      [2]
    to contain exactly (and in same order):
      [3]
    but some elements were not found:
      [3]
    and others were not expected:
      [2]
    at SoftAssertionsTest.lambda$checksTheWholeOrder$0(SoftAssertionsTest.java:24)
    -- failure 3 --
    Expected size: 2 but was: 1 in:
    [com.example.demo.order.OrderLine@177c41d7]
    at SoftAssertionsTest.lambda$checksTheWholeOrder$0(SoftAssertionsTest.java:26)
        at app//com.example.demo.lab.SoftAssertionsTest.checksTheWholeOrder(SoftAssertionsTest.java:22)

package com.example.demo.lab;
 
import java.math.BigDecimal;
 
import com.example.demo.product.Product;
import com.example.demo.product.ProductRepository;
 
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
 
@ExtendWith(MockitoExtension.class)
class DefaultAnswersTest {
 
    @Mock
    private ProductRepository products;
 
    @Test
    void unstubbedCallsReturnDefaults() {
        System.out.println("existsBySku(\"KB-01\") -> " + products.existsBySku("KB-01"));
        System.out.println("findById(1L)         -> " + products.findById(1L));
        System.out.println("findAll()            -> " + products.findAll());
        System.out.println("count()              -> " + products.count());
        System.out.println("save(product)        -> " + products.save(new Product("USB-C hub", "HUB-07", new BigDecimal("39.00"), 5)));
        System.out.println("mock                 -> " + products);
        System.out.println("mock class           -> " + products.getClass().getName());
    }
}

DefaultAnswersTest > unstubbedCallsReturnDefaults() STANDARD_OUT
    existsBySku("KB-01") -> false
    findById(1L)         -> Optional.empty
    findAll()            -> []
    count()              -> 0
    save(product)        -> null
    mock                 -> products
    mock class           -> com.example.demo.product.ProductRepository$MockitoMock$CVaIiiSQ
 
DefaultAnswersTest > unstubbedCallsReturnDefaults() PASSED

package com.example.demo.order;
 
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.BDDMockito.given;
import static org.mockito.BDDMockito.then;
 
import java.math.BigDecimal;
import java.util.List;
import java.util.Optional;
 
import com.example.demo.product.Product;
import com.example.demo.product.ProductRepository;
 
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;
 
@ExtendWith(MockitoExtension.class)
class OrderServiceInjectMocksTest {
 
    @Mock
    private ProductRepository products;
 
    @Mock
    private OrderRepository orders;
 
    @InjectMocks
    private OrderService service;
 
    @Test
    void placesAnOrder() {
        given(products.findById(1L))
                .willReturn(Optional.of(new Product("Mechanical keyboard", "KB-01", new BigDecimal("89.90"), 10)));
 
        service.placeOrder(List.of(new OrderItem(1L, 2)));
 
        then(orders).should().save(any(Order.class));
    }
}

OrderServiceInjectMocksTest > placesAnOrder() FAILED
    java.lang.NullPointerException: Cannot invoke "java.time.Clock.instant()" because "this.clock" is null
        at com.example.demo.order.OrderService.placeOrder(OrderService.java:28)
        at com.example.demo.order.OrderServiceInjectMocksTest.placesAnOrder(OrderServiceInjectMocksTest.java:37)

package com.example.demo.product;
 
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;
 
import java.math.BigDecimal;
 
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.dao.DataIntegrityViolationException;
 
@ExtendWith(MockitoExtension.class)
class ProductServiceMockitoTest {
 
    @Mock
    private ProductRepository products;
 
    private ProductService service;
 
    @BeforeEach
    void setUp() {
        service = new ProductService(products);
    }
 
    @Test
    void savesANewProduct() {
        Product hub = new Product("USB-C hub", "HUB-07", new BigDecimal("39.00"), 5);
        when(products.existsBySku("HUB-07")).thenReturn(false);
        when(products.save(hub)).thenReturn(hub);
 
        Product created = service.create(hub);
 
        assertThat(created).isSameAs(hub);
        verify(products).existsBySku("HUB-07");
        verify(products).save(hub);
        verifyNoMoreInteractions(products);
    }
 
    @Test
    void doesNotSaveADuplicateSku() {
        Product copy = new Product("Compact keyboard", "KB-01", new BigDecimal("59.00"), 5);
        when(products.existsBySku("KB-01")).thenReturn(true);
 
        assertThatThrownBy(() -> service.create(copy)).isInstanceOf(DuplicateSkuException.class);
 
        verify(products, never()).save(any());
    }
 
    @Test
    void passesAConstraintViolationThrough() {
        Product hub = new Product("USB-C hub", "HUB-07", new BigDecimal("39.00"), 5);
        when(products.existsBySku("HUB-07")).thenReturn(false);
        when(products.save(hub)).thenThrow(new DataIntegrityViolationException("uk_products_sku"));
 
        assertThatThrownBy(() -> service.create(hub))
                .isInstanceOf(DataIntegrityViolationException.class)
                .hasMessage("uk_products_sku");
    }
}

ProductServiceMockitoTest > doesNotSaveADuplicateSku() PASSED
 
ProductServiceMockitoTest > passesAConstraintViolationThrough() PASSED
 
ProductServiceMockitoTest > savesANewProduct() PASSED

package com.example.demo.product;
 
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;
 
import java.math.BigDecimal;
 
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
 
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
class ProductServiceLenientVerifyTest {
 
    @Mock
    private ProductRepository products;
 
    @Test
    void doesNotSaveADuplicateSku() {
        Product copy = new Product("Compact keyboard", "KB-01", new BigDecimal("59.00"), 5);
        when(products.existsBySku("KB-01")).thenReturn(true);
 
        assertThatThrownBy(() -> new ProductService(products).create(copy)).isInstanceOf(DuplicateSkuException.class);
 
        verify(products, never()).save(any());
        verifyNoMoreInteractions(products);
    }
}

ProductServiceLenientVerifyTest > doesNotSaveADuplicateSku() FAILED
    org.mockito.exceptions.verification.NoInteractionsWanted: 
    No interactions wanted here:
    -> at com.example.demo.product.ProductServiceLenientVerifyTest.doesNotSaveADuplicateSku(ProductServiceLenientVerifyTest.java:34)
    But found this interaction on mock 'products':
    -> at com.example.demo.product.ProductService.create(ProductService.java:22)
    Actually, above is the only interaction with this mock.
        at app//com.example.demo.product.ProductServiceLenientVerifyTest.doesNotSaveADuplicateSku(ProductServiceLenientVerifyTest.java:34)

then(orders).should().save(savedOrder.capture());
Order order = savedOrder.getValue();

    @BeforeEach
    void setUp() {
        service = new OrderService(products, orders, Clock.fixed(NOW, ZoneOffset.UTC));
        keyboard = new Product("Mechanical keyboard", "KB-01", new BigDecimal("89.90"), 10);
        mouse = new Product("Wireless mouse", "MS-01", new BigDecimal("24.50"), 1);
        given(orders.save(any(Order.class))).willAnswer(invocation -> invocation.getArgument(0)); 
    }

OrderServiceTest > decrementsStockAndSavesTheOrder() PASSED
 
OrderServiceTest > savesNothingWhenALineHasTooLittleStock() FAILED
    org.mockito.exceptions.misusing.UnnecessaryStubbingException: 
    Unnecessary stubbings detected.
    Clean & maintainable test code requires zero unnecessary code.
    Following stubbings are unnecessary (click to navigate to relevant line of code):
      1. -> at com.example.demo.order.OrderServiceTest.setUp(OrderServiceTest.java:53)
    Please remove unnecessary stubbings or use 'lenient' strictness. More info: javadoc for UnnecessaryStubbingException class.
        at app//org.mockito.junit.jupiter.MockitoExtension.lambda$afterEach$2(MockitoExtension.java:200)
        at java.base@21.0.6/java.util.Optional.ifPresent(Optional.java:178)
        at app//org.mockito.junit.jupiter.MockitoExtension.afterEach(MockitoExtension.java:198)
        at java.base@21.0.6/java.util.ArrayList.forEach(ArrayList.java:1596)
        at java.base@21.0.6/java.util.ArrayList.forEach(ArrayList.java:1596)

        given(orders.save(any(Order.class))).willAnswer(invocation -> invocation.getArgument(0)); 
        lenient().when(orders.save(any(Order.class))).thenAnswer(invocation -> invocation.getArgument(0)); 

OrderServiceTest > decrementsStockAndSavesTheOrder() PASSED
 
OrderServiceTest > savesNothingWhenALineHasTooLittleStock() PASSED

    @Test
    void decrementsStockAndSavesTheOrder() {
        given(products.findById(1L)).willReturn(Optional.of(keyboard));
        given(products.findById(2L)).willReturn(Optional.of(mouse)); 
        given(products.findById(3L)).willReturn(Optional.of(mouse)); 
 
        service.placeOrder(List.of(new OrderItem(1L, 2), new OrderItem(2L, 1)));

OrderServiceTest > decrementsStockAndSavesTheOrder() FAILED
    org.mockito.exceptions.misusing.PotentialStubbingProblem: 
    Strict stubbing argument mismatch. Please check:
     - this invocation of 'findById' method:
        products.findById(2L);
        -> at com.example.demo.order.OrderService.placeOrder(OrderService.java:30)
     - has following stubbing(s) with different arguments:
        1. products.findById(3L); stubbed with: [Returns: Optional[com.example.demo.product.Product@f9f3928]]
          -> at com.example.demo.order.OrderServiceTest.decrementsStockAndSavesTheOrder(OrderServiceTest.java:58)
    Typically, stubbing argument mismatch indicates user mistake when writing tests.
    Mockito fails early so that you can debug potential problem easily.
    However, there are legit scenarios when this exception generates false negative signal:
      - stubbing the same method multiple times using 'given().will()' or 'when().then()' API
        Please use 'will().given()' or 'doReturn().when()' API for stubbing.
      - stubbed method is intentionally invoked with different arguments by code under test
        Please use default or 'silent' JUnit Rule (equivalent of Strictness.LENIENT).
    For more information see javadoc for PotentialStubbingProblem class.
        at app//com.example.demo.order.OrderService.placeOrder(OrderService.java:30)
        at app//com.example.demo.order.OrderServiceTest.decrementsStockAndSavesTheOrder(OrderServiceTest.java:60)

package com.example.demo.product;
 
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.BDDMockito.given;
import static org.mockito.BDDMockito.then;
import static org.mockito.Mockito.never;
 
import java.math.BigDecimal;
import java.util.Optional;
 
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
 
@ExtendWith(MockitoExtension.class)
class ProductServiceTest {
 
    @Mock
    private ProductRepository products;
 
    private ProductService service;
 
    @BeforeEach
    void setUp() {
        service = new ProductService(products);
    }
 
    @Nested
    @DisplayName("create")
    class Create {
 
        @Test
        @DisplayName("saves a product whose SKU is free")
        void savesANewProduct() {
            Product hub = new Product("USB-C hub", "HUB-07", new BigDecimal("39.00"), 5);
            given(products.existsBySku("HUB-07")).willReturn(false);
            given(products.save(hub)).willReturn(hub);
 
            assertThat(service.create(hub)).isSameAs(hub);
        }
 
        @Test
        @DisplayName("rejects a duplicate SKU and never saves")
        void rejectsADuplicateSku() {
            Product copy = new Product("Compact keyboard", "KB-01", new BigDecimal("59.00"), 5);
            given(products.existsBySku("KB-01")).willReturn(true);
 
            assertThatThrownBy(() -> service.create(copy))
                    .isInstanceOf(DuplicateSkuException.class)
                    .hasMessage("SKU KB-01 already exists");
 
            then(products).should(never()).save(any());
            then(products).shouldHaveNoMoreInteractions();
        }
    }
 
    @Nested
    @DisplayName("findById")
    class FindById {
 
        @Test
        @DisplayName("throws ProductNotFoundException for an unknown id")
        void throwsForAnUnknownId() {
            given(products.findById(99L)).willReturn(Optional.empty());
 
            assertThatExceptionOfType(ProductNotFoundException.class)
                    .isThrownBy(() -> service.findById(99L))
                    .withMessage("Product 99 not found");
        }
    }
}

ProductServiceTest > findById > throws ProductNotFoundException for an unknown id PASSED
 
ProductServiceTest > create > rejects a duplicate SKU and never saves PASSED
 
ProductServiceTest > create > saves a product whose SKU is free PASSED

package com.example.demo.order;
 
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.assertj.core.api.Assertions.tuple;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.BDDMockito.given;
import static org.mockito.BDDMockito.then;
import static org.mockito.Mockito.never;
 
import java.math.BigDecimal;
import java.time.Clock;
import java.time.Instant;
import java.time.ZoneOffset;
import java.util.List;
import java.util.Optional;
 
import com.example.demo.product.InsufficientStockException;
import com.example.demo.product.Product;
import com.example.demo.product.ProductRepository;
 
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
 
@ExtendWith(MockitoExtension.class)
class OrderServiceTest {
 
    private static final Instant NOW = Instant.parse("2026-11-05T09:00:00Z");
 
    @Mock
    private ProductRepository products;
 
    @Mock
    private OrderRepository orders;
 
    @Captor
    private ArgumentCaptor<Order> savedOrder;
 
    private OrderService service;
    private Product keyboard;
    private Product mouse;
 
    @BeforeEach
    void setUp() {
        service = new OrderService(products, orders, Clock.fixed(NOW, ZoneOffset.UTC));
        keyboard = new Product("Mechanical keyboard", "KB-01", new BigDecimal("89.90"), 10);
        mouse = new Product("Wireless mouse", "MS-01", new BigDecimal("24.50"), 1);
    }
 
    @Test
    void decrementsStockAndSavesTheOrder() {
        given(products.findById(1L)).willReturn(Optional.of(keyboard));
        given(products.findById(2L)).willReturn(Optional.of(mouse));
 
        service.placeOrder(List.of(new OrderItem(1L, 2), new OrderItem(2L, 1)));
 
        then(orders).should().save(savedOrder.capture());
        Order order = savedOrder.getValue();
        assertThat(order.getPlacedAt()).isEqualTo("2026-11-05T09:00:00Z");
        assertThat(order.getLines())
                .extracting(line -> line.getProduct().getStock(), OrderLine::getQuantity)
                .containsExactly(tuple(8, 2), tuple(0, 1));
        assertThat(order.total()).isEqualByComparingTo("204.30");
    }
 
    @Test
    void savesNothingWhenALineHasTooLittleStock() {
        given(products.findById(1L)).willReturn(Optional.of(keyboard));
        given(products.findById(2L)).willReturn(Optional.of(mouse));
 
        assertThatThrownBy(() -> service.placeOrder(List.of(new OrderItem(1L, 2), new OrderItem(2L, 3))))
                .isInstanceOf(InsufficientStockException.class)
                .hasMessage("Only 1 of MS-01 in stock, 3 requested");
 
        then(orders).should(never()).save(any());
        assertThat(keyboard.getStock()).isEqualTo(8);
    }
}

OrderServiceTest > decrementsStockAndSavesTheOrder() PASSED
 
OrderServiceTest > savesNothingWhenALineHasTooLittleStock() PASSED

    private static final Instant NOW = Instant.parse("2026-11-05T09:00:00Z");
 
    @BeforeEach
    void setUp() {
        service = new OrderService(products, orders, Clock.fixed(NOW, ZoneOffset.UTC));

DemoApplicationTests > contextLoads() STANDARD_ERROR
    Mockito is currently self-attaching to enable the inline-mock-maker. This will no longer work in future releases of the JDK. Please add Mockito as an agent to your build as described in Mockito's documentation: https://javadoc.io/doc/org.mockito/mockito-core/latest/org.mockito/org/mockito/Mockito.html#0.3
    WARNING: A Java agent has been loaded dynamically (.../byte-buddy-agent-1.18.11.jar)
    WARNING: If a serviceability tool is in use, please run with -XX:+EnableDynamicAgentLoading to hide this warning
    WARNING: If a serviceability tool is not in use, please run with -Djdk.instrument.traceUsage for more information
    WARNING: Dynamic loading of agents will be disallowed by default in a future release

./gradlew -q dependencies --configuration mockitoAgent

mockitoAgent
\--- org.mockito:mockito-core -> 5.23.0

[ERROR] The forked VM terminated without properly saying goodbye. VM crash or System.exit called?
[ERROR] Command was /bin/sh -c cd '.../demo-mvn' && '.../bin/java' '@{argLine}' '-javaagent:.../mockito-core/5.23.0/mockito-core-5.23.0.jar' '-jar' ...

> Task :testClasses UP-TO-DATE
OpenJDK 64-Bit Server VM warning: Sharing is only supported for boot loader classes because bootstrap classpath has been appended
 
DemoApplicationTests > contextLoads() PASSED
 
OrderLineTest > multipliesUnitPriceByQuantity() PASSED
 
OrderServiceTest > decrementsStockAndSavesTheOrder() PASSED
 
OrderServiceTest > savesNothingWhenALineHasTooLittleStock() PASSED
 
ProductServiceTest > findById > throws ProductNotFoundException for an unknown id PASSED
 
ProductServiceTest > create > rejects a duplicate SKU and never saves PASSED
 
ProductServiceTest > create > saves a product whose SKU is free PASSED

./gradlew test --rerun --tests '*ServiceTest'