Тестирование Node.js API: Jest + Supertest

1npm install -D jest @types/jest ts-jest

1module.exports = {
2  preset: 'ts-jest',
3  testEnvironment: 'node',
4  roots: ['<rootDir>/tests'],
5  testMatch: ['**/*.test.ts'],
6  collectCoverage: true,
7  coverageDirectory: 'coverage',
8};

1import { sum } from '../src/utils';
2
3describe('sum', () => {
4  it('should add two numbers', () => {
5    expect(sum(1, 2)).toBe(3);
6  });
7
8  it('should handle negative numbers', () => {
9    expect(sum(-1, -2)).toBe(-3);
10  });
11});

1npm install -D supertest

1import request from 'supertest';
2import app from '../src/app';
3
4describe('GET /api/users', () => {
5  it('should return list of users', async () => {
6    const response = await request(app)
7      .get('/api/users')
8      .expect(200);
9
10    expect(response.body).toBeInstanceOf(Array);
11    expect(response.body.length).toBeGreaterThan(0);
12  });
13});
14
15describe('POST /api/users', () => {
16  it('should create a new user', async () => {
17    const response = await request(app)
18      .post('/api/users')
19      .send({ name: 'Иван', email: 'ivan@example.com' })
20      .expect(201);
21
22    expect(response.body).toHaveProperty('id');
23    expect(response.body.name).toBe('Иван');
24  });
25
26  it('should return 400 for invalid data', async () => {
27    await request(app)
28      .post('/api/users')
29      .send({ name: '' })
30      .expect(400);
31  });
32});

1import { PrismaClient } from '@prisma/client';
2
3const prisma = new PrismaClient();
4
5beforeAll(async () => {
6  await prisma.$connect();
7});
8
9afterAll(async () => {
10  await prisma.user.deleteMany();
11  await prisma.$disconnect();
12});
13
14describe('User API', () => {
15  let userId: number;
16
17  it('should create user', async () => {
18    const res = await request(app)
19      .post('/api/users')
20      .send({ name: 'Иван', email: 'ivan@test.com' });
21
22    userId = res.body.id;
23    expect(res.status).toBe(201);
24  });
25
26  it('should get user by id', async () => {
27    const res = await request(app)
28      .get(`/api/users/${userId}`);
29
30    expect(res.status).toBe(200);
31    expect(res.body.name).toBe('Иван');
32  });
33
34  it('should delete user', async () => {
35    await request(app)
36      .delete(`/api/users/${userId}`)
37      .expect(204);
38  });
39});

1jest.mock('../src/services/email', () => ({
2  sendEmail: jest.fn().mockResolvedValue(true),
3}));
4
5import { sendEmail } from '../src/services/email';
6
7test('sends welcome email', async () => {
8  await createUser({ name: 'Иван', email: 'ivan@test.com' });
9  expect(sendEmail).toHaveBeenCalledWith(
10    'ivan@test.com',
11    'Добро пожаловать!'
12  );
13});

1jest.mock('../src/prisma', () => ({
2  prisma: {
3    user: {
4      findMany: jest.fn().mockResolvedValue([
5        { id: 1, name: 'Иван' },
6      ]),
7      findUnique: jest.fn().mockResolvedValue({ id: 1, name: 'Иван' }),
8    },
9  },
10}));

1describe('Auth middleware', () => {
2  it('should return 401 without token', async () => {
3    await request(app)
4      .get('/api/protected')
5      .expect(401);
6  });
7
8  it('should return 200 with valid token', async () => {
9    const token = generateToken({ userId: 1 });
10    await request(app)
11      .get('/api/protected')
12      .set('Authorization', `Bearer ${token}`)
13      .expect(200);
14  });
15});

1describe('Error handling', () => {
2  it('should return 500 on internal error', async () => {
3    jest.spyOn(prisma.user, 'findMany')
4      .mockRejectedValue(new Error('DB Error'));
5
6    const res = await request(app)
7      .get('/api/users')
8      .expect(500);
9
10    expect(res.body.error).toBe('Внутренняя ошибка сервера');
11  });
12});

1describe('Authentication', () => {
2  it('should login and return token', async () => {
3    const res = await request(app)
4      .post('/api/auth/login')
5      .send({ email: 'ivan@test.com', password: 'password' })
6      .expect(200);
7
8    expect(res.body).toHaveProperty('token');
9  });
10
11  it('should reject invalid credentials', async () => {
12    await request(app)
13      .post('/api/auth/login')
14      .send({ email: 'wrong@test.com', password: 'wrong' })
15      .expect(401);
16  });
17});

1npx jest --coverage

1// jest.config.js
2module.exports: {
3  collectCoverage: true,
4  coverageThreshold: {
5    global: {
6      branches: 80,
7      functions: 80,
8      lines: 80,
9      statements: 80,
10    },
11  },
12};

1beforeEach(async () => {
2  await prisma.user.deleteMany();
3});