How to use loadBabelConfig method in Jest

The jest api has changed a bit. This is what I use. It doesn't do anything but it's enough to render my components.

const xhrMockClass = () => ({
  open            : jest.fn(),
  send            : jest.fn(),
  setRequestHeader: jest.fn()
})

window.XMLHttpRequest = jest.fn().mockImplementation(xhrMockClass)

and in the test file:

import '../../__mock__/xhr-mock.js'

As Jest is developed on top of jasmine, you can use this

const mockDate = new Date(1434319925275);
spyOn(window, 'Date').and.callFake(() => {
return mockDate;
});

This most likely happens because String.prototype.replaceAll is not implemented in Node.js (at least as of version v14.15.0).

One alternative you could use are regular expressions like in this example:

const str = 'foo-foo';
const regex = /foo/g; // Note the 'g' flag, which matches all occurrences of the expression

console.log(str.replace(regex, 'bar')); // 'bar-bar'

You can check here for more info on regular expressions.

The following method worked for me. This approach allowed me to test some code that should work both in the browser and in Node.js, as it allowed me to set window to undefined.

This was with Jest 24.8 (I believe):

let windowSpy;

beforeEach(() => {
  windowSpy = jest.spyOn(window, "window", "get");
});

afterEach(() => {
  windowSpy.mockRestore();
});

it('should return https://example.com', () => {
  windowSpy.mockImplementation(() => ({
    location: {
      origin: "https://example.com"
    }
  }));

  expect(window.location.origin).toEqual("https://example.com");
});

it('should be undefined.', () => {
  windowSpy.mockImplementation(() => undefined);

  expect(window).toBeUndefined();
});

First of all you are comparing string to object (result is JS object while expected is a string). If you wan't to convert JSON string to an object you would need to use JSON.parse function.

let strObj = "{\"foo\":\"bar\"}"
// you can't access object properties from string:
strObj.foo // undefined
let obj = {"foo":"bar"}
obj.foo // "bar"
let parsed = JSON.parse(strObj)
parsed.foo // "bar"

Secondly, because in JS objects are compared by reference, this code is comparing whether expected and received references point to the same object instance

let a = {foo: "bar"}
let b = {foo: "bar"}
a == b // false

In your case use expect(result).toMatchObject(expected). This checks whether object matches the structure and values in expected (performs deep comparison).

As in jest documentation

Use .toMatchObject to check that a JavaScript object matches a subset of the properties of an object. It will match received objects with properties that are not in the expected object.

So in result your code would probably will look like this:

expect(result).toMatchObject({
    partyRoleIdentifier: {
        internalEmployeeIdentifier: {
            id: "id-modified"
        }
    }
})

You can add following code before test cases. It works for me in Jest v14.1.0 -

  jest.useRealTimers()

Ok, this is a silly problem and I found the solution.

I had to export the CustomEnvironment

const NodeEnvironment = require('jest-environment-node');

class CustomEnvironment extends NodeEnvironment {
  ...
}

module.exports = CustomEnvironment

And also add it in the jest.config.js

const { defaults } = require("jest-config");
module.exports = {
  testEnvironment: './../CustomEnvironment.js',
};

I don't know why the guide doesn't include that line :(

The current best alternative is to use the async versions of fake-timers. So you would do

await clock.tickAsync(1000); // doesn't wait 1000ms but is async

Instead of calling clock.tick. Please see the answer below for more details.

At the moment, it's not supported

You're not doing anything wrong - it doesn't work at the moment - sorry. The following things have to happen before this will work from our end:

• Jest needs to merge the ongoing work to merge lolex as their fake timer implementation here https://github.com/facebook/jest/pull/5171
• Lolex needs to support pumping through promises - we've discussed this with the V8 team in a recent Node.js collaborator summit. That would expose a hook we'll use to allow doing something like advanceTimeByTime(100) and have that work with promises.

The problem in a gist is that the .then(spy) only gets called later.

As we are volunteers - there is no concrete timeline for these things. I hope SimenB does the merge in the coming 2-3 months and I'll follow up with the hook with the V8 team next month.

What you can do now

You can always write an async test:

// note this is an async function now
it('resolves in a given amount of time', async () => {
  // this is in a promise.reoslve.then to not 'lock' on the await
  Promise.resolve().then(() => jest.advanceTimersByTime(100));
  await timeout(100);
});

You can add expectations after the timeout if there is anything else you want to wait for.

Have you tried to change the name of the file? MyComponent.test.tsx Also, did you install the types of jest and stuff npm i -D @types/jest. I mean I’m saying this because if you look at the jest config where it says testRegex. You have it like this __tests__/*.(test|spec).txs the test must be inside a tests folder and it has to have the name: MyComponent.test.tsx