Mocking .env variables with Vitest

2 min read 05-10-2024

Mocking .env Variables with Vitest: Keeping Your Tests Clean and Consistent

Testing your code is essential for building robust and reliable applications. However, when dealing with environment variables stored in a .env file, testing can become tricky. This is because your test environment might not have the same configuration as your production environment, leading to inconsistent test results.

Let's explore how to effectively mock .env variables within your Vitest tests, ensuring your tests are reliable and independent of your environment.

The Scenario:

Imagine you have a simple Node.js application that reads an API key from a .env file.

// api.js
import dotenv from 'dotenv';

dotenv.config();

const apiKey = process.env.API_KEY;

// ... rest of your code

When testing this code, you don't want to rely on an actual .env file or your environment variables. You want to control the value of API_KEY within your tests. Here's where Vitest's mocking capabilities come in handy.

Mocking with Vitest:

Vitest offers a powerful vitest.mock function for mocking modules and functions. Let's see how to use it to mock our .env variables:

// api.test.js
import { describe, expect, it, vi } from 'vitest';
import dotenv from 'dotenv';

describe('API Module', () => {
  it('should use the correct API key', () => {
    // Mock process.env.API_KEY
    vi.mock('dotenv', () => ({
      config: () => {
        process.env.API_KEY = 'TEST_API_KEY';
      }
    }));

    // Import your module
    import api from './api';

    expect(api.apiKey).toBe('TEST_API_KEY'); 
  });
});

In this example, we use vi.mock('dotenv') to overwrite the dotenv module. When our code imports dotenv and calls dotenv.config(), our mock implementation is executed. The mock implementation sets the value of process.env.API_KEY to 'TEST_API_KEY', ensuring our test uses the mocked value.

Key Points to Remember:

Isolation: By mocking .env variables, you guarantee your tests are isolated from your actual environment, preventing unexpected behavior.
Consistency: Your tests will always run with the same mocked values, ensuring consistent results across different environments.
Flexibility: Vitest mocks give you complete control over the values used in your tests, making it easier to test different scenarios.

Additional Tips:

Clear Naming: Use descriptive names for your mocked values to clearly indicate their purpose within the test.
Cleanup: After each test, consider resetting your mocked environment variables to avoid potential conflicts with other tests.
Vitest's Features: Explore other Vitest features like vitest.fn() for mocking functions and vitest.spy() for monitoring function calls.

Conclusion:

Mocking .env variables with Vitest gives you the power to build reliable, isolated, and consistent tests. This approach helps you gain confidence in your code, ensuring its stability and functionality across diverse environments.

By leveraging the flexible mocking capabilities of Vitest, you can streamline your testing workflow and build robust, reliable applications.

Mocking .env variables with Vitest