javascript - How do I set a mock date in Jest? - Stack Overflow

admin管理员组

文章数量:1125922

I'm using moment.js to do most of my date logic in a helper file for my React components but I haven't been able to figure out how to mock a date in Jest a la sinon.useFakeTimers().

The Jest docs only speak about timer functions like setTimeout, setInterval etc but don't help with setting a date and then checking that my date functions do what they're meant to do.

Here is some of my JS file:

var moment = require('moment');

var DateHelper = {
  
  DATE_FORMAT: 'MMMM D',
  API_DATE_FORMAT: 'YYYY-MM-DD',
  
  formatDate: function(date) {
    return date.format(this.DATE_FORMAT);
  },

  isDateToday: function(date) {
    return this.formatDate(date) === this.formatDate(moment());
  }
};


module.exports = DateHelper;

and here is what I've set up using Jest:

jest.dontMock('../../../dashboard/calendar/date-helper')
    .dontMock('moment');

describe('DateHelper', function() {
  var DateHelper = require('../../../dashboard/calendar/date-helper'),
      moment = require('moment'),
      DATE_FORMAT = 'MMMM D';

  describe('formatDate', function() {

    it('should return the date formatted as DATE_FORMAT', function() {
      var unformattedDate = moment('2014-05-12T00:00:00.000Z'),
          formattedDate = DateHelper.formatDate(unformattedDate);

      expect(formattedDate).toEqual('May 12');
    });

  });

  describe('isDateToday', function() {

    it('should return true if the passed in date is today', function() {
      var today = moment();

      expect(DateHelper.isDateToday(today)).toEqual(true);
    });
    
  });

});

Now these tests pass because I'm using moment and my functions use moment but it seems a bit unstable and I would like to set the date to a fixed time for the tests.

Any idea on how that could be accomplished?

I'm using moment.js to do most of my date logic in a helper file for my React components but I haven't been able to figure out how to mock a date in Jest a la sinon.useFakeTimers().

The Jest docs only speak about timer functions like setTimeout, setInterval etc but don't help with setting a date and then checking that my date functions do what they're meant to do.

Here is some of my JS file:

var moment = require('moment');

var DateHelper = {
  
  DATE_FORMAT: 'MMMM D',
  API_DATE_FORMAT: 'YYYY-MM-DD',
  
  formatDate: function(date) {
    return date.format(this.DATE_FORMAT);
  },

  isDateToday: function(date) {
    return this.formatDate(date) === this.formatDate(moment());
  }
};


module.exports = DateHelper;

and here is what I've set up using Jest:

jest.dontMock('../../../dashboard/calendar/date-helper')
    .dontMock('moment');

describe('DateHelper', function() {
  var DateHelper = require('../../../dashboard/calendar/date-helper'),
      moment = require('moment'),
      DATE_FORMAT = 'MMMM D';

  describe('formatDate', function() {

    it('should return the date formatted as DATE_FORMAT', function() {
      var unformattedDate = moment('2014-05-12T00:00:00.000Z'),
          formattedDate = DateHelper.formatDate(unformattedDate);

      expect(formattedDate).toEqual('May 12');
    });

  });

  describe('isDateToday', function() {

    it('should return true if the passed in date is today', function() {
      var today = moment();

      expect(DateHelper.isDateToday(today)).toEqual(true);
    });
    
  });

});

Now these tests pass because I'm using moment and my functions use moment but it seems a bit unstable and I would like to set the date to a fixed time for the tests.

Any idea on how that could be accomplished?

• javascript
• jestjs
• momentjs

Share Improve this question Follow edited Apr 9, 2021 at 14:53 Liam 29.5k2828 gold badges137137 silver badges200200 bronze badges asked Apr 18, 2015 at 16:03 alengelalengel 4,94833 gold badges2222 silver badges2828 bronze badges 1

• 1 can you please select a different answer, since jest now has inbuilt date mocking? – mikemaccana Commented Nov 5, 2021 at 16:08

Add a comment  | 

32 Answers 32

Sorted by: Reset to default 1 2 Next 518

As of Jest 26 this can be achieved using "modern" fake timers without needing to install any 3rd party modules: https://jestjs.io/blog/2020/05/05/jest-26#new-fake-timers

jest
  .useFakeTimers()
  .setSystemTime(new Date('2020-01-01'));

If you want the fake timers to be active for all tests, you can set timers: 'modern' in your configuration: https://jestjs.io/docs/configuration#timers-string

EDIT: As of Jest 27 modern fake timers is the default, so you can drop the argument to useFakeTimers.

Since momentjs uses Date internally, you can just overwrite the Date.now function to always return the same moment.

Date.now = jest.fn(() => 1487076708000) //14.02.2017

or

Date.now = jest.fn(() => new Date(Date.UTC(2017, 1, 14)).valueOf())

For a robust solution, look at timekeeper:

import timekeeper from 'timekeeper';

beforeAll(() => {
    // Lock Time
    timekeeper.freeze(new Date('2014-01-01'));
});

afterAll(() => {
    // Unlock Time
    timekeeper.reset();
});

For older versions of Jest:

For quick and dirty solution use jest.spyOn for locking time:

let dateNowSpy;

beforeAll(() => {
    // Lock Time
    dateNowSpy = jest.spyOn(Date, 'now').mockImplementation(() => 1487076708000);
});

afterAll(() => {
    // Unlock Time
    dateNowSpy.mockRestore();
});

MockDate can be used in jest tests to change what new Date() returns:

var MockDate = require('mockdate');
// I use a timestamp to make sure the date stays fixed to the ms
MockDate.set(1434319925275);
// test code here
// reset to native Date()
MockDate.reset();

For those who want to mock methods on a new Date object you can do the following:

beforeEach(() => {
    jest.spyOn(Date.prototype, 'getDay').mockReturnValue(2);
    jest.spyOn(Date.prototype, 'toISOString').mockReturnValue('2000-01-01T00:00:00.000Z');
});

afterEach(() => {
    jest.restoreAllMocks()
});

Here are a few readable ways for different use cases. I prefer using spies over saving references to the original objects, which can be accidentally overwritten in some other code.

One-off mocking

jest
  .spyOn(global.Date, 'now')
  .mockImplementationOnce(() => Date.parse('2020-02-14'));

A few tests

let dateSpy;

beforeAll(() => {
  dateSpy = jest
    .spyOn(global.Date, 'now')
    .mockImplementation(() => Date.parse('2020-02-14'));
});

afterAll(() => {
  dateSpy.mockRestore();
});

This works for me:

const mockDate = new Date('14 Oct 1995')
global.Date = jest.fn().mockImplementation(() => mockDate) // mock Date "new" constructor
global.Date.now = jest.fn().mockReturnValue(mockDate.valueOf()) // mock Date.now

All the answer based only on the mock of Date.now() will not work everywhere since some packages (for instance moment.js) use new Date() instead.

In this context the answer based on MockDate is I think the only truly correct. If you don't want to use an external package, you can write directly in your beforeAll:

  const DATE_TO_USE = new Date('2017-02-02T12:54:59.218Z');
  // eslint-disable-next-line no-underscore-dangle
  const _Date = Date;
  const MockDate = (...args) => {
    switch (args.length) {
      case 0:
        return DATE_TO_USE;
      default:
        return new _Date(...args);
    }
  };
  MockDate.UTC = _Date.UTC;
  MockDate.now = () => DATE_TO_USE.getTime();
  MockDate.parse = _Date.parse;
  MockDate.toString = _Date.toString;
  MockDate.prototype = _Date.prototype;
  global.Date = MockDate;

jest-date-mock is a complete javascript module wrote by me, and it is used to test Date on jest.

import { advanceBy, advanceTo } from 'jest-date-mock';

test('usage', () => {
  advanceTo(new Date(2018, 5, 27, 0, 0, 0)); // reset to date time.

  const now = Date.now();

  advanceBy(3000); // advance time 3 seconds
  expect(+new Date() - now).toBe(3000);

  advanceBy(-1000); // advance time -1 second
  expect(+new Date() - now).toBe(2000);

  clear();
  Date.now(); // will got current timestamp
});

Use the only 3 api for test cases.

• advanceBy(ms): advance date timestamp by ms.
• advanceTo([timestamp]): reset date to timestamp, default to 0.
• clear(): shut down the mock system.

To mock toISOString you can do:

jest.spyOn(global.Date.prototype, 'toISOString').mockReturnValue('2023-09-06T11:54:47.050Z')

Since Jest version 29 you can do the following as well:

jest.useFakeTimers({
  now: 1673445238335,
});

The following options are allowed:

type FakeTimersConfig = {
  /**
   * If set to `true` all timers will be advanced automatically by 20 milliseconds
   * every 20 milliseconds. A custom time delta may be provided by passing a number.
   * The default is `false`.
   */
  advanceTimers?: boolean | number;
  /**
   * List of names of APIs that should not be faked. The default is `[]`, meaning
   * all APIs are faked.
   */
  doNotFake?: Array<FakeableAPI>;
  /**
   * Use the old fake timers implementation instead of one backed by `@sinonjs/fake-timers`.
   * The default is `false`.
   */
  legacyFakeTimers?: boolean;
  /** Sets current system time to be used by fake timers. The default is `Date.now()`. */
  now?: number | Date;
  /**
   * The maximum number of recursive timers that will be run when calling `jest.runAllTimers()`.
   * The default is `100_000` timers.
   */
  timerLimit?: number;
};

You can read more in the docs.

This is how I mocked my Date.now() method to set the year to 2010 for my test

jest
  .spyOn(global.Date, 'now')
  .mockImplementationOnce(() => new Date(`2010`).valueOf());

Sometimes, using just

jest.useFakeTimers({
  now: 1673445238335,
});

leads to freezes in async/await functions. To avoid freezes, I don't mock some APIs:

      jest.useFakeTimers({
        doNotFake: [
          "setImmediate",
          "clearImmediate",
          "setTimeout",
          "clearTimeout",
          "setInterval",
          "clearInterval",
          "nextTick",
          "queueMicrotask",
        ],
        now: new Date(TEST_DATE),
      });

I'm using moment + moment-timezone and none of these worked for me.

This worked:

jest.mock('moment', () => {
  const moment = jest.requireActual('moment');
  moment.now = () => +new Date('2022-01-18T12:33:37.000Z');
  return moment;
});

I ran into issues with most implementations.

While jest.setSystemTime(new Date(date)); is attractive, in practice, it was not overriding the date in many circumstances.

Just overriding Date.now is OK, but I also use new Date throughout the codebase, as does moment.

Finally, I felt that a package was simply overkill.

After much trial and error, taking some inspiration from the answers here, here is my solution, which inherits from Date, so it will have all it's properties, and will account for different types of parameters (such as multiple parameters, without which moment().startOf('day') wasn't working).

// default mock date, if you want one
export const setDateToReturnMockDate = (date) => {
  const mockDate = new Date(date);
  const _Date = Date;
  class MockDate extends _Date {
    // can accept an array, e.g. new Date(2023, 3, 2);
    constructor(...date) {
      return date.length ? new _Date(...date) : mockDate;
    }
  }
  MockDate.now = () => +mockDate;
  global.Date = MockDate;
};

I would like to offer some alternative approaches.

If you need to stub format() (which can be locale and timezone dependent!)

import moment from "moment";
...
jest.mock("moment");
...
const format = jest.fn(() => 'April 11, 2019')
moment.mockReturnValue({ format })

If you only need to stub moment():

import moment from "moment";
...
jest.mock("moment");
...
const now = "moment(\"2019-04-11T09:44:57.299\")";
moment.mockReturnValue(now);

Regarding the test for the isDateToday function above, I believe the simplest way would be not to mock moment at all

I'd like use Manual Mocks, so it can use in all tests.

// <rootDir>/__mocks__/moment.js
const moment = jest.requireActual('moment')

Date.now = jest.fn(() => 1558281600000) // 2019-05-20 00:00:00.000+08:00

module.exports = moment

In my case I had to mock the whole Date and 'now' function before test:

const mockedData = new Date('2020-11-26T00:00:00.000Z');

jest.spyOn(global, 'Date').mockImplementation(() => mockedData);

Date.now = () => 1606348800;

describe('test', () => {...})

Improving a bit the @pranava-s-balugari response

1. It does noe affect new Date(something)
2. The mocked date can be changed.
3. It will work fot Date.now too

const DateOriginal = global.Date;

global.Date = class extends DateOriginal {
    constructor(params) {
        if (params) {
          super(params)
        } else if (global.Date.NOW === undefined) {
          super()
        } else {
          super(global.Date.NOW)
        }
    }
    static now () {
      return new Date().getTime();
    }
}

afterEach(() => {
  global.Date.NOW = undefined;
})

afterAll(() => {
  global.Date = DateOriginal;
});

describe('some test', () => {
  afterEach(() => NOW = undefined);

  it('some test', () => {
     Date.NOW = '1999-12-31T23:59:59' // or whatever parameter you could pass to new Date([param]) to get the date you want


     expect(new Date()).toEqual(new Date('1999-12-31T23:59:59'));
     expect(new Date('2000-01-01')).toEqual(new Date('2000-01-01'));
     expect(Date.now()).toBe(946681199000)

     Date.NOW = '2020-01-01'

     expect(new Date()).toEqual(new Date('2020-01-01'));
  })
})

The accepted answer works good -

Date.now = jest.fn().mockReturnValue(new Date('2021-08-29T18:16:19+00:00'));

But if we want to run unit tests in pipeline we have to make sure we are using the same time zone. To do that we have to mock timezone as well -

jest.config.js

process.env.TZ = 'GMT';

module.exports = {
 ...
};

See also: the full list of timezones (column TZ database name)

I was using an external library and to make it work I had to run this code on the setup stage:

Date.now = jest.fn(() => new Date(Date.UTC(2021, 2, 30)).valueOf());

I wrote this in my setupTests.ts file set in the setupFilesAfterEnv prop from jest.config.js:

module.exports = {
    setupFilesAfterEnv: ['<rootDir>/src/setupTests.ts'],
};

It would be good to set it before each test.

describe('TestCase', () => {
  beforeAll(() => {
    // Lock Time
    // new Date(). It helps us to achieve dynamic a date rather than hard code.

    jest.useFakeTimers().setSystemTime(new Date());
  });
});

I just wanted to chime in here since no answer addressed the issue if you want to mock the Date object in only a specific suite.

You can mock it using the setup and teardown methods for each suite, jest docs

/**
 * Mocking Date for this test suite
 */
const globalDate = Date;

beforeAll(() => {
  // Mocked Date: 2020-01-08
  Date.now = jest.fn(() => new Date(Date.UTC(2020, 0, 8)).valueOf());
});

afterAll(() => {
  global.Date = globalDate;
});

Hope this helps!

You can use date-faker. Lets you change the current date relatively:

import { dateFaker } from 'date-faker';
// or require if you wish: var { dateFaker } = require('date-faker');

// make current date to be tomorrow
dateFaker.add(1, 'day'); // 'year' | 'month' | 'day' | 'hour' | 'minute' | 'second' | 'millisecond'.

// change using many units
dateFaker.add({ year: 1, month: -2, day: 3 });

// set specific date, type: Date or string
dateFaker.set('2019/01/24');

// reset
dateFaker.reset();

Best way I have found is just to override the prototype with whatever function you are using.

Date.prototype.getTimezoneOffset = function () {
   return 456;
};

Date.prototype.getTime = function () {
      return 123456;
};

The following test stubs Date to return a constant during the test lifecycle.

If you have use new Date() in your project then you could mock it in your test file something like this:

  beforeEach(async () => {
    let time_now = Date.now();
    const _GLOBAL: any = global;
    _GLOBAL.Date = class {
      public static now() {
        return time_now;
      }
    };
}

Now wherever you will use new Date() in your test file, It will produce the same timestamp.

Note: you could replace beforeEach with beforeAll. And _GLOBAL is just a proxy variable to satisfy typescript.

The complete code I tried:

let time_now;
const realDate = Date;

describe("Stubbed Date", () => {
  beforeAll(() => {
    timeNow = Date.now();
    const _GLOBAL: any = global;
    _GLOBAL.Date = class {
      public static now() {
        return time_now;
      }

      constructor() {
        return time_now;
      }

      public valueOf() {
        return time_now;
      }
    };
  });

  afterAll(() => {
    global.Date = realDate;
  });

  it("should give same timestamp", () => {
    const date1 = Date.now();
    const date2 = new Date();
    expect(date1).toEqual(date2);
    expect(date2).toEqual(time_now);
  });
});

It worked for me.

Goal is to mock new Date() with a fixed date wherever it's used during the component rendering for test purposes. Using libraries will be an overhead if the only thing you want is to mock new Date() fn.

Idea is to store the global date to a temp variable, mock the global date and then after usage reassign temp to global date.

export const stubbifyDate = (mockedDate: Date) => {
    /**
     * Set Date to a new Variable
     */
    const MockedRealDate = global.Date;

    /**
     *  Mock Real date with the date passed from the test
     */
    (global.Date as any) = class extends MockedRealDate {
        constructor() {
            super()
            return new MockedRealDate(mockedDate)
        }
    }

    /**
     * Reset global.Date to original Date (MockedRealDate) after every test
     */
    afterEach(() => {
        global.Date = MockedRealDate
    })
}

Usage in your test would be like

import { stubbyifyDate } from './AboveMethodImplementedFile'

describe('<YourComponent />', () => {
    it('renders and matches snapshot', () => {
        const date = new Date('2019-02-18')
        stubbifyDate(date)

        const component = renderer.create(
            <YourComponent data={}/>
        );
        const tree = component.toJSON();
        expect(tree).toMatchSnapshot();
    });
});

I recommend sinonjs/fake-timers. It's very similar to the fake timer provided by jest, but much more user-friendly.

import FakeTimers from '@sinonjs/fake-timers';

const clock = FakeTimers.install()
clock.setSystemTime(new Date('2022-01-01'));

console.log(new Date()) // 2020-01-01T00:00:00.000Z

jest.useFakeTimers('modern').setSystemTime(new Date('2023-03-01'))

jest.useFakeTimers({ now: Number(new Date()) })

Jest docs: https://jestjs.io/docs/timer-mocks

本文标签： javascriptHow do I set a mock date in JestStack Overflow