An operator could only reject work that was waiting on a human decision, so a task sitting in review (PR open) or running had no way to be refused even when it was clearly dangerous. - expose reject in taskstate.Actions for every non-terminal state (queued, running, waiting_human, parked, pr_open) so both the dashboard and the chat tool surface it; terminal states still only expose archive - make rejectTask transition from the task's actual status to closed_wont_do and interrupt running execution first, so nothing keeps working against a task being closed out - keep the distinct stop (recoverable → parked) semantics; reject is the terminal escape hatch - update the lifecycle contract tests to the new intent
409 lines
15 KiB
Go
409 lines
15 KiB
Go
package gateway
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/samcharles93/archie-core/internal/taskstate"
|
|
)
|
|
|
|
// ── StoreTaskCreator ─────────────────────────────────────────────────
|
|
|
|
type fakeChatTaskWriter struct {
|
|
owner, repo, title, body, workflow, identity string
|
|
calls int
|
|
nextID int64
|
|
err error
|
|
}
|
|
|
|
func (f *fakeChatTaskWriter) EnqueueChatTask(ctx context.Context, owner, repo, title, body, workflow, identity string) (int64, error) {
|
|
f.owner, f.repo, f.title, f.body, f.workflow, f.identity = owner, repo, title, body, workflow, identity
|
|
f.calls++
|
|
if f.err != nil {
|
|
return 0, f.err
|
|
}
|
|
f.nextID++
|
|
return f.nextID, nil
|
|
}
|
|
|
|
func TestStoreTaskCreatorCreatesTask(t *testing.T) {
|
|
sw := &fakeChatTaskWriter{}
|
|
tc := NewStoreTaskCreator(sw, "acme", "example-service", []string{"acme/example-service"})
|
|
id, err := tc.CreateTask(context.Background(), SpawnRequest{Title: "Fix the login bug"})
|
|
if err != nil {
|
|
t.Fatalf("CreateTask: %v", err)
|
|
}
|
|
if id == 0 {
|
|
t.Error("task id should be non-zero")
|
|
}
|
|
if sw.owner != "acme" || sw.repo != "example-service" {
|
|
t.Errorf("owner/repo = %s/%s, want acme/example-service", sw.owner, sw.repo)
|
|
}
|
|
if sw.title != "Fix the login bug" {
|
|
t.Errorf("title = %q", sw.title)
|
|
}
|
|
}
|
|
|
|
func TestStoreTaskCreatorRejectsEmptyRepo(t *testing.T) {
|
|
tc := NewStoreTaskCreator(&fakeChatTaskWriter{}, "", "", nil)
|
|
_, err := tc.CreateTask(context.Background(), SpawnRequest{Title: "something"})
|
|
if err == nil || !strings.Contains(err.Error(), "no repo configured") {
|
|
t.Errorf("err = %v, want 'no repo configured'", err)
|
|
}
|
|
}
|
|
|
|
func TestStoreTaskCreatorDelegatesIssueNumberAllocation(t *testing.T) {
|
|
sw := &fakeChatTaskWriter{}
|
|
tc := NewStoreTaskCreator(sw, "acme", "example-service", []string{"acme/example-service"})
|
|
if _, err := tc.CreateTask(context.Background(), SpawnRequest{Title: "first"}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := tc.CreateTask(context.Background(), SpawnRequest{Title: "second"}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if sw.calls != 2 {
|
|
t.Fatalf("EnqueueChatTask calls = %d, want 2", sw.calls)
|
|
}
|
|
}
|
|
|
|
func TestStoreTaskCreatorReturnsRealID(t *testing.T) {
|
|
// The task ID returned to chat must be the store's real database
|
|
// ID returned by EnqueueChatTask.
|
|
sw := &fakeChatTaskWriter{nextID: 999}
|
|
tc := NewStoreTaskCreator(sw, "acme", "example-service", []string{"acme/example-service"})
|
|
id, err := tc.CreateTask(context.Background(), SpawnRequest{Title: "task"})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if id != 1000 {
|
|
t.Errorf("id = %d, want 1000 (fake's nextID+1)", id)
|
|
}
|
|
}
|
|
|
|
func TestStoreTaskCreatorExplicitRepoAllowed(t *testing.T) {
|
|
sw := &fakeChatTaskWriter{}
|
|
tc := NewStoreTaskCreator(sw, "acme", "example-service", []string{"acme/example-service", "acme/archie-core"})
|
|
_, err := tc.CreateTask(context.Background(), SpawnRequest{Title: "x", Repo: "acme/archie-core"})
|
|
if err != nil {
|
|
t.Fatalf("CreateTask: %v", err)
|
|
}
|
|
if sw.owner != "acme" || sw.repo != "archie-core" {
|
|
t.Errorf("owner/repo = %s/%s, want acme/archie-core", sw.owner, sw.repo)
|
|
}
|
|
}
|
|
|
|
func TestStoreTaskCreatorExplicitRepoNotAllowedRejected(t *testing.T) {
|
|
sw := &fakeChatTaskWriter{}
|
|
tc := NewStoreTaskCreator(sw, "acme", "example-service", []string{"acme/example-service"})
|
|
_, err := tc.CreateTask(context.Background(), SpawnRequest{Title: "x", Repo: "someone-else/private-repo"})
|
|
if err == nil || !strings.Contains(err.Error(), "not configured for this identity") {
|
|
t.Errorf("err = %v, want repo-not-allowed error", err)
|
|
}
|
|
if sw.calls != 0 {
|
|
t.Error("EnqueueChatTask must not be called for a disallowed repo")
|
|
}
|
|
}
|
|
|
|
func TestStoreTaskCreatorMalformedRepoRejected(t *testing.T) {
|
|
tc := NewStoreTaskCreator(&fakeChatTaskWriter{}, "acme", "example-service", []string{"no-slash"})
|
|
_, err := tc.CreateTask(context.Background(), SpawnRequest{Title: "x", Repo: "no-slash"})
|
|
if err == nil || !strings.Contains(err.Error(), "owner/name") {
|
|
t.Errorf("err = %v, want owner/name format error", err)
|
|
}
|
|
}
|
|
|
|
func TestStoreTaskCreatorPropagatesWorkflowAndIdentity(t *testing.T) {
|
|
sw := &fakeChatTaskWriter{}
|
|
tc := NewStoreTaskCreator(sw, "acme", "example-service", []string{"acme/example-service"})
|
|
_, err := tc.CreateTask(context.Background(), SpawnRequest{Title: "x", Workflow: "tdd", Identity: "archie"})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if sw.workflow != "tdd" || sw.identity != "archie" {
|
|
t.Errorf("workflow/identity = %s/%s, want tdd/archie", sw.workflow, sw.identity)
|
|
}
|
|
}
|
|
|
|
func TestStoreTaskCreatorPropagatesStoreError(t *testing.T) {
|
|
sw := &fakeChatTaskWriter{err: fmt.Errorf("store unavailable")}
|
|
tc := NewStoreTaskCreator(sw, "acme", "example-service", []string{"acme/example-service"})
|
|
_, err := tc.CreateTask(context.Background(), SpawnRequest{Title: "x"})
|
|
if err == nil || !strings.Contains(err.Error(), "store unavailable") {
|
|
t.Errorf("err = %v, want store error propagated", err)
|
|
}
|
|
}
|
|
|
|
func TestStoreTaskCreatorSelectsIdentityProfile(t *testing.T) {
|
|
sw := &fakeChatTaskWriter{}
|
|
tc := NewStoreTaskCreatorForProfiles(sw, []TaskProfile{
|
|
{Identity: "builder", DefaultOwner: "acme", DefaultRepo: "archie-core", Repos: []string{"acme/archie-core"}},
|
|
{Identity: "reviewer", DefaultOwner: "acme", DefaultRepo: "example-service", Repos: []string{"acme/example-service"}},
|
|
})
|
|
|
|
_, err := tc.CreateTask(context.Background(), SpawnRequest{Title: "review this", Identity: "reviewer"})
|
|
if err != nil {
|
|
t.Fatalf("CreateTask: %v", err)
|
|
}
|
|
if sw.owner != "acme" || sw.repo != "example-service" || sw.identity != "reviewer" {
|
|
t.Errorf("created task = %s/%s identity=%s, want acme/example-service identity=reviewer", sw.owner, sw.repo, sw.identity)
|
|
}
|
|
}
|
|
|
|
func TestStoreTaskCreatorRejectsUnknownIdentity(t *testing.T) {
|
|
sw := &fakeChatTaskWriter{}
|
|
tc := NewStoreTaskCreatorForProfiles(sw, []TaskProfile{
|
|
{Identity: "builder", DefaultOwner: "acme", DefaultRepo: "archie-core", Repos: []string{"acme/archie-core"}},
|
|
})
|
|
|
|
_, err := tc.CreateTask(context.Background(), SpawnRequest{Title: "x", Identity: "unknown"})
|
|
if err == nil || !strings.Contains(err.Error(), "identity") {
|
|
t.Errorf("err = %v, want unknown identity error", err)
|
|
}
|
|
if sw.calls != 0 {
|
|
t.Error("EnqueueChatTask must not be called for an unknown identity")
|
|
}
|
|
}
|
|
|
|
// ── StoreTaskController ──────────────────────────────────────────────
|
|
|
|
type fakeChatTaskStore struct {
|
|
statuses map[int64]ChatTaskStatus
|
|
approved []int64
|
|
cancelled []int64
|
|
lookupErr error
|
|
}
|
|
|
|
func (f *fakeChatTaskStore) ChatTaskStatus(ctx context.Context, taskID int64) (ChatTaskStatus, bool, error) {
|
|
if f.lookupErr != nil {
|
|
return ChatTaskStatus{}, false, f.lookupErr
|
|
}
|
|
st, ok := f.statuses[taskID]
|
|
return st, ok, nil
|
|
}
|
|
|
|
func (f *fakeChatTaskStore) ApproveChatTask(ctx context.Context, taskID int64) error {
|
|
f.approved = append(f.approved, taskID)
|
|
return nil
|
|
}
|
|
|
|
func (f *fakeChatTaskStore) CancelChatTask(ctx context.Context, taskID int64, reason string) error {
|
|
f.cancelled = append(f.cancelled, taskID)
|
|
return nil
|
|
}
|
|
|
|
func TestStoreTaskControllerApproveWaitingHuman(t *testing.T) {
|
|
store := &fakeChatTaskStore{statuses: map[int64]ChatTaskStatus{1: {Status: taskstate.WaitingHuman}}}
|
|
c := NewStoreTaskController(store)
|
|
if err := c.Approve(context.Background(), 1, ""); err != nil {
|
|
t.Fatalf("Approve: %v", err)
|
|
}
|
|
if len(store.approved) != 1 || store.approved[0] != 1 {
|
|
t.Errorf("approved = %v, want [1]", store.approved)
|
|
}
|
|
}
|
|
|
|
func TestStoreTaskControllerApproveRejectsWrongStatus(t *testing.T) {
|
|
for _, status := range []string{"queued", "running", "pr_open", "merged"} {
|
|
store := &fakeChatTaskStore{statuses: map[int64]ChatTaskStatus{1: {Status: status}}}
|
|
c := NewStoreTaskController(store)
|
|
err := c.Approve(context.Background(), 1, "")
|
|
if err == nil {
|
|
t.Errorf("status %s: expected error, got nil", status)
|
|
}
|
|
if len(store.approved) != 0 {
|
|
t.Errorf("status %s: ApproveChatTask must not be called", status)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestStoreTaskControllerApproveTaskNotFound(t *testing.T) {
|
|
c := NewStoreTaskController(&fakeChatTaskStore{statuses: map[int64]ChatTaskStatus{}})
|
|
err := c.Approve(context.Background(), 99, "")
|
|
if err == nil || !strings.Contains(err.Error(), "not found") {
|
|
t.Errorf("err = %v, want not-found error", err)
|
|
}
|
|
}
|
|
|
|
func TestStoreTaskControllerApproveCrossIdentityRejected(t *testing.T) {
|
|
store := &fakeChatTaskStore{statuses: map[int64]ChatTaskStatus{1: {Status: taskstate.WaitingHuman, Identity: "archie"}}}
|
|
c := NewStoreTaskController(store)
|
|
err := c.Approve(context.Background(), 1, "winter")
|
|
if err == nil || !strings.Contains(err.Error(), "different identity") {
|
|
t.Errorf("err = %v, want cross-identity rejection", err)
|
|
}
|
|
if len(store.approved) != 0 {
|
|
t.Error("ApproveChatTask must not be called across identities")
|
|
}
|
|
}
|
|
|
|
func TestStoreTaskControllerApproveSameIdentityAllowed(t *testing.T) {
|
|
store := &fakeChatTaskStore{statuses: map[int64]ChatTaskStatus{1: {Status: taskstate.WaitingHuman, Identity: "archie"}}}
|
|
c := NewStoreTaskController(store)
|
|
if err := c.Approve(context.Background(), 1, "archie"); err != nil {
|
|
t.Fatalf("Approve: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestStoreTaskControllerRejectsCallerIdentityForLegacyTask(t *testing.T) {
|
|
store := &fakeChatTaskStore{statuses: map[int64]ChatTaskStatus{1: {Status: taskstate.WaitingHuman}}}
|
|
c := NewStoreTaskController(store)
|
|
if err := c.Approve(context.Background(), 1, "anyone"); err == nil || !strings.Contains(err.Error(), "different identity") {
|
|
t.Fatalf("Approve error = %v, want cross-identity rejection", err)
|
|
}
|
|
}
|
|
|
|
func TestStoreTaskControllerCancelActiveStates(t *testing.T) {
|
|
for _, status := range []string{taskstate.Queued, taskstate.WaitingHuman, taskstate.Parked} {
|
|
store := &fakeChatTaskStore{statuses: map[int64]ChatTaskStatus{1: {Status: status}}}
|
|
c := NewStoreTaskController(store)
|
|
if err := c.Cancel(context.Background(), 1, ""); err != nil {
|
|
t.Errorf("status %s: Cancel: %v", status, err)
|
|
}
|
|
if len(store.cancelled) != 1 {
|
|
t.Errorf("status %s: CancelChatTask should be called", status)
|
|
}
|
|
}
|
|
}
|
|
|
|
// fakeTaskRuntime records the interruptions a controller asks for.
|
|
type fakeTaskRuntime struct {
|
|
cancelled []int64
|
|
running bool
|
|
stopped []int64
|
|
identity string
|
|
}
|
|
|
|
func (f *fakeTaskRuntime) CancelTask(taskID int64) bool {
|
|
f.cancelled = append(f.cancelled, taskID)
|
|
return f.running
|
|
}
|
|
|
|
func (f *fakeTaskRuntime) CancelRunningTasks(identity string) []int64 {
|
|
f.identity = identity
|
|
return f.stopped
|
|
}
|
|
|
|
// TestStoreTaskControllerCancelInterruptsRunning covers the case that used
|
|
// to be refused. A running task is the only one worth interrupting, so
|
|
// cancelling it must reach the work and then record the outcome.
|
|
func TestStoreTaskControllerCancelInterruptsRunning(t *testing.T) {
|
|
store := &fakeChatTaskStore{statuses: map[int64]ChatTaskStatus{1: {Status: taskstate.Running}}}
|
|
rt := &fakeTaskRuntime{running: true}
|
|
c := NewStoreTaskController(store).WithRuntime(rt)
|
|
|
|
if err := c.Cancel(context.Background(), 1, ""); err != nil {
|
|
t.Fatalf("Cancel: %v", err)
|
|
}
|
|
if len(rt.cancelled) != 1 || rt.cancelled[0] != 1 {
|
|
t.Errorf("runtime cancellations = %v, want [1]; the task kept running", rt.cancelled)
|
|
}
|
|
if len(store.cancelled) != 1 {
|
|
t.Error("the cancellation was not recorded in the store")
|
|
}
|
|
}
|
|
|
|
// TestStoreTaskControllerCancelRecordsStaleRunning covers a task the store
|
|
// calls running that nothing is executing -- a crashed or replaced daemon.
|
|
// Recording the terminal state is what unsticks it.
|
|
func TestStoreTaskControllerCancelRecordsStaleRunning(t *testing.T) {
|
|
store := &fakeChatTaskStore{statuses: map[int64]ChatTaskStatus{1: {Status: taskstate.Running}}}
|
|
rt := &fakeTaskRuntime{running: false}
|
|
c := NewStoreTaskController(store).WithRuntime(rt)
|
|
|
|
if err := c.Cancel(context.Background(), 1, ""); err != nil {
|
|
t.Fatalf("Cancel: %v", err)
|
|
}
|
|
if len(store.cancelled) != 1 {
|
|
t.Error("a stale running task was left stuck")
|
|
}
|
|
}
|
|
|
|
// TestStoreTaskControllerCancelWithoutRuntimeRefusesRunning keeps the
|
|
// refusal honest when nothing can interrupt the work: recording the task
|
|
// as cancelled while it carries on would be a lie.
|
|
func TestStoreTaskControllerCancelWithoutRuntimeRefusesRunning(t *testing.T) {
|
|
store := &fakeChatTaskStore{statuses: map[int64]ChatTaskStatus{1: {Status: taskstate.Running}}}
|
|
c := NewStoreTaskController(store)
|
|
|
|
err := c.Cancel(context.Background(), 1, "")
|
|
if err == nil || !strings.Contains(err.Error(), "no runtime control") {
|
|
t.Errorf("err = %v, want a refusal naming the missing runtime", err)
|
|
}
|
|
if len(store.cancelled) != 0 {
|
|
t.Error("CancelChatTask must not be called when the task cannot be interrupted")
|
|
}
|
|
}
|
|
|
|
// TestStoreTaskControllerStopRunningIsIdentityScoped checks the agent half
|
|
// of /stop reaches the runtime and stays within the caller's identity.
|
|
func TestStoreTaskControllerStopRunningIsIdentityScoped(t *testing.T) {
|
|
rt := &fakeTaskRuntime{stopped: []int64{4, 7}}
|
|
c := NewStoreTaskController(&fakeChatTaskStore{statuses: map[int64]ChatTaskStatus{}}).WithRuntime(rt)
|
|
|
|
stopped, err := c.StopRunning(context.Background(), "archie")
|
|
if err != nil {
|
|
t.Fatalf("StopRunning: %v", err)
|
|
}
|
|
if len(stopped) != 2 || stopped[0] != 4 || stopped[1] != 7 {
|
|
t.Errorf("stopped = %v, want [4 7]", stopped)
|
|
}
|
|
if rt.identity != "archie" {
|
|
t.Errorf("identity = %q, want the caller's identity", rt.identity)
|
|
}
|
|
}
|
|
|
|
func TestStoreTaskControllerStopRunningWithoutRuntime(t *testing.T) {
|
|
c := NewStoreTaskController(&fakeChatTaskStore{statuses: map[int64]ChatTaskStatus{}})
|
|
if _, err := c.StopRunning(context.Background(), ""); err == nil {
|
|
t.Error("StopRunning reported success with no runtime wired")
|
|
}
|
|
}
|
|
|
|
// PROpen is deliberately absent: it is not a terminal state, and reject is
|
|
// now available there so an operator can refuse work still sitting in review.
|
|
// The genuine terminal states must keep refusing cancel.
|
|
func TestStoreTaskControllerCancelRejectsTerminalStates(t *testing.T) {
|
|
for _, status := range []string{
|
|
taskstate.Merged,
|
|
taskstate.Rejected,
|
|
taskstate.Dead,
|
|
taskstate.Declined,
|
|
} {
|
|
store := &fakeChatTaskStore{statuses: map[int64]ChatTaskStatus{1: {Status: status}}}
|
|
c := NewStoreTaskController(store)
|
|
err := c.Cancel(context.Background(), 1, "")
|
|
if err == nil {
|
|
t.Errorf("status %s: expected error, got nil", status)
|
|
}
|
|
if len(store.cancelled) != 0 {
|
|
t.Errorf("status %s: CancelChatTask must not be called", status)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestStoreTaskControllerCancelCrossIdentityRejected(t *testing.T) {
|
|
store := &fakeChatTaskStore{statuses: map[int64]ChatTaskStatus{1: {Status: statusQueuedForTest, Identity: "archie"}}}
|
|
c := NewStoreTaskController(store)
|
|
err := c.Cancel(context.Background(), 1, "winter")
|
|
if err == nil || !strings.Contains(err.Error(), "different identity") {
|
|
t.Errorf("err = %v, want cross-identity rejection", err)
|
|
}
|
|
}
|
|
|
|
func TestStoreTaskControllerLookupErrorPropagates(t *testing.T) {
|
|
store := &fakeChatTaskStore{lookupErr: fmt.Errorf("db unavailable")}
|
|
c := NewStoreTaskController(store)
|
|
if err := c.Approve(context.Background(), 1, ""); err == nil || !strings.Contains(err.Error(), "db unavailable") {
|
|
t.Errorf("Approve err = %v, want lookup error propagated", err)
|
|
}
|
|
if err := c.Cancel(context.Background(), 1, ""); err == nil || !strings.Contains(err.Error(), "db unavailable") {
|
|
t.Errorf("Cancel err = %v, want lookup error propagated", err)
|
|
}
|
|
}
|
|
|
|
// statusQueuedForTest avoids a naming collision with the package's own
|
|
// unexported taskstate.Running/taskstate.WaitingHuman constants in test tables.
|
|
const statusQueuedForTest = "queued"
|