Тестирование use-case без базы данных

Тестирование use-case без базы данных

Главное преимущество гексагональной архитектуры - бизнес-логика тестируется без базы данных, без HTTP, без внешних сервисов. Use-case зависит от интерфейса (порта), а в тестах мы подставляем фейк или мок.

Фейк: in-memory реализация порта

Фейк - это простая реализация интерфейса, которая хранит данные в памяти. В отличие от мока, фейк содержит рабочую логику: добавляет, ищет, удаляет. Мьютекс внутри - та же страховка, что в уроке о репозиториях: тесты гоняют с флагом go test -race, который ловит data race - одновременный доступ горутин к общим данным без синхронизации.

// usecase/create_task_test.go
package usecase_test

import (
    "context"
    "sync"
    "time"

    "myapp/internal/domain"
)

type FakeTaskRepo struct {
    mu    sync.RWMutex
    tasks map[string]domain.Task
}

func NewFakeTaskRepo() *FakeTaskRepo {
    return &FakeTaskRepo{tasks: make(map[string]domain.Task)}
}

func (r *FakeTaskRepo) Create(_ context.Context, t domain.Task) error {
    r.mu.Lock()
    defer r.mu.Unlock()
    r.tasks[t.ID()] = t
    return nil
}

func (r *FakeTaskRepo) GetByID(_ context.Context, id string) (domain.Task, error) {
    r.mu.RLock()
    defer r.mu.RUnlock()
    t, ok := r.tasks[id]
    if !ok {
        return domain.Task{}, domain.ErrTaskNotFound
    }
    return t, nil
}

func (r *FakeTaskRepo) ListByUser(_ context.Context, userID string) ([]domain.Task, error) {
    r.mu.RLock()
    defer r.mu.RUnlock()
    var result []domain.Task
    for _, t := range r.tasks {
        if t.UserID() == userID {
            result = append(result, t)
        }
    }
    return result, nil
}

func (r *FakeTaskRepo) Update(_ context.Context, t domain.Task) error {
    r.mu.Lock()
    defer r.mu.Unlock()
    r.tasks[t.ID()] = t
    return nil
}

func (r *FakeTaskRepo) Delete(_ context.Context, id string) error {
    r.mu.Lock()
    defer r.mu.Unlock()
    delete(r.tasks, id)
    return nil
}
<?php
// tests/Fakes/FakeTaskRepository.php
declare(strict_types=1);

namespace App\Tests\Fakes;

use App\Application\Port\TaskRepositoryPort;
use App\Domain\Task;
use App\Domain\TaskError;

final class FakeTaskRepository implements TaskRepositoryPort
{
    /** @var array<string, Task> */
    private array $tasks = [];

    // clone на входе и выходе - обязателен, а не аккуратность.
    //
    // PHP хранит объекты по ссылке: без clone фейк отдавал бы тот же
    // объект, что лежит в массиве, и мутация домена «сохранялась» бы
    // без вызова update(). Тест на таком фейке зелёный, а в проде тот же
    // код теряет изменения. Go-версия выше хранит значения и получает
    // правильное поведение бесплатно - именно поэтому фейки на двух
    // языках здесь выглядят по-разному.
    public function create(Task $task): void
    {
        $this->tasks[$task->id()] = clone $task;
    }

    public function getById(string $id): Task
    {
        if (!isset($this->tasks[$id])) {
            throw TaskError::notFound();
        }
        return clone $this->tasks[$id];
    }

    /** @return list<Task> */
    public function listByUser(string $userId): array
    {
        $result = [];
        foreach ($this->tasks as $task) {
            if ($task->userId() === $userId) {
                $result[] = clone $task;
            }
        }
        return $result;
    }

    public function update(Task $task): void
    {
        $this->tasks[$task->id()] = clone $task;
    }

    public function delete(string $id): void
    {
        unset($this->tasks[$id]);
    }
}
# tests/fakes.py
import copy
import threading

from myapp import domain


class FakeTaskRepo:
    def __init__(self) -> None:
        self._lock = threading.Lock()
        self._tasks: dict[str, domain.Task] = {}

    # copy на входе и выходе - обязателен, а не аккуратность.
    #
    # Объекты здесь живут по ссылке: без copy фейк отдавал бы тот же
    # объект, что лежит в словаре, и мутация домена «сохранялась» бы
    # без вызова update(). Тест на таком фейке зелёный, а в проде тот же
    # код теряет изменения. Go-версия выше хранит значения и получает
    # правильное поведение бесплатно - именно поэтому фейки на разных
    # языках здесь выглядят по-разному.
    def create(self, task: domain.Task) -> None:
        with self._lock:
            self._tasks[task.id] = copy.copy(task)

    def get_by_id(self, task_id: str) -> domain.Task:
        with self._lock:
            task = self._tasks.get(task_id)
        if task is None:
            raise domain.TaskNotFoundError()
        return copy.copy(task)

    def list_by_user(self, user_id: str) -> list[domain.Task]:
        with self._lock:
            return [copy.copy(t) for t in self._tasks.values() if t.user_id == user_id]

    def update(self, task: domain.Task) -> None:
        with self._lock:
            self._tasks[task.id] = copy.copy(task)

    def delete(self, task_id: str) -> None:
        with self._lock:
            self._tasks.pop(task_id, None)

Фейк ведёт себя как настоящий репозиторий: можно создать задачу, потом получить её по ID. Это позволяет писать тесты, которые проверяют всю цепочку use-case, а не только «был ли вызван метод Save».

⚠️ Что значит «ведёт себя как настоящий» - и где фейки обычно врут

Фраза выше держится на одном свойстве: фейк должен копировать данные на входе и выходе, как это делает настоящее хранилище. Go-версия получает почти бесплатно - map[string]domain.Task хранит значения. Оговорка: копия поверхностная, и если в сущности есть слайсы, map или указатели, которые меняются по месту, их нужно копировать явно. PHP-версия хранила бы ссылки на те же объекты, поэтому там стоит clone.

Почему это важно именно для проверки «всей цепочки»: без копирования мутация домена сохраняется сама, без вызова update(). Тест assert.True(t, got.Completed()) проходит - и продолжал бы проходить, если из use-case удалить сохранение вообще. Такой тест не проверяет цепочку, а создаёт впечатление, что проверяет: в проде тот же код теряет изменения.

Проверить свой фейк можно одним тестом: получить объект, изменить его, не сохранять, получить снова - и убедиться, что изменение не сохранилось.

Тест use-case: CompleteTask

// FakeNotifier записывает вызовы вместо отправки уведомлений.
type FakeNotifier struct {
    calls []string
    err   error
}

func (n *FakeNotifier) TaskCompleted(_ context.Context, userID, title string) error {
    n.calls = append(n.calls, userID+":"+title)
    return n.err
}

func TestCompleteTask_Success(t *testing.T) {
    repo := NewFakeTaskRepo()
    notifier := &FakeNotifier{}
    uc := usecase.NewCompleteTask(repo, notifier)

    // Подготовка: восстанавливаем незавершённую задачу так, как это делает
    // адаптер БД. Литералом `domain.Task{...}` не получится - поля закрыты,
    // и это ровно то, ради чего они закрыты: тест не может собрать
    // сущность в состоянии, которое домен считает невозможным.
    task, err := domain.TaskFromStorage(
        "task-1", "user-1", "Написать тесты", "", false, time.Now(), nil,
    )
    require.NoError(t, err)
    _ = repo.Create(context.Background(), task)

    // Действие: завершаем задачу.
    err = uc.Execute(context.Background(), "task-1", "user-1")

    // Проверка: ошибки нет, задача отмечена как completed.
    require.NoError(t, err)

    got, _ := repo.GetByID(context.Background(), "task-1")
    assert.True(t, got.Completed())
}
<?php
// tests/Application/UseCase/CompleteTaskUseCaseTest.php
declare(strict_types=1);

namespace App\Tests\Application\UseCase;

use App\Application\Port\TaskNotifierPort;
use App\Application\UseCase\CompleteTaskUseCase;
use App\Domain\Task;
use App\Tests\Fakes\FakeTaskRepository;
use PHPUnit\Framework\TestCase;

final class CompleteTaskUseCaseTest extends TestCase
{
    public function testCompletesTaskSuccessfully(): void
    {
        // Arrange
        $repo = new FakeTaskRepository();
        $repo->create(Task::fromStorage(
            id: 'task-1',
            userId: 'user-1',
            title: 'Написать тесты',
            completed: false,
        ));
        // Заглушка порта уведомлений: здесь проверяем только результат
        $uc = new CompleteTaskUseCase($repo, $this->createStub(TaskNotifierPort::class));

        // Act
        $uc->execute('task-1', 'user-1');

        // Assert
        self::assertTrue($repo->getById('task-1')->isCompleted());
    }
}
# tests/usecase/test_complete_task.py
from datetime import datetime, timezone

from myapp import domain
from myapp.usecase import CompleteTask
from tests.fakes import FakeTaskRepo


class FakeNotifier:
    """Записывает вызовы вместо отправки уведомлений."""

    def __init__(self, error: Exception | None = None) -> None:
        self.calls: list[str] = []
        self._error = error

    def task_completed(self, user_id: str, title: str) -> None:
        self.calls.append(f"{user_id}:{title}")
        if self._error is not None:
            raise self._error


def test_complete_task_success() -> None:
    repo = FakeTaskRepo()
    notifier = FakeNotifier()
    uc = CompleteTask(repo, notifier)

    # Подготовка: восстанавливаем незавершённую задачу так, как это делает
    # адаптер БД. Через Task(...) напрямую не собрать - конструктор закрыт
    # соглашением, и это ровно то, ради чего он закрыт: тест не может
    # собрать сущность в состоянии, которое домен считает невозможным.
    task = domain.Task.from_storage(
        "task-1", "user-1", "Написать тесты", "", False, datetime.now(timezone.utc), None,
    )
    repo.create(task)

    # Действие: завершаем задачу. Исключения нет - значит, успех;
    # отдельного require.NoError здесь не нужно.
    uc.execute("task-1", "user-1")

    # Проверка: задача отмечена как completed.
    got = repo.get_by_id("task-1")
    assert got.completed

Никакого PostgreSQL, никакого Docker, никаких миграций. Тест выполняется за миллисекунды.

Table-driven тесты

Когда у use-case несколько сценариев (успех, задача не найдена, уже завершена), table-driven подход компактнее отдельных функций.

func TestCompleteTask(t *testing.T) {
    tests := []struct {
        name    string
        setup   func(repo *FakeTaskRepo)
        taskID  string
        wantErr error
    }{
        {
            name: "успешное завершение",
            setup: func(repo *FakeTaskRepo) {
                task, _ := domain.TaskFromStorage(
                    "t1", "u1", "Задача", "", false, time.Now(), nil,
                )
                _ = repo.Create(context.Background(), task)
            },
            taskID:  "t1",
            wantErr: nil,
        },
        {
            name:    "задача не найдена",
            setup:   func(repo *FakeTaskRepo) {},
            taskID:  "nonexistent",
            wantErr: domain.ErrTaskNotFound,
        },
        {
            name: "задача уже завершена",
            setup: func(repo *FakeTaskRepo) {
                // Завершённую задачу через NewTask не создать - и не нужно:
                // восстановление из хранилища воспроизводит прошлое состояние.
                done := time.Now()
                task, _ := domain.TaskFromStorage(
                    "t2", "u1", "Задача", "", true, done.Add(-time.Hour), &done,
                )
                _ = repo.Create(context.Background(), task)
            },
            taskID:  "t2",
            wantErr: domain.ErrTaskAlreadyCompleted,
        },
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            repo := NewFakeTaskRepo()
            tt.setup(repo)

            uc := usecase.NewCompleteTask(repo, &FakeNotifier{})
            err := uc.Execute(context.Background(), tt.taskID, "u1")

            if tt.wantErr != nil {
                assert.ErrorIs(t, err, tt.wantErr)
            } else {
                require.NoError(t, err)
            }
        })
    }
}
<?php
// PHPUnit data provider - идиоматичный аналог table-driven
declare(strict_types=1);

namespace App\Tests\Application\UseCase;

use App\Application\Port\TaskNotifierPort;
use App\Application\UseCase\CompleteTaskUseCase;
use App\Domain\Task;
use App\Domain\TaskError;
use App\Tests\Fakes\FakeTaskRepository;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\TestCase;

final class CompleteTaskScenariosTest extends TestCase
{
    /** @return iterable<string, array{0: callable, 1: string, 2: ?string}> */
    public static function scenarios(): iterable
    {
        yield 'успешное завершение' => [
            fn (FakeTaskRepository $r) => $r->create(Task::fromStorage('t1', 'u1', 'Задача', false)),
            't1',
            null,
        ];
        yield 'задача не найдена' => [
            fn (FakeTaskRepository $r) => null,
            'nonexistent',
            'task not found',
        ];
        yield 'задача уже завершена' => [
            fn (FakeTaskRepository $r) => $r->create(Task::fromStorage('t2', 'u1', 'Задача', true)),
            't2',
            'task already completed',
        ];
    }

    #[DataProvider('scenarios')]
    public function testScenario(callable $setup, string $taskId, ?string $expectedError): void
    {
        $repo = new FakeTaskRepository();
        $setup($repo);
        $uc = new CompleteTaskUseCase($repo, $this->createStub(TaskNotifierPort::class));

        if ($expectedError !== null) {
            $this->expectException(TaskError::class);
            $this->expectExceptionMessage($expectedError);
        }

        $uc->execute($taskId, 'u1');
        if ($expectedError === null) {
            self::assertTrue($repo->getById($taskId)->isCompleted());
        }
    }
}
from datetime import datetime, timedelta, timezone

import pytest

from myapp import domain
from myapp.usecase import CompleteTask
from tests.fakes import FakeTaskRepo


def _with_open_task(repo: FakeTaskRepo) -> None:
    task = domain.Task.from_storage(
        "t1", "u1", "Задача", "", False, datetime.now(timezone.utc), None,
    )
    repo.create(task)


def _empty(repo: FakeTaskRepo) -> None:
    pass


def _with_completed_task(repo: FakeTaskRepo) -> None:
    # Завершённую задачу через create не создать - и не нужно:
    # восстановление из хранилища воспроизводит прошлое состояние.
    done = datetime.now(timezone.utc)
    task = domain.Task.from_storage(
        "t2", "u1", "Задача", "", True, done - timedelta(hours=1), done,
    )
    repo.create(task)


# Аналог table-driven: одна функция, таблица сценариев в parametrize.
# Подготовка вынесена в именованные функции - в lambda нет места
# для нескольких операторов.
@pytest.mark.parametrize(
    ("setup", "task_id", "want_err"),
    [
        pytest.param(_with_open_task, "t1", None, id="успешное завершение"),
        pytest.param(_empty, "nonexistent", domain.TaskNotFoundError, id="задача не найдена"),
        pytest.param(_with_completed_task, "t2", domain.TaskAlreadyCompletedError, id="задача уже завершена"),
    ],
)
def test_complete_task(setup, task_id: str, want_err: type[Exception] | None) -> None:
    repo = FakeTaskRepo()
    setup(repo)

    uc = CompleteTask(repo, FakeNotifier())

    if want_err is not None:
        with pytest.raises(want_err):
            uc.execute(task_id, "u1")
    else:
        uc.execute(task_id, "u1")

ℹ️ Каждый подтест - чистый репозиторий

Создавай NewFakeTaskRepo() внутри каждого подтеста. Если использовать общий репозиторий, тесты начнут влиять друг на друга, и порядок запуска станет важен. Изоляция - основа надёжных тестов.

Тестирование ошибок репозитория

Что если база упала? Use-case должен корректно пробросить ошибку. Для таких сценариев удобен failing fake - фейк, который всегда возвращает ошибку.

type FailingTaskRepo struct{}

func (r *FailingTaskRepo) GetByID(context.Context, string) (domain.Task, error) {
    return domain.Task{}, errors.New("connection refused")
}
func (r *FailingTaskRepo) Update(context.Context, domain.Task) error {
    return errors.New("connection refused")
}
// ... остальные методы аналогично

func TestCompleteTask_RepoError(t *testing.T) {
    uc := usecase.NewCompleteTask(&FailingTaskRepo{}, &FakeNotifier{})
    err := uc.Execute(context.Background(), "any-id", "u1")

    assert.Error(t, err)
    assert.Contains(t, err.Error(), "connection refused")
}
<?php
// tests/Fakes/FailingTaskRepository.php
declare(strict_types=1);

namespace App\Tests\Fakes;

use App\Application\Port\TaskRepositoryPort;
use App\Domain\Task;
use RuntimeException;

final class FailingTaskRepository implements TaskRepositoryPort
{
    public function create(Task $task): void { throw new RuntimeException('connection refused'); }
    public function getById(string $id): Task { throw new RuntimeException('connection refused'); }
    public function listByUser(string $userId): array { throw new RuntimeException('connection refused'); }
    public function update(Task $task): void { throw new RuntimeException('connection refused'); }
    public function delete(string $id): void { throw new RuntimeException('connection refused'); }
}
<?php
// tests/Application/UseCase/CompleteTaskRepoErrorTest.php
declare(strict_types=1);

namespace App\Tests\Application\UseCase;

use App\Application\Port\TaskNotifierPort;
use App\Application\UseCase\CompleteTaskUseCase;
use App\Tests\Fakes\FailingTaskRepository;
use PHPUnit\Framework\TestCase;
use RuntimeException;

final class CompleteTaskRepoErrorTest extends TestCase
{
    public function testPropagatesInfrastructureError(): void
    {
        $uc = new CompleteTaskUseCase(
            new FailingTaskRepository(),
            $this->createStub(TaskNotifierPort::class),
        );

        $this->expectException(RuntimeException::class);
        $this->expectExceptionMessage('connection refused');

        $uc->execute('any-id', 'user-1');
    }
}
import pytest

from myapp import domain
from myapp.usecase import CompleteTask


class FailingTaskRepo:
    def get_by_id(self, task_id: str) -> domain.Task:
        raise ConnectionError("connection refused")

    def update(self, task: domain.Task) -> None:
        raise ConnectionError("connection refused")

    # ... остальные методы аналогично


def test_complete_task_repo_error() -> None:
    uc = CompleteTask(FailingTaskRepo(), FakeNotifier())

    with pytest.raises(ConnectionError, match="connection refused"):
        uc.execute("any-id", "u1")

Mock vs Fake: когда что использовать

FakeMock (testify/mock)
Что этоРабочая реализация на map/sliceЗаглушка, записывающая вызовы
ПроверяетРезультат (state-based)Взаимодействие (вызван ли метод, с какими аргументами)
Когда использоватьUse-case тесты, когда важен итогПроверка side-effects (отправлено ли уведомление)
ХрупкостьНизкаяВысокая (ломается при рефакторинге)

Пример с testify/mock для проверки side-effect:

// MockNotifier реализует тот же порт TaskNotifier, что и FakeNotifier выше,
// только записывает вызовы через testify/mock.
type MockNotifier struct {
    mock.Mock
}

func (m *MockNotifier) TaskCompleted(ctx context.Context, userID, taskTitle string) error {
    args := m.Called(ctx, userID, taskTitle)
    return args.Error(0)
}

func TestCompleteTask_NotifiesUser(t *testing.T) {
    repo := NewFakeTaskRepo()
    task, err := domain.TaskFromStorage(
        "task-1", "user-1", "Написать тесты", "", false, time.Now(), nil,
    )
    require.NoError(t, err)
    _ = repo.Create(context.Background(), task)

    notifier := new(MockNotifier)
    notifier.On("TaskCompleted", mock.Anything, "user-1", "Написать тесты").Return(nil)

    uc := usecase.NewCompleteTask(repo, notifier)
    require.NoError(t, uc.Execute(context.Background(), "task-1", "user-1"))

    notifier.AssertExpectations(t)
}
<?php
// PHPUnit mock через createMock - встроенный аналог testify/mock
declare(strict_types=1);

namespace App\Tests\Application\UseCase;

use App\Application\Port\TaskNotifierPort;
use App\Application\UseCase\CompleteTaskUseCase;
use App\Domain\Task;
use App\Tests\Fakes\FakeTaskRepository;
use PHPUnit\Framework\TestCase;

final class CompleteTaskNotifiesUserTest extends TestCase
{
    public function testNotifiesUserOnComplete(): void
    {
        $repo = new FakeTaskRepository();
        $repo->create(Task::fromStorage('task-1', 'user-1', 'Написать тесты', false));

        $notifier = $this->createMock(TaskNotifierPort::class);
        $notifier->expects(self::once())
            ->method('taskCompleted')
            ->with('user-1', 'Написать тесты');

        $uc = new CompleteTaskUseCase($repo, $notifier);
        $uc->execute('task-1', 'user-1');
    }
}
# unittest.mock из stdlib - встроенный аналог testify/mock
from datetime import datetime, timezone
from unittest.mock import Mock

from myapp import domain
from myapp.usecase import CompleteTask
from myapp.usecase.ports import TaskNotifier
from tests.fakes import FakeTaskRepo


def test_complete_task_notifies_user() -> None:
    repo = FakeTaskRepo()
    repo.create(domain.Task.from_storage(
        "task-1", "user-1", "Написать тесты", "", False, datetime.now(timezone.utc), None,
    ))
    # Mock(spec=...) ограничивает мок интерфейсом: вызов метода, которого
    # нет в TaskNotifier, упадёт сразу, а не пройдёт молча.
    notifier = Mock(spec=TaskNotifier)

    uc = CompleteTask(repo, notifier)
    uc.execute("task-1", "user-1")

    notifier.task_completed.assert_called_once_with("user-1", "Написать тесты")

⚠️ Не злоупотребляй моками

Если каждый тест проверяет «метод X вызван с аргументами Y» - при любом рефакторинге тесты посыплются. Используй фейки для репозиториев (state-based), а моки - только для side-effects (уведомления, отправка событий).

Пирамида тестов в Hex

Пирамида тестов: 80 процентов unit, 15 процентов integration, 5 процентов E2E

Примерный ориентир (эвристика, а не норма): около 80% - unit-тесты use-case на фейках. Они быстрые (мс), их много, и они покрывают бизнес-логику. Около 15% - integration: адаптер против настоящей зависимости, например репозиторий на реальной БД. Около 5% - E2E: весь сервис в Docker, проверяют только, что он собран и работает. Чем выше по пирамиде, тем тест медленнее, дороже и хрупче.

Большинство тестов - unit-тесты use-case на фейках. Они быстрые (тысячи за секунду), надёжные (нет flaky из-за сети) и покрывают всю бизнес-логику. Интеграционные тесты адаптеров нужны, но их мало: достаточно проверить, что SQL-запросы корректны и маппинг работает.

Чтобы потренироваться на чём-то целом, а не на отдельных фрагментах, возьми мини-проект Tasks API: там уже есть домен с инвариантами, два use-case и in-memory адаптер - ровно тот набор, на котором такая пирамида и строится.

Мини-задание

  • Напиши FakeUserRepo с методами Create, GetByID, GetByEmail - используй map[string]domain.User
  • Напиши table-driven тест для use-case RegisterUser: успех, дублирующий email, пустое имя
  • Добавь FailingUserRepo, который всегда возвращает ошибку, и проверь, что use-case корректно её прокидывает
  • Запусти тесты с флагом -race и убедись, что data race нет

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