Claude Code 실전 활용법: 디버깅, 리팩토링, 테스트 자동화 마스터하기

# 에러 로그를 Claude Code에 전달
claude "이 에러를 분석하고 수정해줘" --attach error.log

# 문제가 있는 코드
def process_data(items):
    result = []
    for item in items:
        result.append(item['value'] * 2)
    return result

# Claude Code의 개선된 버전
def process_data(items):
    """
    안전하게 데이터를 처리하고 변환합니다.

    Args:
        items: 'value' 키를 포함할 수 있는 딕셔너리 리스트

    Returns:
        변환된 값들의 리스트
    """
    result = []
    for item in items:
        if not isinstance(item, dict):
            print(f"Warning: 딕셔너리가 아닌 항목 건너뜀: {item}")
            continue

        value = item.get('value')
        if value is None:
            print(f"Warning: 'value' 키가 없는 항목: {item}")
            continue

        result.append(value * 2)
    return result

def getData(id):
    conn = sqlite3.connect('db.sqlite')
    c = conn.cursor()
    c.execute('SELECT * FROM users WHERE id=?', (id,))
    row = c.fetchone()
    conn.close()
    if row:
        return {'id': row[0], 'name': row[1], 'email': row[2]}
    return None

from contextlib import contextmanager
from typing import Optional
from dataclasses import dataclass

@dataclass
class User:
    id: int
    name: str
    email: str

@contextmanager
def get_db_connection(db_path: str = 'db.sqlite'):
    """데이터베이스 연결을 안전하게 관리하는 컨텍스트 매니저"""
    conn = sqlite3.connect(db_path)
    try:
        yield conn
    finally:
        conn.close()

def get_user_by_id(user_id: int) -> Optional[User]:
    """
    ID로 사용자를 조회합니다.

    Args:
        user_id: 조회할 사용자 ID

    Returns:
        User 객체 또는 None
    """
    with get_db_connection() as conn:
        cursor = conn.cursor()
        cursor.execute(
            'SELECT id, name, email FROM users WHERE id = ?',
            (user_id,)
        )
        row = cursor.fetchone()

        if row:
            return User(id=row[0], name=row[1], email=row[2])
        return None

# 테스트할 함수
def calculate_discount(price: float, customer_type: str) -> float:
    if customer_type == 'premium':
        return price * 0.8
    elif customer_type == 'regular':
        return price * 0.9
    else:
        return price

claude "calculate_discount 함수에 대한 pytest 테스트를 작성해줘. 엣지 케이스도 포함"

import pytest
from decimal import Decimal

class TestCalculateDiscount:
    """calculate_discount 함수 테스트 스위트"""

    def test_premium_discount(self):
        """프리미엄 고객 20% 할인 적용"""
        assert calculate_discount(100.0, 'premium') == 80.0

    def test_regular_discount(self):
        """일반 고객 10% 할인 적용"""
        assert calculate_discount(100.0, 'regular') == 90.0

    def test_unknown_customer_type(self):
        """알 수 없는 고객 유형은 할인 없음"""
        assert calculate_discount(100.0, 'guest') == 100.0

    def test_zero_price(self):
        """가격이 0일 때"""
        assert calculate_discount(0.0, 'premium') == 0.0

    def test_negative_price(self):
        """음수 가격 처리"""
        result = calculate_discount(-50.0, 'premium')
        assert result == -40.0

    def test_large_price(self):
        """큰 금액 처리"""
        result = calculate_discount(1_000_000.0, 'regular')
        assert result == 900_000.0

    def test_empty_customer_type(self):
        """빈 문자열 고객 유형"""
        assert calculate_discount(100.0, '') == 100.0

    @pytest.mark.parametrize('price,customer_type,expected', [
        (100.0, 'premium', 80.0),
        (50.0, 'regular', 45.0),
        (75.0, 'guest', 75.0),
        (0.0, 'premium', 0.0),
    ])
    def test_various_scenarios(self, price, customer_type, expected):
        """다양한 시나리오 파라미터 테스트"""
        assert calculate_discount(price, customer_type) == expected

# 1단계: 테스트 작성
claude "사용자 인증 기능을 위한 실패하는 테스트를 먼저 작성해줘"

# 2단계: 구현
claude "이 테스트를 통과하는 최소한의 코드를 작성해줘"

# 3단계: 리팩토링
claude "보안과 가독성을 고려해서 리팩토링해줘"

# Claude Code가 생성한 FastAPI 통합 테스트
from fastapi.testclient import TestClient
import pytest

@pytest.fixture
def client():
    return TestClient(app)

class TestUserAPI:
    def test_create_user(self, client):
        response = client.post(
            '/users/',
            json={'name': 'Test User', 'email': 'test@example.com'}
        )
        assert response.status_code == 201
        data = response.json()
        assert data['name'] == 'Test User'
        assert 'id' in data

    def test_get_user(self, client):
        # 사용자 생성
        create_response = client.post(
            '/users/',
            json={'name': 'Test', 'email': 'test@test.com'}
        )
        user_id = create_response.json()['id']

        # 조회
        response = client.get(f'/users/{user_id}')
        assert response.status_code == 200
        assert response.json()['id'] == user_id

    def test_user_not_found(self, client):
        response = client.get('/users/99999')
        assert response.status_code == 404