chore: import upstream snapshot with attribution

cmd/gortex/flow_test.go

@@ -0,0 +1,137 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+// capturedFlow records the (repo, tool, args) a dataflow verb lowered to.
+type capturedFlow struct {
+	repo string
+	tool string
+	args map[string]any
+}
+
+// runDataflow drives the real command tree for one dataflow verb (flow/taint),
+// stubbing the shared daemon seam. Returns the captured call, the buffer, and
+// any error.
+func runDataflow(t *testing.T, verb string, argv ...string) (*capturedFlow, *bytes.Buffer, error) {
+	t.Helper()
+	resetFlowFlags()
+
+	orig := flowDaemonTool
+	t.Cleanup(func() { flowDaemonTool = orig })
+
+	var cap *capturedFlow
+	flowDaemonTool = func(repo, tool string, args map[string]any) (json.RawMessage, error) {
+		cap = &capturedFlow{repo: repo, tool: tool, args: args}
+		return json.RawMessage(`{"status":"ok"}`), nil
+	}
+
+	buf := &bytes.Buffer{}
+	rootCmd.SetOut(buf)
+	rootCmd.SetErr(buf)
+	rootCmd.SetIn(strings.NewReader(""))
+	rootCmd.SetArgs(append([]string{verb}, argv...))
+	err := rootCmd.Execute()
+	return cap, buf, err
+}
+
+func resetFlowFlags() {
+	resetCobraFlags(flowCmd)
+	resetCobraFlags(taintCmd)
+
+	flowIndex = "."
+	flowFrom, flowTo = "", ""
+	flowMaxDepth, flowMaxPaths = 0, 0
+	flowMinTier, flowFormat = "", "json"
+
+	taintIndex = "."
+	taintSource, taintSink = "", ""
+	taintMaxDepth, taintLimit = 0, 0
+	taintMinTier, taintFormat = "", "json"
+}
+
+// --- flow (flow_between) ----------------------------------------------------
+
+func TestFlow_Lowers(t *testing.T) {
+	cap, _, err := runDataflow(t, "flow", "--from", "A", "--to", "B")
+	require.NoError(t, err)
+	require.NotNil(t, cap)
+	require.Equal(t, "flow_between", cap.tool)
+	require.Equal(t, "A", cap.args["source_id"])
+	require.Equal(t, "B", cap.args["sink_id"])
+	require.Equal(t, "json", cap.args["format"])
+}
+
+func TestFlow_AllFlags(t *testing.T) {
+	cap, _, err := runDataflow(t, "flow",
+		"--from", "A", "--to", "B",
+		"--max-depth", "6", "--max-paths", "3", "--min-tier", "ast_resolved")
+	require.NoError(t, err)
+	require.Equal(t, "flow_between", cap.tool)
+	require.Equal(t, 6, cap.args["max_depth"])
+	require.Equal(t, 3, cap.args["max_paths"])
+	require.Equal(t, "ast_resolved", cap.args["min_tier"])
+}
+
+func TestFlow_OnlyChangedFlagsSent(t *testing.T) {
+	cap, _, err := runDataflow(t, "flow", "--from", "A", "--to", "B")
+	require.NoError(t, err)
+	_, hasDepth := cap.args["max_depth"]
+	require.False(t, hasDepth, "unset --max-depth must not be forwarded")
+	_, hasTier := cap.args["min_tier"]
+	require.False(t, hasTier, "unset --min-tier must not be forwarded")
+}
+
+func TestFlow_MissingFromTo(t *testing.T) {
+	_, _, err := runDataflow(t, "flow", "--from", "A")
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "--from and --to are required")
+}
+
+// --- taint (taint_paths) ----------------------------------------------------
+
+func TestTaint_Lowers(t *testing.T) {
+	cap, _, err := runDataflow(t, "taint", "--source", "s", "--sink", "k")
+	require.NoError(t, err)
+	require.NotNil(t, cap)
+	require.Equal(t, "taint_paths", cap.tool)
+	require.Equal(t, "s", cap.args["source_pattern"])
+	require.Equal(t, "k", cap.args["sink_pattern"])
+}
+
+func TestTaint_AllFlags(t *testing.T) {
+	cap, _, err := runDataflow(t, "taint",
+		"--source", "s", "--sink", "k",
+		"--max-depth", "10", "--limit", "30", "--min-tier", "lsp_resolved")
+	require.NoError(t, err)
+	require.Equal(t, "taint_paths", cap.tool)
+	require.Equal(t, 10, cap.args["max_depth"])
+	require.Equal(t, 30, cap.args["limit"])
+	require.Equal(t, "lsp_resolved", cap.args["min_tier"])
+}
+
+func TestTaint_MissingSourceSink(t *testing.T) {
+	_, _, err := runDataflow(t, "taint", "--source", "s")
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "--source and --sink are required")
+}
+
+// TestFlow_DaemonRequired asserts the real call path returns the daemon-required
+// error when no daemon tracks the repo.
+func TestFlow_DaemonRequired(t *testing.T) {
+	resetFlowFlags()
+	buf := &bytes.Buffer{}
+	rootCmd.SetOut(buf)
+	rootCmd.SetErr(buf)
+	rootCmd.SetIn(strings.NewReader(""))
+	rootCmd.SetArgs([]string{"flow", "--from", "A", "--to", "B", "--index", t.TempDir()})
+	err := rootCmd.Execute()
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "gortex track")
+}