describe('UserService', () => {
    const userService: UserService = new UserService();
    
    describe('create', () => {
        it('should create user', () => {
            // Given
            ...
            // When
            ...
            // Then
            ...
        });

        it('should throw error when user already exists', () => {
          // Given
          ...
          // When
          ...
          // Then
          ...
        });
    });
});

import { Injectable } from '@nestjs/common';
import { EventBus } from '@nestjs/cqrs';
import { User } from './user';
import { UserCreateEvent } from './user-create.event';

@Injectable()
export class UserFactory {
  constructor(private eventBus: EventBus) {}

  // 유저 객체 생성
  create(
    id: string,
    name: string,
    email: string,
    password: string,
    signupVerifyToken: string,
  ): User {
    // User 객체 생성 후 UserCreatedEvent 발행함, 이후 생성한 유저 도메인 객체 리턴
    const user = new User(id, name, email, password, signupVerifyToken);
    this.eventBus.publish(new UserCreateEvent(email, signupVerifyToken));
    return user;
  }

  // 이벤트 발행없이 유저 객체만 생성
  reconstitute(
    id: string,
    name: string,
    email: string,
    signupVerifyToken: string,
    password: string,
  ): User {
    return new User(id, name, email, signupVerifyToken, password);
  }
}

import { UserFactory } from './user.factory';

describe('UserFactory', () => {
  let userFactory: UserFactory; // test suite 전체에서 사용할 UserFactory

  describe('create', () => {
    it('should create user', () => {
      // Given
      // When
      // Then
    });
  });

  describe('reconstitute', () => {
    it('should reconstitute user', () => {
      // Given
      // When
      // Then
    });
  });
});

import { UserFactory } from './user.factory';
import { Test } from '@nestjs/testing';

describe('UserFactory', () => {
  let userFactory: UserFactory; // test suite 전체에서 사용할 UserFactory

  // Test.createTestingModule() 함수를 이용하여 테스트 모듈 생성
  // 함수의 인수가 ModuleMetadata 이므로 모듈을 임포트할때와 동일하게 컴포넌트 가져올 수 있음
  // UserFactory 가 대상 클래스이므로 이 모듈을 프로바이더로 가져옴
  // 모듈을 가져오는 것은 전체 test suite 내에서 한 번만 이루어지므로 설정 단계인 beforeAll() 구문 내에서 수행
  // Test.createTestingModule() 의 리턴값은 TestingModuleBuilder 임, compile 함수를 수행하여 모듈 생성을 완료한다. (이 함수는 비동기로 처리됨)
  beforeAll(async () => {
    const module = await Test.createTestingModule({
      providers: [UserFactory],
    }).compile();

    userFactory = module.get(UserFactory); // 프로바이더로 제공된 UserFactory 객체를 테스트 모듈에서 가져옴
  });
  
  describe('create', () => {
    ...
  });

  describe('reconstitute', () => {
    ...
  });
});

// 유저 객체 생성
create(
  id: string,
  name: string,
  email: string,
  password: string,
  signupVerifyToken: string,
): User {
  // User 객체 생성 후 UserCreatedEvent 발행함, 이후 생성한 유저 도메인 객체 리턴
  const user = new User(id, name, email, password, signupVerifyToken);
  this.eventBus.publish(new UserCreateEvent(email, signupVerifyToken));
  return user;
}

...
import { Test } from '@nestjs/testing';
import { EventBus } from '@nestjs/cqrs';

describe('UserFactory', () => {
  ...
  let eventBus: jest.Mocked<EventBus>; // Jest 에서 제공하는 Mocked 객체로 EventBus 선언

  beforeAll(async () => {
    const module = await Test.createTestingModule({
      providers: [
        ...
        // EventBus 를 프로바이더로 제공
        // 이 때 EventBus 의 함수를 mocking 함
        // publish 함수가 jest.fn() 으로 선언되었는데 이는 어떠한 동작도 하지 않는 함수라는 의미
        {
          provide: EventBus,
          useValue: {
            publish: jest.fn(),
          },
        },
      ],
    }).compile();

    ...
    eventBus = module.get(EventBus); // 프로바이더로 제공된 EventBus 객체를 테스트 모듈에서 가져옴
  });

  describe('create', () => {
    ...
  });

  describe('reconstitute', () => {
    ...
  });
});

...
import { User } from './user';

describe('UserFactory', () => {
  ...

  describe('create', () => {
    it('should create user', () => {
      // Given
      // 주어진 조건은 딱히 없으므로 작성하지 않음

      // When
      // create 함수 실행
      const user = userFactory.create(
        'user-id',
        'assu3',
        'test3@test.com',
        'password1234',
        'signup-verify-token',
      );

      // Then
      // 수행 결과가 원하는 결과와 맞는지 검증
      // When 단계 수행 시 원하는 결과를 선언하고 Jest 에서 제공하는 Matcher 를 이용하여 판단
      const expected = new User(
        'user-id',
        'assu3',
        'test3@test.com',
        'password1234',
        'signup-verify-token',
      );

      // UserFactory.create 를 통해 생성한 User 객체가 원하는 객체와 맞는지 검사
      expect(expected).toEqual(user);

      // EventBus.publish 함수가 한번 호출되었는지 판단
      expect(eventBus.publish).toBeCalledTimes(1);
    });
  });
...
});

import { UserFactory } from './user.factory';
import { Test } from '@nestjs/testing';
import { EventBus } from '@nestjs/cqrs';
import { User } from './user';

describe('UserFactoryTest', () => {
  let userFactory: UserFactory; // test suite 전체에서 사용할 UserFactory
  let eventBus: jest.Mocked<EventBus>; // Jest 에서 제공하는 Mocked 객체로 EventBus 선언

  // Test.createTestingModule() 함수를 이용하여 테스트 모듈 생성
  // 함수의 인수가 ModuleMetadata 이므로 모듈을 임포트할때와 동일하게 컴포넌트 가져올 수 있음
  // UserFactory 가 대상 클래스이므로 이 모듈을 프로바이더로 가져옴
  // 모듈을 가져오는 것은 전체 test suite 내에서 한 번만 이루어지므로 설정 단계인 beforeAll() 구문 내에서 수행
  // Test.createTestingModule() 의 리턴값은 TestingModuleBuilder 임, compile 함수를 수행하여 모듈 생성을 완료한다. (이 함수는 비동기로 처리됨)
  beforeAll(async () => {
    const module = await Test.createTestingModule({
      providers: [
        UserFactory,
        // EventBus 를 프로바이더로 제공
        // 이 때 EventBus 의 함수를 mocking 함
        // publish 함수가 jest.fn() 으로 선언되었는데 이는 어떠한 동작도 하지 않는 함수라는 의미
        {
          provide: EventBus,
          useValue: {
            publish: jest.fn(),
          },
        },
      ],
    }).compile();

    userFactory = module.get(UserFactory); // 프로바이더로 제공된 UserFactory 객체를 테스트 모듈에서 가져옴
    eventBus = module.get(EventBus); // 프로바이더로 제공된 EventBus 객체를 테스트 모듈에서 가져옴
  });

  describe('createTest', () => {
    it('should create user', () => {
      // Given
      // 주어진 조건은 딱히 없으므로 작성하지 않음

      // When
      // create 함수 실행
      const user = userFactory.create(
              'user-id',
              'assu3',
              'test3@test.com',
              'password1234',
              'signup-verify-token',
      );

      // Then
      // 수행 결과가 원하는 결과와 맞는지 검증
      // When 단계 수행 시 원하는 결과를 선언하고 Jest 에서 제공하는 Matcher 를 이용하여 판단
      const expected = new User(
              'user-id',
              'assu3',
              'test3@test.com',
              'password1234',
              'signup-verify-token',
      );

      // UserFactory.create 를 통해 생성한 User 객체가 원하는 객체와 맞는지 검사
      expect(expected).toEqual(user);

      // EventBus.publish 함수가 한번 호출되었는지 판단
      expect(eventBus.publish).toBeCalledTimes(1);
    });
  });

  describe('reconstituteTest', () => {
    it('should reconstitute user', () => {
      // Given
      // 주어진 조건은 딱히 없으므로 작성하지 않음

      // When
      const user = userFactory.reconstitute(
              'user-id',
              'assu3',
              'test3@test.com',
              'password1234',
              'signup-verify-token',
      );

      // Then
      const expected = new User(
              'user-id',
              'assu3',
              'test3@test.com',
              'password1234',
              'signup-verify-token',
      );

      // UserFactory.create 를 통해 생성한 User 객체가 원하는 객체와 맞는지 검사
      expect(expected).toEqual(user);
    });
  });
});

import * as uuid from 'uuid';
import * as ulid from 'ulid';
import { UserRepository } from 'src/users/infra/db/repository/UserRepository';
import { CreateUserHandler } from './create-user.handler';
import { Test } from '@nestjs/testing';
import { CreateUserCommand } from './create-user.command';
import { UserFactory } from '../../domain/user.factory';
import { UnprocessableEntityException } from '@nestjs/common';

// CreateUserHandler.execute() 에서 uuid, ulid 사용
// 외부 라이브러리가 생성하는 임의의 문자열이 항상 값은 값인 '0000-0000-0000-0000', 'ulid' 를 리턴하도록 함
jest.mock('uuid');
jest.mock('ulid');
jest.spyOn(uuid, 'v1').mockReturnValue('0000-0000-0000-0000');
jest.spyOn(ulid, 'ulid').mockReturnValue('ulid');

describe('CreateUserHandlerTest', () => {
  // 테스트 대상인 CreateUserHandler 와 의존하고 있는 클래스 선언
  let createUserHandler: CreateUserHandler;
  let userFactory: UserFactory;
  let userRepository: UserRepository;

  beforeAll(async () => {
    const module = await Test.createTestingModule({
      providers: [
        CreateUserHandler,
        // UserFactory, UserRepository 를 mock 객체로 제공
        {
          provide: UserFactory,
          useValue: {
            create: jest.fn(),
          },
        },
        {
          provide: 'UserRepository',
          useValue: {
            save: jest.fn(),
          },
        },
      ],
    }).compile();

    createUserHandler = module.get(CreateUserHandler);
    userFactory = module.get(UserFactory);
    userRepository = module.get('UserRepository');
  });

  // 항상 같은 값을 갖는 변수를 미리 선언하고 재사용하도록 함
  const id = ulid.ulid();
  const name = 'assu';
  const email = 'test3@test.com';
  const password = 'password1234';
  const signupVerifyToken = uuid.v1();

  describe('executeTest', () => {
    it('should execute CreateUserHandler', async () => {
      // Given
      // userRepository 에 저장된 유저가 없는 조건 설정
      userRepository.findByEmail = jest.fn().mockResolvedValue(null);

      // When
      // execute 함수 실행
      await createUserHandler.execute(
        new CreateUserCommand(name, email, password),
      );

      // Then
      // 수행 결과가 원하는 결과와 맞는지 검증
      // When 단계 수행 시 원하는 결과를 선언하고 Jest 에서 제공하는 Matcher 를 이용하여 판단
      // UserFactory 에서는 테스트 대상 클래스가 의존하고 있는 객체의 함수를 단순히 호출하는지만 검증했다면 이번엔 인수까지 제대로 넘기고 있는지 검증
      expect(userRepository.save).toBeCalledWith(
        id,
        name,
        email,
        password,
        signupVerifyToken,
      );

      expect(userFactory.create).toBeCalledWith(
        id,
        name,
        email,
        password,
        signupVerifyToken,
      );
    });

    // UserRepository 에 유저 정보가 있을 경우 test case
    it('should throw UnprocessableEntityException when user exists', async () => {
      // Given
      // 생성하려는 유저 정보가 이미 있는 경우를 mocking
      userRepository.findByEmail = jest.fn().mockResolvedValue({
        id,
        name,
        email,
        password,
        signupVerifyToken,
      });

      // When

      // Then
      // 원하는 예외가 발생하는가?
      await expect(
        createUserHandler.execute(new CreateUserCommand(name, email, password)),
      ).rejects.toThrowError(UnprocessableEntityException);
    });
  });
});