How can I playfully imitate an exported function to make it return a Promise instead of undefined?

Question

How can I playfully imitate an exported function to make it return a Promise instead of undefined?

In my project, I am using jest along with Typescript. There is a function called "processData" that is exported from a service file...

export async function processData(
  data: MyDataI,
): Promise<
    ...

In another file (run-my-process.ts) which is called via npm cli, the "processData" function is imported like this:

import {processData} from '../services/my.service';
...
         processData(data)
            .then((result) => {

I wanted to mock the "processData" function in jest, so I attempted this:

jest.mock('../services/my.service', () => {
  // The mock returned only mocks the generateServerSeed method.
  const actual = jest.requireActual('../services/my.service');

  return {
      ...actual,
     processData: jest.fn().mockReturnValue(Promise.resolve({
        dataInserted: 1,
      }))
    }
});

...

describe('calls the job', function () {


  it('invokes the function', async () => {
    ...

    jest.spyOn(process, 'exit').mockImplementationOnce(() => {
      throw new Error('process.exit() was called.');
    });

    expect(() => {
      require('./run-my-process');
    }).toThrow('process.exit() was called.');

However, the test fails and throws the error:

ERROR [1624482717612] (71310 on localhost): Cannot read property 'then' of undefined

It seems like the function "processData" is being evaluated as "undefined" when called with an argument. What is the correct way to mock this function to return a Promise and make my Jest test pass?

typescript unit-testing mocking ts-jest

Answer 1

Answer №1

An alternative method that is much simpler involves:

import * as myService from '../services/my.service';

jest.spyOn(myService, 'processData').mockResolvedValue({ dataInserted: 1 });

By utilizing this approach, you can avoid the complicated mocking process typically done with jest.mock()

Answer 2

An alternative method that is much simpler involves:

import * as myService from '../services/my.service';

jest.spyOn(myService, 'processData').mockResolvedValue({ dataInserted: 1 });

By utilizing this approach, you can avoid the complicated mocking process typically done with jest.mock()

Answer 3

Answer №2

Check out this informative article here, which provides guidance on how to adapt data as needed.

processData: jest.fn(() => Promise.resolve({ data: {}}))

Make sure to export the code snippet below:

export default jest.fn(() => Promise.resolve({ data: {} }));

Answer 4

Check out this informative article here, which provides guidance on how to adapt data as needed.

processData: jest.fn(() => Promise.resolve({ data: {}}))

Make sure to export the code snippet below:

export default jest.fn(() => Promise.resolve({ data: {} }));

Answer 5

Answer №3

To utilize jest.fn, you can supply it with a function that returns a promise:

jest.mock('../services/my.service', () => ({
  ...jest.requireActual('../services/my.service'),
  processData: jest.fn(() => Promise.resolve({ dataInserted: 1 }))
}));

If you require the ability to alter the resolved value for each test, you have the option of resolving a variable within the outer scope that can be modified, or mocking the resolved value using .mockResolvedValue or .mockResolvedValueOnce in the test.

Resolve a modifiable variable:

const newData = {
  dataInserted: 1,
};

jest.mock('../services/my.service', () => ({
  ...jest.requireActual('../services/my.service'),
  processData: jest.fn(() => Promise.resolve({ data: newData }))
}));

describe('...', () => {
  beforeEach(() => {
    newData.dataInserted = 100;
  });

  it('...', () => {
  });
});

Mock the resolved value:

import { processData } from '../services/my.service';

jest.mock('../services/my.service', () => ({
  ...jest.requireActual('../services/my.service'),
  processData: jest.fn()
}));

describe('...', () => {
  beforeEach(() => {
    (processData as jest.Mock).mockResolvedValueOnce({ dataInserted: 100 });
  });

  it('...', () => {
  });
});

Answer 6

To utilize jest.fn, you can supply it with a function that returns a promise:

jest.mock('../services/my.service', () => ({
  ...jest.requireActual('../services/my.service'),
  processData: jest.fn(() => Promise.resolve({ dataInserted: 1 }))
}));

If you require the ability to alter the resolved value for each test, you have the option of resolving a variable within the outer scope that can be modified, or mocking the resolved value using .mockResolvedValue or .mockResolvedValueOnce in the test.

Resolve a modifiable variable:

const newData = {
  dataInserted: 1,
};

jest.mock('../services/my.service', () => ({
  ...jest.requireActual('../services/my.service'),
  processData: jest.fn(() => Promise.resolve({ data: newData }))
}));

describe('...', () => {
  beforeEach(() => {
    newData.dataInserted = 100;
  });

  it('...', () => {
  });
});

Mock the resolved value:

import { processData } from '../services/my.service';

jest.mock('../services/my.service', () => ({
  ...jest.requireActual('../services/my.service'),
  processData: jest.fn()
}));

describe('...', () => {
  beforeEach(() => {
    (processData as jest.Mock).mockResolvedValueOnce({ dataInserted: 100 });
  });

  it('...', () => {
  });
});

Answer 7

Answer №4

There are some issues with certain responses, particularly when it comes to the typing of the mocking function in Typescript.

For those working with typescript and ts-jest, consider using this approach with mocked

import { mocked } from "ts-jest/utils";
import { processData } from '../services/my.service';
jest.mock("../services/my.service");
const mockedProcessData = mocked(processData, true); // ensuring correct typing, I personally prefer mocking functions outside tests but you can also use mocked directly within your tests.

// sample test
mockedProcessData.mockResolvedValueOnce({
    dataInserted: 1,
})

Answer 8

There are some issues with certain responses, particularly when it comes to the typing of the mocking function in Typescript.

For those working with typescript and ts-jest, consider using this approach with mocked

import { mocked } from "ts-jest/utils";
import { processData } from '../services/my.service';
jest.mock("../services/my.service");
const mockedProcessData = mocked(processData, true); // ensuring correct typing, I personally prefer mocking functions outside tests but you can also use mocked directly within your tests.

// sample test
mockedProcessData.mockResolvedValueOnce({
    dataInserted: 1,
})

Answer 9

Answer №5

I tend to steer clear of using jest.mock function due to issues with typings and implicitness. I have also encountered unexpected behavior at times, as jest.mock can feel like a magical solution that should only be used in rare cases where direct access to the source code is not possible.

To keep your code clean and explicit, consider implementing the dependency inversion pattern:

Service code:

export const runProcess = (mapper: (data: Data) => Promise<string>) => {
  // implementation
}

Unit test code:

it('should work', () => {
  const mapper = jest.fn(() => Promise.resolve('testing'));


  expect(runProcess(mapper)).toEqual(...);

})

Client code:

import { runProcess } from './run-process';
import { dataMapper } from './data-mapper';

runProcess(dataMapper)

Alternatively, you can set the data mapper as a default value in your code:

import { dataMapper, DataMapper } from './data-mapper';
export const runProcess = (mapper: DataMapper = dataMapper) => {
  // implementation
}

This way, you won't need to pass the mapper everywhere in your code, although it does introduce a dependency that should ideally be tested. Lastly, ask yourself: Can you write at least one integration test? Integration tests are important to complement unit tests for overall testing efficiency.

Answer 10

I tend to steer clear of using jest.mock function due to issues with typings and implicitness. I have also encountered unexpected behavior at times, as jest.mock can feel like a magical solution that should only be used in rare cases where direct access to the source code is not possible.

To keep your code clean and explicit, consider implementing the dependency inversion pattern:

Service code:

export const runProcess = (mapper: (data: Data) => Promise<string>) => {
  // implementation
}

Unit test code:

it('should work', () => {
  const mapper = jest.fn(() => Promise.resolve('testing'));


  expect(runProcess(mapper)).toEqual(...);

})

Client code:

import { runProcess } from './run-process';
import { dataMapper } from './data-mapper';

runProcess(dataMapper)

Alternatively, you can set the data mapper as a default value in your code:

import { dataMapper, DataMapper } from './data-mapper';
export const runProcess = (mapper: DataMapper = dataMapper) => {
  // implementation
}

This way, you won't need to pass the mapper everywhere in your code, although it does introduce a dependency that should ideally be tested. Lastly, ask yourself: Can you write at least one integration test? Integration tests are important to complement unit tests for overall testing efficiency.

How can I playfully imitate an exported function to make it return a Promise instead of undefined?

Answer №1

Answer №2

Answer №3

Answer №4

Answer №5

Similar questions

Utilize generic types as object properties in TypeScript

What is the reason why modifying a nested array within an object does not cause the child component to re-render?

What are the conditions for Jasmine's .toHaveBeenCalledWith to match the parameters?

Using the TranslateService in Angular to externalize an array of strings

What is the best way to create an ESM / CJS module without needing to include '.default' in the imports?

NextJS and Context API throwing a Typescript error

Tips for rendering arrays as JSX elements in React.js

Step-by-step guide on integrating a custom JS file into an Angular component

The unit tests designed to verify the return of a View are currently unsuccessful

Exploring various options for identifying keys

Building a custom user authentication system using Angular, Firebase, and Google authentication

Utilizing the "as" keyword for type assertion in a freshly created react application using create-react-app leads to the error message `Parsing error: Unexpected token, expected ";"`

Angular directive to access HTML document attributes

Can one determine the type of an object that is inherited from another object?

The `setState` function is failing to change the current value

Leveraging jest for handling glob imports in files

Issue: (SystemJS) Unable to find solutions for all parameters in $WebSocket: ([object Object], [object Object], ?)

Incorporating a complex React (Typescript) component into an HTML page: A Step-by

Testing Django database routers can be a challenge, especially when it comes to migrations. How can you ensure they are

Material-UI: Error thrown when attempting to pass props to makeStyles in React due to missing property 'X' on type '{}'