fix: snowflake 생성 서비스 레이어로 이동

Author: summersummerwhy

apps/backend/src/auth/auth.service.spec.ts

@@ -3,6 +3,7 @@ import { AuthService } from './auth.service';
 import { UserRepository } from '../user/user.repository';
 import { SignUpDto } from './dtos/signUp.dto';
 import { User } from '../user/user.entity';
+import { Snowflake } from '@theinternetfolks/snowflake';
 
 describe('AuthService', () => {
   let authService: AuthService;
@@ -65,14 +66,37 @@ describe('AuthService', () => {
         provider: 'naver',
         email: '[email protected]',
       };
-      const user = new User();
-      jest.spyOn(userRepository, 'create').mockReturnValue(user);
-      jest.spyOn(userRepository, 'save').mockResolvedValue(user);
+      const generatedSnowflakeId = Snowflake.generate(); // Snowflake.generate()의 mock 값을 준비
+      const newDate = new Date();
+      const createdUser = {
+        providerId: dto.providerId,
+        provider: dto.provider,
+        email: dto.email,
+        snowflakeId: generatedSnowflakeId,
+      };
+      const savedUser = {
+        providerId: dto.providerId,
+        provider: dto.provider,
+        email: dto.email,
+        snowflakeId: generatedSnowflakeId,
+        id: 1,
+        createdAt: newDate,
+      };
+
+      jest.spyOn(Snowflake, 'generate').mockReturnValue(generatedSnowflakeId);
+      jest.spyOn(userRepository, 'create').mockReturnValue(createdUser as User);
+      jest.spyOn(userRepository, 'save').mockResolvedValue(savedUser as User);
 
       const result = await authService.signUp(dto);
-      expect(result).toEqual(user);
-      expect(userRepository.create).toHaveBeenCalledWith(dto);
-      expect(userRepository.save).toHaveBeenCalledWith(user);
+
+      // Then
+      expect(result).toEqual(savedUser); // 반환된 값이 예상된 저장된 사용자와 동일
+      expect(Snowflake.generate).toHaveBeenCalled(); // Snowflake.generate 호출 확인
+      expect(userRepository.create).toHaveBeenCalledWith({
+        ...dto,
+        snowflakeId: generatedSnowflakeId,
+      });
+      expect(userRepository.save).toHaveBeenCalledWith(createdUser);
     });
   });
 });

apps/backend/src/auth/auth.service.ts

@@ -2,6 +2,7 @@ import { Injectable } from '@nestjs/common';
 import { UserRepository } from '../user/user.repository';
 import { User } from '../user/user.entity';
 import { SignUpDto } from './dtos/signUp.dto';
+import { Snowflake } from '@theinternetfolks/snowflake';
 
 @Injectable()
 export class AuthService {
@@ -18,7 +19,10 @@ export class AuthService {
   }
 
   async signUp(dto: SignUpDto): Promise<User> {
-    const user = this.userRepository.create(dto);
+    const user = this.userRepository.create({
+      ...dto,
+      snowflakeId: Snowflake.generate(),
+    });
     return this.userRepository.save(user);
   }
 

apps/backend/src/user/user.entity.ts

@@ -5,9 +5,7 @@ import {
   Column,
   CreateDateColumn,
   Index,
-  BeforeInsert,
 } from 'typeorm';
-import { Snowflake } from '@theinternetfolks/snowflake';
 
 @Entity()
 export class User {
@@ -35,9 +33,4 @@ export class User {
 
   @CreateDateColumn()
   createdAt: Date;
-
-  @BeforeInsert()
-  generateSnowflakeId() {
-    this.snowflakeId = Snowflake.generate();
-  }
 }

apps/backend/src/workspace/workspace.entity.ts

@@ -7,10 +7,8 @@ import {
   UpdateDateColumn,
   OneToMany,
   Index,
-  BeforeInsert,
 } from 'typeorm';
 import { User } from '../user/user.entity';
-import { Snowflake } from '@theinternetfolks/snowflake';
 import { Edge } from '../edge/edge.entity';
 import { Page } from '../page/page.entity';
 import { Node } from '../node/node.entity';
@@ -53,9 +51,4 @@ export class Workspace {
 
   @OneToMany(() => Node, (node) => node.workspace)
   nodes: Node[];
-
-  @BeforeInsert()
-  generateSnowflakeId() {
-    this.snowflakeId = Snowflake.generate();
-  }
 }

apps/backend/src/workspace/workspace.service.spec.ts

@@ -12,6 +12,7 @@ import { Role } from '../role/role.entity';
 import { User } from '../user/user.entity';
 import { TokenService } from '../auth/token/token.service';
 import { ForbiddenAccessException } from '../exception/access.exception';
+import { Snowflake } from '@theinternetfolks/snowflake';
 
 describe('WorkspaceService', () => {
   let service: WorkspaceService;
@@ -72,64 +73,68 @@ describe('WorkspaceService', () => {
   });
 
   describe('createWorkspace', () => {
-    it('워크스페이스를 성공적으로 생성한다.', async () => {
+    it('성공적으로 워크스페이스를 생성한다.', async () => {
+      // Mock 데이터
       const userId = 1;
       const dto: CreateWorkspaceDto = {
         title: 'New Workspace',
-        description: 'A test workspace',
+        description: 'Description of workspace',
         visibility: 'private',
-        thumbnailUrl: 'http://example.com/thumbnail.png',
+        thumbnailUrl: 'http://example.com/image.png',
       };
 
-      const owner = { id: userId } as User;
-      const newDate = new Date();
-      const newWorkspace = {
-        id: 1,
-        snowflakeId: 'snowflake-id',
-        owner,
-        title: dto.title,
-        description: dto.description,
-        visibility: dto.visibility,
-        createdAt: newDate,
-        updatedAt: newDate,
-        thumbnailUrl: dto.thumbnailUrl,
-        edges: [],
-        pages: [],
-        nodes: [],
+      const mockUser = { id: userId } as User;
+      const generatedSnowflakeId = Snowflake.generate();
+      const mockWorkspace = {
+        id: 10,
+        ...dto,
+        snowflakeId: generatedSnowflakeId,
       } as Workspace;
 
-      jest.spyOn(userRepository, 'findOneBy').mockResolvedValue(owner);
-      jest.spyOn(workspaceRepository, 'save').mockResolvedValue(newWorkspace);
+      // Mocking
+      jest.spyOn(userRepository, 'findOneBy').mockResolvedValue(mockUser);
+      jest.spyOn(Snowflake, 'generate').mockReturnValue(generatedSnowflakeId);
+      jest.spyOn(workspaceRepository, 'save').mockResolvedValue(mockWorkspace);
+      jest.spyOn(roleRepository, 'save').mockResolvedValue(undefined);
 
+      // 실행
       const result = await service.createWorkspace(userId, dto);
 
-      expect(result).toEqual(newWorkspace);
+      // 검증
       expect(userRepository.findOneBy).toHaveBeenCalledWith({ id: userId });
       expect(workspaceRepository.save).toHaveBeenCalledWith({
-        owner,
-        ...dto,
-        visibility: 'private',
+        snowflakeId: generatedSnowflakeId,
+        owner: mockUser,
+        title: dto.title,
+        description: dto.description,
+        visibility: 'private', // 기본값 확인
+        thumbnailUrl: dto.thumbnailUrl,
       });
       expect(roleRepository.save).toHaveBeenCalledWith({
-        userId: owner.id,
-        workspaceId: newWorkspace.id,
+        userId: mockUser.id,
+        workspaceId: mockWorkspace.id,
         role: 'owner',
       });
+      expect(result).toEqual(mockWorkspace);
     });
 
-    it('사용자가 존재하지 않으면 UserNotFoundException을 throw한다.', async () => {
+    it('사용자를 찾을 수 없으면 UserNotFoundException을 던진다.', async () => {
+      // Mocking
       jest.spyOn(userRepository, 'findOneBy').mockResolvedValue(null);
 
-      const dto: CreateWorkspaceDto = {
-        title: 'New Workspace',
-        description: 'A test workspace',
-        visibility: 'private',
-        thumbnailUrl: 'http://example.com/thumbnail.png',
-      };
-
-      await expect(service.createWorkspace(1, dto)).rejects.toThrow(
-        UserNotFoundException,
-      );
+      // 실행 및 검증
+      await expect(
+        service.createWorkspace(1, {
+          title: 'New Workspace',
+          description: 'Description of workspace',
+          visibility: 'private',
+          thumbnailUrl: 'http://example.com/image.png',
+        }),
+      ).rejects.toThrow(UserNotFoundException);
+
+      expect(userRepository.findOneBy).toHaveBeenCalledWith({ id: 1 });
+      expect(workspaceRepository.save).not.toHaveBeenCalled();
+      expect(roleRepository.save).not.toHaveBeenCalled();
     });
   });
 

apps/backend/src/workspace/workspace.service.ts

@@ -11,6 +11,7 @@ import { NotWorkspaceOwnerException } from '../exception/workspace-auth.exceptio
 import { TokenService } from '../auth/token/token.service';
 import { ForbiddenAccessException } from '../exception/access.exception';
 import { UserAlreadyInWorkspaceException } from '../exception/role-duplicate.exception';
+import { Snowflake } from '@theinternetfolks/snowflake';
 
 enum MainWorkspace {
   OWNER_SNOWFLAKEID = 'admin',
@@ -53,6 +54,7 @@ export class WorkspaceService {
 
     // 워크스페이스 생성 및 저장
     const newWorkspace = await this.workspaceRepository.save({
+      snowflakeId: Snowflake.generate(),
       owner,
       title,
       description,