Mit Jasmine eine Funktion ohne Objekt ausspionieren

Ich bin neu bei Jasmine und habe gerade angefangen, es zu benutzen. Ich habe eine Bibliothek js-Datei mit vielen Funktionen, die keinem Objekt zugeordnet sind (dh global sind). Wie spioniere ich diese Funktionen aus?

Ich habe versucht, Fenster / Dokument als Objekt zu verwenden, aber der Spion hat nicht funktioniert, obwohl die Funktion aufgerufen wurde. Ich habe auch versucht, es wie folgt in ein gefälschtes Objekt zu wickeln:

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

und testen mit

expect(fakeElement.fakeMethod).toHaveBeenCalled();

Dies funktioniert auch nicht, da der Spion nicht funktioniert hat

Wenn Sie Ihre Funktion definieren:

function test() {};

Dann ist dies gleichbedeutend mit:

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

Sollte also spyOn(window, 'test')funktionieren.

Wenn dies nicht der Fall ist, sollten Sie auch in der Lage sein:

test = jasmine.createSpy();

Wenn keines davon funktioniert, läuft etwas anderes mit Ihrem Setup.

Ich glaube nicht, dass Ihre fakeElementTechnik funktioniert, weil sich hinter den Kulissen etwas abspielt. Die ursprüngliche globalMethod zeigt immer noch auf denselben Code. Was Spionage tut, ist Proxy, aber nur im Kontext eines Objekts. Wenn Sie Ihren Testcode über das fakeElement aufrufen können, würde es funktionieren, aber dann könnten Sie globale fns aufgeben.

TypeScript-Benutzer:

Ich weiß, dass das OP nach Javascript gefragt hat, aber für alle TypeScript-Benutzer, die darauf stoßen und eine importierte Funktion ausspionieren möchten, können Sie Folgendes tun.

Konvertieren Sie in der Testdatei den Import der Funktion wie folgt:

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

x = foo(y);

Dazu:

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

x = FooFunctions.foo(y);

Dann kannst du ausspionieren FooFunctions.foo:)

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

Es gibt 2 Alternativen, die ich benutze (für Jasmin 2)

Dieser ist nicht ganz explizit, weil es scheint, dass die Funktion tatsächlich eine Fälschung ist.

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

Die zweite ausführlicher, expliziter und "sauberer":

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

-> Jasmin-Quellcode , um das zweite Argument zu sehen

Ein sehr einfacher Weg:

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

Das hat bei mir funktioniert.

Meine Antwort unterscheidet sich geringfügig von @FlavorScape darin, dass ich im importierten Modul eine einzige (Standardexport-) Funktion hatte. Ich habe Folgendes getan:

import * as functionToTest from 'whatever-lib';

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