Add endtoend replay coverage for parse and analyze

Extend the endtoend replay framework to run config-less, flag-driven
commands. Exec gains an "args" field, FindTests discovers directories by
exec.json when no sqlc config is present, and TestReplay dispatches
parse/analyze through the CLI entry point, comparing stdout to a
stdout.txt golden file. The config-based consumers (TestValidSchema,
TestFormat) skip these config-less cases.

Add two cases that pin the JSON output format of each command so future
changes don't break it: parse of a named PostgreSQL query and analyze of
a SELECT * query against a schema.

Author: claude

internal/endtoend/case_test.go

@@ -15,6 +15,7 @@ type Testcase struct {
 	Path       string
 	ConfigName string
 	Stderr     []byte
+	Stdout     []byte
 	Exec       *Exec
 }
 
@@ -24,6 +25,7 @@ type ExecMeta struct {
 
 type Exec struct {
 	Command  string            `json:"command"`
+	Args     []string          `json:"args"`
 	Contexts []string          `json:"contexts"`
 	Process  string            `json:"process"`
 	OS       []string          `json:"os"`
@@ -50,6 +52,29 @@ func parseStderr(t *testing.T, dir, testctx string) []byte {
 	return nil
 }
 
+func parseStdout(t *testing.T, dir string) []byte {
+	t.Helper()
+	path := filepath.Join(dir, "stdout.txt")
+	if _, err := os.Stat(path); os.IsNotExist(err) {
+		return nil
+	}
+	blob, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return blob
+}
+
+// hasSQLCConfig reports whether dir contains an sqlc configuration file.
+func hasSQLCConfig(dir string) bool {
+	for _, name := range []string{"sqlc.json", "sqlc.yaml", "sqlc.yml"} {
+		if _, err := os.Stat(filepath.Join(dir, name)); err == nil {
+			return true
+		}
+	}
+	return false
+}
+
 func parseExec(t *testing.T, dir string) *Exec {
 	t.Helper()
 	path := filepath.Join(dir, "exec.json")
@@ -76,17 +101,34 @@ func FindTests(t *testing.T, root, testctx string) []*Testcase {
 		if err != nil {
 			return err
 		}
-		if info.Name() == "sqlc.json" || info.Name() == "sqlc.yaml" || info.Name() == "sqlc.yml" {
+		name := info.Name()
+		if name == "sqlc.json" || name == "sqlc.yaml" || name == "sqlc.yml" {
 			dir := filepath.Dir(path)
 			tcs = append(tcs, &Testcase{
 				Path:       dir,
 				Name:       strings.TrimPrefix(dir, root+string(filepath.Separator)),
-				ConfigName: info.Name(),
+				ConfigName: name,
 				Stderr:     parseStderr(t, dir, testctx),
+				Stdout:     parseStdout(t, dir),
 				Exec:       parseExec(t, dir),
 			})
 			return filepath.SkipDir
 		}
+		// Config-less command tests (e.g. parse, analyze) are discovered by
+		// their exec.json when no sqlc config is present in the directory.
+		if name == "exec.json" {
+			dir := filepath.Dir(path)
+			if !hasSQLCConfig(dir) {
+				tcs = append(tcs, &Testcase{
+					Path:   dir,
+					Name:   strings.TrimPrefix(dir, root+string(filepath.Separator)),
+					Stderr: parseStderr(t, dir, testctx),
+					Stdout: parseStdout(t, dir),
+					Exec:   parseExec(t, dir),
+				})
+				return filepath.SkipDir
+			}
+		}
 		return nil
 	})
 	if err != nil {

internal/endtoend/ddl_test.go

@@ -20,6 +20,11 @@ func TestValidSchema(t *testing.T) {
 			}
 		}
 
+		// Config-less command tests (parse, analyze) have no schema to validate.
+		if replay.ConfigName == "" {
+			continue
+		}
+
 		file := filepath.Join(replay.Path, replay.ConfigName)
 		rd, err := os.Open(file)
 		if err != nil {

internal/endtoend/endtoend_test.go

@@ -3,6 +3,7 @@ package main
 import (
 	"bytes"
 	"context"
+	"fmt"
 	"os"
 	osexec "os/exec"
 	"path/filepath"
@@ -298,6 +299,28 @@ func TestReplay(t *testing.T) {
 					}
 				case "vet":
 					err = cmd.Vet(ctx, path, "", &opts)
+				case "parse", "analyze":
+					// These commands are config-less and flag-driven. Run them
+					// through the real CLI entry point from inside the test
+					// directory so file arguments resolve and the output stays
+					// independent of the absolute path.
+					var stdout bytes.Buffer
+					wd, werr := os.Getwd()
+					if werr != nil {
+						t.Fatal(werr)
+					}
+					if cerr := os.Chdir(path); cerr != nil {
+						t.Fatal(cerr)
+					}
+					code := cmd.Do(append([]string{args.Command}, args.Args...), nil, &stdout, &stderr)
+					if cerr := os.Chdir(wd); cerr != nil {
+						t.Fatal(cerr)
+					}
+					if code != 0 {
+						err = fmt.Errorf("%s exited with code %d", args.Command, code)
+					} else if diff := cmp.Diff(strings.TrimSpace(string(tc.Stdout)), strings.TrimSpace(stdout.String()), lineEndings()); diff != "" {
+						t.Errorf("stdout differed (-want +got):\n%s", diff)
+					}
 				default:
 					t.Fatalf("unknown command")
 				}

internal/endtoend/fmt_test.go

@@ -32,6 +32,10 @@ func TestFormat(t *testing.T) {
 	t.Parallel()
 	for _, tc := range FindTests(t, "testdata", "base") {
 		tc := tc
+		// Config-less command tests (parse, analyze) have no config to format.
+		if tc.ConfigName == "" {
+			continue
+		}
 		t.Run(tc.Name, func(t *testing.T) {
 			// Parse the config file to determine the engine
 			configPath := filepath.Join(tc.Path, tc.ConfigName)

internal/endtoend/testdata/analyze_basic/postgresql/exec.json

@@ -0,0 +1,5 @@
+{
+  "command": "analyze",
+  "args": ["--dialect", "postgresql", "--schema", "schema.sql", "query.sql"],
+  "contexts": ["base"]
+}

internal/endtoend/testdata/analyze_basic/postgresql/query.sql

@@ -0,0 +1,2 @@
+-- name: GetAuthor :one
+SELECT * FROM authors WHERE id = $1;

internal/endtoend/testdata/analyze_basic/postgresql/schema.sql

@@ -0,0 +1,5 @@
+CREATE TABLE authors (
+  id   BIGSERIAL PRIMARY KEY,
+  name text      NOT NULL,
+  bio  text
+);

internal/endtoend/testdata/analyze_basic/postgresql/stdout.txt

@@ -0,0 +1,41 @@
+[
+  {
+    "name": "GetAuthor",
+    "cmd": ":one",
+    "columns": [
+      {
+        "name": "id",
+        "data_type": "bigserial",
+        "not_null": true,
+        "is_array": false,
+        "table": "authors"
+      },
+      {
+        "name": "name",
+        "data_type": "text",
+        "not_null": true,
+        "is_array": false,
+        "table": "authors"
+      },
+      {
+        "name": "bio",
+        "data_type": "text",
+        "not_null": false,
+        "is_array": false,
+        "table": "authors"
+      }
+    ],
+    "params": [
+      {
+        "number": 1,
+        "column": {
+          "name": "id",
+          "data_type": "bigserial",
+          "not_null": true,
+          "is_array": false,
+          "table": "authors"
+        }
+      }
+    ]
+  }
+]

internal/endtoend/testdata/parse_basic/postgresql/exec.json

@@ -0,0 +1,5 @@
+{
+  "command": "parse",
+  "args": ["--dialect", "postgresql", "query.sql"],
+  "contexts": ["base"]
+}

internal/endtoend/testdata/parse_basic/postgresql/query.sql

@@ -0,0 +1,2 @@
+-- name: GetValue :one
+SELECT 1;