Files
kandev/apps/backend/internal/office/service/taskless_lifecycle_test.go
T

329 lines
14 KiB
Go

package service_test
import (
"context"
"encoding/json"
"errors"
"fmt"
"testing"
"time"
"github.com/kandev/kandev/internal/agent/runtime/lifecycle"
"github.com/kandev/kandev/internal/agentctl/types/streams"
"github.com/kandev/kandev/internal/events"
"github.com/kandev/kandev/internal/events/bus"
"github.com/kandev/kandev/internal/office/models"
"github.com/kandev/kandev/internal/office/service"
)
type tasklessTestLauncher struct {
svc *service.Service
calls []service.LaunchContext
next int
}
func (l *tasklessTestLauncher) StartRunSession(
ctx context.Context, run *models.Run, agent *models.AgentInstance,
launch service.LaunchContext, _ *service.RouteOverride,
) (service.RunSessionLaunch, error) {
l.calls = append(l.calls, launch)
l.next++
id := fmt.Sprintf("run-session-%d", l.next)
now := time.Now().UTC()
session := &models.RunSession{
ID: id, WorkspaceID: agent.WorkspaceID, AgentProfileID: agent.ID,
RunID: run.ID, Attempt: l.next, State: models.RunSessionStatePreparing,
CreatedAt: now, Version: 1,
}
reserved, err := l.svc.RepoForTest().ReserveRunSession(ctx, session)
if err != nil || !reserved {
return service.RunSessionLaunch{}, fmt.Errorf("reserve test run session: reserved=%v err=%w", reserved, err)
}
if _, err := l.svc.RepoForTest().BindRunSessionExecution(
ctx, id, "execution-"+id, launch.ProfileID, "test-adapter", "test-model", "acp-"+id,
); err != nil {
return service.RunSessionLaunch{}, err
}
if _, err := l.svc.RepoForTest().MarkRunSessionStarted(
ctx, id, "execution-"+id, launch.ProfileID, "test-adapter", "test-model", "acp-"+id,
); err != nil {
return service.RunSessionLaunch{}, err
}
return service.RunSessionLaunch{
SessionID: id, ExecutionID: "execution-" + id,
ExecutionProfileID: launch.ProfileID, Adapter: "test-adapter", Model: "test-model",
ACPSessionID: "acp-" + id,
}, nil
}
func TestTasklessRoutineRunLaunchesRunSessionAndCompletes(t *testing.T) {
svc, eb := newTestServiceWithBus(t)
ctx := context.Background()
launcher := &tasklessTestLauncher{svc: svc}
svc.SetRunSessionLauncher(launcher)
agent := &models.AgentInstance{
ID: "taskless-agent", WorkspaceID: "ws-1", Name: "taskless-agent",
Role: models.AgentRoleCEO, Status: models.AgentStatusIdle,
ExecutorPreference: `{"type":"local_pc"}`,
}
if err := svc.CreateAgentInstance(ctx, agent); err != nil {
t.Fatalf("create agent: %v", err)
}
if _, err := svc.QueueRun(ctx, agent.ID, service.RunReasonRoutineTrigger, `{}`, "taskless-test"); err != nil {
t.Fatalf("queue: %v", err)
}
runs, err := svc.ListRuns(ctx, agent.WorkspaceID)
if err != nil || len(runs) != 1 {
t.Fatalf("list queued run: runs=%#v err=%v", runs, err)
}
run := runs[0]
service.RunSchedulerTick(svc, ctx)
if len(launcher.calls) != 1 || launcher.calls[0].Prompt == "" {
t.Fatalf("taskless launch = %#v, want one real prompt", launcher.calls)
}
session, err := svc.RepoForTest().GetRunSession(ctx, "run-session-1")
if err != nil || session == nil || session.State != models.RunSessionStateRunning {
t.Fatalf("run session after launch = %#v, err=%v", session, err)
}
if runs, err := svc.ListRuns(ctx, agent.WorkspaceID); err != nil || len(runs) != 1 || runs[0].SessionID != "run-session-1" {
t.Fatalf("run session projection = runs=%#v err=%v, want run-session-1", runs, err)
}
if err := eb.Publish(ctx, events.AgentCompleted, bus.NewEvent(events.AgentCompleted, "test", lifecycle.AgentEventPayload{
AgentExecutionID: "execution-run-session-1", AgentID: "test-adapter", AgentProfileID: agent.ID,
RunID: run.ID, RunSessionID: "run-session-1", RunAttempt: 1, OwnerKind: lifecycle.ExecutionOwnerRun,
WorkspaceID: agent.WorkspaceID, Status: "COMPLETED",
})); err != nil {
t.Fatalf("publish completion: %v", err)
}
finished, err := svc.RepoForTest().GetRunSession(ctx, "run-session-1")
if err != nil || finished == nil || finished.State != models.RunSessionStateFinished {
t.Fatalf("run session after completion = %#v, err=%v", finished, err)
}
runs, err = svc.ListRuns(ctx, agent.WorkspaceID)
if err != nil || len(runs) != 1 || runs[0].Status != service.RunStatusFinished {
t.Fatalf("runs after completion = %#v, err=%v", runs, err)
}
var tasks int
if err := svc.RepoForTest().ReaderDB().Get(&tasks, `SELECT COUNT(*) FROM tasks WHERE workspace_id = ?`, agent.WorkspaceID); err != nil {
t.Fatalf("count task rows: %v", err)
}
if tasks != 0 {
t.Fatalf("taskless run created %d task rows", tasks)
}
}
func TestTasklessLateCompletionDoesNotFinishSuccessor(t *testing.T) {
svc, eb := newTestServiceWithBus(t)
ctx := context.Background()
launcher := &tasklessTestLauncher{svc: svc}
svc.SetRunSessionLauncher(launcher)
agent := &models.AgentInstance{
ID: "taskless-successor-agent", WorkspaceID: "ws-1", Name: "taskless-successor-agent",
Role: models.AgentRoleCEO, Status: models.AgentStatusIdle,
ExecutorPreference: `{"type":"local_pc"}`,
}
if err := svc.CreateAgentInstance(ctx, agent); err != nil {
t.Fatalf("create agent: %v", err)
}
if _, err := svc.QueueRun(ctx, agent.ID, service.RunReasonRoutineTrigger, `{}`, "first"); err != nil {
t.Fatalf("queue first: %v", err)
}
runs, err := svc.ListRuns(ctx, agent.WorkspaceID)
if err != nil || len(runs) != 1 {
t.Fatalf("list first run: runs=%#v err=%v", runs, err)
}
first := runs[0]
service.RunSchedulerTick(svc, ctx)
if _, err := svc.FinishRun(ctx, first.ID, service.RunOutcomeProcessed); err != nil {
t.Fatalf("finish first: %v", err)
}
if _, err := svc.QueueRun(ctx, agent.ID, service.RunReasonRoutineTrigger, `{}`, "second"); err != nil {
t.Fatalf("queue second: %v", err)
}
runs, err = svc.ListRuns(ctx, agent.WorkspaceID)
if err != nil || len(runs) != 2 {
t.Fatalf("list successor run: runs=%#v err=%v", runs, err)
}
second := runs[0]
if second.ID == first.ID {
second = runs[1]
}
if _, err := svc.RepoForTest().MarkAgentWorking(ctx, agent.ID, second.ID); err != nil {
t.Fatalf("mark successor working: %v", err)
}
if err := eb.Publish(ctx, events.AgentCompleted, bus.NewEvent(events.AgentCompleted, "test", lifecycle.AgentEventPayload{
AgentExecutionID: "execution-run-session-1", AgentID: "test-adapter", AgentProfileID: agent.ID,
RunID: first.ID, RunSessionID: "run-session-1", RunAttempt: 1, OwnerKind: lifecycle.ExecutionOwnerRun,
WorkspaceID: agent.WorkspaceID, Status: "COMPLETED",
})); err != nil {
t.Fatalf("publish stale completion: %v", err)
}
var workingRunID string
if err := svc.RepoForTest().ReaderDB().Get(&workingRunID, `SELECT working_run_id FROM agent_profiles WHERE id = ?`, agent.ID); err != nil {
t.Fatalf("read working run: %v", err)
}
if workingRunID != second.ID {
t.Fatalf("successor working run = %q, want %q", workingRunID, second.ID)
}
}
func TestTasklessUsageDuplicate(t *testing.T) {
svc, eb := newTestServiceWithBus(t)
ctx := context.Background()
launcher := &tasklessTestLauncher{svc: svc}
svc.SetRunSessionLauncher(launcher)
agent := &models.AgentInstance{
ID: "taskless-usage-agent", WorkspaceID: "ws-1", Name: "taskless-usage-agent",
Role: models.AgentRoleCEO, Status: models.AgentStatusIdle,
ExecutorPreference: `{"type":"local_pc"}`,
}
if err := svc.CreateAgentInstance(ctx, agent); err != nil {
t.Fatalf("create agent: %v", err)
}
if _, err := svc.QueueRun(ctx, agent.ID, service.RunReasonRoutineTrigger, `{}`, "usage"); err != nil {
t.Fatalf("queue: %v", err)
}
service.RunSchedulerTick(svc, ctx)
payload := lifecycle.AgentStreamEventPayload{
ExecutionID: "execution-run-session-1", OwnerKind: lifecycle.ExecutionOwnerRun,
WorkspaceID: agent.WorkspaceID, RunID: "", RunSessionID: "run-session-1", RunAttempt: 1,
AgentProfileID: agent.ID, AgentType: "claude-acp",
Data: &lifecycle.AgentStreamEventData{PromptGeneration: 1, TurnID: "turn-1", CurrentModelID: "test-model", Usage: &streams.PromptUsage{InputTokens: 7, OutputTokens: 3, OutputTokensPresent: true, TotalTokens: 10, ProviderReportedCostSubcents: 123, ProviderReportedCostPresent: true}},
}
stale := payload
stale.RunAttempt++
if err := eb.Publish(ctx, events.BuildAgentStreamSubject("run-session-1"), bus.NewEvent(events.AgentStream, "test", stale)); err != nil {
t.Fatal(err)
}
var staleCosts int
if err := svc.RepoForTest().ReaderDB().Get(&staleCosts, `SELECT COUNT(*) FROM office_cost_events`); err != nil {
t.Fatal(err)
}
if staleCosts != 0 {
t.Fatalf("mismatched attempt recorded %d cost events", staleCosts)
}
encoded, err := json.Marshal(payload)
if err != nil {
t.Fatal(err)
}
var wirePayload map[string]interface{}
if err := json.Unmarshal(encoded, &wirePayload); err != nil {
t.Fatal(err)
}
for i := 0; i < 2; i++ {
if err := eb.Publish(ctx, events.BuildAgentStreamSubject("run-session-1"), bus.NewEvent(events.AgentStream, "test", wirePayload)); err != nil {
t.Fatalf("publish usage %d: %v", i, err)
}
}
var costCount int
if err := svc.RepoForTest().ReaderDB().Get(&costCount,
`SELECT COUNT(*) FROM office_cost_events WHERE session_id = ?`, "run-session-1"); err != nil {
t.Fatalf("count costs: %v", err)
}
if costCount != 1 {
t.Fatalf("cost events = %d, want one deduplicated row", costCount)
}
costEvents, err := svc.RepoForTest().ListCostEvents(ctx, agent.WorkspaceID)
if err != nil || len(costEvents) != 1 {
t.Fatalf("workspace costs = %v, err=%v", costEvents, err)
}
for name, read := range map[string]func(context.Context, string) ([]*models.CostBreakdown, error){
"agent": svc.RepoForTest().GetCostsByAgent, "model": svc.RepoForTest().GetCostsByModel,
"provider": svc.RepoForTest().GetCostsByProvider, "project": svc.RepoForTest().GetCostsByProject,
} {
got, err := read(ctx, agent.WorkspaceID)
if err != nil || len(got) != 1 || got[0].Count != 1 {
t.Errorf("%s costs = %#v, err=%v", name, got, err)
}
}
total, err := svc.RepoForTest().SumCosts(ctx, agent.WorkspaceID)
if err != nil || total != 123 {
t.Errorf("total = %d, err=%v", total, err)
}
total, err = svc.RepoForTest().SumCostsSince(ctx, agent.WorkspaceID, time.Now().Add(-time.Hour))
if err != nil || total != 123 {
t.Errorf("period total = %d, err=%v", total, err)
}
runs, err := svc.ListRuns(ctx, agent.WorkspaceID)
if err != nil {
t.Fatal(err)
}
_, rollup, err := svc.RepoForTest().GetRunWithCosts(ctx, runs[0].ID)
if err != nil || rollup.CostSubcents != 123 || rollup.InputTokens != 7 {
t.Errorf("rollup = %#v, err=%v", rollup, err)
}
}
func TestTasklessRoutineReadyCompletesRun(t *testing.T) {
svc, eb := newTestServiceWithBus(t)
ctx := context.Background()
stopper := &fakeRunExecutionStopper{}
svc.SetRunExecutionStopper(stopper)
launcher := &tasklessTestLauncher{svc: svc}
svc.SetRunSessionLauncher(launcher)
agent := &models.AgentInstance{
ID: "taskless-agent", WorkspaceID: "ws-1", Name: "taskless-agent",
Role: models.AgentRoleCEO, Status: models.AgentStatusIdle,
ExecutorPreference: `{"type":"local_pc"}`,
}
if err := svc.CreateAgentInstance(ctx, agent); err != nil {
t.Fatalf("create agent: %v", err)
}
if _, err := svc.QueueRun(ctx, agent.ID, service.RunReasonRoutineTrigger, `{}`, "taskless-test"); err != nil {
t.Fatalf("queue: %v", err)
}
runs, err := svc.ListRuns(ctx, agent.WorkspaceID)
if err != nil || len(runs) != 1 {
t.Fatalf("list queued run: runs=%#v err=%v", runs, err)
}
run := runs[0]
service.RunSchedulerTick(svc, ctx)
if len(launcher.calls) != 1 || launcher.calls[0].Prompt == "" {
t.Fatalf("taskless launch = %#v, want one real prompt", launcher.calls)
}
session, err := svc.RepoForTest().GetRunSession(ctx, "run-session-1")
if err != nil || session == nil || session.State != models.RunSessionStateRunning {
t.Fatalf("run session after launch = %#v, err=%v", session, err)
}
if runs, err := svc.ListRuns(ctx, agent.WorkspaceID); err != nil || len(runs) != 1 || runs[0].SessionID != "run-session-1" {
t.Fatalf("run session projection = runs=%#v err=%v, want run-session-1", runs, err)
}
stopper.err = errors.New("stop failed")
_ = eb.Publish(ctx, events.AgentReady, bus.NewEvent(events.AgentReady, "test", lifecycle.AgentEventPayload{
AgentExecutionID: "execution-run-session-1", AgentProfileID: agent.ID,
RunID: run.ID, RunSessionID: "run-session-1", RunAttempt: 1, OwnerKind: lifecycle.ExecutionOwnerRun, WorkspaceID: agent.WorkspaceID,
}))
stillRunning, err := svc.RepoForTest().GetRunSession(ctx, "run-session-1")
if err != nil || stillRunning.State != models.RunSessionStateRunning {
t.Fatalf("failed stop settled session: %#v, %v", stillRunning, err)
}
stopper.err = nil
stopper.executionIDs = nil
if err := eb.Publish(ctx, events.AgentReady, bus.NewEvent(events.AgentReady, "test", lifecycle.AgentEventPayload{
AgentExecutionID: "execution-run-session-1", AgentID: "test-adapter", AgentProfileID: agent.ID,
RunID: run.ID, RunSessionID: "run-session-1", RunAttempt: 1, OwnerKind: lifecycle.ExecutionOwnerRun,
WorkspaceID: agent.WorkspaceID, Status: "READY",
})); err != nil {
t.Fatalf("publish completion: %v", err)
}
finished, err := svc.RepoForTest().GetRunSession(ctx, "run-session-1")
if err != nil || finished == nil || finished.State != models.RunSessionStateFinished {
t.Fatalf("run session after completion = %#v, err=%v", finished, err)
}
runs, err = svc.ListRuns(ctx, agent.WorkspaceID)
if err != nil || len(runs) != 1 || runs[0].Status != service.RunStatusFinished {
t.Fatalf("runs after completion = %#v, err=%v", runs, err)
}
var tasks int
if err := svc.RepoForTest().ReaderDB().Get(&tasks, `SELECT COUNT(*) FROM tasks WHERE workspace_id = ?`, agent.WorkspaceID); err != nil {
t.Fatalf("count task rows: %v", err)
}
if tasks != 0 {
t.Fatalf("taskless run created %d task rows", tasks)
}
if len(stopper.executionIDs) != 1 || stopper.executionIDs[0] != "execution-run-session-1" {
t.Fatalf("stopped executions = %v", stopper.executionIDs)
}
}