889 lines
22 KiB
Markdown
889 lines
22 KiB
Markdown
# 测试指南
|
|
|
|
## 1. 测试策略概述
|
|
|
|
### 1.1 测试金字塔
|
|
|
|
```
|
|
┌───────────┐
|
|
│ E2E │ ← 端到端测试 (少量)
|
|
│ Tests │
|
|
─┴───────────┴─
|
|
┌───────────────┐
|
|
│ Integration │ ← 集成测试 (中等)
|
|
│ Tests │
|
|
─┴───────────────┴─
|
|
┌───────────────────┐
|
|
│ Unit Tests │ ← 单元测试 (大量)
|
|
└───────────────────┘
|
|
```
|
|
|
|
### 1.2 测试类型分布
|
|
|
|
| 测试类型 | 数量 | 覆盖范围 | 执行时间 |
|
|
|---------|------|---------|---------|
|
|
| 单元测试 | 20+ | 领域层、值对象、聚合根 | ~2s |
|
|
| 集成测试 | 11+ | 数据库仓储、应用服务 | ~10s |
|
|
| E2E 测试 | 12+ | HTTP API、完整流程 | ~15s |
|
|
| Docker 测试 | 31+ | 容器化环境全量测试 | ~60s |
|
|
|
|
## 2. 单元测试
|
|
|
|
### 2.1 测试范围
|
|
|
|
单元测试主要覆盖:
|
|
- **值对象 (Value Objects)**: 不可变性、验证逻辑、相等性比较
|
|
- **聚合根 (Aggregates)**: 业务规则、状态变更、领域事件
|
|
- **领域服务**: 业务逻辑计算
|
|
|
|
### 2.2 目录结构
|
|
|
|
```
|
|
src/
|
|
├── domain/
|
|
│ ├── value-objects/
|
|
│ │ ├── date-range.vo.ts
|
|
│ │ ├── date-range.spec.ts ← 值对象单元测试
|
|
│ │ ├── report-period.vo.ts
|
|
│ │ ├── report-period.spec.ts
|
|
│ │ ├── export-format.vo.ts
|
|
│ │ └── export-format.spec.ts
|
|
│ └── aggregates/
|
|
│ ├── report-definition/
|
|
│ │ ├── report-definition.aggregate.ts
|
|
│ │ └── report-definition.spec.ts ← 聚合根单元测试
|
|
│ └── report-snapshot/
|
|
│ ├── report-snapshot.aggregate.ts
|
|
│ └── report-snapshot.spec.ts
|
|
```
|
|
|
|
### 2.3 值对象测试示例
|
|
|
|
```typescript
|
|
// src/domain/value-objects/date-range.spec.ts
|
|
describe('DateRange Value Object', () => {
|
|
describe('create', () => {
|
|
it('should create valid date range', () => {
|
|
const startDate = new Date('2024-01-01');
|
|
const endDate = new Date('2024-01-31');
|
|
|
|
const dateRange = DateRange.create(startDate, endDate);
|
|
|
|
expect(dateRange.startDate).toEqual(startDate);
|
|
expect(dateRange.endDate).toEqual(endDate);
|
|
});
|
|
|
|
it('should throw error when start date is after end date', () => {
|
|
const startDate = new Date('2024-01-31');
|
|
const endDate = new Date('2024-01-01');
|
|
|
|
expect(() => DateRange.create(startDate, endDate))
|
|
.toThrow('Start date cannot be after end date');
|
|
});
|
|
});
|
|
|
|
describe('equals', () => {
|
|
it('should return true for equal date ranges', () => {
|
|
const range1 = DateRange.create(
|
|
new Date('2024-01-01'),
|
|
new Date('2024-01-31')
|
|
);
|
|
const range2 = DateRange.create(
|
|
new Date('2024-01-01'),
|
|
new Date('2024-01-31')
|
|
);
|
|
|
|
expect(range1.equals(range2)).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('getDays', () => {
|
|
it('should calculate correct number of days', () => {
|
|
const dateRange = DateRange.create(
|
|
new Date('2024-01-01'),
|
|
new Date('2024-01-31')
|
|
);
|
|
|
|
expect(dateRange.getDays()).toBe(31);
|
|
});
|
|
});
|
|
});
|
|
```
|
|
|
|
### 2.4 聚合根测试示例
|
|
|
|
```typescript
|
|
// src/domain/aggregates/report-snapshot/report-snapshot.spec.ts
|
|
describe('ReportSnapshot Aggregate', () => {
|
|
const mockDefinition = ReportDefinition.reconstitute({
|
|
id: 1n,
|
|
code: 'RPT_TEST',
|
|
name: 'Test Report',
|
|
description: 'Test description',
|
|
category: 'TEST',
|
|
dataSource: 'test_table',
|
|
isActive: true,
|
|
createdAt: new Date(),
|
|
updatedAt: new Date(),
|
|
});
|
|
|
|
describe('create', () => {
|
|
it('should create snapshot with pending status', () => {
|
|
const snapshot = ReportSnapshot.create({
|
|
definition: mockDefinition,
|
|
period: ReportPeriod.DAILY,
|
|
dateRange: DateRange.create(
|
|
new Date('2024-01-01'),
|
|
new Date('2024-01-01')
|
|
),
|
|
});
|
|
|
|
expect(snapshot.status).toBe(SnapshotStatus.PENDING);
|
|
expect(snapshot.reportCode).toBe('RPT_TEST');
|
|
});
|
|
});
|
|
|
|
describe('markAsProcessing', () => {
|
|
it('should transition from pending to processing', () => {
|
|
const snapshot = createPendingSnapshot();
|
|
|
|
snapshot.markAsProcessing();
|
|
|
|
expect(snapshot.status).toBe(SnapshotStatus.PROCESSING);
|
|
});
|
|
|
|
it('should throw error if not in pending status', () => {
|
|
const snapshot = createCompletedSnapshot();
|
|
|
|
expect(() => snapshot.markAsProcessing())
|
|
.toThrow('Cannot start processing');
|
|
});
|
|
});
|
|
|
|
describe('complete', () => {
|
|
it('should set data and mark as completed', () => {
|
|
const snapshot = createProcessingSnapshot();
|
|
const data = { items: [{ id: 1 }], total: 1 };
|
|
|
|
snapshot.complete(data);
|
|
|
|
expect(snapshot.status).toBe(SnapshotStatus.COMPLETED);
|
|
expect(snapshot.snapshotData).toEqual(data);
|
|
});
|
|
});
|
|
});
|
|
```
|
|
|
|
### 2.5 运行单元测试
|
|
|
|
```bash
|
|
# 运行所有单元测试
|
|
npm test
|
|
|
|
# 运行特定文件
|
|
npm test -- date-range.spec.ts
|
|
|
|
# Watch 模式
|
|
npm run test:watch
|
|
|
|
# 带覆盖率
|
|
npm run test:cov
|
|
```
|
|
|
|
## 3. 集成测试
|
|
|
|
### 3.1 测试范围
|
|
|
|
集成测试覆盖:
|
|
- **仓储实现**: Prisma 数据库操作
|
|
- **应用服务**: 命令/查询处理
|
|
- **缓存服务**: Redis 缓存操作
|
|
|
|
### 3.2 目录结构
|
|
|
|
```
|
|
src/
|
|
├── infrastructure/
|
|
│ └── repositories/
|
|
│ ├── prisma-report-definition.repository.ts
|
|
│ └── prisma-report-definition.repository.integration.spec.ts
|
|
├── application/
|
|
│ └── services/
|
|
│ ├── reporting-application.service.ts
|
|
│ └── reporting-application.service.integration.spec.ts
|
|
```
|
|
|
|
### 3.3 数据库集成测试
|
|
|
|
```typescript
|
|
// prisma-report-definition.repository.integration.spec.ts
|
|
describe('PrismaReportDefinitionRepository (Integration)', () => {
|
|
let repository: PrismaReportDefinitionRepository;
|
|
let prismaService: PrismaService;
|
|
|
|
beforeAll(async () => {
|
|
const module = await Test.createTestingModule({
|
|
providers: [
|
|
PrismaReportDefinitionRepository,
|
|
PrismaService,
|
|
],
|
|
}).compile();
|
|
|
|
repository = module.get(PrismaReportDefinitionRepository);
|
|
prismaService = module.get(PrismaService);
|
|
});
|
|
|
|
beforeEach(async () => {
|
|
// 清理测试数据
|
|
await prismaService.reportSnapshot.deleteMany();
|
|
await prismaService.reportDefinition.deleteMany();
|
|
});
|
|
|
|
afterAll(async () => {
|
|
await prismaService.$disconnect();
|
|
});
|
|
|
|
describe('save', () => {
|
|
it('should persist report definition to database', async () => {
|
|
const definition = ReportDefinition.create({
|
|
code: 'RPT_TEST',
|
|
name: 'Test Report',
|
|
description: 'Test',
|
|
category: 'TEST',
|
|
dataSource: 'test_table',
|
|
});
|
|
|
|
await repository.save(definition);
|
|
|
|
const found = await prismaService.reportDefinition.findUnique({
|
|
where: { code: 'RPT_TEST' },
|
|
});
|
|
expect(found).not.toBeNull();
|
|
expect(found?.name).toBe('Test Report');
|
|
});
|
|
});
|
|
|
|
describe('findByCode', () => {
|
|
it('should return null for non-existent code', async () => {
|
|
const result = await repository.findByCode('NON_EXISTENT');
|
|
expect(result).toBeNull();
|
|
});
|
|
|
|
it('should return definition when exists', async () => {
|
|
// 创建测试数据
|
|
await prismaService.reportDefinition.create({
|
|
data: {
|
|
code: 'RPT_FIND',
|
|
name: 'Find Test',
|
|
description: 'Test',
|
|
category: 'TEST',
|
|
dataSource: 'test_table',
|
|
isActive: true,
|
|
},
|
|
});
|
|
|
|
const result = await repository.findByCode('RPT_FIND');
|
|
|
|
expect(result).not.toBeNull();
|
|
expect(result?.code).toBe('RPT_FIND');
|
|
});
|
|
});
|
|
});
|
|
```
|
|
|
|
### 3.4 应用服务集成测试
|
|
|
|
```typescript
|
|
// reporting-application.service.integration.spec.ts
|
|
describe('ReportingApplicationService (Integration)', () => {
|
|
let service: ReportingApplicationService;
|
|
let prismaService: PrismaService;
|
|
|
|
beforeAll(async () => {
|
|
const module = await Test.createTestingModule({
|
|
imports: [AppModule],
|
|
}).compile();
|
|
|
|
service = module.get(ReportingApplicationService);
|
|
prismaService = module.get(PrismaService);
|
|
});
|
|
|
|
beforeEach(async () => {
|
|
await cleanDatabase(prismaService);
|
|
await seedTestData(prismaService);
|
|
});
|
|
|
|
describe('generateReport', () => {
|
|
it('should create snapshot for valid report', async () => {
|
|
const result = await service.generateReport({
|
|
reportCode: 'RPT_LEADERBOARD',
|
|
reportPeriod: ReportPeriod.DAILY,
|
|
startDate: new Date('2024-01-01'),
|
|
endDate: new Date('2024-01-01'),
|
|
});
|
|
|
|
expect(result).toBeDefined();
|
|
expect(result.status).toBe(SnapshotStatus.COMPLETED);
|
|
});
|
|
|
|
it('should throw when report definition not found', async () => {
|
|
await expect(
|
|
service.generateReport({
|
|
reportCode: 'NON_EXISTENT',
|
|
reportPeriod: ReportPeriod.DAILY,
|
|
startDate: new Date('2024-01-01'),
|
|
endDate: new Date('2024-01-01'),
|
|
})
|
|
).rejects.toThrow(ReportDefinitionNotFoundException);
|
|
});
|
|
});
|
|
});
|
|
```
|
|
|
|
### 3.5 测试数据库配置
|
|
|
|
```env
|
|
# .env.test
|
|
DATABASE_URL=postgresql://postgres:postgres@localhost:5433/rwadurian_reporting_test?schema=public
|
|
REDIS_HOST=localhost
|
|
REDIS_PORT=6380
|
|
```
|
|
|
|
### 3.6 运行集成测试
|
|
|
|
```bash
|
|
# 启动测试依赖
|
|
docker compose -f docker-compose.test.yml up -d postgres-test redis-test
|
|
|
|
# 推送 Schema
|
|
DATABASE_URL="postgresql://postgres:postgres@localhost:5433/rwadurian_reporting_test?schema=public" \
|
|
npx prisma db push
|
|
|
|
# 运行集成测试
|
|
npm run test:integration
|
|
|
|
# 或使用 Makefile
|
|
make test-integration
|
|
```
|
|
|
|
## 4. E2E 测试
|
|
|
|
### 4.1 测试范围
|
|
|
|
E2E 测试覆盖:
|
|
- HTTP API 端点
|
|
- 请求验证
|
|
- 响应格式
|
|
- 错误处理
|
|
- 完整业务流程
|
|
|
|
### 4.2 目录结构
|
|
|
|
```
|
|
test/
|
|
├── app.e2e-spec.ts # 主 E2E 测试文件
|
|
├── jest-e2e.json # E2E Jest 配置
|
|
└── setup-e2e.ts # E2E 测试设置
|
|
```
|
|
|
|
### 4.3 E2E 测试配置
|
|
|
|
```json
|
|
// test/jest-e2e.json
|
|
{
|
|
"moduleFileExtensions": ["js", "json", "ts"],
|
|
"rootDir": ".",
|
|
"testEnvironment": "node",
|
|
"testRegex": ".e2e-spec.ts$",
|
|
"testTimeout": 30000,
|
|
"transform": {
|
|
"^.+\\.(t|j)s$": "ts-jest"
|
|
},
|
|
"setupFilesAfterEnv": ["<rootDir>/setup-e2e.ts"],
|
|
"moduleNameMapper": {
|
|
"^@/(.*)$": "<rootDir>/../src/$1",
|
|
"^@domain/(.*)$": "<rootDir>/../src/domain/$1",
|
|
"^@application/(.*)$": "<rootDir>/../src/application/$1",
|
|
"^@infrastructure/(.*)$": "<rootDir>/../src/infrastructure/$1",
|
|
"^@api/(.*)$": "<rootDir>/../src/api/$1"
|
|
}
|
|
}
|
|
```
|
|
|
|
```typescript
|
|
// test/setup-e2e.ts
|
|
import * as dotenv from 'dotenv';
|
|
import * as path from 'path';
|
|
|
|
dotenv.config({ path: path.resolve(__dirname, '../.env.test') });
|
|
```
|
|
|
|
### 4.4 E2E 测试示例
|
|
|
|
```typescript
|
|
// test/app.e2e-spec.ts
|
|
describe('Reporting Service (e2e)', () => {
|
|
let app: INestApplication;
|
|
|
|
beforeAll(async () => {
|
|
const moduleFixture = await Test.createTestingModule({
|
|
imports: [AppModule],
|
|
}).compile();
|
|
|
|
app = moduleFixture.createNestApplication();
|
|
app.setGlobalPrefix('api/v1');
|
|
app.useGlobalPipes(
|
|
new ValidationPipe({
|
|
whitelist: true,
|
|
forbidNonWhitelisted: true,
|
|
transform: true,
|
|
}),
|
|
);
|
|
// 注意: TransformInterceptor 已在 AppModule 中注册
|
|
// 不要重复注册，避免响应双重包装
|
|
await app.init();
|
|
});
|
|
|
|
afterAll(async () => {
|
|
await app.close();
|
|
});
|
|
|
|
describe('Health Check', () => {
|
|
it('/api/v1/health (GET) should return ok status', () => {
|
|
return request(app.getHttpServer())
|
|
.get('/api/v1/health')
|
|
.expect(200)
|
|
.expect((res) => {
|
|
expect(res.body.success).toBe(true);
|
|
expect(res.body.data.status).toBe('ok');
|
|
expect(res.body.data.service).toBe('reporting-service');
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('Reports API', () => {
|
|
describe('POST /api/v1/reports/generate', () => {
|
|
it('should validate request body', () => {
|
|
return request(app.getHttpServer())
|
|
.post('/api/v1/reports/generate')
|
|
.send({})
|
|
.expect(400);
|
|
});
|
|
|
|
it('should reject invalid report period', () => {
|
|
return request(app.getHttpServer())
|
|
.post('/api/v1/reports/generate')
|
|
.send({
|
|
reportCode: 'RPT_LEADERBOARD',
|
|
reportPeriod: 'INVALID_PERIOD',
|
|
startDate: '2024-01-01',
|
|
endDate: '2024-01-31',
|
|
})
|
|
.expect(400);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('Export API', () => {
|
|
describe('POST /api/v1/export', () => {
|
|
it('should validate request body', () => {
|
|
return request(app.getHttpServer())
|
|
.post('/api/v1/export')
|
|
.send({})
|
|
.expect(400);
|
|
});
|
|
|
|
it('should reject invalid format', () => {
|
|
return request(app.getHttpServer())
|
|
.post('/api/v1/export')
|
|
.send({
|
|
snapshotId: '1',
|
|
format: 'INVALID_FORMAT',
|
|
})
|
|
.expect(400);
|
|
});
|
|
});
|
|
});
|
|
});
|
|
```
|
|
|
|
### 4.5 运行 E2E 测试
|
|
|
|
```bash
|
|
# 确保测试数据库运行
|
|
docker compose -f docker-compose.test.yml up -d postgres-test redis-test
|
|
|
|
# 运行 E2E 测试
|
|
npm run test:e2e
|
|
|
|
# 或使用 Makefile
|
|
make test-e2e
|
|
```
|
|
|
|
## 5. Docker 测试
|
|
|
|
### 5.1 测试架构
|
|
|
|
```
|
|
┌─────────────────────────────────────────────────────────┐
|
|
│ Docker Network │
|
|
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
|
|
│ │ PostgreSQL │ │ Redis │ │ Service │ │
|
|
│ │ :5432 │ │ :6379 │ │ Test │ │
|
|
│ │ (tmpfs) │ │ │ │ Container │ │
|
|
│ └──────────────┘ └──────────────┘ └──────────────┘ │
|
|
└─────────────────────────────────────────────────────────┘
|
|
```
|
|
|
|
### 5.2 Docker Compose 配置
|
|
|
|
```yaml
|
|
# docker-compose.test.yml
|
|
version: '3.8'
|
|
|
|
services:
|
|
postgres-test:
|
|
image: postgres:15-alpine
|
|
container_name: reporting-postgres-test
|
|
environment:
|
|
POSTGRES_USER: postgres
|
|
POSTGRES_PASSWORD: postgres
|
|
POSTGRES_DB: rwadurian_reporting_test
|
|
ports:
|
|
- "5433:5432"
|
|
healthcheck:
|
|
test: ["CMD-SHELL", "pg_isready -U postgres"]
|
|
interval: 5s
|
|
timeout: 5s
|
|
retries: 5
|
|
tmpfs:
|
|
- /var/lib/postgresql/data # 使用内存存储加速测试
|
|
|
|
redis-test:
|
|
image: redis:7-alpine
|
|
container_name: reporting-redis-test
|
|
ports:
|
|
- "6380:6379"
|
|
healthcheck:
|
|
test: ["CMD", "redis-cli", "ping"]
|
|
interval: 5s
|
|
timeout: 5s
|
|
retries: 5
|
|
|
|
reporting-service-test:
|
|
build:
|
|
context: .
|
|
dockerfile: Dockerfile.test
|
|
container_name: reporting-service-test
|
|
depends_on:
|
|
postgres-test:
|
|
condition: service_healthy
|
|
redis-test:
|
|
condition: service_healthy
|
|
environment:
|
|
NODE_ENV: test
|
|
DATABASE_URL: postgresql://postgres:postgres@postgres-test:5432/rwadurian_reporting_test?schema=public
|
|
REDIS_HOST: redis-test
|
|
REDIS_PORT: 6379
|
|
JWT_SECRET: test-secret-key
|
|
volumes:
|
|
- ./coverage:/app/coverage
|
|
command: sh -c "npx prisma db push --skip-generate && npm run test:cov"
|
|
```
|
|
|
|
### 5.3 测试 Dockerfile
|
|
|
|
```dockerfile
|
|
# Dockerfile.test
|
|
FROM node:20-alpine
|
|
|
|
WORKDIR /app
|
|
|
|
# 安装 OpenSSL (Prisma 依赖)
|
|
RUN apk add --no-cache openssl openssl-dev
|
|
|
|
# 安装依赖
|
|
COPY package*.json ./
|
|
RUN npm ci
|
|
|
|
# 复制 Prisma Schema
|
|
COPY prisma ./prisma/
|
|
|
|
# 生成 Prisma Client
|
|
RUN npx prisma generate
|
|
|
|
# 复制源代码
|
|
COPY . .
|
|
|
|
# 构建应用
|
|
RUN npm run build
|
|
|
|
# 默认运行测试
|
|
CMD ["npm", "test"]
|
|
```
|
|
|
|
### 5.4 .dockerignore
|
|
|
|
```
|
|
node_modules
|
|
dist
|
|
coverage
|
|
.git
|
|
.env*
|
|
!.env.example
|
|
*.log
|
|
.claude/
|
|
```
|
|
|
|
### 5.5 运行 Docker 测试
|
|
|
|
```bash
|
|
# 构建并运行所有测试
|
|
docker compose -f docker-compose.test.yml up --build --abort-on-container-exit
|
|
|
|
# 查看测试结果
|
|
docker compose -f docker-compose.test.yml logs reporting-service-test
|
|
|
|
# 清理
|
|
docker compose -f docker-compose.test.yml down -v
|
|
|
|
# 使用 Makefile
|
|
make test-docker-all
|
|
```
|
|
|
|
## 6. Makefile 命令
|
|
|
|
```makefile
|
|
# Makefile
|
|
.PHONY: test test-unit test-integration test-e2e test-docker-all
|
|
|
|
# 运行所有测试
|
|
test: test-unit test-integration test-e2e
|
|
|
|
# 单元测试
|
|
test-unit:
|
|
npm test
|
|
|
|
# 集成测试
|
|
test-integration:
|
|
npm run test:integration
|
|
|
|
# E2E 测试
|
|
test-e2e:
|
|
npm run test:e2e
|
|
|
|
# Docker 中运行所有测试
|
|
test-docker-all:
|
|
docker compose -f docker-compose.test.yml up --build --abort-on-container-exit
|
|
docker compose -f docker-compose.test.yml down -v
|
|
|
|
# 测试覆盖率
|
|
test-cov:
|
|
npm run test:cov
|
|
|
|
# 清理测试容器
|
|
test-clean:
|
|
docker compose -f docker-compose.test.yml down -v
|
|
```
|
|
|
|
## 7. 测试最佳实践
|
|
|
|
### 7.1 测试命名规范
|
|
|
|
```typescript
|
|
describe('ClassName', () => {
|
|
describe('methodName', () => {
|
|
it('should [expected behavior] when [condition]', () => {
|
|
// test implementation
|
|
});
|
|
});
|
|
});
|
|
```
|
|
|
|
### 7.2 AAA 模式
|
|
|
|
```typescript
|
|
it('should create valid date range', () => {
|
|
// Arrange - 准备测试数据
|
|
const startDate = new Date('2024-01-01');
|
|
const endDate = new Date('2024-01-31');
|
|
|
|
// Act - 执行被测试的操作
|
|
const dateRange = DateRange.create(startDate, endDate);
|
|
|
|
// Assert - 验证结果
|
|
expect(dateRange.startDate).toEqual(startDate);
|
|
expect(dateRange.endDate).toEqual(endDate);
|
|
});
|
|
```
|
|
|
|
### 7.3 测试隔离
|
|
|
|
```typescript
|
|
describe('Repository Integration Tests', () => {
|
|
beforeEach(async () => {
|
|
// 每个测试前清理数据
|
|
await prismaService.reportSnapshot.deleteMany();
|
|
await prismaService.reportDefinition.deleteMany();
|
|
});
|
|
|
|
afterAll(async () => {
|
|
// 测试结束后断开连接
|
|
await prismaService.$disconnect();
|
|
});
|
|
});
|
|
```
|
|
|
|
### 7.4 Mock 使用
|
|
|
|
```typescript
|
|
// 使用 Jest mock
|
|
const mockRepository = {
|
|
findByCode: jest.fn(),
|
|
save: jest.fn(),
|
|
findAll: jest.fn(),
|
|
};
|
|
|
|
beforeEach(() => {
|
|
jest.clearAllMocks();
|
|
});
|
|
|
|
it('should call repository with correct parameters', async () => {
|
|
mockRepository.findByCode.mockResolvedValue(mockDefinition);
|
|
|
|
await service.getReportDefinition('RPT_TEST');
|
|
|
|
expect(mockRepository.findByCode).toHaveBeenCalledWith('RPT_TEST');
|
|
});
|
|
```
|
|
|
|
## 8. CI/CD 集成
|
|
|
|
### 8.1 GitHub Actions
|
|
|
|
```yaml
|
|
# .github/workflows/test.yml
|
|
name: Test
|
|
|
|
on:
|
|
push:
|
|
branches: [main, develop]
|
|
pull_request:
|
|
branches: [main]
|
|
|
|
jobs:
|
|
test:
|
|
runs-on: ubuntu-latest
|
|
|
|
services:
|
|
postgres:
|
|
image: postgres:15-alpine
|
|
env:
|
|
POSTGRES_USER: postgres
|
|
POSTGRES_PASSWORD: postgres
|
|
POSTGRES_DB: rwadurian_reporting_test
|
|
ports:
|
|
- 5432:5432
|
|
options: >-
|
|
--health-cmd pg_isready
|
|
--health-interval 10s
|
|
--health-timeout 5s
|
|
--health-retries 5
|
|
|
|
redis:
|
|
image: redis:7-alpine
|
|
ports:
|
|
- 6379:6379
|
|
options: >-
|
|
--health-cmd "redis-cli ping"
|
|
--health-interval 10s
|
|
--health-timeout 5s
|
|
--health-retries 5
|
|
|
|
steps:
|
|
- uses: actions/checkout@v4
|
|
|
|
- name: Setup Node.js
|
|
uses: actions/setup-node@v4
|
|
with:
|
|
node-version: '20'
|
|
cache: 'npm'
|
|
|
|
- name: Install dependencies
|
|
run: npm ci
|
|
|
|
- name: Generate Prisma Client
|
|
run: npx prisma generate
|
|
|
|
- name: Push database schema
|
|
run: npx prisma db push
|
|
env:
|
|
DATABASE_URL: postgresql://postgres:postgres@localhost:5432/rwadurian_reporting_test?schema=public
|
|
|
|
- name: Run unit tests
|
|
run: npm test
|
|
|
|
- name: Run integration tests
|
|
run: npm run test:integration
|
|
env:
|
|
DATABASE_URL: postgresql://postgres:postgres@localhost:5432/rwadurian_reporting_test?schema=public
|
|
REDIS_HOST: localhost
|
|
REDIS_PORT: 6379
|
|
|
|
- name: Run E2E tests
|
|
run: npm run test:e2e
|
|
env:
|
|
DATABASE_URL: postgresql://postgres:postgres@localhost:5432/rwadurian_reporting_test?schema=public
|
|
REDIS_HOST: localhost
|
|
REDIS_PORT: 6379
|
|
|
|
- name: Upload coverage
|
|
uses: codecov/codecov-action@v3
|
|
with:
|
|
files: ./coverage/lcov.info
|
|
```
|
|
|
|
## 9. 故障排除
|
|
|
|
### 9.1 常见问题
|
|
|
|
**Q: 测试找不到模块**
|
|
```bash
|
|
# 重新生成 Prisma Client
|
|
npx prisma generate
|
|
```
|
|
|
|
**Q: 数据库连接失败**
|
|
```bash
|
|
# 检查容器状态
|
|
docker ps
|
|
|
|
# 检查数据库日志
|
|
docker logs reporting-postgres-test
|
|
```
|
|
|
|
**Q: E2E 测试响应格式错误**
|
|
```typescript
|
|
// 确保不要重复注册 TransformInterceptor
|
|
// AppModule 中已注册，测试中不需要再次注册
|
|
```
|
|
|
|
**Q: Docker 测试 Prisma 错误**
|
|
```dockerfile
|
|
# 确保 Dockerfile.test 包含 OpenSSL
|
|
RUN apk add --no-cache openssl openssl-dev
|
|
```
|
|
|
|
### 9.2 调试测试
|
|
|
|
```bash
|
|
# 运行单个测试文件
|
|
npm test -- --testPathPattern=date-range.spec.ts
|
|
|
|
# 详细输出
|
|
npm test -- --verbose
|
|
|
|
# 调试模式
|
|
node --inspect-brk node_modules/.bin/jest --runInBand
|
|
```
|