Merge pull request #65 from Cai-Tang-www/fork-pr-666-1779179913

test(runtime): raise resume verify coverage

Author: Cai-Tang-www

internal/runtime/checkpoint_flow_test.go

@@ -12,6 +12,7 @@ import (
 	providertypes "neo-code/internal/provider/types"
 	"neo-code/internal/runtime/controlplane"
 	agentsession "neo-code/internal/session"
+	"neo-code/internal/tools"
 )
 
 type checkpointStoreSpy struct {
@@ -202,6 +203,15 @@ func countPerEditCheckpointMetaFiles(t *testing.T, root string) int {
 	return count
 }
 
+func hasEventType(events []RuntimeEvent, want EventType) bool {
+	for _, event := range events {
+		if event.Type == want {
+			return true
+		}
+	}
+	return false
+}
+
 func TestCreateStartOfTurnCheckpoint_PendingWrite(t *testing.T) {
 	fixture := newRuntimeCheckpointFixture(t)
 	fixture.captureFile(t, "main.go", []byte("package main\nconst v = 1\n"))
@@ -389,6 +399,133 @@ func TestApplyResumeCheckpointVerifyClosureStrategy(t *testing.T) {
 	assertEventSequence(t, events, []EventType{EventResumeApplied, EventRuntimeSnapshotUpdated})
 }
 
+func TestApplyResumeCheckpointSkipsUnsupportedInputs(t *testing.T) {
+	t.Parallel()
+
+	fixture := newRuntimeCheckpointFixture(t)
+	service := &Service{
+		checkpointStore:  &checkpointStoreSpy{},
+		events:           make(chan RuntimeEvent, 16),
+		runtimeSnapshots: make(map[string]RuntimeSnapshot),
+	}
+
+	service.applyResumeCheckpoint(context.Background(), nil)
+
+	emptyState := newRunState("run-empty-session", fixture.session)
+	emptyState.session.ID = "  "
+	service.applyResumeCheckpoint(context.Background(), &emptyState)
+
+	unsupportedState := newRunState("run-unsupported-resume", fixture.session)
+	service.checkpointStore = &checkpointStoreSpy{
+		latestResume: &agentsession.ResumeCheckpoint{
+			RunID:           "run-unknown",
+			SessionID:       fixture.session.ID,
+			Turn:            1,
+			Phase:           "stopped",
+			CompletionState: "completed",
+		},
+	}
+	service.applyResumeCheckpoint(context.Background(), &unsupportedState)
+
+	if unsupportedState.resumeNextBaseLifecycle != "" {
+		t.Fatalf("resumeNextBaseLifecycle = %q, want empty", unsupportedState.resumeNextBaseLifecycle)
+	}
+	if strings.TrimSpace(unsupportedState.pendingSystemReminder) != "" {
+		t.Fatalf("pendingSystemReminder = %q, want empty", unsupportedState.pendingSystemReminder)
+	}
+	if len(collectRuntimeEvents(service.Events())) != 0 {
+		t.Fatal("expected no runtime events for skipped resume checkpoint cases")
+	}
+}
+
+func TestDeriveResumeBaseLifecycle(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name            string
+		phase           string
+		completionState string
+		want            controlplane.RunState
+	}{
+		{name: "verify completed resumes verify", phase: " verify ", completionState: " completed ", want: controlplane.RunStateVerify},
+		{name: "verify incomplete falls back to plan", phase: "verify", completionState: "running", want: controlplane.RunStatePlan},
+		{name: "plan resumes plan", phase: "plan", completionState: "", want: controlplane.RunStatePlan},
+		{name: "execute resumes plan", phase: "execute", completionState: "", want: controlplane.RunStatePlan},
+		{name: "unknown phase ignored", phase: "stopped", completionState: "completed", want: ""},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			if got := deriveResumeBaseLifecycle(tt.phase, tt.completionState); got != tt.want {
+				t.Fatalf("deriveResumeBaseLifecycle(%q, %q) = %q, want %q", tt.phase, tt.completionState, got, tt.want)
+			}
+		})
+	}
+}
+
+func TestServiceRunResumeVerifyClosureBootstrapsFirstTurn(t *testing.T) {
+	t.Parallel()
+
+	manager := newRuntimeConfigManager(t)
+	store := newMemoryStore()
+	providerImpl := &scriptedProvider{
+		responses: []scriptedResponse{
+			{
+				Message: providertypes.Message{
+					Role: providertypes.RoleAssistant,
+					Parts: []providertypes.ContentPart{
+						providertypes.NewTextPart("verification summary"),
+					},
+				},
+				FinishReason: "stop",
+			},
+		},
+	}
+	resumeStore := &checkpointStoreSpy{
+		latestResume: &agentsession.ResumeCheckpoint{
+			RunID:           "run-old-verify",
+			SessionID:       "ignored-by-spy",
+			Turn:            2,
+			Phase:           "verify",
+			CompletionState: "completed",
+		},
+	}
+	service := NewWithFactory(
+		manager,
+		tools.NewRegistry(),
+		store,
+		&scriptedProviderFactory{provider: providerImpl},
+		&stubContextBuilder{},
+	)
+	service.checkpointStore = resumeStore
+	service.events = make(chan RuntimeEvent, 32)
+	service.runtimeSnapshots = make(map[string]RuntimeSnapshot)
+
+	if err := service.Run(context.Background(), UserInput{
+		RunID: "run-resume-verify-first-turn",
+		Parts: []providertypes.ContentPart{providertypes.NewTextPart("continue")},
+	}); err != nil {
+		t.Fatalf("Run() error = %v", err)
+	}
+
+	events := collectRuntimeEvents(service.Events())
+	if !hasEventType(events, EventResumeApplied) {
+		t.Fatalf("expected %s event, got %+v", EventResumeApplied, events)
+	}
+	if !hasPhaseTransition(events, "", "plan") {
+		t.Fatalf("missing bootstrap transition '' -> plan, events=%+v", events)
+	}
+	if !hasPhaseTransition(events, "plan", "verify") {
+		t.Fatalf("missing resume transition plan -> verify, events=%+v", events)
+	}
+	if !hasEventType(events, EventVerificationStarted) {
+		t.Fatalf("expected %s event, got %+v", EventVerificationStarted, events)
+	}
+}
+
 func TestRuntimeCheckpointFacadeMethods(t *testing.T) {
 	t.Run("list checkpoints delegates to store", func(t *testing.T) {
 		spy := &checkpointStoreSpy{

internal/runtime/run_lifecycle_test.go

@@ -159,6 +159,54 @@ func TestApplyTurnBaseRunStateBootstrapsVerifyFromEmpty(t *testing.T) {
 	})
 }
 
+func TestApplyTurnBaseRunStateNonBootstrapPaths(t *testing.T) {
+	t.Parallel()
+
+	service := &Service{events: make(chan RuntimeEvent, 16)}
+	if err := service.applyTurnBaseRunState(context.Background(), nil, controlplane.RunStateVerify); err != nil {
+		t.Fatalf("apply turn base run state nil state: %v", err)
+	}
+
+	state := newRunState("run-bootstrap-plan", newRuntimeSession("session-bootstrap-plan"))
+	if err := service.applyTurnBaseRunState(context.Background(), &state, controlplane.RunStatePlan); err != nil {
+		t.Fatalf("apply turn base run state plan: %v", err)
+	}
+	if state.lifecycle != controlplane.RunStatePlan {
+		t.Fatalf("lifecycle = %q, want plan", state.lifecycle)
+	}
+
+	state.lifecycle = controlplane.RunStatePlan
+	if err := service.applyTurnBaseRunState(context.Background(), &state, controlplane.RunStateVerify); err != nil {
+		t.Fatalf("apply turn base run state verify from plan: %v", err)
+	}
+	if state.lifecycle != controlplane.RunStateVerify {
+		t.Fatalf("lifecycle = %q, want verify", state.lifecycle)
+	}
+
+	events := collectRuntimeEvents(service.Events())
+	assertPhaseTransitions(t, events, [][2]string{
+		{"", "plan"},
+		{"plan", "verify"},
+	})
+}
+
+func TestRunLifecycleRejectsInvalidStates(t *testing.T) {
+	t.Parallel()
+
+	service := &Service{events: make(chan RuntimeEvent, 16)}
+	state := newRunState("run-invalid-lifecycle", newRuntimeSession("session-invalid-lifecycle"))
+
+	if err := service.setBaseRunState(context.Background(), &state, controlplane.RunStateWaitingPermission); err == nil {
+		t.Fatal("expected invalid base lifecycle state error")
+	}
+	if err := service.enterTemporaryRunState(context.Background(), &state, controlplane.RunStatePlan); err == nil {
+		t.Fatal("expected unsupported temporary lifecycle state error")
+	}
+	if err := service.leaveTemporaryRunState(context.Background(), &state, controlplane.RunStatePlan); err == nil {
+		t.Fatal("expected unsupported temporary lifecycle state error")
+	}
+}
+
 func assertPhaseTransitions(t *testing.T, events []RuntimeEvent, expected [][2]string) {
 	t.Helper()
 

internal/runtime/verification_events_test.go

@@ -71,3 +71,50 @@ func TestEmitVerificationLifecycleEvents(t *testing.T) {
 		t.Fatalf("ErrorClass = %q, want unknown", finished.ErrorClass)
 	}
 }
+
+func TestEmitVerificationLifecycleEventsAcceptedAndNilGuards(t *testing.T) {
+	t.Parallel()
+
+	service := &Service{events: make(chan RuntimeEvent, 16)}
+	state := newRunState("run-verification-accepted", agentsession.New("verification-accepted"))
+	service.emitVerificationLifecycleEvents(context.Background(), &state, controlplane.CompletionState{}, acceptgate.Report{
+		Outcome: acceptgate.OutcomeAccepted,
+		Results: []acceptgate.CheckResult{
+			{Name: " permission-check ", Passed: false, Reason: "permission denied"},
+			{Name: " timeout-check ", Passed: false, Reason: "command timeout"},
+			{Name: " lookup-check ", Passed: false, Reason: "binary not found"},
+			{Name: " pass-check ", Passed: true, Reason: "  skipped  "},
+		},
+	})
+	service.emitVerificationLifecycleEvents(context.Background(), nil, controlplane.CompletionState{}, acceptgate.Report{})
+	var nilService *Service
+	nilService.emitVerificationLifecycleEvents(context.Background(), &state, controlplane.CompletionState{}, acceptgate.Report{})
+
+	events := collectRuntimeEvents(service.Events())
+	if len(events) != 6 {
+		t.Fatalf("event count = %d, want 6", len(events))
+	}
+
+	finished, ok := events[len(events)-1].Payload.(VerificationFinishedPayload)
+	if !ok {
+		t.Fatalf("finished payload type = %T", events[len(events)-1].Payload)
+	}
+	if finished.ErrorClass != "" {
+		t.Fatalf("ErrorClass = %q, want empty for accepted verification", finished.ErrorClass)
+	}
+
+	var gotClasses []string
+	for _, event := range events[1 : len(events)-1] {
+		payload, ok := event.Payload.(VerificationStageFinishedPayload)
+		if !ok {
+			t.Fatalf("stage payload type = %T", event.Payload)
+		}
+		gotClasses = append(gotClasses, payload.ErrorClass)
+	}
+	wantClasses := []string{"permission_denied", "timeout", "command_not_found", ""}
+	for i := range wantClasses {
+		if gotClasses[i] != wantClasses[i] {
+			t.Fatalf("stage error class[%d] = %q, want %q", i, gotClasses[i], wantClasses[i])
+		}
+	}
+}