How to use getProjectsRunningMessage method in Jest

You can use either es6 import or require js to import your js files in your jest tests.

When using es6 import you should know that jest is trying to resolve all the dependencies and also calls the constructor for the class that you are importing. During this step, you cannot mock it. The dependency has to be successfully resolved, and then you can proceed with mocks.

I should also add that as can be seen here jest by default hoists any jest.mocks to the top of the file so the order in which you place your imports does not really matter.

Your problem though is different. Your mock function assumes that you have included your js file using require js.

jest.mock('./dependecy', () => {
   return {
      default: jest.fn()
   };
});

When you import a file using require js, this is the structure it has:

So assuming I have imported my class called "Test" using require js, and it has method called "doSomething" I could call it in my test by doing something like:

const test = require('../Test');
test.default.doSomething();

When importing it using es6 import, you should do it differently though. Using the same example:

import Test from '../Test';
Test.doSomething();

EDIT: If you want to use es6 import change your mock function to:

jest.mock('./dependecy', () => jest.fn());

jest.spyOn official documentation gives a great answer:

Note: By default, jest.spyOn also calls the spied method. This is different behavior from most other test libraries. If you want to overwrite the original function, you can use jest.spyOn(object, methodName).mockImplementation(() => customImplementation) or object[methodName] = jest.fn(() => customImplementation);

So in your case just pass a fake method to customImplementation.

Your Jest configuration is missing React Native preset:

"jest": {
  "preset": "react-native"
}

It's available by default in this form since react-native@0.38.0.

I found what the issue is.

Because foo is instantiated by executing the function, calling mockFoo.met1 returns undefined since mockFoo is a function. For mock1 to be defined, I'd have to call mockFoo().met1. But at that point I'm getting a new instance of mockFoo which is different from the one loaded and called by moduleUnderTest.

To fix the problem, I have to declare and set the mock this way:

const mockMet1 = jest.fn()
const mockMet2 = jest.fn()
const mockFoo = () => ({
  met1: mockMet1,
  met2: mockMet2,
})
const moduleUnderTest = require('./moduleUnderTest')
jest.mock('../foo', mockFoo)

// ...snip...
afterEach(() => { // resets the called count etc
  mockMet1.resetMock()
  mockMet2.resetMock()
})
// ...snip...
expect(mockMet1).toHaveBeenCalledTimes(1)
// ...snip...

In Jest you have to pass a function into expect(function).toThrow(<blank or type of error>).

Example:

test("Test description", () => {
  const t = () => {
    throw new TypeError();
  };
  expect(t).toThrow(TypeError);
});

Or if you also want to check for error message:

test("Test description", () => {
  const t = () => {
    throw new TypeError("UNKNOWN ERROR");
  };
  expect(t).toThrow(TypeError);
  expect(t).toThrow("UNKNOWN ERROR");
});

If you need to test an existing function whether it throws with a set of arguments, you have to wrap it inside an anonymous function in expect().

Example:

test("Test description", () => {
  expect(() => {http.get(yourUrl, yourCallbackFn)}).toThrow(TypeError);
});

The best way to encapsulate a logical or in your test suite would be to just exclude the particular case inside of the test itself. For example:

it('has an array of objects', () => {
  if (arr.length > 0) {
    expect(arr).toBe(expect.arrayContaining(expect.toMatchObject({ foo: expect.any(String) })));
  }
});

However, I think a more unit test-friendly approach would be to separate your concerns. One test for when there is an empty array, and one test for when the foo property is set to 'bar', etc.

Installing babel-plugin-dynamic-import-node solved our problem. In addition, make sure that babylon (babel dependency) is at least 6.12.0.

Also, we had a problem with Travis build because Travis cached node_modules and old babylon with it:

$ npm ls babylon
react-boilerplate@3.3.0 /home/travis/build/mxstbr/react-boilerplate
├─┬ babel-core@6.21.0
│ └── babylon@6.11.1
├─┬ babel-eslint@7.1.1
│ └── babylon@6.14.1 
├─┬ jest-cli@18.0.0
│ └─┬ istanbul-lib-instrument@1.3.0
│   └── babylon@6.14.1 

, so we had to turn the cache off with: cache: false

'11 111.11'.split('').map(x => console.log((x.charCodeAt(0))))

Yields "32" for the space character which is a normal space.

new Intl.NumberFormat('fr-CA').format(11111.11).split('').map(x => console.log((x.charCodeAt(0))))

Yields "160" for the space character, which is a non-breaking space.

To make these tests pass, you need to add the non-breaking space UTF-16 (\xa0) character code into the assertion.

expect(formatCurrency(24555.55, 'fr_CA', true)).toBe('24\xa0555,55 $');

Edit: Several years have passed and this isn't really the right way to do this any more (and probably never was, my bad).

Mutating an imported module is nasty and can lead to side effects like tests that pass or fail depending on execution order.

I'm leaving this answer in its original form for historical purposes, but you should really use jest.spyOn or jest.mock. Refer to the jest docs or the other answers on this page for details.

Original answer follows:

I've been able to solve this by using a hack involving import *. It even works for both named and default exports!

For a named export:

// dependency.js
export const doSomething = (y) => console.log(y)

// myModule.js
import { doSomething } from './dependency';

export default (x) => {
  doSomething(x * 2);
}

// myModule-test.js
import myModule from '../myModule';
import * as dependency from '../dependency';

describe('myModule', () => {
  it('calls the dependency with double the input', () => {
    dependency.doSomething = jest.fn(); // Mutate the named export

    myModule(2);

    expect(dependency.doSomething).toBeCalledWith(4);
  });
});

Or for a default export:

// dependency.js
export default (y) => console.log(y)

// myModule.js
import dependency from './dependency'; // Note lack of curlies

export default (x) => {
  dependency(x * 2);
}

// myModule-test.js
import myModule from '../myModule';
import * as dependency from '../dependency';

describe('myModule', () => {
  it('calls the dependency with double the input', () => {
    dependency.default = jest.fn(); // Mutate the default export

    myModule(2);

    expect(dependency.default).toBeCalledWith(4); // Assert against the default
  });
});