chore: import upstream snapshot with attribution

internal/analysis/adjacency_cache_test.go

@@ -0,0 +1,124 @@
+package analysis
+
+import (
+	"testing"
+
+	"github.com/zzet/gortex/internal/graph"
+)
+
+// buildEdgeGraph constructs a small in-memory graph from (from,to) call
+// edges. Node IDs follow the "<pkg>/file.go::Sym" shape so packageOfID
+// resolves a meaningful package directory.
+func buildEdgeGraph(t *testing.T, edges [][2]string) graph.Store {
+	t.Helper()
+	g := graph.New()
+	seen := map[string]bool{}
+	add := func(id string) {
+		if seen[id] {
+			return
+		}
+		seen[id] = true
+		path := id
+		if i := indexOfSep(id); i >= 0 {
+			path = id[:i]
+		}
+		g.AddNode(&graph.Node{ID: id, Kind: graph.KindFunction, Name: id, FilePath: path})
+	}
+	for _, e := range edges {
+		add(e[0])
+		add(e[1])
+	}
+	for _, e := range edges {
+		g.AddEdge(&graph.Edge{From: e[0], To: e[1], Kind: graph.EdgeCalls})
+	}
+	return g
+}
+
+func indexOfSep(s string) int {
+	for i := 0; i+1 < len(s); i++ {
+		if s[i] == ':' && s[i+1] == ':' {
+			return i
+		}
+	}
+	return -1
+}
+
+func TestWalkCacheKeyDeterministic(t *testing.T) {
+	g := buildEdgeGraph(t, [][2]string{
+		{"pkg/a.go::A", "pkg/b.go::B"},
+		{"pkg/b.go::B", "pkg/c.go::C"},
+	})
+	s1 := BuildAdjacencySnapshot(g)
+	s2 := BuildAdjacencySnapshot(g)
+	k1 := s1.WalkCacheKey([]string{"pkg/a.go::A"}, 0)
+	k2 := s2.WalkCacheKey([]string{"pkg/a.go::A"}, 0)
+	if k1 == "" {
+		t.Fatal("expected non-empty key")
+	}
+	if k1 != k2 {
+		t.Fatalf("key not deterministic across identical snapshots: %q vs %q", k1, k2)
+	}
+	// Seed order must not matter (sorted internally).
+	if got := s1.WalkCacheKey([]string{"pkg/a.go::A", "pkg/b.go::B"}, 0); got == k1 {
+		t.Fatal("different seed set should produce a different key")
+	}
+}
+
+func TestWalkCacheKeyPackageInvalidation(t *testing.T) {
+	base := [][2]string{
+		{"pkg/a.go::A", "pkg/b.go::B"},
+		{"other/x.go::X", "other/y.go::Y"},
+	}
+	g1 := buildEdgeGraph(t, base)
+	s1 := BuildAdjacencySnapshot(g1)
+	seeds := []string{"other/x.go::X"}
+	k1 := s1.WalkCacheKey(seeds, 0)
+
+	// Change a package UNRELATED to the seed's dependency set (pkg/*).
+	// The seed walk (other/*) must keep the same key — the incremental
+	// property: an edit to pkg/ doesn't bust an other/ walk.
+	g2 := buildEdgeGraph(t, append([][2]string{
+		{"pkg/a.go::A", "pkg/b.go::B2new"},
+	}, base...))
+	s2 := BuildAdjacencySnapshot(g2)
+	k2 := s2.WalkCacheKey(seeds, 0)
+	if k1 != k2 {
+		t.Fatalf("unrelated-package edit must not change the walk key: %q vs %q", k1, k2)
+	}
+
+	// Now change the seed's OWN package: the key must change (miss).
+	g3 := buildEdgeGraph(t, [][2]string{
+		{"pkg/a.go::A", "pkg/b.go::B"},
+		{"other/x.go::X", "other/y.go::Ynew"}, // seed's out-edge target changed
+	})
+	s3 := BuildAdjacencySnapshot(g3)
+	k3 := s3.WalkCacheKey(seeds, 0)
+	if k1 == k3 {
+		t.Fatal("changing the seed's dependency package must change the walk key")
+	}
+}
+
+func TestPackageRootsPopulated(t *testing.T) {
+	g := buildEdgeGraph(t, [][2]string{
+		{"pkg/a.go::A", "pkg/b.go::B"},
+		{"other/x.go::X", "other/y.go::Y"},
+	})
+	s := BuildAdjacencySnapshot(g)
+	if s.PackageRootCount() < 2 {
+		t.Fatalf("expected >=2 package roots, got %d", s.PackageRootCount())
+	}
+}
+
+func TestPackageOfID(t *testing.T) {
+	cases := map[string]string{
+		"gortex/internal/mcp/server.go::NewServer": "gortex/internal/mcp",
+		"pkg/a.go::A":   "pkg",
+		"top.go::Sym":   "",
+		"a/b/c/f.go::S": "a/b/c",
+	}
+	for id, want := range cases {
+		if got := packageOfID(id); got != want {
+			t.Errorf("packageOfID(%q) = %q, want %q", id, got, want)
+		}
+	}
+}