Unit testing services in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this NestJS service unit test?

Consider this simple NestJS service and its unit test. What will the test output be when run?

NestJS

import { Injectable } from '@nestjs/common';

@Injectable()
export class MathService {
  double(value: number): number {
    return value * 2;
  }
}

// Test file
import { Test, TestingModule } from '@nestjs/testing';
import { MathService } from './math.service';

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

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

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

  it('should return double the input', () => {
    expect(service.double(4)).toBe(8);
  });
});

A The test throws a runtime error due to missing dependencies.

B The test fails because the service is not mocked.

C The test fails because the expected value is incorrect.

D The test passes successfully.

💡 Hint

Think about how the service is provided and used in the test module.

The MathService is provided directly in the testing module. The double method returns the input multiplied by 2, so calling double(4) returns 8, matching the expectation. No mocking or dependencies are needed here.

🔧 Debug

intermediate

Why does this NestJS service unit test fail with a TypeError?

Look at this unit test for a NestJS service. Why does it fail with a TypeError: Cannot read property 'getData' of undefined?

NestJS

import { Injectable } from '@nestjs/common';

@Injectable()
export class DataService {
  getData(): string {
    return 'data';
  }
}

// Test file
import { Test, TestingModule } from '@nestjs/testing';
import { DataService } from './data.service';

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

  beforeEach(() => {
    service = new DataService();
  });

  it('should return data string', () => {
    expect(service.getData()).toBe('data');
  });

  it('should call getData method', () => {
    const spy = jest.spyOn(service, 'getData');
    service.getData();
    expect(spy).toHaveBeenCalled();
  });
});

A The spy is created after the method call, so it never detects the call.

B The service instance is created manually, so jest.spyOn cannot spy on it properly.

C The service is not injected via TestingModule, so dependencies are missing causing the error.

D The service method getData is not defined, causing the TypeError.

💡 Hint

Check the order of spy creation and method call.

The spy is created after the method call, so it does not detect the call. To fix, create the spy before calling the method.

📝 Syntax

advanced

Which option correctly mocks a dependency in a NestJS service unit test?

You have a NestJS service that depends on another service. Which test setup correctly mocks the dependency?

NestJS

import { Injectable } from '@nestjs/common';

@Injectable()
export class UserService {
  constructor(private readonly authService: AuthService) {}

  isUserAuthenticated(userId: string): boolean {
    return this.authService.validateUser(userId);
  }
}

// AuthService interface
export class AuthService {
  validateUser(userId: string): boolean {
    return true;
  }
}

// Test file snippet
import { Test, TestingModule } from '@nestjs/testing';
import { UserService } from './user.service';
import { AuthService } from './auth.service';

A providers: [UserService, { provide: AuthService, useClass: AuthService }]

B providers: [UserService, { provide: AuthService, useValue: { validateUser: () => true } }]

C providers: [UserService, { provide: AuthService, useFactory: () => ({ validateUser: () => true }) }]

D providers: [UserService, { provide: AuthService, useValue: { validateUser: () => false } }]

💡 Hint

Mocking with useValue allows you to replace methods with your own implementations.

Option B correctly mocks AuthService by providing a useValue object with a validateUser method returning true. This allows controlled testing of UserService without calling the real AuthService.

❓ state_output

advanced

What is the value of 'result' after this NestJS service test runs?

Given this service and test, what will be the value of the variable 'result' after the test runs?

NestJS

import { Injectable } from '@nestjs/common';

@Injectable()
export class CounterService {
  private count = 0;

  increment(): number {
    return ++this.count;
  }

  reset(): void {
    this.count = 0;
  }
}

// Test file
import { Test, TestingModule } from '@nestjs/testing';
import { CounterService } from './counter.service';

describe('CounterService', () => {
  let service: CounterService;
  let result: number;

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

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

  it('increments and resets count', () => {
    service.increment();
    service.increment();
    service.reset();
    result = service.increment();
  });
});

A 2

B 3

C 1

D 0

💡 Hint

Think about how the reset method affects the count before the last increment.

The count is incremented twice (count=2), then reset to 0, then incremented once more, so result is 1.

🧠 Conceptual

expert

Which statement best describes the role of TestingModule in NestJS unit tests?

In NestJS unit testing, what is the main purpose of using the TestingModule?

A It creates a lightweight module to provide and inject dependencies for isolated testing of components or services.

B It automatically mocks all dependencies of a service without manual configuration.

C It replaces the need for Jest or other testing frameworks by handling assertions internally.

D It compiles the entire application to run integration tests with real database connections.

💡 Hint

Think about how NestJS manages dependencies during tests.

TestingModule allows you to create a test-specific module that provides and injects only the dependencies needed for the test, enabling isolated unit testing.