Merge pull request #36 from boostcampwm-2022/test/#24-K

Test/#24-K: 워크스페이스 생성 및 참여 서비스 로직

Author: se030

server/apis/auth/service.test.ts

@@ -65,3 +65,5 @@ describe('login', () => {
     expect(() => login()).rejects.toThrow('fail');
   });
 });
+
+export {};

server/apis/user/service.test.ts

@@ -11,28 +11,23 @@ jest.mock('@apis/workspace/model', () => {
   return { find: jest.fn() };
 });
 
-describe('getWorkspaces()', () => {
+describe('getWorkspaces', () => {
   const successfulUser = '';
   const successfulWorkspaces: Object[] = [];
 
   it('정상적인 유저 아이디를 받아서 성공적으로 워크스페이스를 가져온다.', async () => {
-    // arrange
     userModel.findOne.mockResolvedValueOnce(successfulUser);
     workspaceModel.find.mockResolvedValueOnce(successfulWorkspaces);
 
-    // act
     const workspaces = await getWorkspaces('id', 'id');
 
-    // assert
     expect(workspaces).toEqual(successfulWorkspaces);
   });
 
   it('비정상적인 유저 아이디를 받으면 에러를 던진다.', async () => {
-    // arrange
     const user1 = 1;
     const user2 = 2;
 
-    // act & assert
     expect(() => getWorkspaces(user1, user2)).rejects.toThrow(
       AuthorizationError,
     );

server/apis/workspace/service.test.ts

@@ -0,0 +1,94 @@
+const workspaceModel = require('./model');
+const workspaceService = require('./service');
+const { default: InvalidJoinError } = require('@errors/invalid-join-error');
+
+jest.mock('./model', () => {
+  return {
+    create: jest.fn(),
+    findOne: jest.fn(),
+    updateOne: jest.fn(),
+  };
+});
+
+jest.mock('@apis/user/model', () => {
+  return {
+    updateOne: jest.fn(),
+  };
+});
+
+const VALID_CODE = 'wab-0000-0000-0000';
+
+jest.mock('uuid', () => {
+  return {
+    v4: jest.fn(() => VALID_CODE),
+  };
+});
+
+describe('create', () => {
+  it('워크스페이스 이름이 주어진 경우 생성에 성공한다.', async () => {
+    const WORKSPACE_NAME = 'Wab';
+
+    workspaceModel.create.mockResolvedValueOnce({
+      name: WORKSPACE_NAME,
+      code: VALID_CODE,
+    });
+
+    expect(workspaceService.create(WORKSPACE_NAME)).resolves.toEqual({
+      name: WORKSPACE_NAME,
+      code: VALID_CODE,
+    });
+  });
+
+  it('워크스페이스 이름이 없는 경우 생성에 실패한다.', async () => {
+    expect(() => workspaceService.create()).rejects.toThrow(
+      '워크스페이스 이름을 입력하세요 ^^',
+    );
+  });
+});
+
+describe('join', () => {
+  const USER_ID = 1;
+
+  it('유효한 참여코드가 주어진 경우 성공한다.', async () => {
+    const WORKSPACE_ID = 1;
+    const WORKSPACE_NAME = 'Wab';
+
+    workspaceModel.findOne.mockResolvedValueOnce({
+      id: WORKSPACE_ID,
+      name: WORKSPACE_NAME,
+      code: VALID_CODE,
+      users: [],
+      moms: [],
+    });
+
+    expect(workspaceService.join(USER_ID, VALID_CODE)).resolves.toEqual({
+      id: WORKSPACE_ID,
+      name: WORKSPACE_NAME,
+      code: VALID_CODE,
+    });
+  });
+
+  it('참여코드가 없는 경우 실패한다.', async () => {
+    expect(() => workspaceService.join(USER_ID)).rejects.toThrow(
+      InvalidJoinError,
+    );
+  });
+
+  it('참여코드가 유효하지 않은 경우 실패한다.', async () => {
+    workspaceModel.findOne.mockResolvedValueOnce(null);
+
+    expect(() =>
+      workspaceService.join(USER_ID, 'invalid-code'),
+    ).rejects.toThrow(InvalidJoinError);
+  });
+
+  it('db 업데이트 중 에러가 발생하면 실패한다.', async () => {
+    workspaceModel.updateOne.mockRejectedValueOnce(
+      new Error('Some error in database operation'),
+    );
+
+    expect(() => workspaceService.join(USER_ID, VALID_CODE)).rejects.toThrow();
+  });
+});
+
+export {};

server/apis/workspace/service.ts

@@ -5,6 +5,8 @@ import AuthorizationError from '@errors/authorization-error';
 import InvalidJoinError from '@errors/invalid-join-error';
 
 export const create = async (name: string) => {
+  if (!name) throw new Error('워크스페이스 이름을 입력하세요 ^^');
+
   const code = uuidv4();
 
   const workspace = await workspaceModel.create({ name, code });

server/errors/invalid-join-error.ts

@@ -1,8 +1,10 @@
 import CustomError from '.';
 import { BAD_REQUEST } from '@constants/http-status';
 
-export default class InvalidJoinError extends CustomError {
+class InvalidJoinError extends CustomError {
   constructor(message = 'Unauthorized') {
     super(message, BAD_REQUEST);
   }
 }
+
+export default InvalidJoinError;