Bienvenida e Introducci贸n

1

驴Qu茅 son las pruebas unitarias?

2

驴Por qu茅 hacer pruebas unitarias?

Creando un framework de pruebas b谩sico

3

Mi primera prueba unitaria en JavaScript

4

Las funciones expect() y it()

5

Organizando el c贸digo para correr en la web

6

Organizando el c贸digo para correr utilizando nodejs

An谩lisis est谩tico de c贸digo

7

Herramientas de an谩lisis est谩tico de c贸digo

8

ESLint: Agregando alertas a nuestro c贸digo con ECMA Script

9

Herramientas de correcci贸n de estilo

10

Herramientas de tipado

Trabajando con Jasmine en el frontend

11

Profundizaci贸n en SpyOn: Comandos m谩s utilizados y c贸mo ponerlos a prueba

12

Configurar un ambiente de trabajo para trabajar con el framework jasmine

13

Configurar Jasmine utilizando Node.js

14

Primer set de pruebas con Jasmine

15

Diccionario Jasmine

Probando Nodejs apps con Jasmine

16

Introducci贸n al m贸dulo de testing del lado del servidor

17

Configurando el proyecto Jasmine utilizando npm

18

Agregando Plugins a Jasmine

19

Configurando nuestro reporter

20

Pruebas en el servidor: Verificando un status 200 en GET

21

Pruebas en el servidor: Probando el m茅todo GET y Reto con FindByID

22

Pruebas en el servidor: Probando el m茅todo POST (request to server)

23

Pruebas en el servidor: Probando el m茅todo POST (request to PDF)

Probando Angular apps con Jasmine

24

Tipos de pruebas

25

Pruebas en el frontend: Probando el componente principal (App)

26

Configurando los ciclos de vida

27

Creando las pruebas del formulario: Configuraci贸n

28

Creando las pruebas necesarias para un formulario. (Primeras pruebas)

29

Probando el caso de exito al guardar un elemento en el servidor.

30

Trabajando con event emitters

31

Testeando ngZone y navegaci贸n.

32

Configurando el TestBed de el componente PINs

33

Creando un espia sobre el objecto window

Pruebas de integraci贸n de Angular apps con Jasmine

34

Ejecutando funciones a trav茅s de eventos en el template

35

Probando la navegaci贸n

36

Probando servicios con HTTP

37

Completando las pruebas del servicio HTTP

38

Cierre del curso

Aprende todo un fin de semana sin pagar una suscripci贸n 馃敟

Aprende todo un fin de semana sin pagar una suscripci贸n 馃敟

Reg铆strate

Comienza en:

3D
20H
50M
48S
Curso de Unit Testing para MEAN con Jasmine

Curso de Unit Testing para MEAN con Jasmine

Cristian Daniel Marquez Barrios

Cristian Daniel Marquez Barrios

Diccionario Jasmine

15/38

Lectura

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

...

Reg铆strate o inicia sesi贸n para leer el resto del contenido.

Aportes 6

Preguntas 1

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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:

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: 鈥榮d鈥, 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$/));
    });
  });
});

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);
    });
  });
});
<h3>Comparaci贸n</h3> <h4>Datos primitivos</h4>

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 == 鈥榮d鈥, 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);
<h4>Objetos</h4>

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

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

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

Gracias, otros que implemente yo

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

var x = true;

const letra = 鈥淎B鈥;

var tmp = undefined;

describe(鈥淧rueba de test para string鈥, () => {
it(鈥淟a funci贸n saluda鈥, () => {
expect(saludar(鈥淧latzi鈥)).toBe(鈥淗ola Platzi鈥);
});

it(鈥淐omprobar valores booleanos鈥, () => {
expect(x).toBeTruthy();
});

it(鈥淐omprobar valores iguales鈥, () => {
expect(x).toEqual(true);
});

it(鈥淐omprobar valores iguales鈥, () => {
expect(x).toBe(true);
});

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

it(鈥淐omprobar valores undefined鈥, () => {
expect(tmp).toBeUndefined();
});
});

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