TP9.2 - Tests de Integración de los Repositories

Objetivos del TP

En este TP, usted va a:

✅ Probar un repository con @DataJpaTest
✅ Utilizar una base de datos H2 real
✅ Probar las consultas personalizadas
✅ Verificar las restricciones de unicidad
✅ Probar las relaciones entre entidades

Duración estimada: 1h30

Contexto

Usted tiene las entidades Product y Category con una relación Many-to-One. Debe probar que sus consultas JPA funcionan correctamente con una base de datos real.

Parte 1: Las Entidades

Product

@Entity
@Table(name = "products")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false)
    private String name;

    @Column(unique = true)
    private String sku;

    private BigDecimal price;
    private Integer stock;
    private boolean active = true;

    @ManyToOne
    @JoinColumn(name = "category_id")
    private Category category;

    @Column(name = "created_at")
    private LocalDateTime createdAt = LocalDateTime.now();
}

Parte 2: Los Repositories

CategoryRepository

public interface CategoryRepository extends JpaRepository<Category, Long> {
    Optional<Category> findByName(String name);
    boolean existsByName(String name);
}

ProductRepository

public interface ProductRepository extends JpaRepository<Product, Long> {
    
    // Consultas por propiedad simple
    List<Product> findByActiveTrue();
    List<Product> findByActiveFalse();
    Optional<Product> findBySku(String sku);
    
    // Consultas con criterios
    List<Product> findByPriceLessThan(BigDecimal price);
    List<Product> findByPriceBetween(BigDecimal min, BigDecimal max);
    List<Product> findByStockGreaterThan(Integer stock);
    
    // Consultas con relación
    List<Product> findByCategory(Category category);
    List<Product> findByCategoryName(String categoryName);
    
    // Consultas con ordenamiento
    List<Product> findByActiveTrueOrderByPriceAsc();
    List<Product> findByActiveTrueOrderByCreatedAtDesc();
    
    // Consultas @Query
    @Query("SELECT p FROM Product p WHERE p.price < :price AND p.active = true")
    List<Product> findCheapActiveProducts(@Param("price") BigDecimal price);
    
    @Query("SELECT COUNT(p) FROM Product p WHERE p.category.id = :categoryId")
    long countByCategory(@Param("categoryId") Long categoryId);
    
    @Query("SELECT p FROM Product p WHERE p.stock < :threshold")
    List<Product> findLowStockProducts(@Param("threshold") Integer threshold);
}

Parte 3: Configuración de Prueba

application-test.properties

# src/test/resources/application-test.properties
spring.datasource.url=jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1
spring.datasource.driver-class-name=org.h2.Driver
spring.jpa.hibernate.ddl-auto=create-drop
spring.jpa.show-sql=true

Parte 4: Tests a Implementar

Estructura Básica

@DataJpaTest
@ActiveProfiles("test")
class ProductRepositoryTest {

    @Autowired
    private ProductRepository productRepository;

    @Autowired
    private CategoryRepository categoryRepository;

    @Autowired
    private TestEntityManager entityManager;

    private Category electronics;
    private Category clothing;

    @BeforeEach
    void setUp() {
        // Crear categorías
        electronics = categoryRepository.save(new Category(null, "Electronics", "Electronic devices"));
        clothing = categoryRepository.save(new Category(null, "Clothing", "Apparel"));

        // Crear productos
        entityManager.persist(new Product(null, "Laptop", "LAP001", 
            new BigDecimal("999.99"), 10, true, electronics, LocalDateTime.now()));
        entityManager.persist(new Product(null, "Phone", "PHO001", 
            new BigDecimal("599.99"), 25, true, electronics, LocalDateTime.now()));
        entityManager.persist(new Product(null, "T-Shirt", "TSH001", 
            new BigDecimal("29.99"), 100, true, clothing, LocalDateTime.now()));
        entityManager.persist(new Product(null, "Old Phone", "PHO002", 
            new BigDecimal("199.99"), 0, false, electronics, LocalDateTime.now()));
        
        entityManager.flush();
    }
}

Test 1: findAll

@Test
@DisplayName("findAll debería retornar todos los productos")
void findAll_ShouldReturnAllProducts() {
    List<Product> products = productRepository.findAll();
    
    assertThat(products).hasSize(4);
}

Test 2: findByActiveTrue

@Test
@DisplayName("findByActiveTrue debería retornar solo los productos activos")
void findByActiveTrue_ShouldReturnOnlyActiveProducts() {
    // TODO: Implementar
    // Esperar 3 productos activos
}

Test 3: findBySku

@Test
@DisplayName("findBySku debería retornar el producto correspondiente")
void findBySku_WhenExists_ShouldReturnProduct() {
    // TODO: Implementar
}

@Test
@DisplayName("findBySku debería retornar empty cuando el SKU no existe")
void findBySku_WhenNotExists_ShouldReturnEmpty() {
    // TODO: Implementar
}

Test 4: findByPriceLessThan

@Test
@DisplayName("findByPriceLessThan debería retornar los productos más baratos")
void findByPriceLessThan_ShouldReturnCheaperProducts() {
    List<Product> products = productRepository.findByPriceLessThan(new BigDecimal("500"));
    
    assertThat(products)
        .hasSize(2)
        .extracting(Product::getName)
        .containsExactlyInAnyOrder("T-Shirt", "Old Phone");
}

Test 5: findByCategory

@Test
@DisplayName("findByCategory debería retornar los productos de la categoría")
void findByCategory_ShouldReturnProductsInCategory() {
    // TODO: Implementar
    // Esperar 3 productos Electronics
}

Test 6: findByCategoryName

@Test
@DisplayName("findByCategoryName debería retornar los productos por nombre de categoría")
void findByCategoryName_ShouldReturnProducts() {
    // TODO: Implementar
}

Test 7: Consulta @Query personalizada

@Test
@DisplayName("findCheapActiveProducts debería retornar los productos activos y baratos")
void findCheapActiveProducts_ShouldReturnCheapAndActive() {
    List<Product> products = productRepository.findCheapActiveProducts(new BigDecimal("100"));
    
    assertThat(products)
        .hasSize(1)
        .first()
        .extracting(Product::getName)
        .isEqualTo("T-Shirt");
}

Test 8: countByCategory

@Test
@DisplayName("countByCategory debería contar los productos de la categoría")
void countByCategory_ShouldReturnCorrectCount() {
    // TODO: Implementar
}

Test 9: findLowStockProducts

@Test
@DisplayName("findLowStockProducts debería retornar los productos con stock bajo")
void findLowStockProducts_ShouldReturnLowStock() {
    // TODO: Implementar con threshold = 5
}

Test 10: Test de restricción de unicidad

@Test
@DisplayName("Debería lanzar una excepción para un SKU duplicado")
void save_WithDuplicateSku_ShouldThrowException() {
    Product duplicate = new Product();
    duplicate.setName("Duplicate");
    duplicate.setSku("LAP001");  // SKU ya utilizado
    duplicate.setPrice(new BigDecimal("100"));

    assertThrows(DataIntegrityViolationException.class, () -> {
        productRepository.save(duplicate);
        entityManager.flush();  // Forzar la persistencia
    });
}

Test 11: Test de guardado con relación

@Test
@DisplayName("Debería guardar un producto con su categoría")
void save_WithCategory_ShouldPersistRelation() {
    Product newProduct = new Product();
    newProduct.setName("New Product");
    newProduct.setSku("NEW001");
    newProduct.setPrice(new BigDecimal("49.99"));
    newProduct.setStock(50);
    newProduct.setActive(true);
    newProduct.setCategory(clothing);

    Product saved = productRepository.save(newProduct);
    entityManager.flush();
    entityManager.clear();  // Vaciar la caché

    Product found = productRepository.findById(saved.getId()).orElseThrow();
    
    assertThat(found.getCategory()).isNotNull();
    assertThat(found.getCategory().getName()).isEqualTo("Clothing");
}

Test 12: Test de ordenamiento

@Test
@DisplayName("findByActiveTrueOrderByPriceAsc debería ordenar por precio ascendente")
void findByActiveTrueOrderByPriceAsc_ShouldSortByPrice() {
    List<Product> products = productRepository.findByActiveTrueOrderByPriceAsc();
    
    assertThat(products)
        .extracting(Product::getPrice)
        .isSorted();
}

Parte 5: Solucionario

Haga clic para ver el solucionario

@DataJpaTest
@ActiveProfiles("test")
class ProductRepositoryTest {

    @Autowired
    private ProductRepository productRepository;

    @Autowired
    private CategoryRepository categoryRepository;

    @Autowired
    private TestEntityManager entityManager;

    private Category electronics;
    private Category clothing;

    @BeforeEach
    void setUp() {
        electronics = categoryRepository.save(new Category(null, "Electronics", "Electronic devices"));
        clothing = categoryRepository.save(new Category(null, "Clothing", "Apparel"));

        entityManager.persist(createProduct("Laptop", "LAP001", "999.99", 10, true, electronics));
        entityManager.persist(createProduct("Phone", "PHO001", "599.99", 25, true, electronics));
        entityManager.persist(createProduct("T-Shirt", "TSH001", "29.99", 100, true, clothing));
        entityManager.persist(createProduct("Old Phone", "PHO002", "199.99", 0, false, electronics));
        entityManager.flush();
    }

    private Product createProduct(String name, String sku, String price, int stock, boolean active, Category cat) {
        Product p = new Product();
        p.setName(name);
        p.setSku(sku);
        p.setPrice(new BigDecimal(price));
        p.setStock(stock);
        p.setActive(active);
        p.setCategory(cat);
        p.setCreatedAt(LocalDateTime.now());
        return p;
    }

    @Test
    void findByActiveTrue_ShouldReturnOnlyActiveProducts() {
        List<Product> products = productRepository.findByActiveTrue();
        assertThat(products).hasSize(3);
        assertThat(products).allMatch(Product::isActive);
    }

    @Test
    void findBySku_WhenExists_ShouldReturnProduct() {
        Optional<Product> product = productRepository.findBySku("LAP001");
        assertThat(product).isPresent();
        assertThat(product.get().getName()).isEqualTo("Laptop");
    }

    @Test
    void findByCategory_ShouldReturnProductsInCategory() {
        List<Product> products = productRepository.findByCategory(electronics);
        assertThat(products).hasSize(3);
    }

    @Test
    void findByCategoryName_ShouldReturnProducts() {
        List<Product> products = productRepository.findByCategoryName("Clothing");
        assertThat(products).hasSize(1);
        assertThat(products.get(0).getName()).isEqualTo("T-Shirt");
    }

    @Test
    void countByCategory_ShouldReturnCorrectCount() {
        long count = productRepository.countByCategory(electronics.getId());
        assertThat(count).isEqualTo(3);
    }

    @Test
    void findLowStockProducts_ShouldReturnLowStock() {
        List<Product> products = productRepository.findLowStockProducts(5);
        assertThat(products).hasSize(1);
        assertThat(products.get(0).getStock()).isEqualTo(0);
    }
}

Verificación

mvn test -Dtest=ProductRepositoryTest

Checklist

Todos los tests pasan
@DataJpaTest utilizado (no @SpringBootTest)
TestEntityManager utilizado para el setup
Consultas personalizadas probadas
Restricciones verificadas

🎯 Próximo Paso

➡️ TP9.3: Tests REST API

⬅️ Volver al Módulo 9

Objetivos del TP​

Contexto​

Parte 1: Las Entidades​

Category​

Product​

Parte 2: Los Repositories​

CategoryRepository​

ProductRepository​

Parte 3: Configuración de Prueba​

application-test.properties​

Parte 4: Tests a Implementar​

Estructura Básica​

Test 1: findAll​

Test 2: findByActiveTrue​

Test 3: findBySku​

Test 4: findByPriceLessThan​

Test 5: findByCategory​

Test 6: findByCategoryName​

Test 7: Consulta @Query personalizada​

Test 8: countByCategory​

Test 9: findLowStockProducts​

Test 10: Test de restricción de unicidad​

Test 11: Test de guardado con relación​

Test 12: Test de ordenamiento​

Parte 5: Solucionario​

Verificación​

Checklist​

🎯 Próximo Paso​