How to test a nestjs service by passing in a ConfigService with custom values?

Question

I've created a service, and the module for it looks like this:

launchdarkly.module.ts

@Module({
  providers: [LaunchdarklyService],
  exports: [LaunchdarklyService],
  imports: [ConfigService],
})
export class LaunchdarklyModule {}

(this service/module is to let the application use LaunchDarkly feature-flagging)

I'm happy to show the service-implementation if you'd like, but to keep this question shorter I skipped it. The important point is that this service imports the ConfigService (which it uses to grab the LaunchDarkly SDK key).

But how can I test the Launchdarkly service? It reads a key from ConfigService so I want to write tests where ConfigService has various values, but after hours of trying I can't figure out how to configure ConfigService in a test.

Here's the test:

launchdarkly.service.spec.ts

describe('LaunchdarklyService', () => {
  let service: LaunchdarklyService;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [LaunchdarklyService],
      imports: [ConfigModule],
    }).compile();

    service = module.get<LaunchdarklyService>(LaunchdarklyService);
  });

  it("should not create a client if there's no key", async () => {
    // somehow I need ConfigService to have key FOO=undefined for this test
    expect(service.client).toBeUndefined();
  });

  it("should create a client if an SDK key is specified", async () => {
    // For this test ConfigService needs to specify FOO=123
    expect(service.client).toBeDefined();
  });
})

I'm open for any non-hacky suggestions, I just want to feature-flag my application!

Jay McDoniel · Accepted Answer · 2021-01-09T00:05:39.237

Assuming the LaunchdarklyService needs the ConfigService and that is injected into the constructor, you can provide a mock variation of the ConfigService by using a Custom Provider to give back the custom credentials you need. For example, a mock for your test could look like

describe('LaunchdarklyService', () => {
  let service: LaunchdarklyService;
  let config: ConfigService;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [LaunchdarklyService, {
        provide: ConfigService,
        useValue: {
          get: jest.fn((key: string) => {
            // this is being super extra, in the case that you need multiple keys with the `get` method
            if (key === 'FOO') {
              return 123;
            }
            return null;
          })
        }
      ],
    }).compile();

    service = module.get<LaunchdarklyService>(LaunchdarklyService);
    config = module.get<ConfigService>(ConfigService);
  });

  it("should not create a client if there's no key", async () => {
    // somehow I need ConfigService to have key FOO=undefined for this test
    // we can use jest spies to change the return value of a method
    jest.spyOn(config, 'get').mockReturnedValueOnce(undefined);
    expect(service.client).toBeUndefined();
  });

  it("should create a client if an SDK key is specified", async () => {
    // For this test ConfigService needs to specify FOO=123
    // the pre-configured mock takes care of this case
    expect(service.client).toBeDefined();
  });
})

Thanks! The `jest.spyOn(config, 'get').mockReturnValueOnce` results in `Error: Cannot spyOn on a primitive value; undefined given`, but the core `useValue:{get: ...` pattern works. — Jon Lauridsen, Jan 08 '21 at 23:57
Oh whoops, forgot to add a line in the `beforeEach`. I'll make an edit for that — Jay McDoniel, Jan 09 '21 at 00:05
I was just wondering we can't reach the actual ConfigService ? — katmanco, Jun 28 '22 at 09:29
@katmanco you could use the actual `ConfigService`, but I find using mocks more reliable for unit tests — Jay McDoniel, Jun 28 '22 at 17:26

score 4 · Answer 2 · answered May 13 '22 at 21:51

Instead of providing ConfigService you need to import the ConfigModule with mocked data. As an example

imports: [CommonModule,ConfigModule.forRoot({
                ignoreEnvVars: true,
                ignoreEnvFile: true,
                load: [() => ({ IntersectionOptions: { number_of_decimal_places: '3' }})],
            })],

score 0 · Answer 3 · answered May 04 '23 at 10:34

I've done this by overwriting the ConfigService provider as follows:

import { CONFIGURATION_TOKEN } from '@nestjs/config/dist/config.constants';
import { Inject, Injectable, Optional } from '@nestjs/common';

@Injectable()
export class TestConfigService {
  private initialConfig: Record<string, any>;
  constructor(
    @Optional()
    @Inject(CONFIGURATION_TOKEN)
    private internalConfig: Record<string, any> = {},
  ) {
    this.initialConfig = internalConfig;
  }

  get(key: string, def: any) {
    const result = findByPath(this.internalConfig, key);
    return result || def;
  }

  set(key: string, val: any) {
    assignRawDataTo(this.internalConfig, { [key]: val });
  }

  reset() {
    this.internalConfig = this.initialConfig;
  }
}

The findByPath and assignRawDataTo are some utility functions to get and set data to the internalConfig.

Now you can setup your testing module as below:

return Test.createTestingModule({
    imports: [
        ConfigModule.forRoot({
            load: [
                 () => import('./test.config').then((module) => module.default),
             ],
             isGlobal: true,
         }),
      ],
}).overrideProvider(ConfigService)
    .useClass(TestConfigService);

score 0 · Answer 4 · answered Aug 20 '23 at 00:45

You can get a cleaner syntax using the forFeature method provided by ConfigModule.

It accepts an async function that needs to return an object (in your case, your Env object).

The advantage of using the forFeature method is that you can register a partial object so you won't need to worry about other variables (or doing a lot of ifs).

beforeEach(async () => {
  const moduleRef = await Test.createTestingModule({
    imports: [
      ConfigModule.forFeature(async () => ({
        ANY_KEY_YOU_WANT: 'Any_Value'
      }))
    ],
    providers: [AnyService]
  }).compile()

  service = moduleRef.get<AnyService>(AnyService)
})

How to test a nestjs service by passing in a ConfigService with custom values?

4 Answers4

Linked