metodo Jasmine Spies.and.stub

Question

Ho letto la documentazione di Jasmine e ho faticato a capire cosa fa effettivamente il metodo Spies .and.stub. L'inglese non è la mia lingua madre, quindi non so nemmeno cosa significhi la parola "stub", e non c'è alcuna traduzione nella lingua.

Nella documentazione si dice:

Quando una strategia di chiamata viene utilizzato per una spia, il comportamento stubbing originale possono essere restituiti in qualsiasi momento con and.stub.

describe("A spy", function() { 

var foo, bar = null; 

    beforeEach(function() { 
    foo = { 
     setBar: function(value) { 
     bar = value; 
     } 
    }; 

    spyOn(foo, 'setBar').and.callThrough(); 
    }); 

    it("can call through and then stub in the same spec", function() { 
    foo.setBar(123); 
    expect(bar).toEqual(123); 

    foo.setBar.and.stub(); 
    bar = null; 

    foo.setBar(123); 
    expect(bar).toBe(null); 
    }); 
}); 

Cosa and.stub realmente fare e come è utile?

Answer 1

Per il termine, si può guardare su Wikipedia: http://en.wikipedia.org/wiki/Test_stub

In poche parole si tratta di un oggetto "falso" che è possibile controllare che sostituisce un oggetto "reale" nel codice.

Per la funzione, quello che ho capito è che and.stub() rimuove l'effetto di and.callThrough() su una spia.

Quando si chiama and.callThrough, la spia funge da proxy, chiamando la funzione reale, ma passando attraverso un oggetto spia che consente di aggiungere test come l'aspettativa.

Quando si chiama and.stub, o se non si chiama mai and.callThrough, la spia non chiamerà la funzione reale. È davvero utile quando non vuoi testare il comportamento di un oggetto, ma assicurati che sia stato chiamato. Aiutandoti a mantenere il tuo test veramente unitario.

Answer 2

Per completare la risposta precedente:

In effetti, non è chiaro dal documento, ma è molto chiaro nel codice sorgente:

https://github.com/jasmine/jasmine/blob/4be20794827a63ca5295848c58ffc478624ee4dc/src/core/SpyStrategy.js

plan = function() {}; 

-> la funzione chiamata è vuoto

this.callThrough = function() { 
    plan = originalFn; 

-> la funzione chiamata è l'originale f unzione

this.stub = function(fn) { 
    plan = function() {}; 

-> la funzione chiamata è vuota (di nuovo)