如何使用Jest模拟同一模块中的函数

更新：我在https://github.com/magicmark/jest-how-do-i-mock-x/blob/master/src/function-in-same-module/README中收集了此方法和其他方法。 md

正确模拟以下示例的最佳方法是什么？

问题在于，导入时间过后，foo将原始引用保持不变bar。

module.js：

export function bar () {
    return 'bar';
}

export function foo () {
    return `I am foo. bar is ${bar()}`;
}

module.test.js：

import * as module from '../src/module';

describe('module', () => {
    let barSpy;

    beforeEach(() => {
        barSpy = jest.spyOn(
            module,
            'bar'
        ).mockImplementation(jest.fn());
    });


    afterEach(() => {
        barSpy.mockRestore();
    });

    it('foo', () => {
        console.log(jest.isMockFunction(module.bar)); // outputs true

        module.bar.mockReturnValue('fake bar');

        console.log(module.bar()); // outputs 'fake bar';

        expect(module.foo()).toEqual('I am foo. bar is fake bar');
        /**
         * does not work! we get the following:
         *
         *  Expected value to equal:
         *    "I am foo. bar is fake bar"
         *  Received:
         *    "I am foo. bar is bar"
         */
    });
});

谢谢！

编辑：我可以更改：

export function foo () {
    return `I am foo. bar is ${bar()}`;
}

至

export function foo () {
    return `I am foo. bar is ${exports.bar()}`;
}

但这是p。我认为到处都是丑陋的：/

更新：我在https://github.com/magicmark/jest-how-do-i-mock-x/blob/master/src/function-in-same-module/README中收集了此方法和其他方法。 md

问题似乎与您期望解决条的范围有关。

一方面，在module.js您导出两个函数（而不是持有这两个函数的对象）。由于模块的导出方式，对导出内容容器的引用exports就像您提到的那样。

另一方面，您可以module像处理具有这些功能的对象一样处理导出（别名），并尝试替换其功能之一（功能栏）。

如果仔细看一下foo的实现，实际上是持有对bar函数的固定引用。

当您认为自己将bar函数替换为新函数时，实际上只是在module.test.js范围内替换了参考副本。

要使foo实际上使用其他版本的bar，您有两种可能：

1. 在module.js中，导出同时包含foo和bar方法的类或实例：

   Module.js：

   export class MyModule {
     function bar () {
       return 'bar';
     }
   
     function foo () {
       return `I am foo. bar is ${this.bar()}`;
     }
   }
   

   注意在foo方法中此关键字的使用。

   Module.test.js：

   import { MyModule } from '../src/module'
   
   describe('MyModule', () => {
     //System under test :
     const sut:MyModule = new MyModule();
   
     let barSpy;
   
     beforeEach(() => {
         barSpy = jest.spyOn(
             sut,
             'bar'
         ).mockImplementation(jest.fn());
     });
   
   
     afterEach(() => {
         barSpy.mockRestore();
     });
   
     it('foo', () => {
         sut.bar.mockReturnValue('fake bar');
         expect(sut.foo()).toEqual('I am foo. bar is fake bar');
     });
   });
   

2. 就像您说的那样，在全局exports容器中重写全局引用。不建议这样做，因为如果您没有正确地将导出重置为初始状态，则可能会在其他测试中引入奇怪的行为。

一种替代解决方案是将模块导入其自己的代码文件，并使用所有导出实体的导入实例。像这样：

import * as thisModule from './module';

export function bar () {
    return 'bar';
}

export function foo () {
    return `I am foo. bar is ${thisModule.bar()}`;
}

现在模拟bar真的很容易，因为foo还使用的导出实例bar：

import * as module from '../src/module';

describe('module', () => {
    it('foo', () => {
        spyOn(module, 'bar').and.returnValue('fake bar');
        expect(module.foo()).toEqual('I am foo. bar is fake bar');
    });
});

将模块导入其自己的代码看起来很奇怪，但是由于ES6对循环导入的支持，它的运行非常顺利。

首先，我确定的解决方案是通过设置默认参数来使用依赖项注入。

所以我会改变

export function bar () {
    return 'bar';
}

export function foo () {
    return `I am foo. bar is ${bar()}`;
}

至

export function bar () {
    return 'bar';
}

export function foo (_bar = bar) {
    return `I am foo. bar is ${_bar()}`;
}

这并不是对组件API的重大更改，通过执行以下操作，我可以轻松地覆盖测试中的bar

import { foo, bar } from '../src/module';

describe('module', () => {
    it('foo', () => {
        const dummyBar = jest.fn().mockReturnValue('fake bar');
        expect(foo(dummyBar)).toEqual('I am foo. bar is fake bar');
    });
});

这样的好处是也会导致更好的测试代码:)

我遇到了同样的问题，并且由于项目的掉毛标准，exports即使没有掉毛定义，也无法通过代码审查批准的选项定义类或重写引用。我偶然发现可行的选择是使用babel-rewire-plugin，它至少在外观上更加干净。当我发现它在我可以访问的另一个项目中使用时，我注意到它已经在我链接到的类似问题的答案中。这是针对链接的问题提供的针对此问题（且未使用间谍）的摘要，以供参考（由于我不是异教徒，因此我还添加了分号，除了删除了间谍之外）：

import __RewireAPI__, * as module from '../module';

describe('foo', () => {
  it('calls bar', () => {
    const barMock = jest.fn();
    __RewireAPI__.__Rewire__('bar', barMock);
    
    module.foo();

    expect(bar).toHaveBeenCalledTimes(1);
  });
});

https://stackoverflow.com/a/45645229/6867420

为我工作：

cat moduleWithFunc.ts

export function funcA() {
 return export.funcB();
}
export function funcB() {
 return false;
}

cat moduleWithFunc.test.ts

import * as module from './moduleWithFunc';

describe('testFunc', () => {
  beforeEach(() => {
    jest.clearAllMocks();
  });

  afterEach(() => {
    module.funcB.mockRestore();
  });

  it.only('testCase', () => {
    // arrange
    jest.spyOn(module, 'funcB').mockImplementationOnce(jest.fn().mockReturnValue(true));

    // act
    const result = module.funcA();

    // assert
    expect(result).toEqual(true);
    expect(module.funcB).toHaveBeenCalledTimes(1);
  });
});

如果定义导出，则可以将函数作为导出对象的一部分进行引用。然后，您可以分别覆盖模拟中的函数。这是由于导入是如何作为参考而不是副本的。

module.js：

exports.bar () => {
    return 'bar';
}

exports.foo () => {
    return `I am foo. bar is ${exports.bar()}`;
}

module.test.js：

describe('MyModule', () => {

  it('foo', () => {
    let module = require('./module')
    module.bar = jest.fn(()=>{return 'fake bar'})

    expect(module.foo()).toEqual('I am foo. bar is fake bar');
  });

})