15.1. Стратегия тестирования

mkdir -p /tmp/stratlab && cd /tmp/stratlab

# ─── Приложение ───────────────────────────────────────────────────────
cat > service.py <<'PY'
"""Тонкий сервис заказов: проверка, хранение, сериализация."""
from __future__ import annotations

import re
from dataclasses import dataclass, field
from decimal import Decimal, InvalidOperation
from typing import Protocol

SKU = re.compile(r"^[A-Z]{2}-\d{4}$")


class Storage(Protocol):
    def find_order(self, number: str) -> dict | None: ...
    def create_order(self, number: str, sku: str, amount: Decimal) -> int: ...
    def total_by_sku(self, sku: str) -> Decimal: ...


@dataclass
class Response:
    ok: bool
    data: dict = field(default_factory=dict)
    error: str | None = None


def is_valid_sku(sku: str) -> bool:
    """Чистая функция."""
    return bool(SKU.match(sku))


def parse_amount(text: str) -> Decimal | None:
    """Чистая функция: Decimal, а не float — это деньги."""
    try:
        amount = Decimal(text)
    except (InvalidOperation, TypeError):
        return None
    if amount <= 0 or amount.as_tuple().exponent < -2:
        return None
    return amount


def place_order(storage: Storage, number: str, sku: str,
                amount_text: str) -> Response:
    """Тонкий слой над хранилищем."""
    if not is_valid_sku(sku):
        return Response(False, error="неверный артикул")

    amount = parse_amount(amount_text)
    if amount is None:
        return Response(False, error="неверная сумма")

    if storage.find_order(number) is not None:
        return Response(False, error="заказ уже существует")

    ident = storage.create_order(number, sku, amount)
    return Response(True, data={"id": ident, "number": number,
                                "amount": str(amount)})
PY

cat > storage.py <<'PY'
"""Реализация на SQL — место, где живут ошибки, невидимые подделке."""
from __future__ import annotations

import sqlite3
from decimal import Decimal

SCHEMA = """
CREATE TABLE IF NOT EXISTS orders (
    id         INTEGER PRIMARY KEY AUTOINCREMENT,
    number     TEXT NOT NULL UNIQUE,
    sku        TEXT NOT NULL,
    amount     TEXT NOT NULL,
    created_at TEXT NOT NULL DEFAULT (datetime('now')),
    CHECK (length(sku) = 7)
);
CREATE INDEX IF NOT EXISTS idx_sku ON orders(sku);
"""


class SqlStorage:
    def __init__(self, conn: sqlite3.Connection) -> None:
        self.conn = conn
        self.conn.executescript(SCHEMA)

    def find_order(self, number: str) -> dict | None:
        row = self.conn.execute(
            "SELECT id, number, sku, amount FROM orders WHERE number = ?",
            (number,)).fetchone()
        if not row:
            return None
        return {"id": row[0], "number": row[1], "sku": row[2],
                "amount": Decimal(row[3])}

    def create_order(self, number: str, sku: str, amount: Decimal) -> int:
        cur = self.conn.execute(
            "INSERT INTO orders (number, sku, amount) VALUES (?, ?, ?)",
            (number, sku, str(amount)))
        self.conn.commit()
        return cur.lastrowid

    def total_by_sku(self, sku: str) -> Decimal:
        """Агрегация выполняется БАЗОЙ — подделка этого не проверит."""
        row = self.conn.execute(
            "SELECT COALESCE(SUM(CAST(amount AS REAL)), 0) FROM orders "
            "WHERE sku = ?", (sku,)).fetchone()
        return Decimal(str(row[0]))
PY

# ─── Unit-тесты ───────────────────────────────────────────────────────
cat > test_unit.py <<'PY'
"""Unit: подделка хранилища, миллисекунды, один способ отказать."""
from decimal import Decimal

import pytest

from service import is_valid_sku, parse_amount, place_order


class FakeStorage:
    def __init__(self, existing: set[str] | None = None) -> None:
        self.existing = existing or set()
        self.created: list[tuple] = []

    def find_order(self, number):
        return {"number": number} if number in self.existing else None

    def create_order(self, number, sku, amount):
        self.created.append((number, sku, amount))
        return len(self.created)

    def total_by_sku(self, sku):
        return Decimal("0")


@pytest.mark.parametrize("sku,ok", [
    ("AB-1234", True), ("ZZ-0000", True),
    ("ab-1234", False), ("AB-123", False), ("ABC-1234", False), ("", False),
])
def test_sku_validation(sku, ok):
    assert is_valid_sku(sku) is ok


@pytest.mark.parametrize("text,expected", [
    ("100", Decimal("100")), ("99.99", Decimal("99.99")),
    ("0", None), ("-5", None), ("1.999", None), ("abc", None), ("", None),
])
def test_amount_parsing(text, expected):
    assert parse_amount(text) == expected


def test_successful_order():
    storage = FakeStorage()
    result = place_order(storage, "N-1", "AB-1234", "150.50")
    assert result.ok and result.data["amount"] == "150.50"
    assert len(storage.created) == 1


def test_duplicate_order_rejected():
    result = place_order(FakeStorage({"N-1"}), "N-1", "AB-1234", "10")
    assert not result.ok and result.error == "заказ уже существует"


def test_invalid_sku_rejected():
    result = place_order(FakeStorage(), "N-2", "плохой", "10")
    assert not result.ok and result.error == "неверный артикул"


def test_invalid_amount_rejected():
    result = place_order(FakeStorage(), "N-3", "AB-1234", "-1")
    assert not result.ok and result.error == "неверная сумма"
PY

# ─── Тесты с базой ────────────────────────────────────────────────────
cat > test_db.py <<'PY'
"""Integration: настоящая БД. Каждый тест проверяет то,
что подделка воспроизвести не может."""
import sqlite3
from decimal import Decimal

import pytest

from service import place_order
from storage import SqlStorage


@pytest.fixture
def storage():
    conn = sqlite3.connect(":memory:")
    try:
        yield SqlStorage(conn)
    finally:
        conn.close()


def test_sql_is_valid(storage):
    """1. Подделка не выполняет SQL — опечатка в запросе ей не видна."""
    assert storage.find_order("нет") is None


def test_unique_constraint(storage):
    """2. UNIQUE существует только в схеме БД."""
    storage.create_order("N-1", "AB-1234", Decimal("10"))
    with pytest.raises(sqlite3.IntegrityError):
        storage.create_order("N-1", "CD-5678", Decimal("20"))


def test_check_constraint(storage):
    """3. CHECK проверяет БД, а не приложение."""
    with pytest.raises(sqlite3.IntegrityError):
        storage.create_order("N-2", "СЛИШКОМ-ДЛИННЫЙ", Decimal("10"))


def test_default_value(storage):
    """4. DEFAULT вычисляет БД."""
    ident = storage.create_order("N-3", "AB-1234", Decimal("10"))
    row = storage.conn.execute(
        "SELECT created_at FROM orders WHERE id = ?", (ident,)).fetchone()
    assert row[0] and len(row[0]) >= 19


def test_aggregation_in_db(storage):
    """5. SUM выполняет БД; подделка вернула бы что велено."""
    for i, amount in enumerate(["10.00", "20.50", "5.25"], start=1):
        storage.create_order(f"N-{i}0", "AB-1234", Decimal(amount))
    storage.create_order("N-99", "CD-5678", Decimal("1000"))
    assert storage.total_by_sku("AB-1234") == Decimal("35.75")


def test_full_path(storage):
    result = place_order(storage, "N-full", "AB-1234", "42.42")
    assert result.ok
    assert storage.find_order("N-full")["amount"] == Decimal("42.42")
PY

# ─── Измерение цены ───────────────────────────────────────────────────
cat > cost.py <<'PY'
"""Полная цена уровня: время плюс число способов отказать."""
from __future__ import annotations

import json
import sys

LEVELS = {
    "unit": {
        "failure_modes": ["код неверен"],
        "catches": ["ветвления", "чистые функции", "проверка входа"],
        "misses": ["SQL", "схема", "ограничения", "агрегация", "миграции"],
    },
    "integration_sqlite": {
        "failure_modes": ["код неверен", "схема несовместима"],
        "catches": ["синтаксис SQL", "UNIQUE", "CHECK", "DEFAULT", "агрегация"],
        "misses": ["диалект PostgreSQL", "конкурентность", "типы драйвера"],
    },
    "integration_postgres": {
        "failure_modes": ["код неверен", "образ не скачался", "порт занят",
                          "БД не готова", "нехватка памяти", "остаточное состояние"],
        "catches": ["диалект", "миграции", "транзакции", "типы драйвера"],
        "misses": ["ошибки в собранном образе приложения"],
    },
}


def main() -> None:
    times = json.loads(sys.argv[1]) if len(sys.argv) > 1 else {}
    header = f"  {'уровень':<24} {'время, с':>10} {'способов отказать':>19}"
    print(f"{header}  ловит сверх предыдущего")
    print("  " + "─" * 96)
    seen: set[str] = set()
    for name, info in LEVELS.items():
        new = [x for x in info["catches"] if x not in seen]
        seen.update(info["catches"])
        t = times.get(name)
        t_str = f"{t:.2f}" if isinstance(t, (int, float)) else "—"
        print(f"  {name:<24} {t_str:>10} {len(info['failure_modes']):>19}  "
              f"{', '.join(new[:4])}")

    print()
    print("  Способы отказать по уровням:")
    for name, info in LEVELS.items():
        print(f"    {name}: {len(info['failure_modes'])}")
        for mode in info["failure_modes"]:
            print(f"      · {mode}")
    print()
    print("  Рост числа способов отказать — это рост вероятности того,")
    print("  что красный результат окажется НЕ про код.")


if __name__ == "__main__":
    main()
PY

# ─── Определение типа сервиса по коду ─────────────────────────────────
cat > classify.py <<'PY'
"""Определяет тип сервиса по доле кода, не обращающегося к хранилищу.

Эвристика: функция считается чистой, если в её теле нет обращений
к параметру-хранилищу. Для кода, где хранилище передаётся иначе,
эвристика не сработает — это её известное ограничение.
"""
from __future__ import annotations

import ast
import json
import sys

STORAGE_PARAM = "storage"


def is_pure(func: ast.FunctionDef) -> bool:
    params = {a.arg for a in func.args.args}
    if STORAGE_PARAM not in params:
        return True
    for node in ast.walk(func):
        if isinstance(node, ast.Attribute):
            value = node.value
            if isinstance(value, ast.Name) and value.id == STORAGE_PARAM:
                return False
    return True


def classify(path: str) -> dict[str, object]:
    tree = ast.parse(open(path, encoding="utf-8").read())
    funcs = [n for n in tree.body if isinstance(n, ast.FunctionDef)]
    pure = [f for f in funcs if is_pure(f)]

    pure_lines = sum(len(f.body) for f in pure)
    total_lines = sum(len(f.body) for f in funcs) or 1
    share = pure_lines / total_lines * 100

    if share < 50:
        kind, unit, integration, e2e = "тонкий CRUD-сервис", 25, 65, 10
        why = ("большая часть кода — обращения к хранилищу; unit-тесты на этот "
               "код проверяли бы вызов подделки, то есть проверяли бы сам тест")
    else:
        kind, unit, integration, e2e = "сервис с логикой", 70, 25, 5
        why = ("значительный слой чистой логики проверяется изолированно — "
               "дёшево и без риска ложных срабатываний")

    return {
        "функций": len(funcs),
        "чистых": len(pure),
        "имена_чистых": [f.name for f in pure],
        "доля_чистого_кода": round(share),
        "тип": kind,
        "распределение": {"unit": unit, "integration": integration, "e2e": e2e},
        "обоснование": why,
    }


if __name__ == "__main__":
    print(json.dumps(classify(sys.argv[1]), ensure_ascii=False, indent=2))
PY

fail=0
ok()  { printf '  ✓ %s\n' "$1"; }
bad() { printf '  ✗ %s\n' "$1"; fail=1; }

printf '\n═══ Требования 1-3: прогон и измерение ═══\n'
timings="$(docker run --rm -v "$PWD:/w" -w /w python:3.13-slim sh -c '
    pip install --quiet --no-cache-dir pytest==9.1.1 > /dev/null 2>&1
    python - <<"RUNNER"
import json, re, subprocess, time

def run(path):
    start = time.monotonic()
    proc = subprocess.run(["python", "-m", "pytest", path, "-q"],
                          capture_output=True, text=True)
    elapsed = time.monotonic() - start
    passed = re.search(r"(\d+) passed", proc.stdout)
    return {
        "tests": int(passed.group(1)) if passed else 0,
        "code": proc.returncode,
        "seconds": round(elapsed, 3),
    }

print(json.dumps({"unit": run("test_unit.py"), "db": run("test_db.py")},
                 ensure_ascii=False))
RUNNER
' 2>/dev/null)"

echo "$timings" | python3 -c "
import json, sys
d = json.load(sys.stdin)
print(f\"    unit:        {d['unit']['tests']:>3} тестов за {d['unit']['seconds']:.3f} с (код {d['unit']['code']})\")
print(f\"    integration: {d['db']['tests']:>3} тестов за {d['db']['seconds']:.3f} с (код {d['db']['code']})\")
"
u_n="$(echo "$timings" | python3 -c "import json,sys; print(json.load(sys.stdin)['unit']['tests'])")"
d_n="$(echo "$timings" | python3 -c "import json,sys; print(json.load(sys.stdin)['db']['tests'])")"
u_rc="$(echo "$timings" | python3 -c "import json,sys; print(json.load(sys.stdin)['unit']['code'])")"
d_rc="$(echo "$timings" | python3 -c "import json,sys; print(json.load(sys.stdin)['db']['code'])")"
[ "$u_rc" = "0" ] && [ "$d_rc" = "0" ] && [ "$u_n" -ge 10 ] && [ "$d_n" -ge 4 ] \
    && ok "оба уровня прошли: $u_n unit и $d_n integration" \
    || bad "unit=$u_n (код $u_rc), db=$d_n (код $d_rc)"

printf '\n    Проверки, невозможные с подделкой:\n'
grep '^def test_' test_db.py | sed 's/^def /      /' | cut -d'(' -f1 | head -5
printf '\n'
python3 cost.py "$(echo "$timings" | python3 -c "
import json, sys
d = json.load(sys.stdin)
print(json.dumps({'unit': d['unit']['seconds'],
                  'integration_sqlite': d['db']['seconds']}))
")"

printf '\n═══ Требование 4: тип сервиса определён по коду ═══\n'
python3 classify.py service.py | python3 -c "
import json, sys
d = json.load(sys.stdin)
print(f\"    функций всего: {d['функций']}, из них чистых: {d['чистых']}\")
print(f\"    чистые: {', '.join(d['имена_чистых'])}\")
print(f\"    доля кода без обращений к хранилищу: {d['доля_чистого_кода']} %\")
print()
print(f\"    ТИП: {d['тип']}\")
r = d['распределение']
print(f\"    распределение: unit {r['unit']} %, integration {r['integration']} %, e2e {r['e2e']} %\")
print()
print(f\"    Обоснование: {d['обоснование']}\")
"
kind="$(python3 classify.py service.py | python3 -c "import json,sys; print(json.load(sys.stdin)['тип'])")"
[ -n "$kind" ] \
    && ok "тип определён по коду ($kind), а не назначен произвольно" \
    || bad "тип не определён"

printf '\n═══ Требование 5: правило выбора ═══\n'
python3 - <<'PY'
CASES = [
    ("Формат артикула", "мой", False, "прямой вызов, подделка не нужна"),
    ("Ветвление в place_order()", "мой", False, "подделка"),
    ("Агрегация SUM по артикулу", "чужой (СУБД)", False, "настоящая БД"),
    ("Ограничение UNIQUE", "чужой (СУБД)", False, "настоящая БД"),
    ("Платёжный шлюз вернул 402", "чужой", True, "подделка"),
    ("Одновременная вставка двух процессов", "чужой (СУБД)", True, "настоящая БД"),
]
print(f"    {'ситуация':<38} {'контракт':<16} {'редкая':<8} решение")
print("    " + "─" * 88)
for case, owner, rare, decision in CASES:
    print(f"    {case:<38} {owner:<16} {'да' if rare else 'нет':<8} {decision}")
print()
print("    Правило: мой контракт → подделка; чужой → настоящая зависимость;")
print("             редкая ситуация → подделка, КРОМЕ случаев, где подделка")
print("             не воспроизводит семантику (последняя строка).")
PY
ok "правило применено к шести ситуациям, включая исключение"

printf '\n═══ Требование 6: тесты приложения и образ ═══\n'
cat > uses_dep.py <<'PY'
"""Модуль, которому нужна внешняя зависимость."""
import click


def greeting(name: str) -> str:
    return click.style(f"Привет, {name}", fg="green")
PY
cat > test_dep.py <<'PY'
from uses_dep import greeting


def test_greeting():
    assert "Привет" in greeting("мир")
PY
cat > Dockerfile.broken <<'EOF'
# Образ БЕЗ установки зависимостей — типичная ошибка сборки
FROM python:3.13-slim
WORKDIR /app
COPY uses_dep.py service.py storage.py ./
CMD ["python", "-c", "import uses_dep; print(uses_dep.greeting('мир'))"]
EOF

printf '    тесты в окружении разработки (зависимость установлена):\n'
dev_rc=0
docker run --rm -v "$PWD:/w" -w /w python:3.13-slim sh -c '
    pip install --quiet --no-cache-dir pytest==9.1.1 click==8.3.0 > /dev/null 2>&1
    python -m pytest test_dep.py -q 2>&1 | tail -2
' 2>/dev/null | sed 's/^/      /' || dev_rc=1

printf '    запуск СОБРАННОГО образа:\n'
docker build -q -f Dockerfile.broken -t stratlab:broken . > /dev/null 2>&1
img_out="$(docker run --rm stratlab:broken 2>&1 | tail -2)"
echo "$img_out" | sed 's/^/      /'
img_rc=0
echo "$img_out" | grep -q 'ModuleNotFoundError' && img_rc=1

printf '\n    Тесты прошли, образ не работает.\n'
printf '    Это разные вопросы:\n'
printf '      «код правильный?»      → тесты против исходников\n'
printf '      «артефакт правильный?» → проверки против образа\n'
[ "$dev_rc" -eq 0 ] && [ "$img_rc" -eq 1 ] \
    && ok "прохождение тестов не гарантирует работоспособность образа" \
    || bad "тесты=$dev_rc образ=$img_rc"

printf '\n═══ ИТОГ ═══\n'
[ "$fail" -eq 0 ] && echo "  все требования выполнены" || echo "  ЕСТЬ ПРОВАЛЫ"

docker rmi -f stratlab:broken > /dev/null 2>&1
cd /tmp && rm -rf /tmp/stratlab
exit "$fail"

═══ Требования 1-3: прогон и измерение ═══
    unit:         17 тестов за 0.081 с (код 0)
    integration:   6 тестов за 0.104 с (код 0)
  ✓ оба уровня прошли: 17 unit и 6 integration

    Проверки, невозможные с подделкой:
      test_sql_is_valid
      test_unique_constraint
      test_check_constraint
      test_default_value
      test_aggregation_in_db

  уровень                    время, с   способов отказать  ловит сверх предыдущего
  ────────────────────────────────────────────────────────────────────────────────────────────────
  unit                           0.08                   1  ветвления, чистые функции, проверка входа
  integration_sqlite             0.10                   2  синтаксис SQL, UNIQUE, CHECK, DEFAULT
  integration_postgres              —                   6  диалект, миграции, транзакции, типы драйвера

  Способы отказать по уровням:
    unit: 1
      · код неверен
    integration_sqlite: 2
      · код неверен
      · схема несовместима
    integration_postgres: 6
      · код неверен
      · образ не скачался
      · порт занят
      · БД не готова
      · нехватка памяти
      · остаточное состояние

  Рост числа способов отказать — это рост вероятности того,
  что красный результат окажется НЕ про код.

═══ Требование 4: тип сервиса определён по коду ═══
    функций всего: 3, из них чистых: 2
    чистые: is_valid_sku, parse_amount
    доля кода без обращений к хранилищу: 41 %

    ТИП: тонкий CRUD-сервис
    распределение: unit 25 %, integration 65 %, e2e 10 %

    Обоснование: большая часть кода — обращения к хранилищу; unit-тесты на этот код проверяли бы вызов подделки, то есть проверяли бы сам тест
  ✓ тип определён по коду (тонкий CRUD-сервис), а не назначен произвольно

═══ Требование 5: правило выбора ═══
    ситуация                               контракт         редкая   решение
    ────────────────────────────────────────────────────────────────────────────────────────
    Формат артикула                        мой              нет      прямой вызов, подделка не нужна
    Ветвление в place_order()              мой              нет      подделка
    Агрегация SUM по артикулу              чужой (СУБД)     нет      настоящая БД
    Ограничение UNIQUE                     чужой (СУБД)     нет      настоящая БД
    Платёжный шлюз вернул 402              чужой            да       подделка
    Одновременная вставка двух процессов   чужой (СУБД)     да       настоящая БД

    Правило: мой контракт → подделка; чужой → настоящая зависимость;
             редкая ситуация → подделка, КРОМЕ случаев, где подделка
             не воспроизводит семантику (последняя строка).
  ✓ правило применено к шести ситуациям, включая исключение

═══ Требование 6: тесты приложения и образ ═══
    тесты в окружении разработки (зависимость установлена):
      .                                                                [100%]
      1 passed in 0.03s
    запуск СОБРАННОГО образа:
      ModuleNotFoundError: No module named 'click'

    Тесты прошли, образ не работает.
    Это разные вопросы:
      «код правильный?»      → тесты против исходников
      «артефакт правильный?» → проверки против образа
  ✓ прохождение тестов не гарантирует работоспособность образа

═══ ИТОГ ═══
  все требования выполнены