test: auth service, auth controller 테스트 코드

Author: summersummerwhy

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

@@ -1,25 +1,80 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { AuthController } from './auth.controller';
 import { AuthService } from './auth.service';
-
+import { JwtService } from '@nestjs/jwt';
+import { InvalidTokenException } from '../exception/invalid.exception';
+import { LoginRequiredException } from '../exception/login.exception';
+// TODO: 테스트 코드 개선
 describe('AuthController', () => {
-  let controller: AuthController;
+  let authController: AuthController;
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
       controllers: [AuthController],
       providers: [
+        AuthService,
+        JwtService,
         {
           provide: AuthService,
-          useValue: {},
+          useValue: {
+            findUser: jest.fn(),
+            createUser: jest.fn(),
+            findUserById: jest.fn(),
+          },
+        },
+        {
+          provide: JwtService,
+          useValue: {
+            sign: jest.fn().mockReturnValue('test-token'),
+            verify: jest.fn((token: string) => {
+              if (token === 'invalid-token') {
+                throw new InvalidTokenException();
+              }
+              return { sub: 1, provider: 'naver' };
+            }),
+          },
         },
       ],
     }).compile();
 
-    controller = module.get<AuthController>(AuthController);
+    authController = module.get<AuthController>(AuthController);
   });
 
-  it('should be defined', () => {
-    expect(controller).toBeDefined();
+  it('컨트롤러 클래스가 정상적으로 인스턴스화된다.', () => {
+    expect(authController).toBeDefined();
+  });
+
+  describe('getProfile', () => {
+    it('JWT 토큰이 유효한 경우 profile을 return한다.', async () => {
+      const req = {
+        user: { sub: 1, email: '[email protected]', provider: 'naver' },
+      } as any;
+      const result = await authController.getProfile(req);
+      expect(result).toEqual({
+        message: '인증된 사용자 정보',
+        user: req.user,
+      });
+    });
+
+    it('JWT 토큰이 유효가지 않은 경우 InvalidTokenException을 throw한다.', async () => {
+      const req = {
+        headers: { authorization: 'Bearer invalid-token' },
+        user: undefined,
+      } as any;
+      try {
+        await authController.getProfile(req);
+      } catch (error) {
+        expect(error).toBeInstanceOf(InvalidTokenException);
+      }
+    });
+
+    it('JWT 토큰이 없는 경우 LoginRequiredException을 throw한다.', async () => {
+      const req = { headers: {}, user: undefined } as any;
+      try {
+        await authController.getProfile(req);
+      } catch (error) {
+        expect(error).toBeInstanceOf(LoginRequiredException);
+      }
+    });
   });
 });

apps/backend/src/auth/auth.controller.ts

@@ -55,7 +55,7 @@ export class AuthController {
     };
   }
 
-  // Example 1: 로그인한 사용자만 접근할 수 있는 엔드포인트
+  // Example: 로그인한 사용자만 접근할 수 있는 엔드포인트
   // auth/profile
   @Get('profile')
   @UseGuards(JwtAuthGuard) // JWT 인증 검사

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

@@ -1,25 +1,78 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { AuthService } from './auth.service';
 import { UserRepository } from '../user/user.repository';
+import { CreateUserDto } from './dto/createUser.dto';
+import { User } from '../user/user.entity';
 
 describe('AuthService', () => {
-  let service: AuthService;
+  let authService: AuthService;
+  let userRepository: UserRepository;
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
       providers: [
         AuthService,
         {
           provide: UserRepository,
-          useValue: {},
+          useValue: {
+            findOne: jest.fn(),
+            create: jest.fn(),
+            save: jest.fn(),
+          },
         },
       ],
     }).compile();
 
-    service = module.get<AuthService>(AuthService);
+    authService = module.get<AuthService>(AuthService);
+    userRepository = module.get<UserRepository>(UserRepository);
   });
 
-  it('should be defined', () => {
-    expect(service).toBeDefined();
+  it('서비스 클래스가 정상적으로 인스턴스화된다.', () => {
+    expect(authService).toBeDefined();
+  });
+
+  describe('findUser', () => {
+    it('id에 해당하는 사용자를 찾아 성공적으로 반환한다.', async () => {
+      const dto: CreateUserDto = {
+        providerId: 'test-provider-id',
+        provider: 'naver',
+        email: '[email protected]',
+      };
+      const user = new User();
+      jest.spyOn(userRepository, 'findOne').mockResolvedValue(user);
+
+      const result = await authService.findUser(dto);
+      expect(result).toEqual(user);
+    });
+
+    it('id에 해당하는 사용자가 없을 경우 null을 return한다.', async () => {
+      jest.spyOn(userRepository, 'findOne').mockResolvedValue(null);
+      const dto: CreateUserDto = {
+        providerId: 'unknown-id',
+        provider: 'naver',
+        email: '[email protected]',
+      };
+
+      const result = await authService.findUser(dto);
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('createUser', () => {
+    it('사용자를 성공적으로 생성한다', async () => {
+      const dto: CreateUserDto = {
+        providerId: 'new-provider-id',
+        provider: 'naver',
+        email: '[email protected]',
+      };
+      const user = new User();
+      jest.spyOn(userRepository, 'create').mockReturnValue(user);
+      jest.spyOn(userRepository, 'save').mockResolvedValue(user);
+
+      const result = await authService.createUser(dto);
+      expect(result).toEqual(user);
+      expect(userRepository.create).toHaveBeenCalledWith(dto);
+      expect(userRepository.save).toHaveBeenCalledWith(user);
+    });
   });
 });

apps/backend/src/auth/guards/jwt-auth.guard.ts

@@ -1,7 +1,7 @@
 import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';
 import { JwtService } from '@nestjs/jwt';
 import { LoginRequiredException } from '../../exception/login.exception';
-import { InvalidTokenException } from 'src/exception/invalid.exception';
+import { InvalidTokenException } from '../../exception/invalid.exception';
 
 @Injectable()
 export class JwtAuthGuard implements CanActivate {
@@ -12,7 +12,7 @@ export class JwtAuthGuard implements CanActivate {
     const authorizationHeader = request.headers['authorization'];
 
     if (!authorizationHeader) {
-      console.log('Authorization header missing');
+      //   console.log('Authorization header missing');
       throw new LoginRequiredException();
     }
 
@@ -25,7 +25,7 @@ export class JwtAuthGuard implements CanActivate {
       request.user = decodedToken;
       return true;
     } catch (error) {
-      console.log('Invalid token');
+      //   console.log('Invalid token');
       throw new InvalidTokenException();
     }
   }