feat/#66: create test code

src/apis/auth/jwt/jwt.guard.ts

@@ -7,6 +7,7 @@ import { HttpUnauthorizedException } from '@src/http-exceptions/exceptions/http-
 export class JwtAuthGuard extends AuthGuard('jwt') {
   handleRequest(err, user) {
     if (err || !user) {
+      console.log(err, user);
       throw new HttpUnauthorizedException({
         code: COMMON_ERROR_CODE.INVALID_TOKEN,
       });

src/apis/notice-boards/controllers/notice-boards.controller.spec.ts

@@ -1,18 +1,75 @@
+import { faker } from '@faker-js/faker';
 import { Test, TestingModule } from '@nestjs/testing';
+import { UserDto } from '@src/apis/users/dto/user.dto';
+import { mockNoticeBoardsService } from '@test/mock/mock.service';
+import { CreateNoticeBoardDto } from '../dto/create-notice-board.dto';
+import { FindNoticeBoardListQueryDto } from '../dto/find-notice-board-list-query.dto';
+import { NoticeBoardDto } from '../dto/notice-board.dto';
+import { NoticeBoardsService } from '../services/notice-boards.service';
 import { NoticeBoardsController } from './notice-boards.controller';
 
-describe('NoticeBoardsController', () => {
+describe(NoticeBoardsController.name, () => {
   let controller: NoticeBoardsController;
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
       controllers: [NoticeBoardsController],
+      providers: [
+        {
+          provide: NoticeBoardsService,
+          useValue: mockNoticeBoardsService,
+        },
+      ],
     }).compile();
 
     controller = module.get<NoticeBoardsController>(NoticeBoardsController);
   });
 
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
   it('should be defined', () => {
     expect(controller).toBeDefined();
   });
+
+  describe(NoticeBoardsController.prototype.create.name, () => {
+    let user: UserDto;
+    let createNoticeBoardDto: CreateNoticeBoardDto;
+
+    let newNoticeBoard: NoticeBoardDto;
+
+    beforeEach(() => {
+      user = new UserDto();
+      createNoticeBoardDto = new CreateNoticeBoardDto();
+
+      newNoticeBoard = new NoticeBoardDto();
+    });
+
+    it('create Notice board', async () => {
+      user.id = faker.number.int();
+
+      mockNoticeBoardsService.create.mockResolvedValue(newNoticeBoard);
+
+      await expect(
+        controller.create(user, createNoticeBoardDto),
+      ).resolves.toEqual(newNoticeBoard);
+    });
+  });
+
+  describe(NoticeBoardsController.prototype.findAllAndCount.name, () => {
+    let findNoticeBoardListQueryDto: FindNoticeBoardListQueryDto;
+
+    beforeEach(() => {
+      findNoticeBoardListQueryDto = new FindNoticeBoardListQueryDto();
+    });
+
+    it('find all and count', async () => {
+      mockNoticeBoardsService.findAllAndCount.mockResolvedValue([[], 0]);
+
+      await expect(
+        controller.findAllAndCount(findNoticeBoardListQueryDto),
+      ).resolves.toEqual([[], 0]);
+    });
+  });
 });

src/apis/notice-boards/dto/find-notice-board-list-query.dto.ts

@@ -37,6 +37,7 @@ export class FindNoticeBoardListQueryDto
     description: 'title 필터링',
     maxLength: NOTICE_BOARD_TITLE_LENGTH.MAX,
   })
+  @IsOptional()
   title?: string;
 
   @ApiPropertyOptional({

src/apis/notice-boards/dto/notice-board.dto.ts

@@ -14,9 +14,9 @@ export class NoticeBoardDto
       | 'id'
       | 'title'
       | 'description'
+      | 'userId'
       | 'hit'
       | 'allowComment'
-      | 'userId'
       | 'createdAt'
       | 'updatedAt'
     >
@@ -33,6 +33,12 @@ export class NoticeBoardDto
   })
   description: string;
 
+  @ApiProperty({
+    description: '게시글 작성자 고유 ID',
+    format: 'integer',
+  })
+  userId: number;
+
   @ApiProperty({
     description: '공지 게시글 조회수',
     default: 0,
@@ -48,12 +54,6 @@ export class NoticeBoardDto
   })
   allowComment: boolean;
 
-  @ApiProperty({
-    description: '게시글 작성자 고유 ID',
-    format: 'integer',
-  })
-  userId: number;
-
   constructor(noticeBoardDto: Partial<NoticeBoardDto> = {}) {
     super();
 

src/apis/notice-boards/notice-board-history/services/notice-board-history.service.spec.ts

@@ -0,0 +1,65 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { getRepositoryToken } from '@nestjs/typeorm';
+import {
+  mockEntityManager,
+  mockNoticeBoardHistoryRepository,
+} from '@test/mock/mock.repository';
+
+import { NoticeBoardHistory } from '@src/entities/NoticeBoardHistory';
+import { CreateNoticeBoardHistoryDto } from '../dto/create-notice-board-history.dto';
+import { NoticeBoardHistoryService } from './notice-board-history.service';
+
+describe(NoticeBoardHistoryService.name, () => {
+  let service: NoticeBoardHistoryService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        NoticeBoardHistoryService,
+        {
+          provide: getRepositoryToken(NoticeBoardHistory),
+          useValue: mockNoticeBoardHistoryRepository,
+        },
+      ],
+    }).compile();
+
+    service = module.get<NoticeBoardHistoryService>(NoticeBoardHistoryService);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+
+  describe(NoticeBoardHistoryService.prototype.create.name, () => {
+    let entityManager: any;
+    let userId: number;
+    let noticeBoardId: number;
+    let createNoticeBoardHistoryDto: CreateNoticeBoardHistoryDto;
+
+    beforeEach(() => {
+      entityManager = mockEntityManager;
+      userId = NaN;
+      noticeBoardId = NaN;
+      createNoticeBoardHistoryDto = new CreateNoticeBoardHistoryDto({} as any);
+    });
+
+    it('create notice board history', async () => {
+      mockNoticeBoardHistoryRepository.save.mockResolvedValue(
+        createNoticeBoardHistoryDto,
+      );
+
+      await expect(
+        service.create(
+          entityManager,
+          userId,
+          noticeBoardId,
+          createNoticeBoardHistoryDto,
+        ),
+      ).resolves.toEqual({});
+    });
+  });
+});

src/apis/notice-boards/services/notice-boards.service.spec.ts

@@ -1,18 +1,118 @@
+import { faker } from '@faker-js/faker';
 import { Test, TestingModule } from '@nestjs/testing';
+import { getRepositoryToken } from '@nestjs/typeorm';
+import { SortOrder } from '@src/constants/enum';
+import { QueryHelper } from '@src/helpers/query.helper';
+import { mockQueryHelper } from '@test/mock/mock.helper';
+import {
+  mockDataSource,
+  mockNoticeBoardRepository,
+} from '@test/mock/mock.repository';
+import { mockNoticeBoardHistoryService } from '@test/mock/mock.service';
+import { DataSource } from 'typeorm';
 import { NoticeBoardsService } from './notice-boards.service';
+import { NoticeBoardDto } from '../dto/notice-board.dto';
+import { CreateNoticeBoardDto } from '../dto/create-notice-board.dto';
+import { NoticeBoardHistoryService } from '../notice-board-history/services/notice-board-history.service';
+import { NoticeBoard } from '@src/entities/NoticeBoard';
+import { FindNoticeBoardListQueryDto } from '../dto/find-notice-board-list-query.dto';
 
-describe('NoticeBoardsService', () => {
+describe(NoticeBoardsService.name, () => {
   let service: NoticeBoardsService;
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
-      providers: [NoticeBoardsService],
+      providers: [
+        NoticeBoardsService,
+        {
+          provide: NoticeBoardHistoryService,
+          useValue: mockNoticeBoardHistoryService,
+        },
+        {
+          provide: QueryHelper,
+          useValue: mockQueryHelper,
+        },
+        {
+          provide: DataSource,
+          useValue: mockDataSource,
+        },
+        {
+          provide: getRepositoryToken(NoticeBoard),
+          useValue: mockNoticeBoardRepository,
+        },
+      ],
     }).compile();
 
     service = module.get<NoticeBoardsService>(NoticeBoardsService);
   });
 
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
   it('should be defined', () => {
     expect(service).toBeDefined();
   });
+
+  describe(NoticeBoardsService.prototype.create.name, () => {
+    let userId: number;
+    let createNoticeBoardDto: CreateNoticeBoardDto;
+
+    beforeEach(() => {
+      userId = NaN;
+      createNoticeBoardDto = new CreateNoticeBoardDto();
+    });
+
+    it('create notice board', async () => {
+      userId = faker.number.int();
+
+      mockNoticeBoardRepository.save.mockResolvedValue({ id: 1 });
+
+      await expect(
+        service.create(userId, createNoticeBoardDto),
+      ).resolves.toEqual({
+        id: 1,
+      });
+
+      expect(mockNoticeBoardHistoryService.create).toHaveBeenCalled();
+    });
+  });
+
+  describe(NoticeBoardsService.prototype.findAllAndCount.name, () => {
+    let findNoticeBoardListQueryDto: FindNoticeBoardListQueryDto;
+
+    let noticeBoards: NoticeBoardDto[];
+    let count: number;
+
+    beforeEach(() => {
+      findNoticeBoardListQueryDto = new FindNoticeBoardListQueryDto();
+
+      noticeBoards = [];
+      count = NaN;
+    });
+
+    it('default option findAllAndCount', async () => {
+      findNoticeBoardListQueryDto.page = 0;
+      findNoticeBoardListQueryDto.pageSize = 20;
+      findNoticeBoardListQueryDto.order = { id: SortOrder.Desc };
+
+      mockQueryHelper.buildWherePropForFind.mockReturnValue({});
+      mockNoticeBoardRepository.findAndCount.mockResolvedValue([
+        noticeBoards,
+        count,
+      ]);
+
+      await expect(
+        service.findAllAndCount(findNoticeBoardListQueryDto),
+      ).resolves.toEqual([noticeBoards, count]);
+
+      expect(mockNoticeBoardRepository.findAndCount).toHaveBeenCalledWith({
+        select: expect.anything(),
+        where: {},
+        order: { id: SortOrder.Desc },
+        skip: 0,
+        take: 20,
+      });
+    });
+  });
 });

src/apis/notice-boards/services/notice-boards.service.ts

@@ -77,6 +77,7 @@ export class NoticeBoardsService {
     findNoticeBoardListQueryDto: FindNoticeBoardListQueryDto,
   ): Promise<[NoticeBoardsItemDto[], number]> {
     const { page, pageSize, order, ...filter } = findNoticeBoardListQueryDto;
+    console.log(findNoticeBoardListQueryDto);
 
     const where = this.queryHelper.buildWherePropForFind(
       filter,

test/mock/mock.repository.ts

@@ -1,6 +1,8 @@
 import { UserRepository } from '@src/apis/users/repositories/user.repository';
 import { FreeBoard } from '@src/entities/FreeBoard';
 import { FreeBoardHistory } from '@src/entities/FreeBoardHistory';
+import { NoticeBoard } from '@src/entities/NoticeBoard';
+import { NoticeBoardHistory } from '@src/entities/NoticeBoardHistory';
 import { MockProvider } from '@test/mock/mock.type';
 import { Repository } from 'typeorm';
 
@@ -87,3 +89,14 @@ export const mockFreeBoardHistoryRepository: MockProvider<
 > = {
   ...getDefaultRepositoryMethod(),
 };
+
+export const mockNoticeBoardRepository: MockProvider<Repository<NoticeBoard>> =
+  {
+    ...getDefaultRepositoryMethod(),
+  };
+
+export const mockNoticeBoardHistoryRepository: MockProvider<
+  Repository<NoticeBoardHistory>
+> = {
+  ...getDefaultRepositoryMethod(),
+};

test/mock/mock.service.ts

@@ -2,6 +2,8 @@ import { JwtService } from '@nestjs/jwt';
 import { AuthService } from '@src/apis/auth/services/auth.service';
 import { FreeBoardHistoryService } from '@src/apis/free-boards/free-board-history/services/free-board-history.service';
 import { FreeBoardsService } from '@src/apis/free-boards/services/free-board.service';
+import { NoticeBoardHistoryService } from '@src/apis/notice-boards/notice-board-history/services/notice-board-history.service';
+import { NoticeBoardsService } from '@src/apis/notice-boards/services/notice-boards.service';
 import { UsersService } from '@src/apis/users/services/users.service';
 import { AppConfigService } from '@src/core/app-config/services/app-config.service';
 import { EncryptionService } from '@src/libs/encryption/services/encryption.service';
@@ -50,3 +52,13 @@ export const mockFreeBoardHistoryService: MockProvider<FreeBoardHistoryService>
   {
     create: jest.fn(),
   };
+
+export const mockNoticeBoardsService: MockProvider<NoticeBoardsService> = {
+  create: jest.fn(),
+  findAllAndCount: jest.fn(),
+};
+
+export const mockNoticeBoardHistoryService: MockProvider<NoticeBoardHistoryService> =
+  {
+    create: jest.fn(),
+  };