Javascript 模拟导入以测试函数逻辑

假设我有以下文件

此文件从库导入

promiseFunction

，我想测试

doSomething（）

函数

特别是，在承诺解决或失败时声明状态

// file: MyComponent.js

import promiseFunction from 'somewhere';

class MyClass extends Component {

  doSomething = () => {

    promiseFunction()
      .then((data) => {

        this.setState({...this.state, name: data.name});

      }.catch(() => {

        this.setState({...this.state, error: 'error'});

      });

  }
}

如何模拟正在导入的

promise函数

。或者只是任何正在导入的函数

// file: MyClass.spec.js
it('sets error in state when doSomething() is rejected', () => {
  const wrapper = shallow(<MyClass />);

  // How do I mock promiseFunction here?
  wrapper.instance().doSomething();

  expect(wrapper.state().error).toEqual('error');
});

//文件：MyClass.spec.js
它（'在拒绝doSomething（）时设置错误状态'，（）=>{
常量包装器=浅（）；
//我如何在这里模拟承诺？
wrapper.instance（）.doSomething（）；
expect（wrapper.state（）.error）.toEqual（'error'）；
});

您可以与

以下是一个工作示例：

// ---- somewhere.js ----
const promiseFunction = () => {
  return Promise.resolve({name: 'name from promiseFunction'});
}
export default promiseFunction;



// ---- myclass.js ----
import * as React from 'react';
import promiseFunction from './somewhere';

export class MyClass extends React.Component {
  doSomething = () => {
    // return the Promise so the test can wait for it
    return promiseFunction()
      .then((data) => {
        this.setState({...this.state, name: data.name});
      }).catch(() => {
        this.setState({...this.state, error: 'error'});
      });
  }
  render() {
    return <div>This is MyClass</div>;
  }
}



// ---- myclass.test.js ----
import { shallow } from 'enzyme';
import * as React from 'react';
import { MyClass } from './myclass';
import * as somewhere from './somewhere';

describe('MyClass', () => {
  it('sets error in state when promiseFunction rejects', async () => {
    // set up mock for promiseFunction
    const mock = jest.spyOn(somewhere, 'default');
    mock.mockImplementation(() => Promise.reject());

    const wrapper = shallow(<MyClass />);

    await wrapper.instance().doSomething();

    expect(wrapper.state().error).toEqual('error');

    // restore promiseFunction
    mock.mockRestore();
  });
});

/----somewhere.js----
常量承诺函数=（）=>{
返回Promise.resolve（{name:'name from promiseFunction'}）；
}
导出违约承诺函数；
//----myclass.js----
从“React”导入*作为React；
从“./某处”导入promiseFunction；
导出类MyClass扩展React.Component{
doSomething=（）=>{
//返回承诺，以便测试可以等待它
返回承诺函数（）
。然后（（数据）=>{
this.setState（{…this.state，名称：data.name}）；
}).catch（（）=>{
this.setState（{…this.state，错误：'error'}）；
});
}
render（）{
返回这是MyClass；
}
}
//----myclass.test.js----
从“酶”导入{shall}；
从“React”导入*作为React；
从“/MyClass”导入{MyClass}；
从“./某处”导入*为某处；
描述（'MyClass'，（）=>{
它（'在promiseFunction拒绝时设置错误状态'，异步（）=>{
//为承诺功能设置模拟
const mock=jest.spyOn（某处为“默认”）；
mock.mockImplementation（（）=>Promise.reject（））；
常量包装器=浅（）；
等待包装器.instance（）.doSomething（）；
expect（wrapper.state（）.error）.toEqual（'error'）；
//恢复承诺功能
mock.mockRestore（）；
});
});