def test_order_total_calculation():
    # Arrange: テスト対象と前提条件を準備
    order = Order(id="order-1", user_id="user-1")
    order.add_item(OrderItem(product_id="p1", name="商品A", price=1000, quantity=2))
    order.add_item(OrderItem(product_id="p2", name="商品B", price=500, quantity=3))
 
    # Act: テスト対象のメソッドを実行
    total = order.total_amount
 
    # Assert: 期待結果を検証
    assert total == 3500  # 1000*2 + 500*3
 
def test_order_cancel_shipped_raises_error():
    # Arrange
    order = Order(id="order-1", user_id="user-1", status="shipped")
 
    # Act & Assert (例外の場合は一体化してよい)
    with pytest.raises(ValueError, match="出荷済みの注文は取消不可"):
        order.cancel()

# BAD: Arrange が長すぎる
def test_monthly_report_generation():
    user = User(id="u1", name="Alice", role="admin")
    department = Department(id="d1", name="Engineering")
    project1 = Project(id="p1", name="Alpha", budget=1000000)
    project2 = Project(id="p2", name="Beta", budget=2000000)
    team = Team(members=[user], department=department)
    time_entries = [
        TimeEntry(user=user, project=project1, hours=80),
        TimeEntry(user=user, project=project2, hours=40),
    ]
    report_config = ReportConfig(
        period="monthly", include_overtime=True, format="pdf"
    )
 
    report = generate_report(team, time_entries, report_config)
 
    assert report.total_hours == 120
    assert report.overtime_hours == 20
 
 
# GOOD: ファクトリ関数でテストの意図を明確にする
def test_monthly_report_generation():
    team = create_team_with_single_member()
    time_entries = create_time_entries(regular_hours=120, overtime_hours=20)
    config = create_monthly_report_config()
 
    report = generate_report(team, time_entries, config)
 
    assert report.total_hours == 120
    assert report.overtime_hours == 20

# 命名パターン1: [対象]_[状況]_[期待結果]
def test_order_when_empty_items_raises_validation_error():
    ...
 
def test_discount_when_total_exceeds_10000_applies_10_percent():
    ...
 
def test_user_registration_with_duplicate_email_returns_conflict():
    ...
 
# 命名パターン2: BDD スタイル (ネストクラス)
class TestOrder:
    class TestPlace:
        def test_changes_status_to_placed(self): ...
        def test_raises_error_when_items_empty(self): ...
        def test_emits_order_placed_event(self): ...
 
    class TestCancel:
        def test_changes_status_to_cancelled(self): ...
        def test_raises_error_when_already_shipped(self): ...
        def test_restores_inventory(self): ...
 
# 命名パターン3: should スタイル
def test_order_should_calculate_total_including_tax():
    ...
 
def test_user_should_be_locked_after_five_failed_attempts():
    ...

# BAD (Fast 違反): 本物の外部APIを呼ぶ
def test_payment_processing():
    result = stripe.Charge.create(amount=1000, currency="jpy")  # 実際のAPI呼び出し
    assert result.status == "succeeded"
 
# GOOD: テストダブルで即座に応答
def test_payment_processing():
    gateway = StubPaymentGateway(always_succeeds=True)
    processor = PaymentProcessor(gateway=gateway)
 
    result = processor.process(Payment(amount=1000, currency="jpy"))
 
    assert result.status == "succeeded"

# BAD (Independent 違反): テスト間で状態を共有
class TestUserService:
    user_id = None  # クラス変数で状態共有
 
    def test_create_user(self):
        TestUserService.user_id = service.create_user("Alice")
 
    def test_get_user(self):
        user = service.get_user(TestUserService.user_id)  # 前のテストに依存
        assert user.name == "Alice"
 
# GOOD: 各テストが独立
class TestUserService:
    def test_create_user(self):
        user_id = service.create_user("Alice")
        assert user_id is not None
 
    def test_get_user(self):
        user_id = service.create_user("Bob")  # 自分で準備
        user = service.get_user(user_id)
        assert user.name == "Bob"

# BAD (Repeatable 違反): 現在時刻に依存
def test_is_expired():
    token = Token(expires_at=datetime(2026, 3, 1))
    assert token.is_expired()  # 2026年3月以降にしか通らない
 
# GOOD: 時刻を注入可能にする（依存性注入）
def test_is_expired():
    token = Token(expires_at=datetime(2026, 3, 1))
    now = datetime(2026, 3, 2)  # テスト用の固定時刻
    assert token.is_expired(now=now)
 
# GOOD (代替): freezegun で時刻を固定
from freezegun import freeze_time
 
@freeze_time("2026-03-02")
def test_is_expired():
    token = Token(expires_at=datetime(2026, 3, 1))
    assert token.is_expired()

# BAD (Repeatable 違反): ランダム値に依存
import random
 
def test_shuffle_changes_order():
    items = [1, 2, 3, 4, 5]
    shuffled = shuffle(items)
    assert items != shuffled  # まれに同じ順序になる
 
# GOOD: シードを固定
def test_shuffle_changes_order():
    items = [1, 2, 3, 4, 5]
    shuffled = shuffle(items, seed=42)  # シード固定
    assert shuffled == [3, 1, 4, 5, 2]  # 決定的な結果

# BAD (Self-Validating 違反): 手動確認が必要
def test_report_generation():
    report = generate_report(data)
    print(report)  # 目視で確認 → Pass/Fail が自動判定できない
 
# GOOD: 自動判定可能なアサーション
def test_report_generation():
    report = generate_report(data)
    assert report.total_rows == 100
    assert report.summary == "月次レポート: 売上 ¥1,000,000"
    assert report.generated_at is not None

class StubProductRepository:
    """テスト用: 固定の商品データを返す。"""
    def find_by_id(self, product_id: str) -> Product:
        return Product(id=product_id, name="テスト商品", price=1000)
 
    def find_all(self) -> list[Product]:
        return [
            Product(id="p1", name="商品A", price=1000),
            Product(id="p2", name="商品B", price=2000),
        ]
 
def test_create_order_calculates_total():
    # Arrange
    product_repo = StubProductRepository()
    use_case = CreateOrderUseCase(product_repo=product_repo)
 
    # Act
    result = use_case.execute(CreateOrderInput(
        items=[{"product_id": "p1", "quantity": 3}]
    ))
 
    # Assert
    assert result.total_amount == 3000

from unittest.mock import Mock, call
 
def test_order_placement_sends_notification():
    # Arrange
    notifier = Mock()
    service = OrderService(notifier=notifier)
 
    # Act
    service.place_order(order_id="order-1")
 
    # Assert: 正しい引数で呼び出されたか検証
    notifier.send.assert_called_once_with(
        recipient="customer@example.com",
        subject="注文確定のお知らせ",
    )
 
def test_bulk_notification_sends_to_all_users():
    # Arrange
    notifier = Mock()
    service = NotificationService(notifier=notifier)
 
    # Act
    service.notify_all(user_ids=["u1", "u2", "u3"], message="セール開始")
 
    # Assert: 3回呼び出されたか
    assert notifier.send.call_count == 3
    notifier.send.assert_any_call(user_id="u1", message="セール開始")

class FakeOrderRepository:
    """テスト用: インメモリで動作するリポジトリ。"""
    def __init__(self):
        self._store: dict[str, Order] = {}
 
    def save(self, order: Order) -> None:
        self._store[order.id] = order
 
    def find_by_id(self, order_id: str) -> Order | None:
        return self._store.get(order_id)
 
    def find_by_user(self, user_id: str) -> list[Order]:
        return [o for o in self._store.values() if o.user_id == user_id]
 
    def count(self) -> int:
        return len(self._store)
 
def test_order_persistence_and_retrieval():
    # Arrange
    repo = FakeOrderRepository()
    order = Order(id="o1", user_id="u1", items=[
        OrderItem(product_id="p1", quantity=2, price=1000)
    ])
 
    # Act
    repo.save(order)
    found = repo.find_by_id("o1")
 
    # Assert
    assert found is not None
    assert found.id == "o1"
    assert found.user_id == "u1"

# BAD: Mock の過剰使用（実装詳細に結合）
def test_order_creation_uses_correct_sql():
    db = Mock()
    service = OrderService(db=db)
    service.create_order(user_id="u1", items=[...])
 
    # SQL 文の詳細をテスト → リファクタリングで壊れる
    db.execute.assert_called_with(
        "INSERT INTO orders (user_id, total) VALUES (%s, %s)",
        ("u1", 3000)
    )
 
# GOOD: 振る舞いをテスト（Fake を使用）
def test_order_creation_persists_order():
    repo = FakeOrderRepository()
    service = OrderService(repo=repo)
    service.create_order(user_id="u1", items=[...])
 
    # 結果の検証（実装詳細に依存しない）
    orders = repo.find_by_user("u1")
    assert len(orders) == 1
    assert orders[0].total == 3000

import pytest
 
@pytest.mark.parametrize("total, expected_discount", [
    (5000,  0),         # 5000円: 割引なし
    (9999,  0),         # 9999円: 割引なし（境界値-1）
    (10000, 0),         # 10000円: 割引なし（境界値）
    (10001, 1000),      # 10001円: 10%割引（境界値+1）
    (20000, 2000),      # 20000円: 10%割引
    (49999, 4999),      # 49999円: 10%割引（次の境界値-1）
    (50000, 7500),      # 50000円: 15%割引
    (100000, 20000),    # 100000円: 20%割引
])
def test_discount_calculation(total, expected_discount):
    calculator = DiscountCalculator()
    assert calculator.calculate(total) == expected_discount

# 複数パラメータの組み合わせ
@pytest.mark.parametrize("user_type, order_total, expected", [
    ("regular",  5000,  0),
    ("regular",  10001, 1000),
    ("premium",  5000,  250),    # プレミアムは5%
    ("premium",  10001, 1500),   # プレミアムは15%
    ("vip",      5000,  500),    # VIPは10%
    ("vip",      10001, 2000),   # VIPは20%
])
def test_discount_by_user_type(user_type, order_total, expected):
    calculator = DiscountCalculator()
    assert calculator.calculate(order_total, user_type) == expected

class TestPasswordValidation:
    """パスワードバリデーションの境界値テスト。"""
 
    @pytest.mark.parametrize("password, is_valid, description", [
        ("1234567", False, "7文字: 最小-1 → 無効"),
        ("12345678", True, "8文字: 最小境界 → 有効"),
        ("123456789", True, "9文字: 最小+1 → 有効"),
        ("A" * 19, True, "19文字: 最大-1 → 有効"),
        ("A" * 20, True, "20文字: 最大境界 → 有効"),
        ("A" * 21, False, "21文字: 最大+1 → 無効"),
    ])
    def test_length_boundary(self, password, is_valid, description):
        result = validate_password(password)
        assert result.is_valid == is_valid, description
 
    @pytest.mark.parametrize("password, is_valid, description", [
        ("", False, "空文字列"),
        ("a", False, "1文字"),
        ("A" * 1000, False, "極端に長い文字列"),
    ])
    def test_edge_cases(self, password, is_valid, description):
        result = validate_password(password)
        assert result.is_valid == is_valid, description

from hypothesis import given, strategies as st
 
# 性質1: ソートされたリストは元のリストと同じ要素を持つ
@given(st.lists(st.integers()))
def test_sort_preserves_elements(lst):
    sorted_lst = sorted(lst)
    assert sorted(sorted_lst) == sorted(lst)
    assert len(sorted_lst) == len(lst)
 
# 性質2: ソートされたリストは昇順
@given(st.lists(st.integers(), min_size=2))
def test_sort_is_ordered(lst):
    sorted_lst = sorted(lst)
    for i in range(len(sorted_lst) - 1):
        assert sorted_lst[i] <= sorted_lst[i + 1]
 
# 性質3: JSONエンコード→デコードで元のデータが復元される
@given(st.dictionaries(
    keys=st.text(min_size=1, max_size=50),
    values=st.one_of(st.integers(), st.text(), st.booleans(), st.none()),
))
def test_json_roundtrip(data):
    encoded = json.dumps(data)
    decoded = json.loads(encoded)
    assert decoded == data
 
# 性質4: 金額計算で丸め誤差が発生しない
@given(
    price=st.decimals(min_value=1, max_value=1000000, places=0),
    quantity=st.integers(min_value=1, max_value=100),
)
def test_total_is_positive(price, quantity):
    total = price * quantity
    assert total >= price  # 合計は単価以上
    assert total >= quantity  # 合計は数量以上

def test_user_serialization(snapshot):
    user = User(
        id="u1", name="Alice", email="alice@example.com",
        created_at=datetime(2024, 1, 1)
    )
    result = user.to_dict()
 
    # 初回: スナップショットを保存
    # 2回目以降: 保存されたスナップショットと比較
    snapshot.assert_match(json.dumps(result, indent=2), "user_serialization.json")

# テーブル駆動テスト
class TestEmailValidation:
    test_cases = [
        {"input": "user@example.com", "valid": True, "desc": "正常なメール"},
        {"input": "user@example", "valid": False, "desc": "TLDなし"},
        {"input": "@example.com", "valid": False, "desc": "ローカル部なし"},
        {"input": "user@", "valid": False, "desc": "ドメインなし"},
        {"input": "", "valid": False, "desc": "空文字列"},
        {"input": "a" * 255 + "@example.com", "valid": False, "desc": "長すぎる"},
        {"input": "user+tag@example.com", "valid": True, "desc": "プラスタグ"},
        {"input": "user.name@example.com", "valid": True, "desc": "ドット入り"},
    ]
 
    @pytest.mark.parametrize("case", test_cases, ids=lambda c: c["desc"])
    def test_email_validation(self, case):
        result = validate_email(case["input"])
        assert result.is_valid == case["valid"], f"Failed: {case['desc']}"

# カバレッジの限界を示す例
def calculate_discount(amount: int, is_premium: bool) -> int:
    if amount > 10000 and is_premium:
        return int(amount * 0.15)
    return 0
 
# このテストはLine Coverage 100% だがバグを見逃す
def test_discount():
    assert calculate_discount(20000, True) == 3000  # カバレッジ100%
    # だが (20000, False) → 0 のケースをテストしていない
    # もし条件が or に変更されてもテストは通ってしまう

# 元のコード
def is_adult(age: int) -> bool:
    return age >= 18
 
# ミュータント1: >= を > に変更
def is_adult_mutant1(age: int) -> bool:
    return age > 18  # age == 18 のテストがないと検出できない
 
# ミュータント2: 18 を 17 に変更
def is_adult_mutant2(age: int) -> bool:
    return age >= 17  # 境界値テストがないと検出できない
 
# ミュータント3: True/False を反転
def is_adult_mutant3(age: int) -> bool:
    return not (age >= 18)  # 基本テストがあれば検出可能

# BAD: タイミング依存
def test_async_job_completion():
    start_background_job("process-data")
    time.sleep(5)  # 5秒で終わるはず... Flaky!
    assert job_status("process-data") == "completed"
 
# GOOD: ポーリングで待機
def test_async_job_completion():
    start_background_job("process-data")
 
    # 最大30秒、1秒間隔でポーリング
    for _ in range(30):
        if job_status("process-data") == "completed":
            return  # テスト成功
        time.sleep(1)
 
    pytest.fail("ジョブが30秒以内に完了しなかった")
 
 
# BETTER: tenacity ライブラリで待機
from tenacity import retry, stop_after_delay, wait_fixed
 
@retry(stop=stop_after_delay(30), wait=wait_fixed(1))
def wait_for_job_completion(job_id: str):
    assert job_status(job_id) == "completed"
 
def test_async_job_completion():
    start_background_job("process-data")
    wait_for_job_completion("process-data")

import pytest
 
# セッションスコープ: テストスイート全体で1回だけ実行
@pytest.fixture(scope="session")
def database():
    """テスト用データベースの作成と破棄。"""
    db = create_test_database()
    create_schema(db)
    yield db
    drop_database(db)
 
# 関数スコープ: 各テスト関数ごとに実行
@pytest.fixture
def clean_db(database):
    """各テスト前にトランザクション開始、後にロールバック。"""
    database.begin()
    yield database
    database.rollback()
 
# カスタムファクトリフィクスチャ
@pytest.fixture
def create_user(clean_db):
    """テスト用ユーザーのファクトリ。"""
    def _create_user(name="Alice", email="alice@test.com", role="user"):
        user = User(name=name, email=email, role=role)
        clean_db.save(user)
        return user
    return _create_user
 
# フィクスチャの使用
def test_user_can_place_order(create_user, clean_db):
    user = create_user(name="Bob")
    order = Order(user_id=user.id, items=[...])
    clean_db.save(order)
 
    assert order.user_id == user.id

# conftest.py でマーカーを登録
def pytest_configure(config):
    config.addinivalue_line("markers", "slow: 実行が遅いテスト")
    config.addinivalue_line("markers", "integration: 統合テスト")
    config.addinivalue_line("markers", "e2e: E2Eテスト")
 
# テストにマーカーを付与
@pytest.mark.slow
def test_full_data_migration():
    ...
 
@pytest.mark.integration
def test_database_connection():
    ...
 
# 特定のマーカーのテストのみ実行
# $ pytest -m "not slow"           # 遅いテスト以外を実行
# $ pytest -m "integration"        # 統合テストのみ実行
# $ pytest -m "not e2e"            # E2E 以外を実行

# .github/workflows/test.yml
name: Test Pipeline
 
on:
  pull_request:
    branches: [main]
 
jobs:
  unit-tests:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: '3.12'
      - run: pip install -r requirements-dev.txt
      - run: |
          pytest tests/unit/ \
            --cov=src \
            --cov-report=xml \
            --cov-fail-under=80 \
            -x \
            --timeout=10
 
  integration-tests:
    runs-on: ubuntu-latest
    services:
      postgres:
        image: postgres:16
        env:
          POSTGRES_DB: test
          POSTGRES_PASSWORD: test
        ports:
          - 5432:5432
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: '3.12'
      - run: pip install -r requirements-dev.txt
      - run: pytest tests/integration/ -v --timeout=60

# BAD: 内部実装（メソッド呼び出し順序）をテスト
def test_order_creation_calls_methods_in_order():
    mock = Mock()
    service = OrderService(repo=mock)
    service.create_order(...)
    assert mock.method_calls == [
        call.validate(),        # 内部の呼び出し順序に結合
        call.calculate_tax(),
        call.save(),
    ]
    # リファクタリングで内部実装を変えただけでテストが壊れる
 
# GOOD: 振る舞い（入力 → 出力）をテスト
def test_order_creation_returns_valid_order():
    repo = FakeOrderRepository()
    service = OrderService(repo=repo)
    result = service.create_order(user_id="u1", items=[...])
    assert result.status == "created"
    assert result.total > 0

# BAD: 各テストで DB を初期化
def test_user_query(self):
    db.create_all()          # 毎回スキーマ作成 (遅い)
    seed_test_data(1000)     # 毎回1000件投入 (遅い)
    result = query_users()
    assert len(result) > 0
    db.drop_all()
 
# GOOD: フィクスチャで共有、トランザクションロールバック
@pytest.fixture(scope="session")
def db():
    create_schema()
    yield database
    drop_schema()
 
@pytest.fixture(autouse=True)
def transaction(db):
    db.begin()
    yield
    db.rollback()    # 各テスト後にロールバック (高速)

# BAD: 1つのテストで複数の概念を検証
def test_user_creation():
    user = service.create_user("Alice", "alice@example.com")
    assert user.id is not None                    # 概念1: ID生成
    assert user.name == "Alice"                   # 概念2: 名前保存
    assert user.email == "alice@example.com"      # 概念3: メール保存
    assert user.created_at is not None            # 概念4: タイムスタンプ
    assert user.status == "active"                # 概念5: 初期ステータス
    assert email_was_sent("alice@example.com")    # 概念6: メール送信
    assert audit_log_exists("user_created")       # 概念7: 監査ログ
 
# GOOD: 概念ごとにテストを分割
def test_create_user_generates_unique_id():
    user = service.create_user("Alice", "alice@example.com")
    assert user.id is not None
 
def test_create_user_saves_name_and_email():
    user = service.create_user("Alice", "alice@example.com")
    assert user.name == "Alice"
    assert user.email == "alice@example.com"
 
def test_create_user_sets_initial_status_to_active():
    user = service.create_user("Alice", "alice@example.com")
    assert user.status == "active"
 
def test_create_user_sends_welcome_email():
    service.create_user("Alice", "alice@example.com")
    assert email_was_sent("alice@example.com")

# BAD: テスト内に条件分岐がある
def test_discount(user_type):
    calculator = DiscountCalculator()
    if user_type == "premium":
        assert calculator.calculate(10000, user_type) == 1500
    elif user_type == "regular":
        assert calculator.calculate(10000, user_type) == 1000
    else:
        assert calculator.calculate(10000, user_type) == 0
 
# GOOD: パラメタライズテストで条件分岐を排除
@pytest.mark.parametrize("user_type, expected", [
    ("premium", 1500),
    ("regular", 1000),
    ("guest", 0),
])
def test_discount(user_type, expected):
    calculator = DiscountCalculator()
    assert calculator.calculate(10000, user_type) == expected

class PasswordValidator:
    MIN_LENGTH = 8
    MAX_LENGTH = 64
 
    def validate(self, password: str) -> ValidationResult:
        errors = []
        if len(password) < self.MIN_LENGTH:
            errors.append("最低8文字必要です")
        if len(password) > self.MAX_LENGTH:
            errors.append("最大64文字までです")
        if not any(c.isupper() for c in password):
            errors.append("大文字を1文字以上含めてください")
        if not any(c.isdigit() for c in password):
            errors.append("数字を1文字以上含めてください")
        return ValidationResult(is_valid=len(errors) == 0, errors=errors)

class TestPasswordValidator:
    def setup_method(self):
        self.validator = PasswordValidator()
 
    def test_valid_password_returns_success(self):
        result = self.validator.validate("SecurePass1")
        assert result.is_valid is True
        assert result.errors == []
 
    def test_short_password_returns_error(self):
        result = self.validator.validate("Short1A")
        assert result.is_valid is False
        assert "最低8文字必要です" in result.errors
 
    def test_too_long_password_returns_error(self):
        result = self.validator.validate("A1" + "a" * 63)
        assert result.is_valid is False
        assert "最大64文字までです" in result.errors
 
    def test_no_uppercase_returns_error(self):
        result = self.validator.validate("lowercase123")
        assert result.is_valid is False
        assert "大文字を1文字以上含めてください" in result.errors
 
    def test_no_digit_returns_error(self):
        result = self.validator.validate("NoDigitsHere")
        assert result.is_valid is False
        assert "数字を1文字以上含めてください" in result.errors
 
    def test_multiple_violations_returns_all_errors(self):
        result = self.validator.validate("short")
        assert result.is_valid is False
        assert len(result.errors) >= 2

class OrderService:
    def __init__(self, product_repo, payment_gateway, notifier):
        self._product_repo = product_repo
        self._payment = payment_gateway
        self._notifier = notifier
 
    def place_order(self, user_id, items):
        products = [self._product_repo.find_by_id(i["id"]) for i in items]
        total = sum(p.price * i["qty"] for p, i in zip(products, items))
 
        payment_result = self._payment.charge(user_id, total)
        if not payment_result.success:
            raise PaymentError(payment_result.error_message)
 
        order = Order(user_id=user_id, items=items, total=total)
        self._notifier.send_confirmation(user_id, order)
        return order

def test_place_order_calculates_correct_total():
    # Stub: 商品リポジトリから固定の商品を返す
    product_repo = StubProductRepo({
        "p1": Product(id="p1", price=1000),
        "p2": Product(id="p2", price=2000),
    })
    payment = StubPaymentGateway(always_succeeds=True)
    notifier = Mock()
 
    service = OrderService(product_repo, payment, notifier)
    order = service.place_order("u1", [
        {"id": "p1", "qty": 2},
        {"id": "p2", "qty": 1},
    ])
 
    assert order.total == 4000  # 1000*2 + 2000*1
 
def test_place_order_sends_confirmation():
    product_repo = StubProductRepo({"p1": Product(id="p1", price=1000)})
    payment = StubPaymentGateway(always_succeeds=True)
    notifier = Mock()  # Mock: 通知が呼ばれたか検証
 
    service = OrderService(product_repo, payment, notifier)
    service.place_order("u1", [{"id": "p1", "qty": 1}])
 
    # 通知が正しく呼ばれたか検証
    notifier.send_confirmation.assert_called_once()
 
def test_place_order_raises_on_payment_failure():
    product_repo = StubProductRepo({"p1": Product(id="p1", price=1000)})
    payment = StubPaymentGateway(always_fails=True, error="カード拒否")
    notifier = Mock()
 
    service = OrderService(product_repo, payment, notifier)
 
    with pytest.raises(PaymentError, match="カード拒否"):
        service.place_order("u1", [{"id": "p1", "qty": 1}])
 
    # 決済失敗時は通知が送られないこと
    notifier.send_confirmation.assert_not_called()

class Money:
    def __init__(self, amount: int, currency: str = "JPY"):
        if amount < 0:
            raise ValueError("金額は0以上")
        self.amount = amount
        self.currency = currency
 
    def add(self, other: "Money") -> "Money":
        if self.currency != other.currency:
            raise CurrencyMismatchError()
        return Money(self.amount + other.amount, self.currency)
 
    def multiply(self, factor: int) -> "Money":
        return Money(self.amount * factor, self.currency)

from hypothesis import given, strategies as st
 
jpy_amount = st.integers(min_value=0, max_value=10**9)
 
# 性質1: 加算の可換性 (a + b == b + a)
@given(a=jpy_amount, b=jpy_amount)
def test_addition_is_commutative(a, b):
    m1 = Money(a).add(Money(b))
    m2 = Money(b).add(Money(a))
    assert m1.amount == m2.amount
 
# 性質2: 加算の結合性 ((a + b) + c == a + (b + c))
@given(a=jpy_amount, b=jpy_amount, c=jpy_amount)
def test_addition_is_associative(a, b, c):
    left = Money(a).add(Money(b)).add(Money(c))
    right = Money(a).add(Money(b).add(Money(c)))
    assert left.amount == right.amount
 
# 性質3: ゼロの加算は恒等 (a + 0 == a)
@given(a=jpy_amount)
def test_adding_zero_is_identity(a):
    result = Money(a).add(Money(0))
    assert result.amount == a
 
# 性質4: 乗算の分配法則 ((a + b) * n == a*n + b*n)
@given(a=jpy_amount, b=jpy_amount, n=st.integers(min_value=0, max_value=100))
def test_multiplication_distributes_over_addition(a, b, n):
    left = Money(a).add(Money(b)).multiply(n)
    right = Money(a).multiply(n).add(Money(b).multiply(n))
    assert left.amount == right.amount

# デバッグ用ユーティリティ
import logging
import traceback
from functools import wraps
 
# ロガーの設定
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s [%(levelname)s] %(name)s: %(message)s'
)
logger = logging.getLogger(__name__)
 
def debug_decorator(func):
    """関数の入出力をログ出力するデコレータ"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        logger.debug(f"呼び出し: {func.__name__}(args={args}, kwargs={kwargs})")
        try:
            result = func(*args, **kwargs)
            logger.debug(f"戻り値: {func.__name__} -> {result}")
            return result
        except Exception as e:
            logger.error(f"例外発生: {func.__name__}: {e}")
            logger.error(traceback.format_exc())
            raise
    return wrapper
 
@debug_decorator
def process_data(items):
    """データ処理（デバッグ対象）"""
    if not items:
        raise ValueError("空のデータ")
    return [item * 2 for item in items]