How to use loadNotifier method in Jest

Try the code below:

import {describe, expect, it } from '@jest/globals'

if you prefer explicit imports, you can do import {describe, expect, test} from '@jest/globals'.

Source https://jestjs.io/docs/en/api

I'm dealing with a very similar issue, although in my case I was trying to share a single DB container (I'm using dockerode) that I spin up once before all tests and remove after to conserve the overhead of spinning a container for each suite.

Unfortunately for us, after going over a lot of documentation and Github issues my conclusion is that this is by design since Jest's philosophy is to run tests sandboxed and under that restriction, I totally get why they choose not to support this.

Specifically, for my use case I ended up spinning a container in a globalSetup script, tagging it with some unique identifier for the current test run (say, timestamp) and removing it at the end with a globalTeardown (that works since global steps can share state between them).

This looks roughly like:

const options: ContainerCreateOptions = {
Image: POSTGRES_IMAGE,
Tty: false,
HostConfig: {
    AutoRemove: true,
    PortBindings: {'5432/tcp': [{HostPort: `${randomPort}/tcp`}]}
},
Env: [`POSTGRES_DB=${this.env['DB_NAME']}`,
    `POSTGRES_USER=${this.env['DB_USERNAME']}`,
    `POSTGRES_PASSWORD=${this.env['DB_PASSWORD']}`]
};
options.Labels = { testContainer: `${CURRENT_TEST_TIMESTAMP}`};
let container = await this.docker.createContainer(options);
await container.start();

where this.env in my case is a .env file I preload based on the test.

To get the container port/ip (or whatever else I'm interested in) for my tests I use a custom envrironment that my DB-requiring tests use to expose the relevant information on a global variable (reminder: you can only put primitives and objects on global, not instances).

In your case, the requirement to pass a connection pool between suites is probably just not suited for jest since it will never let you pass around an instance between different suites (at least that's my understanding based on all of the links I shared). You can, however, try either:

• Put all tests that need the same connection pool into a single suite/file (not great but would answer your needs)
• Do something similar to what I suggested (setup DB once in global, construct connection pool in custom env and then at least each suite gets its own pool) that way you have a lot of code reuse for setup which is nice. Something similar is discussed here.

Miscalenous: I stumbled across testdeck which might answer your needs as well (setup an abstract test class with your connection pool and inherit it in all required tests) - I didn't try it so I don't know how it will behave with Jest, but when I was writing in Java that's how we used to achieve similar functionality with TestNG

It is not entirely clear what your goal is, but if you look at the documentation of jest.spyOn, you see that it takes a methodName as the second argument, not the method itself:

jest.spyOn(object, methodName)

This explains your error: you didn't give the function name, but the function itself. In this case, using jest.spyOn(services, 'iAmBatman') wouldn't work, since iAmBatman is not exported, and therefore services.iAmBatman is not defined.

Luckily, you don't need spyOn, as you can simply make a new mock function, and then inject that with rewire's __set__ as follows:

(note that I deleted the undefined service.someServiceCall in your first file, and fixed some typos and redundant imports)

// service.js

function iAmBatman() {
    return "Its not who I am underneath";
}

function makeACall() {
    return iAmBatman();
}

module.exports = {
    makeACall: makeACall
}

// service.test.js

const rewire = require('rewire');
const service = rewire('./service.js');

const mockDeepVoice = jest.fn(() => "But what I do that defines me")
service.__set__('iAmBatman', mockDeepVoice)

describe('service.js', () => {
    test('makeACall should call iAmBatman', () => {
        service.makeACall();
        expect(mockDeepVoice).toHaveBeenCalled();
    });
})

Another option would be to restructure your code with iAmBatman in a seperate module, and then mock the module import with Jest. See documentation of jest.mock.

According to the docs on jest.testTimeOut:

This only affects the test file from which this function is called.

The docs further suggest that:

If you want to set the timeout for all test files, a good place to do this is in setupFilesAfterEnv

Example from the docs:

i) Initialise setupFilesAfterEnv in jest.config.js:

module.exports = {
  setupFilesAfterEnv: ['./jest.setup.js'],
};

ii) Set timeout project-wide in jest.setup.js

jest.setTimeout(10000);

Sources:

https://jestjs.io/docs/en/jest-object.html#jestsettimeouttimeout
https://jestjs.io/docs/en/configuration#setupfilesafterenv-array

Works for me with the following settings.

// package.json

"jest": {
  "scriptPreprocessor": "preprocessor.js",
  "unmockedModulePathPatterns": [
    "react"
  ],
  "setupEnvScriptFile": "before_test.js"
}

// preprocessor.js

var ReactTools = require('react-tools');

module.exports = {
    process: function(src) {
        return ReactTools.transform(src);
    }
};

// before_test.js

React = require("react"); // Global React object

Try to add typescript extension in jest config :

module.exports = {
  roots: ['<rootDir>'],
  transform: {
    '^.+\\.ts?$': 'ts-jest'
  },
  testRegex: '(/__tests__/.*|(\\.|/)(test|spec))\\.ts?$',
  moduleFileExtensions: ['ts', 'js', 'json', 'node'],
  collectCoverage: true,
  clearMocks: true,
  coverageDirectory: "coverage",
};

And then load the jest config in your package.json test script :

"scripts": {
    "test": "jest --config ./jest.config.js",
    ...
  },

There are some alternative to accomplish this:

1. Add __mocks__ directory inside utils folder. See https://jestjs.io/docs/en/manual-mocks

utils/index.js

export const  getNumbers= () => [1, 2, 3, 4, 5];

->utils/__mocks__/index.js

export const  getNumbers= () => [3, 4];

jest.config.js

{ 
   "setupFilesAfterEnv": [
      "<rootDir>/jestSetup.js"
    ]
}

jestSetup.js

jest.mock("../utils"); // will apply to all tests

2. Add mock definition directly in jestSetup.js

jest.config.js

{ 
   "setupFilesAfterEnv": [
      "<rootDir>/jestSetup.js"
    ]
}

jestSetup.js

  jest.mock("../utils", () => ({
     getNumbers: () => [3, 4]
  }));

or create a file with mocks

mocks.js

  jest.mock("../utils", () => ({
     getNumbers: () => [3, 4]
  }));

jestSetup.js

  import './mocks.js'

If you don't want to use mocks on specific test, you can call:

jest.unmock('../utils')

See: https://jestjs.io/docs/en/jest-object#jestunmockmodulename

Per discussion here: https://github.com/DevExpress/testcafe/issues/1537

You can exclude the end to end test files that TestCafe looks for in your local tsconfig.json file.

It's a hack but it worked for me.

Example tsconfig.json file, assuming all your end to end test modules are under test/e2e:

{
  "compilerOptions": {
    "target": "esnext",
    "module": "esnext",
    "sourceMap": true,
    "strict": true,
    "moduleResolution": "node",
    "allowSyntheticDefaultImports": true
  },
  "exclude": [
    "test/e2e"
  ]
}

As suggested at https://github.com/vuejs/vue-test-utils-next/issues/194#issuecomment-695333180

Changing the shim to the below fixes the issue.

declare module '*.vue' {
  import { DefineComponent } from 'vue';
  const component: DefineComponent;
  export default component;
}