web-dev-qa-db-fra.com

Utiliser Jasmine pour espionner une fonction sans objet

Je suis nouvelle chez Jasmine et je viens de commencer à l'utiliser. J'ai un fichier de bibliothèque js avec beaucoup de fonctions qui ne sont associées à aucun objet (c'est-à-dire globales). Comment puis-je espionner ces fonctions?

J'ai essayé d'utiliser window/document comme objet, mais l'espion n'a pas fonctionné même si la fonction a été appelée. J'ai aussi essayé de l'envelopper dans un faux objet comme suit:

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

et tester avec

expect(fakeElement.fakeMethod).toHaveBeenCalled();

Cela ne fonctionne pas non plus, car l'espion n'a pas fonctionné

javascriptunit-testingjasmine
124
Chetter Hummin

Si vous définissez votre fonction:

function test() {};

Ensuite, cela équivaut à:

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

Donc, spyOn(window, 'test') devrait fonctionner.

Si ce n'est pas le cas, vous devriez également pouvoir:

test = jasmine.createSpy();

Si aucun de ceux-ci ne fonctionne, quelque chose d'autre se passe avec votre configuration.

Je ne pense pas que votre technique fakeElement fonctionne à cause de ce qui se passe dans les coulisses. Le globalMethod d'origine pointe toujours sur le même code. Ce que l'espionnage fait, c'est le proxy, mais seulement dans le contexte d'un objet. Si vous pouviez demander à votre code de test d'appeler via fakeElement, cela fonctionnerait, mais vous seriez alors en mesure d'abandonner les fns globaux.

139
ndp

Utilisateurs de TypeScript:

Je sais que le PO a posé des questions sur le javascript, mais pour tous les utilisateurs de TypeScript qui rencontrent ce problème et qui souhaitent espionner une fonction importée, voici ce que vous pouvez faire.

Dans le fichier de test, convertissez l'importation de la fonction à partir de ceci:

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

x = foo(y);

Pour ça:

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

x = FooFunctions.foo(y);

Ensuite, vous pouvez espionner FooFunctions.foo :)

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

Il y a 2 alternatives que j'utilise (pour jasmine 2)

Celui-ci n'est pas tout à fait explicite car il semble que la fonction est en réalité un faux.

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

La seconde plus verbeuse, plus explicite et "plus propre":

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

-> code source jasmine pour voir le deuxième argument 

39
IxDay

Un moyen très simple:

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();
            })

Cela a fonctionné pour moi.

0
Sushil