Séance 3 - Tests et CI/CD (4h)

=== Structure des fichiers === <sxh;gutter:false> src/main/resources/ ├── application.properties # Configuration commune ├── application-dev.properties # Développement local ├── application-test.properties # Tests automatisés └── application-prod.properties # Production </sxh> === application.properties (commun) === <sxh properties;gutter:false> # Configuration commune à tous les profils spring.application.name=ecommerce-api server.port=8080 # JPA commun spring.jpa.open-in-view=false spring.jpa.properties.hibernate.jdbc.time_zone=UTC # Validation spring.jackson.deserialization.fail-on-unknown-properties=true </sxh> === application-dev.properties === <sxh properties;gutter:false> # Base H2 fichier pour le dev spring.datasource.url=jdbc:h2:file:./data/ecommerce-dev spring.datasource.username=sa spring.datasource.password= # Console H2 activée spring.h2.console.enabled=true spring.h2.console.path=/h2-console # DDL auto pour en dev spring.jpa.hibernate.ddl-auto=update # Logs verbeux spring.jpa.show-sql=true spring.jpa.properties.hibernate.format_sql=true logging.level.com.ecommerce=DEBUG logging.level.io.hypersistence.utils=DEBUG </sxh> === application-test.properties === <sxh properties;gutter:false> # Base H2 en mémoire pour les tests spring.datasource.url=jdbc:h2:mem:testdb;MODE=PostgreSQL;DB_CLOSE_DELAY=-1 spring.datasource.username=sa spring.datasource.password= # Recréation du schéma à chaque test spring.jpa.hibernate.ddl-auto=create-drop # Logs minimaux (sauf erreurs) spring.jpa.show-sql=false logging.level.com.ecommerce=INFO logging.level.org.hibernate=WARN # Performance tests spring.jpa.properties.hibernate.generate_statistics=true # Désactivation fonctionnalités non nécessaires en test spring.h2.console.enabled=false </sxh> === application-prod.properties === <sxh properties;gutter:false> # Base PostgreSQL (exemple) spring.datasource.url=${DATABASE_URL} spring.datasource.username=${DB_USERNAME} spring.datasource.password=${DB_PASSWORD} # JAMAIS de DDL auto en production spring.jpa.hibernate.ddl-auto=validate # Logs minimaux spring.jpa.show-sql=false logging.level.com.ecommerce=INFO # Sécurité spring.h2.console.enabled=false </sxh> ==== 1.2 Activation des profils ==== <sxh bash;gutter:false> # Dans IntelliJ : Run Configuration > Active profiles: dev # Ou via variable d'environnement export SPRING_PROFILES_ACTIVE=dev # Via ligne de commande mvn spring-boot:run -Dspring-boot.run.profiles=dev </sxh>

===== Partie 2 : Tests Unitaires (1h15) =====

==== 2.1 Dépendances nécessaires (pom.xml) ==== <sxh xml> <dependencies> <!– Spring Boot Test (inclut JUnit 5, Mockito, AssertJ) –> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> </dependencies> </sxh> ==== 2.2 Premier test simple : ProductService ==== <sxh java> package com.ecommerce.service; import com.ecommerce.domain.Product; import com.ecommerce.domain.Category; import com.ecommerce.repository.ProductRepository; import com.ecommerce.exception.ProductNotFoundException; import com.ecommerce.exception.InsufficientStockException; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; import java.math.BigDecimal; import java.util.Optional; import java.util.UUID; import static org.assertj.core.api.Assertions.*; import static org.mockito.Mockito.*; @ExtendWith(MockitoExtension.class) @DisplayName(“ProductService - Unit Tests”) class ProductServiceTest { @Mock private ProductRepository productRepository; @InjectMocks private ProductService productService; @Test @DisplayName(“Should return product when it exists”) void getProduct_WhenExists_ShouldReturnProduct() { Given (Arrange) UUID productId = UUID.randomUUID(); Category category = new Category(“Electronics”, “Devices”); Product expectedProduct = Product.builder() .id(productId) .name(“iPhone”) .price(new BigDecimal(“999.99”)) .stock(10) .category(category) .build(); when(productRepository.findById(productId)) .thenReturn(Optional.of(expectedProduct)); When (Act) Product result = productService.getProduct(productId); Then (Assert) assertThat(result).isNotNull(); assertThat(result.getName()).isEqualTo(“iPhone”); assertThat(result.getPrice()).isEqualByComparingTo(“999.99”); assertThat(result.getStock()).isEqualTo(10); verify(productRepository, times(1)).findById(productId); verifyNoMoreInteractions(productRepository); } @Test @DisplayName(“Should throw exception when product not found”) void getProduct_WhenNotExists_ShouldThrowException() { Given UUID productId = UUID.randomUUID(); when(productRepository.findById(productId)) .thenReturn(Optional.empty()); When & Then assertThatThrownBy¹⁾ .isInstanceOf(ProductNotFoundException.class) .hasMessageContaining(productId.toString()); verify(productRepository).findById(productId); } @Test @DisplayName(“Should decrease stock when updating with negative quantity”) void updateStock_WithNegativeQuantity_ShouldDecreaseStock() { Given UUID productId = UUID.randomUUID(); Product product = Product.builder() .id(productId) .name(“Test Product”) .price(BigDecimal.TEN) .stock(10) .build(); when(productRepository.findById(productId)) .thenReturn(Optional.of(product)); when(productRepository.save(any(Product.class))) .thenReturn(product); When productService.updateStock(productId, -3); Then assertThat(product.getStock()).isEqualTo(7); verify(productRepository).save(product); } @Test @DisplayName(“Should throw exception when insufficient stock”) void updateStock_WithInsufficientStock_ShouldThrowException() { Given UUID productId = UUID.randomUUID(); Product product = Product.builder() .id(productId) .name(“Test Product”) .price(BigDecimal.TEN) .stock(5) .build(); when(productRepository.findById(productId)) .thenReturn(Optional.of(product)); When & Then assertThatThrownBy²⁾ .isInstanceOf(InsufficientStockException.class); verify(productRepository, never()).save(any()); } @Test @DisplayName(“Should increase stock when updating with positive quantity”) void updateStock_WithPositiveQuantity_ShouldIncreaseStock() { Given UUID productId = UUID.randomUUID(); Product product = Product.builder() .id(productId) .name(“Test Product”) .price(BigDecimal.TEN) .stock(10) .build(); when(productRepository.findById(productId)) .thenReturn(Optional.of(product)); when(productRepository.save(any(Product.class))) .thenReturn(product); When productService.updateStock(productId, 5); Then assertThat(product.getStock()).isEqualTo(15); verify(productRepository).save(product); } } </sxh> ==== 2.3 Concepts clés ==== <sxh java;gutter:false> @Mock : Crée un faux objet (ne fait rien par défaut) @Mock private ProductRepository productRepository; @InjectMocks : Injecte automatiquement les mocks dans la classe testée @InjectMocks private ProductService productService; when(…).thenReturn(…) : Définit le comportement du mock when(productRepository.findById(id)).thenReturn(Optional.of(product)); verify(…) : Vérifie qu'une méthode a été appelée (et combien de fois) verify(productRepository, times(1)).save(any()); verify(productRepository, never()).delete(any()); assertThat(…) : Vérifie le résultat (AssertJ - plus lisible que assertEquals) assertThat(result.getStock()).isEqualTo(7); assertThat(result).isNotNull(); assertThat(list).hasSize(3); assertThatThrownBy : Vérifie qu'une exception est levée assertThatThrownBy³⁾ .isInstanceOf(MyException.class) .hasMessage(“Expected message”); </sxh> ==== 2.4 Tests paramétrés (en plus) ==== <sxh java> import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.CsvSource; import org.junit.jupiter.params.provider.ValueSource; @ParameterizedTest @DisplayName(“Should validate price is positive”) @ValueSource(strings = {“-10.00”, “-0.01”, “0.00”}) void createProduct_WithInvalidPrice_ShouldThrowException(String price) { Given CreateProductDto dto = new CreateProductDto(); dto.setName(“Test”); dto.setPrice(new BigDecimal(price)); dto.setStock(10); When & Then assertThatThrownBy⁴⁾ .isInstanceOf(InvalidPriceException.class); } @ParameterizedTest @DisplayName(“Should calculate correct total for different quantities”) @CsvSource({ “1, 10.00, 10.00”, “2, 10.00, 20.00”, “5, 9.99, 49.95” }) void calculateTotal_WithDifferentQuantities_ShouldReturnCorrectAmount( int quantity, String unitPrice, String expectedTotal ) { Given Product product = Product.builder() .price(new BigDecimal(unitPrice)) .build(); When BigDecimal total = productService.calculateTotal(product, quantity); Then assertThat(total).isEqualByComparingTo(expectedTotal); } </sxh>

@ExtendWith(MockitoExtension.class)
@DisplayName("UserService - Unit Tests")
class UserServiceTest {
 
    @Mock
    private UserRepository userRepository;
 
    @Mock
    private OrderRepository orderRepository;
 
    @InjectMocks
    private UserService userService;
 
    @Test
    @DisplayName("Should create user with valid data")
    void createUser_WithValidData_ShouldReturnUser() {
        // Given
        CreateUserDto dto = new CreateUserDto("John Doe", "john@example.com");
        User user = User.builder()
            .id(UUID.randomUUID())
            .name(dto.getName())
            .email(dto.getEmail())
            .build();
 
        when(userRepository.existsByEmail(dto.getEmail())).thenReturn(false);
        when(userRepository.save(any(User.class))).thenReturn(user);
 
        // When
        User result = userService.createUser(dto);
 
        // Then
        assertThat(result).isNotNull();
        assertThat(result.getEmail()).isEqualTo("john@example.com");
        verify(userRepository).save(any(User.class));
    }
 
    // TODO: Implémenter les 4 autres tests
}

===== Partie 3 : Tests d'Intégration (1h15) =====

==== 3.1 Configuration de base ==== <sxh java> package com.ecommerce.controller; import com.ecommerce.domain.Product; import com.ecommerce.domain.Category; import com.ecommerce.repository.ProductRepository; import com.ecommerce.repository.CategoryRepository; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.DisplayName; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.http.MediaType; import org.springframework.test.context.ActiveProfiles; import org.springframework.test.web.servlet.MockMvc; import org.springframework.transaction.annotation.Transactional; import java.math.BigDecimal; import static org.hamcrest.Matchers.*; import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*; import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*; import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.*; @SpringBootTest @AutoConfigureMockMvc @ActiveProfiles(“test”) @Transactional Rollback automatique après chaque test @DisplayName(“ProductController - Integration Tests”) class ProductControllerIntegrationTest { @Autowired private MockMvc mockMvc; @Autowired private ProductRepository productRepository; @Autowired private CategoryRepository categoryRepository; private Category electronics; @BeforeEach void setUp() { Nettoyage (si @Transactional ne suffit pas) productRepository.deleteAll(); categoryRepository.deleteAll(); Données de test electronics = categoryRepository.save( new Category(“Electronics”, “Electronic devices”) ); } @Test @DisplayName(“GET /products/{id} should return 200 when product exists”) void getProduct_WhenExists_ShouldReturn200() throws Exception { Given Product product = productRepository.save( Product.builder() .name(“iPhone 15”) .price(new BigDecimal(“999.99”)) .stock(50) .category(electronics) .build() ); When & Then mockMvc.perform(get(“/products/{id}”, product.getId())) .andDo(print()) Affiche la requête/réponse (utile pour déboguer) .andExpect(status().isOk()) .andExpect(content().contentType(MediaType.APPLICATION_JSON)) .andExpect(jsonPath(“$.id”).value(product.getId().toString())) .andExpect(jsonPath(“$.name”).value(“iPhone 15”)) .andExpect(jsonPath(“$.price”).value(999.99)) .andExpect(jsonPath(“$.stock”).value(50)) .andExpect(jsonPath(“$.category.name”).value(“Electronics”)); } @Test @DisplayName(“GET /products/{id} should return 404 when product not found”) void getProduct_WhenNotExists_ShouldReturn404() throws Exception { When & Then mockMvc.perform(get(“/products/{id}”, “00000000-0000-0000-0000-000000000000”)) .andExpect(status().isNotFound()) .andExpect(jsonPath(“$.message”).exists()); } @Test @DisplayName(“POST /products should return 201 with valid data”) void createProduct_WithValidData_ShouldReturn201() throws Exception { Given String requestBody = “”“ { “name”: “iPad Pro”, “price”: 799.99, “stock”: 30, “categoryId”: ”%s“ } ”“”.formatted(electronics.getId()); When & Then mockMvc.perform(post(“/products”) .contentType(MediaType.APPLICATION_JSON) .content(requestBody)) .andDo(print()) .andExpect(status().isCreated()) .andExpect(header().exists(“Location”)) .andExpect(jsonPath(“$.id”).exists()) .andExpect(jsonPath(“$.name”).value(“iPad Pro”)) .andExpect(jsonPath(“$.price”).value(799.99)) .andExpect(jsonPath(“$.stock”).value(30)); } @Test @DisplayName(“POST /products should return 400 with invalid data”) void createProduct_WithInvalidData_ShouldReturn400() throws Exception { Given - prix négatif String requestBody = “”“ { “name”: “Invalid Product”, “price”: -10.00, “stock”: 10, “categoryId”: ”%s“ } ”“”.formatted(electronics.getId()); When & Then mockMvc.perform(post(“/products”) .contentType(MediaType.APPLICATION_JSON) .content(requestBody)) .andExpect(status().isBadRequest()) .andExpect(jsonPath(“$.errors”).isArray()); } @Test @DisplayName(“PUT /products/{id}/stock should update stock correctly”) void updateStock_WithValidQuantity_ShouldReturn200() throws Exception { Given Product product = productRepository.save( Product.builder() .name(“Test Product”) .price(BigDecimal.TEN) .stock(10) .category(electronics) .build() ); String requestBody = “”“ { “quantity”: 5 } ”“”; When & Then mockMvc.perform(put(“/products/{id}/stock”, product.getId()) .contentType(MediaType.APPLICATION_JSON) .content(requestBody)) .andExpect(status().isOk()) .andExpect(jsonPath(“$.stock”).value(15)); } @Test @DisplayName(“GET /products should return paginated list”) void getProducts_ShouldReturnPaginatedList() throws Exception { Given productRepository.save(Product.builder() .name(“Product 1”) .price(BigDecimal.TEN) .stock(10) .category(electronics) .build()); productRepository.save(Product.builder() .name(“Product 2”) .price(BigDecimal.valueOf(20)) .stock(20) .category(electronics) .build()); When & Then mockMvc.perform(get(“/products”) .param(“page”, “0”) .param(“size”, “10”)) .andExpect(status().isOk()) .andExpect(jsonPath(“$.content”).isArray()) .andExpect(jsonPath(“$.content”, hasSize(2))) .andExpect(jsonPath(“$.totalElements”).value(2)); } @Test @DisplayName(“GET /products should filter by category”) void getProducts_WithCategoryFilter_ShouldReturnFilteredList() throws Exception { Given Category books = categoryRepository.save(new Category(“Books”, “Books category”)); productRepository.save(Product.builder() .name(“iPhone”) .price(BigDecimal.valueOf(999)) .stock(10) .category(electronics) .build()); productRepository.save(Product.builder() .name(“Java Book”) .price(BigDecimal.valueOf(50)) .stock(20) .category(books) .build()); When & Then mockMvc.perform(get(“/products”) .param(“categoryId”, electronics.getId().toString())) .andExpect(status().isOk()) .andExpect(jsonPath(“$.content”, hasSize(1))) .andExpect(jsonPath(“$.content[0].name”).value(“iPhone”)); } } </sxh> ==== 3.2 Concepts clés ==== <sxh java;gutter:false> @SpringBootTest : Lance toute l'application Spring @SpringBootTest @AutoConfigureMockMvc : Configure MockMvc pour simuler les requêtes HTTP @AutoConfigureMockMvc @ActiveProfiles(“test”) : Utilise application-test.properties @ActiveProfiles(“test”) @Transactional : Rollback automatique après chaque test @Transactional MockMvc : Simule des requêtes HTTP sans démarrer le serveur mockMvc.perform(get(“/products/123”)) .andExpect(status().isOk()) .andExpect(jsonPath(“$.name”).value(“iPhone”)); jsonPath : Parcourt la réponse JSON avec des expressions jsonPath(“$.name”) Champ direct jsonPath(“$.category.name”) Objet imbriqué jsonPath(“$.items[0].name”) Premier élément d'un tableau jsonPath(“$.items”, hasSize(3)) Taille du tableau </sxh> ==== 3.3 Test avec détection N+1 ==== <sxh java> import io.hypersistence.utils.jdbc.validator.SQLStatementCountValidator; import static io.hypersistence.utils.jdbc.validator.SQLStatementCountValidator.*; @Test @DisplayName(“GET /users/{id}/orders should not trigger N+1 queries”) void getUserOrders_ShouldNotTriggerNPlusOne() throws Exception { Given User user = userRepository.save(new User(“John”, “john@example.com”)); for (int i = 0; i < 5; i++) { Order order = new Order(user); order.addItem(new OrderItem(product1, 1, product1.getPrice())); order.addItem(new OrderItem(product2, 2, product2.getPrice())); orderRepository.save(order); } When SQLStatementCountValidator.reset(); mockMvc.perform(get(“/users/{id}/orders”, user.getId())) .andExpect(status().isOk()) .andExpect(jsonPath(“$”, hasSize(5))) .andExpect(jsonPath(“$[0].items”, hasSize(2))); Then - Vérifier le nombre de requêtes SQL assertSelectCount(2); 1 pour User + 1 pour Orders avec items (JOIN FETCH) } </sxh>