Практика: приводим «грязный» модуль в порядок
Сейчас сделаем то, что реально прокачивает: возьмём «грязный» кусок кода и приведём в порядок, применяя все принципы из предыдущих уроков.
Исходник: грязный код
func handle(w http.ResponseWriter, r *http.Request) {
var d struct {
U int `json:"u"`
I int `json:"i"`
Q int `json:"q"`
}
json.NewDecoder(r.Body).Decode(&d)
if d.U != 0 {
if d.I != 0 {
if d.Q > 0 {
var u User
db.First(&u, d.U)
if u.ID != 0 {
if u.Active {
var item Item
db.First(&item, d.I)
if item.ID != 0 {
if item.Stock >= d.Q {
// do purchase
item.Stock -= d.Q
db.Save(&item)
order := Order{UserID: u.ID, ItemID: item.ID, Qty: d.Q,
Total: float64(d.Q) * item.Price}
db.Create(&order)
// send email
msg := fmt.Sprintf("Order #%d confirmed", order.ID)
smtp.SendMail("smtp.example.com:587", nil,
"noreply@shop.com", []string{u.Email}, []byte(msg))
w.WriteHeader(200)
json.NewEncoder(w).Encode(map[string]interface{}{
"ok": true, "order_id": order.ID,
})
} else {
http.Error(w, "out of stock", 400)
}
} else {
http.Error(w, "item not found", 404)
}
} else {
http.Error(w, "user inactive", 403)
}
} else {
http.Error(w, "user not found", 404)
}
} else {
http.Error(w, "bad qty", 400)
}
} else {
http.Error(w, "bad item", 400)
}
} else {
http.Error(w, "bad user", 400)
}
}
То же самое в PHP - типичный legacy-контроллер Symfony до рефакторинга:
<?php
final class PurchaseController
{
public function handle(Request $request): Response
{
$d = json_decode($request->getContent(), true);
if ($d['u'] != 0) {
if ($d['i'] != 0) {
if ($d['q'] > 0) {
$u = $this->em->find(User::class, $d['u']);
if ($u !== null) {
if ($u->active) {
$item = $this->em->find(Item::class, $d['i']);
if ($item !== null) {
if ($item->stock >= $d['q']) {
// do purchase
$item->stock -= $d['q'];
$order = new Order();
$order->user = $u;
$order->item = $item;
$order->qty = $d['q'];
$order->total = $d['q'] * $item->price;
$this->em->persist($order);
$this->em->flush();
// send email
mail($u->email, 'Order confirmed', "Order #{$order->id}");
return new JsonResponse(['ok' => true, 'order_id' => $order->id]);
} else {
return new Response('out of stock', 400);
}
} else {
return new Response('item not found', 404);
}
} else {
return new Response('user inactive', 403);
}
} else {
return new Response('user not found', 404);
}
} else {
return new Response('bad qty', 400);
}
} else {
return new Response('bad item', 400);
}
} else {
return new Response('bad user', 400);
}
}
}
# Фреймворк-независимый хендлер: принимает Request, возвращает Response.
# В FastAPI/Django это тело view-функции, db - сессия SQLAlchemy
def handle(r):
d = json.loads(r.body)
if d["u"] != 0:
if d["i"] != 0:
if d["q"] > 0:
u = db.get(User, d["u"])
if u is not None:
if u.active:
item = db.get(Item, d["i"])
if item is not None:
if item.stock >= d["q"]:
# do purchase
item.stock -= d["q"]
order = Order(user_id=u.id, item_id=item.id, qty=d["q"],
total=d["q"] * item.price)
db.add(order)
db.commit()
# send email
msg = f"Order #{order.id} confirmed"
smtplib.SMTP("smtp.example.com", 587).sendmail(
"noreply@shop.com", [u.email], msg)
return Response(200, json.dumps({"ok": True, "order_id": order.id}))
else:
return Response(400, "out of stock")
else:
return Response(404, "item not found")
else:
return Response(403, "user inactive")
else:
return Response(404, "user not found")
else:
return Response(400, "bad qty")
else:
return Response(400, "bad item")
else:
return Response(400, "bad user")
Что здесь плохо:
Проблема Принцип из урока
──────────────────────── ──────────────────────────────
Однобуквенные имена Урок 2: именование
7 уровней вложенности Урок 4: ранние return
Всё в одной функции Урок 3: маленькие функции
Ошибки без контекста Урок 5: обработка ошибок
SQL в хендлере Урок 7: структура проекта
Нет тестов Урок 8: рефакторинг с тестами
Шаг 1: Guard clauses + понятные ошибки
Убираем лесенку, ставим проверки в начало:
func handlePurchase(w http.ResponseWriter, r *http.Request) {
var req PurchaseRequest
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
http.Error(w, "invalid JSON", http.StatusBadRequest)
return
}
if req.UserID == 0 {
http.Error(w, "user_id is required", http.StatusBadRequest)
return
}
if req.ItemID == 0 {
http.Error(w, "item_id is required", http.StatusBadRequest)
return
}
if req.Quantity <= 0 {
http.Error(w, "quantity must be positive", http.StatusBadRequest)
return
}
// ... основная логика на уровне 0
}
<?php
declare(strict_types=1);
final class PurchaseController
{
public function handle(Request $request): Response
{
try {
$data = json_decode($request->getContent(), associative: true, flags: JSON_THROW_ON_ERROR);
} catch (JsonException) {
return new JsonResponse(['error' => 'invalid JSON'], Response::HTTP_BAD_REQUEST);
}
if (($data['user_id'] ?? 0) === 0) {
return new JsonResponse(['error' => 'user_id is required'], Response::HTTP_BAD_REQUEST);
}
if (($data['item_id'] ?? 0) === 0) {
return new JsonResponse(['error' => 'item_id is required'], Response::HTTP_BAD_REQUEST);
}
if (($data['quantity'] ?? 0) <= 0) {
return new JsonResponse(['error' => 'quantity must be positive'], Response::HTTP_BAD_REQUEST);
}
// ... основная логика на уровне 0
}
}
import json
from http import HTTPStatus
def handle_purchase(r: Request) -> Response:
try:
req = PurchaseRequest(**json.loads(r.body))
except (ValueError, TypeError):
return Response(HTTPStatus.BAD_REQUEST, "invalid JSON")
if req.user_id == 0:
return Response(HTTPStatus.BAD_REQUEST, "user_id is required")
if req.item_id == 0:
return Response(HTTPStatus.BAD_REQUEST, "item_id is required")
if req.quantity <= 0:
return Response(HTTPStatus.BAD_REQUEST, "quantity must be positive")
# ... основная логика на уровне 0
Уже лучше: имена понятные, ошибки конкретные, вложенность - ноль.
Шаг 2: Выделяем слои (domain, use case, adapter)
Идея слоёв напрямую следует из DIP: бизнес-логика владеет интерфейсами, а адаптеры на периферии их реализуют. На уровне HTTP-слоя - это тонкий handler как Facade над use case.
// domain/order.go - сущности и интерфейсы репозиториев.
// Никаких json-тегов: домен не знает про HTTP
type UserRepository interface {
GetByID(ctx context.Context, id int) (*User, error)
}
type ItemRepository interface {
GetByID(ctx context.Context, id int) (*Item, error)
DecreaseStock(ctx context.Context, id int, qty int) error
}
type OrderRepository interface {
Create(ctx context.Context, order *Order) error
}
<?php
declare(strict_types=1);
// src/Application/Purchase/PurchaseCommand.php - входные данные use case (immutable)
namespace App\Application\Purchase;
final readonly class PurchaseCommand
{
public function __construct(
public int $userId,
public int $itemId,
public int $quantity,
) {}
}
// src/Domain/User/UserRepositoryInterface.php
namespace App\Domain\User;
interface UserRepositoryInterface
{
public function findById(int $id): ?User;
}
// src/Domain/Item/ItemRepositoryInterface.php
namespace App\Domain\Item;
interface ItemRepositoryInterface
{
public function findById(int $id): ?Item;
public function decreaseStock(int $id, int $qty): void;
}
// src/Domain/Order/OrderRepositoryInterface.php
namespace App\Domain\Order;
interface OrderRepositoryInterface
{
public function save(Order $order): void;
}
# domain/order.py - сущности и интерфейсы репозиториев (про HTTP не знает)
from typing import Protocol
# Вместо (*User, error) репозиторий бросает NotFoundError
class UserRepository(Protocol):
def get_by_id(self, user_id: int) -> User: ...
class ItemRepository(Protocol):
def get_by_id(self, item_id: int) -> Item: ...
def decrease_stock(self, item_id: int, qty: int) -> None: ...
class OrderRepository(Protocol):
def create(self, order: Order) -> None: ...
// usecase/purchase.go - бизнес-сценарий
// PurchaseRequest - входные данные сценария. Без json-тегов:
// формат HTTP-запроса - забота адаптера
type PurchaseRequest struct {
UserID int
ItemID int
Quantity int
}
type PurchaseUC struct {
users domain.UserRepository
items domain.ItemRepository
orders domain.OrderRepository
notifier domain.Notifier
}
func (uc *PurchaseUC) Execute(ctx context.Context, req PurchaseRequest) (*Order, error) {
user, err := uc.users.GetByID(ctx, req.UserID)
if err != nil {
return nil, fmt.Errorf("get user %d: %w", req.UserID, err)
}
if !user.Active {
return nil, ErrUserInactive
}
item, err := uc.items.GetByID(ctx, req.ItemID)
if err != nil {
return nil, fmt.Errorf("get item %d: %w", req.ItemID, err)
}
if item.Stock < req.Quantity {
return nil, ErrOutOfStock
}
order := NewOrder(user, item, req.Quantity)
if err := uc.orders.Create(ctx, order); err != nil {
return nil, fmt.Errorf("create order: %w", err)
}
if err := uc.items.DecreaseStock(ctx, item.ID, req.Quantity); err != nil {
return nil, fmt.Errorf("decrease stock: %w", err)
}
uc.notifier.OrderCreated(ctx, order)
return order, nil
}
<?php
declare(strict_types=1);
// src/Application/Purchase/PurchaseHandler.php - use case
namespace App\Application\Purchase;
use App\Domain\Item\ItemNotFoundException;
use App\Domain\Item\ItemRepositoryInterface;
use App\Domain\Item\OutOfStockException;
use App\Domain\Notification\NotifierInterface;
use App\Domain\Order\Order;
use App\Domain\Order\OrderRepositoryInterface;
use App\Domain\User\UserInactiveException;
use App\Domain\User\UserNotFoundException;
use App\Domain\User\UserRepositoryInterface;
final readonly class PurchaseHandler
{
public function __construct(
private UserRepositoryInterface $users,
private ItemRepositoryInterface $items,
private OrderRepositoryInterface $orders,
private NotifierInterface $notifier,
) {}
public function __invoke(PurchaseCommand $command): Order
{
$user = $this->users->findById($command->userId)
?? throw new UserNotFoundException($command->userId);
if (!$user->active) {
throw new UserInactiveException($command->userId);
}
$item = $this->items->findById($command->itemId)
?? throw new ItemNotFoundException($command->itemId);
if ($item->stock < $command->quantity) {
throw new OutOfStockException($item->id);
}
$order = Order::create($user, $item, $command->quantity);
$this->orders->save($order);
$this->items->decreaseStock($item->id, $command->quantity);
$this->notifier->orderCreated($order);
return $order;
}
}
# usecase/purchase.py - бизнес-сценарий
from dataclasses import dataclass
from domain import (ItemRepository, Notifier, Order, OrderRepository,
UserRepository, new_order)
from domain.errors import OutOfStockError, UserInactiveError
# Входные данные сценария: живут в use case, а не в домене
@dataclass(frozen=True, slots=True)
class PurchaseRequest:
user_id: int
item_id: int
quantity: int
@dataclass(slots=True)
class PurchaseUC:
users: UserRepository
items: ItemRepository
orders: OrderRepository
notifier: Notifier
def execute(self, req: PurchaseRequest) -> Order:
# NotFoundError из репозитория не оборачиваем: контекст (какой id)
# уже в сообщении и traceback, а except NotFoundError в хендлере
# должен сработать по типу
user = self.users.get_by_id(req.user_id)
if not user.active:
raise UserInactiveError(req.user_id)
item = self.items.get_by_id(req.item_id)
if item.stock < req.quantity:
raise OutOfStockError(item.id)
order = new_order(user, item, req.quantity)
# Сбои записи тоже пробрасываем как есть: тип исключения - контракт,
# шаг виден в traceback. Обёртка RuntimeError("create order") from e
# стёрла бы тип: `from e` - не аналог errors.Is, ловят по типу нового
self.orders.create(order)
self.items.decrease_stock(item.id, req.quantity)
self.notifier.order_created(order)
return order
⚠️ Чего этот пример пока не делает
Создание заказа и списание остатка здесь - два независимых шага. Если списание упадёт, заказ уже сохранён. А между проверкой
Stock < Quantityи списанием параллельный запрос может забрать тот же товар. В боевом коде оба шага идут в одной транзакции, а списание делают атомарным:UPDATE items SET stock = stock - $1 WHERE id = $2 AND stock >= $1. Для этого в домен вводят интерфейс вродеTxManagerили Unit of Work - это тема следующих курсов. Здесь мы сознательно упростили пример, чтобы не отвлекаться от слоёв.
// adapter/http/purchase_handler.go - тонкий хендлер
// purchaseRequestJSON - формат тела запроса API, живёт только в HTTP-слое
type purchaseRequestJSON struct {
UserID int `json:"user_id"`
ItemID int `json:"item_id"`
Quantity int `json:"quantity"`
}
func (h *Handler) HandlePurchase(w http.ResponseWriter, r *http.Request) {
var body purchaseRequestJSON
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
respondError(w, "invalid JSON", http.StatusBadRequest)
return
}
req := usecase.PurchaseRequest{
UserID: body.UserID, ItemID: body.ItemID, Quantity: body.Quantity,
}
if err := validatePurchaseRequest(req); err != nil {
respondError(w, err.Error(), http.StatusBadRequest)
return
}
order, err := h.purchaseUC.Execute(r.Context(), req)
if err != nil {
switch {
case errors.Is(err, domain.ErrNotFound):
respondError(w, "not found", http.StatusNotFound)
case errors.Is(err, domain.ErrUserInactive):
respondError(w, "user is inactive", http.StatusForbidden)
case errors.Is(err, domain.ErrOutOfStock):
respondError(w, "out of stock", http.StatusConflict)
default:
log.Printf("purchase error: %v", err)
respondError(w, "internal error", http.StatusInternalServerError)
}
return
}
respondJSON(w, http.StatusOK, map[string]interface{}{
"ok": true, "order_id": order.ID,
})
}
<?php
declare(strict_types=1);
// src/Infrastructure/Http/PurchaseController.php - тонкий контроллер
namespace App\Infrastructure\Http;
use App\Application\Purchase\PurchaseCommand;
use App\Application\Purchase\PurchaseHandler;
use App\Domain\Item\ItemNotFoundException;
use App\Domain\Item\OutOfStockException;
use App\Domain\User\UserInactiveException;
use App\Domain\User\UserNotFoundException;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Attribute\AsController;
use Symfony\Component\Routing\Attribute\Route;
use JsonException;
#[AsController]
final readonly class PurchaseController
{
public function __construct(private PurchaseHandler $handler) {}
#[Route('/api/purchase', methods: ['POST'])]
public function __invoke(Request $request): JsonResponse
{
try {
$data = json_decode($request->getContent(), associative: true, flags: JSON_THROW_ON_ERROR);
$command = new PurchaseCommand(
userId: (int) ($data['user_id'] ?? 0),
itemId: (int) ($data['item_id'] ?? 0),
quantity: (int) ($data['quantity'] ?? 0),
);
$order = ($this->handler)($command);
return new JsonResponse(['ok' => true, 'order_id' => $order->id]);
} catch (JsonException) {
return new JsonResponse(['error' => 'invalid JSON'], Response::HTTP_BAD_REQUEST);
} catch (UserNotFoundException | ItemNotFoundException) {
return new JsonResponse(['error' => 'not found'], Response::HTTP_NOT_FOUND);
} catch (UserInactiveException) {
return new JsonResponse(['error' => 'user is inactive'], Response::HTTP_FORBIDDEN);
} catch (OutOfStockException) {
return new JsonResponse(['error' => 'out of stock'], Response::HTTP_CONFLICT);
}
}
}
В Symfony доменные исключения на HTTP-статусы маппят цепочкой catch в контроллере, как выше, или централизованно - слушателем события kernel.exception (ExceptionListener превращает любое доменное исключение в JSON-ответ).
# adapter/http/purchase_handler.py - тонкий хендлер
import json
import logging
from http import HTTPStatus
from domain.errors import NotFoundError, OutOfStockError, UserInactiveError
from usecase.purchase import PurchaseRequest, PurchaseUC
logger = logging.getLogger(__name__)
class Handler:
def __init__(self, purchase_uc: PurchaseUC) -> None:
self._purchase_uc = purchase_uc
def handle_purchase(self, r: Request) -> Response:
try:
req = PurchaseRequest(**json.loads(r.body))
except (ValueError, TypeError):
return respond_error("invalid JSON", HTTPStatus.BAD_REQUEST)
try:
validate_purchase_request(req)
except ValueError as e:
return respond_error(str(e), HTTPStatus.BAD_REQUEST)
try:
order = self._purchase_uc.execute(req)
except NotFoundError:
return respond_error("not found", HTTPStatus.NOT_FOUND)
except UserInactiveError:
return respond_error("user is inactive", HTTPStatus.FORBIDDEN)
except OutOfStockError:
return respond_error("out of stock", HTTPStatus.CONFLICT)
except Exception:
logger.exception("purchase error")
return respond_error("internal error", HTTPStatus.INTERNAL_SERVER_ERROR)
return respond_json(HTTPStatus.OK, {"ok": True, "order_id": order.id})
Заметь: заодно мы поменяли контракт API. «Out of stock» было 400, стало 409, а ответы были простым текстом, стали JSON. Это уже не рефакторинг, а изменение поведения: такие правки делают отдельным коммитом и заранее согласуют с клиентами API.
⚠️ Главная мысль
Мы не стали «умнее». Мы стали понятнее. И теперь каждый слой можно тестировать независимо: use case с моками, handler с httptest, репозиторий с тестовой БД.
Шаг 3: Тесты для use case
func TestPurchaseUC_Execute_Success(t *testing.T) {
users := &mockUserRepo{user: &User{ID: 1, Active: true, Email: "a@b.com"}}
items := &mockItemRepo{item: &Item{ID: 10, Stock: 5, Price: 100}}
orders := &mockOrderRepo{}
notifier := &mockNotifier{}
uc := &PurchaseUC{users: users, items: items, orders: orders, notifier: notifier}
order, err := uc.Execute(context.Background(), PurchaseRequest{
UserID: 1, ItemID: 10, Quantity: 2,
})
assert.NoError(t, err)
assert.Equal(t, 200.0, order.Total)
assert.True(t, notifier.called)
}
func TestPurchaseUC_Execute_InactiveUser(t *testing.T) {
users := &mockUserRepo{user: &User{ID: 1, Active: false}}
uc := &PurchaseUC{users: users}
_, err := uc.Execute(context.Background(), PurchaseRequest{UserID: 1})
assert.ErrorIs(t, err, ErrUserInactive)
}
<?php
declare(strict_types=1);
namespace App\Tests\Application\Purchase;
use App\Application\Purchase\PurchaseCommand;
use App\Application\Purchase\PurchaseHandler;
use App\Domain\User\UserInactiveException;
use PHPUnit\Framework\TestCase;
final class PurchaseHandlerTest extends TestCase
{
public function testSuccess(): void
{
$users = new InMemoryUserRepository([new User(id: 1, active: true, email: 'a@b.com')]);
$items = new InMemoryItemRepository([new Item(id: 10, stock: 5, price: 100.0)]);
$orders = new InMemoryOrderRepository();
$notifier = new SpyNotifier();
$handler = new PurchaseHandler($users, $items, $orders, $notifier);
$order = $handler(new PurchaseCommand(userId: 1, itemId: 10, quantity: 2));
self::assertSame(200.0, $order->total);
self::assertTrue($notifier->wasCalled());
}
public function testInactiveUserThrows(): void
{
$users = new InMemoryUserRepository([new User(id: 1, active: false)]);
$handler = new PurchaseHandler($users, /* ... */);
$this->expectException(UserInactiveException::class);
$handler(new PurchaseCommand(userId: 1, itemId: 10, quantity: 1));
}
}
In-memory реализации интерфейсов часто чище моков: они проще читаются и не ломаются на смене сигнатур. PHPUnit createMock(UserRepositoryInterface::class) - тоже вариант, но fakes/stubs обычно выигрывают по читаемости.
import pytest
def test_purchase_uc_execute_success() -> None:
users = FakeUserRepo(user=User(id=1, active=True, email="a@b.com"))
items = FakeItemRepo(item=Item(id=10, stock=5, price=100))
orders = FakeOrderRepo()
notifier = SpyNotifier()
uc = PurchaseUC(users=users, items=items, orders=orders, notifier=notifier)
order = uc.execute(PurchaseRequest(user_id=1, item_id=10, quantity=2))
assert order.total == 200.0
assert notifier.called
def test_purchase_uc_execute_inactive_user() -> None:
users = FakeUserRepo(user=User(id=1, active=False))
uc = PurchaseUC(users=users, items=FakeItemRepo(), orders=FakeOrderRepo(), notifier=SpyNotifier())
with pytest.raises(UserInactiveError):
uc.execute(PurchaseRequest(user_id=1, item_id=10, quantity=1))
Итого: что изменилось
До После
──────────────────────────── ────────────────────────────
1 функция, 50 строк 3 слоя, 5+ функций
7 уровней вложенности 0 уровней (guard clauses)
Однобуквенные имена Осмысленные имена
SQL в хендлере Репозиторий за интерфейсом
Ошибки: "bad user" Ошибки: sentinel + контекст
Тесты: невозможны Тесты: unit + integration
smtp.SendMail в хендлере Notifier за интерфейсом
Интеграция чистого кода в CI
Чтобы качество не деградировало, добавь автоматические проверки:
# golangci-lint - стиль и сложность
golangci-lint run ./...
# gofumpt - форматирование (строже gofmt)
gofumpt -d .
# go test с race detector
go test -race -coverprofile=coverage.out ./...
# проверка покрытия
go tool cover -func=coverage.out
# Минимальный .golangci.yml (формат golangci-lint v2)
version: "2"
linters:
enable:
- revive # стиль и именование
- cyclop # цикломатическая сложность
- gocritic # антипаттерны
- gosec # безопасность
# errcheck (необработанные ошибки) включён по умолчанию
settings:
cyclop:
max-complexity: 15
formatters:
enable:
- gofumpt # форматирование (строже gofmt)
# php-cs-fixer - стиль и форматирование
vendor/bin/php-cs-fixer fix --dry-run --diff
# PHPStan - типы и ошибки (уровень повышают постепенно)
vendor/bin/phpstan analyse --level=8 src
# phpmd - сложность и размер методов
vendor/bin/phpmd src text codesize
# тесты с покрытием
XDEBUG_MODE=coverage vendor/bin/phpunit --coverage-text
# ruff - стиль, именование, частые ошибки
ruff check .
# ruff format - форматирование
ruff format --check .
# mypy - проверка типов
mypy src/
# тесты с покрытием (плагин pytest-cov)
pytest --cov=src --cov-report=term
Мини-задание
- Возьми реальный модуль из своего проекта (самый «грязный»)
- Примени шаги 1-3 из этого урока: guard clauses → слои → тесты
- В MR добавь описание: какие принципы чистого кода применил
- Настрой линтер своего языка (
golangci-lint, PHPStan или ruff) в CI для автоматической проверки