* 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
132 lines
3.5 KiB
Go
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)
|
|
}
|
|
}
|