NestJS测试策略

学习目标

• 掌握NestJS中单元测试的实现方法
• 理解集成测试的概念和实现技巧
• 学习如何编写端到端测试
• 了解NestJS的测试工具和辅助函数
• 掌握测试覆盖率的管理和优化

核心知识点

1. 测试简介

测试是软件开发生命周期中的重要组成部分，它可以帮助我们：

• 确保代码的正确性和可靠性
• 早期发现和修复bug
• 提高代码的可维护性
• 支持重构和代码改进
• 减少回归错误

在NestJS中，测试主要分为三种类型：

• 单元测试：测试单个组件的功能，如服务、控制器、管道等
• 集成测试：测试多个组件之间的交互，如模块、API端点等
• 端到端测试：测试整个应用的功能，从用户界面到数据库

2. 测试环境配置

NestJS使用Jest作为默认的测试框架。当我们使用Nest CLI创建项目时，它会自动配置测试环境：

# 使用Nest CLI创建项目
nest new project-name

项目创建后，会生成以下测试相关文件：

• package.json：包含测试脚本和依赖
• jest.config.js：Jest配置文件
• src/app.controller.spec.ts：示例控制器测试
• src/app.service.spec.ts：示例服务测试

3. 单元测试

3.1 服务测试

// src/app.service.spec.ts
import { Test, TestingModule } from '@nestjs/testing';
import { AppService } from './app.service';

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

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

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

  it('should be defined', () => {
    expect(service).toBeDefined();
  });

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

3.2 控制器测试

// src/app.controller.spec.ts
import { Test, TestingModule } from '@nestjs/testing';
import { AppController } from './app.controller';
import { AppService } from './app.service';

describe('AppController', () => {
  let controller: AppController;
  let service: AppService;

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

    controller = module.get<AppController>(AppController);
    service = module.get<AppService>(AppService);
  });

  it('should be defined', () => {
    expect(controller).toBeDefined();
  });

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

3.3 管道测试

// src/common/pipes/validation.pipe.spec.ts
import { Test, TestingModule } from '@nestjs/testing';
import { ValidationPipe } from './validation.pipe';

describe('ValidationPipe', () => {
  let pipe: ValidationPipe;

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

    pipe = module.get<ValidationPipe>(ValidationPipe);
  });

  it('should be defined', () => {
    expect(pipe).toBeDefined();
  });

  it('should transform and validate data', async () => {
    class CreateCatDto {
      name: string;
      age: number;
      breed: string;
    }

    const data = {
      name: 'Kitty',
      age: 3,
      breed: 'Persian',
    };

    const result = await pipe.transform(data, {
      metatype: CreateCatDto,
      type: 'body',
      data: data,
    });

    expect(result).toEqual(data);
  });
});

4. 集成测试

集成测试测试多个组件之间的交互，如模块、API端点等。

4.1 模块测试

// src/app.module.spec.ts
import { Test, TestingModule } from '@nestjs/testing';
import { AppModule } from './app.module';
import { AppController } from './app.controller';
import { AppService } from './app.service';

describe('AppModule', () => {
  let module: TestingModule;
  let controller: AppController;
  let service: AppService;

  beforeEach(async () => {
    module = await Test.createTestingModule({
      imports: [AppModule],
    }).compile();

    controller = module.get<AppController>(AppController);
    service = module.get<AppService>(AppService);
  });

  it('should be defined', () => {
    expect(module).toBeDefined();
  });

  it('should provide AppController', () => {
    expect(controller).toBeDefined();
  });

  it('should provide AppService', () => {
    expect(service).toBeDefined();
  });

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

4.2 API端点测试

// src/app.e2e-spec.ts
import { Test, TestingModule } from '@nestjs/testing';
import { INestApplication } from '@nestjs/common';
import * as request from 'supertest';
import { AppModule } from './app.module';

describe('AppController (e2e)', () => {
  let app: INestApplication;

  beforeEach(async () => {
    const moduleFixture: TestingModule = await Test.createTestingModule({
      imports: [AppModule],
    }).compile();

    app = moduleFixture.createNestApplication();
    await app.init();
  });

  it('/ (GET)', () => {
    return request(app.getHttpServer())
      .get('/')
      .expect(200)
      .expect('Hello World!');
  });

  afterAll(async () => {
    await app.close();
  });
});

5. 端到端测试

端到端测试测试整个应用的功能，从用户界面到数据库。在NestJS中，我们通常使用Supertest来模拟HTTP请求。

// test/app.e2e-spec.ts
import { Test, TestingModule } from '@nestjs/testing';
import { INestApplication } from '@nestjs/common';
import * as request from 'supertest';
import { AppModule } from '../src/app.module';

describe('AppController (e2e)', () => {
  let app: INestApplication;

  beforeEach(async () => {
    const moduleFixture: TestingModule = await Test.createTestingModule({
      imports: [AppModule],
    }).compile();

    app = moduleFixture.createNestApplication();
    await app.init();
  });

  it('/ (GET)', () => {
    return request(app.getHttpServer())
      .get('/')
      .expect(200)
      .expect('Hello World!');
  });

  it('/cats (GET)', () => {
    return request(app.getHttpServer())
      .get('/cats')
      .expect(200)
      .expect([]);
  });

  it('/cats (POST)', () => {
    return request(app.getHttpServer())
      .post('/cats')
      .send({ name: 'Kitty', age: 3, breed: 'Persian' })
      .expect(201)
      .expect((res) => {
        expect(res.body.name).toBe('Kitty');
        expect(res.body.age).toBe(3);
        expect(res.body.breed).toBe('Persian');
      });
  });

  afterAll(async () => {
    await app.close();
  });
});

6. 测试工具和辅助函数

NestJS提供了以下测试工具和辅助函数：

6.1 Test.createTestingModule

创建测试模块，用于模拟NestJS的模块系统。

const module: TestingModule = await Test.createTestingModule({
  controllers: [AppController],
  providers: [AppService],
}).compile();

6.2 TestingModule

测试模块对象，提供了获取组件和创建应用的方法。

// 获取组件
const service = module.get<AppService>(AppService);

// 创建应用
const app = module.createNestApplication();

6.3 模拟（Mock）

使用Jest的模拟功能来模拟依赖。

// 模拟AppService
const mockAppService = {
  getHello: jest.fn().mockReturnValue('Hello Mock!'),
};

const module: TestingModule = await Test.createTestingModule({
  controllers: [AppController],
  providers: [
    {
      provide: AppService,
      useValue: mockAppService,
    },
  ],
}).compile();

6.4 测试请求/响应

使用Supertest来测试HTTP请求和响应。

return request(app.getHttpServer())
  .get('/')
  .expect(200)
  .expect('Hello World!');

7. 测试覆盖率

测试覆盖率是衡量测试质量的重要指标，它表示代码被测试覆盖的比例。在NestJS中，我们可以使用Jest来生成测试覆盖率报告：

# 运行测试并生成覆盖率报告
npm test -- --coverage

测试覆盖率报告包括以下指标：

• 语句覆盖率：执行了多少代码语句
• 分支覆盖率：执行了多少代码分支
• 函数覆盖率：执行了多少函数
• 行覆盖率：执行了多少代码行

8. 测试最佳实践

1. 测试命名规范：使用清晰、描述性的测试名称
2. 测试隔离：每个测试应该独立运行，不依赖其他测试的状态
3. 测试数据：使用明确的测试数据，避免使用随机数据
4. 测试边界：测试边界情况和异常情况
5. 测试速度：保持测试快速运行，避免使用真实的外部依赖
6. 测试可读性：编写清晰、易读的测试代码
7. 测试维护：定期更新测试，确保它们与代码同步

实用案例分析

案例1：完整的测试套件

需求分析

我们需要为一个简单的猫管理API实现完整的测试套件，包括单元测试、集成测试和端到端测试。

实现方案

1. 创建猫模块：

// src/cats/cats.module.ts
import { Module } from '@nestjs/common';
import { CatsController } from './cats.controller';
import { CatsService } from './cats.service';
import { Cat } from './interfaces/cat.interface';

@Module({
  controllers: [CatsController],
  providers: [CatsService],
  exports: [CatsService],
})
export class CatsModule {}

2. 创建猫接口：

// src/cats/interfaces/cat.interface.ts
export interface Cat {
  id: string;
  name: string;
  age: number;
  breed: string;
}

3. 创建猫服务：

// src/cats/cats.service.ts
import { Injectable } from '@nestjs/common';
import { Cat } from './interfaces/cat.interface';
import { v4 as uuidv4 } from 'uuid';

@Injectable()
export class CatsService {
  private readonly cats: Cat[] = [];

  create(cat: Omit<Cat, 'id'>): Cat {
    const newCat: Cat = {
      id: uuidv4(),
      ...cat,
    };
    this.cats.push(newCat);
    return newCat;
  }

  findAll(): Cat[] {
    return this.cats;
  }

  findOne(id: string): Cat {
    return this.cats.find(cat => cat.id === id);
  }

  update(id: string, cat: Partial<Cat>): Cat {
    const index = this.cats.findIndex(cat => cat.id === id);
    if (index === -1) {
      return null;
    }
    this.cats[index] = { ...this.cats[index], ...cat };
    return this.cats[index];
  }

  remove(id: string): boolean {
    const index = this.cats.findIndex(cat => cat.id === id);
    if (index === -1) {
      return false;
    }
    this.cats.splice(index, 1);
    return true;
  }
}

4. 创建猫控制器：

// src/cats/cats.controller.ts
import { Controller, Get, Post, Put, Delete, Body, Param, NotFoundException } from '@nestjs/common';
import { CatsService } from './cats.service';
import { Cat } from './interfaces/cat.interface';

@Controller('cats')
export class CatsController {
  constructor(private readonly catsService: CatsService) {}

  @Post()
  create(@Body() cat: Omit<Cat, 'id'>): Cat {
    return this.catsService.create(cat);
  }

  @Get()
  findAll(): Cat[] {
    return this.catsService.findAll();
  }

  @Get(':id')
  findOne(@Param('id') id: string): Cat {
    const cat = this.catsService.findOne(id);
    if (!cat) {
      throw new NotFoundException('Cat not found');
    }
    return cat;
  }

  @Put(':id')
  update(@Param('id') id: string, @Body() cat: Partial<Cat>): Cat {
    const updatedCat = this.catsService.update(id, cat);
    if (!updatedCat) {
      throw new NotFoundException('Cat not found');
    }
    return updatedCat;
  }

  @Delete(':id')
  remove(@Param('id') id: string): { message: string } {
    const result = this.catsService.remove(id);
    if (!result) {
      throw new NotFoundException('Cat not found');
    }
    return { message: 'Cat deleted successfully' };
  }
}

5. 创建猫服务测试：

// src/cats/cats.service.spec.ts
import { Test, TestingModule } from '@nestjs/testing';
import { CatsService } from './cats.service';
import { Cat } from './interfaces/cat.interface';

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

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

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

  it('should be defined', () => {
    expect(service).toBeDefined();
  });

  it('should create a cat', () => {
    const catData: Omit<Cat, 'id'> = {
      name: 'Kitty',
      age: 3,
      breed: 'Persian',
    };
    const cat = service.create(catData);
    expect(cat).toBeDefined();
    expect(cat.id).toBeDefined();
    expect(cat.name).toBe(catData.name);
    expect(cat.age).toBe(catData.age);
    expect(cat.breed).toBe(catData.breed);
  });

  it('should find all cats', () => {
    const catData1: Omit<Cat, 'id'> = {
      name: 'Kitty',
      age: 3,
      breed: 'Persian',
    };
    const catData2: Omit<Cat, 'id'> = {
      name: 'Tom',
      age: 5,
      breed: 'Siamese',
    };
    service.create(catData1);
    service.create(catData2);
    const cats = service.findAll();
    expect(cats).toHaveLength(2);
  });

  it('should find one cat', () => {
    const catData: Omit<Cat, 'id'> = {
      name: 'Kitty',
      age: 3,
      breed: 'Persian',
    };
    const createdCat = service.create(catData);
    const foundCat = service.findOne(createdCat.id);
    expect(foundCat).toBeDefined();
    expect(foundCat.id).toBe(createdCat.id);
  });

  it('should update a cat', () => {
    const catData: Omit<Cat, 'id'> = {
      name: 'Kitty',
      age: 3,
      breed: 'Persian',
    };
    const createdCat = service.create(catData);
    const updatedData: Partial<Cat> = {
      name: 'Updated Kitty',
      age: 4,
    };
    const updatedCat = service.update(createdCat.id, updatedData);
    expect(updatedCat).toBeDefined();
    expect(updatedCat.name).toBe(updatedData.name);
    expect(updatedCat.age).toBe(updatedData.age);
    expect(updatedCat.breed).toBe(catData.breed);
  });

  it('should remove a cat', () => {
    const catData: Omit<Cat, 'id'> = {
      name: 'Kitty',
      age: 3,
      breed: 'Persian',
    };
    const createdCat = service.create(catData);
    const result = service.remove(createdCat.id);
    expect(result).toBe(true);
    const foundCat = service.findOne(createdCat.id);
    expect(foundCat).toBeUndefined();
  });
});

6. 创建猫控制器测试：

// src/cats/cats.controller.spec.ts
import { Test, TestingModule } from '@nestjs/testing';
import { CatsController } from './cats.controller';
import { CatsService } from './cats.service';
import { Cat } from './interfaces/cat.interface';
import { NotFoundException } from '@nestjs/common';

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

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

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

  it('should be defined', () => {
    expect(controller).toBeDefined();
  });

  it('should create a cat', () => {
    const catData: Omit<Cat, 'id'> = {
      name: 'Kitty',
      age: 3,
      breed: 'Persian',
    };
    const cat = controller.create(catData);
    expect(cat).toBeDefined();
    expect(cat.id).toBeDefined();
    expect(cat.name).toBe(catData.name);
  });

  it('should find all cats', () => {
    const cats = controller.findAll();
    expect(Array.isArray(cats)).toBe(true);
  });

  it('should find one cat', () => {
    const catData: Omit<Cat, 'id'> = {
      name: 'Kitty',
      age: 3,
      breed: 'Persian',
    };
    const createdCat = service.create(catData);
    const foundCat = controller.findOne(createdCat.id);
    expect(foundCat).toBeDefined();
    expect(foundCat.id).toBe(createdCat.id);
  });

  it('should throw NotFoundException when cat not found', () => {
    expect(() => controller.findOne('non-existent-id')).toThrow(NotFoundException);
  });

  it('should update a cat', () => {
    const catData: Omit<Cat, 'id'> = {
      name: 'Kitty',
      age: 3,
      breed: 'Persian',
    };
    const createdCat = service.create(catData);
    const updatedData: Partial<Cat> = {
      name: 'Updated Kitty',
    };
    const updatedCat = controller.update(createdCat.id, updatedData);
    expect(updatedCat).toBeDefined();
    expect(updatedCat.name).toBe(updatedData.name);
  });

  it('should delete a cat', () => {
    const catData: Omit<Cat, 'id'> = {
      name: 'Kitty',
      age: 3,
      breed: 'Persian',
    };
    const createdCat = service.create(catData);
    const result = controller.remove(createdCat.id);
    expect(result).toEqual({ message: 'Cat deleted successfully' });
  });
});

7. 创建猫模块集成测试：

// src/cats/cats.module.spec.ts
import { Test, TestingModule } from '@nestjs/testing';
import { CatsModule } from './cats.module';
import { CatsController } from './cats.controller';
import { CatsService } from './cats.service';

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

  beforeEach(async () => {
    module = await Test.createTestingModule({
      imports: [CatsModule],
    }).compile();

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

  it('should be defined', () => {
    expect(module).toBeDefined();
  });

  it('should provide CatsController', () => {
    expect(controller).toBeDefined();
  });

  it('should provide CatsService', () => {
    expect(service).toBeDefined();
  });
});

8. 创建端到端测试：

// test/cats.e2e-spec.ts
import { Test, TestingModule } from '@nestjs/testing';
import { INestApplication } from '@nestjs/common';
import * as request from 'supertest';
import { CatsModule } from '../src/cats/cats.module';

describe('CatsController (e2e)', () => {
  let app: INestApplication;

  beforeEach(async () => {
    const moduleFixture: TestingModule = await Test.createTestingModule({
      imports: [CatsModule],
    }).compile();

    app = moduleFixture.createNestApplication();
    await app.init();
  });

  it('/cats (GET)', () => {
    return request(app.getHttpServer())
      .get('/cats')
      .expect(200)
      .expect([]);
  });

  it('/cats (POST)', () => {
    return request(app.getHttpServer())
      .post('/cats')
      .send({ name: 'Kitty', age: 3, breed: 'Persian' })
      .expect(201)
      .expect((res) => {
        expect(res.body.name).toBe('Kitty');
        expect(res.body.age).toBe(3);
        expect(res.body.breed).toBe('Persian');
        expect(res.body.id).toBeDefined();
      });
  });

  it('/cats/:id (GET)', async () => {
    // 先创建一只猫
    const createResponse = await request(app.getHttpServer())
      .post('/cats')
      .send({ name: 'Kitty', age: 3, breed: 'Persian' });
    const catId = createResponse.body.id;

    // 然后获取这只猫
    return request(app.getHttpServer())
      .get(`/cats/${catId}`)
      .expect(200)
      .expect((res) => {
        expect(res.body.id).toBe(catId);
        expect(res.body.name).toBe('Kitty');
      });
  });

  it('/cats/:id (PUT)', async () => {
    // 先创建一只猫
    const createResponse = await request(app.getHttpServer())
      .post('/cats')
      .send({ name: 'Kitty', age: 3, breed: 'Persian' });
    const catId = createResponse.body.id;

    // 然后更新这只猫
    return request(app.getHttpServer())
      .put(`/cats/${catId}`)
      .send({ name: 'Updated Kitty', age: 4 })
      .expect(200)
      .expect((res) => {
        expect(res.body.id).toBe(catId);
        expect(res.body.name).toBe('Updated Kitty');
        expect(res.body.age).toBe(4);
        expect(res.body.breed).toBe('Persian');
      });
  });

  it('/cats/:id (DELETE)', async () => {
    // 先创建一只猫
    const createResponse = await request(app.getHttpServer())
      .post('/cats')
      .send({ name: 'Kitty', age: 3, breed: 'Persian' });
    const catId = createResponse.body.id;

    // 然后删除这只猫
    return request(app.getHttpServer())
      .delete(`/cats/${catId}`)
      .expect(200)
      .expect({ message: 'Cat deleted successfully' });
  });

  afterAll(async () => {
    await app.close();
  });
});

常见问题与解决方案

1. 测试运行缓慢

可能原因：

• 使用了真实的外部依赖（如数据库、API）
• 测试数据量过大
• 测试代码复杂

解决方案：

• 使用模拟（mock）替代真实的外部依赖
• 使用较小的测试数据
• 简化测试代码，避免不必要的操作

2. 测试失败但代码正常

可能原因：

• 测试数据与代码期望不匹配
• 测试环境与生产环境不同
• 测试依赖于外部状态

解决方案：

• 检查测试数据是否正确
• 确保测试环境与生产环境一致
• 确保测试的隔离性，不依赖外部状态

3. 测试覆盖率低

可能原因：

• 测试覆盖的代码范围有限
• 未测试边界情况和异常情况
• 测试质量不高

解决方案：

• 增加测试用例，覆盖更多的代码路径
• 测试边界情况和异常情况
• 编写更全面、更有针对性的测试

4. 测试维护困难

可能原因：

• 测试代码与业务代码耦合度高
• 测试代码结构混乱
• 测试数据管理困难

解决方案：

• 保持测试代码与业务代码的解耦
• 组织清晰的测试代码结构
• 使用测试数据工厂或fixture管理测试数据

最佳实践

1. 分层测试：实现单元测试、集成测试和端到端测试的分层测试策略
2. 测试驱动开发：采用TDD（测试驱动开发）方法，先写测试再写代码
3. 模拟外部依赖：使用模拟替代真实的外部依赖，提高测试速度和可靠性
4. 测试数据管理：使用一致的测试数据，便于复现和调试
5. 测试覆盖率目标：设定合理的测试覆盖率目标，如80%以上
6. 持续集成：在CI/CD流程中运行测试，确保代码质量
7. 测试文档：为复杂的测试编写文档，说明测试的目的和方法
8. 定期审查测试：定期审查和更新测试，确保它们与代码同步

代码优化建议

1. 使用测试工具库：使用Jest、Supertest等测试工具库，提高测试效率
2. 创建测试辅助函数：创建测试辅助函数，减少重复代码
3. 使用测试工厂：使用测试工厂创建一致的测试数据
4. 实现测试钩子：使用beforeEach、afterEach等测试钩子，设置和清理测试环境
5. 使用快照测试：对于复杂的输出，使用快照测试，减少测试代码的维护

总结

测试是NestJS应用开发的重要组成部分，它可以帮助我们确保代码的正确性和可靠性。通过本文的学习，你应该已经掌握了：

• 单元测试的实现方法
• 集成测试的概念和实现技巧
• 端到端测试的编写方法
• NestJS的测试工具和辅助函数
• 测试覆盖率的管理和优化
• 测试的最佳实践和常见问题解决方案

编写高质量的测试可以提高代码的可维护性，减少bug的数量，支持重构和代码改进。希望本文对你理解和实现NestJS应用的测试策略有所帮助。

互动问答

1. 什么是单元测试？它的主要作用是什么？

2. 如何在NestJS中创建单元测试？

3. 单元测试和集成测试的区别是什么？

4. 如何使用模拟（mock）替代真实的外部依赖？

5. 如何提高测试覆盖率？