Python 테스트 완전 정리

Python code

# test_calculator.py
import pytest
from calculator import add, divide

# 기본 테스트
def test_add_positive():
    assert add(2, 3) == 5

def test_add_negative():
    assert add(-1, 1) == 0

# 예외 테스트
def test_divide_by_zero():
    with pytest.raises(ZeroDivisionError, match="division by zero"):
        divide(10, 0)

# @pytest.mark.parametrize — 여러 케이스 자동 실행
@pytest.mark.parametrize("a, b, expected", [
    (2, 3, 5),
    (0, 0, 0),
    (-1, 1, 0),
    (100, -50, 50),
])
def test_add_cases(a, b, expected):
    assert add(a, b) == expected

# fixture — 테스트 전후 설정/정리
@pytest.fixture
def sample_data():
    data = {"users": ["Alice", "Bob"], "count": 2}
    yield data          # 여기서 테스트 실행됨
    # yield 이후는 teardown
    print("\n정리 완료")

def test_with_fixture(sample_data):
    assert sample_data["count"] == 2
    assert "Alice" in sample_data["users"]

# tmp_path fixture (pytest 내장)
def test_file_write(tmp_path):
    file = tmp_path / "test.txt"
    file.write_text("hello")
    assert file.read_text() == "hello"

# monkeypatch — 의존성 교체
def test_with_mock(monkeypatch):
    monkeypatch.setattr("builtins.input", lambda _: "42")
    # input()이 항상 "42"를 반환

Python code

import pytest
from unittest.mock import AsyncMock, MagicMock, patch

# 비동기 함수 테스트 (pytest-asyncio 필요)
# pip install pytest-asyncio

# pytest.ini 또는 pyproject.toml에 추가:
# [tool.pytest.ini_options]
# asyncio_mode = "auto"

async def fetch_user(api_client, user_id: int) -> dict:
    response = await api_client.get(f"/users/{user_id}")
    return response.json()

@pytest.mark.asyncio
async def test_fetch_user():
    mock_client = AsyncMock()
    mock_client.get.return_value.json.return_value = {
        "id": 1, "name": "Alice"
    }

    result = await fetch_user(mock_client, 1)

    mock_client.get.assert_called_once_with("/users/1")
    assert result["name"] == "Alice"

# patch 데코레이터로 의존성 교체
@patch("requests.get")
def test_with_patch(mock_get):
    mock_get.return_value.json.return_value = {"status": "ok"}
    import requests
    resp = requests.get("https://api.example.com")
    assert resp.json()["status"] == "ok"
    mock_get.assert_called_once_with("https://api.example.com")

# fixture + mock 조합
@pytest.fixture
def mock_db():
    db = MagicMock()
    db.find.return_value = [{"id": 1}, {"id": 2}]
    return db

def test_service(mock_db):
    results = mock_db.find({"active": True})
    assert len(results) == 2
    mock_db.find.assert_called_once_with({"active": True})

Python code

<span class="cm">// hypothesis 기반 속성 테스트 예제
// data/prompts.js의 생성 프롬프트로 상세 코드 생성 가능</span>
fun main() { println("hypothesis 기반 속성 테스트") }

Python code

# pytest 테스트 예제 (실행: pytest test_example.py -v)
import pytest

# 기본 테스트
def test_addition():
    assert 1 + 1 == 2

def test_string():
    assert "hello".upper() == "HELLO"

# 예외 테스트
def test_zero_division():
    with pytest.raises(ZeroDivisionError):
        1 / 0

def test_value_error_message():
    with pytest.raises(ValueError, match="invalid"):
        raise ValueError("invalid input")

# 마커
@pytest.mark.slow
def test_slow_operation():
    import time
    time.sleep(0.01)
    assert True

@pytest.mark.skip(reason="아직 구현 안 됨")
def test_future_feature():
    pass

@pytest.mark.skipif(
    __import__("sys").version_info < (3, 11),
    reason="Python 3.11+ 필요"
)
def test_new_feature():
    assert True

# 근사값 비교
def test_floating_point():
    assert 0.1 + 0.2 == pytest.approx(0.3)
    assert [0.1, 0.2] == pytest.approx([0.1, 0.2], abs=1e-10)

# 실행: pytest -v --tb=short -k "not slow"
print("pytest 테스트 패턴 준비 완료")

Python code

import pytest

# 기본 fixture
@pytest.fixture
def sample_users():
    return [
        {"name": "Alice", "age": 30},
        {"name": "Bob", "age": 25},
    ]

def test_user_count(sample_users):
    assert len(sample_users) == 2

def test_user_name(sample_users):
    assert sample_users[0]["name"] == "Alice"

# Setup / Teardown (yield fixture)
@pytest.fixture
def database():
    db = {"connected": True, "data": []}
    print("\n  DB 연결")
    yield db
    print("  DB 해제")
    db["connected"] = False

def test_insert(database):
    database["data"].append("item1")
    assert len(database["data"]) == 1

# fixture 스코프
@pytest.fixture(scope="module")
def expensive_resource():
    print("\n  [모듈] 비싼 리소스 생성")
    return {"ready": True}

# 파라미터화된 fixture
@pytest.fixture(params=["sqlite", "postgres", "mysql"])
def db_engine(request):
    return {"engine": request.param}

def test_engine(db_engine):
    assert "engine" in db_engine

# conftest.py에 공유 fixture 정의
# 파일: conftest.py
# @pytest.fixture(autouse=True)
# def reset_state():
#     yield
#     # 테스트 후 상태 초기화
print("fixture 패턴 준비 완료")

Python code

import pytest

# 기본 파라미터화
@pytest.mark.parametrize("input,expected", [
    (1, 1),
    (2, 4),
    (3, 9),
    (-1, 1),
    (0, 0),
])
def test_square(input, expected):
    assert input ** 2 == expected

# 여러 파라미터 조합
@pytest.mark.parametrize("a,b,result", [
    (1, 2, 3),
    (0, 0, 0),
    (-1, 1, 0),
    (100, 200, 300),
])
def test_add(a, b, result):
    assert a + b == result

# ID 지정으로 가독성 향상
@pytest.mark.parametrize("text,expected", [
    pytest.param("hello", "HELLO", id="basic"),
    pytest.param("", "", id="empty"),
    pytest.param("Hello World", "HELLO WORLD", id="mixed"),
], ids=str)
def test_upper(text, expected):
    assert text.upper() == expected

# 다중 parametrize (데카르트 곱)
@pytest.mark.parametrize("x", [1, 2])
@pytest.mark.parametrize("y", [10, 20])
def test_multiply(x, y):
    assert x * y > 0  # 4개 조합 테스트

# 조건부 건너뛰기
@pytest.mark.parametrize("n", [
    1,
    pytest.param(2, marks=pytest.mark.skip(reason="알려진 버그")),
    3,
])
def test_with_skip(n):
    assert n > 0

print("파라미터화 테스트 패턴 준비 완료")

Python code

from unittest.mock import Mock, patch, MagicMock

# 기본 Mock
mock_db = Mock()
mock_db.query.return_value = [{"id": 1, "name": "Alice"}]
result = mock_db.query("SELECT * FROM users")
print(f"Mock 결과: {result}")
mock_db.query.assert_called_once_with("SELECT * FROM users")

# side_effect: 동적 반환값
mock_api = Mock()
mock_api.fetch.side_effect = [
    {"status": 200},       # 첫 번째 호출
    {"status": 200},       # 두 번째 호출
    ConnectionError("실패"), # 세 번째 호출
]
print(mock_api.fetch())
print(mock_api.fetch())
try:
    mock_api.fetch()
except ConnectionError as e:
    print(f"예외: {e}")

# patch 데코레이터 패턴
def get_current_time():
    from datetime import datetime
    return datetime.now().isoformat()

# 테스트에서 시간 고정
with patch("datetime.datetime") as mock_dt:
    from datetime import datetime
    mock_dt.now.return_value = datetime(2024, 1, 1, 12, 0)
    # get_current_time() 이 항상 같은 시간 반환

# spec으로 인터페이스 강제
class UserService:
    def get_user(self, user_id: int) -> dict: ...
    def create_user(self, name: str) -> dict: ...

mock_service = Mock(spec=UserService)
mock_service.get_user.return_value = {"name": "Alice"}
print(mock_service.get_user(1))
# mock_service.non_existent()  # AttributeError (spec 위반)

Python code

import pytest

# 테스트할 시스템
class UserRepository:
    def __init__(self):
        self._store = {}
        self._next_id = 1
    def save(self, data):
        data["id"] = self._next_id
        self._store[self._next_id] = data
        self._next_id += 1
        return data
    def find(self, uid):
        return self._store.get(uid)

class EmailService:
    def __init__(self):
        self.sent = []
    def send(self, to, subject):
        self.sent.append({"to": to, "subject": subject})

class UserService:
    def __init__(self, repo, email):
        self.repo = repo
        self.email = email
    def register(self, name, email):
        user = self.repo.save({"name": name, "email": email})
        self.email.send(email, f"환영합니다 {name}님!")
        return user

# 통합 테스트 (실제 객체 사용)
@pytest.fixture
def user_system():
    repo = UserRepository()
    email = EmailService()
    service = UserService(repo, email)
    return {"service": service, "repo": repo, "email": email}

def test_registration_flow(user_system):
    svc = user_system["service"]
    user = svc.register("Alice", "alice@test.com")

    # 저장 확인
    saved = user_system["repo"].find(user["id"])
    assert saved["name"] == "Alice"

    # 이메일 발송 확인
    emails = user_system["email"].sent
    assert len(emails) == 1
    assert emails[0]["to"] == "alice@test.com"
    print("통합 테스트 통과!")

# 직접 실행
system = {"service": UserService(UserRepository(), EmailService()),
          "repo": UserRepository(), "email": EmailService()}
system["service"] = UserService(system["repo"], system["email"])
test_registration_flow(system)

Python code

# hypothesis 패턴 시뮬레이션
import random

def property_test(func, generator, num_tests=100):
    """간단한 프로퍼티 기반 테스트 러너"""
    for i in range(num_tests):
        test_input = generator()
        try:
            func(test_input)
        except AssertionError as e:
            print(f"  실패! 입력: {test_input}")
            raise
    print(f"  {num_tests}개 테스트 통과!")

# 테스트할 함수
def my_sort(lst):
    return sorted(lst)

# 속성 1: 정렬 결과의 길이는 입력과 같다
def test_sort_preserves_length(data):
    result = my_sort(data)
    assert len(result) == len(data)

# 속성 2: 결과는 정렬되어 있다
def test_sort_is_ordered(data):
    result = my_sort(data)
    assert all(result[i] <= result[i+1] for i in range(len(result)-1))

# 속성 3: 모든 원소가 보존된다
def test_sort_preserves_elements(data):
    result = my_sort(data)
    assert sorted(result) == sorted(data)

# 무작위 입력 생성기
def random_int_list():
    return [random.randint(-100, 100)
            for _ in range(random.randint(0, 20))]

print("=== 길이 보존 ===")
property_test(test_sort_preserves_length, random_int_list)
print("=== 정렬 순서 ===")
property_test(test_sort_is_ordered, random_int_list)
print("=== 원소 보존 ===")
property_test(test_sort_preserves_elements, random_int_list)

# 실제 hypothesis 사용법:
# from hypothesis import given, strategies as st
# @given(st.lists(st.integers()))
# def test_sort(data):
#     assert sorted(data) == sorted(sorted(data))

Python code

# BDD 스타일 테스트 프레임워크 시뮬레이션
class BDDTest:
    def __init__(self, feature: str):
        self.feature = feature
        self.context = {}
        print(f"Feature: {feature}")

    def scenario(self, name: str):
        print(f"\n  Scenario: {name}")
        self.context = {}
        return self

    def given(self, desc: str, action=None):
        print(f"    Given {desc}")
        if action:
            action(self.context)
        return self

    def when(self, desc: str, action=None):
        print(f"    When {desc}")
        if action:
            action(self.context)
        return self

    def then(self, desc: str, check=None):
        print(f"    Then {desc}")
        if check:
            check(self.context)
            print("      ✅ 통과")
        return self

# 테스트 대상
class Cart:
    def __init__(self):
        self.items = []
    def add(self, item, price):
        self.items.append({"item": item, "price": price})
    @property
    def total(self):
        return sum(i["price"] for i in self.items)

# BDD 테스트 실행
test = BDDTest("장바구니 기능")

(test.scenario("상품 추가")
    .given("빈 장바구니가 있다",
           lambda ctx: ctx.update({"cart": Cart()}))
    .when("노트북을 추가한다",
          lambda ctx: ctx["cart"].add("노트북", 1500000))
    .when("마우스를 추가한다",
          lambda ctx: ctx["cart"].add("마우스", 50000))
    .then("상품이 2개이다",
          lambda ctx: assert_(len(ctx["cart"].items) == 2))
    .then("총액은 1,550,000원이다",
          lambda ctx: assert_(ctx["cart"].total == 1550000)))

def assert_(condition):
    assert condition

Python code

# coverage 라이브러리 사용 패턴 시뮬레이션
# pip install coverage pytest-cov

# 테스트 대상 코드
def calculate_grade(score: int) -> str:
    if score >= 90:
        return "A"
    elif score >= 80:
        return "B"
    elif score >= 70:
        return "C"
    elif score >= 60:
        return "D"
    else:
        return "F"

def is_prime(n: int) -> bool:
    if n < 2:
        return False
    if n == 2:
        return True
    if n % 2 == 0:
        return False
    for i in range(3, int(n**0.5) + 1, 2):
        if n % i == 0:
            return False
    return True

# 테스트
def test_grade():
    assert calculate_grade(95) == "A"
    assert calculate_grade(85) == "B"
    assert calculate_grade(75) == "C"
    assert calculate_grade(65) == "D"
    assert calculate_grade(50) == "F"
    print("test_grade 통과!")

def test_prime():
    assert not is_prime(1)
    assert is_prime(2)
    assert is_prime(3)
    assert not is_prime(4)
    assert is_prime(17)
    print("test_prime 통과!")

test_grade()
test_prime()

# 실행 방법:
# pytest --cov=src --cov-report=html
# coverage run -m pytest
# coverage report --show-missing
# coverage html  → htmlcov/index.html
print("\n커버리지 명령어:")
print("  pytest --cov=. --cov-report=term-missing")

Python code

import time
from functools import lru_cache

# 벤치마크 대상 함수들
def fib_recursive(n):
    if n < 2:
        return n
    return fib_recursive(n-1) + fib_recursive(n-2)

@lru_cache(maxsize=None)
def fib_cached(n):
    if n < 2:
        return n
    return fib_cached(n-1) + fib_cached(n-2)

def fib_iterative(n):
    a, b = 0, 1
    for _ in range(n):
        a, b = b, a + b
    return a

# 간단한 벤치마크 러너
def benchmark(func, *args, iterations=1000):
    start = time.perf_counter()
    for _ in range(iterations):
        result = func(*args)
    elapsed = time.perf_counter() - start
    avg = elapsed / iterations * 1_000_000  # 마이크로초
    print(f"  {func.__name__:20s}: {avg:>8.2f} μs/호출 "
          f"({iterations}회, 총 {elapsed:.3f}초)")
    return result

n = 20
print(f"=== 피보나치({n}) 벤치마크 ===")
benchmark(fib_recursive, n, iterations=100)
fib_cached.cache_clear()
benchmark(fib_cached, n, iterations=10000)
benchmark(fib_iterative, n, iterations=10000)

# pytest-benchmark 사용법:
# def test_fib(benchmark):
#     result = benchmark(fib_iterative, 20)
#     assert result == 6765
# 실행: pytest --benchmark-only
print("\npytest 명령: pytest --benchmark-compare")

Python code

import json
import hashlib

class SnapshotTester:
    def __init__(self):
        self._snapshots: dict[str, str] = {}

    def assert_match(self, name: str, value) -> bool:
        serialized = json.dumps(value, sort_keys=True,
                                ensure_ascii=False, indent=2)
        checksum = hashlib.md5(serialized.encode()).hexdigest()[:8]

        if name not in self._snapshots:
            self._snapshots[name] = serialized
            print(f"  📸 스냅샷 저장: {name} [{checksum}]")
            return True

        if self._snapshots[name] == serialized:
            print(f"  ✅ 스냅샷 일치: {name} [{checksum}]")
            return True

        print(f"  ❌ 스냅샷 불일치: {name}")
        print(f"    기대: {self._snapshots[name][:50]}...")
        print(f"    실제: {serialized[:50]}...")
        return False

# 사용 예시
def generate_report(users):
    return {
        "total": len(users),
        "names": sorted(u["name"] for u in users),
        "avg_age": sum(u["age"] for u in users) / len(users),
    }

snap = SnapshotTester()

users = [
    {"name": "Alice", "age": 30},
    {"name": "Bob", "age": 25},
]

report = generate_report(users)
snap.assert_match("user_report", report)
snap.assert_match("user_report", report)  # 일치

# 변경 감지
report["total"] = 999
snap.assert_match("user_report", report)  # 불일치!

# 실제 사용: pip install pytest-snapshot 또는 syrupy
# def test_report(snapshot):
#     assert generate_report(users) == snapshot

Python code

import copy
import ast

# 간단한 뮤테이션 테스트 시뮬레이션
def is_adult(age: int) -> bool:
    return age >= 18

def calculate_discount(price: float, rate: float) -> float:
    if rate < 0 or rate > 1:
        raise ValueError("할인율은 0~1 사이")
    return price * (1 - rate)

# 테스트 스위트
def test_is_adult():
    assert is_adult(18) == True
    assert is_adult(17) == False
    assert is_adult(0) == False
    assert is_adult(100) == True

def test_discount():
    assert calculate_discount(10000, 0.1) == 9000
    assert calculate_discount(10000, 0) == 10000

# 뮤턴트 생성 및 테스트
mutations = [
    ("age >= 18 → age > 18", lambda age: age > 18),
    ("age >= 18 → age >= 19", lambda age: age >= 19),
    ("age >= 18 → age <= 18", lambda age: age <= 18),
    ("age >= 18 → True", lambda age: True),
]

print("=== 뮤테이션 테스트 ===")
killed = 0
for desc, mutant in mutations:
    try:
        assert mutant(18) == True
        assert mutant(17) == False
        assert mutant(0) == False
        print(f"  ☠️ 살아남음: {desc}")  # 테스트 부족!
    except AssertionError:
        killed += 1
        print(f"  ✅ 잡힘: {desc}")

total = len(mutations)
score = killed / total * 100
print(f"\n뮤테이션 점수: {killed}/{total} ({score:.0f}%)")

# 실제 사용: pip install mutmut
# mutmut run --paths-to-mutate=src/

Python code

# .github/workflows/test.yml 내용
ci_config = """
name: Python Tests

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        python-version: ["3.10", "3.11", "3.12"]

    steps:
    - uses: actions/checkout@v4
    - name: Set up Python
      uses: actions/setup-python@v5
      with:
        python-version: ${{ matrix.python-version }}
    - name: Install dependencies
      run: |
        pip install -e ".[dev]"
    - name: Lint
      run: ruff check src/
    - name: Type check
      run: mypy src/
    - name: Test
      run: pytest --cov=src --cov-report=xml -v
    - name: Upload coverage
      uses: codecov/codecov-action@v3
"""
print(ci_config)

# pyproject.toml 테스트 설정
pyproject_testing = """
[tool.pytest.ini_options]
testpaths = ["tests"]
addopts = "-v --tb=short --strict-markers"
markers = [
    "slow: 느린 테스트",
    "integration: 통합 테스트",
]

[tool.coverage.run]
source = ["src"]
omit = ["*/tests/*"]

[tool.coverage.report]
fail_under = 80
show_missing = true
"""
print(pyproject_testing)