Unit testing controllers in NestJS - Step-by-Step Execution

Concept Flow - Unit testing controllers

Write test case

↓

Setup testing module

↓

Inject controller

↓

Mock dependencies

↓

Call controller method

↓

Assert expected result

↓

Test passes or fails

This flow shows how a unit test for a NestJS controller is written, setting up the test module, injecting the controller, mocking dependencies, calling methods, and checking results.

Execution Sample

NestJS

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

  const mockCatsService = {
    findAll: jest.fn(),
  };

  beforeEach(async () => {
    const module = await Test.createTestingModule({
      controllers: [CatsController],
      providers: [{ provide: CatsService, useValue: mockCatsService }],
    }).compile();

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

  it('should return all cats', async () => {
    jest.spyOn(mockCatsService, 'findAll').mockResolvedValue(['cat1', 'cat2']);
    const result = await controller.findAll();
    expect(result).toEqual(['cat1', 'cat2']);
  });
});

This test sets up a NestJS testing module, injects the CatsController with a mocked CatsService, calls the findAll method, and checks the returned cats.

Execution Table

Step	Action	Evaluation	Result
1	Create testing module with CatsController and mockCatsService	Module created	Testing module ready
2	Get CatsController instance from module	Controller injected	controller variable assigned
3	Mock CatsService.findAll to return ['cat1', 'cat2']	Mock applied	findAll returns ['cat1', 'cat2']
4	Call controller.findAll()	Calls mocked service	Returns ['cat1', 'cat2']
5	Assert result equals ['cat1', 'cat2']	Check equality	Test passes

💡 Test completes after assertion; passes if result matches expected array

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
controller	undefined	CatsController instance	CatsController instance with mocked service	Result of findAll call pending	Result is ['cat1', 'cat2']
mockCatsService.findAll	undefined	undefined	Mocked to return ['cat1', 'cat2']	Returns ['cat1', 'cat2']	Returns ['cat1', 'cat2']

Key Moments - 3 Insights

Why do we mock the service instead of using the real one?

We mock the service to isolate the controller's behavior and avoid dependencies on external data or logic, as shown in step 3 of the execution_table.

How does the controller get the mocked service?

The mocked service is provided in the testing module setup (step 1), so when the controller is injected (step 2), it uses the mock instead of the real service.

What happens if the controller method returns a different result than expected?

The assertion in step 5 will fail, causing the test to fail, indicating a problem in the controller or mock setup.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'controller' after step 2?

A MockCatsService instance

B CatsController instance

C undefined

D Array of cats

💡 Hint

Check the variable_tracker row for 'controller' after Step 2

At which step is the CatsService.findAll method mocked?

A Step 3

B Step 2

C Step 4

D Step 5

💡 Hint

Look at the 'Action' column in execution_table for mocking

If the mock returned an empty array instead of ['cat1', 'cat2'], what would change in the execution_table?

A Step 5 assertion would pass

B Step 3 would fail

C Step 4 result would be [] instead of ['cat1', 'cat2']

D Controller would not be injected

💡 Hint

Check the 'Result' column for Step 4 and how it affects the assertion in Step 5

Concept Snapshot

Unit testing controllers in NestJS:
- Use Test.createTestingModule to set up test environment
- Provide controller and mock dependencies
- Inject controller instance
- Mock service methods with jest.spyOn
- Call controller methods and assert results
- Isolate controller logic from real services

Full Transcript

Unit testing controllers in NestJS involves creating a testing module that includes the controller and mocks of its dependencies. The controller is injected from this module. Service methods are mocked to control their output. The controller method is called, and its output is checked against expected results. This isolates the controller's logic and ensures it behaves correctly without relying on real services or databases.