How to Mock process.env in Jest

Nizar Jailane

Jan 15, 2023 • 4 min read

Learn how to mock environment variables in a NodeJs project while implementing Jest tests that depend on environmental variables.

🌐

You can find the source code at the end of the post.

What Is process.env?
Why Mock process.env?
Mock process.env in Jest Tests
Conclusion

What Is process.env?

In NodeJs, process.env is basically a global object that holds the state of the system's environmental variables, being available at runtime to our application.

Why Mock process.env?

Most of the time when developing an application we don't really need the process.env variable or it's properties values, but in some parts of the application we do need them, for example if we need to grab the app's version in runtime or the app's port to start a server of some kind.

To make sure that the app behaves the way we want it to, we need to test it thoroughly and this mean we need to test the parts of the app that rely on this object and this is the case where we need to mock process.env to test different cases the app can run into.

Mock process.env in Jest Tests

For the sake of this post, we will have a very simple NodeJs app that has one file with two functions; appEnv and appVersion which will print out the app's env and version respectively.

Create a file named app.js and copy the following content into it:

function appEnv() {
  const currentEnv = process.env.NODE_ENV

  if (!currentEnv) {
    throw new Error('NODE_ENV is not defined')
  }

  return `App is running on ${currentEnv} environment`
}

function appVersion() {
  const currentAppVersion = process.env.APP_VERSION

  if (!currentAppVersion) {
    throw new Error('APP_VERSION is not defined')
  }

  return `App's version is ${currentAppVersion}`
}

module.exports = { appEnv, appVersion }

As you can see, we only print out the values here, and if the value is undefined we throw an error, pretty simple.

Now that we got this out of the way, we can start.
Mocking process.env is actually pretty simple, but first we need to know where we can set those values for our tests after that we will mock them in our tests.

App Wide Mocking

The default values for every test can be set in one of Jest's setup files, when this is done, the setup file will be executed before each test file.

To setup Jest setup-files execute the following steps:

First, create a jest.config.js file in the root of the directory (besides package.json).
Content of the config file would be:

module.exports = {
  setupFiles: ['<rootDir>/jest-setup.js'],
}

Then, create a setup-jest.js file in the root of the directory too.
Content of the file should be our default values:

process.env.NODE_ENV = 'local'
process.env.APP_VERSION = 'v0.1'

Now we did setup the default values for the whole app's tests env, Let's mock them!

First, create a test file named app.test.js next to app.js file.
Then we can start our tests in a dedicated test suite (App Tests - Default ENV Values) as you can see below:

const { appEnv, appVersion } = require('./app')

describe('App Tests - Default ENV Values', () => {
  const originalEnv = process.env

  afterEach(() => {
    // Reset process.env after each test case
    process.env = originalEnv
  })

  describe('APP_VERSION Tests', () => {
    it('should return default value when APP_VERSION', () => {
      const result = appVersion()

      expect(result).toBe(`App's version is v0.1`)
    })

    it('should throw an error if APP_VERSION is not defined', () => {
      process.env = { APP_VERSION: undefined }
      // OR process.env = {}

      expect(appVersion).toThrow('APP_VERSION is not defined')
    })
  })

  describe('NODE_ENV Tests', () => {
    it('should return default value when NODE_ENV', () => {
      const result = appEnv()

      expect(result).toBe('App is running on local environment')
    })

    it('should throw an error if NODE_ENV is not defined', () => {
      process.env = { NODE_ENV: undefined }
      // OR process.env = {}

      expect(appEnv).toThrow('NODE_ENV is not defined')
    })
  })
})

Now let's talk about the above tests, first we created a test group named App Tests - Default ENV Values which contains two other groups APP_VERSION Tests and NODE_ENV Tests.

Before we dive into the tests, notice we have a variable to hold the original env object's value, that's important because in some tests we do override the process.env properties and we need to reset it to the original value after each test case.

Our first test case, in both groups, ensures that our env variables are correct and picked up from the setup file we had earlier.

Second test case again in both groups is different, we override the process.env value to set undefined values for our properties (NODE_ENV & APP_VERSION) and those tests should ensure that our code will throw an error when those values are missing from env variable.

Per Test File Mocking

Now since we mocked the app-wide env variable, let's find out how to mock the env variables in a test file/suite in case we don't have a setup file or we just want to test different values other than the values in the setup file.

In the same app.test.js file, we can add another group named App Tests - Manual ENV Values right next to App Tests - Default ENV Values (just to keep the test file clean and clear).

describe('App Tests - Manual ENV Values', () => {
  const originalEnv = process.env

  beforeEach(() => {
    // Override process.env object before each test case:
    process.env = {
      NODE_ENV: 'prod',
      APP_VERSION: 'v1.0',
    }
    // By default the value of process.env.NODE_ENV is test when running tests with jest
  })

  afterEach(() => {
    // Reset process.env value after each test case
    process.env = originalEnv
  })

  describe('APP_VERSION Tests', () => {
    it('should return correct value when APP_VERSION is defined', () => {
      const result = appVersion()

      expect(result).toBe(`App's version is v1.0`)
    })

    it('should throw an error if APP_VERSION is not defined', () => {
      process.env = { APP_VERSION: undefined }
      // OR process.env = {}

      expect(appVersion).toThrow('APP_VERSION is not defined')
    })
  })

  describe('NODE_ENV Tests', () => {
    it('should return correct value when NODE_ENV is defined', () => {
      const result = appEnv()

      expect(result).toBe('App is running on prod environment')
    })

    it('should throw an error if NODE_ENV is not defined', () => {
      process.env = { NODE_ENV: undefined }
      // OR process.env = {}

      expect(appEnv).toThrow('NODE_ENV is not defined')
    })
  })
})

Again, let's talk about our new test group.

Actually, not much changed, In the new test group we mock or set custom values for the process.env object before each test case which allows us to have more control over the values in our test file instead of the globally set variables.

Conclusion

At last, in this post we saw how we can set our env variables globally while testing our application along with a per-test mock of the env object.

Table of contents