Files
archie/internal/gateway/task_action_tool_test.go
T
sam 4e641478c2 feat(gateway): give the dashboard operator its own task-action contract
archie-core-8cda.5.4 requires /api/tasks/{id}/action to go through
ChatContract rather than a task-action service the UI process composes
itself. The contract could not carry the request: ApplyTaskAction's identity
is a scope, and the daemon's action service distinguishes a named identity
from a nil one, which is the authenticated operator acting across
identities. Sending "" would not have expressed it either -- that is a real
identity in a single-identity deployment (chatTaskProfiles).

ApplyOperatorTaskAction is that case, additively: a separate RPC, so buf
sees no cardinality change on a shipped field, and no request that can carry
both an identity and operator authority. ChatTaskActor's identity becomes a
pointer end to end, from the Gateway's local adapter through the NATS hop to
taskactions.Service.Apply, which has always taken one.

The conformance test now covers both scopes through the local adapter and
the gRPC hop; the chat tool test pins that a chat action is never unscoped.
No caller passes nil yet -- the dashboard handler switches over with the
rest of the cutover.
2026-09-09 23:29:11 +10:00

275 lines
8.0 KiB
Go

package gateway
import (
"context"
"errors"
"fmt"
"strings"
"testing"
"github.com/samcharles93/archie-core/internal/taskstate"
"github.com/samcharles93/archie-core/internal/tools"
)
type fakeActor struct {
result TaskActionResult
err error
gotIdentity string
gotScoped bool
gotTaskID int64
gotAction taskstate.Action
}
func (f *fakeActor) ApplyChatTaskAction(_ context.Context, identity *string, taskID int64, action taskstate.Action) (TaskActionResult, error) {
if identity != nil {
f.gotIdentity = *identity
}
f.gotScoped = identity != nil
f.gotTaskID = taskID
f.gotAction = action
return f.result, f.err
}
func TestTaskActionToolProperties(t *testing.T) {
actor := &fakeActor{}
entry := toolNamed(t, TaskTools(nil, nil, nil, actor, "archie"), "task_action")
if err := entry.Validate(); err != nil {
t.Fatalf("entry.Validate() = %v", err)
}
if entry.Name != "task_action" {
t.Errorf("Name = %q, want task_action", entry.Name)
}
if entry.Toolset != "tasks" {
t.Errorf("Toolset = %q, want tasks", entry.Toolset)
}
wantClass := tools.ClassMutating | tools.RequiresApproval
if entry.Classification != wantClass {
t.Errorf("Classification = %v, want %v", entry.Classification, wantClass)
}
if entry.BuildApprovalDescription == nil {
t.Fatal("BuildApprovalDescription is nil, want a description builder for confirmation")
}
}
func TestTaskActionOmittedWhenActorIsNil(t *testing.T) {
entries := TaskTools(&fakeLister{}, &fakeCreator{}, &fakeLogReader{}, nil, "archie")
for _, e := range entries {
if e.Name == "task_action" {
t.Fatal("task_action is present when actor is nil -- a tool that cannot run must not be advertised")
}
}
}
func TestTaskActionAppearsWhenActorIsNonNil(t *testing.T) {
entries := TaskTools(nil, nil, nil, &fakeActor{}, "archie")
toolNamed(t, entries, "task_action") // fails if absent
}
func TestTaskActionUsesBoundIdentity(t *testing.T) {
actor := &fakeActor{result: TaskActionResult{TaskID: 42, Action: "abandon", Message: "abandoned"}}
entry := toolNamed(t, TaskTools(nil, nil, nil, actor, "archie"), "task_action")
_, err := entry.Handler(context.Background(), map[string]any{
"task_id": float64(42),
"action": "abandon",
"identity": "other-identity",
})
if err != nil {
t.Fatal(err)
}
if actor.gotIdentity != "archie" {
t.Errorf("identity = %q, want bound %q", actor.gotIdentity, "archie")
}
// Scoped, always: an unscoped action is the dashboard operator's
// authorization, and a chat tool must never reach for it.
if !actor.gotScoped {
t.Error("chat tool action arrived unscoped, which authorizes it across every identity")
}
}
func TestTaskActionInputValidation(t *testing.T) {
tests := []struct {
name string
input map[string]any
actor *fakeActor
wantErr bool
wantTaskID int64
wantAction taskstate.Action
}{
{
name: "valid float64 task_id",
input: map[string]any{"task_id": float64(10), "action": "abandon"},
actor: &fakeActor{result: TaskActionResult{TaskID: 10, Action: "abandon"}},
wantTaskID: 10,
wantAction: taskstate.ActionAbandon,
},
{
name: "valid int task_id",
input: map[string]any{"task_id": 11, "action": "archive"},
actor: &fakeActor{result: TaskActionResult{TaskID: 11, Action: "archive"}},
wantTaskID: 11,
wantAction: taskstate.ActionArchive,
},
{
name: "valid int64 task_id",
input: map[string]any{"task_id": int64(12), "action": "retry"},
actor: &fakeActor{result: TaskActionResult{TaskID: 12, Action: "retry"}},
wantTaskID: 12,
wantAction: taskstate.ActionRetry,
},
{
name: "normalizes action casing and whitespace",
input: map[string]any{"task_id": float64(13), "action": " ABANDON "},
actor: &fakeActor{result: TaskActionResult{TaskID: 13, Action: "abandon"}},
wantTaskID: 13,
wantAction: taskstate.ActionAbandon,
},
{
name: "missing task_id",
input: map[string]any{"action": "abandon"},
actor: &fakeActor{},
wantErr: true,
},
{
name: "invalid task_id type",
input: map[string]any{"task_id": "not-a-number", "action": "abandon"},
actor: &fakeActor{},
wantErr: true,
},
{
name: "missing action",
input: map[string]any{"task_id": float64(10)},
actor: &fakeActor{},
wantErr: true,
},
{
name: "blank action",
input: map[string]any{"task_id": float64(10), "action": " "},
actor: &fakeActor{},
wantErr: true,
},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
entry := toolNamed(t, TaskTools(nil, nil, nil, tc.actor, "archie"), "task_action")
out, err := entry.Handler(context.Background(), tc.input)
if tc.wantErr {
if err == nil {
t.Fatalf("Handler(%v) = nil error, want error", tc.input)
}
return
}
if err != nil {
t.Fatalf("Handler(%v) = %v, want nil error", tc.input, err)
}
if tc.actor.gotTaskID != tc.wantTaskID {
t.Errorf("task_id = %d, want %d", tc.actor.gotTaskID, tc.wantTaskID)
}
if tc.actor.gotAction != tc.wantAction {
t.Errorf("action = %q, want %q", tc.actor.gotAction, tc.wantAction)
}
res, ok := out.(TaskActionResult)
if !ok {
t.Fatalf("Handler output = %T, want TaskActionResult", out)
}
if res.TaskID != tc.wantTaskID {
t.Errorf("res.TaskID = %d, want %d", res.TaskID, tc.wantTaskID)
}
})
}
}
func TestTaskActionAllActions(t *testing.T) {
actions := []struct {
action taskstate.Action
input string
}{
{action: taskstate.ActionAbandon, input: "abandon"},
{action: taskstate.ActionArchive, input: "archive"},
{action: taskstate.ActionRetry, input: "retry"},
{action: taskstate.ActionStop, input: "stop"},
{action: taskstate.ActionCancel, input: "cancel"},
{action: taskstate.ActionApprove, input: "approve"},
{action: taskstate.ActionReject, input: "reject"},
}
for _, tc := range actions {
t.Run(string(tc.action), func(t *testing.T) {
actor := &fakeActor{result: TaskActionResult{
TaskID: 99,
Action: string(tc.action),
Message: fmt.Sprintf("Applied %s to task 99.", tc.action),
}}
entry := toolNamed(t, TaskTools(nil, nil, nil, actor, "archie"), "task_action")
out, err := entry.Handler(context.Background(), map[string]any{
"task_id": float64(99),
"action": tc.input,
})
if err != nil {
t.Fatalf("Handler(%s) error = %v", tc.input, err)
}
res, ok := out.(TaskActionResult)
if !ok {
t.Fatalf("Handler output = %T, want TaskActionResult", out)
}
if res.Action != string(tc.action) {
t.Errorf("res.Action = %q, want %q", res.Action, tc.action)
}
})
}
}
func TestTaskActionPropagatesActorError(t *testing.T) {
actor := &fakeActor{err: errors.New("action not available while task is running")}
entry := toolNamed(t, TaskTools(nil, nil, nil, actor, "archie"), "task_action")
_, err := entry.Handler(context.Background(), map[string]any{
"task_id": float64(42),
"action": "abandon",
})
if err == nil {
t.Fatal("expected error, got nil")
}
if !strings.Contains(err.Error(), "action not available while task is running") {
t.Errorf("error = %v, want substring %q", err, "action not available while task is running")
}
}
func TestTaskActionBuildApprovalDescription(t *testing.T) {
tests := []struct {
name string
input map[string]any
want string
}{
{
name: "abandon parked task",
input: map[string]any{"task_id": float64(42), "action": "abandon"},
want: "Apply action \"abandon\" to task 42.",
},
{
name: "archive dead task",
input: map[string]any{"task_id": int64(101), "action": "archive"},
want: "Apply action \"archive\" to task 101.",
},
{
name: "missing fields fallback cleanly",
input: map[string]any{},
want: "Apply action \"\" to task 0.",
},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
actor := &fakeActor{}
entry := toolNamed(t, TaskTools(nil, nil, nil, actor, "archie"), "task_action")
got := entry.BuildApprovalDescription(tc.input)
if got != tc.want {
t.Errorf("BuildApprovalDescription(%v) = %q, want %q", tc.input, got, tc.want)
}
})
}
}