How to use reportSuccess method in Jest

Based on this issue it appears that it was decided that shipping node.js with internationalization would make it too large. You can npm install intl and require that, and it will replace toLocaleString with a version that works.

That's probably because you're using babel-jest, which according to the documentation, will hoist jest.mock() to top-level regardless of where it's actually placed in your ES6 module code.

When using babel-jest, calls to mock will automatically be hoisted to the top of the code block.

Instead, you can use the jest.doMock() and jest.dontMock() methods in your before() and after() hooks respectively for individual tests that require you to mock the functions in your module definition.

You need to use jest's timer mocks https://jestjs.io/docs/en/timer-mocks

First you tell jest to use mock timers, then you run the timers within your test.

It would look something like:

function doAsync(c) {
  setTimeout(() => {
      c(true)
    }, 1000)
}

jest.useFakeTimers()

test('doAsync calls both callbacks', () => {

  expect.assertions(2);

  function callback1(data) {
    expect(data).toBeTruthy();
  }

  function callback2(data) {
    expect(data).toBeTruthy();
  }

  doAsync(callback1);
  doAsync(callback2);

  jest.runAllTimers(); // or jest.advanceTimersByTime(1000)
});

You could use jest.mock(moduleName, factory, options) to mock node-cron module. Use dotenv package load the environment variables from .env before running the test cases.

E.g.

cronJob.js:

import cron from 'node-cron';

class CronJob {
  constructor() {
    this.startJob();
  }

  async startJob() {
    cron.schedule(
      process.env.FREQUENCY_CRON,
      async () => {
        console.log('DO SOME DATA PROCESSING');
      },
      {
        scheduled: process.env.SCHEDULED,
        timezone: process.env.TIMEZONE,
      },
    );
  }
}

export default new CronJob();

cronJob.test.js:

import cron from 'node-cron';
import path from 'path';

require('dotenv').config({ path: path.resolve(__dirname, './.env') });

jest.mock('node-cron', () => {
  return {
    schedule: jest.fn(),
  };
});

describe('61765291', () => {
  it('should pass', () => {
    const logSpy = jest.spyOn(console, 'log');
    cron.schedule.mockImplementationOnce(async (frequency, callback) => await callback());
    require('./cronJob');
    expect(logSpy).toBeCalledWith('DO SOME DATA PROCESSING');
    expect(cron.schedule).toBeCalledWith('30 00 * * *', expect.any(Function), {
      scheduled: 'true',
      timezone: 'America/Sao_Paulo',
    });
  });
});

.env:

#CRON JOB
FREQUENCY_CRON='30 00 * * *'
TIMEZONE="America/Sao_Paulo"
SCHEDULED=true
INACTIVE_EXPIRATION_TIME=2592000000 #30 DAYS

unit test results with 100% coverage:

 PASS  stackoverflow/61765291/cronJob.test.js (8.148s)
  61765291
    ✓ should pass (30ms)

  console.log
    DO SOME DATA PROCESSING

      at CustomConsole.<anonymous> (node_modules/jest-environment-enzyme/node_modules/jest-mock/build/index.js:866:25)

------------|---------|----------|---------|---------|-------------------
File        | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s 
------------|---------|----------|---------|---------|-------------------
All files   |     100 |      100 |     100 |     100 |                   
 cronJob.js |     100 |      100 |     100 |     100 |                   
------------|---------|----------|---------|---------|-------------------
Test Suites: 1 passed, 1 total
Tests:       1 passed, 1 total
Snapshots:   0 total
Time:        9.145s, estimated 10s

It looks like babel-jest is missing among your dependencies. That's why jest is not running babel on your ES6+ code before executing tests.

I solved the problem by just setting the regex so it finds all .js files in my ./test folder:

"jest": {
   "preset": "react-native",
    "globals": {
        "__DEV__": true
    },
    "testRegex": "./test/.*.js$",
    "rootDir": "."
 },

(jcollum here: I don't know what __DEV__ is actually doing there but an error will be thrown if isn't. jest 17.0.3)

The short answer is anywhere you want.

JavaScript has had a lot of different stages in its life and a lot of different types of people using it. Which is probably why most tools these days are highly configurable, to allow for personalization (customization.)

Even Jest itself shows these signs. For instance the test matcher will look for tests in either __tests__ folders or with files that are contain .spec or .test.

Or as per their docs in a visual manner:

├── __tests__
│   └── component.spec.js # test
│   └── anything # test
├── package.json # not test
├── foo.test.js # test
├── bar.spec.jsx # test
└── component.js # not test

With regards to fixtures and other test files the answer is the same, there is no one way to do it.

Pick what works for you.

I recommend for the __tests__ structure placing fixture data close to the test thats using it, and if multiple tests need access then move it further up the project until its in a common place.

My preference is a tests folder to keep the tests, fixtures, and testing separate to the src code.

I found this library that a colleague of mine wrote recently: jest-when

import { when } from 'jest-when';

const fn = jest.fn();
when(fn).calledWith(1).mockReturnValue('yay!');

const result = fn(1);
expect(result).toEqual('yay!');

Here's the library: https://github.com/timkindberg/jest-when

Actually you can use jest.spyOn jest.spyOn

If method is called when component created use:

import { mount } from 'enzyme'; 

describe('My component', () => {
  it('should call getData', () => {
    const spy = jest.spyOn(Component.prototype, 'getData');
    mount(<Component />);
    expect(spy).toHaveBeenCalledTimes(1)
  });
})

or if you have it in your DOM and method use bind you can use:

import { shallow } from 'enzyme'; 

describe('My component', () => {
  it('should call getData', () => {
    const wrapper = shallow(<Component />);
    const instance = wrapper.instance()
    const spy = jest.spyOn(instance, 'getData');
    wrapper.find('button').simulate('click')
    expect(spy).toHaveBeenCalledTimes(1)
  });
})