Тестова база даних

NODE_ENV=test
DATABASE_HOST=localhost
DATABASE_PORT=5432
DATABASE_USER=postgres
DATABASE_PASSWORD=postgres
DATABASE_NAME=app_test

createdb -h localhost -U postgres app_test

CREATE DATABASE app_test;

// src/database/database.options.ts
import { DataSourceOptions } from 'typeorm';
import { User } from '../users/user.entity';

export function getDatabaseOptions(): DataSourceOptions {
  const isTest = process.env.NODE_ENV === 'test';

  return {
    type: 'postgres',
    host: process.env.DATABASE_HOST,
    port: Number(process.env.DATABASE_PORT),
    username: process.env.DATABASE_USER,
    password: process.env.DATABASE_PASSWORD,
    database: process.env.DATABASE_NAME,

    entities: [User],

    migrations: [
      isTest
        ? 'src/database/migrations/*.ts'
        : 'dist/database/migrations/*.js',
    ],

    // Схема створюється міграціями, а не автоматично.
    synchronize: false,

    // Міграції запускаються явно в тестовому setup-файлі.
    migrationsRun: false,
  };
}

// src/app.module.ts
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { getDatabaseOptions } from './database/database.options';
import { User } from './users/user.entity';

@Module({
  imports: [
    TypeOrmModule.forRoot(getDatabaseOptions()),
    TypeOrmModule.forFeature([User]),
  ],
})
export class AppModule {}

// src/database/migrations/1710000000000-create-users.ts
import {
  MigrationInterface,
  QueryRunner,
  Table,
} from 'typeorm';

export class CreateUsers1710000000000 implements MigrationInterface {
  public async up(queryRunner: QueryRunner): Promise<void> {
    await queryRunner.createTable(
      new Table({
        name: 'users',
        columns: [
          {
            name: 'id',
            type: 'integer',
            isPrimary: true,
            isGenerated: true,
            generationStrategy: 'increment',
          },
          {
            name: 'email',
            type: 'varchar',
            isUnique: true,
          },
          {
            name: 'name',
            type: 'varchar',
          },
        ],
      }),
    );
  }

  public async down(queryRunner: QueryRunner): Promise<void> {
    await queryRunner.dropTable('users');
  }
}

// src/users/user.entity.ts
import {
  Column,
  Entity,
  PrimaryGeneratedColumn,
} from 'typeorm';

@Entity('users')
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Column({ unique: true })
  email: string;

  @Column()
  name: string;
}

// test/setup.ts
import * as dotenv from 'dotenv';
import { DataSource } from 'typeorm';

dotenv.config({ path: '.env.test' });

let dataSource: DataSource;

beforeAll(async () => {
  const { AppModule } = await import('../src/app.module');
  const { Test } = await import('@nestjs/testing');

  const moduleRef = await Test.createTestingModule({
    imports: [AppModule],
  }).compile();

  const app = moduleRef.createNestApplication();
  await app.init();

  dataSource = app.get(DataSource);

  // Створюємо або оновлюємо схему тестової бази міграціями.
  await dataSource.runMigrations();

  await app.close();
});

afterAll(async () => {
  if (dataSource?.isInitialized) {
    await dataSource.destroy();
  }
});

// test/test-database.ts
import { DataSource } from 'typeorm';

export async function clearTestDatabase(
  dataSource: DataSource,
): Promise<void> {
  await dataSource.query(
    'TRUNCATE TABLE "users" RESTART IDENTITY CASCADE',
  );
}

// test/users.integration.spec.ts
import * as dotenv from 'dotenv';
import { INestApplication } from '@nestjs/common';
import { Test, TestingModule } from '@nestjs/testing';
import { DataSource, Repository } from 'typeorm';
import { getRepositoryToken } from '@nestjs/typeorm';

import { AppModule } from '../src/app.module';
import { User } from '../src/users/user.entity';

dotenv.config({ path: '.env.test' });

describe('Users integration', () => {
  let app: INestApplication;
  let dataSource: DataSource;
  let usersRepository: Repository<User>;

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

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

    dataSource = app.get(DataSource);
    usersRepository = app.get<Repository<User>>(
      getRepositoryToken(User),
    );

    // Схема створюється міграціями один раз перед тестами.
    await dataSource.runMigrations();
  });

  afterEach(async () => {
    // Дані кожного сценарію не впливають на наступний сценарій.
    await dataSource.query(
      'TRUNCATE TABLE "users" RESTART IDENTITY CASCADE',
    );
  });

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

  it('створює користувача в тестовій базі', async () => {
    const user = usersRepository.create({
      email: 'anna@example.com',
      name: 'Anna',
    });

    const savedUser = await usersRepository.save(user);

    expect(savedUser.id).toBe(1);
    expect(savedUser.email).toBe('anna@example.com');
  });

  it('починає роботу з порожньою таблицею', async () => {
    const users = await usersRepository.find();

    expect(users).toEqual([]);
  });
});

{
  "scripts": {
    "test:integration": "NODE_ENV=test jest --runInBand --config ./test/jest-integration.json"
  }
}

{
  "moduleFileExtensions": ["js", "json", "ts"],
  "rootDir": "..",
  "testEnvironment": "node",
  "testRegex": ".*\\.integration\\.spec\\.ts$",
  "transform": {
    "^.+\\.(t|j)s$": "ts-jest"
  },
  "moduleNameMapper": {
    "^src/(.*)$": "<rootDir>/src/$1"
  }
}

await usersRepository.delete({});

// test/test-database.ts
import { DataSource } from 'typeorm';

export async function clearTestDatabase(
  dataSource: DataSource,
): Promise<void> {
  await dataSource.query(`
    TRUNCATE TABLE
      "users"
    RESTART IDENTITY CASCADE
  `);
}

console.log({
  environment: process.env.NODE_ENV,
  database: process.env.DATABASE_NAME,
});

{
  environment: 'test',
  database: 'app_test'
}

synchronize: false

await dataSource.runMigrations();