Files
archie/internal/daemon/identity_dispatch_test.go
T

164 lines
5.4 KiB
Go

package daemon
import (
"context"
"log/slog"
"strings"
"testing"
"github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/domain/identity"
"github.com/samcharles93/archie-core/internal/domain/workflow"
"github.com/samcharles93/archie-core/internal/domain/workintake"
"github.com/samcharles93/archie-core/internal/eventbus"
"github.com/samcharles93/archie-core/internal/store"
"github.com/samcharles93/archie-core/internal/worktree"
)
// fakeMessage is a minimal eventbus.Message for driving processNATSTask
// without standing up a broker.
type fakeMessage struct {
data []byte
subject string
acked bool
naked bool
}
func (m *fakeMessage) Data() []byte { return m.data }
func (m *fakeMessage) Subject() string { return m.subject }
func (m *fakeMessage) Ack() error { m.acked = true; return nil }
func (m *fakeMessage) Nak() error { m.naked = true; return nil }
var _ eventbus.Message = (*fakeMessage)(nil)
// TestProcessNATSTaskRejectsUnresolvableIdentity pins the intake half of the
// fail-closed relation: a task envelope naming an identity this daemon does
// not know must not be written to the store at all. Today it is enqueued and
// only fails open later, when forgeFor/repoFor fall back to the root forge.
func TestProcessNATSTaskRejectsUnresolvableIdentity(t *testing.T) {
s := store.OpenTest(t)
d := &Daemon{
Store: s,
Cfg: config.NewHolder(config.Config{}),
Trees: &worktree.Manager{},
Log: slog.New(slog.DiscardHandler),
}
data, err := workintake.TaskEnvelope{
Owner: "acme", Repo: "widget", Number: 1, Title: "ghost task",
Identity: "ghost",
}.Encode()
if err != nil {
t.Fatal(err)
}
msg := &fakeMessage{data: data, subject: workintake.SubjectTaskDefault}
d.processNATSTask(t.Context(), msg)
if msg.naked {
t.Fatal("unresolvable identity intake was nacked; a redelivery can never resolve it")
}
if !msg.acked {
t.Fatal("unresolvable identity intake was not dropped (acked)")
}
task, err := s.TaskByIssue(t.Context(), "acme", "widget", 1)
if err != nil {
t.Fatal(err)
}
if task != nil {
t.Fatalf("task %d was created with an unresolvable identity %q", task.ID, task.Identity)
}
}
// TestProcessParksTaskWhoseIdentityNoLongerResolves pins the dispatch half of
// the fail-closed relation: a task whose non-empty identity no longer has a
// configured runner must park, never fall back to the root forge's credential.
func TestProcessParksTaskWhoseIdentityNoLongerResolves(t *testing.T) {
d, s, rootFg, _, _ := twoIdentityDaemon(t)
d.Log = slog.New(slog.DiscardHandler)
ctx := context.Background()
if _, err := s.EnqueueIssue(ctx, "acme", "shared", 42, "t", "b", "", "ghost"); err != nil {
t.Fatal(err)
}
task, err := s.ClaimNext(ctx)
if err != nil || task == nil {
t.Fatalf("ClaimNext = (%+v, %v)", task, err)
}
d.process(ctx, task)
got, err := s.TaskByID(ctx, task.ID)
if err != nil || got == nil {
t.Fatalf("TaskByID = (%+v, %v)", got, err)
}
if got.Status != workflow.StatusParked {
t.Fatalf("status = %q, want parked", got.Status)
}
if !strings.Contains(got.ParkReason, "no longer resolves") {
t.Errorf("ParkReason = %q, want it to name the unresolvable identity", got.ParkReason)
}
// The root forge must not have been touched for this task: parking on an
// identity that no longer resolves is the fail-closed outcome, not a
// fallback to root credentials.
if calls := len(rootFg.stateLabels) + len(rootFg.closedIssues) + len(rootFg.comments); calls != 0 {
t.Errorf("root forge was called %d time(s) for a task with an unresolvable identity", calls)
}
}
// TestProcessParksRetiredIdentity pins the lifecycle half: an identity that
// still has a runner but has been retired may not act, so its tasks park
// rather than running under a credential the control plane has retired.
func TestProcessParksRetiredIdentity(t *testing.T) {
s := store.OpenTest(t)
ctx := context.Background()
log := slog.New(slog.DiscardHandler)
id := identity.StableID("worker")
created, err := identity.New(id, identity.KindBot, "worker")
if err != nil {
t.Fatal(err)
}
created, err = s.Create(ctx, created, identity.Audit{ActorID: identity.SystemID, Source: "test", RequestID: "create"})
if err != nil {
t.Fatal(err)
}
if _, err := s.Apply(ctx, created.ID, created.Version, identity.Command{Type: identity.CommandRetire}, identity.Audit{ActorID: identity.SystemID, Source: "test", RequestID: "retire"}); err != nil {
t.Fatal(err)
}
repo := config.Repo{Owner: "acme", Name: "widget"}
d := &Daemon{
Cfg: config.NewHolder(config.Config{Repos: []config.Repo{repo}}),
Store: s,
Log: log,
IdentityRepository: s,
Identities: []*IdentityRunner{{
Name: "worker", ID: id,
Forge: &testForge{}, Trees: &worktree.Manager{},
Repos: []config.Repo{repo}, Cfg: config.IdentityConfig{Name: "worker"}, Log: log,
}},
}
if _, err := s.EnqueueIssue(ctx, "acme", "widget", 7, "t", "b", "", string(id)); err != nil {
t.Fatal(err)
}
task, err := s.ClaimNext(ctx)
if err != nil || task == nil {
t.Fatalf("ClaimNext = (%+v, %v)", task, err)
}
d.process(ctx, task)
got, err := s.TaskByID(ctx, task.ID)
if err != nil || got == nil {
t.Fatalf("TaskByID = (%+v, %v)", got, err)
}
if got.Status != workflow.StatusParked {
t.Fatalf("status = %q, want parked", got.Status)
}
if !strings.Contains(got.ParkReason, "may not act") {
t.Errorf("ParkReason = %q, want it to name the retired identity", got.ParkReason)
}
}