Test process.env with Jest

I have an application that depends on environmental variables like:

const APP_PORT = process.env.APP_PORT || 8080;

And I would like to test that for example:

• APP_PORT can be set by a Node.js environment variable.
• or that an Express.js application is running on the port set with process.env.APP_PORT

How can I achieve this with Jest? Can I set these process.env variables before each test or should I mock it somehow maybe?

The way I did it can be found in this Stack Overflow question.

It is important to use resetModules before each test and then dynamically import the module inside the test:

describe('environmental variables', () => {
  const OLD_ENV = process.env;

  beforeEach(() => {
    jest.resetModules() // Most important - it clears the cache
    process.env = { ...OLD_ENV }; // Make a copy
  });

  afterAll(() => {
    process.env = OLD_ENV; // Restore old environment
  });

  test('will receive process.env variables', () => {
    // Set the variables
    process.env.NODE_ENV = 'dev';
    process.env.PROXY_PREFIX = '/new-prefix/';
    process.env.API_URL = 'https://new-api.com/';
    process.env.APP_PORT = '7080';
    process.env.USE_PROXY = 'false';

    const testedModule = require('../../config/env').default

    // ... actual testing
  });
});

If you look for a way to load environment values before running the Jest look for the answer below. You should use setupFiles for that.

Jest's setupFiles is the proper way to handle this, and you need not install dotenv, nor use an .env file at all, to make it work.

jest.config.js:

module.exports = {
  setupFiles: ["<rootDir>/.jest/setEnvVars.js"]
};

.jest/setEnvVars.js:

process.env.MY_CUSTOM_TEST_ENV_VAR = 'foo'

That's it.

Another option is to add it to the jest.config.js file after the module.exports definition:

process.env = Object.assign(process.env, {
  VAR_NAME: 'varValue',
  VAR_NAME_2: 'varValue2'
});

This way it's not necessary to define the environment variables in each .spec file and they can be adjusted globally.

In ./package.json:

"jest": {
  "setupFiles": [
    "<rootDir>/jest/setEnvVars.js"
  ]
}

In ./jest/setEnvVars.js:

process.env.SOME_VAR = 'value';

You can use the setupFiles feature of the Jest configuration. As the documentation said that,

> A list of paths to modules that run some code to configure or set up > the testing environment. Each setupFile will be run once per test > file. Since every test runs in its own environment, these scripts will > be executed in the testing environment immediately before executing > the test code itself.

1. npm install dotenv dotenv that uses to access environment variable.

2. Create your .env file to the root directory of your application and add this line into it:

   #.env
   APP_PORT=8080
   

3. Create your custom module file as its name being someModuleForTest.js and add this line into it:

   // someModuleForTest.js
   require("dotenv").config()
   

4. Update your jest.config.js file like this:

   module.exports = {
     setupFiles: ["./someModuleForTest"]
   }
   

5. You can access an environment variable within all test blocks.

   test("Some test name", () => {
     expect(process.env.APP_PORT).toBe("8080")
   })
   

Expanding a bit on Serhan C.'s answer...

According to the blog post How to Setup dotenv with Jest Testing - In-depth Explanation, you can include "dotenv/config" directly in setupFiles, without having to create and reference an external script that calls require("dotenv").config().

I.e., simply do

module.exports = {
    setupFiles: ["dotenv/config"]
}

In my opinion, it's much cleaner and easier to understand if you extract the retrieval of environment variables into a utility (you probably want to include a check to fail fast if an environment variable is not set anyway), and then you can just mock the utility.

// util.js
exports.getEnv = (key) => {
    const value = process.env[key];
    if (value === undefined) {
      throw new Error(`Missing required environment variable ${key}`);
    }
    return value;
};

// app.test.js
const util = require('./util');
jest.mock('./util');

util.getEnv.mockImplementation(key => `fake-${key}`);

test('test', () => {...});

In test file:

const APP_PORT = process.env.APP_PORT || 8080;

In the test script of ./package.json:

"scripts": {
   "test": "jest --setupFiles dotenv/config",
 }

In ./env:

APP_PORT=8080

Depending on how you can organize your code, another option can be to put the environment variable within a function that's executed at runtime.

In this file, the environment variable is set at import time and requires dynamic requires in order to test different environment variables (as described in this answer):

const env = process.env.MY_ENV_VAR;

const envMessage = () => `MY_ENV_VAR is set to ${env}!`;

export default myModule;

In this file, the environment variable is set at envMessage execution time, and you should be able to mutate process.env directly in your tests:

const envMessage = () => {
  const env = process.env.MY_VAR;
  return `MY_ENV_VAR is set to ${env}!`;
}

export default myModule;

Jest test:

const vals = [
  'ONE',
  'TWO',
  'THREE',
];

vals.forEach((val) => {
  it(`Returns the correct string for each ${val} value`, () => {
    process.env.MY_VAR = val;

    expect(envMessage()).toEqual(...

you can import this in your jest.config.js

require('dotenv').config()

this work for me

Building on top of @jahller's answer.

I made it responsive so you don't need to keep the files in sync as things change.

Put this at the bottom of your jest.config.js file.

const arr = require('fs')
  .readFileSync('.env', 'utf8')
  .split('\n')
  .reduce((vars, i) => {
    const [variable, value] = i.split('=')
    vars[variable] = value
    return vars
  }, {})

process.env = Object.assign(process.env, arr)

It reads the contents of your .env file, splits every new line and reduces it all back down to an object where you then assign it to process.env

OR

just use dotenv in jest.setup.js 路‍♂️

All the above methods work if you're using require("dotenv").config within the jest.config.js file, a NodeJS application without TypeScript such as what Jialx or Henry Tipantuna has suggested.

But if you're using ts-jest and within the jest.config.ts file.

import dotenv from "dotenv"
dotenv.config()

/* config options below */

When using Typescript the following works for me:

in root: jest.config.js

/* eslint-disable @typescript-eslint/no-var-requires */
const { pathsToModuleNameMapper } = require('ts-jest');

const { compilerOptions } = require('./tsconfig.paths.json');

module.exports = {
  // [...]
  moduleNameMapper: pathsToModuleNameMapper(compilerOptions.paths, { prefix: '<rootDir>/' }),
};
process.env = Object.assign(process.env, {
  env_name: 'dev',
  another_var: 'abc123',
});

I think you could try this too:

const currentEnv = process.env;
process.env = { ENV_NODE: 'whatever' };

// test code...

process.env = currentEnv;

This works for me and you don't need module things