Tipos de assertions en JUnit 5

En este artículo vamos a ver los diferentes tipos de assertions en JUnit 5 que podemos aplicar en nuestra fase de test en nuestas aplicaciones.

¿Qué son las asserciones (assertions) en JUnit 5?

Las asserciones son métodos que nos permiten afirmar el resultado de una operación. Estos métodos son proporcionados por la clase Assertions en JUnit 5.

assertEquals(2, 2);

Tipos de Assertions en JUnit 5

Las assertions en JUnit 5 permiten comprobar todos los tipos primitivos además se apoya en las funcionalidades introducidas en Java 8 con lo que el mensaje de salida del assert puede ser un Supplier.

Vamos a ver los diferentes tipos de asserts que podemos encontrar en JUnit 5.

assertNotEquals en JUnit 5

El método assertNotEquals nos permite verificar que el valor esperado y valor actual son diferentes.

@Test
void when_assert_two_values_then_assert_not_equals() {
    String hi = "hi"; 
    
    assertNotEquals("bye", hi, "Value is different than "bye");
}

assertEquals en JUnit 5

El método assertEquals funciona a la inversa que el assertNotEquals, es decir, verifica que el valor esperado y el actual son iguales.

@Test
void when_assert_two_values_then_assert_are_equals() {
    String hi = "hi"; 
    
    assertEquals("hi", hi);
}

Una característica importante del assertEquals es que nos permite añadir un valor Delta que establece una diferencia entre el valor esperado y el actual.

@Test
void when_assert_2_times_pi_then_assert_has_delta() {
    Double pi = 3.14; 
    Double piDouble = pi*2;

    Double delta = 0.28;

    assertEquals(6, piDouble, delta);
}

assertArrayEquals con JUnit 5

El assertArrayEquals nos permite verificar si el array esperado es igual que el array actual.

@Test
public void when_assert_two_arrays_then_are_equals() {
    
    char[] expected = "Pepito".toCharArray();
    
    char[] actual = { 'P', 'e', 'p', 'i', 't', 'o' };


    assertArrayEquals(expected, actual, "Pepito arrays are not equals");
}

Uso de assertTrue

AssertTrue nos permite verificar que una condición entre valor actual y el esperado es true.

@Test
public void when_assert_two_values_then_are_equals() {
    
    int expected = 7;
    
    int actual = 5+2;

    assertTrue(expected, actual, "Values are equals");
}

Como hemos comentado anteriormente, assert en JUnit 5 se apoya en las expresiones lambda, por lo que el assert anterior lo podríamos indicar de la siguiente manera:

@Test
public void when_assert_two_values_then_are_equals() {
    
    int expected = 7;
    
    int actual = 5+2;

    BooleanSupplier condition = () -> expected > actual;

    assertTrue(condition, "expected and actual are equals");
}

Uso de assertFalse

AssertFalse en JUnit 5 funciona a la inversa que assertTrue, es decir, asegura que dos valores (esperado y actual) son diferentes.

@Test
public void when_assert_two_values_then_are_equals() {
    
    int expected = 77;
    
    int actual = 5+2;

    assertFalse(expected, actual, "Values are not equals");
}

assertNotNull en JUnit 5

El assertNotNull nos permite asegurar que el valor actual es distinto de null.

@Test
void when_assert_not_null_then_not_null_value() {
    String sayHi = "hi";

    assertNotNull(sayHi, () -> "Value cannot be null");
}

assertNull

assertNull en JUnit 5 es utilizado para asegurar que el valor que queremos verificar es null.

@Test
void when_assert_null_then_null_value() {
    String sayHi = null;

    assertNotNull(sayHi, () -> "Value must be null");
}

assertSame en Junit 5

AssertSame es utilizado para referenciar que dos objetos hacen referencia al mismo objeto, vamos a verlo mejor con un ejemplo:

    @Test
    public void given_two_string_when_assert_same_then_assert_is_true(){
    	
        String cityA ="Spain";
    	String cityAA ="Spain";
    	Assertions.assertSame(cityA,cityAA);
    }
    
    @Test
    public void given_two_string_when_assert_same_then_assert_is_false(){
    	
        String cityA ="Spain";
    	String cityAA ="Spain";
    	Assertions.assertSame(cityA,cityAA, "cityA and cityAA do not refer to same object"););
    }

assertNotSame

AssertNotSame es uno de los tipos de assert en JUnit 5 que nos permite asegurar que dos objetos hacen referencia a diferentes objetos. Es igual que el funcionamiento de assertSame pero al revés.

    @Test
    public void given_two_string_when_assert_not_same_then_assert_is_true(){
    	
        String cityA ="Spain";
    	String cityAA ="France";
    	Assertions.assertNotSame(cityA,cityAA);
    }

assertAll

AssertAll es una característica introducida en JUnit 5, la cual nos permite agrupar los assertions en grupos.

@Test
void given_multiples_number_when_assert_all_then_every_assert_is_ok() {
    int value = 5;
    assertAll(
      "heading",
      () -> assertEquals(10, 5+5),
      () -> assertEquals(5, value),
      () -> assertNotNull(value)
    );
}

assertIterableEquals en JUnit 5

El assertIterableEquals funciona de la misma manera que el assertArrayEquals con la única diferencia que va enfocado al objeto Iterable.

assertLinesMatch

Hace assert si dos listas de String son iguales, se diferencia con assertEquals y assertIterableEquals en :

• Realiza la comprobación expected.equals(actual)
• Utiliza el método String.matches() para tratar la línea como expresión regular.
• Compruebe si la línea esperada es un marcador fast-forward. En caso afirmativo, se aplica el avance rápido y repetimos desde el punto 1.

Un marcador fast-forward es una cadena que comienza y termina con >> y tiene al menos cuatro caracteres. Si hay caracteres entre los literales se descarta.

	@Test
	void given_values_to_compare_when_assert_lines_match_then_true() {

		List<String> expected = asList("Blue", "\\w+", "Sun");

		List<String> actual = asList("Blue", "hola", "Sun");

		assertLinesMatch(expected, actual);
	}

En el caso anterior pasamos una expresión regular que acepta cualquier palabra, por lo que al comparar \\w+ con «hola» el resultado es true.

assertThrows

Nos permite validar si con determinado valor nuestro código lanzará alguna excepción.

	@Test
	public void given_wrong_values_when_parse_to_int_then_throw_exception() {

		Exception exception = assertThrows(ArithmeticException.class, () -> {
			int value = 5/0;
		});

		String expectedMessage = "/ by zero";
		String actualMessage = exception.getMessage();

		assertTrue(actualMessage.contains(expectedMessage));
	}

Ejemplo de assertTimeout en JUnit 5

El tipo de assertions en JUnit 5 de assertTimeout nos permite verificar si nuestro código dará algún tipo de timeout en un determinado tiempo.

	@Test
	void given_1_second_of_time_out_when_request_process_then_return_true() {
		assertTimeout(ofSeconds(1),
				() -> {
					Thread.sleep(100);
				}
		);
	}

 assertTimeoutPreemptively en JUnit 5

La única diferencia de assertTimeoutPreemptively con assertTimeout, es que si assertTimeoutPreemptively la ejecución del Executable o ThrowingSupllier se cancela si se excede un tiempo de espera.

	@Test
	void given_1_second_of_time_out_preemptively_when_request_process_then_return_true() {
		assertTimeoutPreemptively(ofSeconds(1),
				() -> {
					Thread.sleep(100);
				}
		);
	}

Al aplicar este assertion conseguimos que el executable no se siga ejecutando.

Conclusión de tipos de assertions en JUnit 5

En esta entrada hemos visto los diferentes tipos de assertions en JUnit 5, lo que nos ayudará en nuestros test.