chore: import upstream snapshot with attribution

internal/resolver/framework_synth_test.go

@@ -0,0 +1,99 @@
+package resolver
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/zzet/gortex/internal/graph"
+)
+
+func TestStampSynthesized(t *testing.T) {
+	e := &graph.Edge{From: "a", To: "b", Kind: graph.EdgeCalls}
+	StampSynthesized(e, SynthEventChannel)
+	assert.Equal(t, SynthEventChannel, e.Meta[MetaSynthesizedBy])
+	assert.Equal(t, ProvenanceHeuristic, e.Meta[MetaProvenance])
+
+	// Does not clobber an explicit provenance already set.
+	e2 := &graph.Edge{From: "a", To: "b", Kind: graph.EdgeCalls, Meta: map[string]any{MetaProvenance: "verified"}}
+	StampSynthesized(e2, SynthGRPCStub)
+	assert.Equal(t, "verified", e2.Meta[MetaProvenance])
+	assert.Equal(t, SynthGRPCStub, e2.Meta[MetaSynthesizedBy])
+
+	UnstampSynthesized(e)
+	_, hasBy := e.Meta[MetaSynthesizedBy]
+	_, hasProv := e.Meta[MetaProvenance]
+	assert.False(t, hasBy)
+	assert.False(t, hasProv)
+
+	// nil-safe.
+	StampSynthesized(nil, SynthGRPCStub)
+	UnstampSynthesized(nil)
+}
+
+func TestStampSynthesizedTyped(t *testing.T) {
+	// The typed-tier stamp records ProvenanceFramework, not Heuristic.
+	e := &graph.Edge{From: "a", To: "b", Kind: graph.EdgeCalls}
+	StampSynthesizedTyped(e, SynthEventChannel)
+	assert.Equal(t, SynthEventChannel, e.Meta[MetaSynthesizedBy])
+	assert.Equal(t, ProvenanceFramework, e.Meta[MetaProvenance])
+
+	// The two provenance tiers are distinct values so analyze
+	// kind=synthesizers can separate them from one MetaProvenance read.
+	assert.NotEqual(t, ProvenanceHeuristic, ProvenanceFramework)
+
+	// Confidence tiers carry the documented values.
+	assert.Equal(t, 0.85, ConfidenceTyped)
+	assert.Equal(t, 0.6, ConfidenceHeuristic)
+
+	// UnstampSynthesized clears the typed provenance too.
+	UnstampSynthesized(e)
+	_, hasBy := e.Meta[MetaSynthesizedBy]
+	_, hasProv := e.Meta[MetaProvenance]
+	assert.False(t, hasBy)
+	assert.False(t, hasProv)
+
+	// nil-safe.
+	StampSynthesizedTyped(nil, SynthGRPCStub)
+}
+
+func TestRunFrameworkSynthesizers_Report(t *testing.T) {
+	b := newEventChannelTestGraph()
+	b.emit("p.go::p", "eventemitter", "e", "p.go", 1)
+	b.listen("c.go::c", "eventemitter", "e", "c.go", 1)
+
+	rep := RunFrameworkSynthesizers(b.g)
+	assert.Equal(t, 1, rep.Total, "the one event-channel pair is the only synthesized edge")
+
+	byName := map[string]int{}
+	for _, p := range rep.Per {
+		byName[p.Name] = p.Edges
+	}
+	// Every registered synthesizer reports a row, even at zero.
+	require.Contains(t, byName, SynthGRPCStub)
+	require.Contains(t, byName, SynthTemporalStub)
+	require.Contains(t, byName, SynthEventChannel)
+	require.Contains(t, byName, SynthStoreFactory)
+	require.Contains(t, byName, SynthReduxThunk)
+	require.Contains(t, byName, SynthObjectRegistry)
+	require.Contains(t, byName, SynthRTKQuery)
+	require.Contains(t, byName, SynthVuexDispatch)
+	require.Contains(t, byName, SynthCelery)
+	require.Contains(t, byName, SynthSpringEvent)
+	require.Contains(t, byName, SynthMediatR)
+	require.Contains(t, byName, SynthSidekiq)
+	require.Contains(t, byName, SynthLaravelEvent)
+	require.Contains(t, byName, SynthFnPointerDispatch)
+	require.Contains(t, byName, SynthGoFrameRoute)
+	require.Contains(t, byName, SynthExpressResolve)
+	assert.Equal(t, 0, byName[SynthGRPCStub])
+	assert.Equal(t, 0, byName[SynthTemporalStub])
+	assert.Equal(t, 1, byName[SynthEventChannel])
+}
+
+func TestRunFrameworkSynthesizers_NilGraph(t *testing.T) {
+	rep := RunFrameworkSynthesizers(nil)
+	assert.Equal(t, 0, rep.Total)
+	assert.Nil(t, rep.Per)
+}