Тестирование¶

package myapi

import (
    "context"
    "encoding/json"
    "net/http"
    "net/http/httptest"
    "testing"
)

func TestGetUsers(t *testing.T) {
    ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // Проверяем Authorization header
        if got := r.Header.Get("Authorization"); got != "OAuth test-token" {
            t.Errorf("auth: want %q, got %q", "OAuth test-token", got)
        }
        // Возвращаем фиктивные данные
        json.NewEncoder(w).Encode(usersResponse{
            Users: []User{
                {ID: 1, Name: "Alice"},
                {ID: 2, Name: "Bob"},
            },
        })
    }))
    defer ts.Close()

    // WithBaseURL перенаправляет на mock сервер
    client := NewClient("test-token", WithBaseURL(ts.URL))

    users, err := client.GetUsers(context.Background())
    if err != nil {
        t.Fatalf("GetUsers() error = %v", err)
    }
    if len(users) != 2 {
        t.Errorf("len = %d, want 2", len(users))
    }
    if users[0].Name != "Alice" {
        t.Errorf("users[0].Name = %q, want Alice", users[0].Name)
    }
}

func TestGetUsers_Unauthorized(t *testing.T) {
    ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusUnauthorized)
        w.Write([]byte(`{"error": "invalid_token"}`))
    }))
    defer ts.Close()

    _, err := NewClient("bad-token", WithBaseURL(ts.URL)).
        GetUsers(context.Background())

    if err == nil {
        t.Fatal("expected error for 401, got nil")
    }
    // Убедиться что сообщение содержит код ошибки
    if !strings.Contains(err.Error(), "401") {
        t.Errorf("error should mention 401, got: %v", err)
    }
}

package mcp

import (
    "bytes"
    "errors"
    "strings"
    "testing"
)

func TestTransport_ReadRequest(t *testing.T) {
    input := `{"jsonrpc":"2.0","id":1,"method":"ping"}` + "\n"
    transport := NewStdioTransport(strings.NewReader(input), &bytes.Buffer{})

    req, err := transport.ReadRequest()
    if err != nil {
        t.Fatalf("ReadRequest() error = %v", err)
    }
    if req.Method != "ping" {
        t.Errorf("Method = %q, want ping", req.Method)
    }
}

func TestTransport_InvalidJSON(t *testing.T) {
    transport := NewStdioTransport(strings.NewReader("not-json\n"), &bytes.Buffer{})

    _, err := transport.ReadRequest()
    if err == nil {
        t.Fatal("expected parse error")
    }
    var pe *parseError
    if !errors.As(err, &pe) {
        t.Errorf("expected *parseError, got %T: %v", err, err)
    }
}

func TestTransport_EOF(t *testing.T) {
    transport := NewStdioTransport(strings.NewReader(""), &bytes.Buffer{})

    _, err := transport.ReadRequest()
    if !errors.Is(err, io.EOF) {
        t.Errorf("expected io.EOF, got %v", err)
    }
}