it-swarm-eu.dev

Usando Jasmine per spiare una funzione senza un oggetto

Sono nuovo di Jasmine e ho appena iniziato a usarlo. Ho un file js della libreria con molte funzioni che non sono associate ad alcun oggetto (cioè sono globali). Come faccio a spiare queste funzioni?

Ho provato ad usare window/document come oggetto, ma la spia non ha funzionato anche se la funzione è stata chiamata. Ho anche provato a confezionarlo in un oggetto falso come segue:

var fakeElement = {};
fakeElement.fakeMethod = myFunctionName;
spyOn(fakeElement, "fakeMethod");

e prova con

expect(fakeElement.fakeMethod).toHaveBeenCalled();

Questo non funziona neanche perché la spia non ha funzionato

124
Chetter Hummin

Se stai definendo la tua funzione:

function test() {};

Quindi, questo è equivalente a:

window.test = function() {}  /* (in the browser) */

Quindi spyOn(window, 'test') dovrebbe funzionare.

In caso contrario, dovresti anche essere in grado di:

test = jasmine.createSpy();

Se nessuno di quelli funziona, qualcos'altro sta succedendo con il tuo setup.

Non credo che la tua tecnica fakeElement funzioni a causa di ciò che accade dietro le quinte. Il GlobalMethod originale punta ancora allo stesso codice. Ciò che fa lo spionaggio è proxy, ma solo nel contesto di un oggetto. Se riesci a ottenere il codice di prova per chiamare tramite fakeElement, potrebbe funzionare, ma in questo modo potresti rinunciare ai fns globali.

139
ndp

Utenti TypeScript:

So che l'OP ha chiesto informazioni su javascript, ma per tutti gli utenti di TypeScript che si imbattono in questo che vogliono spiare una funzione importata, ecco cosa puoi fare.

Nel file di test, converti l'importazione della funzione da questo:

import {foo} from '../foo_functions';

x = foo(y);

A questo:

import * as FooFunctions from '../foo_functions';

x = FooFunctions.foo(y);

Quindi puoi spiare FooFunctions.foo :)

spyOn(FooFunctions, 'foo').and.callFake(...);
// ...
expect(FooFunctions.foo).toHaveBeenCalled();
40
Alexander Taylor

C'è 2 alternative che uso (per il gelsomino 2)

Questo non è abbastanza esplicito perché sembra che la funzione sia in realtà un falso.

test = createSpy().and.callFake(test); 

Il secondo più verboso, più esplicito e "più pulito":

test = createSpy('testSpy', test).and.callThrough();

-> codice sorgente del gelsomino per vedere il secondo argomento 

39
IxDay

Un modo molto semplice:

import * as myFunctionContainer from 'whatever-lib';

const fooSpy = spyOn(myFunctionContainer, 'myFunc');
7
FlavorScape
import * as saveAsFunctions from 'file-saver';
..........
....... 
let saveAs;
            beforeEach(() => {
                saveAs = jasmine.createSpy('saveAs');
            })
            it('should generate the Excel on sample request details page', () => {
                spyOn(saveAsFunctions, 'saveAs').and.callFake(saveAs);
                expect(saveAsFunctions.saveAs).toHaveBeenCalled();
            })

Questo ha funzionato per me.

0
Sushil