* 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
231 lines
7.8 KiB
Go
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)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|