Troubleshooting Common Issues in Facebook JEST

tslib

With the appropriate node configuration, tslib effectively supports both cjs and es6 modules. The success of no errors when running indicates a proper implementation occurs with ESMs (Node Compatible) functioning through the exports property.

import { __assign } from "tslib";

const d = __assign({ a: "a" });
console.log(d.a);

However when running the following test in Jest ESM:

import { __assign } from "tslib";

test.only("General config is working", async () => {
  const d = __assign({ a: "a" });
  expect(d.a).toBe("a");
});

You’ll get the following error:

FAIL  src/tslib.test.js
  ● Test suite failed to run

    SyntaxError: The requested module 'tslib' does not provide an export named '__assign'

      at Runtime.linkAndEvaluateModule (node_modules/jest-runtime/build/index.js:669:5) It appears that Jest and NodeJS have different interpretation of the same file, leading to an incorrect determination by cjs-module-lexer as to what is being exported.

Summary

By delving into this issue, we can strive to resolve it for tslib. To fully fix the matter for glob, however, will necessitate addressingcjs-module-lexer as well.

jest.mock does not mock an ES module without Babel

Jest’s jest.mock function is designed to allow you to mock out the dependencies of a module during testing. However, by default, it will only work for CommonJS modules, which are not the same as ECMAScript (ES) modules.

If you are using an ES module and you want to mock it with jest.mock, you will need to make sure that you have Babel configured to transform your code to a format that Jest can understand. Specifically, you will need to have the @babel/preset-env and @babel/plugin-transform-modules-commonjs presets installed and configured in your Babel configuration.

Once you have these presets set up, you should be able to use jest.mock to mock out your ES modules in your tests. For example:

// my-module.js
export default function myModule() {
  // ...
}

// my-module.test.js
import myModule from './my-module';

jest.mock('./my-module');

test('mocks myModule', () => {
  myModule.mockImplementation(() => 'mocked result');
  expect(myModule()).toBe('mocked result');
});

Jest failing with “Call retries were exceeded”, using –runInBand works-around issue

After appending the --runInBandflag, success was achieved. No further information is required as long as the desired outcome of seeing green tests has been fulfilled.

spyOn getter only works for static getters and not for instance getters

Working with Mobx and TypeScript can present some unwanted challenges due to an unpleasant bug. As a workaround, the property may be set directly despite any typescript errors that arise in the process:

// @ts-ignore
instance.foo = false;

doc : jest fake timers : expect on setTimeout not working

After activating the fake timers, you can spy on global activities:

jest.spyOn(global, 'setTimeout');

Utilizing modern fake timers can be an effective way to test a given task without relying on the exact millisecond timing. For example, jest.advanceTimersByTime() provides much control over when tasks are run and in what order they occur in using jest.runAllTimers(). Additionally one can verify them with tools such as toHaveBeenNthCalledWith().

jest cannot find tests when projects are defined in configuration

To provide a resolution to your issue, this solution may prove useful:

{
roots: ["<rootDir>/src/", "<rootDir>/__tests__/"],
}

Without such a folder, any other material will be disregarded.

Async callback was not invoked within the 5000ms timeout – Error Message Improvement

Despite rigorous testing, an unfortunate reality remains: the mocked return values of certain tests may unintentionally bleed into other tests due to a lack of proper resetting. While not a definitive answer, we hope this information will prove useful for those seeking solutions similar to this one:

afterEach(() => { 
  jest.clearAllMocks(); 
  jest.resetAllMocks();
});

moduleNameMapper should work on resolved import paths

The challenge of this issue was swiftly resolved by leveraging the typeface library and providing a precise path to the css file:

import 'typeface-montserrat/index.css'

Despite its impressive capabilities, moduleNameMapper will only identify modules that have been imported with a .css file in the path.

Allow to share global state between tests from globalSetup

While the desired use case may appear to be a challenging feat, it is worth investigating this potential solution. Initial testing suggests we could utilize integration tests with an in-memory server; thereby providing us with a possible approach moving forward:

const server = await startServer()


The need to launch a “server” instance over multiple test files is challenging, especially since the associated ‘startServer’ function requires five to ten seconds of startup time. With this in mind, it would be encouraging if someone could provide assurance that an effective solution exists for this dilemma.

Retrieve global variable after running jest programmatically

If you are looking for a potential solution, consider adding an afterAll hook in the setupFilesAfterEnv. This will enable serializable data to be passed between processes or create your own test environment and use its teardown.

Introduce a more flexible and better typed way to mock APIs

For a more sophisticated approach, this version offers the ability to mock types that include properties that do not involve functions.

type GenericFunction = (...args: any[]) => any

type PickByTypeKeyFilter<T, C> = {
  [K in keyof T]: T[K] extends C ? K : never
}

type KeysByType<T, C> = PickByTypeKeyFilter<T, C>[keyof T]

type ValuesByType<T, C> = {
  [K in keyof T]: T[K] extends C ? T[K] : never
}

type PickByType<T, C> = Pick<ValuesByType<T, C>, KeysByType<T, C>>

type MethodsOf<T> = KeysByType<Required<T>, GenericFunction>

type InterfaceOf<T> = PickByType<T, GenericFunction>

type PartiallyMockedInterfaceOf<T> = {
  [K in MethodsOf<T>]?: jest.Mock<InterfaceOf<T>[K]>
}

export function mock<T>(...mockedMethods: MethodsOf<T>[]): jest.Mocked<T> {
  const partiallyMocked: PartiallyMockedInterfaceOf<T> = {}
  mockedMethods.forEach(mockedMethod =>
    partiallyMocked[mockedMethod] = jest.fn())
  return partiallyMocked as jest.Mocked<T>
}

More issues from Facebook repos

Troubleshooting facebook-react | Troubleshooting facebook-create-react-app | Troubleshooting facebook-metro | Troubleshooting facebook-prophet | Troubleshooting facebook-flipper