modify : userService 테스트 파일 작성(임시)

Author: cheonHwi

src/__test__/services/user.service.test.ts

@@ -10,9 +10,9 @@ describe('UserService 테스트', () => {
   let userRepository: UserRepository;
 
   beforeEach(() => {
-    // userRepository 모킹
     userRepository = new UserRepository(pool);
     userService = new UserService(userRepository);
+
     jest.spyOn(userService, 'findByVelogUUID').mockResolvedValue({
       id: 1,
       velog_uuid: '1',
@@ -39,43 +39,90 @@ describe('UserService 테스트', () => {
           updated_at: new Date(),
         });
       });
+
+    jest.spyOn(userService as any, 'encryptTokens').mockReturnValue({
+      encryptedAccessToken: 'encryptedAccessToken',
+      encryptedRefreshToken: 'encryptedRefreshToken',
+    });
+
+    // userRepository의 createUser모킹하기
+    jest.spyOn(userRepository, 'createUser').mockImplementation(() => {});
+  });
+
+  test('handleUserTokensByVelogUUID - 기존 사용자 토큰 업데이트', async () => {
+    // 사용자가 존재하는 경우 테스트
+    const mockUserData: UserWithTokenDto = {
+      id: '1',
+      email: 'test@test.com',
+      accessToken: 'accessToken',
+      refreshToken: 'refreshToken',
+    };
+
+    const result = await userService.handleUserTokensByVelogUUID(mockUserData);
+
+    expect(result).toBeDefined();
+    expect(userService.findByVelogUUID).toHaveBeenCalledWith('1');
+    expect((userService as any).encryptTokens).toHaveBeenCalled();
+    expect(userRepository.updateTokens).toHaveBeenCalledWith('1', 'encryptedAccessToken', 'encryptedRefreshToken');
+  });
+
+  test('handleUserTokensByVelogUUID - 새 사용자 생성', async () => {
+    // findByVelogUUID가 null 반환하도록 재설정
+    jest.spyOn(userService, 'findByVelogUUID').mockResolvedValueOnce(null);
+
+    const mockUserData: UserWithTokenDto = {
+      id: '1',
+      email: 'test@test.com',
+      accessToken: 'accessToken',
+      refreshToken: 'refreshToken',
+    };
+
+    const result = await userService.handleUserTokensByVelogUUID(mockUserData);
+
+    expect(result).toBeDefined();
+    expect(userService.findByVelogUUID).toHaveBeenCalledWith('1');
+    expect(userService.createUser).toHaveBeenCalledWith(mockUserData);
+    expect((userService as any).encryptTokens).toHaveBeenCalled();
+    expect(userRepository.updateTokens).toHaveBeenCalled();
   });
 
-  test('handleUserTokensByVelogUUID 메서드 테스트', async () => {
+  test('handleUserTokensByVelogUUID - 에러 처리', async () => {
+    jest.spyOn(userService, 'findByVelogUUID').mockRejectedValueOnce(new Error('DB 에러'));
+
     const mockUserData: UserWithTokenDto = {
       id: '1',
       email: 'test@test.com',
       accessToken: 'accessToken',
       refreshToken: 'refreshToken',
     };
 
-    const { id, email, accessToken, refreshToken } = mockUserData;
-
-    let user = await userService.findByVelogUUID(id);
-    if (!user) {
-      user = await userService.createUser(mockUserData);
-    }
-
-    expect(user).toBeDefined();
-    expect(user?.id).toBe(Number(id));
-    expect(user?.email).toBe(email);
-    expect(user?.access_token).toBe(accessToken);
-    expect(user?.refresh_token).toBe(refreshToken);
-
-    const { encryptedAccessToken, encryptedRefreshToken } = (userService as any).encryptTokens(
-      user.group_id,
-      accessToken,
-      refreshToken,
-    );
-
-    const result = await userService.updateUserTokens({
-      id,
-      email,
-      accessToken: encryptedAccessToken,
-      refreshToken: encryptedRefreshToken,
+    await expect(userService.handleUserTokensByVelogUUID(mockUserData)).rejects.toThrow();
+  });
+
+  test('findSampleUser 메서드 테스트', async () => {
+    jest.spyOn(userRepository, 'findSampleUser').mockResolvedValue({
+      id: 1,
+      velog_uuid: '1',
+      access_token: 'encryptedAccessToken',
+      refresh_token: 'encryptedRefreshToken',
+      group_id: 1,
+      email: 'test@test.com',
+      is_active: true,
+      created_at: new Date(),
+      updated_at: new Date(),
+    });
+
+    jest.spyOn(userService as any, 'decryptTokens').mockReturnValue({
+      decryptedAccessToken: 'decryptedAccessToken',
+      decryptedRefreshToken: 'decryptedRefreshToken',
     });
 
-    expect(result?.access_token).toBe(encryptedAccessToken);
-    expect(result?.refresh_token).toBe(encryptedRefreshToken);
+    const result = await userService.findSampleUser();
+
+    expect(result).toBeDefined();
+    expect(result.decryptedAccessToken).toBe('decryptedAccessToken');
+    expect(result.decryptedRefreshToken).toBe('decryptedRefreshToken');
+    expect(userRepository.findSampleUser).toHaveBeenCalled();
+    expect((userService as any).decryptTokens).toHaveBeenCalled();
   });
 });