Cursos Empresas Blog Live Conf Eventos Precios

Esta lectura te servirá de referencia para las cosas que puedes hacer con Jasmine:

Creando un set de pruebas
describe("Componente", () => {
  it("debería ...", () => {
    expect(true).toBe(true);
  });
});

Agrupando por funcionalidad
describe("Componente", () => {
  describe("Funcionalidad uno", () => {
    it("debería ...", () => {
      expect(true).toBe(true);
    });
  });
});

Matchers

expect(false).not.toBe(true); // Prueba negativa
comparación con ===, ejemplo: 1 === 1 1 !== '1'

expect(thing).toBe(realThing);
El valor no es undefined 

expect(result).toBeDefined();
El valor actual es falso, ejemplo:0, '', false

expect(result).toBeFalsy();
El valor actual es verdadero, ejemplo: 'sd', 1, true

expect(thing).toBeTruthy();
El valor actual es mayor al esperado

expect(result).toBeGreaterThan(3);
El valor actual es mayor o igual al esperado

expect(result).toBeGreaterThanOrEqual(25);
El valor actual es menor al esperado

expect(result).toBeLessThan(0);
El valor actual es menor o igual al esperado

expect(result).toBeLessThanOrEqual(123);
El valor actual es NaN

expect(thing).toBeNaN();
El valor actual es -Infinity 

expect(thing).toBeNegativeInfinity();
El valor actual es Infinity

expect(thing).toBePositiveInfinity();
El valor actual es null 

expect(result).toBeNull();
El valor actual continue una cadena. Ejemplo:

 'Hola mundo'.toContain('Hola') // true
['Hola', 'mundo'].toContain('Hola') // true
expect(array).toContain(anElement); expect(string).toContain(substring);
El valor actual es igual utilizando una comparación profunda

expect(bigObject).toEqual({"foo": ['bar', 'baz']});
El espía fue llamado

expect(mySpy).toHaveBeenCalled(); expect(mySpy).not.toHaveBeenCalled();
El espía fue llamado antes que otro

expect(mySpy).toHaveBeenCalledBefore(otherSpy);
El espía fue llamado n veces:

expect(mySpy).toHaveBeenCalledTimes(3);
El espía fue llamado con los siguientes parámetros

expect(mySpy).toHaveBeenCalledWith('foo', 'bar', 2);
Verificar si un elemento tiene una clase

const el = document.createElement('div');
el.className = 'foo bar baz';
expect(el).toHaveClass('bar');
El valor actual comparado con una expresión regular

expect("my string").toMatch(/string$/); 
expect("other string").toMatch("her");
Ciclos de vida
describe("Component", () => {
  // Shared variables
  var foo = 0;
beforeAll(() => {})
  beforeEach(() => {})
  afterEach(() => {})
  afterAll(() => {})
});
Deshabilitando pruebas
xdescribe("A spec", () => {
  it("waiting to be enable", function() {
    expect(true).toEqual(true);
  });
});
describe("A spec", () => {
  it("this run", () => {
    expect(true).toEqual(true);
  });
  xit("this is skipped", () => {
    expect(true).toEqual(true);
  });
});
Utilizando spyOn
describe('A spy', () => {
  let foo,
    bar = null;
  beforeEach(() => {
    foo = {
      setBar: value => {
        bar = value;
      },
    };
    spyOn(foo, 'setBar');
    foo.setBar(123);
    foo.setBar(456, 'another param');
  });
  it('tracks that the spy was called', () => {
    expect(foo.setBar).toHaveBeenCalled();
  });
  it('tracks that the spy was called x times', () => {
    expect(foo.setBar).toHaveBeenCalledTimes(2);
  });
  it('tracks all the arguments of its calls', () => {
    expect(foo.setBar).toHaveBeenCalledWith(123);
    expect(foo.setBar).toHaveBeenCalledWith(456, 'another param');
  });
});
Crear espía cuando desconocemos si la función existe
describe("Create a 'bare' spy", () => {
  let notSure;
  beforeEach(function() {
    notSure = jasmine.createSpy('notSure');
    notSure("I", "am", "a", "spy");
  });
  it("tracks that the spy was called", function() {
    expect(notSure).toHaveBeenCalled();
  });
});
Creando multiples espías en un mismo objeto
describe("Multiple spies", () => {
  const tape;
  beforeEach(() => {
    tape = jasmine.createSpyObj('tape', ['play', 'pause', 'stop']);
    tape.play();
      tape.pause();
      tape.rewind(0);
    });
  it("creates spies for each requested function", () => {
    expect(tape.play).toBeDefined();
    expect(tape.pause).toBeDefined();
    expect(tape.stop).toBeDefined();
  });
});
Verificar una propiedad de un objeto
describe("jasmine.objectContaining", () => {
  let foo;
  beforeEach(() => {
    foo = {
      a: 1,
      b: 2,
      bar: "baz"
    };
  });
  it("matches objects with the expect key/value pairs", () => {
    expect(foo).toEqual(jasmine.objectContaining({
      bar: "baz"
    }));
    expect(foo).not.toEqual(jasmine.objectContaining({
      c: 37
    }));
  });
});
Verificar una propiedad dentro de un objeto pasado como parámetro a una función
describe('jasmine.objectContaining', () => {
  it('is useful for comparing arguments', () => {
    const callback = jasmine.createSpy('callback');
    callback({
      bar: 'baz',
    });
    expect(callback).toHaveBeenCalledWith(
      jasmine.objectContaining({
        bar: 'baz',
      })
    );
  });
});
Verificar un valor dentro de un arreglo
describe("jasmine.arrayContaining", () => {
  let foo;
  beforeEach(function() {
    foo = [1, 2, 3, 4];
  });
  it("matches arrays with some of the values", () => {
    expect(foo).toEqual(jasmine.arrayContaining([3, 1]));
    expect(foo).not.toEqual(jasmine.arrayContaining([6]));
  });
});
Verificar un valor dentro de un arreglo pasado como parámetro a una función
describe('jasmine.arrayContaining', () => {
  it('is useful when comparing arguments', () => {
    const callback = jasmine.createSpy('callback');
    callback([1, 2, 3, 4]);
   expect(callback)
     .toHaveBeenCalledWith(jasmine.arrayContaining([4, 2, 3]));
   expect(callback)
     .not.toHaveBeenCalledWith(jasmine.arrayContaining([5, 2]));
  });
});
Usando regex para comparar comparar cadenas de texto
describe('jasmine.stringMatching', () => {
  it("matches as a regexp", () => {
    expect({foo: 'bar'})
      .toEqual({foo: jasmine.stringMatching(/^bar$/)});
    expect({foo: 'foobarbaz'})
      .toEqual({foo: jasmine.stringMatching('bar')});
  });
   describe("when used with a spy", () => {
    it("comparing arguments", () => {
      const callback = jasmine.createSpy('callback');
      callback('foobarbaz');
      expect(callback)
        .toHaveBeenCalledWith(jasmine.stringMatching('bar'));
      expect(callback)
        .not.toHaveBeenCalledWith(jasmine.stringMatching(/^bar$/));
    });
  });
});

Pruebas Unitarias con Jasmine: Matchers, Espías y Ciclos de Vida

Curso de Unit Testing para MEAN con Jasmine

Clase 15 de 38

Clase 15 / 38

Carlos Alejandro Hernández Mejía

Hace 6 años

Me pareció bastante confuso leer el diccionario cómo lo dejó Cristian, así que me tomé la tarea de hacerlo más digerible.

Creando un set de pruebas

describe("Componente", () => {
  it("debería ...", () => {
    expect(true).toBe(true);
  });
});

Agrupando por funcionalidad

describe("Componente", () => {
  describe("Funcionalidad uno", () => {
    it("debería ...", () => {
      expect(true).toBe(true);
    });
  });
});

Comparación

Datos primitivos

Igualdad

expect(thing).toBe(realThing);

Desigualdad

expect(false).not.toBe(true);

El valor está definidido → No es undefined

expect(resul).toBeDefined();

El valor actual es falso. Ejemplo: result == 0, result == '', result == false

expect(result).toBeFalsy();

El valor actual es verdadero. Ejemplo: result == 'sd', result == 1, result == true

expect(result).toBeTruthy();

result > 3

expect(result).toBeGreaterThan(3);

result >= 25

expect(result).toBeGreaterThanOrEqual(25);

result < 0

expect(result).toBeLessThan(0);

result <= 123

expect(result).toBeLessThanOrEqual(123);

thing== NaN

expect(thing).toBeNaN();

thing == -∞

expect(thing).toBeNegativeInfinity();

thing == +∞

expect(thing).toBePositiveInfinity();

result == null

expect(result).toBeNull();

El valor actual contiene una cadena.

'Hola mundo'.toContain('Hola') // true
['Hola', 'mundo'].toContain('Hola') // true
expect(array).toContain(anElement); expect(string).toContain(substring);

Objetos

Igualdad

expect(bigObject).toEqual({"foo": ['bar', 'baz']});

El espía fue llamado

expect(mySpy).toHaveBeenCalled();
expect(mySpy).not.toHaveBeenCalled();

El espía fue llamado antes que otro

expect(mySpy).toHaveBeenCalledBefore(otherSpy);

El espía fue llamado n veces:

expect(mySpy).toHaveBeenCalledTimes(3);

El espía fue llamado con los siguientes parámetros

expect(mySpy).toHaveBeenCalledWith('foo', 'bar', 2);

Verificar si un elemento tiene una clase

const el = document.createElement('div');
el.className = 'foo bar baz';
expect(el).toHaveClass('bar');

El valor actual comparado con una expresión regular

expect("my string").toMatch(/string$/); 
expect("other string").toMatch("her");

Ciclos de vida

describe("Component", () => {
  // Shared variables
  var foo = 0;
	beforeAll(() => {})
  beforeEach(() => {})
  afterEach(() => {})
  afterAll(() => {})
});

Deshabilitando pruebas

xdescribe("A spec", () => {
  it("waiting to be enable", function() {
    expect(true).toEqual(true);
  });
});
describe("A spec", () => {
  it("this run", () => {
    expect(true).toEqual(true);
  });
  xit("this is skipped", () => {
    expect(true).toEqual(true);
  });
});

Utilizando spyOn

describe('A spy', () => {
  let foo,
  bar = null;
	beforeEach(() => {
    foo = {
      setBar: value => {
        bar = value;
      },
    };
    spyOn(foo, 'setBar');
    foo.setBar(123);
    foo.setBar(456, 'another param');
  });
  it('tracks that the spy was called', () => {
    expect(foo.setBar).toHaveBeenCalled();
  });
  it('tracks that the spy was called x times', () => {
    expect(foo.setBar).toHaveBeenCalledTimes(2);
  });
  it('tracks all the arguments of its calls', () => {
    expect(foo.setBar).toHaveBeenCalledWith(123);
    expect(foo.setBar).toHaveBeenCalledWith(456, 'another param');
  });
});

Crear espía cuando desconocemos si la función existe

describe("Create a 'bare' spy", () => {
  let notSure;
  beforeEach(function() {
    notSure = jasmine.createSpy('notSure');
    notSure("I", "am", "a", "spy");
  });
  it("tracks that the spy was called", function() {
    expect(notSure).toHaveBeenCalled();
  });
});

Creando multiples espías en un mismo objeto

describe("Multiple spies", () => {
  const tape;
  beforeEach(() => {
    tape = jasmine.createSpyObj('tape', ['play', 'pause', 'stop']);
    tape.play();
    tape.pause();
    tape.rewind(0);
  });
  it("creates spies for each requested function", () => {
    expect(tape.play).toBeDefined();
    expect(tape.pause).toBeDefined();
    expect(tape.stop).toBeDefined();
  });
});

Verificar una propiedad de un objeto

describe("jasmine.objectContaining", () => {
  let foo;
  beforeEach(() => {
    foo = {
      a: 1,
      b: 2,
      bar: "baz"
    };
  });
  it("matches objects with the expect key/value pairs", () => {
    expect(foo).toEqual(jasmine.objectContaining({
      bar: "baz"
    }));
    expect(foo).not.toEqual(jasmine.objectContaining({
      c: 37
    }));
  });
});

Verificar una propiedad dentro de un objeto pasado como parámetro a una función

describe('jasmine.objectContaining', () => {
  it('is useful for comparing arguments', () => {
    const callback = jasmine.createSpy('callback');
    callback({
      bar: 'baz',
    });
    expect(callback).toHaveBeenCalledWith(
      jasmine.objectContaining({
        bar: 'baz',
      })
    );
  });
});

Verificar un valor dentro de un arreglo

describe("jasmine.arrayContaining", () => {
  let foo;
  beforeEach(function() {
    foo = [1, 2, 3, 4];
  });
  it("matches arrays with some of the values", () => {
    expect(foo).toEqual(jasmine.arrayContaining([3, 1]));
    expect(foo).not.toEqual(jasmine.arrayContaining([6]));
  });
});

Verificar un valor dentro de un arreglo pasado como parámetro a una función

describe('jasmine.arrayContaining', () => {
  it('is useful when comparing arguments', () => {
    const callback = jasmine.createSpy('callback');
    callback([1, 2, 3, 4]);
		expect(callback).toHaveBeenCalledWith(jasmine.arrayContaining([4, 2, 3]));
	  expect(callback).not.toHaveBeenCalledWith(jasmine.arrayContaining([5, 2]));
  });
});

Usando regex para comparar comparar cadenas de texto

describe('jasmine.stringMatching', () => {
  it("matches as a regexp", () => {
    expect({foo: 'bar'}).toEqual({foo: jasmine.stringMatching(/^bar$/)});
    expect({foo: 'foobarbaz'}).toEqual({foo: jasmine.stringMatching('bar')});
  });
   describe("when used with a spy", () => {
    it("comparing arguments", () => {
      const callback = jasmine.createSpy('callback');
      callback('foobarbaz');
      expect(callback).toHaveBeenCalledWith(jasmine.stringMatching('bar'));
      expect(callback).not.toHaveBeenCalledWith(jasmine.stringMatching(/^bar$/));
    });
  });
});

Comentarios (7)7 comentarios

David Behar

Hace 7 años

Se confunde un poco con todo en el mismo bloque de código, acá un edit Prueba negativa

expect(false).not.toBe(true); comparación con ===, ejemplo: 1 === 1 1 !== '1'

Igualdad completa:

El valor no es undefined

expect(result).toBeDefined();

El valor actual es falso, ejemplo:0, '', false

El valor actual es verdadero, ejemplo: 'sd', 1, true

expect(thing).toBeTruthy();

El valor actual es mayor al esperado

El valor actual es mayor o igual al esperado

El valor actual es menor al esperado

El valor actual es menor o igual al esperado

El valor actual es NaN

El valor actual es -Infinity

El valor actual es Infinity

El valor actual es null

El valor actual continue una cadena. Ejemplo:

El valor actual es igual utilizando una comparación profunda

describe("Component", () => {
  // Shared variables
  var foo = 0;
beforeAll(() => {})
  beforeEach(() => {})
  afterEach(() => {})
  afterAll(() => {})
});
Deshabilitando pruebas
xdescribe("A spec", () => {
  it("waiting to be enable", function() {
    expect(true).toEqual(true);
  });
});
describe("A spec", () => {
  it("this run", () => {
    expect(true).toEqual(true);
  });
  xit("this is skipped", () => {
    expect(true).toEqual(true);
  });
});

describe("Multiple spies", () => {
  const tape;
  beforeEach(() => {
    tape = jasmine.createSpyObj('tape', ['play', 'pause', 'stop']);
    tape.play();
      tape.pause();
      tape.rewind(0);
    });
  it("creates spies for each requested function", () => {
    expect(tape.play).toBeDefined();
    expect(tape.pause).toBeDefined();
    expect(tape.stop).toBeDefined();
  });
});
Verificar una propiedad de un objeto
describe("jasmine.objectContaining", () => {
  let foo;
  beforeEach(() => {
    foo = {
      a: 1,
      b: 2,
      bar: "baz"
    };
  });
  it("matches objects with the expect key/value pairs", () => {
    expect(foo).toEqual(jasmine.objectContaining({
      bar: "baz"
    }));
    expect(foo).not.toEqual(jasmine.objectContaining({
      c: 37
    }));
  });
});

Carlos Enrique Ramírez Flores

Excelente David, yo opino lo mismo, es muy fácil de perderte en el!

Rodrigo Roldan

Hace 4 años

Gracias por tu aporte David, me pareció que estaban mal ubicados los elementos y no quedaba claro a qué pertenecía cada código.

Víctor Alejandro Sagal Muñoz

Un buen recurso como ayuda, pero se hace denso de entender que solo sea en texto y no con un video de apoyo.

Yo opino lo mismo!

Alejandro Mejia Escobar

Hace 5 años

¿A qué se refiere con "espia"?

Andrés Lauga

Revisen este curso. Está lleno de errores y desorganizado.

Wilson Alejandro Gonzalez Gaitan

Gracias, otros que implemente yo

const saludar = require("../app");

var x = true;

const letra = "AB";

var tmp = undefined;

describe("Prueba de test para string", () => { it("La función saluda", () => { expect(saludar("Platzi")).toBe("Hola Platzi"); });

it("Comprobar valores booleanos", () => { expect(x).toBeTruthy(); });

it("Comprobar valores iguales", () => { expect(x).toEqual(true); });

it("Comprobar valores iguales", () => { expect(x).toBe(true); });

it("Comprobar valores de expresiones regulares", () => { expect(x).toMatch("[^AB]"); });

it("Comprobar valores undefined", () => { expect(tmp).toBeUndefined(); }); });

William Schnaider Torres Bermon

Los invito a consultar la documentación de Jasmine para chequear los matchers disponibles por versiones. Les dejo el enlace: Namespace: matchers.

Pruebas Unitarias con Jasmine: Matchers, Espías y Ciclos de Vida

Progreso del curso

Bienvenida e Introducción

Creando un framework de pruebas básico

Análisis estático de código

Trabajando con Jasmine en el frontend

Probando Nodejs apps con Jasmine

Probando Angular apps con Jasmine

Pruebas de integración de Angular apps con Jasmine