5. Тестирование gRPC

package grpcapi_test

import (
    "context"
    "net"
    "testing"

    "github.com/stretchr/testify/require"
    "go.uber.org/mock/gomock"
    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials/insecure"
    "google.golang.org/grpc/test/bufconn"

    // Сгенерированные Protocol Buffers структуры
    pb "yourproject/internal/generated/billing/v1"
    "yourproject/internal/grpcapi"
    "yourproject/internal/mocks"
)

// Емкость кольцевого буфера в оперативной памяти (1 МБ достаточно для тестов)
const bufSize = 1024 * 1024

// setupGRPCServer разворачивает in-memory gRPC стенд и возвращает готовый клиент
func setupGRPCServer(t *testing.T) (pb.BillingServiceClient, *mocks.MockBillingService) {
    t.Helper()

    // 1. Инициализируем контроллер и мок сервисного слоя
    ctrl := gomock.NewController(t)
    mockSvc := mocks.NewMockBillingService(ctrl)

    // 2. Создаем in-memory слушатель через bufconn
    listener := bufconn.Listen(bufSize)

    // 3. Создаем боевой gRPC сервер
    server := grpc.NewServer()

    // Инициализируем наш контроллер и регистрируем в gRPC сервере
    billingAPI := grpcapi.NewBillingAPI(mockSvc)
    pb.RegisterBillingServiceServer(server, billingAPI)

    // 4. Запускаем сервер в фоновой горутине
    go func() {
        if err := server.Serve(listener); err != nil {
            // Игнорируем штатную ошибку остановки сервера
            if err.Error() != "grpc: the server has been stopped" {
                t.Errorf("Ошибка запуска gRPC сервера: %v", err)
            }
        }
    }()

    // 5. Регистрируем корректную остановку сервера после завершения теста
    t.Cleanup(func() {
        server.Stop()
    })

    // 6. Конфигурируем клиентский диалер на подключение к нашему bufconn слушателю
    ctx := context.Background()
    dialer := func(context.Context, string) (net.Conn, error) {
        return listener.Dial() // Выдаем виртуальное соединение прямо из памяти!
    }

    conn, err := grpc.DialContext(ctx, "bufnet",
        grpc.WithContextDialer(dialer),
        grpc.WithTransportCredentials(insecure.NewCredentials()),
    )
    require.NoError(t, err, "не удалось установить соединение с in-memory gRPC сервером")

    t.Cleanup(func() {
        _ = conn.Close()
    })

    // Возвращаем типизированного сгенерированного клиента
    client := pb.NewBillingServiceClient(conn)

    return client, mockSvc
}

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

    // Arrange: Поднимаем сервер и получаем клиент
    client, mockSvc := setupGRPCServer(t)
    ctx := context.Background()

    req := &pb.ProcessPaymentRequest{
        UserId: "user_123",
        Amount: 500.0,
    }

    // Ожидаем, что API корректно распакует protobuf и вызовет доменную логику
    mockSvc.EXPECT().
        Process(gomock.Any(), "user_123", 500.0).
        Return("tx_999", nil).
        Times(1)

    // Act: Выполняем сетевой RPC-вызов через gRPC-клиент
    resp, err := client.ProcessPayment(ctx, req)

    // Assert: Верифицируем ответ
    require.NoError(t, err)
    require.NotNil(t, resp)
    require.Equal(t, "tx_999", resp.TransactionId)
}

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

    client, mockSvc := setupGRPCServer(t)
    ctx := context.Background()

    // Имитируем ошибку предметной области (недостаточно средств)
    mockSvc.EXPECT().
        Process(gomock.Any(), "user_123", 50000.0).
        Return("", grpcapi.ErrInsufficientFunds).
        Times(1)

    req := &pb.ProcessPaymentRequest{
        UserId: "user_123",
        Amount: 50000.0,
    }

    // Act: Вызываем метод клиента
    _, err := client.ProcessPayment(ctx, req)

    // Assert: Проверяем gRPC статус ошибки
    require.Error(t, err)

    // Извлекаем gRPC-статус из полученной ошибки
    st, ok := status.FromError(err)
    require.True(t, ok, "Возвращенная ошибка обязана быть валидным gRPC статусом")

    // Проверяем корректность трансляции ошибки в код FailedPrecondition
    require.Equal(t, codes.FailedPrecondition, st.Code())
    require.Equal(t, "insufficient funds", st.Message())
}

func TestLogService_StreamLogs(t *testing.T) {
    t.Parallel()
    client, _ := setupLogServer(t)

    // Получаем интерфейс StreamClient для чтения потока
    stream, err := client.DownloadLogs(context.Background(), &pb.LogRequest{})
    require.NoError(t, err)

    var receivedChunks int
    for {
        // Читаем очередной бинарный чанк из потока
        chunk, err := stream.Recv()
        if err == io.EOF {
            break // Поток корректно завершен сервером!
        }
        require.NoError(t, err)
        require.NotEmpty(t, chunk.Data)
        receivedChunks++
    }

    require.Greater(t, receivedChunks, 0)
}