Designing for Testability — Practice Tasks¶

import secrets
import string
from typing import Protocol


class RandomSource(Protocol):
    def choice(self, seq):  # mirrors random.Random.choice / SystemRandom.choice
        ...


# secrets.SystemRandom is cryptographically secure and exposes .choice
def generate_password(
    length: int = 12,
    *,
    rng: RandomSource | None = None,
) -> str:
    rng = rng or secrets.SystemRandom()
    alphabet = string.ascii_letters + string.digits
    return "".join(rng.choice(alphabet) for _ in range(length))

import random
from passwords import generate_password


def test_generate_password_is_reproducible_with_seeded_rng():
    rng = random.Random(42)  # deterministic; for TEST ONLY
    first = generate_password(8, rng=rng)

    rng = random.Random(42)
    second = generate_password(8, rng=rng)

    assert first == second
    assert len(first) == 8


def test_generate_password_respects_length():
    assert len(generate_password(20, rng=random.Random(1))) == 20

from collections import defaultdict
from typing import Callable


class RateLimiter:
    def __init__(self, limit: int = 5, window: float = 60.0,
                 now: Callable[[], float] | None = None) -> None:
        self._limit = limit
        self._window = window
        self._now = now or __import__("time").time
        self._hits: dict[str, list[float]] = defaultdict(list)

    def allow(self, user_id: str) -> bool:
        now = self._now()
        hits = self._hits[user_id]
        hits[:] = [t for t in hits if now - t < self._window]
        if len(hits) >= self._limit:
            return False
        hits.append(now)
        return True

from ratelimit import RateLimiter


class FakeClock:
    def __init__(self, t: float = 0.0) -> None:
        self.t = t

    def __call__(self) -> float:  # usable as the `now` callable
        return self.t


def test_blocks_after_limit_then_recovers_after_window():
    clock = FakeClock(t=1000.0)
    rl = RateLimiter(limit=2, window=10.0, now=clock)

    assert rl.allow("u1") is True
    assert rl.allow("u1") is True
    assert rl.allow("u1") is False           # third hit blocked

    clock.t += 11.0                          # window elapses
    assert rl.allow("u1") is True            # counter has aged out


def test_users_are_independent():
    rl = RateLimiter(limit=1, window=10.0, now=FakeClock(0.0))
    assert rl.allow("a") is True
    assert rl.allow("b") is True             # b unaffected by a

import pytest
from shipping import ship_cost


# Each row was produced by running the CURRENT function and recording its output.
# These lock in today's behavior so refactoring cannot change it silently.
@pytest.mark.parametrize("weight,dist,express,intl,expected", [
    (0.5, 0,    False, False, 5.0),
    (1.0, 100,  False, False, 6.0),
    (3.0, 100,  False, False, 10.0),    # 5 + 2*2 + 1.0
    (10.0, 0,   False, False, 20.5),    # 13 + 5*1.5
    (3.0, 100,  True,  False, 15.0),    # 10.0 * 1.5
    (3.0, 100,  False, True,  30.0),    # 10.0 + 20
    (3.0, 100,  True,  True,  55.0),    # 10*1.5=15, +20 intl, +10 express-intl
])
def test_characterization(weight, dist, express, intl, expected):
    assert ship_cost(weight, dist, express, intl) == expected

from dataclasses import dataclass

EXPRESS_MULTIPLIER = 1.5
INTL_SURCHARGE = 20.0
INTL_EXPRESS_SURCHARGE = 10.0
DISTANCE_RATE = 0.01


@dataclass(frozen=True)
class ShipmentRequest:
    weight: float
    distance: float
    express: bool = False
    international: bool = False


def _weight_cost(weight: float) -> float:
    if weight <= 1:
        return 5.0
    if weight <= 5:
        return 5.0 + (weight - 1) * 2.0
    return 13.0 + (weight - 5) * 1.5


def ship_cost_v2(req: ShipmentRequest) -> float:
    cost = _weight_cost(req.weight) + req.distance * DISTANCE_RATE
    if req.express:
        cost *= EXPRESS_MULTIPLIER
    if req.international:
        cost += INTL_SURCHARGE
        if req.express:
            cost += INTL_EXPRESS_SURCHARGE
    return round(cost, 2)

OVERSIZE_THRESHOLD = 20.0
OVERSIZE_SURCHARGE = 35.0


def ship_cost_v3(req: ShipmentRequest) -> float:
    cost = ship_cost_v2(req)
    if req.weight > OVERSIZE_THRESHOLD:
        cost = round(cost + OVERSIZE_SURCHARGE, 2)
    return cost

def test_oversize_tier_adds_surcharge():
    light = ShipmentRequest(weight=10, distance=0)
    heavy = ShipmentRequest(weight=25, distance=0)
    assert ship_cost_v3(heavy) == ship_cost_v3(light) + 35.0

def test_oversize_does_not_disturb_existing_tiers():
    # All original golden values still hold through v3 for non-oversize inputs.
    assert ship_cost_v3(ShipmentRequest(3.0, 100, True, True)) == 55.0

from dataclasses import dataclass
from datetime import datetime
from typing import Callable, Protocol


# --- Ports (seams) ---
class Gateway(Protocol):
    def charge(self, order_id: str, amount: float) -> None: ...

class OrderStore(Protocol):
    def save(self, order_id: str, amount: float, at: datetime) -> None: ...

class IdempotencyStore(Protocol):
    def seen(self, key: str) -> bool: ...
    def mark(self, key: str) -> None: ...

class FxRates(Protocol):
    def usd_rate(self) -> float: ...


# --- Functional core: pure, instantly testable ---
DISCOUNT_THRESHOLD = 10_000
def apply_discount(total: float) -> float:
    return total * 0.95 if total > DISCOUNT_THRESHOLD else total


# --- Imperative shell: all collaborators injected ---
@dataclass
class CheckoutService:
    db: OrderStore
    gateway: Gateway
    fx: FxRates
    processed: IdempotencyStore
    now: Callable[[], datetime]
    new_order_id: Callable[[], str]

    def checkout(self, cart) -> str:
        if self.processed.seen(cart.id):
            return "duplicate"
        order_id = self.new_order_id()
        total = apply_discount(cart.subtotal * self.fx.usd_rate())
        self.gateway.charge(order_id, total)
        self.db.save(order_id, total, self.now())
        self.processed.mark(cart.id)
        return order_id

from datetime import datetime

class FakeFx:    usd_rate = staticmethod(lambda: 1.0)
class SpyGateway:
    def __init__(self): self.charges = []
    def charge(self, oid, amt): self.charges.append((oid, amt))
class MemStore:
    def __init__(self): self.rows = []
    def save(self, oid, amt, at): self.rows.append((oid, amt, at))
class MemIdem:
    def __init__(self): self._s = set()
    def seen(self, k): return k in self._s
    def mark(self, k): self._s.add(k)

def test_checkout_applies_discount_and_charges_once():
    gw = SpyGateway()
    svc = CheckoutService(
        db=MemStore(), gateway=gw, fx=FakeFx(), processed=MemIdem(),
        now=lambda: datetime(2026, 1, 1), new_order_id=lambda: "ORD-1",
    )
    cart = type("Cart", (), {"id": "C1", "subtotal": 20_000})()

    assert svc.checkout(cart) == "ORD-1"
    assert gw.charges == [("ORD-1", 19_000.0)]   # 20000 * 0.95
    assert svc.checkout(cart) == "duplicate"     # idempotency works