使用 Jasmine 在没有 object 的情况下监视 function

Question

我正在使用 Jasmine 并且有一个库 js 文件，其中包含许多与任何 object（即全局）无关的函数。 我 go 如何监视这些功能？

我尝试使用窗口/文档作为 object，但即使调用了 function，间谍也没有工作。 我还尝试将其包装在一个假的 object 中，如下所示：

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

并测试

expect(fakeElement.fakeMethod).toHaveBeenCalled();

这也不起作用，因为间谍不起作用。

Answer 1

如果您正在定义您的功能：

function test() {};

那么，这相当于：

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

所以spyOn(window, 'test')应该可以工作。

如果不是这样，您还应该能够：

test = jasmine.createSpy();

如果这些都不起作用，那么您的设置就会发生其他事情。

由于幕后发生的事情，我认为您的fakeElement技术fakeElement 。 原来的 globalMethod 仍然指向相同的代码。 间谍所做的是代理它，但仅在对象的上下文中。 如果你可以让你的测试代码通过 fakeElement 调用它就会工作，但是你就可以放弃全局 fns。

Answer 2

打字稿用户：

我知道 OP 询问了 javascript，但是对于遇到此问题的任何想要监视导入函数的 TypeScript 用户，您可以执行以下操作。

在测试文件中，从这个转换函数的导入：

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

x = foo(y);

对此：

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

x = FooFunctions.foo(y);

然后你可以监视FooFunctions.foo :)

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

Answer 3

我使用了 2 个替代方案（用于茉莉花 2）

这个不是很明确，因为看起来这个函数实际上是一个假的。

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

第二个更冗长，更明确，“更干净”：

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

-> jasmine 源码看第二个参数

Answer 4

一个非常简单的方法：

import * as myFunctionContainer from 'whatever-lib';

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

Answer 5

解决方案 TypeScript

替换您的import ：

import { yourGlobalFunction } from '../your-global-functions';

和：

import * as Functions from '../your-global-functions';

然后：

spyOnProperty(Functions, 'yourGlobalFunction').and.returnValue(() => 'mock return value');

Answer 6

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

这对我有用。

Answer 7

我们通常遵循的方法如下：

utils.ts // file for all global utilities

function globalUtil() {
  // some code
}

abc.component.ts 

function foo {
  // some code
  globalUtil();  // calls global function from util.ts
}

While writing a Jasmine test for function foo () , you can spy on the globalUtil function as follows : 

abc.component.spec.ts

import * as SharedUtilities from 'util.ts';

it('foo', () =>
{
  const globalUtilSpy = jasmine.createSpy('globalUtilSpy');
  spyOnProperty(SharedUtilities, "globalUtilSpy").and.returnValue(globalUtilSpy);
  
  foo();
  expect(globalUtilSpy).toHaveBeenCalled();
});

Answer 8

我的答案与 @FlavorScape 略有不同，因为我在导入的模块中有一个（默认导出）函数，我做了以下事情：

import * as functionToTest from 'whatever-lib';

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

Answer 9

我想这是最简单的方法：

const funcSpy = spyOn(myFunc, 'call');