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