250 lines
7.2 KiB
Go
250 lines
7.2 KiB
Go
package orchestration
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"runtime"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"git.yeij.top/AskaEth/Cyrene_v2/internal/runtime/agent"
|
|
"git.yeij.top/AskaEth/Cyrene_v2/internal/runtime/loop"
|
|
"git.yeij.top/AskaEth/Cyrene_v2/internal/runtime/model"
|
|
"git.yeij.top/AskaEth/Cyrene_v2/internal/runtime/orchestration/comm"
|
|
)
|
|
|
|
func TestJoinMergesResults(t *testing.T) {
|
|
t.Parallel()
|
|
s := newScheduler(t, Options{MaxParallel: 2})
|
|
m := &mockRunner{result: &loop.Result{Text: "answer", Steps: 3, StopReason: "stop"}}
|
|
s.runner = m
|
|
|
|
ctx := context.Background()
|
|
for i := 0; i < 3; i++ {
|
|
if _, err := s.Spawn(ctx, AgentSpec{Goal: fmt.Sprintf("goal %d", i)}); err != nil {
|
|
t.Fatalf("Spawn %d: %v", i, err)
|
|
}
|
|
}
|
|
|
|
res, err := s.Join(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Join: %v", err)
|
|
}
|
|
if res.Total != 3 || res.Succeeded != 3 || res.Failed != 0 || res.Aborted != 0 {
|
|
t.Fatalf("merged = %d total / %d ok / %d failed / %d aborted, want 3/3/0/0",
|
|
res.Total, res.Succeeded, res.Failed, res.Aborted)
|
|
}
|
|
if len(res.Agents) != 3 {
|
|
t.Fatalf("Agents len = %d, want 3", len(res.Agents))
|
|
}
|
|
for _, a := range res.Agents {
|
|
if a.Status != StatusDone {
|
|
t.Fatalf("agent %s status = %s, want done", a.ID, a.Status)
|
|
}
|
|
if a.Summary == "" {
|
|
t.Fatalf("agent %s has no summary", a.ID)
|
|
}
|
|
if a.Text != "answer" || a.Steps != 3 {
|
|
t.Fatalf("agent %s result = text %q steps %d, want answer/3", a.ID, a.Text, a.Steps)
|
|
}
|
|
}
|
|
if !strings.Contains(res.Summary, "3 成功") {
|
|
t.Fatalf("merged summary = %q, want a 3-成功 aggregate", res.Summary)
|
|
}
|
|
}
|
|
|
|
func TestFailureSummary(t *testing.T) {
|
|
t.Parallel()
|
|
s := newScheduler(t, Options{MaxParallel: 2})
|
|
boom := errors.New("boom")
|
|
m := &mockRunner{err: boom}
|
|
s.runner = m
|
|
|
|
sub, err := s.Spawn(context.Background(), AgentSpec{Goal: "x"})
|
|
if err != nil {
|
|
t.Fatalf("Spawn: %v", err)
|
|
}
|
|
waitFor(t, func() bool { return sub.Status() == StatusFailed }, waitTimeout)
|
|
if !strings.Contains(sub.Summary(), "boom") {
|
|
t.Fatalf("Summary = %q, want the failure recorded", sub.Summary())
|
|
}
|
|
if !errors.Is(sub.Err(), boom) {
|
|
t.Fatalf("Err = %v, want boom", sub.Err())
|
|
}
|
|
if sub.Result() != nil {
|
|
t.Fatalf("Result = %v, want nil on failure", sub.Result())
|
|
}
|
|
|
|
res, err := s.Join(context.Background())
|
|
if err != nil {
|
|
t.Fatalf("Join: %v", err)
|
|
}
|
|
if res.Total != 1 || res.Failed != 1 || res.Succeeded != 0 {
|
|
t.Fatalf("merged = %d total / %d ok / %d failed, want 1/0/1",
|
|
res.Total, res.Succeeded, res.Failed)
|
|
}
|
|
}
|
|
|
|
func TestContextIsolation(t *testing.T) {
|
|
t.Parallel()
|
|
s := newScheduler(t, Options{MaxParallel: 1})
|
|
m := &mockRunner{result: &loop.Result{Text: "done"}}
|
|
s.runner = m
|
|
|
|
specCtx := []model.Message{model.TextMessage(model.RoleUser, "hello")}
|
|
sub, err := s.Spawn(context.Background(), AgentSpec{Goal: "x", Context: specCtx})
|
|
if err != nil {
|
|
t.Fatalf("Spawn: %v", err)
|
|
}
|
|
|
|
// Mutating the caller's slice after Spawn must not leak into the sub-agent.
|
|
specCtx[0].Content[0].Text = "mutated"
|
|
|
|
res, err := s.Join(context.Background())
|
|
if err != nil {
|
|
t.Fatalf("Join: %v", err)
|
|
}
|
|
if len(res.Agents) != 1 {
|
|
t.Fatalf("Agents len = %d, want 1", len(res.Agents))
|
|
}
|
|
if m.total != 1 {
|
|
t.Fatalf("runner calls = %d, want 1", m.total)
|
|
}
|
|
got := m.captured(0)
|
|
if len(got) != 1 || got[0].Content[0].Text != "hello" {
|
|
t.Fatalf("runner received context = %#v, want the isolated 'hello' context", got)
|
|
}
|
|
if sub.Context[0].Content[0].Text != "hello" {
|
|
t.Fatalf("sub-agent context text = %q, want hello", sub.Context[0].Content[0].Text)
|
|
}
|
|
}
|
|
|
|
func TestProgressEvents(t *testing.T) {
|
|
t.Parallel()
|
|
s := newScheduler(t, Options{MaxParallel: 1})
|
|
gate := make(chan struct{})
|
|
m := &mockRunner{gate: gate}
|
|
s.runner = m
|
|
|
|
listener := comm.New(s.Bus(), "main")
|
|
events := make(chan comm.Event, 8)
|
|
unsub, err := listener.SubscribeEvent(context.Background(), func(_ context.Context, e comm.Event) error {
|
|
events <- e
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("SubscribeEvent: %v", err)
|
|
}
|
|
defer unsub()
|
|
|
|
if _, err := s.Spawn(context.Background(), AgentSpec{Goal: "x"}); err != nil {
|
|
t.Fatalf("Spawn: %v", err)
|
|
}
|
|
waitFor(t, func() bool { return m.activeCount() >= 1 }, waitTimeout)
|
|
close(gate)
|
|
|
|
names := collectEventNames(t, events, waitTimeout)
|
|
seen := make(map[string]bool)
|
|
for _, n := range names {
|
|
seen[n] = true
|
|
}
|
|
for _, want := range []string{EventDispatched, EventStarted, EventDone} {
|
|
if !seen[want] {
|
|
t.Fatalf("missing progress event %q, got %v", want, names)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestJoin_CanceledCtx(t *testing.T) {
|
|
t.Parallel()
|
|
s := newScheduler(t, Options{MaxParallel: 1, PerAgentTimeout: 2 * time.Second})
|
|
m := &mockRunner{gate: make(chan struct{})}
|
|
s.runner = m
|
|
|
|
if _, err := s.Spawn(context.Background(), AgentSpec{Goal: "x"}); err != nil {
|
|
t.Fatalf("Spawn: %v", err)
|
|
}
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
|
|
defer cancel()
|
|
res, err := s.Join(ctx)
|
|
if !errors.Is(err, context.DeadlineExceeded) {
|
|
t.Fatalf("Join err = %v, want DeadlineExceeded", err)
|
|
}
|
|
if res == nil {
|
|
t.Fatal("Join returned a nil merged result on canceled ctx")
|
|
}
|
|
}
|
|
|
|
func TestApprove_NoApprover(t *testing.T) {
|
|
t.Parallel()
|
|
s := newScheduler(t, Options{})
|
|
if _, err := s.Approve(context.Background(), "bob", "run", "do something"); !errors.Is(err, ErrNoApprover) {
|
|
t.Fatalf("Approve err = %v, want ErrNoApprover", err)
|
|
}
|
|
}
|
|
|
|
func TestSinkMemory_NoStore(t *testing.T) {
|
|
t.Parallel()
|
|
s := newScheduler(t, Options{})
|
|
sub, err := s.Spawn(context.Background(), AgentSpec{Goal: "x"})
|
|
if err != nil {
|
|
t.Fatalf("Spawn: %v", err)
|
|
}
|
|
if _, err := s.SinkMemory(context.Background(), sub, "remember this", "persona", "relationship"); !errors.Is(err, ErrNoMemory) {
|
|
t.Fatalf("SinkMemory err = %v, want ErrNoMemory", err)
|
|
}
|
|
}
|
|
|
|
func TestRunWithRealLoop(t *testing.T) {
|
|
t.Parallel()
|
|
ad := &mockAdapter{resp: model.Response{Content: "final answer", Model: "mock"}}
|
|
ag, err := agent.New("You are a helper.", nil, nil, agent.WithModel(ad, nil))
|
|
if err != nil {
|
|
t.Fatalf("agent.New: %v", err)
|
|
}
|
|
lp := loop.New(loop.Options{Agent: ag, MaxRounds: 3})
|
|
s := newScheduler(t, Options{Loop: lp, MaxParallel: 2})
|
|
|
|
sub, err := s.Spawn(context.Background(), AgentSpec{Goal: "x"})
|
|
if err != nil {
|
|
t.Fatalf("Spawn: %v", err)
|
|
}
|
|
waitFor(t, func() bool { return sub.Status() == StatusDone }, waitTimeout)
|
|
if sub.Result() == nil {
|
|
t.Fatal("real loop produced no result")
|
|
}
|
|
if sub.Result().Text != "final answer" {
|
|
t.Fatalf("result text = %q, want final answer", sub.Result().Text)
|
|
}
|
|
|
|
res, err := s.Join(context.Background())
|
|
if err != nil {
|
|
t.Fatalf("Join: %v", err)
|
|
}
|
|
if res.Succeeded != 1 || res.Failed != 0 {
|
|
t.Fatalf("merged = %d ok / %d failed, want 1 ok", res.Succeeded, res.Failed)
|
|
}
|
|
}
|
|
|
|
func TestNoGoroutineLeak(t *testing.T) {
|
|
// Not parallel: a goroutine-count assertion is noisy under parallel tests.
|
|
s := newScheduler(t, Options{MaxParallel: 2})
|
|
m := &mockRunner{result: &loop.Result{Text: "ok"}}
|
|
s.runner = m
|
|
|
|
baseline := runtime.NumGoroutine()
|
|
ctx := context.Background()
|
|
for i := 0; i < 20; i++ {
|
|
if _, err := s.Spawn(ctx, AgentSpec{Goal: fmt.Sprintf("g%d", i)}); err != nil {
|
|
t.Fatalf("Spawn %d: %v", i, err)
|
|
}
|
|
}
|
|
if _, err := s.Join(ctx); err != nil {
|
|
t.Fatalf("Join: %v", err)
|
|
}
|
|
waitFor(t, func() bool { return runtime.NumGoroutine() <= baseline+5 }, waitTimeout)
|
|
}
|