Files
archie/internal/app/agentworker/worker_test.go
T
sam 5e94cef784 refactor(workflow): relocate Task/Status/Source and define workflow.Store (#754)
* refactor(workflow,store): relocate Task/Status/Source and define workflow.Store

Move store.Task, store.Status*/store.Source*, and the 3-method workflow
store interface out of internal/store into internal/domain/workflow as
workflow.Task/workflow.Status/workflow.Source plus a consumer-owned
workflow.Store, superseding store.WorkflowStore. internal/domain/workflow
now imports zero internal/store symbols; internal/store persists the
domain type instead (infrastructure depends on domain), and its Store
satisfies workflow.Store.

Updates every production and test caller of the relocated symbols across
daemon, webui, gateway, agentworker, agenttransport/nats, storerpc,
taskrun, and worktreerpc, and removes TestRecordDispatchViaExplicitTx per
docs/prds/state-store-contract.md (rev. 2c) sections 4 and 12 step 2.

Two workflow-package integration tests that exercise the real *store.Store
move to an external workflow_test package (store_integration_test.go) to
avoid a workflow(test)->store->workflow(prod) import cycle now that store
depends on workflow.

* no-mistakes(document): docs(state-store): mark §4.8 relocation done in state-store-contract
2026-09-07 00:39:26 +10:00

231 lines
7.8 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"
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) 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)
}
}
})
}
}