Pythonで「テストしやすいコード」にするための設計原則15選

def process_and_save_user(raw_data: dict, db):
    # 1. バリデーション
    if "name" not in raw_data or not raw_data["name"]:
        raise ValueError("name is required")
    if "age" not in raw_data or raw_data["age"] < 0:
        raise ValueError("age must be non-negative")

    # 2. ドメインロジック(年齢区分)
    if raw_data["age"] >= 20:
        category = "adult"
    else:
        category = "child"

    # 3. DB保存
    db.insert_user(name=raw_data["name"], age=raw_data["age"], category=category)

    # 4. ログ出力
    print(f"Saved user: {raw_data['name']} ({category})")

from dataclasses import dataclass


@dataclass
class User:
    name: str
    age: int
    category: str


def validate_user_data(raw_data: dict) -> None:
    """入力データのバリデーションのみを行う関数"""
    if "name" not in raw_data or not raw_data["name"]:
        raise ValueError("name is required")
    if "age" not in raw_data or raw_data["age"] < 0:
        raise ValueError("age must be non-negative")


def classify_user(age: int) -> str:
    """年齢からカテゴリーを判定する純粋関数"""
    return "adult" if age >= 20 else "child"


def build_user(raw_data: dict) -> User:
    """バリデーションと分類を組み合わせてUserを生成する"""
    validate_user_data(raw_data)
    category = classify_user(raw_data["age"])
    return User(
        name=raw_data["name"],
        age=raw_data["age"],
        category=category,
    )


def save_user(user: User, db) -> None:
    """DB保存のみを行う関数"""
    db.insert_user(name=user.name, age=user.age, category=user.category)


def process_and_save_user(raw_data: dict, db) -> User:
    """オーケストレーション担当(高レベルの流れだけ)"""
    user = build_user(raw_data)
    save_user(user, db)
    print(f"Saved user: {user.name} ({user.category})")
    return user

def calculate_discount(user_type: str, price: int) -> int:
    if user_type == "normal":
        return price
    elif user_type == "member":
        return int(price * 0.9)
    elif user_type == "vip":
        return int(price * 0.8)
    # 新しい区分が増えるたびにここにelifを足す必要がある

from abc import ABC, abstractmethod
from typing import Protocol


class DiscountStrategy(Protocol):
    def apply(self, price: int) -> int:
        ...


class NormalDiscount:
    def apply(self, price: int) -> int:
        return price


class MemberDiscount:
    def apply(self, price: int) -> int:
        return int(price * 0.9)


class VipDiscount:
    def apply(self, price: int) -> int:
        return int(price * 0.8)


def calculate_discount(price: int, strategy: DiscountStrategy) -> int:
    """戦略(依存)を注入することでOCPを満たす"""
    return strategy.apply(price)

import requests


def fetch_user_name(user_id: int) -> str:
    # HTTPクライアントを直接呼び出している
    resp = requests.get(f"https://api.example.com/users/{user_id}")
    resp.raise_for_status()
    return resp.json()["name"]

from typing import Protocol


class HttpClient(Protocol):
    def get(self, url: str) -> dict:
        ...


class RequestsHttpClient:
    """実運用時に使う実装"""
    def get(self, url: str) -> dict:
        import requests  # 遅延インポートで依存を局所化
        resp = requests.get(url)
        resp.raise_for_status()
        return resp.json()


def fetch_user_name(user_id: int, client: HttpClient) -> str:
    """抽象(Protocol)に依存させる"""
    data = client.get(f"https://api.example.com/users/{user_id}")
    return data["name"]

class FakeHttpClient:
    def __init__(self, responses: dict[int, dict]):
        self._responses = responses

    def get(self, url: str) -> dict:
        # 非常に単純なURLパース(サンプルのため)
        user_id = int(url.rstrip("/").split("/")[-1])
        return self._responses[user_id]


def test_fetch_user_name():
    client = FakeHttpClient({1: {"name": "Alice"}})
    assert fetch_user_name(1, client) == "Alice"

class UserRepository:
    def find_by_id(self, user_id: int):
        ...
    def find_all(self):
        ...
    def save(self, user):
        ...
    def delete(self, user_id: int):
        ...
    def count(self):
        ...
    # 他にも多数のメソッド...

from typing import Protocol, Iterable


class UserReader(Protocol):
    def find_by_id(self, user_id: int):
        ...
    def find_all(self) -> Iterable:
        ...


class UserWriter(Protocol):
    def save(self, user) -> None:
        ...
    def delete(self, user_id: int) -> None:
        ...


class SqlUserRepository(UserReader, UserWriter):
    """実装クラスは複数のProtocolを実装してもよい"""
    ...

def test_discount_normal():
    price = 1000
    result = calculate_discount("normal", price)
    assert result == 1000

def test_discount_member():
    price = 1000
    result = calculate_discount("member", price)
    assert result == 900

def test_discount_vip():
    price = 1000
    result = calculate_discount("vip", price)
    assert result == 800

import pytest

@pytest.mark.parametrize(
    "user_type, price, expected",
    [
        ("normal", 1000, 1000),
        ("member", 1000, 900),
        ("vip", 1000, 800),
    ],
)
def test_discount(user_type, price, expected):
    assert calculate_discount(user_type, price) == expected

def process(value: int) -> int:
    if value >= 0:
        if value % 2 == 0:
            # いろいろ処理...
            return value * 2
        else:
            # 別の処理...
            return value * 3
    else:
        # エラー処理...
        raise ValueError

def process(value: int) -> int:
    if value < 0:
        raise ValueError("value must be non-negative")

    if value % 2 == 0:
        return value * 2

    return value * 3

# 悪い例
cache = {}

def get_from_cache(key: str):
    return cache.get(key)

def set_to_cache(key: str, value: str):
    cache[key] = value

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

    def get(self, key: str) -> str | None:
        return self._data.get(key)

    def set(self, key: str, value: str) -> None:
        self._data[key] = value

class UserService:
    def __init__(self):
        self._repo = SqlUserRepository()  # ここで具象クラスを直接生成

    def get_user_name(self, user_id: int) -> str:
        user = self._repo.find_by_id(user_id)
        return user.name

from typing import Protocol


class UserRepository(Protocol):
    def find_by_id(self, user_id: int):
        ...


class UserService:
    def __init__(self, repo: UserRepository):
        self._repo = repo

    def get_user_name(self, user_id: int) -> str:
        user = self._repo.find_by_id(user_id)
        return user.name

class FakeUserRepository:
    def __init__(self, users):
        self._users = users

    def find_by_id(self, user_id: int):
        return self._users[user_id]


def test_get_user_name():
    repo = FakeUserRepository({1: type("User", (), {"name": "Alice"})})
    service = UserService(repo)
    assert service.get_user_name(1) == "Alice"

def send_report(email: str, content: str) -> None:
    smtp_host = "smtp.example.com"  # 直書き
    ...

@dataclass
class MailConfig:
    smtp_host: str
    smtp_port: int


def send_report(email: str, content: str, config: MailConfig) -> None:
    # configから値を取得する
    ...

def load_config(path: str) -> dict:
    try:
        with open(path) as f:
            return json.load(f)
    except Exception:
        return {}  # 何が起きたか分からない

class ConfigLoadError(Exception):
    pass


def load_config(path: str) -> dict:
    try:
        with open(path) as f:
            return json.load(f)
    except FileNotFoundError as e:
        raise ConfigLoadError(f"config file not found: {path}") from e
    except json.JSONDecodeError as e:
        raise ConfigLoadError(f"invalid json: {path}") from e

def test_load_config_missing_file(tmp_path):
    path = tmp_path / "missing.json"
    with pytest.raises(ConfigLoadError) as excinfo:
        load_config(str(path))
    assert "not found" in str(excinfo.value)

from typing import Sequence


def average(values: Sequence[float]) -> float:
    if not values:
        raise ValueError("values must not be empty")
    return sum(values) / len(values)

from typing import Protocol
from abc import ABC, abstractmethod


class PaymentGateway(Protocol):
    def charge(self, amount: int) -> str:
        ...


class StripePaymentGateway(ABC):
    @abstractmethod
    def charge(self, amount: int) -> str:
        ...

class FakePaymentGateway:
    def __init__(self):
        self.charged_amounts: list[int] = []

    def charge(self, amount: int) -> str:
        self.charged_amounts.append(amount)
        return "fake_tx_id"

from contextlib import contextmanager


@contextmanager
def transactional(session):
    try:
        yield
        session.commit()
    except Exception:
        session.rollback()
        raise

import asyncio
from typing import Protocol


class AsyncUserRepo(Protocol):
    async def find_by_id(self, user_id: int):
        ...


async def greet_user(user_id: int, repo: AsyncUserRepo) -> str:
    user = await repo.find_by_id(user_id)
    return f"Hello, {user.name}!"

class FakeAsyncUserRepo:
    async def find_by_id(self, user_id: int):
        await asyncio.sleep(0)  # 文脈切り替え用(任意)
        return type("User", (), {"name": "Bob"})


@pytest.mark.asyncio
async def test_greet_user():
    repo = FakeAsyncUserRepo()
    assert await greet_user(1, repo) == "Hello, Bob!"