Run globalSetup and globalTeardown only once in watch mode

🚀 Feature Proposal

Hey there 👋 I’d like to propose running globalSetup and globalTeardown functions only once before actually entering watch mode and then after exiting it. I can’t think of any side-effects atm, it could be opt-in/out configuration flag if there’s any.

Motivation

Global setup hooks are great to prepare performance-wise expensive environment, and it would be helpful to run it just once before starting and stopping Jest. Currently Jest re-runs whole global setup/teardown on each change detected in watch mode.

Example

puppeteer and any other expensive server-kind processes, e.g. webpack-serve are good examples. Having single instance running in background during --watch mode would be amazing performance boost.

[samwyma]

I’ve just faced this problem and noticed that the first argument to both globalSetup and globalTeardown comes with a watch and watchAll property. You can check if either property is true and then not do your teardown (your setup function has to cache it’s result so it doesn’t execute more than once). You can then use the ‘signal-exit’ npm package to do proper teardown.

It’s a bit of a work-around, but I’m running a test elasticsearch cluster locally using this method and it saves a bunch of time in not setting that up each test run

[samwyma]

Yeah, the above isn’t exactly what you need.

Here’s pretty much the setup I’m using for elasticsearch (but some other database or service should work too):

// setup.js
const { startServer, ES_PORT } = require("./elasticsearch");
module.exports = async () => {
  await startServer();

  process.env.AWS_ES_ENDPOINT = `http://localhost:${ES_PORT}`;
}

// teardown.js
const { destroyCluster } = require("./elasticsearch");

module.exports = async function(opts) {
  if (!opts.watch && !opts.watchAll) {
    await destroyCluster();
  }
};

// jest.config.js
module.exports = {
  globalSetup: "<rootDir>/setup.js",
  globalTeardown: "<rootDir>/teardown.js",
};

// elasticsearch.js
const onExit = require("signal-exit");

let clusterSetupPromise;
async function setupServer() {
  let cluster = createCluster(); //This uses the package esvm

  onExit(function() {
    cluster.shutdown().then(function() {
      process.exit();
    });
  });

  // ...setup elasticsearch...

  runningCluster = cluster;

  return cluster;
}

module.exports = {
  async startServer() {
    if (clusterSetupPromise) {
      return clusterSetupPromise;
    } else {
      clusterSetupPromise = setupServer();
      return clusterSetupPromise;
    }
  },
  async destroyCluster() {
    if (runningCluster) {
      await runningCluster.shutdown();
      clusterSetupPromise = null;
      runningCluster = null;
    }
  }
};

I apologise that the example is somewhat verbose, but there are a few key things to it:

• Your setup script has to cache the result such that it only executes once, even if it’s called multiple times (in this example this is done by setting the clusterSetupPromise variable)
• Use the signal-exit module to ensure your service is always destroyed. I’m not sure whether this will work in all cases, but it’s working well for me
• Your teardown script is where you check for the watch flags. That way, it’ll not teardown anything when you’re doing jest --watch, but a normal run of jest will tear everything down fine (I suppose that, since I’m using signal-exit I don’t need the teardown script at all, but I figure it makes it a bit clearer what’s going on)

I have to admit this seems like a bit of a hack. I’d advocate for something like a flag to be set on the options given to the setup/teardown the first time setup is run and the last time teardown will be run. Not sure how possible this is, but it would make my code clearer.

But, for the purposes of just getting on with what you’re doing, this is working well for me 😃.

Hopefully this helps! Feel free to ask any questions