테스트, 배포, 운영 전략 수립

단위 테스트 (Unit Tests)

• 목표: 개별 함수, 클래스, 메서드와 같이 애플리케이션의 가장 작은 단위가 예상대로 동작하는지 검증합니다. 외부 의존성(데이터베이스, 외부 API 등)은 모킹(Mocking) 처리합니다.
• 대상: 서비스(Service), 유틸리티 함수, 엔티티의 비즈니스 로직, DTO 유효성 검사 등.
• Jest 활용: NestJS CLI는 서비스, 컨트롤러, 게이트웨이 등을 생성할 때 기본 단위 테스트 스펙 파일(.spec.ts)을 함께 생성합니다.

  // src/auth/auth.service.spec.ts (예시)
  import { Test, TestingModule } from '@nestjs/testing';
  import { AuthService } from './auth.service';
  import { getRepositoryToken } from '@nestjs/typeorm';
  import { User } from './entities/user.entity';
  import { JwtService } from '@nestjs/jwt';
  import { ConfigService } from '@nestjs/config';
  
  describe('AuthService', () => {
    let service: AuthService;
    let usersRepository: any; // Mock Repository
    let jwtService: JwtService;
  
    beforeEach(async () => {
      const module: TestingModule = await Test.createTestingModule({
        providers: [
          AuthService,
          {
            provide: getRepositoryToken(User),
            useValue: {
              findOne: jest.fn(),
              create: jest.fn(),
              save: jest.fn(),
            },
          },
          {
            provide: JwtService,
            useValue: {
              sign: jest.fn(() => 'mock_jwt_token'),
            },
          },
          {
            provide: ConfigService,
            useValue: {
              get: jest.fn((key: string) => {
                if (key === 'JWT_SECRET') return 'test_secret';
                return null;
              }),
            },
          },
        ],
      }).compile();
  
      service = module.get<AuthService>(AuthService);
      usersRepository = module.get(getRepositoryToken(User));
      jwtService = module.get<JwtService>(JwtService);
    });
  
    it('should be defined', () => {
      expect(service).toBeDefined();
    });
  
    it('should register a user', async () => {
      usersRepository.findOne.mockResolvedValue(null); // 기존 사용자 없음
      usersRepository.create.mockReturnValue({ id: '1', email: 'test@example.com' });
      usersRepository.save.mockResolvedValue({ id: '1', email: 'test@example.com' });
  
      const result = await service.register({
        email: 'test@example.com',
        password: 'password123',
        nickname: 'Tester',
      });
      expect(result).toEqual({ message: 'User registered successfully' });
      expect(usersRepository.create).toHaveBeenCalledWith(
        expect.objectContaining({ email: 'test@example.com' })
      );
    });
  
    it('should throw ConflictException if email already registered', async () => {
      usersRepository.findOne.mockResolvedValue({}); // 기존 사용자 존재
  
      await expect(
        service.register({
          email: 'test@example.com',
          password: 'password123',
          nickname: 'Tester',
        })
      ).rejects.toThrow('Email already registered');
    });
    // ... 로그인 테스트 등
  });

통합 테스트 (Integration Tests)

• 목표: 여러 컴포넌트(컨트롤러, 서비스, 리포지토리)가 함께 동작하며 예상대로 통합되는지 검증합니다. 실제 데이터베이스 또는 외부 서비스의 모의 객체를 사용합니다.
• 대상: API 엔드포인트, 미들웨어, 가드, 데이터베이스 상호작용 등.
• Jest + Supertest 활용: NestJS는 통합 테스트를 위해 E2E Testing 섹션에서 app.e2e-spec.ts 파일을 제공하며, supertest 라이브러리를 사용하여 HTTP 요청을 시뮬레이션합니다.

  // src/project/project.controller.e2e-spec.ts (간략화된 예시)
  import { Test, TestingModule } from '@nestjs/testing';
  import * as request from 'supertest';
  import { INestApplication } from '@nestjs/common';
  import { AppModule } from '../app.module';
  import { AuthModule } from '../auth/auth.module';
  import { ProjectModule } from './project.module';
  import { TypeOrmModule } from '@nestjs/typeorm';
  import { User } from '../auth/entities/user.entity';
  import { Project } from './entities/project.entity';
  import { File } from '../file/entities/file.entity';
  import { Folder } from '../folder/entities/folder.entity';
  import { AuthService } from '../auth/auth.service';
  import { JwtService } from '@nestjs/jwt';
  
  describe('ProjectController (e2e)', () => {
    let app: INestApplication;
    let authService: AuthService;
    let jwtService: JwtService;
    let accessToken: string;
    let testUser: User;
  
    beforeAll(async () => {
      const moduleFixture: TestingModule = await Test.createTestingModule({
        imports: [
          AppModule, // 전체 AppModule 임포트 (통합 테스트용 DB 설정)
          TypeOrmModule.forRoot({ // 테스트용 인메모리 DB 또는 별도 DB 설정
              type: 'sqlite', // 개발용으로 sqlite 사용
              database: ':memory:',
              entities: [User, Project, File, Folder],
              synchronize: true,
          }),
          AuthModule,
          ProjectModule,
        ],
      }).compile();
  
      app = moduleFixture.createNestApplication();
      await app.init();
  
      authService = moduleFixture.get<AuthService>(AuthService);
      jwtService = moduleFixture.get<JwtService>(JwtService);
  
      // 테스트 유저 생성 및 토큰 발급
      testUser = await authService['usersRepository'].save({ // private 접근 주의
          email: 'test@example.com',
          password: await (authService as any)['bcrypt'].hash('password123', 10),
          nickname: 'TestUser',
      });
      accessToken = (await authService.login({ email: 'test@example.com', password: 'password123' })).accessToken;
    });
  
    afterAll(async () => {
      await app.close();
    });
  
    it('/projects (POST) - creates a project', async () => {
      return request(app.getHttpServer())
        .post('/projects')
        .set('Authorization', `Bearer ${accessToken}`)
        .send({ name: 'My Test Project' })
        .expect(201)
        .expect((res) => {
          expect(res.body.name).toEqual('My Test Project');
          expect(res.body.ownerId).toEqual(testUser.id);
        });
    });
  
    it('/projects (GET) - gets all user projects', async () => {
      await request(app.getHttpServer())
        .post('/projects')
        .set('Authorization', `Bearer ${accessToken}`)
        .send({ name: 'Another Project' });
  
      return request(app.getHttpServer())
        .get('/projects')
        .set('Authorization', `Bearer ${accessToken}`)
        .expect(200)
        .expect((res) => {
          expect(res.body.length).toBeGreaterThanOrEqual(2);
          expect(res.body[0].ownerId).toEqual(testUser.id);
        });
    });
    // ... 기타 프로젝트, 파일, 폴더 API 테스트
  });

E2E 테스트 (End-to-End Tests)

• 목표: 실제 사용자 시나리오를 모방하여 전체 시스템(프론트엔드, 백엔드, 데이터베이스)이 완벽하게 통합되어 동작하는지 검증합니다.
• 도구: Cypress, Playwright, Selenium 등.
• 적용: 사용자 가입 -> 로그인 -> 프로젝트 생성 -> 파일 편집 -> 실시간 동기화 확인과 같은 복합적인 시나리오 테스트.