Test doubles & non-functional testing

test_doubles.pyimport unittest
from unittest.mock import MagicMock

# The five test doubles (Meszaros), each shown against the SAME collaborator: a
# Notifier that a PasswordReset service depends on.

# --- 1. DUMMY: passed to satisfy a signature, never actually used. ---
class DummyNotifier:
    def send(self, *a, **k): raise AssertionError("dummy must not be called")

# --- 2. STUB: returns canned answers to drive the code under test. ---
class StubClock:
    def now(self): return 1000            # fixed time, no real clock

# --- 3. FAKE: a real working implementation, but not production-grade. ---
class FakeEmailStore:                     # in-memory 'database'
    def __init__(self): self.sent = []
    def send(self, to, body): self.sent.append((to, body)); return True

# --- 4. SPY: records how it was called so the test can assert on it. ---
class SpyNotifier:
    def __init__(self): self.calls = []
    def send(self, to, body): self.calls.append((to, body))

# --- 5. MOCK: pre-programmed with expectations, verifies them (library-backed). ---
def reset_password(user, notifier, clock):
    token = f"tok-{clock.now()}"
    notifier.send(user, f"reset: {token}")
    return token

class TestDoubles(unittest.TestCase):
    def test_stub_and_fake(self):
        fake = FakeEmailStore()
        token = reset_password("ana@x.io", fake, StubClock())
        self.assertEqual(token, "tok-1000")          # stub drove the value
        self.assertEqual(fake.sent, [("ana@x.io", "reset: tok-1000")])  # fake stored it
    def test_spy_records_calls(self):
        spy = SpyNotifier()
        reset_password("bo@x.io", spy, StubClock())
        self.assertEqual(len(spy.calls), 1)          # spy verifies interaction
    def test_mock_verifies_expectation(self):
        mock = MagicMock()
        reset_password("cy@x.io", mock, StubClock())
        mock.send.assert_called_once_with("cy@x.io", "reset: tok-1000")

if __name__ == "__main__":
    unittest.main(verbosity=2)

flaky.pyimport random, unittest

# A flaky test: depends on randomness / hidden global state -> nondeterministic.
def pick_greeting_flaky():
    return random.choice(["hi", "hello", "hey"])      # nondeterministic output

# The FIX: inject the source of nondeterminism so the test controls it.
def pick_greeting(rng):
    return rng.choice(["hi", "hello", "hey"])

class TestFlaky(unittest.TestCase):
    def test_deterministic_with_injected_rng(self):
        rng = random.Random(42)               # seeded -> repeatable
        self.assertEqual(pick_greeting(rng), pick_greeting(random.Random(42)))
    def test_no_order_dependence(self):
        # Isolated: does not rely on any other test having run first.
        self.assertIn(pick_greeting(random.Random(1)), ["hi", "hello", "hey"])

if __name__ == "__main__":
    unittest.main(verbosity=2)

percentiles.py# Non-functional: latency is a DISTRIBUTION, not a mean. Report percentiles.
# p50 = median, p95/p99 = tail. The mean hides the tail that users feel.
def percentile(sorted_data, p):
    # nearest-rank method: smallest value >= p% of the data.
    k = max(0, (len(sorted_data) * p + 99) // 100 - 1)   # ceil(n*p/100)-1, clamped
    return sorted_data[k]

# 100 request latencies in ms: mostly fast, a few very slow (a realistic tail).
latencies = sorted([20] * 90 + [50] * 5 + [200] * 4 + [900] * 1)
mean = sum(latencies) / len(latencies)

print(f"count      : {len(latencies)}")
print(f"mean       : {mean:.1f} ms")
print(f"p50 (median): {percentile(latencies, 50)} ms")
print(f"p95        : {percentile(latencies, 95)} ms")
print(f"p99        : {percentile(latencies, 99)} ms")
print(f"max        : {latencies[-1]} ms")

# Throughput vs latency: throughput = requests / total time (concurrency matters).
total_seconds = 2.0
requests = 1000
print(f"throughput : {requests / total_seconds:.0f} req/s")

test_llm.py# Testing the "untestable": a nondeterministic (e.g. LLM) system where exact
# output can't be asserted. Test PROPERTIES and use SNAPSHOTS, not equality.
import re

def fake_llm_extract(text):
    # Stand-in for a model call: extract an order id. Output wording may vary.
    m = re.search(r"order #?(\d{4,})", text, re.I)
    return f"The order id is {m.group(1)}." if m else "No order id found."

# 1. PROPERTY/INVARIANT check: the extracted id must appear in the input.
def prop_id_grounded(text):
    out = fake_llm_extract(text)
    m = re.search(r"(\d{4,})", out)
    return (m is None) or (m.group(1) in text)   # never hallucinate an id

cases = ["please refund order #10432", "where is ORDER 88888?", "hi there"]
print("grounded on all cases:", all(prop_id_grounded(c) for c in cases))

# 2. SNAPSHOT check: pin the current output; a diff flags an intended change.
snapshot = "The order id is 10432."
print("matches snapshot     :", fake_llm_extract(cases[0]) == snapshot)

# 3. RUBRIC/allow-list check: output must be one of the accepted shapes.
def valid_shape(out):
    return out == "No order id found." or out.startswith("The order id is ")
print("all outputs valid    :", all(valid_shape(fake_llm_extract(c)) for c in cases))