1---
2title: Use Testing Module for Unit Tests
3impact: HIGH
4impactDescription: Enables proper isolated testing with mocked dependencies
5tags: testing, unit-tests, mocking, jest
6---
7 
8## Use Testing Module for Unit Tests
9 
10Use `@nestjs/testing` module to create isolated test environments with mocked dependencies. This ensures your tests run fast, don't depend on external services, and properly test your business logic in isolation.
11 
12**Incorrect (manual instantiation bypassing DI):**
13 
14```typescript
15// Instantiate services manually without DI
16describe('UsersService', () => {
17  it('should create user', async () => {
18    // Manual instantiation bypasses DI
19    const repo = new UserRepository(); // Real repo!
20    const service = new UsersService(repo);
21 
22    const user = await service.create({ name: 'Test' });
23    // This hits the real database!
24  });
25});
26 
27// Test implementation details
28describe('UsersController', () => {
29  it('should call service', async () => {
30    const service = { create: jest.fn() };
31    const controller = new UsersController(service as any);
32 
33    await controller.create({ name: 'Test' });
34 
35    expect(service.create).toHaveBeenCalled(); // Tests implementation, not behavior
36  });
37});
38```
39 
40**Correct (use Test.createTestingModule with mocked dependencies):**
41 
42```typescript
43// Use Test.createTestingModule for proper DI
44import { Test, TestingModule } from '@nestjs/testing';
45 
46describe('UsersService', () => {
47  let service: UsersService;
48  let repo: jest.Mocked<UserRepository>;
49 
50  beforeEach(async () => {
51    const module: TestingModule = await Test.createTestingModule({
52      providers: [
53        UsersService,
54        {
55          provide: UserRepository,
56          useValue: {
57            save: jest.fn(),
58            findOne: jest.fn(),
59            find: jest.fn(),
60          },
61        },
62      ],
63    }).compile();
64 
65    service = module.get<UsersService>(UsersService);
66    repo = module.get(UserRepository);
67  });
68 
69  afterEach(() => {
70    jest.clearAllMocks();
71  });
72 
73  describe('create', () => {
74    it('should save and return user', async () => {
75      const dto = { name: 'John', email: '[email protected]' };
76      const expectedUser = { id: '1', ...dto };
77 
78      repo.save.mockResolvedValue(expectedUser);
79 
80      const result = await service.create(dto);
81 
82      expect(result).toEqual(expectedUser);
83      expect(repo.save).toHaveBeenCalledWith(dto);
84    });
85 
86    it('should throw on duplicate email', async () => {
87      repo.findOne.mockResolvedValue({ id: '1', email: '[email protected]' });
88 
89      await expect(
90        service.create({ name: 'Test', email: '[email protected]' }),
91      ).rejects.toThrow(ConflictException);
92    });
93  });
94 
95  describe('findById', () => {
96    it('should return user when found', async () => {
97      const user = { id: '1', name: 'John' };
98      repo.findOne.mockResolvedValue(user);
99 
100      const result = await service.findById('1');
101 
102      expect(result).toEqual(user);
103    });
104 
105    it('should throw NotFoundException when not found', async () => {
106      repo.findOne.mockResolvedValue(null);
107 
108      await expect(service.findById('999')).rejects.toThrow(NotFoundException);
109    });
110  });
111});
112 
113// Testing guards and interceptors
114describe('RolesGuard', () => {
115  let guard: RolesGuard;
116  let reflector: Reflector;
117 
118  beforeEach(async () => {
119    const module = await Test.createTestingModule({
120      providers: [RolesGuard, Reflector],
121    }).compile();
122 
123    guard = module.get<RolesGuard>(RolesGuard);
124    reflector = module.get<Reflector>(Reflector);
125  });
126 
127  it('should allow when no roles required', () => {
128    const context = createMockExecutionContext({ user: { roles: [] } });
129    jest.spyOn(reflector, 'getAllAndOverride').mockReturnValue(undefined);
130 
131    expect(guard.canActivate(context)).toBe(true);
132  });
133 
134  it('should allow admin for admin-only route', () => {
135    const context = createMockExecutionContext({ user: { roles: ['admin'] } });
136    jest.spyOn(reflector, 'getAllAndOverride').mockReturnValue(['admin']);
137 
138    expect(guard.canActivate(context)).toBe(true);
139  });
140});
141 
142function createMockExecutionContext(request: Partial<Request>): ExecutionContext {
143  return {
144    switchToHttp: () => ({
145      getRequest: () => request,
146    }),
147    getHandler: () => jest.fn(),
148    getClass: () => jest.fn(),
149  } as ExecutionContext;
150}
151```
152 
153Reference: [NestJS Testing](https://docs.nestjs.com/fundamentals/testing)
154