Spiare un costruttore usando Jasmine

Question

Sto usando Jasmine per verificare se alcuni oggetti sono stati creati e se i metodi sono stati chiamati su di essi.

Ho un widget jQuery che crea oggetti di flipcounter e chiama il metodo setValue su di essi. Il codice per flipcounter è qui: https://bitbucket.org/cnanney/apple-style-flip-counter/src/13fd00129a41/js/flipcounter.js

I flipcounters vengono creati utilizzando:

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

voglio provare che le flipcounters vengono creati e il metodo setValue è chiamato su di loro. Il mio problema è che come faccio a spiare questi oggetti ancor prima che vengano creati? Spio il costruttore e restituisco oggetti falsi? Il codice di esempio sarebbe davvero d'aiuto. Grazie per l'aiuto! :)

Aggiornamento:

Ho provato spiare la flipCounter come questo:

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

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

Poi il test per la chiamata setValue da flipCounter:

spyOn(myStub, 'setValue'); 

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

la prima test per l'inizializzazione di flipCounter va bene, ma per testare la chiamata setValue, tutto quello che sto ottenendo è un errore 'setValue() non esiste'. Sto facendo questo nel modo giusto? Grazie!

Answer 1

flipCounter è solo un'altra funzione, anche se capita anche di costruire un oggetto. Da qui si può fare:

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

per ottenere una spia su di esso, e fare ogni sorta di ispezioni su di esso o dire:

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

Tuttavia, questo sembra eccessivo.Sarebbe sufficiente:

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

Answer 2

Non so come farlo usando i jasmine mock, ma se volete potenti mocking/spy/stub raccomando sinon.js, che funziona molto bene con il gelsomino.

Da docs:

Una spia di prova è una funzione che registra argomenti, valore di ritorno, il valore di questo e di eccezione generata (se presente) per tutti i suoi appelli. Una spia può essere una funzione anonima o può avvolgere una funzione esistente.

I mock (e le aspettative finte) sono metodi falsi (come le spie) con il comportamento pre-programmato (come gli stub) nonché le aspettative pre-programmate . Un mock fallirà il test se non viene utilizzato come previsto.

Con sinon.js è possibile creare una finta del costruttore flipCounter che restituisce un'altra spia.

Quindi asserire che il costruttore è stato chiamato utilizzando constructorMock.calledWithNew() e asserire che la spia restituita è stata chiamata con returnSpy.calledWith (arg1, arg2 ...).

Answer 3

Quanto segue non si basa su "finestra". Consente di dire che questo è il codice che si desidera testare -

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

Il test potrebbe essere -

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

Bisogna implementare un costruttore falso per flipCounter che imposta la proprietà setValue a una funzione spia. Diciamo che la funzione che si desidera verificare è questo:

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

tuo spec dovrebbe essere simile a questo:

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

Io suggerirei di usare jasmine.createSpyObj() quando si vuole prendere in giro oggetti con proprietà che hanno bisogno di essere spiati sopra.

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

Questo mette alla prova le interazioni con l'interfaccia di flipCounter previsto, senza dipendere dal flipCounter attuazione.

Answer 6

La mia versione di testare un costruttore è quello di spiare sul prototipo:

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