Páginas

16/1/15

JUnit assert

JUnit assert. Tipos de assertions.

JUnit assert. Tipos de assertions.





JUnit Assert Tutorial JUnit nos proporciona métodos en los cuales nosotros podemos hacer afirmaciones (Assertions), con estos métodos podemos afirmar tipos primitivos, objetos y arreglos. Estos métodos están conformados de esta manera, (Mensaje en caso de falla, valor esperado, valor real), en el valor real es en donde vamos a afirmar que un valor será el que nosotros creemos, hay que tomar en cuenta que algunos varían con valor esperado y valor real.
Un ejemplo de afirmación de una suma utilizando el método assertEquals se vería así:
assertEquals("El resultado esta mal: ", 1 + 1, 2);

En donde estamos afirmando que la operación (1 + 1) = 2.
Sigue este tutorial y veras todos los tipos de afirmaciones:


Estos son los tipos de afirmaciones (Assertions) que hay disponible hasta el momento:
Assertions Descripción
assertArrayEquals Sirve para comparar dos arreglos y afirmar distintas propiedades del mismo.
assertEquals Sirve para comparar dos tipos de datos u objetos y afirmar que son iguales.
assertFalse Sirve para afirmar que un tipo de dato u objeto es falso.
assertNotNull Sirve para afirmar que un tipo de dato u objeto no es nulo.
assertNotSame Sirve para comparar dos tipos de datos y afirmar que son distintos.
assertNull Sirve para afirmar que un tipo de dato u objeto es nulo.
assertThat Sirve para comparar un tipo de dato u objeto. A diferencia de los assertions normales este trabaja con Matcher
assertTrue Sirve para afirmar que un tipo de dato u objeto es verdadero.

Ahora voy a presentar ejemplos de cada afirmación (Assert) para entender mejor, bueno manos al teclado:

assertArrayEquals:
 @Test
 public void testAssertArrayEquals() {
  String[] nombresEsperados = { "java", "junit", "jboss" };
  String[] nombresActuales = { "java", "junit", "jboss" };

  assertArrayEquals("Fallo - No son los mismos arreglos",
    nombresEsperados, nombresActuales);
 }  

Como vemos en este ejemplo estamos comparando dos arreglos, en este caso la prueba unitaria se realiza sin fallas porque los dos arreglos son iguales, pero si hacemos esto
 @Test
 public void testAssertArrayEquals() {
  String[] nombresEsperados = { "java", "junit", "jboss" };
  String[] nombresActuales = { "java", "junit", "jon server" };

  assertArrayEquals("Fallo - No son los mismos arreglos",
    nombresEsperados, nombresActuales);
 }  

assertArrayEquals Fail
assertArrayEquals
En el ejemplo anterior provocamos el fallo de la afirmación assertArrayEquals ya que los arreglos no son iguales y vemos la manera en la que nos ayuda el mensaje de falla para poder entender que es lo que paso.

assertEquals:

Para hacer esta prueba unitaria vamos a imaginar que tenemos un método en el cual se realiza una suma:
 public int sumar(int num1, int num2) {
  int resultado = num1 + num2;

  return resultado;
 }
Este método recibe dos números y devuelve un int en el cual está el resultado de la operación, para hacerle la prueba unitaria con JUnit tenemos que hacer esto:
 @Test
 public void testSumar() {
  assertEquals("El resultado esta mal: ", sumar(1, 1), 2);
 }
La prueba unitaria pasa sin ningún problema lo que quiere decir que el método sumar(int, int) está bien implementado. Para provocar la falla del método sumar(int, int) con la afirmación assertEquals podemos hacer un cambio simple y esto es lo que sucedería:
 @Test
 public void testSumar() {
  assertEquals("El resultado esta mal: ", sumar(1, 1), 3);
 }
assertArrayEquals Fail
assertEquals fail
Obviamente (1 + 1 no es = 3) y se produce el error.

assertFalse:

Para hacer una prueba unitaria de esta afirmación imaginemos que tenemos un método que dependiendo de un bucle for devuelva un valor boolean el cual nos indique si sobrepasa el máximo permitido o no.
 public boolean validarMax(int maximo){
  boolean max = false;

  for (int i = 0; i < maximo; i++) {
   if(i == 3){
    max = true;
    break;
   }
  }
  return max;
 }
El método validarMax(int) recibe una variable int con la cual se evalúa si se devuelve un false o un true.
 @Test
 public void testValidarMax() {
  assertFalse("Esta variable no es false: ", validarMax(3));
 }
assertFalse
assertFalse
En el ejemplo anterior de la afirmación assertFalse la prueba unitaria pasa sin problemas ya que la variable max nunca llega a ser true.

assertNotNull:

 
 @Test
 public void testAssertNotNull() {
  List nombres = new ArrayList();
  assertNotNull("La lista 'nombres' esta null:", nombres);

  for (int i = 0; i < 3; i++) {
   if (i == 2) {
    nombres = null;
   }
  }
  assertNotNull("La lista 'nombres' esta null:", nombres);
 }
En este ejemplo al principio declaramos la lista nombres como new ArrayList() lo que quiere decir que en la afirmación que hacemos después de eso la lista no está null pero siguiendo con la porción de código notamos que hay un bucle for en el cual la lista la ponemos null y al hacer la afirmación de nuevo la misma falla.
assertNotNull
assertNotNull

assertNotSame:

En este ejemplo vamos a utilizar el mismo método validarMax(int), lo que vamos hacer es afirmar que no devolverá el mismo valor si lo invocamos con distintos int.
 @Test
 public void testAssertNotSame() {
  boolean esMaximo = validarMax(4);// El retorno es true
  boolean noEsMaximo = validarMax(3);// EL retorno es falso

  assertNotSame("Fallo - No son iguales los dos objetos: ", esMaximo,
    noEsMaximo);
 }
En el ejemplo anterior no hay error ya que estamos afirmando que no son los mismos valores.

assertNull:

Bueno esta afirmación es lo opuesto de assertNotNull jejeje obvio... de esta forma se utiliza
 @Test
 public void testAssertNull() {
  String nombre = null;
 
  List nombres = new ArrayList();
  nombres.add("Java");
  nombres.add("JUnit");
  nombres.add("JBoss");
  
  for(String n: nombres){
   if(n.equals("JUnit")){
    nombre = "Tutorial JUnit Assertions"; //Asignamos un valor a la variable
    break;
   }
  }
  assertNull("No esta nulo el objeto", nombre);
 }
  
assertNotNull
assertNotNull
Provocamos el error en el método anterior ya que el objeto no está null.

assertThat:

Hemos llegado a una de las afirmaciones más interesantes que tiene JUnit, como dije en la descripción de esta afirmación assertThat, utiliza Matcher. En este tutorial los Matcher's utilizan la librería llamada Hamcrest. En otro dato java voy a explicarle las bondades de esta poderosa librería.
Por ahora vamos hacer un ejemplo sencillo utilizando un Matcher que trae la librería Hamcrest para que vean de que se trata. Vamos hacer la misma afirmación con uno de los ejemplos anteriores para que vean la diferencia de una assert normal y de un assertThat.

Primero refresquemos la memoria con el ejemplo de la afirmación assertArrayEquals:
 @Test
 public void testAssertArrayEquals() {
  String[] nombresEsperados = { "java", "junit", "jboss" };
  String[] nombresActuales = { "java", "junit", "jon server" };

  assertArrayEquals("Fallo - No son los mismos arreglos",
    nombresEsperados, nombresActuales);
 }  

assertArrayEquals Fail
assertArrayEquals
Ahora haciendo lo mismo pero con assertThat
 @Test
 public void testAssertThatArray() {
  String[] nombresEsperados = { "java", "junit", "jboss" };
  String[] nombresActuales = { "java", "junit", "jon server" };

  assertThat("Fallo - No son los mismos arreglos", nombresActuales,
    is(nombresEsperados));
 }

assertThat Fail
assertThat
Como notamos en el ejemplo anterior la forma en que presenta el error es un poco más clara que con el assertArrayEquals lo que quiere decir que es mejor implementar el assertThat ya que es un poco más humano, es mas entendible, imagínate que después de mucho tiempo ejecutes las pruebas unitarias y hallan varios errores pero como de repente ya no te acuerdas y aparte el mensaje de error no te ayuda mucho tienes que comenzar a perder tiempo buscando que es lo que pasa. Como dije anteriormente próximamente estaré publicando un tutorial acerca de la librería Hamcrest así que pendiente.

assertTrue:

Obvio que se sabe que es lo opuesto de assertFalse, se puede usar de esta forma
 @Test
 public void testAssertTrue() {
  assertTrue("Esta variable no es false: ", validarMax(4));
 }

2 comentarios :

  1. Muy buena entrada, fácil de entender y 100% recomendable!!

    ResponderEliminar
    Respuestas
    1. Que bueno que te gusto la entrada, Suerte Anónimo.

      Eliminar