# ===== コード例 1: pytest によるユニットテストと AAA パターン =====
 
import pytest
from decimal import Decimal
 
 
# --- テスト対象のコード ---
 
class Money:
    """金額を扱うバリューオブジェクト。"""
 
    def __init__(self, amount: int, currency: str = "JPY"):
        if amount < 0:
            raise ValueError("金額は 0 以上でなければならない")
        if currency not in ("JPY", "USD", "EUR"):
            raise ValueError(f"未対応の通貨: {currency}")
        self.amount = amount
        self.currency = currency
 
    def add(self, other: "Money") -> "Money":
        if self.currency != other.currency:
            raise ValueError("異なる通貨同士の加算はできない")
        return Money(self.amount + other.amount, self.currency)
 
    def multiply(self, factor: int) -> "Money":
        if factor < 0:
            raise ValueError("係数は 0 以上でなければならない")
        return Money(self.amount * factor, self.currency)
 
    def __eq__(self, other: object) -> bool:
        if not isinstance(other, Money):
            return NotImplemented
        return self.amount == other.amount and self.currency == other.currency
 
    def __repr__(self) -> str:
        return f"Money({self.amount}, '{self.currency}')"
 
 
# --- テストコード ---
 
class TestMoney:
    """Money クラスのユニットテスト。"""
 
    # === 正常系テスト ===
 
    def test_生成_正常な金額で生成できる(self):
        # Arrange（準備）
        amount = 1000
        currency = "JPY"
 
        # Act（実行）
        money = Money(amount, currency)
 
        # Assert（検証）
        assert money.amount == 1000
        assert money.currency == "JPY"
 
    def test_加算_同一通貨の金額を加算できる(self):
        # Arrange
        money1 = Money(1000, "JPY")
        money2 = Money(500, "JPY")
 
        # Act
        result = money1.add(money2)
 
        # Assert
        assert result == Money(1500, "JPY")
 
    def test_乗算_正の係数で乗算できる(self):
        # Arrange
        money = Money(100, "USD")
 
        # Act
        result = money.multiply(3)
 
        # Assert
        assert result == Money(300, "USD")
 
    def test_等価性_同じ金額と通貨なら等しい(self):
        assert Money(500, "JPY") == Money(500, "JPY")
 
    def test_等価性_金額が異なれば等しくない(self):
        assert Money(500, "JPY") != Money(600, "JPY")
 
    def test_等価性_通貨が異なれば等しくない(self):
        assert Money(500, "JPY") != Money(500, "USD")
 
    # === 異常系テスト ===
 
    def test_生成_負の金額で例外が発生する(self):
        with pytest.raises(ValueError, match="金額は 0 以上"):
            Money(-100, "JPY")
 
    def test_生成_未対応通貨で例外が発生する(self):
        with pytest.raises(ValueError, match="未対応の通貨"):
            Money(100, "GBP")
 
    def test_加算_異なる通貨で例外が発生する(self):
        money_jpy = Money(1000, "JPY")
        money_usd = Money(10, "USD")
        with pytest.raises(ValueError, match="異なる通貨"):
            money_jpy.add(money_usd)
 
    def test_乗算_負の係数で例外が発生する(self):
        money = Money(100, "JPY")
        with pytest.raises(ValueError, match="係数は 0 以上"):
            money.multiply(-1)
 
    # === 境界値テスト ===
 
    def test_生成_金額0は有効(self):
        money = Money(0, "JPY")
        assert money.amount == 0
 
    def test_加算_金額0同士の加算(self):
        result = Money(0, "JPY").add(Money(0, "JPY"))
        assert result == Money(0, "JPY")
 
    def test_乗算_係数0で金額0になる(self):
        result = Money(1000, "JPY").multiply(0)
        assert result == Money(0, "JPY")

# ===== コード例 2: pytest + SQLAlchemy による統合テスト =====
 
import pytest
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import sessionmaker, declarative_base
 
Base = declarative_base()
 
 
class User(Base):
    """ユーザーテーブルのモデル。"""
    __tablename__ = "users"
    id = Column(Integer, primary_key=True, autoincrement=True)
    name = Column(String(100), nullable=False)
    email = Column(String(255), unique=True, nullable=False)
 
 
class UserRepository:
    """ユーザーのデータアクセスを担当するリポジトリ。"""
 
    def __init__(self, session):
        self.session = session
 
    def add(self, name: str, email: str) -> User:
        user = User(name=name, email=email)
        self.session.add(user)
        self.session.commit()
        return user
 
    def find_by_email(self, email: str) -> User | None:
        return self.session.query(User).filter_by(email=email).first()
 
    def find_all(self) -> list[User]:
        return self.session.query(User).all()
 
    def delete(self, user: User) -> None:
        self.session.delete(user)
        self.session.commit()
 
 
# --- テスト用フィクスチャ ---
 
@pytest.fixture
def db_session():
    """テスト用のインメモリ SQLite セッションを提供する。"""
    engine = create_engine("sqlite:///:memory:", echo=False)
    Base.metadata.create_all(engine)
    Session = sessionmaker(bind=engine)
    session = Session()
    yield session
    session.close()
 
 
@pytest.fixture
def user_repo(db_session):
    """UserRepository のインスタンスを提供する。"""
    return UserRepository(db_session)
 
 
# --- 統合テスト ---
 
class TestUserRepository:
    """UserRepository の統合テスト。実際の DB（インメモリ SQLite）を使用する。"""
 
    def test_ユーザーを追加して取得できる(self, user_repo):
        # Arrange & Act
        user_repo.add("Alice", "alice@example.com")
 
        # Assert
        found = user_repo.find_by_email("alice@example.com")
        assert found is not None
        assert found.name == "Alice"
        assert found.email == "alice@example.com"
 
    def test_存在しないメールで検索するとNoneが返る(self, user_repo):
        result = user_repo.find_by_email("nobody@example.com")
        assert result is None
 
    def test_複数ユーザーを登録して全件取得できる(self, user_repo):
        user_repo.add("Alice", "alice@example.com")
        user_repo.add("Bob", "bob@example.com")
        user_repo.add("Charlie", "charlie@example.com")
 
        users = user_repo.find_all()
        assert len(users) == 3
 
    def test_ユーザーを削除できる(self, user_repo):
        user = user_repo.add("Alice", "alice@example.com")
        user_repo.delete(user)
 
        assert user_repo.find_by_email("alice@example.com") is None
 
    def test_重複メールで追加すると例外が発生する(self, user_repo):
        user_repo.add("Alice", "alice@example.com")
        with pytest.raises(Exception):  # IntegrityError
            user_repo.add("Alice2", "alice@example.com")

# ===== コード例 3: TDD で FizzBuzz を実装する =====
 
# --- ステップ 1: RED — 最初のテストを書く ---
# テストファイル: test_fizzbuzz.py
 
def test_1を渡すと文字列1を返す():
    assert fizzbuzz(1) == "1"
 
# この時点で fizzbuzz 関数は存在しないため、テストは失敗する（NameError）
 
 
# --- ステップ 2: GREEN — テストを通す最小限のコード ---
# プロダクションコード: fizzbuzz.py
 
def fizzbuzz(n: int) -> str:
    return str(n)
 
# テスト実行 → PASSED
 
 
# --- ステップ 3: RED — 次のテストを追加 ---
 
def test_3を渡すとFizzを返す():
    assert fizzbuzz(3) == "Fizz"
 
# テスト実行 → FAILED（"3" != "Fizz"）
 
 
# --- ステップ 4: GREEN — テストを通す ---
 
def fizzbuzz(n: int) -> str:
    if n % 3 == 0:
        return "Fizz"
    return str(n)
 
# テスト実行 → 2件とも PASSED
 
 
# --- ステップ 5: RED — さらにテストを追加 ---
 
def test_5を渡すとBuzzを返す():
    assert fizzbuzz(5) == "Buzz"
 
# テスト実行 → FAILED
 
 
# --- ステップ 6: GREEN ---
 
def fizzbuzz(n: int) -> str:
    if n % 3 == 0:
        return "Fizz"
    if n % 5 == 0:
        return "Buzz"
    return str(n)
 
# テスト実行 → 3件とも PASSED
 
 
# --- ステップ 7: RED — 15の倍数のテスト ---
 
def test_15を渡すとFizzBuzzを返す():
    assert fizzbuzz(15) == "FizzBuzz"
 
# テスト実行 → FAILED（"Fizz" != "FizzBuzz"）
 
 
# --- ステップ 8: GREEN ---
 
def fizzbuzz(n: int) -> str:
    if n % 15 == 0:
        return "FizzBuzz"
    if n % 3 == 0:
        return "Fizz"
    if n % 5 == 0:
        return "Buzz"
    return str(n)
 
# テスト実行 → 4件とも PASSED
 
 
# --- ステップ 9: REFACTOR — コードの整理 ---
 
def fizzbuzz(n: int) -> str:
    """n に対する FizzBuzz の結果を返す。
 
    - 3 の倍数なら "Fizz"
    - 5 の倍数なら "Buzz"
    - 15 の倍数なら "FizzBuzz"
    - それ以外は数値の文字列表現
    """
    result = ""
    if n % 3 == 0:
        result += "Fizz"
    if n % 5 == 0:
        result += "Buzz"
    return result or str(n)
 
# テスト実行 → 4件とも PASSED（リファクタリング後もテストは通る）
 
 
# --- 最終的なテストスイート ---
 
import pytest
 
class TestFizzBuzz:
    """FizzBuzz のテストスイート。"""
 
    @pytest.mark.parametrize("input_val, expected", [
        (1, "1"),
        (2, "2"),
        (3, "Fizz"),
        (5, "Buzz"),
        (6, "Fizz"),
        (10, "Buzz"),
        (15, "FizzBuzz"),
        (30, "FizzBuzz"),
        (7, "7"),
    ])
    def test_fizzbuzz(self, input_val, expected):
        assert fizzbuzz(input_val) == expected

# ===== Gherkin によるシナリオ記述の例 =====
 
Feature: ショッピングカート
  オンラインショップの顧客として
  商品をカートに追加し、合計金額を確認したい
  購入前に数量の変更や商品の削除もできるようにしたい
 
  Background:
    Given 以下の商品がカタログに登録されている
      | 商品名      | 単価  |
      | Python入門  | 3000  |
      | Go実践      | 3500  |
      | Rust入門    | 4000  |
 
  Scenario: 商品をカートに追加する
    Given カートが空である
    When "Python入門" を 1 個カートに追加する
    Then カート内の商品数は 1 である
    And 合計金額は 3000 円である
 
  Scenario: 複数商品をカートに追加する
    Given カートが空である
    When "Python入門" を 2 個カートに追加する
    And "Go実践" を 1 個カートに追加する
    Then カート内の商品数は 3 である
    And 合計金額は 9500 円である
 
  Scenario: カートから商品を削除する
    Given カートに "Python入門" が 1 個入っている
    When "Python入門" をカートから削除する
    Then カートが空である
    And 合計金額は 0 円である
 
  Scenario Outline: 数量による合計金額の計算
    Given カートが空である
    When "<商品名>" を <数量> 個カートに追加する
    Then 合計金額は <期待金額> 円である
 
    Examples:
      | 商品名     | 数量 | 期待金額 |
      | Python入門 | 1    | 3000    |
      | Python入門 | 3    | 9000    |
      | Go実践     | 2    | 7000    |
      | Rust入門   | 1    | 4000    |

# ===== コード例 4: unittest.mock を用いたモックとスタブの実践 =====
 
from unittest.mock import Mock, patch, MagicMock
import pytest
from dataclasses import dataclass
from typing import Protocol
 
 
# --- プロダクションコード ---
 
@dataclass
class WeatherData:
    """天気データを表すデータクラス。"""
    city: str
    temperature: float
    humidity: float
    description: str
 
 
class WeatherApiClient:
    """外部天気 API との通信を担当する。"""
 
    def __init__(self, api_key: str):
        self.api_key = api_key
 
    def fetch_weather(self, city: str) -> dict:
        """外部 API から天気データを取得する（実際のHTTP通信）。"""
        # 実際には requests.get() などで API を呼ぶ
        raise NotImplementedError("本番コードでは HTTP 通信を行う")
 
 
class WeatherService:
    """天気情報のビジネスロジックを担当する。"""
 
    def __init__(self, api_client: WeatherApiClient):
        self.api_client = api_client
 
    def get_weather(self, city: str) -> WeatherData:
        """指定都市の天気を取得して WeatherData に変換する。"""
        raw = self.api_client.fetch_weather(city)
        return WeatherData(
            city=city,
            temperature=raw["main"]["temp"],
            humidity=raw["main"]["humidity"],
            description=raw["weather"][0]["description"],
        )
 
    def is_hot(self, city: str, threshold: float = 30.0) -> bool:
        """指定都市が暑いかどうかを判定する。"""
        weather = self.get_weather(city)
        return weather.temperature >= threshold
 
    def compare_temperature(self, city1: str, city2: str) -> str:
        """2 都市の気温を比較する。"""
        w1 = self.get_weather(city1)
        w2 = self.get_weather(city2)
        if w1.temperature > w2.temperature:
            return f"{city1} の方が暑い"
        elif w1.temperature < w2.temperature:
            return f"{city2} の方が暑い"
        else:
            return "同じ気温"
 
 
# --- テストコード（スタブの例）---
 
class TestWeatherService:
    """WeatherService のテスト。外部 API はスタブで置き換える。"""
 
    def _create_service_with_stub(self, stub_response: dict) -> WeatherService:
        """スタブ化された API クライアントでサービスを生成する。"""
        mock_client = Mock(spec=WeatherApiClient)
        mock_client.fetch_weather.return_value = stub_response
        return WeatherService(mock_client)
 
    def _sample_response(self, temp: float = 25.0, humidity: float = 60.0,
                         desc: str = "clear sky") -> dict:
        """テスト用のダミーレスポンスを生成する。"""
        return {
            "main": {"temp": temp, "humidity": humidity},
            "weather": [{"description": desc}],
        }
 
    def test_天気データを正しく変換できる(self):
        # Arrange: スタブが固定のレスポンスを返すように設定
        service = self._create_service_with_stub(
            self._sample_response(temp=25.0, humidity=60.0, desc="晴れ")
        )
 
        # Act
        weather = service.get_weather("東京")
 
        # Assert
        assert weather.city == "東京"
        assert weather.temperature == 25.0
        assert weather.humidity == 60.0
        assert weather.description == "晴れ"
 
    def test_閾値以上なら暑いと判定する(self):
        service = self._create_service_with_stub(
            self._sample_response(temp=35.0)
        )
        assert service.is_hot("東京", threshold=30.0) is True
 
    def test_閾値未満なら暑くないと判定する(self):
        service = self._create_service_with_stub(
            self._sample_response(temp=25.0)
        )
        assert service.is_hot("東京", threshold=30.0) is False
 
 
# --- テストコード（モックの例：呼び出しの検証）---
 
class TestWeatherServiceInteraction:
    """WeatherService の相互作用をモックで検証する。"""
 
    def test_get_weatherがAPIクライアントを正しく呼び出す(self):
        # Arrange
        mock_client = Mock(spec=WeatherApiClient)
        mock_client.fetch_weather.return_value = {
            "main": {"temp": 25.0, "humidity": 60.0},
            "weather": [{"description": "晴れ"}],
        }
        service = WeatherService(mock_client)
 
        # Act
        service.get_weather("大阪")
 
        # Assert: API クライアントが正しい引数で呼ばれたことを検証
        mock_client.fetch_weather.assert_called_once_with("大阪")
 
    def test_compare_temperatureが2回APIを呼び出す(self):
        # Arrange
        mock_client = Mock(spec=WeatherApiClient)
        mock_client.fetch_weather.side_effect = [
            {"main": {"temp": 30.0, "humidity": 50.0},
             "weather": [{"description": "晴れ"}]},
            {"main": {"temp": 25.0, "humidity": 70.0},
             "weather": [{"description": "曇り"}]},
        ]
        service = WeatherService(mock_client)
 
        # Act
        result = service.compare_temperature("東京", "札幌")
 
        # Assert
        assert result == "東京 の方が暑い"
        assert mock_client.fetch_weather.call_count == 2

# .github/workflows/test.yml
 
name: テスト自動実行
 
on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]
 
jobs:
  lint:
    name: Lint & 静的解析
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: "3.12"
      - run: pip install ruff mypy
      - run: ruff check .
      - run: mypy src/
 
  unit-test:
    name: ユニットテスト
    runs-on: ubuntu-latest
    needs: lint
    strategy:
      matrix:
        python-version: ["3.11", "3.12", "3.13"]
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: ${{ matrix.python-version }}
      - run: pip install -e ".[test]"
      - run: pytest tests/unit/ -v --cov=src/ --cov-report=xml
      - uses: codecov/codecov-action@v4
        with:
          file: ./coverage.xml
 
  integration-test:
    name: 統合テスト
    runs-on: ubuntu-latest
    needs: unit-test
    services:
      postgres:
        image: postgres:16
        env:
          POSTGRES_DB: testdb
          POSTGRES_USER: testuser
          POSTGRES_PASSWORD: testpass
        ports:
          - 5432:5432
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: "3.12"
      - run: pip install -e ".[test]"
      - run: pytest tests/integration/ -v
        env:
          DATABASE_URL: postgresql://testuser:testpass@localhost:5432/testdb
 
  e2e-test:
    name: E2E テスト
    runs-on: ubuntu-latest
    needs: integration-test
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: "3.12"
      - run: pip install -e ".[test]"
      - run: npx playwright install --with-deps chromium
      - run: pytest tests/e2e/ -v --headed=false

# カバレッジ 100% だがバグを検出できない例
 
def divide(a: int, b: int) -> float:
    return a / b  # b=0 の場合の処理がない
 
def test_divide():
    assert divide(10, 2) == 5.0
    # この 1 つのテストだけで行カバレッジ 100% だが、
    # b=0 の場合のテストがないためバグを見逃す

# カバレッジレポートの生成
pytest --cov=src/ --cov-report=term-missing --cov-report=html
 
# 出力例:
# Name                     Stmts   Miss  Cover   Missing
# -------------------------------------------------------
# src/money.py                25      2    92%   18, 22
# src/weather_service.py      40      5    88%   35-39
# -------------------------------------------------------
# TOTAL                       65      7    89%

# ===== コード例 5: Hypothesis によるプロパティベーステスト =====
 
from hypothesis import given, assume, settings, example
from hypothesis import strategies as st
import pytest
 
 
# --- テスト対象 ---
 
def sort_list(lst: list[int]) -> list[int]:
    """リストをソートして返す。"""
    return sorted(lst)
 
 
def reverse_string(s: str) -> str:
    """文字列を反転させる。"""
    return s[::-1]
 
 
def encode_decode(text: str) -> str:
    """UTF-8 でエンコードしてデコードする。"""
    return text.encode("utf-8").decode("utf-8")
 
 
def clamp(value: int, min_val: int, max_val: int) -> int:
    """value を min_val〜max_val の範囲に制限する。"""
    if min_val > max_val:
        raise ValueError("min_val は max_val 以下でなければならない")
    return max(min_val, min(value, max_val))
 
 
# --- プロパティベーステスト ---
 
class TestSortListProperties:
    """sort_list のプロパティベーステスト。"""
 
    @given(st.lists(st.integers()))
    def test_ソート結果の長さは入力と同じ(self, lst):
        """プロパティ: ソートは要素数を変えない。"""
        result = sort_list(lst)
        assert len(result) == len(lst)
 
    @given(st.lists(st.integers()))
    def test_ソート結果は昇順に並んでいる(self, lst):
        """プロパティ: ソート結果の各要素は前の要素以上。"""
        result = sort_list(lst)
        for i in range(1, len(result)):
            assert result[i] >= result[i - 1]
 
    @given(st.lists(st.integers()))
    def test_ソート結果は入力と同じ要素を含む(self, lst):
        """プロパティ: ソートは要素を変えない（並び替えるだけ）。"""
        result = sort_list(lst)
        assert sorted(result) == sorted(lst)
 
    @given(st.lists(st.integers()))
    def test_ソートの冪等性(self, lst):
        """プロパティ: 2回ソートしても結果は同じ。"""
        once = sort_list(lst)
        twice = sort_list(once)
        assert once == twice
 
 
class TestReverseStringProperties:
    """reverse_string のプロパティベーステスト。"""
 
    @given(st.text())
    def test_二重反転で元に戻る(self, s):
        """プロパティ: 反転の反転は恒等変換。"""
        assert reverse_string(reverse_string(s)) == s
 
    @given(st.text())
    def test_反転結果の長さは同じ(self, s):
        """プロパティ: 反転は長さを変えない。"""
        assert len(reverse_string(s)) == len(s)
 
 
class TestClampProperties:
    """clamp のプロパティベーステスト。"""
 
    @given(
        st.integers(min_value=-1000, max_value=1000),
        st.integers(min_value=-1000, max_value=0),
        st.integers(min_value=0, max_value=1000),
    )
    def test_結果は常に範囲内(self, value, min_val, max_val):
        """プロパティ: clamp の結果は必ず [min_val, max_val] の範囲内。"""
        assume(min_val <= max_val)
        result = clamp(value, min_val, max_val)
        assert min_val <= result <= max_val
 
    @given(
        st.integers(min_value=0, max_value=100),
        st.integers(min_value=0, max_value=100),
    )
    def test_範囲内の値はそのまま返る(self, value, bound):
        """プロパティ: 既に範囲内の値は変更されない。"""
        min_val = 0
        max_val = max(value, bound)
        min_val_actual = min(0, value)
        # value が [min_val, max_val] 内なら結果は value 自身
        result = clamp(value, min_val, max_val)
        if min_val <= value <= max_val:
            assert result == value
 
 
class TestEncodeDecodeProperties:
    """encode_decode のプロパティベーステスト。"""
 
    @given(st.text())
    def test_ラウンドトリップ(self, text):
        """プロパティ: エンコード→デコードで元に戻る。"""
        assert encode_decode(text) == text

# ===== アンチパターン: テスト間の順序依存 =====
 
# 危険: テスト A の結果がテスト B に影響する
 
class SharedState:
    """グローバルに共有される状態（アンチパターン）。"""
    items = []
 
 
class TestBad_テスト間の順序依存:
    """テストの順序に依存する悪い例。"""
 
    def test_A_アイテムを追加(self):
        SharedState.items.append("item1")
        assert len(SharedState.items) == 1
 
    def test_B_アイテム数を確認(self):
        # 危険: test_A が先に実行されることを前提としている
        assert len(SharedState.items) == 1  # test_A に依存
 
    def test_C_アイテムを削除(self):
        SharedState.items.clear()
        assert len(SharedState.items) == 0
        # test_B の後に実行されなければ失敗するかもしれない
 
 
# ===== 改善例: 各テストが独立 =====
 
class TestGood_テストの独立性:
    """各テストが独立している良い例。"""
 
    def setup_method(self):
        """各テストの前に状態を初期化する。"""
        self.items = []
 
    def test_A_アイテムを追加(self):
        self.items.append("item1")
        assert len(self.items) == 1
 
    def test_B_空のリストのサイズは0(self):
        assert len(self.items) == 0
 
    def test_C_追加して削除すると空になる(self):
        self.items.append("item1")
        self.items.clear()
        assert len(self.items) == 0

# ===== アンチパターン: 1つのテストに多すぎるアサーション =====
 
def test_bad_ユーザー登録から購入まで全部テスト():
    """1 つのテストケースに多すぎる検証を詰め込む悪い例。"""
    # ユーザー登録
    user = register_user("Alice", "alice@example.com")
    assert user.id is not None
    assert user.name == "Alice"
    assert user.email == "alice@example.com"
    assert user.is_active is True
 
    # ログイン
    token = login(user.email, "password123")
    assert token is not None
    assert len(token) > 0
 
    # 商品検索
    products = search_products("Python")
    assert len(products) > 0
    assert products[0].name == "Python入門"
 
    # カートに追加
    cart = add_to_cart(user.id, products[0].id, quantity=2)
    assert len(cart.items) == 1
    assert cart.total == 6000
 
    # 決済
    order = checkout(user.id, cart.id)
    assert order.status == "completed"
    assert order.total == 6000
 
 
# ===== 改善例: 適切な粒度に分割 =====
 
class TestUserRegistration:
    def test_正常な情報で登録できる(self):
        user = register_user("Alice", "alice@example.com")
        assert user.id is not None
        assert user.name == "Alice"
 
class TestAuthentication:
    def test_正しい認証情報でログインできる(self):
        # ...（ユーザーはフィクスチャで事前準備）
        pass
 
class TestShoppingCart:
    def test_商品をカートに追加できる(self):
        # ...（ユーザーとカートはフィクスチャで事前準備）
        pass
 
class TestCheckout:
    def test_カートの内容で決済できる(self):
        # ...
        pass

# 悪い例: 出力全体を文字列比較
def test_bad_レポート出力():
    result = generate_report(2024, 1)
    assert result == "2024年1月の売上レポート\n売上合計: ¥1,234,567\n前月比: +5.2%\n..."
    # 改行やスペースが1つ変わるだけで失敗する
 
# 良い例: 重要な情報だけを検証
def test_good_レポートに売上合計が含まれる():
    result = generate_report(2024, 1)
    assert "売上合計" in result
    assert "¥1,234,567" in result

# pytest のフィクスチャ活用例
 
import pytest
 
@pytest.fixture
def sample_user():
    """テスト用のユーザーオブジェクトを提供する。"""
    return User(name="テスト太郎", email="test@example.com")
 
@pytest.fixture
def authenticated_client(sample_user):
    """認証済みの API クライアントを提供する。"""
    client = TestClient(app)
    token = create_token(sample_user)
    client.headers["Authorization"] = f"Bearer {token}"
    return client
 
# フィクスチャの粒度:
#   - 小さすぎる: 各テストで同じセットアップコードが重複する
#   - 大きすぎる: 不要なセットアップが含まれ、テストが遅くなる
#   - 適切: テストが何をテストしているか明確で、必要最小限のセットアップ

# ミューテーションテストの実行
mutmut run --paths-to-mutate=src/
mutmut results

# pytest-snapshot を使ったスナップショットテスト
 
def test_レポート出力のスナップショット(snapshot):
    result = generate_report(year=2024, month=1)
    snapshot.assert_match(result, "report_2024_01.txt")
    # 初回実行時: スナップショットファイルが生成される
    # 2回目以降: 保存されたスナップショットと比較される
    # 変更時: pytest --snapshot-update で更新

# pytest マーカーによる層別実行の例
 
import pytest
 
# テストにマーカーを付与
@pytest.mark.unit
def test_高速なユニットテスト():
    assert 1 + 1 == 2
 
@pytest.mark.integration
def test_DB接続を伴うテスト():
    # DB に接続するテスト
    pass
 
@pytest.mark.slow
def test_時間のかかるテスト():
    # 実行に数十秒かかるテスト
    pass
 
@pytest.mark.e2e
def test_ブラウザ操作テスト():
    # Playwright でブラウザを操作するテスト
    pass
 
# pyproject.toml での設定:
# [tool.pytest.ini_options]
# markers = [
#     "unit: ユニットテスト",
#     "integration: 統合テスト",
#     "slow: 実行が遅いテスト",
#     "e2e: E2E テスト",
# ]
 
# 実行例:
# pytest -m unit           → ユニットテストだけ
# pytest -m "not slow"     → 遅いテスト以外
# pytest -m "unit or integration"  → ユニット + 統合

# テストデータのファクトリーパターン
 
from dataclasses import dataclass, field
import uuid
 
 
@dataclass
class UserFactory:
    """テスト用のユーザーデータを生成するファクトリー。"""
 
    name: str = "テスト太郎"
    email: str = field(default_factory=lambda: f"test-{uuid.uuid4().hex[:8]}@example.com")
    age: int = 30
    is_active: bool = True
 
    def build(self) -> dict:
        """辞書形式でユーザーデータを返す。"""
        return {
            "name": self.name,
            "email": self.email,
            "age": self.age,
            "is_active": self.is_active,
        }
 
    @classmethod
    def admin(cls) -> "UserFactory":
        """管理者ユーザーのプリセット。"""
        return cls(name="管理者", age=40)
 
    @classmethod
    def child(cls) -> "UserFactory":
        """子供ユーザーのプリセット。"""
        return cls(name="テスト子供", age=10)
 
 
# 使用例
def test_デフォルトユーザーで登録できる():
    user_data = UserFactory().build()
    result = register_user(**user_data)
    assert result.name == "テスト太郎"
 
def test_管理者で登録できる():
    user_data = UserFactory.admin().build()
    result = register_user(**user_data)
    assert result.name == "管理者"
 
def test_カスタムデータで登録できる():
    user_data = UserFactory(name="カスタム", age=25).build()
    result = register_user(**user_data)
    assert result.name == "カスタム"

# テストデータのビルダーパターン
 
class OrderBuilder:
    """テスト用の注文データをビルダーパターンで生成する。"""
 
    def __init__(self):
        self._customer_id = "C001"
        self._items = []
        self._discount = 0
        self._shipping_address = "東京都千代田区"
 
    def with_customer(self, customer_id: str) -> "OrderBuilder":
        self._customer_id = customer_id
        return self
 
    def with_item(self, name: str, price: int, quantity: int = 1) -> "OrderBuilder":
        self._items.append({"name": name, "price": price, "quantity": quantity})
        return self
 
    def with_discount(self, discount: int) -> "OrderBuilder":
        self._discount = discount
        return self
 
    def with_shipping_address(self, address: str) -> "OrderBuilder":
        self._shipping_address = address
        return self
 
    def build(self) -> dict:
        return {
            "customer_id": self._customer_id,
            "items": self._items,
            "discount": self._discount,
            "shipping_address": self._shipping_address,
        }
 
 
# 使用例
def test_複数商品の注文合計():
    order = (
        OrderBuilder()
        .with_item("Python入門", 3000, quantity=2)
        .with_item("Go実践", 3500)
        .with_discount(500)
        .build()
    )
    total = calculate_order_total(order)
    assert total == 9000  # (3000*2 + 3500) - 500

# ===== コード例 6: 依存性注入によるテスタビリティの向上 =====
 
# 悪い例: 直接依存を生成
class NotificationService_Bad:
    def notify(self, user_id: str, message: str) -> bool:
        # テスト時にもメールが送信されてしまう
        import smtplib
        server = smtplib.SMTP("smtp.example.com")
        server.sendmail("noreply@example.com", user_id, message)
        return True
 
 
# 良い例: 依存性注入
from typing import Protocol
 
class EmailSender(Protocol):
    def send(self, to: str, subject: str, body: str) -> bool: ...
 
class NotificationService_Good:
    def __init__(self, email_sender: EmailSender):
        self._email_sender = email_sender
 
    def notify(self, user_id: str, message: str) -> bool:
        return self._email_sender.send(
            to=user_id,
            subject="通知",
            body=message,
        )
 
 
# テストコード
class FakeEmailSender:
    """テスト用のフェイク実装。"""
    def __init__(self):
        self.sent_emails = []
 
    def send(self, to: str, subject: str, body: str) -> bool:
        self.sent_emails.append({"to": to, "subject": subject, "body": body})
        return True
 
 
def test_通知が送信される():
    fake_sender = FakeEmailSender()
    service = NotificationService_Good(fake_sender)
 
    result = service.notify("user@example.com", "テストメッセージ")
 
    assert result is True
    assert len(fake_sender.sent_emails) == 1
    assert fake_sender.sent_emails[0]["to"] == "user@example.com"

class StringCalculator:
    """文字列形式の数値を計算する。"""
 
    def add(self, numbers: str) -> int:
        """カンマ区切りの数値文字列を受け取り、合計を返す。
 
        ルール:
        - 空文字列の場合は 0 を返す
        - 数値が 1 つの場合はその数値を返す
        - カンマ区切りの複数数値の合計を返す
        - 改行もデリミタとして扱う（"1\n2,3" → 6）
        - 負の数が含まれる場合は ValueError を発生させる
          （エラーメッセージに負の数を含める）
        - 1000 より大きい数は無視する（"2,1001" → 2）
        """
        if not numbers:
            return 0
 
        delimiters = [",", "\n"]
        for d in delimiters:
            numbers = numbers.replace(d, ",")
 
        values = [int(x) for x in numbers.split(",")]
 
        negatives = [v for v in values if v < 0]
        if negatives:
            raise ValueError(f"負の数は許可されていない: {negatives}")
 
        return sum(v for v in values if v <= 1000)

import json
from typing import Any
 
 
def json_round_trip(data: dict) -> dict:
    """JSON シリアライズ → デシリアライズのラウンドトリップ。"""
    return json.loads(json.dumps(data))
 
 
def flatten_dict(d: dict, prefix: str = "") -> dict:
    """ネストされた辞書をフラットにする。
    例: {"a": {"b": 1}} → {"a.b": 1}
    """
    result = {}
    for key, value in d.items():
        new_key = f"{prefix}.{key}" if prefix else key
        if isinstance(value, dict):
            result.update(flatten_dict(value, new_key))
        else:
            result[new_key] = value
    return result
 
 
def compact(lst: list) -> list:
    """リストから None と空文字列を除去する。"""
    return [x for x in lst if x is not None and x != ""]