단위 테스트 작성과 모킹

import { Injectable } from '@nestjs/common';

@Injectable()
export class AppService {
  getHello(): string {
    return 'Hello World!';
  }

  sum(a: number, b: number): number {
    return a + b;
  }
}

import { Test, TestingModule } from '@nestjs/testing';
import { AppService } from './app.service';

describe('AppService', () => { // 'describe' 블록은 테스트 그룹을 정의합니다.
  let service: AppService; // 테스트할 서비스 인스턴스

  // 각 테스트 실행 전에 이 블록이 실행됩니다.
  // 여기서는 NestJS 테스트 모듈을 설정하고 서비스 인스턴스를 가져옵니다.
  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [AppService], // 테스트할 서비스(AppService)를 프로바이더로 등록
    }).compile(); // 모듈 컴파일

    service = module.get<AppService>(AppService); // 컴파일된 모듈에서 AppService 인스턴스 가져오기
  });

  // 'it' 또는 'test' 블록은 개별 테스트 케이스를 정의합니다.
  it('should be defined', () => {
    // AppService 인스턴스가 성공적으로 생성되었는지 확인
    expect(service).toBeDefined();
  });

  it('should return "Hello World!"', () => {
    // getHello() 메서드가 예상된 문자열을 반환하는지 확인
    expect(service.getHello()).toBe('Hello World!');
  });

  it('should return the sum of two numbers', () => {
    // sum() 메서드가 올바른 합계를 반환하는지 확인
    expect(service.sum(1, 2)).toBe(3);
    expect(service.sum(-1, 1)).toBe(0);
    expect(service.sum(0, 0)).toBe(0);
  });
});

npm run test # 또는 npm test

import { Injectable } from '@nestjs/common';

interface User {
  id: number;
  name: string;
  email: string;
}

// 가상의 DatabaseService (실제로는 ORM이나 DB 클라이언트가 될 수 있음)
@Injectable()
export class DatabaseService {
  private users: User[] = [
    { id: 1, name: 'Alice', email: '[email protected]' },
    { id: 2, name: 'Bob', email: '[email protected]' },
  ];
  private nextId = 3;

  async findOneUser(id: number): Promise<User | undefined> {
    // 실제 DB 호출 로직 (비동기)
    console.log(`[DB] Finding user with ID: ${id}`);
    return Promise.resolve(this.users.find(user => user.id === id));
  }

  async createUser(user: { name: string; email: string }): Promise<User> {
    // 실제 DB 삽입 로직 (비동기)
    const newUser = { id: this.nextId++, ...user };
    this.users.push(newUser);
    console.log(`[DB] Creating user: ${newUser.name}`);
    return Promise.resolve(newUser);
  }
}

@Injectable()
export class UsersService {
  constructor(private readonly databaseService: DatabaseService) {} // DatabaseService 의존성 주입

  async getUserById(id: number): Promise<User | undefined> {
    return this.databaseService.findOneUser(id);
  }

  async createUser(name: string, email: string): Promise<User> {
    // 사용자 생성 전 추가 로직이 있을 수 있음
    const newUser = await this.databaseService.createUser({ name, email });
    // 예를 들어, 환영 이메일 발송 등
    return newUser;
  }
}

import { Test, TestingModule } from '@nestjs/testing';
import { UsersService } from './users.service';
import { DatabaseService } from './users.service';

const createDatabaseServiceMock = () => ({
  findOneUser: jest.fn(),
  createUser: jest.fn(),
});

describe('UsersService', () => {
  let service: UsersService;
  let databaseServiceMock: ReturnType<typeof createDatabaseServiceMock>;

  beforeEach(async () => {
    // 테스트마다 새 double을 만들어 호출 기록과 구현을 공유하지 않습니다.
    databaseServiceMock = createDatabaseServiceMock();

    const module: TestingModule = await Test.createTestingModule({
      providers: [
        UsersService,
        {
          provide: DatabaseService,
          useValue: databaseServiceMock,
        },
      ],
    }).compile();

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

  it('should be defined', () => {
    expect(service).toBeDefined();
  });

  describe('getUserById', () => {
    it('should return a user if found', async () => {
      databaseServiceMock.findOneUser.mockResolvedValueOnce({
        id: 1,
        name: 'MockUser1',
        email: '[email protected]',
      });

      const user = await service.getUserById(1);

      expect(user).toEqual({ id: 1, name: 'MockUser1', email: '[email protected]' });
      expect(databaseServiceMock.findOneUser).toHaveBeenCalledTimes(1);
      expect(databaseServiceMock.findOneUser).toHaveBeenCalledWith(1);
    });

    it('should return undefined if user not found', async () => {
      databaseServiceMock.findOneUser.mockResolvedValueOnce(undefined);

      const user = await service.getUserById(2);

      expect(user).toBeUndefined();
      expect(databaseServiceMock.findOneUser).toHaveBeenCalledWith(2);
    });
  });

  describe('createUser', () => {
    it('should create and return a new user', async () => {
      databaseServiceMock.createUser.mockResolvedValueOnce({
        id: 99,
        name: 'New User',
        email: '[email protected]',
      });

      const newUser = await service.createUser('New User', '[email protected]');

      expect(newUser).toEqual({ id: 99, name: 'New User', email: '[email protected]' });
      expect(databaseServiceMock.createUser).toHaveBeenCalledTimes(1);
      expect(databaseServiceMock.createUser).toHaveBeenCalledWith({ name: 'New User', email: '[email protected]' });
    });
  });
});

it('should propagate a database failure', async () => {
  const failure = new Error('DB offline');
  databaseServiceMock.findOneUser.mockRejectedValueOnce(failure);

  await expect(service.getUserById(7)).rejects.toBe(failure);
  expect(databaseServiceMock.findOneUser).toHaveBeenCalledTimes(1);
  expect(databaseServiceMock.findOneUser).toHaveBeenCalledWith(7);
});

import { Controller, Get, Post, Body } from '@nestjs/common';
import { AppService } from './app.service';

@Controller('app')
export class AppController {
  constructor(private readonly appService: AppService) {}

  @Get('hello')
  getHello(): string {
    return this.appService.getHello();
  }

  @Post('sum')
  sumNumbers(@Body() data: { a: number; b: number }): number {
    return this.appService.sum(data.a, data.b);
  }
}

import { Test, TestingModule } from '@nestjs/testing';
import { AppController } from './app.controller';
import { AppService } from './app.service';

const createAppServiceMock = () => ({
  getHello: jest.fn(),
  sum: jest.fn(),
});

describe('AppController', () => {
  let appController: AppController;
  let appServiceMock: ReturnType<typeof createAppServiceMock>;

  beforeEach(async () => {
    appServiceMock = createAppServiceMock();

    const app: TestingModule = await Test.createTestingModule({
      controllers: [AppController],
      providers: [
        {
          provide: AppService,
          useValue: appServiceMock,
        },
      ],
    }).compile();

    appController = app.get<AppController>(AppController);
  });

  it('should be defined', () => {
    expect(appController).toBeDefined();
  });

  describe('getHello', () => {
    it('should return "Hello from Mock!"', () => {
      appServiceMock.getHello.mockReturnValueOnce('Hello from Mock!');

      const result = appController.getHello();

      expect(result).toBe('Hello from Mock!');
      expect(appServiceMock.getHello).toHaveBeenCalledTimes(1);
    });
  });

  describe('sumNumbers', () => {
    it('should return the sum from the service', () => {
      // 계산을 mock에 복제하지 않고 이번 협력 결과만 정합니다.
      appServiceMock.sum.mockReturnValueOnce(8);

      const result = appController.sumNumbers({ a: 5, b: 3 });

      expect(result).toBe(8);
      expect(appServiceMock.sum).toHaveBeenCalledTimes(1);
      expect(appServiceMock.sum).toHaveBeenCalledWith(5, 3);
    });
  });
});