Test database strategies in NestJS

Introduction

Testing with a database helps ensure your app works well with real data. Using test databases keeps your real data safe and your tests reliable.

When you want to check if your database queries return correct results.

When you need to test how your app handles saving or updating data.

When you want to avoid messing up real data during tests.

When you want to run automated tests that include database operations.

When you want to simulate different database states for testing.

Syntax

NestJS

import { Test } from '@nestjs/testing';
import { TypeOrmModule } from '@nestjs/typeorm';

await Test.createTestingModule({
  imports: [
    TypeOrmModule.forRoot({
      type: 'sqlite',
      database: ':memory:',
      entities: [YourEntity],
      synchronize: true,
    }),
    TypeOrmModule.forFeature([YourEntity]),
  ],
  providers: [YourService],
}).compile();

Use an in-memory database like SQLite for fast, isolated tests.

Set synchronize: true to auto-create tables during tests.

Examples

Sets up an in-memory SQLite database for quick tests without files.

NestJS

TypeOrmModule.forRoot({
  type: 'sqlite',
  database: ':memory:',
  entities: [User],
  synchronize: true,
})

Connects to a real Postgres test database for integration tests.

NestJS

TypeOrmModule.forRoot({
  type: 'postgres',
  host: 'localhost',
  port: 5432,
  username: 'test',
  password: 'test',
  database: 'test_db',
  entities: [User],
  synchronize: true,
})

Resets the test database before each test to keep tests independent.

NestJS

await connection.dropDatabase();
await connection.synchronize();

Sample Program

This example shows a NestJS test setup using an in-memory SQLite database. It creates a user and fetches all users to verify database operations work in tests.

NestJS

import { Test } from '@nestjs/testing';
import { TypeOrmModule } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';

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

  @Column()
  name: string;
}

@Injectable()
class UserService {
  constructor(
    @InjectRepository(User)
    private repo: Repository<User>,
  ) {}

  async createUser(name: string) {
    const user = this.repo.create({ name });
    return this.repo.save(user);
  }

  async findAll() {
    return this.repo.find();
  }
}

async function bootstrap() {
  const moduleRef = await Test.createTestingModule({
    imports: [
      TypeOrmModule.forRoot({
        type: 'sqlite',
        database: ':memory:',
        entities: [User],
        synchronize: true,
      }),
      TypeOrmModule.forFeature([User]),
    ],
    providers: [UserService],
  }).compile();

  const userService = moduleRef.get(UserService);

  await userService.createUser('Alice');
  const users = await userService.findAll();
  console.log(users);
}

bootstrap();

Important Notes

Use an in-memory database for fast tests that don't affect real data.

Reset the database state before each test to avoid test interference.

For complex tests, consider using a dedicated test database server.

Summary

Test databases keep your real data safe during testing.

In-memory databases like SQLite are fast and easy for tests.

Resetting the database before tests keeps tests independent and reliable.

Practice

1.

Why do we use a separate test database in NestJS applications?

easy

A. To store user passwords securely

B. To keep real data safe and avoid accidental changes during tests

C. To make the application run faster in production

D. To reduce the size of the main database

Solution

1. Step 1: Understand the purpose of test databases

   Test databases are used to isolate testing data from real data to prevent accidental data loss or corruption.

2. Step 2: Identify the main reason for using test databases in NestJS

   Using a separate test database ensures tests do not affect production data, keeping it safe.

3. Final Answer:

   To keep real data safe and avoid accidental changes during tests -> Option B

4. Quick Check:

   Test database = Protect real data [OK]

Hint: Test DB isolates test data from real data [OK]

Common Mistakes:

• Thinking test DB improves production speed
• Confusing test DB with security for passwords
• Assuming test DB reduces main DB size

2.

Which of the following is the correct way to configure an in-memory SQLite database for testing in a NestJS TypeOrmModule?

TypeOrmModule.forRoot({
  type: 'sqlite',
  database: ???,
  entities: [User],
  synchronize: true,
})

easy

A. 'test.db'

B. 'memory.db'

C. ':disk:'

D. ':memory:'

Solution

1. Step 1: Recall SQLite in-memory database syntax

   SQLite uses ':memory:' as the special name to create a temporary in-memory database.

2. Step 2: Match the correct database name in the config

   Using ':memory:' tells TypeORM to use an in-memory DB for fast, isolated tests.

3. Final Answer:

   ':memory:' -> Option D

4. Quick Check:

   SQLite in-memory DB = ':memory:' [OK]

Hint: SQLite in-memory DB uses ':memory:' string [OK]

Common Mistakes:

• Using a file name instead of ':memory:'
• Confusing ':disk:' as valid SQLite option
• Using arbitrary file names like 'memory.db'

3.

Given this NestJS test setup snippet, what will be the output of console.log(users.length) inside the test?

beforeEach(async () => {
  await connection.synchronize(true); // resets DB
  await userRepository.save([{ name: 'Alice' }, { name: 'Bob' }]);
});

test('users count', async () => {
  const users = await userRepository.find();
  console.log(users.length);
});

medium

A. 1

B. 0

C. 2

D. undefined

Solution

1. Step 1: Understand what synchronize(true) does

   Calling synchronize(true) resets the database, clearing all data before each test.

2. Step 2: Analyze the data saved before the test

   After reset, two users 'Alice' and 'Bob' are saved, so the DB has 2 users.

3. Step 3: Check the find() result

   Finding all users returns an array of length 2.

4. Final Answer:

   2 -> Option C

5. Quick Check:

   Reset + save 2 users = 2 users found [OK]

Hint: Reset DB then save 2 users means find() returns 2 [OK]

Common Mistakes:

• Assuming DB is not reset and counting old data
• Thinking synchronize(true) deletes data after save
• Expecting undefined because of async confusion

4.

What is the main problem with this test database setup code snippet?

beforeAll(async () => {
  await connection.synchronize(true);
});

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

test('should save user', async () => {
  await userRepository.save({ name: 'Charlie' });
  const users = await userRepository.find();
  expect(users.length).toBe(1);
});

test('should find no users initially', async () => {
  const users = await userRepository.find();
  expect(users.length).toBe(0);
});

medium

A. Database is reset only once before all tests, causing data to persist between tests

B. Connection is closed before tests run

C. User repository is not defined

D. Tests run synchronously causing race conditions

Solution

1. Step 1: Analyze when the database reset happens

   Database reset with synchronize(true) is done only once before all tests, not before each test.

2. Step 2: Understand test data persistence

   Data saved in the first test remains in the DB during the second test, causing unexpected results.

3. Final Answer:

   Database is reset only once before all tests, causing data to persist between tests -> Option A

4. Quick Check:

   Reset once beforeAll causes data carryover [OK]

Hint: Reset DB before each test to avoid data carryover [OK]

Common Mistakes:

• Thinking connection closes too early
• Assuming userRepository is undefined
• Believing tests run in parallel causing race

5.

You want to ensure each test in your NestJS app runs with a clean database state using an in-memory SQLite DB. Which strategy best achieves this?

1. Use TypeOrmModule.forRoot with database: ':memory:'
2. Reset the database schema before each test
3. Close and reopen the connection before each test
4. Seed only required test data inside each test

Which combination of these steps is best practice?

hard

A. All steps 1, 2, 3, and 4

B. 1 and 3 only

C. 2, 3, and 4 only

D. 1, 2, and 4 only

Solution

1. Step 1: Use in-memory DB for fast isolated tests

   Setting database to ':memory:' creates a fresh DB in memory for each connection.

2. Step 2: Reset schema before each test

   Resetting schema ensures no leftover data or schema changes affect tests.

3. Step 3: Close and reopen connection before each test

   Reopening connection resets the in-memory DB state fully.

4. Step 4: Seed only needed data per test

   Seeding minimal data keeps tests independent and fast.

5. Final Answer:

   All steps 1, 2, 3, and 4 -> Option A

6. Quick Check:

   Full reset + seed per test = reliable tests [OK]

Hint: Combine in-memory DB, reset, reconnect, and seed per test [OK]

Common Mistakes:

• Skipping connection reopen causing stale DB
• Not resetting schema before tests
• Seeding too much data globally