javascript - recorrer - Espiando a un constructor usando Jasmine

metodos en javascript

Question

Estoy usando Jasmine para probar si se crean ciertos objetos y se invocan métodos sobre ellos.

Tengo un widget jQuery que crea objetos flipcounter y llama al método setValue en ellos. 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 los flipcounters se crean y se les llama al método setValue. Mi problema es que ¿cómo espío estos objetos incluso antes de que se creen? ¿Espío al constructor y devuelvo objetos falsos? El código de muestra realmente ayudaría. ¡Gracias por tu ayuda! :)

Actualizar:

Intenté espiar el flipCounter así:

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

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

Luego probando 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 a setValue, todo lo que obtengo es un error de ''setValue (el método no existe''). ¿Estoy haciendo esto de la manera correcta? ¡Gracias!

Answer 1

Lo siguiente no depende de ''ventana''. Digamos que este es el código que quiere probar:

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

Su 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 2

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 3

No sé cómo hacer esto usando el jazmín se burla, pero si quieres poderosos imitaciones / espías, recomiendo sinon.js , que funciona muy bien con el jazmín.

De documentos:

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

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

Con sinon.js puedes crear un simulacro del constructor flipCounter que devuelve otro espía.

Luego afirme que se llamó al constructor utilizando constructorMock.calledWithNew () y afirma que se llamó al espía devuelto con returnedSpy.calledWith (arg1, arg2 ...).

Answer 4

Sugeriría usar jasmine.createSpyObj() cuando quieras simular objetos con propiedades que necesitan ser espiadas.

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

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

Answer 5

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

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

Su 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 6

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 en él o decir:

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

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

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