Conociendo a jasmine

Primeramente jasmine es una chica la cual los programadores no conocemos, es en realidad un framework de behavior-driven development(BDD) para aplicar pruebas al código javascript de nuestros proyectos. Para realizar las pruebas no se necesita DOM('Modelo de Objetos del Documento o en inglés Document Object Model).

El porqué de jasmine es que muchos programadores están desarrollando un proyecto web es casi un 99% que se utilice javascript o alguna librería derivada de este lenguaje, además cuando se codifica en este lenguaje se crean muchas funciones para eventos o alguna otra funcionalidad dentro del proyecto. Además muchos programadores han visto las pruebas unitarias como algo muy molesto debido algunos frameworks de estos tipos no le hacían el trabajo un poco más fácil al desarrollador, jasmine en su sencillez trata de hacer la vida más fácil a la persona que lo implementa en el proyecto

Características

• Posee una sintaxis muy clara
• funciones que permiten la escritura más fácil
• cada test creado por el usuario es una función

Conjunto de funciones

La facilidad para poder escribir las pruebas unitarias en jasmine es gracias a las funciones que posee este framework, las cuales son las siguientes

Suites:
Los “suites” es un nombre que describe a qué género o sección se va a pasar por un conjunto de pruebas unitarias además tiene una herramienta que es el núcleo que se necesita para poder tener un orden al momento de crear las pruebas. “describes” es una función global y es con la cual se inicia toda prueba unitaria, además consta con dos parámetros y las sintaxis de la misma es así describe(“”, function(){});

• El primer parámetro es una cadena de caracteres donde se define el nombre de la prueba unitaria.
• El segundo parámetro es una función donde está el código que ejecutará la prueba de código.

Specs:
Las expectativas en jasmine (son afirmaciones que pueden ser ciertas o falsas dependiendo de cuál resultado el programador espere en la prueba unitaria.

“it” como “describe” es una función que toma dos parámetros que el primero es una cadena de caracteres para describir un título o nombre de la prueba unitaria y como segundo parámetro una función donde se ejecuta un bloque de código, y la sintaxis es la siguiente it(“”, function(){});

Expectations:
Son construidas con la función “expect” el cual toma el valor actual, ese valor está enlazado con la función matcher(inglés) que toma el valor esperado. La sintaxis es la siguiente expect(valor actual).matchers(valor esperado)

Matchers:
Los matchers son funciones que implementan comparaciones booleanas entre el valor actual y el esperado, ellos son los responsables de reportar a jasmine si la expectativa es verdadera o falsa.
Listado de matchers más comunes aunque se pueden crear matchers personalizados a la necesidad del programador.

• expect(x).toEqual(y); verifica si ambos valores son iguales.
• expect(x).toBe(y); verifica si ambos objetos son iguales.
• expect(x).toMatch(pattern); verifica si el valor pertenece al patrón establecido.
• expect(x).toBeDefined(); verifica si el valor está definido.
• expect(x).toBeUndefined(); verifica si el valor es indefinido.
• expect(x).toBeNull(); verifica si el valor es nulo.
• expect(x).toBeTruthy(); verifica si el valor es verdadero.
• expect(x).toBeFalsy(); verifica si el valor es falso.
• expect(x).toContain(y); verifica si el valor actual contiene el esperado.
• expect(x).toBeLessThan(y); verifica si el valor actual es menor que el esperado.
• expect(x).toBeGreaterThan(y); verifica si el valor actual es mayor que el esperado.

Ahora después de la vasta explicación que se dio en la lista anterior se hablara de otras funcionalidades que nos brinda jasmine.

Agrupar “specs” mediante “describe”

El título se debe a que jasmine nos permite agrupar muchos “specs” dentro de un “describe” que tenga una descripción clara de lo que se está haciendo y se puede observar en el siguiente ejemplo para que pueda quedar más claro.

Pero antes de ejecutar nuestro primero ejemplo debemos descargar el archivo que contiene Jasmine para poder realizar nuestras prueba, con el siguiente enlace https://github.com/pivotal/jasmine/downloads , una vez en tu computadora extraes los archivos y en la carpeta llamada “spec” colocas los archivos o scripts donde están escritas las pruebas unitarias y en la llamada “src” colocan los archivos que tienen las funciones del proyecto. El último paso es buscar el archivo llamado “SpecRunner.htnl” y es donde colocas las rutas de los archivos colocados en las carpetas mencionadas anteriormente, después de eso manos a la obra.

Ejemplo 1:

describe("operaciones aritméticas", function(){
it("adicion", function(){
var suma = 1 + 3;
expect(suma).toEqual(4);
});

it("resta", function(){
var resta = 2 + 1;
expect(resta).toBeLessThan(4);
});

it("multiplicacion", function(){
var multiplicacion = 2 * 10;
expect(multiplicacion).toBeGreaterThan(9);
});

it("division", function(){
var division = 15 + 3;
expect(division).toEqual(5);
});
});

En este ejemplo podemos observar cómo se ejecutan pruebas unitarias de las cuatro operaciones aritméticas básicas. Como se observa en el ejemplo se puede agrupar muchas pruebas en un grupo específico gracias a “specs” y “describe”.

Todo no acaba con la muestra anterior todavía jasmine tiene más sorpresas para nosotros y son y se explicarán con el siguiente bloque.

Organizaciones (“Setup”) y Desmontar (“Teardown”)

Con estos conceptos se pueden evitar la duplicidad de código y mantener las variables inicializadas en un solo lugar además de mantener la modularidad. Jasmine provee las funciones globales llamadas “beforeEach” y “afterEach” con las cuales nuestras pruebas unitarias serán más fáciles de realizar.

• beforeEach se ejecuta antes de cada “spec” dentro del “describe”.
• afterEach se ejecuta después de cada “spec” dentro del “describe”.

Con el siguiente ejemplo veremos cómo se usan están excelentes funciones.

Ejemplo 2:

describe("operaciones aritméticas", function(){
var suma;
var resta;
var multiplicacion;
var division;

beforeEach(function(){
suma = 1 + 3;
resta = 2 + 1;
multiplicacion = 2 * 10;
division = 15 + 3;
});

afterEach(function(){
suma = 0;
resta = 0;
multiplicacion = 0;
division = 0;
});

it("adicion", function(){
expect(suma).toEqual(4);
});

it("resta", function(){
expect(resta).toBeLessThan(4);
});

it("multiplicacion", function(){
expect(multiplicacion).toBeGreaterThan(9);
});

it("division", function(){
expect(division).toEqual(5);
});
});

Este ejemplo es parecido al anterior pero con la diferencia que aplicamos las funciones mencionadas en el párrafo anterior.

Anidación(“Nesting”) y Bloques(“Blocks”)

Otra gran ayuda que nos da jasmine es la anidación y bloques los cuales se combinan para hacer el trabajo de las pruebas unitarias algo más agradable para el programador al momento de ver cómo va ordenar su conjunto de pruebas ya que por lo general en los proyectos se codifican muchas funciones por ende la lista de pruebas aumenta conforme pasa el tiempo y crezcan las funcionalidades del proyecto.

La finalidad es poder crear “describe” dentro de “describe” entonces esto se hace para poder darle más claridad y modularidad, la mejor manera de explicar esto es a través de nuestro último ejemplo.

Ejemplo 3:

describe("calculadora",function(){
describe("operaciones aritméticas", function(){
var suma;
var resta;
var multiplicacion;
var division;

beforeEach(function(){
suma = 1 + 3;
resta = 2 + 1;
multiplicacion = 2 * 10;
division = 15 + 3;
});

afterEach(function(){
suma = 0;
resta = 0;
multiplicacion = 0;
division = 0;
});

it("adicion", function(){
expect(suma).toEqual(4);
});

it("resta", function(){
expect(resta).toBeLessThan(4);
});

it("multiplicacion", function(){
expect(multiplicacion).toBeGreaterThan(9);
});

it("division", function(){
expect(division).toEqual(5);
});
});

describe("operaciones especiales",function(){

beforeEach(function(){
var raizcuadrada = 0;
var exponente = 0;
var base = 0;
});

afterEach(function(){
var raizcuadrada = 0;
var exponente = 0;
var base = 0;
});

it("raiz cuadrada",function(){
raizcuadrada = 4
expect(raizcuadrada).toEqual(Math.sqrt(16));
});


it("exponente",function(){
var exponente = 3;
var base = 4;
respuesta = Math.pow(base,exponente);
expect(respuesta).toEqual(64);
});

});
});

Con este ejemplo se observa que la anidación descrita en el párrafo anterior algo que nos ayuda como programadores que realizamos pruebas unitarias en nuestros proyectos. Por lo visto durante este escrito solo quedar animarse para implementar esta excelente herramienta en nuestro proyecto web actual o futuro solo queda decir “Happy Testing”.