Testing AgentRouter con Go

package agentrouter

import (
    "encoding/json"
    "errors"
    "math"
)

// Tipos públicos —————————————————————————————————————————

type TaskType string

const (
    TaskSEO        TaskType = "seo"
    TaskCopywriting TaskType = "copywriting"
    TaskAnalytics  TaskType = "analytics"
    TaskEmail      TaskType = "email"
)

type Request struct {
    ClientID string   `json:"client_id"`
    Task     TaskType `json:"task"`
    Priority int      `json:"priority"`  // 1-10
    Context  string   `json:"context"`
}

type Agent struct {
    ID           string
    Capabilities []TaskType
    Load         float64  // 0.0–1.0
    Latency      float64  // ms promedio
}

type AgentID = string

var ErrNoAgentAvailable = errors.New("no agent available for task")
var ErrInvalidRequest   = errors.New("invalid request")

// Router ———————————————————————————————————————————————

type Router struct {
    agents []Agent
}

func NewRouter(agents []Agent) *Router {
    return &Router{agents: agents}
}

// RouteRequest selecciona el agente óptimo para la petición.
func (r *Router) RouteRequest(req Request) (AgentID, error) {
    if req.ClientID == "" || req.Task == "" {
        return "", ErrInvalidRequest
    }
    var best *Agent
    var bestScore float64 = -1
    for i := range r.agents {
        score := ScoreAgent(r.agents[i], req.Task)
        if score > bestScore {
            bestScore = score
            best = &r.agents[i]
        }
    }
    if best == nil || bestScore == 0 {
        return "", ErrNoAgentAvailable
    }
    return best.ID, nil
}

// ScoreAgent puntúa la idoneidad: capacidad (0|1) × (1-load) × (1/latency).
func ScoreAgent(a Agent, task TaskType) float64 {
    capable := false
    for _, cap := range a.Capabilities {
        if cap == task { capable = true; break }
    }
    if !capable { return 0 }
    return (1 - a.Load) * (1 / math.Max(a.Latency, 1))
}

// ParseRequest deserializa JSON → Request.
func ParseRequest(raw string) (*Request, error) {
    if raw == "" { return nil, ErrInvalidRequest }
    var req Request
    if err := json.Unmarshal([]byte(raw), &req); err != nil {
        return nil, ErrInvalidRequest
    }
    return &req, nil
}

package agentrouter

import (
    "testing"
)

// ── fixtures ─────────────────────────────────────────────────────────────────

var testAgents = []Agent{
    {ID: "seo-01",  Capabilities: []TaskType{TaskSEO},                          Load: 0.2, Latency: 50},
    {ID: "copy-01", Capabilities: []TaskType{TaskCopywriting, TaskEmail},         Load: 0.5, Latency: 30},
    {ID: "data-01", Capabilities: []TaskType{TaskAnalytics},                     Load: 0.1, Latency: 80},
    {ID: "full-01", Capabilities: []TaskType{TaskSEO, TaskCopywriting, TaskEmail}, Load: 0.9, Latency: 20},
}

// ── TestRouteRequest ─────────────────────────────────────────────────────────

func TestRouteRequest(t *testing.T) {
    r := NewRouter(testAgents)

    tests := []struct {
        name        string
        req         Request
        wantAgent   string
        wantErr     bool
    }{
        {
            name:      "SEO task → seo-01 (menor carga)",
            req:       Request{ClientID: "cultiva", Task: TaskSEO, Priority: 5},
            wantAgent: "seo-01",
        },
        {
            name:      "Copywriting → copy-01 sobre full-01 (menor carga)",
            req:       Request{ClientID: "cultiva", Task: TaskCopywriting, Priority: 8},
            wantAgent: "copy-01",
        },
        {
            name:      "Analytics → data-01 (único capaz)",
            req:       Request{ClientID: "cultiva", Task: TaskAnalytics},
            wantAgent: "data-01",
        },
        {
            name:    "ClientID vacío → ErrInvalidRequest",
            req:     Request{Task: TaskSEO},
            wantErr: true,
        },
        {
            name:    "Task vacío → ErrInvalidRequest",
            req:     Request{ClientID: "cultiva"},
            wantErr: true,
        },
        {
            name:    "Task desconocido → ErrNoAgentAvailable",
            req:     Request{ClientID: "cultiva", Task: "video"},
            wantErr: true,
        },
    }

    for _, tt := range tests {
        tt := tt // capture para t.Parallel()
        t.Run(tt.name, func(t *testing.T) {
            t.Parallel()

            got, err := r.RouteRequest(tt.req)

            if tt.wantErr {
                if err == nil {
                    t.Errorf("RouteRequest(%+v) esperaba error, got nil", tt.req)
                }
                return
            }
            if err != nil {
                t.Fatalf("RouteRequest(%+v) error inesperado: %v", tt.req, err)
            }
            if got != tt.wantAgent {
                t.Errorf("RouteRequest() = %q; want %q", got, tt.wantAgent)
            }
        })
    }
}

// ── TestParseRequest ─────────────────────────────────────────────────────────

func TestParseRequest(t *testing.T) {
    tests := []struct{
        name    string
        input   string
        want    *Request
        wantErr bool
    }{
        {"JSON válido",  `{"client_id":"c1","task":"seo","priority":7}`, &Request{ClientID:"c1",Task:TaskSEO,Priority:7}, false},
        {"JSON mínimo",  `{"client_id":"c2","task":"email"}`,            &Request{ClientID:"c2",Task:TaskEmail},              false},
        {"JSON inválido", `{client_id}`,                                nil,                                               true},
        {"string vacío", "",                                           nil,                                               true},
        {"array",        `[]`,                                         nil,                                               true},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            got, err := ParseRequest(tt.input)
            if (err != nil) != tt.wantErr {
                t.Fatalf("ParseRequest(%q) error=%v, wantErr=%v", tt.input, err, tt.wantErr)
            }
            if !tt.wantErr && got.ClientID != tt.want.ClientID {
                t.Errorf("ClientID got %q; want %q", got.ClientID, tt.want.ClientID)
            }
        })
    }
}

// ── TestScoreAgent (subtests por agente) ──────────────────────────────────────

func TestScoreAgent(t *testing.T) {
    t.Run("agente capaz devuelve score > 0", func(t *testing.T) {
        score := ScoreAgent(testAgents[0], TaskSEO)
        if score <= 0 { t.Errorf("esperaba score > 0, got %f", score) }
    })
    t.Run("agente incapaz devuelve 0", func(t *testing.T) {
        score := ScoreAgent(testAgents[0], TaskAnalytics)
        if score != 0 { t.Errorf("esperaba 0, got %f", score) }
    })
    t.Run("mayor carga → menor score", func(t *testing.T) {
        // copy-01 (load 0.5) vs full-01 (load 0.9), misma tarea
        s1 := ScoreAgent(testAgents[1], TaskCopywriting)
        s2 := ScoreAgent(testAgents[3], TaskCopywriting)
        if s1 <= s2 { t.Errorf("copy-01 score %f debería superar full-01 %f", s1, s2) }
    })
}

// ── Benchmarks ────────────────────────────────────────────────────────────────

func BenchmarkRouteRequest(b *testing.B) {
    r := NewRouter(testAgents)
    req := Request{ClientID: "cultiva", Task: TaskSEO, Priority: 5}

    sizes := []int{100, 1000, 10000}
    for _, n := range sizes {
        b.Run(fmt.Sprintf("n=%d", n), func(b *testing.B) {
            b.ResetTimer()
            for i := 0; i < b.N; i++ {
                for j := 0; j < n; j++ {
                    _, _ = r.RouteRequest(req)
                }
            }
        })
    }
}