Usando o Jasmine para espionar uma função sem um objeto

Eu sou novo no Jasmine e comecei a usá-lo. Eu tenho um arquivo js de biblioteca com muitas funções que não estão associadas a nenhum objeto (ou seja, são globais). Como faço para espionar essas funções?

Tentei usar a janela / documento como objeto, mas o espião não funcionou, mesmo que a função tenha sido chamada. Eu também tentei envolvê-lo em um objeto falso da seguinte maneira:

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

e teste com

expect(fakeElement.fakeMethod).toHaveBeenCalled();

Isso também não funciona, pois o espião não funcionou

Se você estiver definindo sua função:

function test() {};

Então, isso é equivalente a:

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

Então spyOn(window, 'test')deve funcionar.

Caso contrário, você também deve ser capaz de:

test = jasmine.createSpy();

Se nenhum deles estiver funcionando, algo mais está acontecendo com sua configuração.

Não acho que sua fakeElementtécnica funcione por causa do que está acontecendo nos bastidores. O globalMethod original ainda aponta para o mesmo código. O que a espionagem faz é procurá-la, mas apenas no contexto de um objeto. Se você conseguir que seu código de teste chame o fakeElement, ele funcionaria, mas poderá renunciar ao fns global.

Usuários do TypeScript:

Eu sei que o OP perguntou sobre javascript, mas para qualquer usuário TypeScript que se depare com isso que queira espionar uma função importada, eis o que você pode fazer.

No arquivo de teste, converta a importação da função a partir disso:

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

x = foo(y);

Para isso:

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

x = FooFunctions.foo(y);

Então você pode espionar FooFunctions.foo:)

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

Há 2 alternativas que eu uso (para jasmim 2)

Este não é bem explícito, porque parece que a função é realmente falsa.

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

O segundo mais detalhado, mais explícito e "mais limpo":

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

-> código fonte de jasmim para ver o segundo argumento

Uma maneira muito simples:

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

Isso funcionou para mim.

Minha resposta difere um pouco do @FlavorScape, pois eu tinha uma única função (exportação padrão) no módulo importado, fiz o seguinte:

import * as functionToTest from 'whatever-lib';

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