How to use freezeConsole method in Jest

Happened something similar to me with pipeline cache, in my case what solved the problem appears to be "Clear Runner caches" through the Gitlab UI.

Read this documentation in order to understand about what button i'm talking about

I solved it.

requires('...') now returns an object, So your image will be in default key, like below

<img src={require('./logo.svg').default} className="App-logo" alt="logo" />

I don't know why this was changed tho.

I use the follow command and works:

jest "/client"

You can see the Jest documentation here: https://jestjs.io/docs/en/22.x/cli

Node

If you want to run them directly through node, try to require jest and/or jest-runtime. Also give @types/jest a try as well.

Check Edit 2 for new info about this

Edit

@types/jest (jest-DefinitelyTyped) is definitely needed (or just one solution). If you install it (e.g., dev dependency), the IDE errors should go away. I just tried it on Webstorm, and it works.

Edit 2

The new Jest@20 Matchers (e.g., .resolves and .rejects) are still not defined in @types/jest. You can keep track of its status on the links below: https://github.com/DefinitelyTyped/DefinitelyTyped/pull/16645 https://github.com/DefinitelyTyped/DefinitelyTyped/issues/16803

It should be available soon, though!

Also, it doesn't seem possible to run it directly through node. Last night I tried a bunch of different things, but using jest is the way to go - it really uses node under the hood, so I thought it would be possible as well. @thymikee over your opened issue at GitHub made clear that it's not.

Edit 3

The new release (20.0.1) includes the newest Jest definitions.

Lint

this isn't in the scope of this specific problem, but it also helps

Are you using something like ESLint? If so, you'll need eslint-plugin-jest

Following the steps described in this page: https://www.npmjs.com/package/eslint-plugin-jest, you will basically need to add it as an ESLint plugin and set jest globals in the ESLint configuration:

{
  "env": {
    "jest/globals": true
  }
}

If you plan on supporting ES6 tests, you'll also need Babel and babel-jest plugin with the following jest configuration:

"transform": {
  "^.+\\.js$": "babel-jest"
}

Finally, for Typescript tests you'd need the @types/jest and ts-jest packages as well

Okay, so I finally managed to solve this issue.

The problem was that iOS and Android apparently require different names for the fonts you want to load.

The simple-line-icons that i loaded in only worked for iOS and so on Android i got this error: fontFamily 'SimpleLineIcons' is not a system font and has not been loaded through Font.loadAsync.

I ended up loading both the simple-line-icons and the SimpleLineIcons, pointing to the same directory like so:

componentDidMount() {
    this.loadAssetsAsync()
  }

  loadAssetsAsync = async () => {
    await Font.loadAsync({
      amaticBold: require('./assets/fonts/amaticSC-Bold.ttf'),
      indieFlower: require('./assets/fonts/indieFlower.ttf'),
      'Material Icons': require('@expo/vector-icons/fonts/MaterialIcons.ttf'),
      'MaterialIcons': require('@expo/vector-icons/fonts/MaterialIcons.ttf'),
      'SimpleLineIcons': require('@expo/vector-icons/fonts/SimpleLineIcons.ttf'),
      'simple-line-icons': require('@expo/vector-icons/fonts/SimpleLineIcons.ttf')
    })
    this.setState({ fontLoaded: true })
  }

  render() {
    const store = createStore(reducers, {}, applyMiddleware(ReduxThunk))

    if (!this.state.fontLoaded) {
      return <AppLoading />
    }

    return (
      <Provider store={store}>
        <Router />
      </Provider>
    )
  }

This admittedly ugly solution solved my issue for now. Make sure you really type exactly like the error tells you to. If the error is: fontFamily 'MyAwesomeFont' is not a system font... Then you really need to name it:

Font.loadAsync({
    'MyAwesomeFont': require('./path/to/MyAwesomeFont.ttf')
})

Hope this helps anyone out there.

From the docs on Manual Mocks:

When we require that module in our tests, then explicitly calling jest.mock('./moduleName') is required.

If the module you are mocking is a Node module (e.g.: lodash), the mock should be placed in the __mocks__ directory adjacent to node_modules (unless you configured roots to point to a folder other than the project root) and will be automatically mocked. There's no need to explicitly call jest.mock('module_name').

Short answer

Use require to grab a fresh module in every test function after setting up mocks.

it("should print breakfast (mocked)", () => {
    jest.doMock(...);
    const getMeal = require("../src/meal").default;

    ...
});

or

Turn Food into a function and put a call to jest.mock into module scope.

import getMeal from "../src/meal";
import food from "../src/food";

jest.mock("../src/food");
food.mockReturnValue({ ... });

...

Long answer

There is a snippet in Jest manual that reads:

Note: In order to mock properly, Jest needs jest.mock('moduleName') to be in the same scope as the require/import statement.

The same manual also states:

If you're using ES module imports then you'll normally be inclined to put your import statements at the top of the test file. But often you need to instruct Jest to use a mock before modules use it. For this reason, Jest will automatically hoist jest.mock calls to the top of the module (before any imports).

ES6 imports are resolved in the module scope before any of the test functions execute. Thus for mocks to be applied, they need to be declared outside of test functions and before any modules are imported. Jest's Babel plugin will "hoist" jest.mock statements to the beginning of the file so they are executed before any imports take place. Note that jest.doMock is deliberately not hoisted.

One can study the generated code by taking a peek into Jest's cache directory (run jest --showConfig to learn the location).

The food module in the example is difficult to mock because it is an object literal and not a function. The easiest way is to force a reload of the module every time the value needs to be changed.

Option 1a: Do not use ES6 modules from tests

ES6 import statements must be module scoped, however the "good old" require has no such limitation and can be called from the scope of a test method.

describe("meal tests", () => {
  beforeEach(() => {
    jest.resetModules();
  });

  it("should print dinner", () => {
    const getMeal = require("../src/meal").default;

    expect(getMeal()).toBe(
      "Good evening. Dinner is green beans and rice. Yum!"
    );
  });

  it("should print breakfast (mocked)", () => {
    jest.doMock("../src/food", () => ({
      type: "breakfast",
      veg: "avocado",
      carbs: "toast"
    }));

    const getMeal = require("../src/meal").default;

    // ...this works now
    expect(getMeal()).toBe("Good morning. Breakfast is avocado and toast. Yum!");
  });
});

Option 1b: Reload module on every invocation

One can also wrap the function under test.

Instead of

import getMeal from "../src/meal";

use

const getMeal = () => require("../src/meal").default();

Option 2: Register the mock and call through to real functions by default

If the food module exposed a function and not a literal, it could be mocked. The mock instance is mutable and can be changed from test to test.

src/food.js

const Food = {
  carbs: "rice",
  veg: "green beans",
  type: "dinner"
};

export default function() { return Food; }

src/meal.js

import getFood from "./food";

function formatMeal() {
  const { carbs, veg, type } = getFood();

  if (type === "dinner") {
    return `Good evening. Dinner is ${veg} and ${carbs}. Yum!`;
  } else if (type === "breakfast") {
    return `Good morning. Breakfast is ${veg} and ${carbs}. Yum!`;
  } else {
    return "No soup for you!";
  }
}

export default function getMeal() {
  const meal = formatMeal();

  return meal;
}

__tests__/meal_test.js

import getMeal from "../src/meal";
import food from "../src/food";

jest.mock("../src/food");

const realFood = jest.requireActual("../src/food").default;    
food.mockImplementation(realFood);

describe("meal tests", () => {
  beforeEach(() => {
    jest.resetModules();
  });

  it("should print dinner", () => {
    expect(getMeal()).toBe(
      "Good evening. Dinner is green beans and rice. Yum!"
    );
  });

  it("should print breakfast (mocked)", () => {
    food.mockReturnValueOnce({ 
        type: "breakfast",
        veg: "avocado",
        carbs: "toast"
    });

    // ...this works now
    expect(getMeal()).toBe("Good morning. Breakfast is avocado and toast. Yum!");
  });
});

Of-course there are other options like splitting the test into two modules where one file sets up a mock and the other one uses a real module or returning a mutable object in place of a default export for the food module so it can be modified by each test and then manually reset in beforeEach.

tldr; The second argument of console.dir(value, options) is ignored in the current Jest implementation.

---

Jest redefines the global console with its own implementation. Both in BufferedConsole and CustomConsole you may find that dir method looks like this:

dir(firstArg: unknown, ...args: Array<unknown>): void {
  this._log('dir', format(firstArg, ...args));
}

It's hard to find the exact definition of the format function, but Github suggests the following implementations:

export const format = (value: unknown): string =>
  typeof value === 'function'
    ? value.toString()
    : prettyFormat(value, {min: true});

prettyFormat has maxDepth option which is not passed in all 3 implementations.

I solved it by creating a metro.config.js file in the root of the folder with this:

module.exports = {
  resolver: {
    blacklistRE: /#current-cloud-backend\/.*/,
  },
};