Probar varias propiedades de objeto en Single Assert

Probar varias propiedades de objeto en Single Assert

En este artículo, aprenderemos cómo afirmar múltiples propiedades de un objeto en una sola afirmación en JUnit, Hamcrest y AssertJ.

Índice
  1. Conocimiento
  2. Afirmaciones grupales
    1. Junit - afirmarTodo
    2. Hamcrest - allof
    3. AssertJ - devuelve... de

Conocimiento

Por lo general, escribimos una prueba unitaria para verificar el resultado esperado de una pieza de código. Cuando el resultado esperado es un objeto, hay dos formas de comprobar las propiedades de un objeto:-

  1. Escriba una afirmación para cada propiedad de un objeto y verifíquela individualmente
  2. Agrupe la aserción de todas las propiedades de un objeto y verifíquelas colectivamente

La afirmación colectiva de las propiedades de los objetos es más fácil de leer y mantener. Veamos cómo agrupar aserciones usando JUnit, Hamcrest y AssertJ.

Afirmaciones grupales

Digamos que queremos comprobar Product Object, que tiene diferentes tipos de propiedades, que van desde Long, String, Boolean, Integer, BigDecimal hasta List.

public class Product {
    private Long id;
    private String name;
    private Boolean onSale;
    private Integer stockQuantity;
    private BigDecimal price;
    private List<String> labels;
}

Junit - afirmarTodo

Podemos afirmar colectivamente las propiedades del objeto usando assertAll() en Junet. Veamos el ejemplo de uso: -

  1. Verifique el valor de la propiedad de cada objeto usando assertEquals()
  2. Verifique las diferentes condiciones de propiedad del objeto usando assertNotNull() Y assertTrue()
assertAll(messge,
    () -> assertFn(expected, actual),
    () -> assertFn(...),
    () -> assertFn(...)
)
import static org.junit.jupiter.api.Assertions.*;

@Test
public void givenObject_testAllProperties() {
    // Object to test
    Product product = new Product(1L, "Office Desk", true, 50, new BigDecimal("599.99"), Arrays.asList("Wooden", "Electric"));

    // 1. Verify property values collectively
    assertAll("Verify All Product Property Values",
        () -> assertEquals(1L, product.getId()),
        () -> assertEquals("Office Desk", product.getName()),
        () -> assertEquals(true, product.getOnSale()),
        () -> assertEquals(50, product.getStockQuantity()),
        () -> assertEquals("599.99", product.getPrice().toString()),
        () -> assertEquals(Arrays.asList("Wooden", "Electric"), product.getLabels()));

    // 2. Test property conditions collectively
    assertAll("Verify Product Property Conditions",
        () -> assertNotNull(product), 
        () -> assertNotNull(product.getId()),
        () -> assertTrue(product.getName().contains("Desk")),  // Product name contains 'Desk'
        () -> assertTrue(product.getOnSale()),  // Product on sale
        () -> assertTrue(product.getStockQuantity() > 0),  // Stock is available
        () -> assertTrue(product.getPrice().compareTo(new BigDecimal(1000.0)) < 0),  // Price under 1000
        () -> assertTrue(product.getLabels().contains("Wooden")));  // Looking for 'Wooden' Desk
    }

Hamcrest - allof

Podemos combinar emparejadores Hamcrest usando allOf() para afirmar colectivamente las propiedades del Objeto.

assertThat(message, object, allOf(matcher1, matcher2, ...))

Veamos un ejemplo de uso: -

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;

@Test
public void givenObject_testAllProperties() {
    // Object to test
    Product product = new Product(1L, "Office Desk", true, 50, new BigDecimal("599.99"), Arrays.asList("Wooden", "Electric"));

    // Verify property values collectively
    assertThat("Verify All Product Property Values", product, allOf(
            hasProperty("id", equalTo(1L)),
            hasProperty("name", equalTo("Office Desk")),
            hasProperty("onSale", is(true)),
            hasProperty("stockQuantity", equalTo(50)),
            hasProperty("price", is(new BigDecimal("599.99"))),
            hasProperty("labels", equalTo(List.of("Wooden", "Electric")))));

    // Test property conditions collectively
    assertThat("Verify Product Property Conditions", product, allOf(
            notNullValue(),
            hasProperty("id", notNullValue()),
            hasProperty("name", endsWith("Desk")),  // Product name endsWith 'Desk'
            hasProperty("onSale", is(true)),  // Product on sale
            hasProperty("stockQuantity", greaterThan(0)),  // Stock is available
            hasProperty("price", lessThan(new BigDecimal(1000.0))),  // Price under 1000
            hasProperty("labels", hasItem("Electric"))));  // Looking for 'Electric' Desk
}

En AssertJ, podemos afirmar colectivamente las propiedades de los objetos extrayéndolos como una lista usando extracting() luego encadenarlos con containsExactly() para comprobar el:-

  1. valor de propiedad de cada objeto tomado de extracting() pasar nombres de campo
  2. resultado de la condición de propiedad de cada objeto recuperada de extracting() pasando las condiciones
assertThat(object)
    .describedAs(message)
    .extracting(fieldName1/condition1, fieldName2/condition2, ...)
    .containsExactly(value1/result1, value2/result2, ...)

Veamos el ejemplo de uso: -

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

@Test
public void givenObject_testAllProperties_extracting_containsExactly(){
    // Object to test
    Product product = new Product(1L, "Office Desk", true, 50, new BigDecimal("599.99"), Arrays.asList("Wooden", "Electric"));

    // 1. Verify property values collectively
    assertThat(product)
            .describedAs("Verify All Product Property Values")
            .extracting("id", "name", "onSale", "stockQuantity", "price", "labels")
            .containsExactly(1L, "Office Desk", true, 50, new BigDecimal("599.99"), Arrays.asList("Wooden", "Electric"));

    // 2. Test property conditions collectively
    assertThat(product)
            .describedAs("Verify Product Property Conditions")
            .extracting(Product::getId, 
                Product::getName, 
                Product::getOnSale, 
                p -> p.getStockQuantity() > 0, 
                p -> p.getPrice().compareTo(new BigDecimal(1000.0)) < 0, 
                p -> p.getLabels().contains("Wooden"))
            .containsExactly(1L, "Office Desk", true, true, true, true);

}

AssertJ - devuelve... de

En AssertJ, podemos afirmar colectivamente la propiedad del objeto encadenando el returns() para cada propiedad juntos. Extraemos el:-

  1. valor de la propiedad del objeto pasando el nombre del campo dentro from()
  2. resultado de la condición de propiedad del objeto pasando la condición dentro from()
assertThat(object)
    .describedAs(message)
    .returns(expected, from(fieldNameOrCondition))
    .returns(...)
    .returns(...)

Veamos el ejemplo de uso: -

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

@Test
public void givenObject_testAllProperties_returns_from(){
    // Object to test
    Product product = new Product(1L, "Office Desk", true, 50, new BigDecimal("599.99"), Arrays.asList("Wooden", "Electric"));

    // 1. Verify property values collectively
    assertThat(product)
            .describedAs("Verify All Product Property Values")
            .returns(1L, from(Product::getId))
            .returns("Office Desk", from(Product::getName))
            .returns(true, from(Product::getOnSale))
            .returns(50, from(Product::getStockQuantity))
            .returns(new BigDecimal("599.99"), from(Product::getPrice))
            .returns(Arrays.asList("Wooden", "Electric"), from(Product::getLabels));

    // 2. Test property conditions collectively
    assertThat(product)
            .describedAs("Verify Product Property Conditions")
            .isNotNull()
            .hasNoNullFieldsOrProperties()
            .returns(true, from(p -> p.getName().contains("Desk")))  // Product name endsWith 'Desk'
            .returns(true, from(Product::getOnSale))  // Product on sale
            .returns(true, from(p -> p.getStockQuantity() > 0))  // Stock is available
            .returns(true, from(p -> p.getPrice().compareTo(new BigDecimal(1000.0)) < 0))  // Price under 1000
            .returns(true, from(p -> p.getLabels().contains("Wooden")));  // Looking for 'Wooden' Desk
}

Si quieres conocer otros artículos parecidos a Probar varias propiedades de objeto en Single Assert puedes visitar la categoría Tutoriales.

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Subir

Esta página web utiliza cookies para analizar de forma anónima y estadística el uso que haces de la web, mejorar los contenidos y tu experiencia de navegación. Para más información accede a la Política de Cookies . Ver mas