Files
kandev/apps/backend/internal/task/service/service_deferred_launch_test.go
T

436 lines
18 KiB
Go

package service
import (
"context"
"errors"
"fmt"
"testing"
"github.com/kandev/kandev/internal/auth/authn"
"github.com/kandev/kandev/internal/task/models"
"github.com/kandev/kandev/internal/task/repository"
sqliterepo "github.com/kandev/kandev/internal/task/repository/sqlite"
v1 "github.com/kandev/kandev/pkg/api/v1"
"github.com/stretchr/testify/require"
)
const deferredLaunchTaskID = "task-deferred"
func TestCreateTaskPersistsDeferredLaunchOriginUserID(t *testing.T) {
svc, _, repo := createTestService(t)
ctx := authn.WithIdentity(context.Background(), authn.Identity{UserID: "user-created"})
require.NoError(t, repo.CreateWorkspace(ctx, &models.Workspace{ID: "ws-origin", Name: "Origin"}))
require.NoError(t, repo.CreateWorkflow(ctx, &models.Workflow{ID: "wf-origin", WorkspaceID: "ws-origin", Name: "flow"}))
result, err := svc.CreateTask(ctx, &CreateTaskRequest{
WorkspaceID: "ws-origin",
WorkflowID: "wf-origin",
Title: "Deferred task",
StartAgent: true,
RecordAgentProfileRecentUse: true,
DeferredLaunch: map[string]interface{}{
"intent": "start",
"agent_profile_id": "profile-1",
"prompt": "run this later",
},
})
require.NoError(t, err)
launch, ok := result.Task.Metadata[models.MetaKeyDeferredLaunch].(map[string]interface{})
require.True(t, ok, "created task must retain its deferred launch intent")
if got := launch[models.DeferredLaunchUserIDKey]; got != "user-created" {
t.Fatalf("deferred launch user_id = %v, want user-created", got)
}
if got := launch[models.DeferredLaunchRecordRecentUseKey]; got != true {
t.Fatalf("deferred launch record_recent_use = %v, want true", got)
}
}
func TestCreateTaskDoesNotPersistDeferredLaunchOriginUserIDWithoutOptIn(t *testing.T) {
svc, _, repo := createTestService(t)
ctx := authn.WithIdentity(context.Background(), authn.Identity{UserID: "mcp-user"})
require.NoError(t, repo.CreateWorkspace(ctx, &models.Workspace{ID: "ws-mcp", Name: "MCP"}))
require.NoError(t, repo.CreateWorkflow(ctx, &models.Workflow{ID: "wf-mcp", WorkspaceID: "ws-mcp", Name: "flow"}))
result, err := svc.CreateTask(ctx, &CreateTaskRequest{
WorkspaceID: "ws-mcp",
WorkflowID: "wf-mcp",
Title: "MCP deferred task",
StartAgent: true,
DeferredLaunch: map[string]interface{}{
"intent": "start",
"agent_profile_id": "profile-mcp",
"prompt": "run this later",
},
})
require.NoError(t, err)
launch, ok := result.Task.Metadata[models.MetaKeyDeferredLaunch].(map[string]interface{})
require.True(t, ok, "created task must retain its deferred launch intent")
if _, exists := launch[models.DeferredLaunchUserIDKey]; exists {
t.Fatalf("deferred launch user_id = %v, want no recency attribution without opt-in", launch[models.DeferredLaunchUserIDKey])
}
}
func TestUpdateTaskCannotReplaceDeferredLaunchAttribution(t *testing.T) {
svc, _, repo := createTestService(t)
ctx := context.Background()
require.NoError(t, repo.CreateWorkspace(ctx, &models.Workspace{ID: "ws-protected", Name: "Protected"}))
require.NoError(t, repo.CreateWorkflow(ctx, &models.Workflow{ID: "wf-protected", WorkspaceID: "ws-protected", Name: "flow"}))
require.NoError(t, repo.CreateTask(ctx, &models.Task{
ID: "task-protected", WorkspaceID: "ws-protected", WorkflowID: "wf-protected",
Title: "Protected deferred task", State: v1.TaskStateCreated,
Metadata: map[string]interface{}{
models.MetaKeyDeferredLaunch: map[string]interface{}{
"intent": "start",
"agent_profile_id": "profile-protected",
models.DeferredLaunchUserIDKey: "user-a",
models.DeferredLaunchRecordRecentUseKey: true,
},
},
}))
attackerCtx := authn.WithIdentity(ctx, authn.Identity{UserID: "user-b"})
_, err := svc.UpdateTask(attackerCtx, "task-protected", &UpdateTaskRequest{
Metadata: map[string]interface{}{
"ordinary": "allowed",
models.MetaKeyDeferredLaunch: map[string]interface{}{
"intent": "start",
"agent_profile_id": "profile-protected",
models.DeferredLaunchUserIDKey: "user-b",
models.DeferredLaunchRecordRecentUseKey: true,
},
},
})
require.NoError(t, err)
updated, err := repo.GetTask(ctx, "task-protected")
require.NoError(t, err)
launch, ok := updated.Metadata[models.MetaKeyDeferredLaunch].(map[string]interface{})
require.True(t, ok, "deferred launch attribution must survive generic metadata updates")
if got := launch[models.DeferredLaunchUserIDKey]; got != "user-a" {
t.Fatalf("deferred launch user_id = %v, want immutable user-a", got)
}
if got := updated.Metadata["ordinary"]; got != "allowed" {
t.Fatalf("ordinary metadata = %v, want the caller's update preserved", got)
}
_, err = svc.UpdateTaskMetadata(attackerCtx, "task-protected", map[string]interface{}{
"ordinary_from_merge": "allowed",
models.MetaKeyDeferredLaunch: map[string]interface{}{
models.DeferredLaunchUserIDKey: "user-b",
models.DeferredLaunchRecordRecentUseKey: true,
},
})
require.NoError(t, err)
updated, err = repo.GetTask(ctx, "task-protected")
require.NoError(t, err)
launch, ok = updated.Metadata[models.MetaKeyDeferredLaunch].(map[string]interface{})
require.True(t, ok, "deferred launch attribution must survive metadata merges")
if got := launch[models.DeferredLaunchUserIDKey]; got != "user-a" {
t.Fatalf("merged deferred launch user_id = %v, want immutable user-a", got)
}
if got := updated.Metadata["ordinary_from_merge"]; got != "allowed" {
t.Fatalf("ordinary metadata from merge = %v, want the caller's update preserved", got)
}
}
// seedDeferredLaunchTask creates a task carrying a pending start-when-unblocked
// deferred launch, matching what create_task_kandev with blocked_by leaves.
func seedDeferredLaunchTask(t *testing.T, repo *sqliterepo.Repository) {
t.Helper()
ctx := context.Background()
if err := repo.CreateWorkspace(ctx, &models.Workspace{ID: "ws-defer", Name: "Defer"}); err != nil {
t.Fatalf("create workspace: %v", err)
}
if err := repo.CreateWorkflow(ctx, &models.Workflow{ID: "wf-defer", WorkspaceID: "ws-defer", Name: "flow"}); err != nil {
t.Fatalf("create workflow: %v", err)
}
if err := repo.CreateTask(ctx, &models.Task{
ID: deferredLaunchTaskID, WorkspaceID: "ws-defer", WorkflowID: "wf-defer",
Title: "Chain step", State: v1.TaskStateCreated,
Metadata: map[string]interface{}{
models.MetaKeyDeferredLaunch: map[string]interface{}{
"intent": "start",
"agent_profile_id": "profile-1",
"prompt": "the brief written before the work started",
models.DeferredLaunchStartWhenUnblockedKey: true,
},
},
}); err != nil {
t.Fatalf("create task: %v", err)
}
}
func storedLaunch(t *testing.T, repo *sqliterepo.Repository) map[string]interface{} {
t.Helper()
task, err := repo.GetTask(context.Background(), deferredLaunchTaskID)
if err != nil {
t.Fatalf("GetTask: %v", err)
}
launch, ok := task.Metadata[models.MetaKeyDeferredLaunch].(map[string]interface{})
if !ok {
t.Fatalf("metadata = %v, want a deferred launch record", task.Metadata)
}
return launch
}
// The bug 4 fix: a pending launch's prompt can be corrected before it fires.
// The rest of the record must survive, or the corrected launch would run
// without its agent profile.
func TestUpdateDeferredLaunchPromptReplacesOnlyThePrompt(t *testing.T) {
svc, _, repo := createTestService(t)
seedDeferredLaunchTask(t, repo)
if _, err := svc.UpdateDeferredLaunchPrompt(
context.Background(), deferredLaunchTaskID, "what we actually learned"); err != nil {
t.Fatalf("UpdateDeferredLaunchPrompt: %v", err)
}
launch := storedLaunch(t, repo)
if launch["prompt"] != "what we actually learned" {
t.Fatalf("prompt = %v, want the replacement", launch["prompt"])
}
if launch["agent_profile_id"] != "profile-1" {
t.Fatalf("agent_profile_id = %v, want the original record preserved", launch["agent_profile_id"])
}
if flag, _ := launch[models.DeferredLaunchStartWhenUnblockedKey].(bool); !flag {
t.Fatal("the start-when-unblocked flag must survive; without it the gate stops recognising the intent")
}
}
func TestUpdateDeferredLaunchPromptPatchesNestedCeilingPayload(t *testing.T) {
svc, _, repo := createTestService(t)
seedDeferredLaunchTask(t, repo)
task, err := repo.GetTask(context.Background(), deferredLaunchTaskID)
require.NoError(t, err)
launch := task.Metadata[models.MetaKeyDeferredLaunch].(map[string]interface{})
launch[models.CeilingDeferredKey] = true
launch[models.CeilingLaunchKindKey] = string(models.CeilingLaunchStart)
launch[models.CeilingLaunchPayloadKey] = map[string]interface{}{
"prompt": "old nested prompt",
"agent_profile_id": "profile-1",
}
require.NoError(t, repo.UpdateTask(context.Background(), task))
_, err = svc.UpdateDeferredLaunchPrompt(context.Background(), deferredLaunchTaskID, "new nested prompt")
require.NoError(t, err)
launch = storedLaunch(t, repo)
nested, ok := launch[models.CeilingLaunchPayloadKey].(map[string]interface{})
require.True(t, ok, "ceiling launch payload must remain an object")
require.Equal(t, "new nested prompt", nested["prompt"])
require.Equal(t, "new nested prompt", launch["prompt"], "legacy top-level prompt remains updated for older readers")
}
// Once the task has a session it is running, and a launch prompt nothing will
// read must not be silently accepted.
func TestUpdateDeferredLaunchPromptRejectsAStartedTask(t *testing.T) {
svc, _, repo := createTestService(t)
seedDeferredLaunchTask(t, repo)
ctx := context.Background()
if err := repo.CreateTaskSession(ctx, &models.TaskSession{
ID: "sess-started", TaskID: deferredLaunchTaskID,
AgentProfileID: "profile-1", State: models.TaskSessionStateRunning, IsPrimary: true,
}); err != nil {
t.Fatalf("create session: %v", err)
}
_, err := svc.UpdateDeferredLaunchPrompt(ctx, deferredLaunchTaskID, "too late")
if !errors.Is(err, ErrDeferredLaunchAlreadyStarted) {
t.Fatalf("err = %v, want ErrDeferredLaunchAlreadyStarted", err)
}
if launch := storedLaunch(t, repo); launch["prompt"] != "the brief written before the work started" {
t.Fatalf("prompt = %v, want the record left untouched", launch["prompt"])
}
}
// A cancelled session still means the task was started, so the rejection is not
// filtered by session state.
func TestUpdateDeferredLaunchPromptRejectsATaskWithOnlyACancelledSession(t *testing.T) {
svc, _, repo := createTestService(t)
seedDeferredLaunchTask(t, repo)
ctx := context.Background()
if err := repo.CreateTaskSession(ctx, &models.TaskSession{
ID: "sess-cancelled", TaskID: deferredLaunchTaskID,
AgentProfileID: "profile-1", State: models.TaskSessionStateCancelled, IsPrimary: true,
}); err != nil {
t.Fatalf("create session: %v", err)
}
if _, err := svc.UpdateDeferredLaunchPrompt(ctx, deferredLaunchTaskID, "too late"); !errors.Is(
err, ErrDeferredLaunchAlreadyStarted) {
t.Fatalf("err = %v, want ErrDeferredLaunchAlreadyStarted", err)
}
}
func TestUpdateDeferredLaunchPromptRejectsATaskWithoutOne(t *testing.T) {
svc, _, repo := createTestService(t)
ctx := context.Background()
if err := repo.CreateWorkspace(ctx, &models.Workspace{ID: "ws-defer", Name: "Defer"}); err != nil {
t.Fatalf("create workspace: %v", err)
}
if err := repo.CreateWorkflow(ctx, &models.Workflow{ID: "wf-defer", WorkspaceID: "ws-defer", Name: "flow"}); err != nil {
t.Fatalf("create workflow: %v", err)
}
if err := repo.CreateTask(ctx, &models.Task{
ID: deferredLaunchTaskID, WorkspaceID: "ws-defer", WorkflowID: "wf-defer",
Title: "Ordinary", State: v1.TaskStateCreated,
}); err != nil {
t.Fatalf("create task: %v", err)
}
if _, err := svc.UpdateDeferredLaunchPrompt(ctx, deferredLaunchTaskID, "hello"); !errors.Is(
err, ErrNoPendingDeferredLaunch) {
t.Fatalf("err = %v, want ErrNoPendingDeferredLaunch", err)
}
}
// Blanking the prompt would make the launch silently fall back to the task
// description, which is a different operation from correcting a brief.
func TestUpdateDeferredLaunchPromptRejectsABlankPrompt(t *testing.T) {
svc, _, repo := createTestService(t)
seedDeferredLaunchTask(t, repo)
if _, err := svc.UpdateDeferredLaunchPrompt(
context.Background(), deferredLaunchTaskID, " \n "); !errors.Is(err, ErrDeferredLaunchPromptEmpty) {
t.Fatalf("err = %v, want ErrDeferredLaunchPromptEmpty", err)
}
if launch := storedLaunch(t, repo); launch["prompt"] != "the brief written before the work started" {
t.Fatalf("prompt = %v, want the record left untouched", launch["prompt"])
}
}
// racingSessionRepo fires a concurrent start at the exact point the prompt
// update is vulnerable: after it has decided the task has no session, before it
// writes. Deterministic — the interleaving is the seam, not a sleep.
type racingSessionRepo struct {
repository.SessionRepository
tasks *sqliterepo.Repository
fired bool
}
func (r *racingSessionRepo) ListTaskSessions(ctx context.Context, taskID string) ([]*models.TaskSession, error) {
sessions, err := r.SessionRepository.ListTaskSessions(ctx, taskID)
if err != nil || r.fired {
return sessions, err
}
r.fired = true
// The task starts right now: the start path claims the intent atomically,
// exactly as consumeDeferredLaunchOnStart's claim does.
if _, removeErr := r.tasks.RemoveTaskMetadataKey(ctx, taskID, models.MetaKeyDeferredLaunch); removeErr != nil {
return nil, removeErr
}
return sessions, nil
}
// racingDeferredLaunchCASRepo injects a concurrent, successful
// SetTaskDeferredLaunchIfUnchanged write between the first
// GetTaskDeferredLaunch read UpdateDeferredLaunchPrompt performs and its own
// compare-and-set write — modelling the session ceiling's own CAS writers
// (for example the replay sweeper) mutating the record while the prompt
// edit is mid-flight. Deterministic: the interleaving is the seam, not a
// sleep.
type racingDeferredLaunchCASRepo struct {
repository.TaskRepository
taskID string
fired bool
}
func (r *racingDeferredLaunchCASRepo) GetTaskDeferredLaunch(
ctx context.Context, taskID string,
) (map[string]interface{}, interface{}, error) {
launch, prior, err := r.TaskRepository.GetTaskDeferredLaunch(ctx, taskID)
if err != nil || r.fired || taskID != r.taskID {
return launch, prior, err
}
r.fired = true
concurrent := make(map[string]interface{}, len(launch)+1)
for k, v := range launch {
concurrent[k] = v
}
concurrent["ceiling_deferred"] = true
if _, lostCompare, casErr := r.SetTaskDeferredLaunchIfUnchanged(
ctx, taskID, prior, concurrent); casErr != nil || lostCompare {
return nil, nil, fmt.Errorf(
"failed to inject concurrent deferred launch write: lostCompare=%v err=%v", lostCompare, casErr)
}
// Return the pre-race snapshot: this call models the read a caller already
// performed before the concurrent write landed.
return launch, prior, nil
}
// The ceiling-CAS-bypass race F2 exists to fix: a concurrent, legitimate
// write to deferred_launch (the session ceiling's own CAS writers) landing
// between UpdateDeferredLaunchPrompt's read and its write must not be
// silently clobbered by a stale read-modify-write. Before the fix, the write
// went through SetTaskMetadataKeyIfPresent — a presence-only predicate that
// only checks the key still exists, not that its value is unchanged — so it
// happily overwrote the concurrent writer's change with a stale copy plus
// just the new prompt.
func TestUpdateDeferredLaunchPromptSurvivesAConcurrentCeilingWrite(t *testing.T) {
svc, _, repo := createTestService(t)
seedDeferredLaunchTask(t, repo)
racing := &racingDeferredLaunchCASRepo{TaskRepository: repo, taskID: deferredLaunchTaskID}
svc.tasks = racing
if _, err := svc.UpdateDeferredLaunchPrompt(
context.Background(), deferredLaunchTaskID, "what we actually learned"); err != nil {
t.Fatalf("UpdateDeferredLaunchPrompt: %v", err)
}
if !racing.fired {
t.Fatal("the fixture never injected the concurrent ceiling write; the test proved nothing")
}
launch := storedLaunch(t, repo)
if launch["prompt"] != "what we actually learned" {
t.Fatalf("prompt = %v, want the replacement", launch["prompt"])
}
if launch["agent_profile_id"] != "profile-1" {
t.Fatalf("agent_profile_id = %v, want the original record preserved", launch["agent_profile_id"])
}
if launch["ceiling_deferred"] != true {
t.Fatal("the concurrent ceiling write must survive; a stale read-modify-write clobbered it")
}
}
// The resurrection race, reported independently by three reviewers on #2660.
//
// A read-modify-write prompt edit re-creates the metadata key when a start
// consumes it between the read and the write, because UpdateTask persists the
// whole metadata blob it read earlier. The gate then finds a live intent on a
// task that is already running and launches a second session — the exact bug
// this PR exists to fix, reintroduced through the editing path.
//
// The conditional single-key write makes the start win: nothing is written and
// the caller is told the task started.
func TestUpdateDeferredLaunchPromptLosesToAConcurrentStart(t *testing.T) {
var racing *racingSessionRepo
svc, _, repo := createTestServiceWithSessionsRepo(t, func(r *sqliterepo.Repository) repository.SessionRepository {
racing = &racingSessionRepo{SessionRepository: r, tasks: r}
return racing
})
seedDeferredLaunchTask(t, repo)
_, err := svc.UpdateDeferredLaunchPrompt(context.Background(), deferredLaunchTaskID, "a prompt nothing will read")
if !errors.Is(err, ErrDeferredLaunchAlreadyStarted) {
t.Fatalf("err = %v, want ErrDeferredLaunchAlreadyStarted", err)
}
if !racing.fired {
t.Fatal("the fixture never injected the concurrent start; the test proved nothing")
}
task, getErr := repo.GetTask(context.Background(), deferredLaunchTaskID)
if getErr != nil {
t.Fatalf("GetTask: %v", getErr)
}
if _, resurrected := task.Metadata[models.MetaKeyDeferredLaunch]; resurrected {
t.Fatal("the prompt edit resurrected a launch intent the start had consumed; " +
"the gate can now gate-launch a second session on a running task")
}
}