Merge pull request #46 from Cai-Tang-www/fork-pr-506-1777382006

test: improve coverage for hook P3 branches

Author: Cai-Tang-www

internal/runtime/repo_hooks_test.go

@@ -568,3 +568,94 @@ hooks:
 		t.Fatalf("cache size = %d, want 1", cacheSize)
 	}
 }
+
+func TestDynamicRepoHookExecutorEarlyReturnBranches(t *testing.T) {
+	exec := &dynamicRepoHookExecutor{}
+	out := exec.Run(context.Background(), runtimehooks.HookPointBeforeToolCall, runtimehooks.HookContext{})
+	if len(out.Results) != 0 || out.Blocked {
+		t.Fatalf("expected empty output for nil-config executor, got %+v", out)
+	}
+
+	exec = &dynamicRepoHookExecutor{fallbackWorkdir: " "}
+	out = exec.Run(context.Background(), runtimehooks.HookPointBeforeToolCall, runtimehooks.HookContext{})
+	if len(out.Results) != 0 || out.Blocked {
+		t.Fatalf("expected empty output for blank workspace, got %+v", out)
+	}
+
+	exec = &dynamicRepoHookExecutor{fallbackWorkdir: "relative/path"}
+	out = exec.Run(context.Background(), runtimehooks.HookPointBeforeToolCall, runtimehooks.HookContext{})
+	if len(out.Results) != 0 || out.Blocked {
+		t.Fatalf("expected empty output for invalid workspace path, got %+v", out)
+	}
+}
+
+func TestLoadRepoHookItemsAndDefaultsBranches(t *testing.T) {
+	workspace := t.TempDir()
+	hooksPath := filepath.Join(workspace, ".neocode", "hooks.yaml")
+	if err := os.MkdirAll(filepath.Dir(hooksPath), 0o755); err != nil {
+		t.Fatalf("mkdir hooks dir: %v", err)
+	}
+
+	if err := os.WriteFile(hooksPath, []byte(" \n\t "), 0o644); err != nil {
+		t.Fatalf("write empty hooks file: %v", err)
+	}
+	if _, err := loadRepoHookItems(hooksPath, config.StaticDefaults().Runtime.Hooks); err == nil {
+		t.Fatal("expected empty hooks file error")
+	}
+
+	content := `
+hooks:
+  items:
+    - id: disabled
+      enabled: false
+      point: before_tool_call
+      handler: add_context_note
+      params:
+        note: skip
+    - id: enabled-defaults
+      point: before_tool_call
+      handler: add_context_note
+      params:
+        note: ok
+`
+	if err := os.WriteFile(hooksPath, []byte(content), 0o644); err != nil {
+		t.Fatalf("write hooks file: %v", err)
+	}
+	items, err := loadRepoHookItems(hooksPath, config.StaticDefaults().Runtime.Hooks)
+	if err != nil {
+		t.Fatalf("loadRepoHookItems() error = %v", err)
+	}
+	if len(items) != 1 {
+		t.Fatalf("items len = %d, want 1", len(items))
+	}
+	item := items[0]
+	if item.Scope != "repo" || item.Kind != "builtin" || item.Mode != "sync" {
+		t.Fatalf("unexpected defaults: scope=%q kind=%q mode=%q", item.Scope, item.Kind, item.Mode)
+	}
+}
+
+func TestResolveTrustedWorkspacesPathFallbackBranches(t *testing.T) {
+	t.Setenv("HOME", "relative-home")
+	path := resolveTrustedWorkspacesPath()
+	if !strings.Contains(path, filepath.Join(".neocode", repoHooksTrustStoreFileName)) {
+		t.Fatalf("unexpected trust store path: %q", path)
+	}
+
+	t.Setenv("HOME", "")
+	path = resolveTrustedWorkspacesPath()
+	if !strings.Contains(path, filepath.Join(".neocode", repoHooksTrustStoreFileName)) {
+		t.Fatalf("unexpected trust store path with empty HOME: %q", path)
+	}
+}
+
+func TestRepoHookEventEmittersAndHelpers(t *testing.T) {
+	emitRepoHooksLifecycleEvent(nil, EventRepoHooksDiscovered, RepoHooksLifecyclePayload{})
+	emitRepoHooksTrustStoreInvalidEvent(nil, RepoHooksTrustStoreInvalidPayload{})
+
+	if got := coalesceHookMessage(" ", "fallback", "other"); got != "fallback" {
+		t.Fatalf("coalesceHookMessage() = %q, want fallback", got)
+	}
+	if got := coalesceHookMessage(" ", "\t"); got != "" {
+		t.Fatalf("coalesceHookMessage(blank) = %q, want empty", got)
+	}
+}

internal/runtime/user_hooks_test.go

@@ -341,6 +341,80 @@ func TestUserComposedHookExecutorAndHelpers(t *testing.T) {
 	})
 }
 
+func TestRepoComposedHookExecutorBranches(t *testing.T) {
+	t.Parallel()
+
+	base := &countingHookExecutor{
+		output: runtimehooks.RunOutput{
+			Results: []runtimehooks.HookResult{{HookID: "base", Scope: runtimehooks.HookScopeInternal, Status: runtimehooks.HookResultPass}},
+		},
+	}
+	repo := &countingHookExecutor{
+		output: runtimehooks.RunOutput{
+			Results:       []runtimehooks.HookResult{{HookID: "repo", Scope: runtimehooks.HookScopeRepo, Status: runtimehooks.HookResultPass}},
+			Blocked:       true,
+			BlockedBy:     "repo",
+			BlockedSource: runtimehooks.HookSourceRepo,
+		},
+	}
+	composed := &repoComposedHookExecutor{base: base, repo: repo}
+	out := composed.Run(context.Background(), runtimehooks.HookPointBeforeToolCall, runtimehooks.HookContext{})
+	if !out.Blocked || out.BlockedBy != "repo" || out.BlockedSource != runtimehooks.HookSourceRepo {
+		t.Fatalf("unexpected blocked output: %+v", out)
+	}
+	if len(out.Results) != 2 {
+		t.Fatalf("results len = %d, want 2", len(out.Results))
+	}
+
+	blockedBase := &countingHookExecutor{
+		output: runtimehooks.RunOutput{Blocked: true, BlockedBy: "base"},
+	}
+	composed = &repoComposedHookExecutor{base: blockedBase, repo: repo}
+	out = composed.Run(context.Background(), runtimehooks.HookPointBeforeToolCall, runtimehooks.HookContext{})
+	if !out.Blocked || out.BlockedBy != "base" {
+		t.Fatalf("expected base block passthrough, got %+v", out)
+	}
+}
+
+func TestResolveHookPathWithinWorkdirAndSymlinkBranches(t *testing.T) {
+	t.Parallel()
+
+	workdir := t.TempDir()
+	if _, err := resolveHookPathWithinWorkdir("", "a.txt"); err == nil {
+		t.Fatal("expected empty workdir error")
+	}
+	if _, err := resolveHookPathWithinWorkdir(workdir, ""); err == nil {
+		t.Fatal("expected empty path error")
+	}
+	if _, err := resolveHookPathWithinWorkdir(workdir, "../escape.txt"); err == nil {
+		t.Fatal("expected outside workdir error")
+	}
+
+	target := filepath.Join(workdir, "target.txt")
+	if err := os.WriteFile(target, []byte("ok"), 0o644); err != nil {
+		t.Fatalf("write target: %v", err)
+	}
+	link := filepath.Join(workdir, "link.txt")
+	if err := os.Symlink(target, link); err != nil {
+		t.Fatalf("create symlink: %v", err)
+	}
+	got, err := resolveHookPathWithinWorkdir(workdir, "link.txt")
+	if err != nil {
+		t.Fatalf("resolveHookPathWithinWorkdir(symlink) error = %v", err)
+	}
+	if strings.TrimSpace(got) == "" {
+		t.Fatal("expected non-empty resolved path")
+	}
+
+	hasLink, err := hookPathContainsSymlink(workdir, link)
+	if err != nil {
+		t.Fatalf("hookPathContainsSymlink() error = %v", err)
+	}
+	if !hasLink {
+		t.Fatal("expected symlink detection for link.txt")
+	}
+}
+
 func TestUserHookHelpersAndErrorBranches(t *testing.T) {
 	t.Parallel()
 

internal/tui/services/gateway_stream_client_test.go

@@ -2,6 +2,7 @@ package services
 
 import (
 	"encoding/json"
+	"strings"
 	"testing"
 	"time"
 
@@ -281,6 +282,39 @@ func TestGatewayStreamClientEmitsDecodeErrorAsRuntimeErrorEvent(t *testing.T) {
 	}
 }
 
+func TestGatewayStreamClientStopsOnPayloadVersionMismatch(t *testing.T) {
+	source := make(chan gatewayRPCNotification, 2)
+	client := NewGatewayStreamClient(source)
+	t.Cleanup(func() { _ = client.Close() })
+
+	source <- gatewayRPCNotification{
+		Method: protocol.MethodGatewayEvent,
+		Params: json.RawMessage(`{"type":"event","action":"run","session_id":"s","run_id":"r","payload":{"runtime_event_type":"error","payload_version":999,"payload":"boom"}}`),
+	}
+	source <- gatewayRPCNotification{
+		Method: protocol.MethodGatewayEvent,
+		Params: json.RawMessage(`{"type":"event","action":"run","session_id":"s","run_id":"r","payload":{"runtime_event_type":"agent_chunk","payload_version":4,"payload":"after"}}`),
+	}
+
+	first := <-client.Events()
+	if first.Type != EventError {
+		t.Fatalf("first.Type = %q, want %q", first.Type, EventError)
+	}
+	msg, ok := first.Payload.(string)
+	if !ok || !strings.Contains(strings.ToLower(msg), "payload_version") {
+		t.Fatalf("first.Payload = %#v, want payload_version error", first.Payload)
+	}
+
+	select {
+	case event, ok := <-client.Events():
+		if ok {
+			t.Fatalf("expected stream to stop after version mismatch, got extra event: %#v", event)
+		}
+	case <-time.After(2 * time.Second):
+		t.Fatalf("timed out waiting stream close after version mismatch")
+	}
+}
+
 func buildGatewayEventNotification(t *testing.T, frame gateway.MessageFrame) gatewayRPCNotification {
 	t.Helper()
 	raw, err := json.Marshal(frame)