Cuando se analiza con orientación a objetos, creamos clases que deberían ser totalmente autónomas, y totalmente desacopladas de las demás. Luego, si esto es así, podemos hacer pruebas unitarias de cada clase para comprobar que funcionan perfectamente, y para ayudarnos en esas pruebas, tenemos JUnit.
A lo largo de la fase de diseño, hemos ido definiendo clases; esas clases contienen atributos y los métodos que los ha de manipular. A medida que vayamos avanzando en la implementación, esas clases van a ir siendo instanciadas desde otras, hasta que en medio de una maraña de objetos, nuestra aplicación realice la función solicitada.
Sin embargo, hacer pruebas globales es complicado, y difícil de asegurarnos que están cubiertas todas las posibilidades. Así mismo, cuando vayamos a modificar algo, el tener que realizar directamente las pruebas completas, es terriblemente tedioso.
Por otra parte, y dado que tenemos «clases», pequeños objetos perfectamente aislados, podemos hacer pruebas para verificar que cada uno de ellos cumple con los requisitos pedidos.
Para hacerlo, solo es cuestión que construyamos una clase que instancie la clase a probar, y vaya llamando a los métodos correspondientes, entregando unos conjuntos de datos conocidos, y analizando las respuestas recibidas.
Si veis las ventajas de esa solución, comprenderéis el porque tiene tanta importancia el framework JUnit.
JUnit es un conjunto de clases Java que nos ayudan a preparar, documentar y ejecutar las baterías de pruebas que consideremos adecuado hacer. Ademas, se pueden programar para que dichas pruebas se hagan cada vez que vayamos a compilar una clase, de tal forma que siempre comprobemos que las modificaciones realizadas no van a afectar nuestra aplicación, y que nuestra clase sigue funcionando.
Para aclarar conceptos, vamos a ver un ejemplo de utilización. Primero escribimos la clase que queremos probar, es una sencilla calculadora:
Para poder realizar las pruebas con JUnit 4.x vamos a crear, dentro del proyecto una carpeta para el código de test, y asi lo mantendremos dentro del mismo paquete, pero con los fuentes separados. Enla nueva carpeta, escribimos una clase con el nombre de la clase a probar mas la partícula «Test» (Si estamos utilizando Maven, la particula Test ha de iniciar el nombre de la clase)
En JUnit 4 podemos trabajar con anotaciones, y eso hacemos. Hemos preparado una serie de métodos para realizar pruebas, pero como para todos ellos debemos instanciar la clase Calculadora, hemos creado un método «inicio» 8 (linea 13-15) y con la anotación Before le indicamos que ha de lanzar ese método antes de iniciar cada test; teníamos la posibilidad de declarar otro método que se ejecutara siempre al finalizar cada test, y para el que hubiéramos utilizado la anotación «After«
El resto del programa se dedica a definir métodos de prueba. Para que JUnit los utilice, utilizamos @test, y en cada uno de ellos, utilizamos el método estático de la clase Assert, proporcionada por JUnit. La forma de llamada que estamos utilizando es:
assertEquals("mensaje", "valor deseado", "valor recibido", delta)
Este método compara el valor recibido con el valor deseado, y para los datos numericos acepta la tolerancia indicada en «delta», y si no coinciden, marca el error y presenta el mensaje.
En el ejemplo propuesto, en Eclipse, recibimos en la ventana de JUnit, la siguiente salida:
En la columna de la izquierda nos muestra todos los métodos que ha ejecutado y el tiempo que ha empleado en cada uno, así como una marca para decir si fue correcto o no; cuando seleccionamos alguno de los erróneos, nos aparece a la derecha el mensaje que indicamos, asi como el valor previsto, y el valor recibido.
Si prevemos una excepción, solo debemos indicarlo, por ejemplo, podriamos modificar el programa anterior
En esta ocasión, el test saldrá por correcto, ya que lanzara el error que estamos esperando
4 comentarios