Design by Contract — Find the Bug¶

class Ledger:
    def __init__(self):
        self.entries: list[tuple[str, int]] = []
        self.balance_cents = 0

    def post(self, memo: str, amount_cents: int) -> None:
        """
        Precondition: amount_cents is a whole number of cents (int), may be
        negative for debits. Caller must convert dollars to cents first.
        """
        self.entries.append((memo, amount_cents))
        self.balance_cents += amount_cents


# Caller in a different module, written by someone who forgot the unit:
ledger = Ledger()
ledger.post("coffee", 4.50)        # dollars, not cents
ledger.post("refund", -1.25)       # dollars, not cents
print(ledger.balance_cents)         # 3.25 ... a float, in a "cents" field

class RateLimiter:
    """Base contract:
       precondition for allow(): cost >= 0  (any non-negative cost accepted)
       postcondition: returns True if the request fits in the budget, else False
    """
    def __init__(self, budget: int):
        self.remaining = budget

    def allow(self, cost: int) -> bool:
        if cost <= self.remaining:
            self.remaining -= cost
            return True
        return False


class StrictRateLimiter(RateLimiter):
    def allow(self, cost: int) -> bool:
        if cost == 0:
            raise ValueError("zero-cost requests are not allowed")  # stronger precondition
        return super().allow(cost)


# Polymorphic consumer written against the BASE contract:
def admit_all(limiter: RateLimiter, requests: list[int]) -> int:
    admitted = 0
    for cost in requests:
        if limiter.allow(cost):   # base contract says cost >= 0 is always safe
            admitted += 1
    return admitted

# Works fine:        admit_all(RateLimiter(100), [10, 0, 20, 0])  -> 4
# Crashes in prod:   admit_all(StrictRateLimiter(100), [10, 0, 20, 0])

def create_account(payload: dict) -> "Account":
    """payload comes straight from an HTTP request body (untrusted)."""
    email = payload["email"]
    age = payload["age"]

    # "Validation":
    assert "@" in email, "invalid email"
    assert isinstance(age, int) and age >= 18, "must be 18+"

    return Account(email=email, age=age)

class ShoppingCart:
    def __init__(self, items: list[str]):
        self._items = items

    def snapshot(self) -> list[str]:
        """Return the current items for an audit log.

        Postcondition: the returned list reflects the cart at the moment
        of the call and is NOT affected by later mutations (it is an
        'old' value captured for the audit trail).
        """
        return self._items   # hand back the items

    def add(self, item: str) -> None:
        self._items.append(item)


cart = ShoppingCart(["apple"])
before = cart.snapshot()     # intended to freeze the "before" state
cart.add("banana")
after = cart.snapshot()

print("before:", before)     # expected ['apple']
print("after :", after)      # expected ['apple', 'banana']
assert before != after, "audit log must distinguish before vs after"

class InventoryService:
    def __init__(self, repo, emailer):
        self.repo = repo
        self.emailer = emailer

    def reserve(self, sku: str, qty: int) -> None:
        """
        Precondition: qty > 0 and the SKU has at least qty units in stock.
        Postcondition: stock is decremented by qty and a confirmation is sent;
                       on any precondition failure, NOTHING changes (no partial effect).
        """
        item = self.repo.get(sku)
        item.stock -= qty                       # decrement first
        self.emailer.send_reservation(sku, qty) # notify

        if qty <= 0 or item.stock < 0:          # ...validate afterward
            raise ValueError("invalid reservation")

        self.repo.save(item)