[이제와서 시작하는 Claude AI 마스터하기 #12] 테스트 코드 작성 자동화

게시 2025/07/27

By YonYonWare

18 분읽는 시간

완벽한 테스트 커버리지를 향해

Claude Code의 테스트 자동 생성 기능은 개발자가 가장 번거로워하는 작업 중 하나인 테스트 작성을 혁신적으로 간소화합니다. 코드의 의도를 이해하고 엣지 케이스까지 고려한 포괄적인 테스트를 생성합니다.

테스트 생성 기본 기능

테스트 유형별 Claude Code 자동 생성 능력

테스트 유형	설명	자동화 수준	생성 시간	주요 특징
단위 테스트	개별 함수/메소드	95% 자동	1-3초	엣지 케이스 포함
통합 테스트	컴포넌트 간 상호작용	80% 자동	5-10초	의존성 모킹
E2E 테스트	전체 시나리오	60% 자동	10-20초	시나리오 기반
성능 테스트	부하/응답시간	70% 자동	5-15초	벤치마크 생성
보안 테스트	취약점 검증	50% 자동	10-30초	OWASP 기준

1. 자동 테스트 생성 프로세스

graph TD
    A[코드 분석] --> B[함수 시그니처 파악]
    B --> C[로직 이해]
    C --> D[테스트 케이스 도출]
    
    D --> E[정상 케이스]
    D --> F[엣지 케이스]
    D --> G[에러 케이스]
    
    E --> H[테스트 코드 생성]
    F --> H
    G --> H
    
    H --> I[테스트 실행]
    I --> J[커버리지 확인]

2. 단위 테스트 자동 생성

  
// 원본 함수
function calculateDiscount(price, discountRate, customerType) {
  if (price < 0 || discountRate < 0 || discountRate > 1) {
    throw new Error('Invalid input');
  }
  
  let finalDiscount = discountRate;
  
  if (customerType === 'VIP') {
    finalDiscount = Math.min(discountRate * 1.5, 0.5);
  } else if (customerType === 'REGULAR' && price > 100) {
    finalDiscount = discountRate * 1.1;
  }
  
  return price * (1 - finalDiscount);
}

// Claude가 생성한 테스트
describe('calculateDiscount', () => {
  describe('정상 케이스', () => {
    it('일반 고객 기본 할인 적용', () => {
      expect(calculateDiscount(100, 0.1, 'REGULAR')).toBe(90);
    });
    
    it('일반 고객 100원 초과 시 추가 할인', () => {
      expect(calculateDiscount(200, 0.1, 'REGULAR')).toBe(178);
    });
    
    it('VIP 고객 할인율 1.5배 적용', () => {
      expect(calculateDiscount(100, 0.2, 'VIP')).toBe(70);
    });
    
    it('VIP 최대 할인율 50% 제한', () => {
      expect(calculateDiscount(100, 0.4, 'VIP')).toBe(50);
    });
  });
  
  describe('엣지 케이스', () => {
    it('가격이 0원인 경우', () => {
      expect(calculateDiscount(0, 0.1, 'REGULAR')).toBe(0);
    });
    
    it('할인율이 0인 경우', () => {
      expect(calculateDiscount(100, 0, 'VIP')).toBe(100);
    });
    
    it('할인율이 1인 경우', () => {
      expect(calculateDiscount(100, 1, 'REGULAR')).toBe(0);
    });
    
    it('정확히 100원인 경우 추가 할인 없음', () => {
      expect(calculateDiscount(100, 0.1, 'REGULAR')).toBe(90);
    });
  });
  
  describe('에러 케이스', () => {
    it('음수 가격 입력 시 에러', () => {
      expect(() => calculateDiscount(-100, 0.1, 'REGULAR'))
        .toThrow('Invalid input');
    });
    
    it('음수 할인율 입력 시 에러', () => {
      expect(() => calculateDiscount(100, -0.1, 'REGULAR'))
        .toThrow('Invalid input');
    });
    
    it('1 초과 할인율 입력 시 에러', () => {
      expect(() => calculateDiscount(100, 1.5, 'REGULAR'))
        .toThrow('Invalid input');
    });
    
    it('알 수 없는 고객 타입은 기본 할인만 적용', () => {
      expect(calculateDiscount(100, 0.1, 'UNKNOWN')).toBe(90);
    });
  });
});

3. 통합 테스트 생성

  
// API 엔드포인트
class UserController {
  async createUser(req: Request, res: Response) {
    const {name, email} = req.body;
    
    if (!name || !email) {
      return res.status(400).json({error: 'Missing required fields'});
    }
    
    const existingUser = await User.findOne({email});
    if (existingUser) {
      return res.status(409).json({error: 'User already exists'});
    }
    
    const user = await User.create({name, email});
    return res.status(201).json(user);
  }
}

// Claude가 생성한 통합 테스트
describe('UserController', () => {
  let app: Application;
  
  beforeAll(() => {
    app = createTestApp();
  });
  
  afterEach(async () => {
    await User.deleteMany({});
  });
  
  describe('POST /users', () => {
    it('성공적으로 사용자 생성', async () => {
      const response = await request(app)
        .post('/users')
        .send({
          name: 'John Doe',
          email: 'john@example.com'
        });
      
      expect(response.status).toBe(201);
      expect(response.body).toMatchObject({
        name: 'John Doe',
        email: 'john@example.com'
      });
      
      const user = await User.findOne({email: 'john@example.com'});
      expect(user).toBeTruthy();
    });
    
    it('필수 필드 누락 시 400 에러', async () => {
      const response = await request(app)
        .post('/users')
        .send({name: 'John Doe'});
      
      expect(response.status).toBe(400);
      expect(response.body.error).toBe('Missing required fields');
    });
    
    it('중복 이메일 시 409 에러', async () => {
      await User.create({
        name: 'Existing User',
        email: 'john@example.com'
      });
      
      const response = await request(app)
        .post('/users')
        .send({
          name: 'John Doe',
          email: 'john@example.com'
        });
      
      expect(response.status).toBe(409);
      expect(response.body.error).toBe('User already exists');
    });
    
    it('DB 연결 실패 시 500 에러', async () => {
      jest.spyOn(User, 'create').mockRejectedValue(
        new Error('DB connection failed')
      );
      
      const response = await request(app)
        .post('/users')
        .send({
          name: 'John Doe',
          email: 'john@example.com'
        });
      
      expect(response.status).toBe(500);
    });
  });
});

테스트 전략 수립

테스트 작성 베스트 프랙티스

원칙	설명	좋은 예	나쁜 예
단일 책임	하나의 테스트는 하나만 검증	`it('calculates discount correctly')`	`it('tests everything')`
독립성	테스트 간 의존성 없음	각 테스트마다 setup/teardown	이전 테스트 결과 활용
명확성	테스트 이름이 의도를 설명	`it('returns 404 when user not found')`	`it('test case 1')`
속도	빠른 실행	모킹/스터빙 활용	실제 DB/API 호출
유지보수성	변경에 강한 테스트	구현보다 동작 검증	내부 구현 검증

1. 테스트 피라미드 구현

graph TD
    A[E2E 테스트<br>10%] --> B[통합 테스트<br>30%]
    B --> C[단위 테스트<br>60%]
    
    D[Claude 자동 생성]
    D --> E[단위: 완전 자동]
    D --> F[통합: 반자동]
    D --> G[E2E: 시나리오 기반]

2. 커버리지 목표 설정

  
// .claude/test-config.json
{
  "coverage": {
    "target": {
      "statements": 80,
      "branches": 75,
      "functions": 80,
      "lines": 80
    },
    "exclude": [
      "**/*.test.js",
      "**/node_modules/**",
      "**/migrations/**"
    ],
    "autoGenerate": {
      "enabled": true,
      "minCoverage": 70,
      "prioritize": ["critical", "complex", "public"]
    }
  }
}

고급 테스트 생성

1. 프로퍼티 기반 테스트

  
// 일반 함수
function sortArray(arr: number[]): number[] {
  return [...arr].sort((a, b) => a - b);
}

// Claude가 생성한 프로퍼티 테스트
import fc from 'fast-check';

describe('sortArray property tests', () => {
  it('결과 배열의 길이는 입력과 동일', () => {
    fc.assert(
      fc.property(fc.array(fc.integer()), (arr) => {
        expect(sortArray(arr).length).toBe(arr.length);
      })
    );
  });
  
  it('결과는 항상 오름차순', () => {
    fc.assert(
      fc.property(fc.array(fc.integer()), (arr) => {
        const sorted = sortArray(arr);
        for (let i = 1; i < sorted.length; i++) {
          expect(sorted[i]).toBeGreaterThanOrEqual(sorted[i-1]);
        }
      })
    );
  });
  
  it('원본 배열의 모든 요소 포함', () => {
    fc.assert(
      fc.property(fc.array(fc.integer()), (arr) => {
        const sorted = sortArray(arr);
        const originalCounts = countElements(arr);
        const sortedCounts = countElements(sorted);
        expect(sortedCounts).toEqual(originalCounts);
      })
    );
  });
  
  it('멱등성: 두 번 정렬해도 결과 동일', () => {
    fc.assert(
      fc.property(fc.array(fc.integer()), (arr) => {
        const once = sortArray(arr);
        const twice = sortArray(once);
        expect(twice).toEqual(once);
      })
    );
  });
});

2. 스냅샷 테스트 생성

  
// React 컴포넌트
const UserProfile = ({user}) => (
  <div className="user-profile">
    <img src={user.avatar} alt={user.name} />
    <h2>{user.name}</h2>
    <p>{user.bio}</p>
    <div className="stats">
      <span>Posts: {user.postCount}</span>
      <span>Followers: {user.followerCount}</span>
    </div>
  </div>
);

// Claude가 생성한 스냅샷 테스트
describe('UserProfile', () => {
  it('기본 렌더링 스냅샷', () => {
    const user = {
      avatar: 'https://example.com/avatar.jpg',
      name: 'John Doe',
      bio: 'Software Developer',
      postCount: 42,
      followerCount: 100
    };
    
    const component = renderer.create(
      <UserProfile user={user} />
    );
    
    expect(component.toJSON()).toMatchSnapshot();
  });
  
  it('긴 이름과 바이오 스냅샷', () => {
    const user = {
      avatar: 'https://example.com/avatar.jpg',
      name: 'Very Long Name That Might Break Layout',
      bio: 'A very long bio that contains multiple sentences...',
      postCount: 999999,
      followerCount: 999999
    };
    
    const component = renderer.create(
      <UserProfile user={user} />
    );
    
    expect(component.toJSON()).toMatchSnapshot();
  });
});

3. 모킹 전략

  
// 복잡한 의존성이 있는 서비스
class PaymentService {
  constructor(
    private stripe: StripeClient,
    private emailService: EmailService,
    private logger: Logger
  ) {}
  
  async processPayment(amount: number, customerId: string) {
    try {
      const charge = await this.stripe.charges.create({
        amount,
        currency: 'usd',
        customer: customerId
      });
      
      await this.emailService.sendReceipt(customerId, charge.id);
      this.logger.info(`Payment processed: ${charge.id}`);
      
      return {success: true, chargeId: charge.id};
    } catch (error) {
      this.logger.error('Payment failed', error);
      throw error;
    }
  }
}

// Claude가 생성한 모킹 테스트
describe('PaymentService', () => {
  let paymentService: PaymentService;
  let mockStripe: jest.Mocked<StripeClient>;
  let mockEmailService: jest.Mocked<EmailService>;
  let mockLogger: jest.Mocked<Logger>;
  
  beforeEach(() => {
    mockStripe = {
      charges: {
        create: jest.fn()
      }
    };
    mockEmailService = {
      sendReceipt: jest.fn()
    };
    mockLogger = {
      info: jest.fn(),
      error: jest.fn()
    };
    
    paymentService = new PaymentService(
      mockStripe,
      mockEmailService,
      mockLogger
    );
  });
  
  it('성공적인 결제 처리', async () => {
    mockStripe.charges.create.mockResolvedValue({
      id: 'ch_123',
      amount: 1000
    });
    mockEmailService.sendReceipt.mockResolvedValue();
    
    const result = await paymentService.processPayment(1000, 'cus_123');
    
    expect(result).toEqual({
      success: true,
      chargeId: 'ch_123'
    });
    
    expect(mockStripe.charges.create).toHaveBeenCalledWith({
      amount: 1000,
      currency: 'usd',
      customer: 'cus_123'
    });
    
    expect(mockEmailService.sendReceipt).toHaveBeenCalledWith(
      'cus_123',
      'ch_123'
    );
    
    expect(mockLogger.info).toHaveBeenCalledWith(
      'Payment processed: ch_123'
    );
  });
  
  it('Stripe 에러 처리', async () => {
    const error = new Error('Card declined');
    mockStripe.charges.create.mockRejectedValue(error);
    
    await expect(
      paymentService.processPayment(1000, 'cus_123')
    ).rejects.toThrow('Card declined');
    
    expect(mockEmailService.sendReceipt).not.toHaveBeenCalled();
    expect(mockLogger.error).toHaveBeenCalledWith(
      'Payment failed',
      error
    );
  });
});

테스트 유지보수

1. 테스트 리팩토링

  
// 중복이 많은 테스트
describe('UserService - Before', () => {
  it('test1', () => {
    const user = {id: 1, name: 'John', age: 30};
    const service = new UserService();
    // ... 테스트 로직
  });
  
  it('test2', () => {
    const user = {id: 1, name: 'John', age: 30};
    const service = new UserService();
    // ... 테스트 로직
  });
});

// Claude 리팩토링 후
describe('UserService', () => {
  let service: UserService;
  let testUser: User;
  
  beforeEach(() => {
    service = new UserService();
    testUser = createTestUser();
  });
  
  // 테스트 헬퍼 함수
  function createTestUser(overrides = {}): User {
    return {
      id: 1,
      name: 'John',
      age: 30,
      email: 'john@example.com',
      ...overrides
    };
  }
  
  // 커스텀 매처
  expect.extend({
    toBeValidUser(received) {
      const pass = received.id && received.name && received.email;
      return {
        pass,
        message: () => `Expected ${received} to be a valid user`
      };
    }
  });
  
  it('사용자 생성 성공', () => {
    const result = service.createUser(testUser);
    expect(result).toBeValidUser();
  });
});

2. 테스트 성능 최적화

  
// Claude의 테스트 성능 분석
{
  "slowTests": [
    {
      "name": "Database integration test",
      "duration": "5.2s",
      "suggestion": "Use in-memory database for tests"
    },
    {
      "name": "API integration test",
      "duration": "3.8s",
      "suggestion": "Mock external API calls"
    }
  ],
  "optimization": {
    "before": "Total: 45s",
    "after": "Total: 12s",
    "improvement": "73% faster"
  }
}

CI/CD 통합

테스트 자동화 파이프라인

  
# .github/workflows/test.yml
name: Automated Testing

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    
    steps:
    - uses: actions/checkout@v2
    
    - name: Claude Test Generation
      run: |
        claude test generate --missing
        claude test optimize --performance
    
    - name: Run Tests
      run: |
        npm test -- --coverage
    
    - name: Coverage Report
      run: |
        claude test coverage --analyze
    
    - name: Test Quality Check
      run: |
        claude test quality --min-assertions 3

2025년 최신 테스트 자동화 트렌드

AI 기반 테스트 생성 도구 비교

도구	유형	주요 기능	장점	단점	가격
Claude Code	AI 통합	컨텍스트 인식 테스트	높은 정확도	Claude 구독 필요	$20/월
GitHub Copilot	AI 자동완성	코드 작성 중 제안	IDE 통합	제한적 테스트	$10/월
TestGPT	전용 테스트 AI	테스트 특화	다양한 프레임워크	별도 도구	$30/월
Codium AI	테스트 생성	자동 테스트 제안	무료 옵션	기능 제한	무료/$19
Tabnine	AI 코드 완성	테스트 패턴 학습	오프라인 가능	일반적 패턴만	$12/월

Claude Code 2025 테스트 자동화 신기능

graph LR
    A[소스 코드] --> B[Claude Code 분석]
    B --> C{테스트 전략}
    
    C --> D[Coverage 분석]
    C --> E[복잡도 평가]
    C --> F[의존성 파악]
    
    D --> G[Missing Tests]
    E --> H[Priority Tests]
    F --> I[Mock Strategy]
    
    G --> J[자동 생성]
    H --> J
    I --> J
    
    J --> K[테스트 코드]
    K --> L[실행 & 검증]
    L --> M{통과?}
    
    M -->|Yes| N[커밋]
    M -->|No| O[수정 제안]
    O --> J

테스트 문서화

자동 생성된 테스트 문서

  
# 테스트 사양서
생성일: 2025-07-27
생성자: Claude Code

## calculateDiscount 함수

### 목적
가격, 할인율, 고객 타입에 따라 최종 가격을 계산

### 테스트 시나리오

#### 1. 정상 케이스 (4개)
- ✅ 일반 고객 기본 할인
- ✅ 일반 고객 추가 할인 (100원 초과)
- ✅ VIP 고객 1.5배 할인
- ✅ VIP 최대 할인 제한 (50%)

#### 2. 엣지 케이스 (4개)
- ✅ 0원 가격 처리
- ✅ 0% 할인율 처리
- ✅ 100% 할인율 처리
- ✅ 경계값 (정확히 100원)

#### 3. 에러 케이스 (3개)
- ✅ 음수 가격 검증
- ✅ 잘못된 할인율 검증
- ✅ 알 수 없는 고객 타입

### 커버리지
- Statement: 100%
- Branch: 100%
- Function: 100%

다음 편 예고

다음 편에서는 “멀티파일 편집과 대규모 변경”을 다룰 예정입니다. Claude Code로 프로젝트 전체를 효율적으로 수정하는 방법을 알아보겠습니다.

💡 오늘의 과제: 테스트가 없는 함수를 하나 선택해 Claude Code로 테스트를 생성해보세요. 생성된 테스트의 커버리지와 품질을 평가해보세요!

AI, Claude, Tutorial

claude ai tutorial beginner series testing automation test-generation claude-code