Unit testing controllers in NestJS

Introduction

Unit testing controllers helps check if each part of your app that handles user requests works correctly on its own. It finds mistakes early and keeps your app reliable.

When you want to check if a controller returns the right response for a request.

When you want to test controller logic without running the whole app.

When you want to catch bugs in how controllers handle data or call services.

When you want to make sure changes in code don't break controller behavior.

When you want to write automated tests to save time in the future.

Syntax

NestJS

describe('ControllerName', () => {
  let controller: ControllerName;
  let service: ServiceName;

  beforeEach(async () => {
    const module = await Test.createTestingModule({
      controllers: [ControllerName],
      providers: [
        {
          provide: ServiceName,
          useValue: { methodName: jest.fn() },
        },
      ],
    }).compile();

    controller = module.get<ControllerName>(ControllerName);
    service = module.get<ServiceName>(ServiceName);
  });

  it('should do something', () => {
    // test code here
  });
});

Use Test.createTestingModule to set up a test environment for your controller.

Mock services with useValue to isolate controller tests from real service logic.

Examples

This example tests a findAll method in a CatsController. The service is mocked to return a fixed list.

NestJS

describe('CatsController', () => {
  let controller: CatsController;
  let service: CatsService;

  beforeEach(async () => {
    const module = await Test.createTestingModule({
      controllers: [CatsController],
      providers: [
        {
          provide: CatsService,
          useValue: { findAll: jest.fn().mockReturnValue(['cat1', 'cat2']) },
        },
      ],
    }).compile();

    controller = module.get<CatsController>(CatsController);
    service = module.get<CatsService>(CatsService);
  });

  it('should return an array of cats', () => {
    expect(controller.findAll()).toEqual(['cat1', 'cat2']);
  });
});

This example tests a create method that adds a user. The service mock returns the user with an ID.

NestJS

describe('UsersController', () => {
  let controller: UsersController;
  let service: UsersService;

  beforeEach(async () => {
    const module = await Test.createTestingModule({
      controllers: [UsersController],
      providers: [
        {
          provide: UsersService,
          useValue: { createUser: jest.fn().mockImplementation(user => ({ id: 1, ...user })) },
        },
      ],
    }).compile();

    controller = module.get<UsersController>(UsersController);
    service = module.get<UsersService>(UsersService);
  });

  it('should create a user', () => {
    const userDto = { name: 'Alice' };
    expect(controller.create(userDto)).toEqual({ id: 1, name: 'Alice' });
  });
});

Sample Program

This test checks two controller methods: findAll returns a list of books, and findOne returns a single book by id. The service is mocked to return fixed values.

NestJS

import { Test } from '@nestjs/testing';
import { BooksController } from './books.controller';
import { BooksService } from './books.service';

describe('BooksController', () => {
  let controller: BooksController;
  let service: BooksService;

  beforeEach(async () => {
    const module = await Test.createTestingModule({
      controllers: [BooksController],
      providers: [
        {
          provide: BooksService,
          useValue: {
            findAll: jest.fn().mockReturnValue(['Book A', 'Book B']),
            findOne: jest.fn().mockImplementation(id => `Book ${id}`),
          },
        },
      ],
    }).compile();

    controller = module.get<BooksController>(BooksController);
    service = module.get<BooksService>(BooksService);
  });

  it('should return all books', () => {
    expect(controller.findAll()).toEqual(['Book A', 'Book B']);
  });

  it('should return one book by id', () => {
    expect(controller.findOne('A')).toBe('Book A');
  });
});

Important Notes

Always mock services to keep controller tests focused and fast.

Use jest.fn() to create mock functions and control their return values.

Run tests often to catch errors early and keep your code healthy.

Summary

Unit testing controllers checks if they handle requests correctly by themselves.

Mock services to isolate controller logic from other parts.

Use NestJS testing tools like Test.createTestingModule and Jest mocks.

Practice

1. What is the main purpose of unit testing a controller in NestJS?

easy

A. To verify the controller handles requests correctly without depending on other parts

B. To test the database connection and queries

C. To check the UI rendering of the application

D. To measure the performance of the entire application

Solution

1. Step 1: Understand the role of a controller

   Controllers handle incoming requests and return responses, so testing them focuses on this behavior.

2. Step 2: Identify what unit testing isolates

   Unit testing isolates the controller from other parts like services or databases to test its logic alone.

3. Final Answer:

   To verify the controller handles requests correctly without depending on other parts -> Option A

4. Quick Check:

   Unit testing controller logic = To verify the controller handles requests correctly without depending on other parts [OK]

Hint: Controllers handle requests; test them isolated from services [OK]

Common Mistakes:

• Confusing unit tests with integration tests
• Testing database or UI in controller unit tests
• Ignoring mocking dependencies

2. Which of the following is the correct way to create a testing module for a controller in NestJS?

easy

A. const module = Test.createModule({ providers: [MyController] });

B. const module = new Module({ controllers: [MyController] });

C. const module = await Test.createTestingModule({ controllers: [MyController] }).compile();

D. const module = await Test.createTestingModule({ services: [MyController] }).compile();

Solution

1. Step 1: Recall NestJS testing syntax

   Use Test.createTestingModule with a config object specifying controllers or providers, then compile it.

2. Step 2: Identify correct property for controllers

   The property to register controllers is 'controllers', not 'services' or 'providers' for controllers.

3. Final Answer:

   const module = await Test.createTestingModule({ controllers: [MyController] }).compile(); -> Option C

4. Quick Check:

   Use controllers array in createTestingModule = const module = await Test.createTestingModule({ controllers: [MyController] }).compile(); [OK]

Hint: Use controllers: [] inside Test.createTestingModule [OK]

Common Mistakes:

• Using 'services' instead of 'controllers' key
• Forgetting to await compile()
• Using new Module() instead of Test.createTestingModule

3. Given this controller method and test snippet, what will result be?

class MyController {
  getHello() {
    return 'Hello World!';
  }
}

// Test snippet
const controller = new MyController();
const result = controller.getHello();

medium

A. null

B. undefined

C. An error because getHello is async

D. 'Hello World!'

Solution

1. Step 1: Analyze the controller method

   The method getHello returns the string 'Hello World!' synchronously.

2. Step 2: Check the test call

   Calling getHello() directly returns the string without errors or async behavior.

3. Final Answer:

   'Hello World!' -> Option D

4. Quick Check:

   Direct method call returns string = 'Hello World!' [OK]

Hint: Direct call returns method's return value immediately [OK]

Common Mistakes:

• Assuming async behavior without async keyword
• Expecting undefined if not mocked
• Confusing method call with property access

4. What is wrong with this unit test for a NestJS controller?

describe('MyController', () => {
  let controller: MyController;

  beforeEach(() => {
    controller = new MyController();
  });

  it('should return greeting', () => {
    expect(controller.getHello()).toBe('Hello World!');
  });
});

medium

A. The controller is not created using Test.createTestingModule

B. The test does not mock the service dependency

C. The test is missing async keyword

D. The expect statement uses toBe instead of toEqual

Solution

1. Step 1: Check controller instantiation

   Creating controller directly is allowed but only if it has no dependencies.

2. Step 2: Identify missing mocking

   If the controller depends on a service, it must be mocked to isolate controller logic.

3. Final Answer:

   The test does not mock the service dependency -> Option B

4. Quick Check:

   Missing mocks for dependencies = The test does not mock the service dependency [OK]

Hint: Always mock services when testing controllers with dependencies [OK]

Common Mistakes:

• Assuming direct instantiation is always wrong
• Forgetting to mock injected services
• Confusing toBe and toEqual for strings

5. You want to unit test a NestJS controller method that calls a service method returning a promise. Which approach correctly mocks the service to test the controller method synchronously?

hard

A. Mock the service method with jest.fn().mockResolvedValue(value) and await the controller method in the test

B. Mock the service method with jest.fn().mockReturnValue(value) without async/await

C. Call the real service method without mocking to test actual behavior

D. Mock the service method with jest.fn().mockImplementation(() => { throw new Error(); })

Solution

1. Step 1: Understand async service method

   The service method returns a promise, so the mock must simulate a resolved promise.

2. Step 2: Use jest.fn().mockResolvedValue

   This creates a mock that returns a resolved promise with the given value, allowing the controller method to await it.

3. Step 3: Await controller method in test

   The test must await the controller method to handle the async call properly.

4. Final Answer:

   Mock the service method with jest.fn().mockResolvedValue(value) and await the controller method in the test -> Option A

5. Quick Check:

   Use mockResolvedValue and await async calls = Mock the service method with jest.fn().mockResolvedValue(value) and await the controller method in the test [OK]

Hint: Use mockResolvedValue for async mocks and await calls [OK]

Common Mistakes:

• Using mockReturnValue for async methods
• Not awaiting async controller methods
• Testing real service instead of mocking