2. Тестирование handler функций

package api

import (
    "context"
    "encoding/json"
    "errors"
    "net/http"
)

// Ошибки предметной области
var (
    ErrNotFound      = errors.New("пользователь не найден")
    ErrAlreadyExists = errors.New("пользователь с таким email уже зарегистрирован")
)

// UserService — узкий интерфейс бизнес-логики, необходимый хэндлеру
type UserService interface {
    Create(ctx context.Context, email string) (int, error)
}

// UserHandler инкапсулирует зависимость от бизнес-сервиса
type UserHandler struct {
    service UserService
}

func NewUserHandler(s UserService) *UserHandler {
    return &UserHandler{service: s}
}

// CreateUser обрабатывает запрос на создание пользователя
func (h *UserHandler) CreateUser(w http.ResponseWriter, r *http.Request) {
    var req struct {
        Email string `json:"email"`
    }

    // 1. Потоковое чтение и парсинг входящего JSON
    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
        w.Header().Set("Content-Type", "application/json")
        w.WriteHeader(http.StatusBadRequest)
        _, _ = w.Write([]byte(`{"error": "bad request"}`))
        return
    }

    // 2. Вызов бизнес-логики с пробросом контекста запроса
    id, err := h.service.Create(r.Context(), req.Email)
    if err != nil {
        w.Header().Set("Content-Type", "application/json")
        switch {
        case errors.Is(err, ErrAlreadyExists):
            w.WriteHeader(http.StatusConflict)
            _, _ = w.Write([]byte(`{"error": "conflict"}`))
        default:
            w.WriteHeader(http.StatusInternalServerError)
            _, _ = w.Write([]byte(`{"error": "internal"}`))
        }
        return
    }

    // 3. Формирование успешного ответа
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusCreated)
    _ = json.NewEncoder(w).Encode(map[string]int{"id": id})
}

package api_test

import (
    "bytes"
    "context"
    "net/http"
    "net/http/httptest"
    "testing"

    "github.com/stretchr/testify/require"
    "go.uber.org/mock/gomock"

    "yourproject/internal/api"
    "yourproject/internal/mocks" // Пакет со сгенерированным MockUserService
)

func TestUserHandler_CreateUser(t *testing.T) {
    t.Parallel()

    // 1. Декларативное описание схемы сценария
    type testCase struct {
        name           string
        requestBody    string
        setupMock      func(m *mocks.MockUserService)
        expectedStatus int
        expectedJSON   string
    }

    // 2. Набор тест-кейсов
    testCases := []testCase{
        {
            name:        "Happy Path: Успешное создание",
            requestBody: `{"email": "test@example.com"}`,
            setupMock: func(m *mocks.MockUserService) {
                // Проверяем факт вызова метода с ожидаемым аргументом ровно 1 раз
                m.EXPECT().
                    Create(gomock.Any(), "test@example.com").
                    Return(42, nil).
                    Times(1)
            },
            expectedStatus: http.StatusCreated,
            expectedJSON:   `{"id": 42}`,
        },
        {
            name:        "Bad Request: Невалидный JSON",
            requestBody: `{"email": "test...`, // Синтаксически сломанный JSON
            setupMock: func(m *mocks.MockUserService) {
                // При ошибке парсинга сервис НЕ должен вызываться вовсе
            },
            expectedStatus: http.StatusBadRequest,
            expectedJSON:   `{"error": "bad request"}`,
        },
        {
            name:        "Conflict: Пользователь уже зарегистрирован",
            requestBody: `{"email": "exist@example.com"}`,
            setupMock: func(m *mocks.MockUserService) {
                m.EXPECT().
                    Create(gomock.Any(), "exist@example.com").
                    Return(0, api.ErrAlreadyExists).
                    Times(1)
            },
            expectedStatus: http.StatusConflict,
            expectedJSON:   `{"error": "conflict"}`,
        },
        {
            name:        "Internal Error: Сбой сервисного слоя",
            requestBody: `{"email": "crash@example.com"}`,
            setupMock: func(m *mocks.MockUserService) {
                m.EXPECT().
                    Create(gomock.Any(), "crash@example.com").
                    Return(0, api.ErrNotFound).
                    Times(1)
            },
            expectedStatus: http.StatusInternalServerError,
            expectedJSON:   `{"error": "internal"}`,
        },
    }

    // 3. Параллельное исполнение сценариев
    for _, tc := range testCases {
        tc := tc // Защитный захват переменной замыкания (актуально для Go < 1.22)
        t.Run(tc.name, func(t *testing.T) {
            t.Parallel()

            // Инициализируем контроллер моков
            ctrl := gomock.NewController(t)

            mockSvc := mocks.NewMockUserService(ctrl)
            tc.setupMock(mockSvc)

            handler := api.NewUserHandler(mockSvc)

            // Создаем искусственный входящий запрос и перехватчик ответа
            req := httptest.NewRequest(http.MethodPost, "/users", bytes.NewBufferString(tc.requestBody))
            rec := httptest.NewRecorder()

            // Act: Прямой вызов обработчика в памяти
            handler.CreateUser(rec, req)

            // Assert: Проверяем транспортный контракт
            res := rec.Result()
            defer res.Body.Close()

            require.Equal(t, tc.expectedStatus, res.StatusCode)

            // Семантическая валидация JSON-ответа
            require.JSONEq(t, tc.expectedJSON, rec.Body.String())
        })
    }
}

m.EXPECT().
    Create(gomock.AssignableToTypeOf(context.Background()), "test@example.com").
    DoAndReturn(func(ctx context.Context, email string) (int, error) {
        // Убеждаемся, что контекст не был подменен на пустой Background
        require.NotNil(t, ctx.Done(), "Контекст обязан быть отменяемым контекстом HTTP-запроса")
        return 42, nil
    })

json.NewDecoder(r.Body).Decode(&req)