beads/internal/doltserver/socket_integration_test.go
Julian Knutsen 9e8d411f71
Add PR CI wrapper command surface (#4211)
* ci: add PR wrapper command surface

* ci: collect wrapper timing in PR checks

* docs: record initial CI wrapper measurements

* ci: add manual measurement workflow

* ci: allow branch measurement dispatch

* ci: keep measuring independent commands after failures

* docs: record branch-dispatched CI measurement

* ci: keep measuring package suites after failures

* docs: record CI measurement batch

* fix: repair CI-measured test failures

* test: make local Go gates hermetic

* ci: add sharded integration measurement lane

* test: fix internal beads integration TestMain

* docs: record fixed integration shard measurement

* ci: add hybrid integration sharding measurement

* ci: speed up cmd/bd test shard discovery

* ci: add 16-way integration sharding measurement

* ci: measure prebuilt cmd bd sharding

* docs: record prebuilt sharding measurement

* docs: design CI build artifact stage

* docs: record repeat prebuilt integration measurement

* ci: add build artifact stage

* ci: reuse build artifact in linux test lane

* ci: promote main linux integration shards

* ci: gate legacy platform tests to main

* ci: satisfy workflow shell lint

* ci: ignore archived migrations in duplicate check

* ci: add package gate wrappers

* test: clean up testing short boundaries

* ci: allow unreleased version docs lag

* ci: gate releases on package checks

* ci: split workflow by tier

* ci: add aggregate PR gates
2026-05-29 18:52:53 -07:00

132 lines
3.5 KiB
Go

//go:build integration && !windows
package doltserver_test
import (
"database/sql"
"net"
"os"
"os/exec"
"path/filepath"
"strconv"
"syscall"
"testing"
"time"
_ "github.com/go-sql-driver/mysql"
"github.com/steveyegge/beads/internal/storage/doltutil"
"github.com/steveyegge/beads/internal/testutil/integration"
)
// TestUnixSocket_ConnectAndQuery starts a Dolt server with --socket,
// connects via the unix socket DSN, and executes SQL to verify end-to-end
// unix socket connectivity. Covers the full path from GH#2939.
func TestUnixSocket_ConnectAndQuery(t *testing.T) {
doltBin := integration.RequireDolt(t)
tmpDir := t.TempDir()
beadsDir := filepath.Join(tmpDir, ".beads")
doltDir := filepath.Join(beadsDir, "dolt")
if err := os.MkdirAll(doltDir, 0700); err != nil {
t.Fatalf("mkdir: %v", err)
}
// Initialize dolt database.
configureDoltTestIdentity(t, doltBin, tmpDir)
initCmd := exec.Command(doltBin, "init")
initCmd.Dir = doltDir
initCmd.Env = doltTestEnv(tmpDir)
if out, err := initCmd.CombinedOutput(); err != nil {
t.Fatalf("dolt init: %v\n%s", err, out)
}
socketPath := filepath.Join(tmpDir, "dolt.sock")
portListener, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
t.Fatalf("allocate TCP port: %v", err)
}
tcpPort := portListener.Addr().(*net.TCPAddr).Port
_ = portListener.Close()
// Start dolt sql-server with --socket. Current Dolt requires a valid TCP
// listener port even when the test connects exclusively over the socket.
serverCmd := exec.Command(doltBin, "sql-server",
"--socket", socketPath,
"--loglevel=warning",
"-H", "127.0.0.1",
"-P", strconv.Itoa(tcpPort),
)
serverCmd.Dir = doltDir
serverCmd.Env = doltTestEnv(tmpDir)
serverCmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
logFile := filepath.Join(tmpDir, "dolt-server.log")
lf, err := os.Create(logFile)
if err != nil {
t.Fatalf("create log file: %v", err)
}
serverCmd.Stdout = lf
serverCmd.Stderr = lf
if err := serverCmd.Start(); err != nil {
lf.Close()
t.Fatalf("dolt sql-server start: %v", err)
}
t.Cleanup(func() {
_ = serverCmd.Process.Signal(syscall.SIGTERM)
_ = serverCmd.Wait()
lf.Close()
})
// Wait for the socket file to become connectable.
deadline := time.Now().Add(10 * time.Second)
for time.Now().Before(deadline) {
conn, err := net.DialTimeout("unix", socketPath, 500*time.Millisecond)
if err == nil {
_ = conn.Close()
break
}
time.Sleep(100 * time.Millisecond)
}
// Connect via unix socket DSN.
dsn := doltutil.ServerDSN{
Socket: socketPath,
User: "root",
Database: "dolt",
}.String()
db, err := sql.Open("mysql", dsn)
if err != nil {
t.Fatalf("sql.Open: %v", err)
}
defer db.Close()
// Verify connectivity.
deadline = time.Now().Add(5 * time.Second)
for time.Now().Before(deadline) {
if err := db.Ping(); err == nil {
break
}
time.Sleep(100 * time.Millisecond)
}
if err := db.Ping(); err != nil {
logs, _ := os.ReadFile(logFile)
t.Fatalf("db.Ping via socket failed: %v\nServer logs:\n%s", err, logs)
}
// Create, insert, query — prove the socket carries real MySQL traffic.
if _, err := db.Exec("CREATE TABLE socket_test (id INT PRIMARY KEY, val VARCHAR(100))"); err != nil {
t.Fatalf("CREATE TABLE: %v", err)
}
if _, err := db.Exec("INSERT INTO socket_test VALUES (1, 'socket-works')"); err != nil {
t.Fatalf("INSERT: %v", err)
}
var val string
if err := db.QueryRow("SELECT val FROM socket_test WHERE id = 1").Scan(&val); err != nil {
t.Fatalf("SELECT: %v", err)
}
if val != "socket-works" {
t.Errorf("expected 'socket-works', got %q", val)
}
}