Question

133

How to test dynamic imports (then and catch) with Jest

rated 0 times [ 139] [ 6] / answers: 1 / hits: 14266 / 4 Years ago, mon, september 14, 2020, 12:00:00

So I have been struggling with how to test dynamic imports generally and in this case, especially in jest, I have been reading a lot on the internet but did not find anything concrete, so I thought about bringing the question up to centralize a decent solution.

I have the following methods inside of a class

class MyClass {

   successMethod() {  ...  }



   errorMethod() { ... }



    myMethod() {

        return import('./myFile.js')

           .then(() => this.successMethod())

           .catch(() => this.errorMethod());

    }

}

My question is:

How do you mock both Success and Failing promise cases for this dynamic import using Jest to make sure each method (successMethod and errorMethod) are called when resolving or failing respectively?.

I found jest.doMock helps for mocking the resolved case but did not find a way to make the dynamic import fail by mocking it so the catch case is uncovered.

Note: this is not a react application, this is a Vanilla JS project.

Answers

Only authorized users can answer the question. Please sign in first, or register a free account.

ryanulyssesb

Add To Favorites

Follow

Total Points: 91

Total Questions: 105

Total Answers: 102

Location: England

Member since Tue, Sep 8, 2020

4 Years ago

ryanulyssesb questions

1 Vue 3: `defineProps` are referencing locally declared variables

Sat, Nov 13, 21, 00:00, 3 Years ago

1 How to put file path in package.json file

Sat, Mar 20, 21, 00:00, 3 Years ago

1 Sending data from Python to Javascript using EEL

Mon, Mar 9, 20, 00:00, 4 Years ago

1 SyntaxError: Unexpected token / in JSON at position 132

Sun, Jul 7, 19, 00:00, 5 Years ago

1 Is it possible to return resolved value from promise without async/await?

Sun, Jun 16, 19, 00:00, 5 Years ago

View All

answered 4 Years ago loganl · Accepted Answer

Prototype methods can be spied or mocked on either MyClass.prototype or class instance. Module mocks and spy functions should be restored for each test in order for them to not affect each other.

let myClass;

beforeEach(() => {

  jest.resetModules();

  jest.restoreAllMocks();

  myClass = new MyClass();

  jest.spyOn(myClass, 'successMethod');

  jest.spyOn(myClass, 'errorMethod');

});

jest.doMock requires to import all affected modules after it was called. In order for dynamic import to result in rejected promise, myFile module should throw an error when evaluated. Since dynamic import returns a promise, tests should be asynchronous.

it('...', async () => {

  jest.mock('./myFile.js', () => 'value');

  await expect(myClass.myMethod()).resolves.toEqual(/* return value from successMethod */);

  expect(myClass.successMethod).toBeCalled();

  expect(myClass.errorMethod).not.toBeCalled();

});



it('...', async () => {

  jest.mock('./myFile.js', () => { throw new Error() });

  await expect(myClass.myMethod()).rejects.toThrow(/* error message from errorMethod */);

  expect(myClass.successMethod).not.toBeCalled();

  expect(myClass.errorMethod).toBeCalled();

});