Files
kandev/apps/backend/internal/agent/lifecycle/manager_interaction_test.go
T
2026-02-23 23:54:27 +00:00

335 lines
9.1 KiB
Go

package lifecycle
import (
"context"
"encoding/json"
"net/http"
"net/http/httptest"
"slices"
"sync"
"testing"
"time"
"github.com/gorilla/websocket"
"github.com/kandev/kandev/internal/events"
v1 "github.com/kandev/kandev/pkg/api/v1"
ws "github.com/kandev/kandev/pkg/websocket"
)
type restartMockAgentctlServer struct {
server *httptest.Server
mu sync.Mutex
httpActions []string
wsActions []string
failStop bool
failSessionNew bool
}
func newRestartMockAgentctlServer(t *testing.T, failStop, failSessionNew bool) *restartMockAgentctlServer {
t.Helper()
m := &restartMockAgentctlServer{
failStop: failStop,
failSessionNew: failSessionNew,
}
upgrader := websocket.Upgrader{
CheckOrigin: func(_ *http.Request) bool { return true },
}
mux := http.NewServeMux()
mux.HandleFunc("/health", func(w http.ResponseWriter, _ *http.Request) {
w.WriteHeader(http.StatusOK)
_, _ = w.Write([]byte(`{"ok":true}`))
})
mux.HandleFunc("/api/v1/stop", func(w http.ResponseWriter, _ *http.Request) {
m.recordHTTP("stop")
if m.failStop {
_, _ = w.Write([]byte(`{"success":false,"error":"stop failed"}`))
return
}
_, _ = w.Write([]byte(`{"success":true}`))
})
mux.HandleFunc("/api/v1/agent/configure", func(w http.ResponseWriter, _ *http.Request) {
m.recordHTTP("configure")
_, _ = w.Write([]byte(`{"success":true}`))
})
mux.HandleFunc("/api/v1/start", func(w http.ResponseWriter, _ *http.Request) {
m.recordHTTP("start")
_, _ = w.Write([]byte(`{"success":true,"command":"auggie --model test"}`))
})
mux.HandleFunc("/api/v1/agent/stream", func(w http.ResponseWriter, r *http.Request) {
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
return
}
defer func() { _ = conn.Close() }()
for {
_, message, err := conn.ReadMessage()
if err != nil {
return
}
var msg ws.Message
if err := json.Unmarshal(message, &msg); err != nil {
continue
}
if msg.Type != ws.MessageTypeRequest {
continue
}
m.recordWS(msg.Action)
var resp *ws.Message
switch msg.Action {
case "agent.initialize":
resp, _ = ws.NewResponse(msg.ID, msg.Action, map[string]interface{}{
"success": true,
"agent_info": map[string]string{
"name": "test-agent",
"version": "1.0.0",
},
})
case "agent.session.new":
if m.failSessionNew {
resp, _ = ws.NewResponse(msg.ID, msg.Action, map[string]interface{}{
"success": false,
"error": "session new failed",
})
} else {
resp, _ = ws.NewResponse(msg.ID, msg.Action, map[string]interface{}{
"success": true,
"session_id": "new-session-123",
})
}
default:
resp, _ = ws.NewError(msg.ID, msg.Action, ws.ErrorCodeUnknownAction, "unknown action", nil)
}
data, _ := json.Marshal(resp)
if err := conn.WriteMessage(websocket.TextMessage, data); err != nil {
return
}
}
})
mux.HandleFunc("/api/v1/workspace/stream", func(w http.ResponseWriter, r *http.Request) {
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
return
}
defer func() { _ = conn.Close() }()
connected := map[string]string{"type": "connected"}
data, _ := json.Marshal(connected)
_ = conn.WriteMessage(websocket.TextMessage, data)
for {
if _, _, err := conn.ReadMessage(); err != nil {
return
}
}
})
m.server = httptest.NewServer(mux)
t.Cleanup(m.server.Close)
return m
}
func (m *restartMockAgentctlServer) recordHTTP(action string) {
m.mu.Lock()
defer m.mu.Unlock()
m.httpActions = append(m.httpActions, action)
}
func (m *restartMockAgentctlServer) recordWS(action string) {
m.mu.Lock()
defer m.mu.Unlock()
m.wsActions = append(m.wsActions, action)
}
func (m *restartMockAgentctlServer) getHTTPActions() []string {
m.mu.Lock()
defer m.mu.Unlock()
out := make([]string, len(m.httpActions))
copy(out, m.httpActions)
return out
}
func (m *restartMockAgentctlServer) getWSActions() []string {
m.mu.Lock()
defer m.mu.Unlock()
out := make([]string, len(m.wsActions))
copy(out, m.wsActions)
return out
}
func TestManager_RestartAgentProcess_Success(t *testing.T) {
mgr := newTestManager()
mock := newRestartMockAgentctlServer(t, false, false)
client := createTestClient(t, mock.server.URL)
t.Cleanup(client.Close)
exec := &AgentExecution{
ID: "exec-1",
TaskID: "task-1",
SessionID: "session-1",
AgentProfileID: "profile-1",
ACPSessionID: "old-session",
AgentCommand: "auggie --model test",
Status: v1.AgentStatusRunning,
WorkspacePath: "/workspace",
Metadata: map[string]interface{}{
"task_description": "review the changes",
},
agentctl: client,
promptDoneCh: make(chan PromptCompletionSignal, 1),
}
exec.messageBuffer.WriteString("old-response")
exec.thinkingBuffer.WriteString("old-thinking")
exec.currentMessageID = "msg-1"
exec.currentThinkingID = "th-1"
exec.needsResumeContext = true
exec.resumeContextInjected = true
exec.promptDoneCh <- PromptCompletionSignal{StopReason: "stale"}
mgr.executionStore.Add(exec)
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
defer cancel()
if err := mgr.RestartAgentProcess(ctx, exec.ID); err != nil {
t.Fatalf("RestartAgentProcess failed: %v", err)
}
if exec.ACPSessionID != "new-session-123" {
t.Fatalf("expected new ACP session ID, got %q", exec.ACPSessionID)
}
if exec.Status != v1.AgentStatusReady {
t.Fatalf("expected status %q, got %q", v1.AgentStatusReady, exec.Status)
}
if exec.messageBuffer.Len() != 0 || exec.thinkingBuffer.Len() != 0 {
t.Fatalf("expected message buffers to be reset")
}
if exec.currentMessageID != "" || exec.currentThinkingID != "" {
t.Fatalf("expected streaming message IDs to be reset")
}
if exec.needsResumeContext || exec.resumeContextInjected {
t.Fatalf("expected resume context flags to be reset")
}
select {
case <-exec.promptDoneCh:
t.Fatalf("expected stale prompt signal to be drained")
default:
}
httpActions := mock.getHTTPActions()
if !slices.Equal(httpActions, []string{"stop", "configure", "start"}) {
t.Fatalf("unexpected HTTP action order: %v", httpActions)
}
wsActions := mock.getWSActions()
if !slices.Equal(wsActions, []string{"agent.initialize", "agent.session.new"}) {
t.Fatalf("unexpected WS action order: %v", wsActions)
}
mockBus, ok := mgr.eventBus.(*MockEventBus)
if !ok {
t.Fatal("expected mock event bus")
}
eventTypes := make([]string, 0, len(mockBus.PublishedEvents))
for _, ev := range mockBus.PublishedEvents {
eventTypes = append(eventTypes, ev.Type)
}
if !slices.Contains(eventTypes, events.AgentReady) {
t.Fatalf("expected %q event, got %v", events.AgentReady, eventTypes)
}
if !slices.Contains(eventTypes, events.AgentACPSessionCreated) {
t.Fatalf("expected %q event, got %v", events.AgentACPSessionCreated, eventTypes)
}
if !slices.Contains(eventTypes, events.AgentContextReset) {
t.Fatalf("expected %q event, got %v", events.AgentContextReset, eventTypes)
}
}
func TestManager_RestartAgentProcess_StopErrorIsNonFatal(t *testing.T) {
mgr := newTestManager()
mock := newRestartMockAgentctlServer(t, true, false)
client := createTestClient(t, mock.server.URL)
t.Cleanup(client.Close)
exec := &AgentExecution{
ID: "exec-stop-error",
TaskID: "task-1",
SessionID: "session-1",
AgentProfileID: "profile-1",
AgentCommand: "auggie --model test",
Status: v1.AgentStatusRunning,
WorkspacePath: "/workspace",
agentctl: client,
promptDoneCh: make(chan PromptCompletionSignal, 1),
}
mgr.executionStore.Add(exec)
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
defer cancel()
if err := mgr.RestartAgentProcess(ctx, exec.ID); err != nil {
t.Fatalf("expected restart to continue after stop failure, got: %v", err)
}
}
func TestManager_RestartAgentProcess_SessionInitFailure(t *testing.T) {
mgr := newTestManager()
mock := newRestartMockAgentctlServer(t, false, true)
client := createTestClient(t, mock.server.URL)
t.Cleanup(client.Close)
exec := &AgentExecution{
ID: "exec-session-fail",
TaskID: "task-1",
SessionID: "session-1",
AgentProfileID: "profile-1",
AgentCommand: "auggie --model test",
Status: v1.AgentStatusRunning,
WorkspacePath: "/workspace",
agentctl: client,
promptDoneCh: make(chan PromptCompletionSignal, 1),
}
mgr.executionStore.Add(exec)
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
defer cancel()
err := mgr.RestartAgentProcess(ctx, exec.ID)
if err == nil {
t.Fatal("expected restart to fail when ACP session initialization fails")
}
updated, found := mgr.executionStore.Get(exec.ID)
if !found {
t.Fatal("expected execution to still exist")
}
if updated.Status != v1.AgentStatusFailed {
t.Fatalf("expected status %q, got %q", v1.AgentStatusFailed, updated.Status)
}
if updated.ErrorMessage == "" {
t.Fatal("expected execution error message to be set")
}
mockBus, ok := mgr.eventBus.(*MockEventBus)
if !ok {
t.Fatal("expected mock event bus")
}
for _, ev := range mockBus.PublishedEvents {
if ev.Type == events.AgentContextReset {
t.Fatalf("did not expect %q event on failed restart", events.AgentContextReset)
}
}
}