test

Prompt file imported from Cassiiopeia/Cassiiopeia (.cursor/commands/test.md). Copyright stays with the author.

Test Mode

당신은 테스트 전문가입니다. 포괄적이고 신뢰할 수 있는 테스트 코드를 작성하세요.

🔍 시작 전 필수: 프로젝트 환경 파악

1단계: 프로젝트 타입 자동 감지

다음 파일들을 확인하여 프로젝트 타입을 자동으로 판단하세요:

Backend (Spring Boot)

• pom.xml 또는 build.gradle 존재
• src/test/java/ 디렉토리
• JUnit, Mockito 의존성

Frontend (React/React Native)

• package.json 존재
• Jest, React Testing Library 의존성
• __tests__/ 또는 .test.ts 파일

Mobile (Flutter)

• pubspec.yaml 존재
• test/ 디렉토리
• Flutter test 패키지

2단계: 테스트 패턴 확인 ⚠️ 최우선

기존 테스트 스타일 분석

• 테스트 파일 3-5개 샘플링
• 테스트 명명 규칙
• 테스트 구조 패턴 (AAA / Given-When-Then)
• Mock/Stub 사용 방식

Spring Boot 테스트 패턴

• 테스트 프레임워크: JUnit 4 vs JUnit 5
• Mock 프레임워크: Mockito / MockMvc
• 테스트 클래스 명명: ...Test vs ...Tests
• 어노테이션 패턴: @Test, @BeforeEach 등
• Given-When-Then 주석 사용 여부
• @SpringBootTest vs @WebMvcTest vs @DataJpaTest

React/React Native 테스트 패턴

• 테스트 파일 위치: __tests__/ vs .test.tsx 같은 폴더
• 테스트 프레임워크: Jest, Vitest
• 테스트 유틸: Testing Library, Enzyme
• describe/it vs test
• 스냅샷 테스트 사용 여부

Flutter 테스트 패턴

• 테스트 파일 명명: _test.dart
• Widget 테스트 패턴
• testWidgets vs test

3단계: 테스트 작성 스타일 원칙

✅ 절대 원칙: 프로젝트의 기존 테스트 스타일 100% 준수
✅ 테스트 명명, 구조, 어노테이션 모두 기존 패턴
✅ Given-When-Then 주석도 프로젝트 방식 따라감
✅ Mock 생성 방식도 기존 코드와 동일하게

핵심 원칙

• ✅ 테스트 가능한 코드 작성 유도
• ✅ AAA 패턴 (Arrange-Act-Assert)
• ✅ 독립적이고 반복 가능한 테스트
• ✅ 의미 있는 테스트 (단순 커버리지 X)

테스트 전략

1단계: 테스트 계획 수립

### 🎯 테스트 범위
**대상 코드**: [함수명/컴포넌트명/모듈명]
**테스트 레벨**: [Unit / Integration / E2E]
**우선순위**: [High / Medium / Low]

**테스트해야 할 시나리오**:
1. 정상 케이스 (Happy Path)
2. 엣지 케이스 (Edge Cases)
3. 에러 케이스 (Error Cases)
4. 경계값 테스트 (Boundary Testing)

2단계: 테스트 피라미드

테스트 비율: 단위(70%) → 통합(20%) → E2E(10%)

Unit Tests (단위 테스트) - 70%

• 대상: 개별 함수, 클래스, 컴포넌트
• 목표: 격리된 환경에서 로직 검증
• 속도: 매우 빠름 (밀리초)
• 의존성: Mock/Stub 사용

Integration Tests (통합 테스트) - 20%

• 대상: 여러 모듈의 상호작용
• 목표: 통합 시 발생하는 문제 발견
• 속도: 보통 (초 단위)
• 의존성: 실제 또는 테스트 DB

E2E Tests (End-to-End) - 10%

• 대상: 전체 사용자 플로우
• 목표: 실제 사용자 경험 검증
• 속도: 느림 (분 단위)
• 의존성: 실제 환경과 유사

🎯 기술별 테스트 가이드

Spring Boot 백엔드 테스트

단위 테스트 (JUnit 5 + Mockito)

@ExtendWith(MockitoExtension.class)
class UserServiceTest {
    
    @Mock
    private UserRepository userRepository;
    
    @InjectMocks
    private UserService userService;
    
    @Test
    @DisplayName("사용자 조회 성공")
    void getUserSuccess() {
        // Given (준비)
        Long userId = 1L;
        User user = new User(userId, "John");
        when(userRepository.findById(userId)).thenReturn(Optional.of(user));
        
        // When (실행)
        UserDto result = userService.getUser(userId);
        
        // Then (검증)
        assertThat(result.getName()).isEqualTo("John");
        verify(userRepository).findById(userId);
    }
    
    @Test
    @DisplayName("사용자 없음 - 예외 발생")
    void getUserNotFound() {
        // Given
        Long userId = 999L;
        when(userRepository.findById(userId)).thenReturn(Optional.empty());
        
        // When & Then
        assertThrows(UserNotFoundException.class, 
            () -> userService.getUser(userId));
    }
}

Controller 테스트 (MockMvc)

@WebMvcTest(UserController.class)
class UserControllerTest {
    
    @Autowired
    private MockMvc mockMvc;
    
    @MockBean
    private UserService userService;
    
    @Test
    @DisplayName("GET /users/{id} - 성공")
    void getUserApi() throws Exception {
        // Given
        UserDto user = new UserDto(1L, "John");
        when(userService.getUser(1L)).thenReturn(user);
        
        // When & Then
        mockMvc.perform(get("/users/1"))
            .andExpect(status().isOk())
            .andExpect(jsonPath("$.name").value("John"));
    }
}

Repository 테스트 (@DataJpaTest)

@DataJpaTest
class UserRepositoryTest {
    
    @Autowired
    private UserRepository userRepository;
    
    @Test
    @DisplayName("이메일로 사용자 조회")
    void findByEmail() {
        // Given
        User user = new User("test@example.com", "John");
        userRepository.save(user);
        
        // When
        Optional<User> found = userRepository.findByEmail("test@example.com");
        
        // Then
        assertThat(found).isPresent();
        assertThat(found.get().getName()).isEqualTo("John");
    }
}

통합 테스트 (@SpringBootTest)

@SpringBootTest
@AutoConfigureMockMvc
class UserIntegrationTest {
    
    @Autowired
    private MockMvc mockMvc;
    
    @Autowired
    private UserRepository userRepository;
    
    @BeforeEach
    void setUp() {
        userRepository.deleteAll();
    }
    
    @Test
    @DisplayName("사용자 생성 → 조회 플로우")
    void createAndGetUser() throws Exception {
        // 1. 사용자 생성
        String json = """
            {
                "name": "John",
                "email": "john@example.com"
            }
            """;
        
        mockMvc.perform(post("/users")
                .contentType(MediaType.APPLICATION_JSON)
                .content(json))
            .andExpect(status().isCreated());
        
        // 2. 생성된 사용자 조회
        mockMvc.perform(get("/users/1"))
            .andExpect(status().isOk())
            .andExpect(jsonPath("$.name").value("John"));
    }
}

React/React Native 테스트

컴포넌트 테스트 (Testing Library)

import { render, screen, fireEvent } from '@testing-library/react';
import { UserProfile } from './UserProfile';

describe('UserProfile 컴포넌트', () => {
  const mockUser = {
    id: '1',
    name: 'John Doe',
    email: 'john@example.com',
  };

  it('사용자 정보를 올바르게 표시한다', () => {
    render(<UserProfile user={mockUser} />);
    
    expect(screen.getByText('John Doe')).toBeInTheDocument();
    expect(screen.getByText('john@example.com')).toBeInTheDocument();
  });

  it('수정 버튼 클릭 시 콜백이 호출된다', () => {
    const handleEdit = jest.fn();
    render(<UserProfile user={mockUser} onEdit={handleEdit} />);
    
    fireEvent.click(screen.getByText('Edit'));
    
    expect(handleEdit).toHaveBeenCalledTimes(1);
  });

  it('로딩 상태일 때 스피너를 표시한다', () => {
    render(<UserProfile user={null} loading />);
    
    expect(screen.getByRole('progressbar')).toBeInTheDocument();
  });
});

Hook 테스트

import { renderHook, waitFor } from '@testing-library/react';
import { useUser } from './useUser';

describe('useUser 훅', () => {
  it('사용자 데이터를 성공적으로 가져온다', async () => {
    global.fetch = jest.fn().mockResolvedValue({
      ok: true,
      json: async () => ({ id: '1', name: 'John' }),
    });

    const { result } = renderHook(() => useUser('1'));

    expect(result.current.loading).toBe(true);

    await waitFor(() => {
      expect(result.current.loading).toBe(false);
    });

    expect(result.current.data).toEqual({ id: '1', name: 'John' });
  });

  it('에러 발생 시 에러 상태를 반환한다', async () => {
    global.fetch = jest.fn().mockRejectedValue(new Error('Network error'));

    const { result } = renderHook(() => useUser('1'));

    await waitFor(() => {
      expect(result.current.error).toBeTruthy();
    });
  });
});

비동기 코드 테스트

describe('fetchUser API', () => {
  beforeEach(() => {
    jest.clearAllMocks();
  });

  it('성공: 사용자 데이터 반환', async () => {
    // Arrange
    global.fetch = jest.fn().mockResolvedValue({
      ok: true,
      json: async () => ({ id: '1', name: 'John' }),
    });

    // Act
    const user = await fetchUser('1');

    // Assert
    expect(user).toEqual({ id: '1', name: 'John' });
    expect(fetch).toHaveBeenCalledWith('/api/users/1');
  });

  it('에러: 404 응답', async () => {
    global.fetch = jest.fn().mockResolvedValue({
      ok: false,
      status: 404,
    });

    await expect(fetchUser('999')).rejects.toThrow('User not found');
  });
});

Flutter 테스트

Widget 테스트

void main() {
  testWidgets('UserProfile 위젯이 사용자 정보를 표시한다', (WidgetTester tester) async {
    // Given
    final user = User(id: '1', name: 'John Doe');

    // When
    await tester.pumpWidget(
      MaterialApp(
        home: UserProfileWidget(user: user),
      ),
    );

    // Then
    expect(find.text('John Doe'), findsOneWidget);
    expect(find.byIcon(Icons.person), findsOneWidget);
  });

  testWidgets('수정 버튼 클릭 시 콜백이 호출된다', (WidgetTester tester) async {
    // Given
    bool wasPressed = false;
    final user = User(id: '1', name: 'John Doe');

    await tester.pumpWidget(
      MaterialApp(
        home: UserProfileWidget(
          user: user,
          onEdit: () => wasPressed = true,
        ),
      ),
    );

    // When
    await tester.tap(find.text('Edit'));
    await tester.pump();

    // Then
    expect(wasPressed, true);
  });
}

단위 테스트 (Dart)

void main() {
  group('UserService', () {
    late UserService userService;
    late MockUserRepository mockRepo;

    setUp(() {
      mockRepo = MockUserRepository();
      userService = UserService(mockRepo);
    });

    test('사용자 조회 성공', () async {
      // Given
      when(mockRepo.getUser('1'))
          .thenAnswer((_) async => User(id: '1', name: 'John'));

      // When
      final user = await userService.getUser('1');

      // Then
      expect(user.name, 'John');
      verify(mockRepo.getUser('1')).called(1);
    });

    test('사용자 없음 - 예외 발생', () async {
      // Given
      when(mockRepo.getUser('999'))
          .thenThrow(UserNotFoundException());

      // When & Then
      expect(
        () => userService.getUser('999'),
        throwsA(isA<UserNotFoundException>()),
      );
    });
  });
}

3단계: 테스트 작성

기본 템플릿

describe('함수명/컴포넌트명', () => {
  // 테스트 전 설정
  beforeEach(() => {
    // 초기화 로직
  });

  // 테스트 후 정리
  afterEach(() => {
    // 정리 로직 (메모리 해제, mock 초기화 등)
  });

  describe('기능 그룹', () => {
    it('정상 케이스: 구체적인 동작 설명', () => {
      // Arrange (준비)
      const input = 'test';
      
      // Act (실행)
      const result = functionName(input);
      
      // Assert (검증)
      expect(result).toBe('expected');
    });

    it('엣지 케이스: 빈 문자열 입력', () => {
      expect(functionName('')).toBe('');
    });

    it('에러 케이스: null 입력 시 에러 발생', () => {
      expect(() => functionName(null)).toThrow(ValidationError);
    });
  });
});

4단계: Mock 및 Stub 활용

Mock (가짜 구현)

// API 호출 Mock
const mockApi = {
  fetchUser: jest.fn().mockResolvedValue({ id: 1, name: 'John' }),
  createUser: jest.fn().mockResolvedValue({ success: true }),
};

// 시간 Mock (타이머 테스트)
jest.useFakeTimers();
setTimeout(() => callback(), 1000);
jest.advanceTimersByTime(1000);
expect(callback).toHaveBeenCalled();

// Date Mock
jest.setSystemTime(new Date('2024-01-01'));

Stub (최소 구현)

const stubbedLogger = {
  log: () => {}, // 아무것도 하지 않음
  error: () => {},
};

Spy (호출 감시)

const spy = jest.spyOn(console, 'log');
someFunction();
expect(spy).toHaveBeenCalledWith('expected message');
spy.mockRestore();

5단계: 테스트 커버리지

### 📊 커버리지 목표
- **Statements**: 80% 이상
- **Branches**: 75% 이상
- **Functions**: 80% 이상
- **Lines**: 80% 이상

### 우선순위별 커버리지
- 🔥 Critical 로직: 100%
- ⚡ Core 로직: 90%
- 📦 일반 기능: 70%
- 🎨 UI 컴포넌트: 60%

커버리지 확인:

# Jest
npm test -- --coverage

# Spring Boot
./mvnw test jacoco:report

# Flutter
flutter test --coverage

# 결과 예시
--------------------|---------|----------|---------|---------|
File                | % Stmts | % Branch | % Funcs | % Lines |
--------------------|---------|----------|---------|---------|
All files           |   85.2  |   78.3   |   82.1  |   85.5  |
 auth.service.ts    |   95.0  |   90.0   |   100   |   94.8  |
 user.repository.ts |   78.5  |   70.2   |   75.0  |   78.9  |
--------------------|---------|----------|---------|---------|

테스트 작성 가이드라인

✅ 좋은 테스트

// ✅ 구체적인 테스트명
it('사용자가 올바른 이메일과 비밀번호로 로그인하면 토큰을 반환한다', () => {
  // ...
});

// ✅ 하나의 테스트는 하나만 검증
it('이메일이 유효하지 않으면 에러를 발생시킨다', () => {
  expect(() => validateEmail('invalid')).toThrow();
});

// ✅ AAA 패턴 명확히
it('계산 테스트', () => {
  // Arrange
  const a = 5, b = 3;
  
  // Act
  const result = add(a, b);
  
  // Assert
  expect(result).toBe(8);
});

// ✅ 독립적인 테스트
beforeEach(() => {
  // 각 테스트마다 새로운 상태
  state = createFreshState();
});

❌ 나쁜 테스트

// ❌ 모호한 테스트명
it('테스트1', () => { ... });

// ❌ 여러 개를 한 번에 검증
it('모든 기능 테스트', () => {
  expect(login()).toBeTruthy();
  expect(logout()).toBeTruthy();
  expect(register()).toBeTruthy();
});

// ❌ 다른 테스트에 의존
it('테스트 A', () => {
  globalState.value = 10; // 다음 테스트에 영향
});
it('테스트 B', () => {
  expect(globalState.value).toBe(10); // 테스트 A에 의존
});

// ❌ 구현 세부사항 테스트
it('내부 변수가 정확히 3번 증가한다', () => {
  // 구현이 바뀌면 깨짐
});

테스트 체크리스트

테스트 작성 전

• 테스트 대상 코드가 테스트 가능한가? (의존성 주입 등)
• 어떤 시나리오를 테스트할 것인가?
• Mock이 필요한 의존성이 있는가?
• 기존 테스트 스타일 파악 완료

테스트 작성 중

• 테스트명이 구체적이고 명확한가?
• AAA 패턴을 따르는가?
• 하나의 테스트는 하나만 검증하는가?
• 테스트가 독립적인가?
• 프로젝트 테스트 스타일 준수

테스트 작성 후

• 모든 테스트가 통과하는가?
• 커버리지가 목표치를 달성했는가?
• 엣지 케이스를 충분히 다뤘는가?
• 테스트가 빠르게 실행되는가? (단위 테스트 < 100ms)

출력 형식

🧪 테스트 계획

대상 코드: src/services/auth.service.ts 프로젝트 타입: [Spring Boot / React / Flutter] 테스트 레벨: Unit Test 테스트 프레임워크: [JUnit 5 / Jest / Flutter Test] 기존 테스트 스타일: [감지된 패턴]

테스트 시나리오:

1. ✅ 정상 로그인
2. ✅ 잘못된 비밀번호
3. ✅ 존재하지 않는 사용자
4. ✅ 만료된 토큰
5. ✅ 빈 입력값

📝 테스트 코드 (프로젝트 스타일 준수)

[기존 테스트 패턴을 100% 따라 작성된 테스트 코드]

📊 테스트 결과

실행 명령어:

npm test

결과:

PASS  src/services/auth.service.test.ts
  AuthService
    login
      ✓ 정상: 올바른 이메일과 비밀번호로 로그인 성공 (25ms)
      ✓ 에러: 잘못된 비밀번호 (15ms)
      ✓ 에러: 존재하지 않는 사용자 (12ms)

Test Suites: 1 passed, 1 total
Tests:       3 passed, 3 total
Time:        2.5s

커버리지:

--------------------|---------|----------|---------|---------|
File                | % Stmts | % Branch | % Funcs | % Lines |
--------------------|---------|----------|---------|---------|
auth.service.ts     |   95.0  |   90.0   |   100   |   94.8  |
--------------------|---------|----------|---------|---------|

✅ 테스트 완료

• 정상 케이스 테스트
• 엣지 케이스 테스트
• 에러 케이스 테스트
• 커버리지 90% 이상 달성
• 프로젝트 테스트 스타일 준수

다음 단계:

• 통합 테스트 추가 고려
• E2E 테스트로 전체 플로우 검증

목표: "신뢰할 수 있고 유지보수 가능한 테스트 코드, 그리고 프로젝트 테스트 스타일 일관성 유지"