Практика: приводим «грязный» модуль в порядок

Сейчас сделаем то, что реально прокачивает: возьмём «грязный» кусок кода и приведём в порядок, применяя все принципы из предыдущих уроков.

Исходник: грязный код

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 для автоматической проверки

Зарегистрируйтесь бесплатно, чтобы пройти квиз, решить задание с автопроверкой, вести прогресс.