Espiando a un constructor usando jazmín

Question

Estoy usando Jasmine para probar si se crean ciertos objetos y se les llama métodos.

Tengo un widget jQuery que crea objetos Flipcounter y llama al método SetValue. El código para Flipcounter está aquí: https://bitbucket.org/cnanney/apple-style-flip-counter/src/13fd00129a41/js/flipcounter.js

Los Flipcounters se crean usando:

var myFlipCounter = new flipCounter("counter", {inc: 23, pace: 500});

Quiero probar que se crean los Flipcounters y se les llama el método SetValue. Mi problema es que ¿cómo espía estos objetos incluso antes de que se creen? ¿Espía en el constructor y devuelvo objetos falsos? El código de muestra realmente ayudaría. ¡Gracias por tu ayuda! :)

Actualizar:

He intentado espiar el flipcounter como este:

myStub = jasmine.createSpy('myStub');
spyOn(window, 'flipCounter').andReturn(myStub);

//expectation
expect(window.flipCounter).toHaveBeenCalled();

Luego, prueba la llamada SetValue por Flipcounter:

spyOn(myStub, 'setValue');

//expectation
expect(myStub.setValue).toHaveBeenCalled();

La primera prueba para inicializar Flipcounter está bien, pero para probar la llamada SetValue, todo lo que recibo es un error 'setValue () no existe'. ¿Estoy haciendo esto de la manera correcta? ¡Gracias!

Answer 1

flipCounter es solo otra función, incluso si también construye un objeto. Por lo tanto, puedes hacer:

var cSpy = spyOn(window, 'flipCounter');

Para obtener un espía y hacer todo tipo de inspecciones o decir:

var cSpy = spyOn(window, 'flipCounter').andCallThrough();
var counter = flipCounter('foo', options);
expect(cSpy).wasCalled();

Sin embargo, esto parece excesivo. Sería suficiente para hacer:

var myFlipCounter = new flipCounter("counter", options);
expect(myFlipCounter).toBeDefined();
expect(myFlipCounter.getValue(foo)).toEqual(bar);

Answer 2

Sugeriría usar jasmine.createSpyObj() Cuando desee burlarse de los objetos con propiedades que deben ser espiadas.

myStub = jasmine.createSpyObj('myStub', ['setValue']);
spyOn(window, 'flipCounter').andReturn(myStub);

Esto prueba las interacciones con la esperada flipCounter interfaz, sin depender de la flipCounter implementación.

Answer 3

Lo siguiente no confía en la 'ventana'. Digamos que este es el código que desea probar -

function startCountingFlips(flipCounter) {
    var myFlipCounter = new flipCounter("counter", {inc: 23, pace: 500});
}

Tu prueba podría ser -

var initSpy = jasmine.createSpy('initFlipCounter');
var flipCounter = function(id, options) {
    initSpy(id, options);
}
startCountingFlips(flipCounter);
expect(initSpy).toHaveBeenCalledWith("counter", {inc:23, pace:500});

Answer 4

Tienes que implementar un constructor falso para flipCounter que establece el setValue propiedad a una función de espía. Digamos que la función que desea probar es esta:

function flipIt() {
  var myFlipCounter = new flipCounter("counter", {inc: 23, pace: 500});
  myFlipCounter.setValue(100);
}

Tu especificación debería verse así:

describe('flipIt', function () {
  var setValue;
  beforeEach(function () {
    setValue = jasmine.createSpy('setValue');
    spyOn(window, 'flipCounter').and.callFake(function () {
      this.setValue = setValue;
    });
    flipIt();
  });
  it('should call flipCounter constructor', function () {
    expect(window.flipCounter)
      .toHaveBeenCalledWith("counter", {inc: 23, pace: 500});
  });
  it('should call flipCounter.setValue', function () {
    expect(setValue).toHaveBeenCalledWith(100);
  });
});

Answer 5

Mi versión para probar un constructor es espiar el prototipo:

spyOn(flipCounter.prototype, 'setValue').and.callThrough();
var myFlipCounter = new flipCounter("counter", {inc: 23, pace: 500});
expect(flipCounter.prototype.setValue).toHaveBeenCalledTimes(1);

Answer 6

No sé cómo hacer esto usando simulacros de jazmín, pero si quieres burlar/espiar/stubs potentes, recomiendo sinon.js, que funciona muy bien con Jasmine.

De Docs:

Un Spy de prueba es una función que registra los argumentos, el valor de retorno, el valor de este y la excepción que se lanza (si las hay) para todas sus llamadas. Un espía de prueba puede ser una función anónima o puede envolver una función existente.

Las simulacros (y las expectativas simuladas) son métodos falsos (como espías) con comportamiento preprogramado (como los trozos), así como las expectativas preprogramadas. Un simulacro fallará su prueba si no se usa como se esperaba.

Con Sinon.js podría crear un simulacro del constructor Flipcounter que devuelve otro espía.

Luego afirme que el constructor se llamó usando constructorMock.calledwithNew (), y afirma que el espía devuelto se llamó con returnedspy.calledwith (arg1, arg2 ...).