fix(test): isolate regression tests from production Dolt server

Regression tests were connecting to the production Dolt server on port
3307, polluting it with test databases. Start a dedicated Dolt server
on a dynamic port in TestMain and pass BEADS_DOLT_PORT to all bd
subprocess invocations via runEnv().

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: steveyegge

tests/regression/discovery_test.go

@@ -4,7 +4,7 @@
 // on 2026-02-22. These tests exercise the candidate binary ONLY (not differential)
 // since bd export was removed from main (BUG-1 in DISCOVERY.md).
 //
-// These tests require a running Dolt server on 127.0.0.1:3307.
+// TestMain starts an isolated Dolt server on a dynamic port (via BEADS_DOLT_PORT).
 // Each test uses a unique prefix to avoid cross-contamination (BUG-6).
 package regression
 

tests/regression/regression_test.go

@@ -12,18 +12,23 @@ package regression
 import (
 	"archive/tar"
 	"compress/gzip"
+	"database/sql"
 	"encoding/json"
 	"fmt"
 	"io"
+	"net"
 	"net/http"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"runtime"
 	"sort"
+	"strconv"
 	"strings"
 	"testing"
 	"time"
+
+	_ "github.com/go-sql-driver/mysql"
 )
 
 // baselineBin is the path to the pinned baseline bd binary.
@@ -32,24 +37,33 @@ var baselineBin string
 // candidateBin is the path to the bd binary built from the current worktree.
 var candidateBin string
 
+// testDoltServerPort is the port of the isolated Dolt server started by TestMain.
+var testDoltServerPort int
+
 func TestMain(m *testing.M) {
 	if runtime.GOOS == "windows" {
 		fmt.Fprintln(os.Stderr, "regression tests not yet supported on Windows (zip extraction needed)")
 		os.Exit(0)
 	}
 
+	// Start an isolated Dolt server so regression tests don't pollute
+	// the production database on port 3307.
+	cleanupServer := startTestDoltServer()
+
 	tmpDir, err := os.MkdirTemp("", "bd-regression-bin-*")
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "creating temp dir: %v\n", err)
+		cleanupServer()
 		os.Exit(1)
 	}
-	defer os.RemoveAll(tmpDir)
 
 	// Build candidate from current worktree
 	candidateBin = filepath.Join(tmpDir, "bd-candidate")
 	fmt.Fprintln(os.Stderr, "Building candidate binary...")
 	if err := buildCandidate(candidateBin); err != nil {
 		fmt.Fprintf(os.Stderr, "building candidate: %v\n", err)
+		os.RemoveAll(tmpDir)
+		cleanupServer()
 		os.Exit(1)
 	}
 
@@ -58,11 +72,16 @@ func TestMain(m *testing.M) {
 	baselineBin, err = getBaseline()
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "getting baseline: %v\n", err)
+		os.RemoveAll(tmpDir)
+		cleanupServer()
 		os.Exit(1)
 	}
 
 	fmt.Fprintf(os.Stderr, "Baseline:  %s\nCandidate: %s\n\n", baselineBin, candidateBin)
-	os.Exit(m.Run())
+	code := m.Run()
+	os.RemoveAll(tmpDir)
+	cleanupServer()
+	os.Exit(code)
 }
 
 // ---------------------------------------------------------------------------
@@ -242,6 +261,9 @@ func (w *workspace) runEnv() []string {
 		"BEADS_NO_DAEMON=1",
 		"GIT_CONFIG_NOSYSTEM=1",
 	}
+	if testDoltServerPort != 0 {
+		env = append(env, "BEADS_DOLT_PORT="+strconv.Itoa(testDoltServerPort))
+	}
 	if v := os.Getenv("TMPDIR"); v != "" {
 		env = append(env, "TMPDIR="+v)
 	}
@@ -695,3 +717,126 @@ func (w *workspace) tryCreate(args ...string) (string, error) {
 	w.createdIDs = append(w.createdIDs, id)
 	return id, nil
 }
+
+// ---------------------------------------------------------------------------
+// Test Dolt server (isolation from production)
+// ---------------------------------------------------------------------------
+
+// startTestDoltServer starts a dedicated Dolt SQL server in a temp directory
+// on a dynamic port. This prevents regression tests from creating databases on
+// the production Dolt server (port 3307).
+// Returns a cleanup function that stops the server and removes the temp dir.
+func startTestDoltServer() func() {
+	if _, err := exec.LookPath("dolt"); err != nil {
+		fmt.Fprintln(os.Stderr, "WARN: dolt not found in PATH; regression tests will be skipped")
+		return func() {}
+	}
+
+	tmpDir, err := os.MkdirTemp("", "bd-regression-dolt-*")
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "WARN: failed to create test dolt dir: %v\n", err)
+		return func() {}
+	}
+
+	dbDir := filepath.Join(tmpDir, "data")
+	if err := os.MkdirAll(dbDir, 0755); err != nil {
+		fmt.Fprintf(os.Stderr, "WARN: failed to create test dolt data dir: %v\n", err)
+		_ = os.RemoveAll(tmpDir)
+		return func() {}
+	}
+
+	// Configure dolt user identity (required by dolt init).
+	doltEnv := append(os.Environ(), "DOLT_ROOT_PATH="+tmpDir)
+	for _, args := range [][]string{
+		{"dolt", "config", "--global", "--add", "user.name", "regression-test"},
+		{"dolt", "config", "--global", "--add", "user.email", "test@regression.test"},
+	} {
+		cfgCmd := exec.Command(args[0], args[1:]...)
+		cfgCmd.Env = doltEnv
+		if out, err := cfgCmd.CombinedOutput(); err != nil {
+			fmt.Fprintf(os.Stderr, "WARN: %s failed: %v\n%s\n", args[1], err, out)
+			_ = os.RemoveAll(tmpDir)
+			return func() {}
+		}
+	}
+
+	initCmd := exec.Command("dolt", "init")
+	initCmd.Dir = dbDir
+	initCmd.Env = doltEnv
+	if out, err := initCmd.CombinedOutput(); err != nil {
+		fmt.Fprintf(os.Stderr, "WARN: dolt init failed for test server: %v\n%s\n", err, out)
+		_ = os.RemoveAll(tmpDir)
+		return func() {}
+	}
+
+	port, err := findFreePort()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "WARN: failed to find free port for test dolt server: %v\n", err)
+		_ = os.RemoveAll(tmpDir)
+		return func() {}
+	}
+
+	serverCmd := exec.Command("dolt", "sql-server",
+		"-H", "127.0.0.1",
+		"-P", fmt.Sprintf("%d", port),
+		"--no-auto-commit",
+	)
+	serverCmd.Dir = dbDir
+	serverCmd.Env = doltEnv
+	if os.Getenv("BEADS_TEST_DOLT_VERBOSE") != "1" {
+		serverCmd.Stderr = nil
+		serverCmd.Stdout = nil
+	}
+	if err := serverCmd.Start(); err != nil {
+		fmt.Fprintf(os.Stderr, "WARN: failed to start test dolt server: %v\n", err)
+		_ = os.RemoveAll(tmpDir)
+		return func() {}
+	}
+
+	if !waitForServer(port, 10*time.Second) {
+		fmt.Fprintf(os.Stderr, "WARN: test dolt server did not become ready on port %d\n", port)
+		_ = serverCmd.Process.Kill()
+		_ = serverCmd.Wait()
+		_ = os.RemoveAll(tmpDir)
+		return func() {}
+	}
+
+	testDoltServerPort = port
+	fmt.Fprintf(os.Stderr, "Test Dolt server running on port %d\n", port)
+
+	return func() {
+		testDoltServerPort = 0
+		_ = serverCmd.Process.Kill()
+		_ = serverCmd.Wait()
+		_ = os.RemoveAll(tmpDir)
+	}
+}
+
+// findFreePort finds an available TCP port by binding to :0.
+func findFreePort() (int, error) {
+	l, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		return 0, err
+	}
+	port := l.Addr().(*net.TCPAddr).Port
+	_ = l.Close()
+	return port, nil
+}
+
+// waitForServer polls until the Dolt server accepts a MySQL connection.
+func waitForServer(port int, timeout time.Duration) bool {
+	deadline := time.Now().Add(timeout)
+	dsn := fmt.Sprintf("root@tcp(127.0.0.1:%d)/?timeout=1s", port)
+	for time.Now().Before(deadline) {
+		db, err := sql.Open("mysql", dsn)
+		if err == nil {
+			if err := db.Ping(); err == nil {
+				_ = db.Close()
+				return true
+			}
+			_ = db.Close()
+		}
+		time.Sleep(200 * time.Millisecond)
+	}
+	return false
+}