Files
archie/internal/app/agentworker/worker_test.go
T

234 lines
8.0 KiB
Go

package agentworker
import (
"bytes"
"context"
"errors"
"log/slog"
"strings"
"testing"
"time"
"github.com/samcharles93/archie-core/internal/agentexec"
"github.com/samcharles93/archie-core/internal/domain/workflow"
"github.com/samcharles93/archie-core/internal/domain/workflow/task"
agentnats "github.com/samcharles93/archie-core/internal/infrastructure/agenttransport/nats"
)
type workerPublisher struct{ messages *[][]byte }
func (p workerPublisher) Publish(_ string, data []byte) error {
if p.messages != nil {
*p.messages = append(*p.messages, append([]byte(nil), data...))
}
return nil
}
type workerSubscription struct {
close func()
closeErr error
}
func (s workerSubscription) Close() error {
s.close()
return s.closeErr
}
type workerTransportStub struct {
events *[]string
subscribeErr error
subCloseErr error
publisher agentexec.LogPublisher
eventPublisher agentexec.EventPublisher
taskID int64
}
func (t *workerTransportStub) Close() { *t.events = append(*t.events, "transport-close") }
func (t *workerTransportStub) LogPublisher() agentexec.LogPublisher {
*t.events = append(*t.events, "log-publisher")
if t.publisher != nil {
return t.publisher
}
return workerPublisher{}
}
func (t *workerTransportStub) EventPublisher() agentexec.EventPublisher {
*t.events = append(*t.events, "event-publisher")
if t.eventPublisher != nil {
return t.eventPublisher
}
return workerPublisher{}
}
func (t *workerTransportStub) SubscribeTasks(_ context.Context, taskID int64, _ agentnats.TaskHandler, _ *slog.Logger) (agentnats.Subscription, error) {
*t.events = append(*t.events, "subscribe")
t.taskID = taskID
if t.subscribeErr != nil {
return nil, t.subscribeErr
}
return workerSubscription{
close: func() { *t.events = append(*t.events, "subscription-close") },
closeErr: t.subCloseErr,
}, nil
}
func (*workerTransportStub) Forger(string, time.Duration) workflow.Forger { return nil }
func (*workerTransportStub) Store(time.Duration) workflow.Store { return nil }
func (*workerTransportStub) Calls(time.Duration) task.Caller { return nil }
func (*workerTransportStub) Trees(string, string, time.Duration) agentnats.RemoteTrees { return nil }
func TestRunPassesCompleteTransportConfiguration(t *testing.T) {
var got agentnats.Config
var events []string
transport := &workerTransportStub{events: &events}
ctx, cancel := context.WithCancel(t.Context())
dependencies := workerDependencies{
markSafe: func(context.Context, string, *slog.Logger) bool { return true },
connect: func(_ context.Context, config agentnats.Config, _ *slog.Logger) (workerTransport, error) {
got = config
return transport, nil
},
bootID: func(string) (int64, error) { return 42, nil },
wait: func(context.Context, *slog.Logger) { cancel() },
}
settings := Settings{NATSURL: "nats://test", NATSToken: "secret", WorkDir: "/worktree"}
if err := run(ctx, settings, slog.New(slog.DiscardHandler), dependencies); err != nil {
t.Fatal(err)
}
if got.URL != settings.NATSURL || got.Token != settings.NATSToken {
t.Fatalf("connection config = %#v, want URL/token from settings", got)
}
}
func TestRunPreservesStartupAndReverseCleanupOrder(t *testing.T) {
var events []string
transport := &workerTransportStub{events: &events}
dependencies := workerDependencies{
markSafe: func(context.Context, string, *slog.Logger) bool {
events = append(events, "git-safety")
return true
},
connect: func(context.Context, agentnats.Config, *slog.Logger) (workerTransport, error) {
events = append(events, "connect")
return transport, nil
},
bootID: func(string) (int64, error) {
events = append(events, "boot-id")
return 42, nil
},
wait: func(context.Context, *slog.Logger) {
events = append(events, "wait")
},
}
if err := run(t.Context(), Settings{NATSURL: "nats://test", WorkDir: "/worktree"}, slog.New(slog.DiscardHandler), dependencies); err != nil {
t.Fatal(err)
}
want := []string{"git-safety", "connect", "boot-id", "log-publisher", "subscribe", "wait", "subscription-close", "transport-close"}
if len(events) != len(want) {
t.Fatalf("events = %v, want %v", events, want)
}
for i := range want {
if events[i] != want[i] {
t.Fatalf("events = %v, want %v", events, want)
}
}
if transport.taskID != 42 {
t.Fatalf("subscription task ID = %d, want 42", transport.taskID)
}
}
func TestRunWarnsWhenNormalSubscriptionCleanupFails(t *testing.T) {
closeErr := errors.New("unsubscribe failed")
var events []string
transport := &workerTransportStub{events: &events, subCloseErr: closeErr}
dependencies := workerDependencies{
markSafe: func(context.Context, string, *slog.Logger) bool { return true },
connect: func(context.Context, agentnats.Config, *slog.Logger) (workerTransport, error) {
return transport, nil
},
bootID: func(string) (int64, error) { return 42, nil },
wait: func(context.Context, *slog.Logger) {},
}
var output bytes.Buffer
if err := run(t.Context(), Settings{NATSURL: "nats://test"}, slog.New(slog.NewTextHandler(&output, nil)), dependencies); err != nil {
t.Fatal(err)
}
if !strings.Contains(output.String(), "task run unsubscribe failed") || !strings.Contains(output.String(), closeErr.Error()) {
t.Fatalf("cleanup log = %q, want warning containing %q", output.String(), closeErr)
}
}
func TestRunStartupFailuresCleanUpOwnedResources(t *testing.T) {
connectErr := errors.New("connect failed")
bootErr := errors.New("invalid boot metadata")
subscribeErr := errors.New("subscribe failed")
tests := []struct {
name string
connectErr error
bootErr error
subscribeErr error
wantErr error
wantOperation string
wantClosed bool
}{
{name: "connect", connectErr: connectErr, wantErr: connectErr, wantOperation: "nats connect failed"},
{name: "boot metadata", bootErr: bootErr, wantErr: bootErr, wantOperation: "task boot failed", wantClosed: true},
{name: "subscribe", subscribeErr: subscribeErr, wantErr: subscribeErr, wantOperation: "taskrun subscribe failed", wantClosed: true},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
var events []string
var published [][]byte
transport := &workerTransportStub{events: &events, subscribeErr: test.subscribeErr, publisher: workerPublisher{messages: &published}}
dependencies := workerDependencies{
markSafe: func(context.Context, string, *slog.Logger) bool { return true },
connect: func(context.Context, agentnats.Config, *slog.Logger) (workerTransport, error) {
return transport, test.connectErr
},
bootID: func(string) (int64, error) {
if test.bootErr != nil {
return 0, test.bootErr
}
return 42, nil
},
wait: func(context.Context, *slog.Logger) { t.Fatal("wait called") },
}
var output bytes.Buffer
err := run(t.Context(), Settings{NATSURL: "nats://test"}, slog.New(slog.NewTextHandler(&output, nil)), dependencies)
if !errors.Is(err, test.wantErr) {
t.Fatalf("error = %v, want %v", err, test.wantErr)
}
var startupErr *StartupError
if !errors.As(err, &startupErr) || startupErr.Operation != test.wantOperation {
t.Fatalf("startup error = %#v, want operation %q", startupErr, test.wantOperation)
}
closed := len(events) > 0 && events[len(events)-1] == "transport-close"
if closed != test.wantClosed {
t.Fatalf("transport closed = %v, want %v; events %v", closed, test.wantClosed, events)
}
if test.bootErr != nil {
for _, event := range events {
if event == "subscribe" {
t.Fatalf("invalid boot metadata reached task subscription: events %v", events)
}
}
}
if got := strings.Count(output.String(), test.wantOperation); got != 1 {
t.Fatalf("operation log count = %d, want 1; output %q", got, output.String())
}
if test.subscribeErr != nil {
var joined strings.Builder
for _, data := range published {
joined.WriteString(string(data))
}
if !strings.Contains(joined.String(), test.wantOperation) {
t.Fatalf("task-scoped logs %q do not contain %q", joined.String(), test.wantOperation)
}
}
})
}
}