234 lines
8.0 KiB
Go
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)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|