Automatización de pruebas

Mediante las pruebas unitarias garantizamos que una parte del código funciona como se espera. Este tipo de pruebas son codificadas por el usuario, utilizando una serie de funciones o métodos de una clase.

Este conjunto de clases (En el caso de JAVA), se denomina Frameworks y nos proporciona las herramientas a modo de métodos y anotaciones, para llevar a cabo las pruebas, codificando algoritmos que comparan el resultado dado por el programa con el resultado que se espera.

Para JAVA tenemos el caso de JUnit, este framework resulta muy útil para realizar y automatizar estas pruebas.

Como ya hemos comentado, una prueba unitaria se caracteriza por realizar una comparación del resultado esperado de un método con lo retornado por la codificación.

Esta comparación puede ser con cualquier tipo de dato, ya sean numéricos, cadenas de texto, booleanos o incluso excepciones. El único requisito para que una prueba unitaria resulte efectiva es que tenga únicamente dos posibilidades de resolución (correcta/incorrecta).

JUnit forma parte de las versiones mas actuales de Netbeans y Eclipse, aunque si usamos alguna versión que no lo traiga incluido, se puede instalar desde el “market” de cada aplicación fácilmente.

Las ventajas principales de JUnit son:

Es de código abierto.
Podemos crear anotaciones para identificar los métodos de ensayo.
Funciona a base de aserciones.
Es sencillo de aplicar.
Se pueden ejecutar de forma automática.
Permite realizar suites de pruebas.
Además del error nos proporciona información.

Las clases principales que nos encontramos en JUnit son:

Assert: contienen un conjunto de métodos de aserción.
TestCase: contienen un caso de prueba definido como accesorio para ejecutar varias pruebas.
TestResult: contienen métodos para recoger los resultados de la ejecución de un caso de prueba.

Además disponemos de anotaciones como @RunWith y @Suite, qur nos permitirán ejecutar baterías de pruebas.

JUnit se encarga de ejecutar todos los métodos testxxx() que contiene la clase.

En el siguiente ejemplo el único método con este nombre es testConcat(), por tanto JUnit lo ejecutará. Dentro de testConcat() hay una llamada al método assertTrue(). Este método comprueba si la expresión que recibe como argumento es cierta, y trasmite el resultado a JUnit.

import junit.framework.*; 
//Un test de ejemplo sobre la clase String. 
public class EjemploTest extends TestCase { 
      public void testConcat()  { 
                String s = "hola"; 
            String s2 = s.concat(" que tal"); 
                assertTrue(s2.equals("hola que tal")); 
      } 
      public static Test suite() {  
            return new TestSuite(EjemploTest.class); 
      } 
      public static void main (String[] args) { 
            junit.textui.TestRunner.run(suite()); 
      } 
}

import junit.framework.*;

//Un test de ejemplo sobre la clase String.

public class EjemploTest extends TestCase {

public void testConcat() {

String s = "hola";

String s2 = s.concat(" que tal");

assertTrue(s2.equals("hola que tal"));

}

public static Test suite() {

return new TestSuite(EjemploTest.class);

}

public static void main (String[] args) {

junit.textui.TestRunner.run(suite());

}

Para conocer más a fondo el uso de JUnit, tanto en NetBeans como en Eclipse, y su funcionamiento básico, te recomendamos las siguientes lecturas:

Tutorial JUnit (Eclipse)

JUnit es una biblioteca de Java que te ayuda a realizar pruebas unitarias. https://courses.cs.washington.edu/courses/cse143/11wi/eclipse-tutorial/junit.shtml

Tutorial JUnit (NetBeans)

Este tutorial presenta los conceptos básicos de escritura y ejecución de pruebas de unidad JUnit en el IDE NetBeans. https://netbeans.org/kb/docs/java/junit-intro.html

La clase JUnit

Como sucede con todo lo referente a JAVA, al hablar de JUnit estamos refiriéndonos a un conjunto de clases, desde las cuales ejecutaremos los métodos para implementar las pruebas.

Estas clases heredan de junit.framework.TestCase. En el caso de los métodos de prueba veremos que comienzan por test.

import junit.framework.*;  
 public class CuentaTest extends TestCase  {  
 … 
 }

import junit.framework.*;

public class CuentaTest extends TestCase {

…

}

El procedimiento para realizar las pruebas es sencillo, una vez tenemos creada la clase, definimos los métodos(Test) donde ejecutaremos los métodos del programa y mediante los assert comprobaremos si el resultado es el que le indicamos.

public void testCuentaNueva ()  {  
   Cuenta cuenta = new Cuenta();   
    assertEquals(cuenta.getSaldo(), 0.00);  
 }  
 
 public void testIngreso () {  
   Cuenta cuenta = new Cuenta();  
       cuenta.ingresar(100.00);  
   assertEquals(cuenta.getSaldo(), 100.00);  
 }

public void testCuentaNueva () {

Cuenta cuenta = new Cuenta();

assertEquals(cuenta.getSaldo(), 0.00);

}

public void testIngreso () {

Cuenta cuenta = new Cuenta();

cuenta.ingresar(100.00);

assertEquals(cuenta.getSaldo(), 100.00);

}

En el código anterior vemos dos métodos de prueba, el primero usamos el constructor de nuestro programa y comprobamos que el saldo este en 0.

En el segundo utilizamos un método ingresar, donde añadimos 100 € y comprobamos que el nuevo saldo sea el esperado.

Una vez que codifiquemos nuestros casos de prueba, la herramienta JUnit se encargará de validar los resultados y mostrarlos.

Ventanas de JUnit para mostrar el resultado de la prueba.

Métodos JUnit

JUnit dispone de los métodos Assert para probar que los resultados sean los esperados por la ejecución de nuestro código. Estos métodos permiten especificar un error, el resultado esperado y el resultado real.

Estos métodos son:

assertArrayEquals()
assertEquals()
assertTrue()
assertFalse()
assertNull()
assertNotNull()
assertSame()
assertNotSame()
assertThat()

Veamos algunos ejemplos de aplicación:

assertArrayEquals()

package ar.com.ladooscurojava.model.test; 
import org.junit.Assert; 
import org.junit.Test; 
/** 
 * @author ciber 
 */ 
public class PersonaTest { 
    @Test 
    public void testCompararStringArray() { 
       
        String[] arrayEsperado = {"Juan", "María", "Jose"}; 
        String[] arrayPrueba   = {"Juan", "María", "Jose"}; 
        Assert.assertArrayEquals(arrayEsperado, arrayPrueba); 
    } 
}

package ar.com.ladooscurojava.model.test;

import org.junit.Assert;

import org.junit.Test;

/**

* @author ciber

public class PersonaTest {

@Test

public void testCompararStringArray() {

String[] arrayEsperado = {"Juan", "María", "Jose"};

String[] arrayPrueba = {"Juan", "María", "Jose"};

Assert.assertArrayEquals(arrayEsperado, arrayPrueba);

}

Con el método assertArrayEquals() comparamos el array de prueba con el array generado por nuestro código, determinando si el resultado es el esperado.

assertEquals()

package ar.com.ladooscurojava.model.test; 
import org.junit.Assert; 
import org.junit.Test; 
 
/** 
 * @author ciber 
 */ 
public class PersonaTest { 
    @Test 
    public void testComprarIgual() { 
        Assert.assertEquals("dato1", "dato2"); 
    } 
}

package ar.com.ladooscurojava.model.test;

import org.junit.Assert;

import org.junit.Test;

/**

* @author ciber

public class PersonaTest {

@Test

public void testComprarIgual() {

Assert.assertEquals("dato1", "dato2");

}

Con el método assertEquals() comprobamos si el dato resultante tiene el valor deseado.

assertTrue() y assertFalse()

package ar.com.ladooscurojava.model.test; 
import org.junit.Assert; 
import org.junit.Test; 
/** 
 * @author ciber 
 */ 
public class VehiculoTest { 
    @Test 
    public void testComprarTrue() { 
        Assert.assertTrue(true); 
    } 
}

package ar.com.ladooscurojava.model.test;

import org.junit.Assert;

import org.junit.Test;

/**

* @author ciber

public class VehiculoTest {

@Test

public void testComprarTrue() {

Assert.assertTrue(true);

}

Con los métodos assertTrue() y assertFalse() validamos si un resultado es verdadero o falso.

Anotaciones JUnit

Para crear un método test dentro de una clase tenemos que añadir la anotación “@test”.

A continuación detallamos algunas anotaciones existentes:

@RunWith. Se le asigna una clase a la que se invocará en lugar del ejecutor por defecto.
@Before. Indicamos que el método se debe ejecutar antes de cada test (precede al método setUp).
@After. Indicamos que el siguiente método se debe ejecutar después de cada test.
@Test. Indicamos que es un método de test.

public class Empleado{ 
@Test 
public void testSueldo(){ 
float resultadoReal = Empleado.calcularSueldo(2000); 
float esperado = 2200; 
assertEquals(resultadoReal,esperado,0.01): 
} 
}

public class Empleado{

@Test

public void testSueldo(){

float resultadoReal = Empleado.calcularSueldo(2000);

float esperado = 2200;

assertEquals(resultadoReal,esperado,0.01):

}

En algunos casos el resultado de la ejecución puede ser una excepción. Mediante la anotación @Test podemos indicar la excepción esperada.

@Test(expected=BRException.class) 
public void testSueldo(){ 
Empleado.sueldoCalc(2500); 
}

@Test(expected=BRException.class)

public void testSueldo(){

Empleado.sueldoCalc(2500);

}

Otra forma de realizar la prueba es utilizando el método fail, que nos indica un fallo en la prueba.

De este modo, mediante un bloque try-catch, podemos capturar la excepción esperada si el método falla.

@Test 
public void testSueldo(){ 
try{ 
Empleado.sueldoCalc(2500); 
fail('Se esperaba un a excepcion') 
}catch(BRException e)

@Test

public void testSueldo(){

try{

Empleado.sueldoCalc(2500);

fail('Se esperaba un a excepcion')

}catch(BRException e)

Suites de pruebas

Cuando desarrollamos un programa la cantidad de métodos puede crecer considerablemente.

Esto provoca que debamos agrupar diferentes casos de prueba para ejecutarlos a la vez.

Mediante las suites podemos agrupar métodos de prueba para ejecutarlos de forma conjunta.

@RunWith(Suite.class) 
@SuiteClasses({Prueba1.class,Prueba2.class}) 
public class MiSuite{}

@RunWith(Suite.class)

@SuiteClasses({Prueba1.class,Prueba2.class})

public class MiSuite{}

Ejemplo de uso

Vamos a realizar un ejemplo de uso de JUnit sobre una aplicación muy sencilla que calcule el precio con IVA de un producto.

Diseño de nuestra aplicación.

Public class Producto{ 
 
//ATRIBUTOS DE LA CLASE 

 private int id; 
 private String nombre; 
 private double pvc;
 private int ref; 
 prinvate int unidades; 
 private double beneficio; 
 private double iva; 

//CONSTRUCTORES 

public Producto() { 
this.beneficio = 1.30; 
this.iva = 1.21; 
}

public Producto (int ref) { 
this.ref = ref; 
this.beneficio = 1.30; 
this.iva = 1.21; 
}

 public Producto (int id, String nombre, double pvc, int ref, int unidades){ 
  	this.id = id; 
  	this.nombre = nombre; 
  	this.pvc = pvc; 
  	this.ref = ref; 
  	this.unidades = unidades; 
this.beneficio = 1.30; 
this.iva = 1.21; 
} 

}

Public class Producto{

//ATRIBUTOS DE LA CLASE

private int id;

private String nombre;

private double pvc;

private int ref;

prinvate int unidades;

private double beneficio;

private double iva;

//CONSTRUCTORES

public Producto() {

this.beneficio = 1.30;

this.iva = 1.21;

}

public Producto (int ref) {

this.ref = ref;

this.beneficio = 1.30;

this.iva = 1.21;

}

public Producto (int id, String nombre, double pvc, int ref, int unidades){

this.id = id;

this.nombre = nombre;

this.pvc = pvc;

this.ref = ref;

this.unidades = unidades;

this.beneficio = 1.30;

this.iva = 1.21;

}

Declaración de atributos y constructores.

/** 
*método que calcula un beneficio al coste del producto 
*@return Valor total con el beneficio 
*/ 
public double damePvp(){ 
 double pvp =  this.pvc * this.beneficio; 
 return pvp; 
} 
public double damePvpIva(){ 
 double res = this.damePvp() * this.iva; 
 return res; 
}

/**

*método que calcula un beneficio al coste del producto

*@return Valor total con el beneficio

public double damePvp(){

double pvp = this.pvc * this.beneficio;

return pvp;

}

public double damePvpIva(){

double res = this.damePvp() * this.iva;

return res;

}

Una vez tenemos nuestro pequeño programa, vamos a generar la clase de pruebas con JUnit.

Crear clase JUnit

Al ser la primera vez que lo utilizamos, Eclipse no nos mostrara el acceso en el menú inicial, por lo que le damos a «Other…».

Configuración de la clase.

Seleccionamos la opción JUnit Test Case y en la ventana seleccionamos la versión de JUnit a utilizar y el nombre que le daremos a la clase de pruebas.

@Test 
public void testDamePvp(){ 
 Producto prod = new Producto();
//LÓGICA DE LA CLASE 
 prod.setPvc(100.00); 
 prod.setIva(1.21); 
 prod.setBeneficio(1.3); 
 double res = 130.00; 
 //RESULTADO ESPERADO 
 assertEquals(res, prod.damePvp(), 0.01); 
} 
@Test 
public void testDamePvpIva(){ 
 Producto prod = new Producto(); 
 //MÉTODO DE PRUEBA 
 prod.setPvc(100.00); 
 prod.setIva(1.21); 
 prod.setBeneficio(1.3); 
 //ESPERADO 
 double res = 1.21*1.3*100.00; 
 assertEquals (res, prod.damePvpIva(), 0.01); 
}

@Test

public void testDamePvp(){

Producto prod = new Producto();

//LÓGICA DE LA CLASE

prod.setPvc(100.00);

prod.setIva(1.21);

prod.setBeneficio(1.3);

double res = 130.00;

//RESULTADO ESPERADO

assertEquals(res, prod.damePvp(), 0.01);

}

@Test

public void testDamePvpIva(){

Producto prod = new Producto();

//MÉTODO DE PRUEBA

prod.setPvc(100.00);

prod.setIva(1.21);

prod.setBeneficio(1.3);

//ESPERADO

double res = 1.21*1.3*100.00;

assertEquals (res, prod.damePvpIva(), 0.01);

}

Métodos de prueba, el primero compara el valor del precio con PVP y el segundo con el IVA añadido.

Resultado de la prueba.

Pruebas parametrizadas

En algunas ocasiones no es suficiente comprobar el resultado con un solo dato, necesitando enviar una batería de datos para comprobar que el método funciona correctamente.

Con JUnit podemos parametrizar pruebas, enviando mediante una lista una serie de datos a comprobar.

@RunWith (Paremeterized.class) 
public class ProductoParametrosTest { 
 private double pvc; 
 private double esperado; 
 public ProductoParametrosTest( double pvc, double esperado) { 
 // TODO Auto-generated constructor stub 
 Producto prod = new Producto(); 
 prod.setPvc(pvc); 
 this.pvc = prod.damePvp(); 
 this.esperado = esperado; 
 } 
 @Parameters 
 public estatic Collection<Object[]> data (){ 
130.00} }; 
  } 
  Objetc[][] = data = new Object [][] { {10.00,13.00} , {100.00, 
return Arrays.asList(data); 
 @Test 
 public void test() { 
  asserteEquals(pvc, esperado, 0) 
 } 
}

@RunWith (Paremeterized.class)

public class ProductoParametrosTest {

private double pvc;

private double esperado;

public ProductoParametrosTest( double pvc, double esperado) {

// TODO Auto-generated constructor stub

Producto prod = new Producto();

prod.setPvc(pvc);

this.pvc = prod.damePvp();

this.esperado = esperado;

}

@Parameters

public estatic Collection<Object[]> data (){

130.00} };

}

Objetc[][] = data = new Object [][] { {10.00,13.00} , {100.00,

return Arrays.asList(data);

@Test

public void test() {

asserteEquals(pvc, esperado, 0)

}