如何在玩笑中模拟 const 方法？

Question

I unit test code in typescript, use jest. Please teach me how to mock getData to return the expected value. My code as below:

// File util.ts
export const getData = async () => {
    // Todo something
    return data;
}

// File execution.ts import { getData } from './util';
function execute()
{
    // todo something
    const data = await getData();
    // todo something 
}

Answer 1

The problem is that your function returns a promise. Depends on how you use it there are several ways to mock it.

The simplest way would be to mock it directly, but then it will always return the same value:

// note, the path is relative to your test file
jest.mock('./util', () => ({ getData: () => 'someValue' }));

If you want to test both the resolved and the rejected case you need to mock getData so it will return a spy where you later on can change the implementation use mockImplementation . You also need to use async/await to make the test work, have a look at the docs about asynchronous testing:

import { getData } from './util';
jest.mock('./util', () => ({ getData: ()=> jest.fn() }));

it('success case', async () => {
  const result = Promise.resolve('someValue');
  getData.mockImplementation(() => result);

  // call your function to test
  await result; // you need to use await to make jest aware of the promise
});

it('error case', async () => {
  const result = Promise.reject(new Error('someError'));
  getData.mockImplementation(() => result);

  // call your function to test
  await expect(result).rejects.toThrow('someError');
});

Answer 2

Try the following in your test file. Import the function from the module.

 import { getData } from './util';

Then mock the module with the function and its return value after all the import statements

jest.mock('./util', () => ({ getData: jest.fn() }))
getData.mockReturnValue("abc");

Then use it in your tests.

Answer 3

Because mocking expression functions can be a real pain to get right, I'm posting a full example below.

Scenario

Let's say we want to test some code that performs some REST call, but we don't want the actual REST call to be made:

// doWithApi.ts

export const doSomethingWithRest = () => {
    post("some-url", 123);
}

Where the post is a function expression in a separate file:

// apiHelpers.ts

export const post = (url: string, num: number) => {
    throw Error("I'm a REST call that should not run during unit tests!");
}

Setup

Since the post function is used directly (and not passed in as a parameter), we must create a mock file that Jest can use during tests as a replacement for the real post function:

// __mocks__/apiHelpers.ts

export const post = jest.fn();

Spy and Test

Now, finally inside the actual test, we may do the following:

// mockAndSpyInternals.test.ts

import {doSomethingWithRest} from "./doWithApi";

afterEach(jest.clearAllMocks);   // Resets the spy between tests
jest.mock("./apiHelpers");       // Replaces runtime functions inside 'apiHelpers' with those found inside __mocks__. Path is relative to current file. Note that we reference the file we want to replace, not the mock we replace it with.

test("When doSomethingWithRest is called, a REST call is performed.", () => {

    // If we want to spy on the post method to perform assertions we must add the following lines. 
    // If no spy is wanted, these lines can be omitted. 
    const apiHelpers = require("./apiHelpers");
    const postSpy = jest.spyOn(apiHelpers, "post");

    // Alter the spy if desired (e.g by mocking a resolved promise)
    // postSpy.mockImplementation(() => Promise.resolve({..some object}))

    doSomethingWithRest();

    expect(postSpy).toBeCalledTimes(1)
    expect(postSpy).toHaveBeenCalledWith("some-url", 123);
});

Examples are made using Jest 24.9.0 and Typescript 3.7.4