Utiliser Jasmine pour espionner une fonction sans objet

Question

Je ne connais pas le jasmin et je viens de commencer à l'utiliser. J'ai un fichier de bibliothèque js avec beaucoup de fonctions qui ne sont pas associées à un objet (c'est-à-dire qu'elles sont globales). Comment dois-je procéder pour espionner ces fonctions ?

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

Answer 1

Si vous définissez votre fonction :

function test() {};

Alors, c'est équivalent à :

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

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

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

test = jasmine.createSpy();

Si aucun d'entre eux ne fonctionne, il y a quelque chose d'autre dans votre installation.

Je ne pense pas que votre fakeElement La technique fonctionne grâce à ce qui se passe dans les coulisses. Le globalMethod original pointe toujours vers le même code. Ce que l'espionnage fait, c'est le proxyer, mais seulement dans le contexte d'un objet. Si vous pouvez faire en sorte que votre code de test appelle à travers le fakeElement, cela fonctionnerait, mais vous seriez alors en mesure d'abandonner les fns globaux.

Answer 2

Utilisateurs de TypeScript :

Je sais que l'OP a demandé à propos de javascript, mais pour tous les utilisateurs de TypeScript qui tombent sur ce sujet et qui veulent espionner une fonction importée, voici ce que vous pouvez faire.

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

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

x = foo(y);

A ceci :

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

x = FooFunctions.foo(y);

Alors vous pouvez espionner FooFunctions.foo :)

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

Answer 3

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

Celle-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 est plus verbeuse, plus explicite et plus "propre" :

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

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

Answer 4

Une façon très simple :

import * as myFunctionContainer from 'whatever-lib';

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

Answer 5

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 marché pour moi.