nestjs-testing-utils

A lightweight utility package for NestJS providing a generic mock in-memory repository and validation pipes to simplify both unit testing and production use.

Installation

npm install nestjs-testing-utils
# or
yarn add nestjs-testing-utils

What's Included

| Export | Description | |---|---| | BaseMockRepository<T> | Generic in-memory repository implementing IRepository<T> | | Validator<T> | NestJS pipe that validates a full request body against a reference object | | UpdateValidator<T> | NestJS pipe that validates partial update request bodies | | IRepository<T> | TypeScript interface for repository abstraction |

Usage

IRepository<T> — Repository Interface

Use this interface to type your repositories in services, keeping them decoupled from the underlying data source (TypeORM, mock, etc).

import { type IRepository } from 'nestjs-testing-utils';
import { Order } from './entities/order.entity';

@Injectable()
export class OrdersService {
  constructor(
    @Inject('OrderRepository')
    private readonly orderRepo: IRepository<Order>,
  ) {}
}

BaseMockRepository<T> — In-Memory Mock Repository

Extend BaseMockRepository to create a mock repository backed by an in-memory array. Useful for unit tests or in-memory/mock database modules.

import { BaseMockRepository } from 'nestjs-testing-utils';
import { Order } from './entities/order.entity';
import { mockOrders } from '../mockDatas/orders.stub';

export class OrderMockRepository extends BaseMockRepository<Order> {
  constructor() {
    super(Promise.resolve(mockOrders));
  }

  // Optionally override methods for custom behaviour
  async create(entity: Order): Promise<Order | null> {
    return super.create({ ...entity, time: new Date() });
  }
}

You can also implement IRepository<T> on your production TypeORM repository to keep the same interface:

import { IRepository } from 'nestjs-testing-utils';
import { Repository } from 'typeorm';

export class BaseTypeormRepository<T extends { id: string }>
  implements IRepository<T>
{
  constructor(protected readonly repo: Repository<T>) {}
  // ... implement methods
}

Using in NestJS Unit Tests

IRepository<T> makes it easy to mock repositories in @nestjs/testing:

import { IRepository } from 'nestjs-testing-utils';
import { Order } from './entities/order.entity';

describe('OrdersService', () => {
  let orderRepo: IRepository<Order>;

  beforeEach(async () => {
    const module = await Test.createTestingModule({
      providers: [
        OrdersService,
        {
          provide: 'OrderRepository',
          useValue: {
            create: jest.fn(),
            update: jest.fn(),
            findBy: jest.fn(),
            findOneBy: jest.fn(),
            deleteBy: jest.fn(),
            isExists: jest.fn(),
          },
        },
      ],
    }).compile();

    orderRepo = module.get<IRepository<Order>>('OrderRepository');
  });
});

Validator<T> — Full Body Validation Pipe

Validates that an incoming request body matches the full structure and types of a reference object. Throws BadRequestException if any field is missing or has the wrong type.

import { Validator } from 'nestjs-testing-utils';

const referenceOrder = { username: '', productId: '', quantity: 0 };

@Post()
create(@Body(new Validator(referenceOrder)) body: CreateOrderDto) {
  return this.ordersService.create(body);
}

UpdateValidator<T> — Partial Update Validation Pipe

Validates partial update bodies — only validates fields that are present in the request.

import { UpdateValidator } from 'nestjs-testing-utils';

const referenceOrder = { username: '', productId: '', quantity: 0 };

@Patch(':id')
update(@Body(new UpdateValidator(referenceOrder)) body: Partial<CreateOrderDto>) {
  return this.ordersService.update(body);
}

IRepository<T> Interface

export interface IRepository<T> {
  create(entity: Partial<T>): Promise<T | null>;
  findBy(where?: Partial<T>, isOr?: boolean): Promise<T[]>;
  isExists(where: Partial<T>, isOr?: boolean): Promise<boolean>;
  findOneBy(where: Partial<T>, isOr?: boolean): Promise<T | null>;
  update(entity: Partial<T> & { id: string }): Promise<T | null>;
  deleteBy(where: Partial<T>, isOr?: boolean): Promise<void>;
}

License

ISC