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$/));
});
});
});
