Utiliser Jasmine pour espionner une fonction sans objet

Je suis nouveau sur 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 espionner ces fonctions?

J'ai essayé d'utiliser window / document comme objet, mais l'espion ne fonctionnait pas même si la fonction était appelée. J'ai également 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é

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, il se passe autre chose avec votre configuration.

Je ne pense pas que votre fakeElementtechnique fonctionne à cause de ce qui se passe dans les coulisses. Le globalMethod d'origine pointe toujours vers le même code. Ce que fait l'espionnage, c'est le proxy, mais uniquement dans le contexte d'un objet. Si vous pouvez faire appeler votre code de test via le fakeElement, cela fonctionnerait, mais vous pourrez alors abandonner les fns globales.

Utilisateurs de TypeScript:

Je sais que l'OP a posé des questions sur 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();

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

Celui-ci n'est pas tout à fait explicite car il semble que la fonction soit en fait 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

Une manière très simple:

import * as myFunctionContainer from 'whatever-lib';

const fooSpy = spyOn(myFunctionContainer, 'myFunc');

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.

Ma réponse diffère légèrement de @FlavorScape en ce que j'avais une seule fonction (exportation par défaut) dans le module importé, j'ai fait ce qui suit:

import * as functionToTest from 'whatever-lib';

const fooSpy = spyOn(functionToTest, 'default');