[Spring Boot Basics] Test với Spring Boot: @SpringBootTest, @WebMvcTest với MockMvcTester và @DataJpaTest

src/main/java/com/example/demo
├── DemoApplication.java
├── common
│   ├── GlobalExceptionHandler.java
│   ├── ProblemDetailSecurityHandler.java
│   └── SecurityConfig.java
├── product
│   ├── CreateProductRequest.java
│   ├── DuplicateSkuException.java
│   ├── Product.java
│   ├── ProductController.java
│   ├── ProductNotFoundException.java
│   ├── ProductRepository.java
│   ├── ProductResponse.java
│   └── ProductService.java
└── user
    ├── AppUser.java
    ├── AppUserRepository.java
    ├── AuthController.java
    ├── JpaUserDetailsService.java
    ├── LoginRequest.java
    ├── Role.java
    ├── TokenResponse.java
    ├── TokenService.java
    └── UserSeeder.java

@Entity
@Table(name = "products")
public class Product {
 
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
 
    @Column(nullable = false, length = 40, unique = true)
    private String sku;
 
    @Column(nullable = false, length = 120)
    private String name;
 
    @Column(nullable = false, length = 60)
    private String category;
 
    @Column(nullable = false, precision = 10, scale = 2)
    private BigDecimal price;
 
    protected Product() {
    }
 
    public Product(String sku, String name, String category, BigDecimal price) {
        this.sku = sku;
        this.name = name;
        this.category = category;
        this.price = price;
    }
 
    // getters, plus setName and setPrice
}

public interface ProductRepository extends JpaRepository<Product, Long> {
 
    Optional<Product> findBySku(String sku);
 
    boolean existsBySku(String sku);
 
    List<Product> findByCategoryOrderByPriceAsc(String category);
 
    @Query("select p from Product p where lower(p.name) like lower(concat('%', :text, '%')) order by p.name")
    List<Product> search(String text);
 
    @Modifying(clearAutomatically = true)
    @Query("update Product p set p.price = p.price * :factor where p.category = :category")
    int changePrices(String category, BigDecimal factor);
}

@Service
@Transactional(readOnly = true)
public class ProductService {
 
    private final ProductRepository repository;
 
    public ProductService(ProductRepository repository) {
        this.repository = repository;
    }
 
    public List<Product> findAll() {
        return repository.findAll(Sort.by("id"));
    }
 
    public Product findById(long id) {
        return repository.findById(id).orElseThrow(() -> new ProductNotFoundException(id));
    }
 
    @Transactional
    public Product create(Product product) {
        if (repository.existsBySku(product.getSku())) {
            throw new DuplicateSkuException(product.getSku());
        }
        return repository.save(product);
    }
}

@RestController
@RequestMapping("/api/products")
public class ProductController {
 
    private final ProductService service;
 
    public ProductController(ProductService service) {
        this.service = service;
    }
 
    @GetMapping
    public List<ProductResponse> findAll() {
        return service.findAll().stream().map(ProductResponse::from).toList();
    }
 
    @GetMapping("/{id}")
    public ProductResponse findById(@PathVariable long id) {
        return ProductResponse.from(service.findById(id));
    }
 
    @PostMapping
    public ResponseEntity<ProductResponse> create(@Valid @RequestBody CreateProductRequest request) {
        Product product = service.create(request.toProduct());
        URI location = ServletUriComponentsBuilder.fromCurrentRequest()
                .path("/{id}")
                .buildAndExpand(product.getId())
                .toUri();
        return ResponseEntity.created(location).body(ProductResponse.from(product));
    }
}

@Configuration
public class SecurityConfig {
 
    @Bean
    SecurityFilterChain apiSecurityFilterChain(HttpSecurity http, ProblemDetailSecurityHandler problemHandler) {
        http
                .securityMatcher("/api/**")
                .authorizeHttpRequests(auth -> auth
                        .requestMatchers(HttpMethod.GET, "/api/products/**").permitAll()
                        .requestMatchers(HttpMethod.POST, "/api/auth/login").permitAll()
                        .requestMatchers(HttpMethod.POST, "/api/products/**").hasRole("ADMIN")
                        .requestMatchers(HttpMethod.PUT, "/api/products/**").hasRole("ADMIN")
                        .requestMatchers(HttpMethod.DELETE, "/api/products/**").hasRole("ADMIN")
                        .anyRequest().authenticated())
                .oauth2ResourceServer(oauth2 -> oauth2
                        .jwt(Customizer.withDefaults())
                        .authenticationEntryPoint(problemHandler))
                .exceptionHandling(exceptions -> exceptions
                        .authenticationEntryPoint(problemHandler)
                        .accessDeniedHandler(problemHandler))
                .csrf(csrf -> csrf.disable())
                .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS));
        return http.build();
    }
 
    @Bean
    PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
 
    @Bean
    AuthenticationManager authenticationManager(AuthenticationConfiguration configuration) {
        return configuration.getAuthenticationManager();
    }
 
    @Bean
    JwtEncoder jwtEncoder(
            @Value("${spring.security.oauth2.resourceserver.jwt.public-key-location}") RSAPublicKey publicKey,
            @Value("${app.jwt.private-key-location}") RSAPrivateKey privateKey) {
        return NimbusJwtEncoder.withKeyPair(publicKey, privateKey).build();
    }
}

spring.application.name=demo
spring.datasource.url=jdbc:h2:mem:catalog
spring.jpa.open-in-view=false
spring.security.oauth2.resourceserver.jwt.public-key-location=classpath:certs/public.pem
spring.security.oauth2.resourceserver.jwt.authorities-claim-name=roles
spring.security.oauth2.resourceserver.jwt.authority-prefix=ROLE_
app.jwt.private-key-location=classpath:certs/private.pem

dependencies {
    implementation 'org.springframework.boot:spring-boot-h2console'
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    implementation 'org.springframework.boot:spring-boot-starter-security'
    implementation 'org.springframework.boot:spring-boot-starter-security-oauth2-resource-server'
    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-security-oauth2-resource-server-test'
    testImplementation 'org.springframework.boot:spring-boot-starter-security-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'
}

import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;

import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager;
import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase;

./gradlew compileTestJava

> Task :compileTestJava FAILED
src/test/java/com/example/demo/product/ProductControllerTest.java:5: error: package org.springframework.boot.test.autoconfigure.web.servlet does not exist
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
                                                              ^
src/test/java/com/example/demo/product/ProductControllerTest.java:6: error: package org.springframework.boot.test.mock.mockito does not exist
import org.springframework.boot.test.mock.mockito.MockBean;
                                                 ^
src/test/java/com/example/demo/product/ProductRepositoryTest.java:5: error: package org.springframework.boot.test.autoconfigure.orm.jpa does not exist
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
                                                          ^
src/test/java/com/example/demo/product/ProductRepositoryTest.java:7: error: cannot find symbol
import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase;
                                                       ^
  symbol:   class AutoConfigureTestDatabase
  location: package org.springframework.boot.test.autoconfigure.jdbc

package com.example.demo;
 
import java.util.Collections;
import java.util.IdentityHashMap;
import java.util.Set;
 
import org.springframework.context.ApplicationContext;
import org.springframework.core.Ordered;
import org.springframework.test.context.TestContext;
import org.springframework.test.context.TestExecutionListener;
 
public class ContextStatsListener implements TestExecutionListener, Ordered {
 
    private static final Set<ApplicationContext> seen = Collections.newSetFromMap(new IdentityHashMap<>());
 
    @Override
    public void beforeTestClass(TestContext testContext) {
        long start = System.nanoTime();
        ApplicationContext context = testContext.getApplicationContext();
        long millis = (System.nanoTime() - start) / 1_000_000;
        boolean reused = !seen.add(context);
        System.out.printf("[context] %s: %s, %d bean definitions%n",
                testContext.getTestClass().getSimpleName(),
                reused ? "reused from cache" : "loaded in " + millis + " ms",
                context.getBeanDefinitionCount());
    }
 
    @Override
    public int getOrder() {
        return Ordered.HIGHEST_PRECEDENCE;
    }
}

org.springframework.test.context.TestExecutionListener=com.example.demo.ContextStatsListener

package com.example.demo.product;
 
import static org.assertj.core.api.Assertions.assertThat;
 
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.webmvc.test.autoconfigure.WebMvcTest;
import org.springframework.test.web.servlet.assertj.MockMvcTester;
 
@WebMvcTest(ProductController.class)
class ProductControllerTest {
 
    @Autowired
    MockMvcTester mvc;
 
    @Test
    void returnsProductById() {
        assertThat(mvc.get().uri("/api/products/1")).hasStatusOk();
    }
}

./gradlew test

ProductControllerTest > returnsProductById() FAILED
    java.lang.IllegalStateException at DefaultCacheAwareContextLoaderDelegate.java:195
        Caused by: org.springframework.beans.factory.UnsatisfiedDependencyException at ConstructorResolver.java:804
            Caused by: org.springframework.beans.factory.NoSuchBeanDefinitionException at DefaultListableBeanFactory.java:2304

***************************
APPLICATION FAILED TO START
***************************
 
Description:
 
Parameter 0 of constructor in com.example.demo.product.ProductController required a bean of type 'com.example.demo.product.ProductService' that could not be found.
 
 
Action:
 
Consider defining a bean of type 'com.example.demo.product.ProductService' in your configuration.

import org.springframework.test.context.bean.override.mockito.MockitoBean; 
 
@WebMvcTest(ProductController.class)
class ProductControllerTest {
 
    @Autowired
    MockMvcTester mvc;
 
    @MockitoBean
    ProductService productService; 

package com.example.demo.product;
 
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.BDDMockito.given;
import static org.mockito.BDDMockito.then;
import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.jwt;
 
import java.math.BigDecimal;
import java.util.List;
 
import com.example.demo.common.ProblemDetailSecurityHandler;
import com.example.demo.common.SecurityConfig;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.webmvc.test.autoconfigure.WebMvcTest;
import org.springframework.context.annotation.Import;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.test.context.support.WithMockUser;
import org.springframework.test.context.bean.override.mockito.MockitoBean;
import org.springframework.test.util.ReflectionTestUtils;
import org.springframework.test.web.servlet.assertj.MockMvcTester;
 
@WebMvcTest(ProductController.class)
@Import({SecurityConfig.class, ProblemDetailSecurityHandler.class})
class ProductControllerTest {
 
    private static final String NEW_PRODUCT = """
            {"sku":"HB-001","name":"USB-C hub","category":"hubs","price":35.00}
            """;
 
    @Autowired
    MockMvcTester mvc;
 
    @MockitoBean
    ProductService productService;
 
    @Test
    void getReturnsTheProductAsJson() {
        given(productService.findById(1L)).willReturn(product(1L, "KB-001", "Mechanical keyboard", "89.90"));
 
        assertThat(mvc.get().uri("/api/products/1"))
                .hasStatusOk()
                .hasContentType(MediaType.APPLICATION_JSON)
                .bodyJson()
                .isLenientlyEqualTo("""
                        {"id":1,"sku":"KB-001","name":"Mechanical keyboard","price":89.90}
                        """);
    }
 
    // the tests of the next sections go here
 
    static Product product(long id, String sku, String name, String price) {
        return withId(new Product(sku, name, "keyboards", new BigDecimal(price)), id);
    }
 
    static Product withId(Product product, long id) {
        ReflectionTestUtils.setField(product, "id", id);
        return product;
    }
}

    @Test
    void getListExposesJsonPaths() {
        given(productService.findAll()).willReturn(List.of(
                product(1L, "KB-001", "Mechanical keyboard", "89.90"),
                product(2L, "MS-001", "Wireless mouse", "24.50")));
 
        assertThat(mvc.get().uri("/api/products"))
                .hasStatusOk()
                .bodyJson()
                .hasPathSatisfying("$.length()", length -> assertThat(length).asNumber().isEqualTo(2))
                .extractingPath("$[*].sku").asArray().containsExactly("KB-001", "MS-001");
    }

    @Test
    void getConvertsTheBodyToTheResponseRecord() {
        given(productService.findById(1L)).willReturn(product(1L, "KB-001", "Mechanical keyboard", "89.90"));
 
        assertThat(mvc.get().uri("/api/products/1"))
                .bodyJson()
                .convertTo(ProductResponse.class)
                .satisfies(response -> {
                    assertThat(response.sku()).isEqualTo("KB-001");
                    assertThat(response.price()).isEqualByComparingTo("89.90");
                });
    }

    @Test
    @WithMockUser(roles = "ADMIN")
    void postCreatesTheProduct() {
        given(productService.create(any(Product.class)))
                .willAnswer(invocation -> withId(invocation.getArgument(0), 42L));
 
        assertThat(mvc.post().uri("/api/products")
                .contentType(MediaType.APPLICATION_JSON)
                .content(NEW_PRODUCT))
                .hasStatus(HttpStatus.CREATED)
                .hasHeader("Location", "http://localhost/api/products/42")
                .bodyJson()
                .extractingPath("$.id").asNumber().isEqualTo(42);
    }

    @Test
    void unknownIdIsA404ProblemDetail() {
        given(productService.findById(99L)).willThrow(new ProductNotFoundException(99L));
 
        assertThat(mvc.get().uri("/api/products/99"))
                .hasStatus(HttpStatus.NOT_FOUND)
                .hasContentType(MediaType.APPLICATION_PROBLEM_JSON)
                .bodyJson()
                .isLenientlyEqualTo("""
                        {"title":"Product not found","status":404,"detail":"Product 99 not found","productId":99}
                        """);
    }
 
    @Test
    @WithMockUser(roles = "ADMIN")
    void duplicateSkuIsA409ProblemDetail() {
        given(productService.create(any(Product.class))).willThrow(new DuplicateSkuException("HB-001"));
 
        assertThat(mvc.post().uri("/api/products")
                .contentType(MediaType.APPLICATION_JSON)
                .content(NEW_PRODUCT))
                .hasStatus(HttpStatus.CONFLICT)
                .bodyJson()
                .isLenientlyEqualTo("""
                        {"title":"Duplicate SKU","status":409,"sku":"HB-001"}
                        """);
    }

    @Test
    @WithMockUser(roles = "ADMIN")
    void invalidBodyIsA422WithFieldErrors() {
        assertThat(mvc.post().uri("/api/products")
                .contentType(MediaType.APPLICATION_JSON)
                .content("""
                        {"sku":"","name":"USB-C hub","category":"hubs","price":-5}
                        """))
                .hasStatus(HttpStatus.UNPROCESSABLE_CONTENT)
                .bodyJson()
                .isLenientlyEqualTo("""
                        {"status":422,"errors":[
                          {"field":"price","message":"must be greater than 0"},
                          {"field":"sku","message":"must not be blank"}]}
                        """);
 
        then(productService).shouldHaveNoInteractions();
    }

    @Test
    void unexpectedErrorIsA500ProblemDetail() {
        given(productService.findById(1L)).willThrow(new IllegalStateException("Database is down"));
 
        assertThat(mvc.get().uri("/api/products/1"))
                .hasStatus(HttpStatus.INTERNAL_SERVER_ERROR)
                .bodyJson()
                .extractingPath("$.detail").asString().isEqualTo("An unexpected error occurred.");
    }

package com.example.demo.product;
 
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.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
 
import com.example.demo.common.ProblemDetailSecurityHandler;
import com.example.demo.common.SecurityConfig;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.webmvc.test.autoconfigure.WebMvcTest;
import org.springframework.context.annotation.Import;
import org.springframework.http.MediaType;
import org.springframework.test.context.bean.override.mockito.MockitoBean;
import org.springframework.test.web.servlet.MockMvc;
 
@WebMvcTest(ProductController.class)
@Import({SecurityConfig.class, ProblemDetailSecurityHandler.class})
class ProductControllerMockMvcTest {
 
    @Autowired
    MockMvc mockMvc;
 
    @MockitoBean
    ProductService productService;
 
    @Test
    void getReturnsTheProductAsJson() throws Exception {
        given(productService.findById(1L))
                .willReturn(ProductControllerTest.product(1L, "KB-001", "Mechanical keyboard", "89.90"));
 
        mockMvc.perform(get("/api/products/1"))
                .andExpect(status().isOk())
                .andExpect(content().contentType(MediaType.APPLICATION_JSON))
                .andExpect(jsonPath("$.sku").value("KB-001"))
                .andExpect(jsonPath("$.price").value(89.90));
    }
}

org.opentest4j.AssertionFailedError: [HTTP status code] 
expected: 201
 but was: 200

java.lang.AssertionError: Status expected:<201> but was:<200>

org.opentest4j.AssertionFailedError: 
expected: "KB-002"
 but was: "KB-001"

java.lang.AssertionError: JSON path "$.sku" expected:<KB-002> but was:<KB-001>

DefaultSecurityFilterChain defined as 'jwtSecurityFilterChain' in [class path resource [org/springframework/boot/security/oauth2/server/resource/autoconfigure/web/OAuth2ResourceServerWebSecurityAutoConfiguration.class]] matching [any request] and having filters [DisableEncodeUrl, WebAsyncManagerIntegration, SecurityContextHolder, HeaderWriter, Csrf, Logout, OAuth2ProtectedResourceMetadata, BearerTokenAuthentication, RequestCacheAware, SecurityContextHolderAwareRequest, AnonymousAuthentication, ExceptionTranslation, Authorization]

Description:
 
Parameter 1 of method apiSecurityFilterChain in com.example.demo.common.SecurityConfig required a bean of type 'com.example.demo.common.ProblemDetailSecurityHandler' that could not be found.

@WebMvcTest(ProductController.class)
@Import({SecurityConfig.class, ProblemDetailSecurityHandler.class}) 
class ProductControllerTest {

    @Test
    void postWithoutATokenIs401() {
        assertThat(mvc.post().uri("/api/products")
                .contentType(MediaType.APPLICATION_JSON)
                .content(NEW_PRODUCT))
                .hasStatus(HttpStatus.UNAUTHORIZED)
                .hasHeader("WWW-Authenticate", "Bearer realm=\"catalogue\", resource_metadata=\"http://localhost/.well-known/oauth-protected-resource\"")
                .bodyJson()
                .extractingPath("$.detail").asString().isEqualTo("Valid credentials are required to access this resource.");
    }
 
    @Test
    void postWithAUserJwtIs403() {
        assertThat(mvc.post().uri("/api/products")
                .with(jwt().authorities(new SimpleGrantedAuthority("ROLE_USER")))
                .contentType(MediaType.APPLICATION_JSON)
                .content(NEW_PRODUCT))
                .hasStatus(HttpStatus.FORBIDDEN)
                .bodyJson()
                .extractingPath("$.title").asString().isEqualTo("Forbidden");
    }
 
    @Test
    void postWithAnAdminJwtIs201() {
        given(productService.create(any(Product.class)))
                .willAnswer(invocation -> withId(invocation.getArgument(0), 42L));
 
        assertThat(mvc.post().uri("/api/products")
                .with(jwt().jwt(token -> token.subject("admin"))
                        .authorities(new SimpleGrantedAuthority("ROLE_ADMIN")))
                .contentType(MediaType.APPLICATION_JSON)
                .content(NEW_PRODUCT))
                .hasStatus(HttpStatus.CREATED);
    }

java.lang.StackOverflowError
	at java.base/java.lang.String.contains(String.java:2981)
	at org.springframework.util.ClassUtils.getUserClass(ClassUtils.java:1009)
	at org.springframework.core.BridgeMethodResolver.resolveBridgeMethod(BridgeMethodResolver.java:105)
	at org.springframework.core.BridgeMethodResolver.findBridgedMethod(BridgeMethodResolver.java:71)
	at org.springframework.aop.support.AopUtils.invokeJoinpointUsingReflection(AopUtils.java:356)
	at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:215)
	at jdk.proxy3/jdk.proxy3.$Proxy158.authenticate(Unknown Source)
	at java.base/java.lang.reflect.Method.invoke(Method.java:580)
	at org.springframework.aop.support.AopUtils.invokeJoinpointUsingReflection(AopUtils.java:359)
	at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:215)
	at jdk.proxy3/jdk.proxy3.$Proxy158.authenticate(Unknown Source)

[    Test worker] beddedDataSourceBeanFactoryPostProcessor : Replacing 'dataSource' DataSource bean with embedded version
[    Test worker] o.s.j.d.e.EmbeddedDatabaseFactory        : Starting embedded database: url='jdbc:h2:mem:5a433bfe-9186-4cce-a896-61d72556390f;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=false', username='sa'

package com.example.demo.product;
 
import static org.assertj.core.api.Assertions.assertThat;
 
import java.math.BigDecimal;
 
import org.junit.jupiter.api.MethodOrderer;
import org.junit.jupiter.api.Order;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.data.jpa.test.autoconfigure.DataJpaTest;
import org.springframework.boot.jpa.test.autoconfigure.TestEntityManager;
 
@DataJpaTest
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
class ProductRepositoryTest {
 
    @Autowired
    TestEntityManager entityManager;
 
    @Autowired
    ProductRepository repository;
 
    @Test
    @Order(1)
    void firstTestInsertsARow() {
        entityManager.persistAndFlush(keyboard("KB-001", "89.90"));
 
        System.out.println(">>> rows in first test: " + repository.count());
        assertThat(repository.count()).isEqualTo(1);
    }
 
    @Test
    @Order(2)
    void secondTestStartsFromAnEmptyTable() {
        System.out.println(">>> rows in second test: " + repository.count());
        assertThat(repository.count()).isZero();
    }
 
    // the query tests of the next sections go here
 
    private static Product keyboard(String sku, String price) {
        return new Product(sku, "Keyboard " + sku, "keyboards", new BigDecimal(price));
    }
}

[    Test worker] o.s.t.c.transaction.TransactionContext   : Began transaction (1) for test class [com.example.demo.product.ProductRepositoryTest]; test method [firstTestInsertsARow]; transaction manager [org.springframework.orm.jpa.JpaTransactionManager@18afb626]; rollback [true]
Hibernate: insert into products (category,name,price,sku,id) values (?,?,?,?,default)
Hibernate: select count(*) from products p1_0
>>> rows in first test: 1
Hibernate: select count(*) from products p1_0
[    Test worker] o.s.t.c.transaction.TransactionContext   : Rolled back transaction (1) for test class [com.example.demo.product.ProductRepositoryTest]; test method [firstTestInsertsARow]
[    Test worker] o.s.t.c.transaction.TransactionContext   : Began transaction (1) for test class [com.example.demo.product.ProductRepositoryTest]; test method [secondTestStartsFromAnEmptyTable]; transaction manager [org.springframework.orm.jpa.JpaTransactionManager@18afb626]; rollback [true]
Hibernate: select count(*) from products p1_0
>>> rows in second test: 0
Hibernate: select count(*) from products p1_0
[    Test worker] o.s.t.c.transaction.TransactionContext   : Rolled back transaction (1) for test class [com.example.demo.product.ProductRepositoryTest]; test method [secondTestStartsFromAnEmptyTable]

    @Test
    void priceIsStoredAsSaved() {
        Product saved = repository.save(new Product("KB-001", "Keyboard KB-001", "keyboards", new BigDecimal("89.999")));
 
        Product found = repository.findById(saved.getId()).orElseThrow();
 
        assertThat(found).isSameAs(saved);
        assertThat(found.getPrice()).isEqualTo(new BigDecimal("89.999"));
    }

Hibernate: insert into products (category,name,price,sku,id) values (?,?,?,?,default)

    @Test
    void priceIsStoredAsSavedAfterFlushAndClear() {
        Product saved = repository.save(new Product("KB-001", "Keyboard KB-001", "keyboards", new BigDecimal("89.999")));
        entityManager.flush(); 
        entityManager.clear(); 
 
        Product found = repository.findById(saved.getId()).orElseThrow();
 
        assertThat(found.getPrice()).isEqualTo(new BigDecimal("89.999"));
    }

Hibernate: insert into products (category,name,price,sku,id) values (?,?,?,?,default)
Hibernate: select p1_0.id,p1_0.category,p1_0.name,p1_0.price,p1_0.sku from products p1_0 where p1_0.id=?

org.opentest4j.AssertionFailedError: 
expected: 89.999
 but was: 90.00

    @Test
    @Order(6)
    void priceIsRoundedToTheColumnScale() {
        Product saved = repository.save(keyboard("KB-001", "89.999"));
        entityManager.flush();
        entityManager.clear();
 
        Product found = repository.findById(saved.getId()).orElseThrow();
 
        assertThat(found).isNotSameAs(saved);
        assertThat(found.getPrice()).isEqualTo(new BigDecimal("90.00"));
    }

org.hibernate.exception.ConstraintViolationException: could not execute statement [Unique index or primary key violation: "PUBLIC.CONSTRAINT_F INDEX PUBLIC.CONSTRAINT_INDEX_F ON PUBLIC.PRODUCTS(SKU NULLS FIRST) VALUES ( /* 1 */ 'KB-001' )"; SQL statement:

org.hibernate.exception.DataException: could not execute statement [Value too long for column "NAME CHARACTER VARYING(120)": "'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx... (130)"; SQL statement:

    @Test
    @Order(3)
    void derivedQueryOrdersByPrice() {
        entityManager.persist(keyboard("KB-001", "89.90"));
        entityManager.persist(keyboard("KB-002", "59.00"));
        entityManager.persist(new Product("MS-001", "Wireless mouse", "mice", new BigDecimal("24.50")));
        entityManager.flush();
 
        assertThat(repository.findByCategoryOrderByPriceAsc("keyboards"))
                .extracting(Product::getSku)
                .containsExactly("KB-002", "KB-001");
    }
 
    @Test
    @Order(4)
    void searchIsCaseInsensitive() {
        entityManager.persist(new Product("KB-001", "Mechanical Keyboard", "keyboards", new BigDecimal("89.90")));
        entityManager.persist(new Product("MS-001", "Wireless mouse", "mice", new BigDecimal("24.50")));
        entityManager.flush();
 
        assertThat(repository.search("KEYBOARD"))
                .extracting(Product::getSku)
                .containsExactly("KB-001");
    }
 
    @Test
    @Order(5)
    void bulkPriceChangeUpdatesMatchingRows() {
        Long id = entityManager.persistAndGetId(keyboard("KB-001", "89.90"), Long.class);
        entityManager.persist(new Product("MS-001", "Wireless mouse", "mice", new BigDecimal("24.50")));
        entityManager.flush();
 
        int updated = repository.changePrices("keyboards", new BigDecimal("1.10"));
 
        assertThat(updated).isEqualTo(1);
        assertThat(repository.findById(id)).get()
                .extracting(Product::getPrice)
                .isEqualTo(new BigDecimal("98.89"));
    }

Hibernate: select p1_0.id,p1_0.category,p1_0.name,p1_0.price,p1_0.sku from products p1_0 where p1_0.category=? order by p1_0.price
Hibernate: select p1_0.id,p1_0.category,p1_0.name,p1_0.price,p1_0.sku from products p1_0 where lower(p1_0.name) like lower(('%'||?||'%')) escape '' order by p1_0.name
Hibernate: update products p1_0 set price=(p1_0.price*cast(? as numeric(10,2))) where p1_0.category=?
Hibernate: select p1_0.id,p1_0.category,p1_0.name,p1_0.price,p1_0.sku from products p1_0 where p1_0.id=?

package com.example.demo.product;
 
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.jwt;
 
import com.example.demo.TestPasswordEncoderConfig;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.webmvc.test.autoconfigure.AutoConfigureMockMvc;
import org.springframework.context.annotation.Import;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.transaction.AfterTransaction;
import org.springframework.test.web.servlet.assertj.MockMvcTester;
import org.springframework.transaction.annotation.Transactional;
 
@SpringBootTest
@AutoConfigureMockMvc
@ActiveProfiles("test")
@Import(TestPasswordEncoderConfig.class)
@Transactional
class ProductApiMockEnvironmentTest {
 
    @Autowired
    MockMvcTester mvc;
 
    @Autowired
    ProductRepository repository;
 
    @Test
    void adminCreatesAProductThroughTheWholeApplication() {
        assertThat(mvc.post().uri("/api/products")
                .with(jwt().authorities(new SimpleGrantedAuthority("ROLE_ADMIN")))
                .contentType(MediaType.APPLICATION_JSON)
                .content("""
                        {"sku":"HB-001","name":"USB-C hub","category":"hubs","price":35.00}
                        """))
                .hasStatus(HttpStatus.CREATED);
 
        assertThat(repository.count()).isEqualTo(1);
    }
 
    @Test
    void unknownIdIsA404FromTheRealService() {
        assertThat(mvc.get().uri("/api/products/999"))
                .hasStatus(HttpStatus.NOT_FOUND)
                .bodyJson()
                .extractingPath("$.productId").asNumber().isEqualTo(999);
    }
 
    @AfterTransaction
    void countRowsAfterRollback() {
        System.out.println("products after the test transaction: " + repository.count());
    }
}

[    Test worker] o.s.t.c.transaction.TransactionContext   : Began transaction (1) for test class [com.example.demo.product.ProductApiMockEnvironmentTest]; test method [adminCreatesAProductThroughTheWholeApplication]; transaction manager [org.springframework.orm.jpa.JpaTransactionManager@6dafdb99]; rollback [true]
[    Test worker] org.hibernate.SQL                        : insert into products (category,name,price,sku,id) values (?,?,?,?,default)
[    Test worker] o.s.t.c.transaction.TransactionContext   : Rolled back transaction (1) for test class [com.example.demo.product.ProductApiMockEnvironmentTest]; test method [adminCreatesAProductThroughTheWholeApplication]
products after the test transaction: 0

>>> without annotations: RestTestClient=null TestRestTemplate=null

package com.example.demo.product;
 
import static org.assertj.core.api.Assertions.assertThat;
 
import java.math.BigDecimal;
 
import com.example.demo.TestPasswordEncoderConfig;
import com.example.demo.user.LoginRequest;
import com.example.demo.user.TokenResponse;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.resttestclient.autoconfigure.AutoConfigureRestTestClient;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
import org.springframework.context.annotation.Import;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.transaction.AfterTransaction;
import org.springframework.test.web.servlet.client.RestTestClient;
import org.springframework.transaction.annotation.Transactional;
 
@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
@AutoConfigureRestTestClient
@ActiveProfiles("test")
@Import(TestPasswordEncoderConfig.class)
@Transactional
class ProductApiRandomPortTest {
 
    @Autowired
    RestTestClient client;
 
    @Autowired
    ProductRepository repository;
 
    @Test
    void adminLogsInCreatesAndReadsAProduct() {
        TokenResponse token = client.post().uri("/api/auth/login")
                .contentType(MediaType.APPLICATION_JSON)
                .body(new LoginRequest("admin", "Admin-2026-secret"))
                .exchange()
                .expectStatus().isOk()
                .expectBody(TokenResponse.class)
                .returnResult()
                .getResponseBody();
 
        ProductResponse created = client.post().uri("/api/products")
                .header(HttpHeaders.AUTHORIZATION, "Bearer " + token.accessToken())
                .contentType(MediaType.APPLICATION_JSON)
                .body(new CreateProductRequest("HB-001", "USB-C hub", "hubs", new BigDecimal("35.00")))
                .exchange()
                .expectStatus().isCreated()
                .expectBody(ProductResponse.class)
                .returnResult()
                .getResponseBody();
 
        client.get().uri("/api/products/{id}", created.id())
                .exchange()
                .expectStatus().isOk()
                .expectBody()
                .jsonPath("$.sku").isEqualTo("HB-001")
                .jsonPath("$.price").isEqualTo(35.00);
    }
 
    @AfterTransaction
    void countRowsAfterRollback() {
        System.out.println("products after the test transaction: " + repository.count());
    }
}

[    Test worker] o.s.t.c.transaction.TransactionContext   : Began transaction (1) for test class [com.example.demo.product.ProductApiRandomPortTest]; test method [adminLogsInCreatesAndReadsAProduct]; transaction manager [org.springframework.orm.jpa.JpaTransactionManager@79f16678]; rollback [true]
[o-auto-1-exec-2] org.hibernate.SQL                        : insert into products (category,name,price,sku,id) values (?,?,?,?,default)
[    Test worker] o.s.t.c.transaction.TransactionContext   : Rolled back transaction (1) for test class [com.example.demo.product.ProductApiRandomPortTest]; test method [adminLogsInCreatesAndReadsAProduct]
products after the test transaction: 1

import org.junit.jupiter.api.AfterEach; 
import org.springframework.test.context.transaction.AfterTransaction; 
import org.springframework.transaction.annotation.Transactional; 
 
@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
@AutoConfigureRestTestClient
@ActiveProfiles("test")
@Import(TestPasswordEncoderConfig.class)
@Transactional
class ProductApiRandomPortTest {
 
    @AfterTransaction
    void countRowsAfterRollback() { 
        System.out.println("products after the test transaction: " + repository.count()); 
    } 
    @AfterEach
    void deleteProducts() { 
        repository.deleteAll(); 
    } 

package com.example.demo;
 
import org.springframework.boot.test.context.TestConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Primary;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
 
@TestConfiguration(proxyBeanMethods = false)
public class TestPasswordEncoderConfig {
 
    @Bean
    @Primary
    PasswordEncoder fastPasswordEncoder() {
        return new BCryptPasswordEncoder(4);
    }
}

Description:
 
The bean 'passwordEncoder', defined in com.example.demo.probe.ClashProbeTest$ClashConfig, could not be registered. A bean with that name has already been defined in class path resource [com/example/demo/common/SecurityConfig.class] and overriding is disabled.
 
Action:
 
Consider renaming one of the beans or enabling overriding by setting spring.main.allow-bean-definition-overriding=true

logging.level.org.hibernate.SQL=debug

tasks.named('test') {
    useJUnitPlatform()
    systemProperty 'logging.level.org.springframework.test.context.cache', 'debug'
}

junit.jupiter.testclass.order.default=org.junit.jupiter.api.ClassOrderer$ClassName

[context] ProductApiMockEnvironmentTest: loaded in 1745 ms, 289 bean definitions
[context] ProductApiRandomPortTest: loaded in 299 ms, 287 bean definitions
[context] ProductControllerMockMvcTest: loaded in 259 ms, 175 bean definitions
[context] ProductControllerTest: reused from cache, 175 bean definitions
[context] ProductRepositoryTest: loaded in 121 ms, 83 bean definitions

[    Test worker] org.springframework.test.context.cache   : Spring test ApplicationContext cache statistics: [DefaultContextCache@57f60b5e size = 4, maxSize = 32, contextUsageCount = 1, parentContextCount = 0, hitCount = 276, missCount = 4, failureCount = 0]

@SpringBootTest
@AutoConfigureMockMvc
@ActiveProfiles("test")
@Import(TestPasswordEncoderConfig.class)
class ProductApiFailureTest {
 
    @Autowired
    MockMvcTester mvc;
 
    @MockitoBean
    ProductService productService;
 
    @Test
    void unexpectedErrorIsA500ProblemDetail() {
        given(productService.findById(1L)).willThrow(new IllegalStateException("Database is down"));
 
        assertThat(mvc.get().uri("/api/products/1"))
                .hasStatus(HttpStatus.INTERNAL_SERVER_ERROR)
                .bodyJson()
                .extractingPath("$.detail").asString().isEqualTo("An unexpected error occurred.");
    }
}