Unit Testing Guide

src/
├── employee/
│   ├── employee.service.ts
│   ├── employee.service.spec.ts    ← unit test
│   ├── employee.controller.ts
│   └── employee.controller.spec.ts

# Run all tests
yarn test

# Run tests for a specific package
yarn test --project=@gauzy/core

# Run in watch mode
yarn test --watch

# With coverage
yarn test --coverage

import { Test, TestingModule } from "@nestjs/testing";
import { EmployeeService } from "./employee.service";
import { TypeOrmEmployeeRepository } from "./repository/type-orm-employee.repository";

describe("EmployeeService", () => {
  let service: EmployeeService;
  let mockRepo: jest.Mocked<TypeOrmEmployeeRepository>;

  beforeEach(async () => {
    mockRepo = {
      findOne: jest.fn(),
      save: jest.fn(),
      find: jest.fn(),
      delete: jest.fn(),
    } as any;

    const module: TestingModule = await Test.createTestingModule({
      providers: [
        EmployeeService,
        {
          provide: TypeOrmEmployeeRepository,
          useValue: mockRepo,
        },
      ],
    }).compile();

    service = module.get<EmployeeService>(EmployeeService);
  });

  describe("findById", () => {
    it("should return an employee by ID", async () => {
      const employee = { id: "uuid", firstName: "John" };
      mockRepo.findOne.mockResolvedValue(employee as any);

      const result = await service.findOneByIdString("uuid");
      expect(result).toEqual(employee);
      expect(mockRepo.findOne).toHaveBeenCalledWith({
        where: { id: "uuid" },
      });
    });

    it("should throw if employee not found", async () => {
      mockRepo.findOne.mockResolvedValue(null);
      await expect(service.findOneByIdString("bad-id")).rejects.toThrow();
    });
  });
});

describe("EmployeeController", () => {
  let controller: EmployeeController;
  let service: jest.Mocked<EmployeeService>;

  beforeEach(async () => {
    service = {
      findAll: jest.fn(),
      create: jest.fn(),
    } as any;

    const module = await Test.createTestingModule({
      controllers: [EmployeeController],
      providers: [{ provide: EmployeeService, useValue: service }],
    }).compile();

    controller = module.get(EmployeeController);
  });

  it("should return paginated employees", async () => {
    service.findAll.mockResolvedValue({ items: [], total: 0 });
    const result = await controller.findAll({});
    expect(result.total).toBe(0);
  });
});