Adds a project-agnostic beads_global database to shared-server mode so clients can track issues globally across all projects on the server. - Add EnsureGlobalDatabase() to create the DB during shared server init - Add --global persistent flag to switch CLI commands to the global DB - Add global_dolt_database field to metadata.json for connection info - Seed global DB with issue_prefix="global" and sentinel project ID - Export/import default to global-issues.jsonl with --global flag - --global errors when not in shared-server mode (additive, no breakage) Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
1805 lines
52 KiB
Go
1805 lines
52 KiB
Go
package doltserver
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"net"
|
|
"os"
|
|
"path/filepath"
|
|
"runtime"
|
|
"strconv"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/steveyegge/beads/internal/config"
|
|
"github.com/steveyegge/beads/internal/configfile"
|
|
)
|
|
|
|
func TestAllocateEphemeralPort(t *testing.T) {
|
|
// Should return a valid port in the ephemeral range
|
|
port, err := allocateEphemeralPort("127.0.0.1")
|
|
if err != nil {
|
|
t.Fatalf("allocateEphemeralPort: %v", err)
|
|
}
|
|
if port < 1024 || 65535 < port {
|
|
t.Errorf("port %d outside valid range [1024, 65535]", port)
|
|
}
|
|
|
|
// Multiple calls should return different ports (with very high probability)
|
|
port2, err := allocateEphemeralPort("127.0.0.1")
|
|
if err != nil {
|
|
t.Fatalf("allocateEphemeralPort (2nd call): %v", err)
|
|
}
|
|
if port == port2 {
|
|
t.Logf("warning: two consecutive allocations returned the same port %d (unlikely)", port)
|
|
}
|
|
|
|
// The returned port should be available for binding
|
|
ln, err := net.Listen("tcp", net.JoinHostPort("127.0.0.1", strconv.Itoa(port2)))
|
|
if err != nil {
|
|
t.Logf("warning: allocated port %d not immediately bindable (TOCTOU): %v", port2, err)
|
|
} else {
|
|
_ = ln.Close()
|
|
}
|
|
}
|
|
|
|
func TestAllocateEphemeralPortIPv6(t *testing.T) {
|
|
// Should work with IPv6 loopback if available
|
|
port, err := allocateEphemeralPort("::1")
|
|
if err != nil {
|
|
t.Skipf("IPv6 loopback not available: %v", err)
|
|
}
|
|
if port < 1024 || 65535 < port {
|
|
t.Errorf("port %d outside valid range [1024, 65535]", port)
|
|
}
|
|
}
|
|
|
|
func TestIsRunningNoServer(t *testing.T) {
|
|
dir := t.TempDir()
|
|
|
|
// Unset GT_ROOT so we don't pick up a real daemon PID
|
|
orig := os.Getenv("GT_ROOT")
|
|
os.Unsetenv("GT_ROOT")
|
|
defer func() {
|
|
if orig != "" {
|
|
os.Setenv("GT_ROOT", orig)
|
|
}
|
|
}()
|
|
|
|
state, err := IsRunning(dir)
|
|
if err != nil {
|
|
t.Fatalf("IsRunning error: %v", err)
|
|
}
|
|
if state.Running {
|
|
t.Error("expected Running=false when no PID file exists")
|
|
}
|
|
}
|
|
|
|
func TestIsRunningChecksDaemonPidUnderOrchestrator(t *testing.T) {
|
|
dir := t.TempDir()
|
|
gtRoot := t.TempDir()
|
|
|
|
// Set GT_ROOT to simulate orchestrator environment
|
|
orig := os.Getenv("GT_ROOT")
|
|
os.Setenv("GT_ROOT", gtRoot)
|
|
defer func() {
|
|
if orig != "" {
|
|
os.Setenv("GT_ROOT", orig)
|
|
} else {
|
|
os.Unsetenv("GT_ROOT")
|
|
}
|
|
}()
|
|
|
|
// No daemon PID file, no standard PID file → not running
|
|
state, err := IsRunning(dir)
|
|
if err != nil {
|
|
t.Fatalf("IsRunning error: %v", err)
|
|
}
|
|
if state.Running {
|
|
t.Error("expected Running=false when no PID files exist")
|
|
}
|
|
|
|
// Write a stale daemon PID file → still not running
|
|
daemonDir := filepath.Join(gtRoot, "daemon")
|
|
if err := os.MkdirAll(daemonDir, 0750); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
daemonPidFile := filepath.Join(daemonDir, "dolt.pid")
|
|
if err := os.WriteFile(daemonPidFile, []byte("99999999"), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
state, err = IsRunning(dir)
|
|
if err != nil {
|
|
t.Fatalf("IsRunning error: %v", err)
|
|
}
|
|
if state.Running {
|
|
t.Error("expected Running=false for stale daemon PID")
|
|
}
|
|
|
|
// Daemon PID file should NOT be cleaned up (it's owned by the daemon)
|
|
if _, err := os.Stat(daemonPidFile); os.IsNotExist(err) {
|
|
t.Error("daemon PID file should not be cleaned up by IsRunning")
|
|
}
|
|
}
|
|
|
|
func TestIsRunningStalePID(t *testing.T) {
|
|
dir := t.TempDir()
|
|
|
|
// Unset GT_ROOT so we don't pick up a real daemon PID
|
|
orig := os.Getenv("GT_ROOT")
|
|
os.Unsetenv("GT_ROOT")
|
|
defer func() {
|
|
if orig != "" {
|
|
os.Setenv("GT_ROOT", orig)
|
|
}
|
|
}()
|
|
|
|
// Write a PID file with a definitely-dead PID
|
|
pidFile := filepath.Join(dir, "dolt-server.pid")
|
|
// PID 99999999 almost certainly doesn't exist
|
|
if err := os.WriteFile(pidFile, []byte("99999999"), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
state, err := IsRunning(dir)
|
|
if err != nil {
|
|
t.Fatalf("IsRunning error: %v", err)
|
|
}
|
|
if state.Running {
|
|
t.Error("expected Running=false for stale PID")
|
|
}
|
|
|
|
// PID file should have been cleaned up
|
|
if _, err := os.Stat(pidFile); !os.IsNotExist(err) {
|
|
t.Error("expected stale PID file to be removed")
|
|
}
|
|
}
|
|
|
|
func TestIsRunningStalePIDRemovesPortFile(t *testing.T) {
|
|
dir := t.TempDir()
|
|
|
|
if err := os.WriteFile(pidPath(dir), []byte("99999999"), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := writePortFile(dir, 14567); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
state, err := IsRunning(dir)
|
|
if err != nil {
|
|
t.Fatalf("IsRunning error: %v", err)
|
|
}
|
|
if state.Running {
|
|
t.Error("expected Running=false for stale PID")
|
|
}
|
|
if _, err := os.Stat(portPath(dir)); !os.IsNotExist(err) {
|
|
t.Error("expected stale port file to be removed")
|
|
}
|
|
}
|
|
|
|
func TestIsRunningCorruptPID(t *testing.T) {
|
|
dir := t.TempDir()
|
|
|
|
// Unset GT_ROOT so we don't pick up a real daemon PID
|
|
orig := os.Getenv("GT_ROOT")
|
|
os.Unsetenv("GT_ROOT")
|
|
defer func() {
|
|
if orig != "" {
|
|
os.Setenv("GT_ROOT", orig)
|
|
}
|
|
}()
|
|
|
|
pidFile := filepath.Join(dir, "dolt-server.pid")
|
|
if err := os.WriteFile(pidFile, []byte("not-a-number"), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
state, err := IsRunning(dir)
|
|
if err != nil {
|
|
t.Fatalf("IsRunning error: %v", err)
|
|
}
|
|
if state.Running {
|
|
t.Error("expected Running=false for corrupt PID file")
|
|
}
|
|
|
|
// PID file should have been cleaned up
|
|
if _, err := os.Stat(pidFile); !os.IsNotExist(err) {
|
|
t.Error("expected corrupt PID file to be removed")
|
|
}
|
|
}
|
|
|
|
func TestIsRunningCorruptPIDRemovesPortFile(t *testing.T) {
|
|
dir := t.TempDir()
|
|
|
|
if err := os.WriteFile(pidPath(dir), []byte("not-a-number"), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := writePortFile(dir, 14567); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
state, err := IsRunning(dir)
|
|
if err != nil {
|
|
t.Fatalf("IsRunning error: %v", err)
|
|
}
|
|
if state.Running {
|
|
t.Error("expected Running=false for corrupt PID file")
|
|
}
|
|
if _, err := os.Stat(portPath(dir)); !os.IsNotExist(err) {
|
|
t.Error("expected stale port file to be removed")
|
|
}
|
|
}
|
|
|
|
func TestDefaultConfig(t *testing.T) {
|
|
t.Run("standalone_returns_zero_port", func(t *testing.T) {
|
|
// Clear env vars to test pure standalone behavior
|
|
t.Setenv("GT_ROOT", "")
|
|
t.Setenv("BEADS_DOLT_SERVER_PORT", "")
|
|
|
|
freshDir := t.TempDir()
|
|
cfg := DefaultConfig(freshDir)
|
|
if cfg.Host != "127.0.0.1" {
|
|
t.Errorf("expected host 127.0.0.1, got %s", cfg.Host)
|
|
}
|
|
// No configured port source → port 0 (ephemeral allocation on Start)
|
|
if cfg.Port != 0 {
|
|
t.Errorf("expected port 0 (ephemeral) when no port source configured, got %d", cfg.Port)
|
|
}
|
|
if cfg.BeadsDir != freshDir {
|
|
t.Errorf("expected BeadsDir=%s, got %s", freshDir, cfg.BeadsDir)
|
|
}
|
|
})
|
|
|
|
t.Run("config_yaml_port", func(t *testing.T) {
|
|
// When config.yaml sets dolt.port, DefaultConfig should use it
|
|
// (provided no env var or metadata.json port is set).
|
|
t.Setenv("GT_ROOT", "")
|
|
t.Setenv("BEADS_DOLT_SERVER_PORT", "")
|
|
|
|
// Create a temp dir with config.yaml containing dolt.port
|
|
configDir := t.TempDir()
|
|
configYaml := filepath.Join(configDir, "config.yaml")
|
|
if err := os.WriteFile(configYaml, []byte("dolt.port: 3308\n"), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Point BEADS_DIR at the config dir so config.Initialize() picks it up
|
|
t.Setenv("BEADS_DIR", configDir)
|
|
if err := config.Initialize(); err != nil {
|
|
t.Fatalf("config.Initialize: %v", err)
|
|
}
|
|
t.Cleanup(config.ResetForTesting)
|
|
|
|
freshDir := t.TempDir()
|
|
cfg := DefaultConfig(freshDir)
|
|
if cfg.Port != 3308 {
|
|
t.Errorf("expected port 3308 from config.yaml, got %d", cfg.Port)
|
|
}
|
|
})
|
|
|
|
t.Run("no_config_returns_zero_port", func(t *testing.T) {
|
|
// When no env var, no metadata port, no port file, and no config.yaml,
|
|
// DefaultConfig should return port 0 (ephemeral allocation on Start).
|
|
t.Setenv("GT_ROOT", "")
|
|
t.Setenv("BEADS_DOLT_SERVER_PORT", "")
|
|
|
|
freshDir := t.TempDir()
|
|
cfg := DefaultConfig(freshDir)
|
|
|
|
if cfg.Port != 0 {
|
|
t.Errorf("expected port 0 (ephemeral) when no port source, got %d", cfg.Port)
|
|
}
|
|
})
|
|
|
|
t.Run("port_file_takes_precedence_over_ephemeral", func(t *testing.T) {
|
|
// When a port file exists (written by Start()), DefaultConfig should
|
|
// use it.
|
|
t.Setenv("GT_ROOT", "")
|
|
t.Setenv("BEADS_DOLT_SERVER_PORT", "")
|
|
|
|
freshDir := t.TempDir()
|
|
if err := writePortFile(freshDir, 14000); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
cfg := DefaultConfig(freshDir)
|
|
|
|
if cfg.Port != 14000 {
|
|
t.Errorf("expected port file port 14000, got %d", cfg.Port)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestEnsurePortFile(t *testing.T) {
|
|
beadsDir := t.TempDir()
|
|
portFile := filepath.Join(beadsDir, "dolt-server.port")
|
|
|
|
if err := EnsurePortFile(beadsDir, 14567); err != nil {
|
|
t.Fatalf("EnsurePortFile(write missing): %v", err)
|
|
}
|
|
if data, err := os.ReadFile(portFile); err != nil {
|
|
t.Fatalf("ReadFile(missing): %v", err)
|
|
} else if got := strings.TrimSpace(string(data)); got != "14567" {
|
|
t.Fatalf("port file = %q, want 14567", got)
|
|
}
|
|
|
|
if err := os.WriteFile(portFile, []byte("bad"), 0600); err != nil {
|
|
t.Fatalf("WriteFile(corrupt): %v", err)
|
|
}
|
|
if err := EnsurePortFile(beadsDir, 14568); err != nil {
|
|
t.Fatalf("EnsurePortFile(repair corrupt): %v", err)
|
|
}
|
|
if data, err := os.ReadFile(portFile); err != nil {
|
|
t.Fatalf("ReadFile(repaired): %v", err)
|
|
} else if got := strings.TrimSpace(string(data)); got != "14568" {
|
|
t.Fatalf("repaired port file = %q, want 14568", got)
|
|
}
|
|
|
|
if err := os.WriteFile(portFile, []byte("14569"), 0600); err != nil {
|
|
t.Fatalf("WriteFile(stale): %v", err)
|
|
}
|
|
if err := EnsurePortFile(beadsDir, 14570); err != nil {
|
|
t.Fatalf("EnsurePortFile(update stale): %v", err)
|
|
}
|
|
if data, err := os.ReadFile(portFile); err != nil {
|
|
t.Fatalf("ReadFile(updated): %v", err)
|
|
} else if got := strings.TrimSpace(string(data)); got != "14570" {
|
|
t.Fatalf("updated port file = %q, want 14570", got)
|
|
}
|
|
}
|
|
|
|
func TestStopNotRunning(t *testing.T) {
|
|
dir := t.TempDir()
|
|
|
|
err := Stop(dir)
|
|
if err == nil {
|
|
t.Error("expected error when stopping non-running server")
|
|
}
|
|
}
|
|
|
|
// --- Port collision fallback tests ---
|
|
|
|
func TestIsPortAvailable(t *testing.T) {
|
|
// Bind a port to make it unavailable
|
|
ln, err := net.Listen("tcp", "127.0.0.1:0")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer ln.Close()
|
|
|
|
addr := ln.Addr().(*net.TCPAddr)
|
|
if isPortAvailable("127.0.0.1", addr.Port) {
|
|
t.Error("expected port to be unavailable while listener is active")
|
|
}
|
|
|
|
// A random high port should generally be available
|
|
if !isPortAvailable("127.0.0.1", 0) {
|
|
t.Log("warning: port 0 reported as unavailable (unusual)")
|
|
}
|
|
}
|
|
|
|
func TestReclaimPortAvailable(t *testing.T) {
|
|
dir := t.TempDir()
|
|
// When the port is free, reclaimPort should return (0, nil)
|
|
adoptPID, err := reclaimPort("127.0.0.1", 14200, dir)
|
|
if err != nil {
|
|
t.Errorf("reclaimPort failed on free port: %v", err)
|
|
}
|
|
if adoptPID != 0 {
|
|
t.Errorf("expected adoptPID=0 for free port, got %d", adoptPID)
|
|
}
|
|
}
|
|
|
|
func TestReclaimPortBusyNonDolt(t *testing.T) {
|
|
dir := t.TempDir()
|
|
// Occupy a port with a non-dolt process
|
|
ln, err := net.Listen("tcp", "127.0.0.1:0")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer ln.Close()
|
|
occupiedPort := ln.Addr().(*net.TCPAddr).Port
|
|
|
|
// reclaimPort should fail (not silently use another port)
|
|
adoptPID, err := reclaimPort("127.0.0.1", occupiedPort, dir)
|
|
if err == nil {
|
|
t.Error("reclaimPort should fail when a non-dolt process holds the port")
|
|
}
|
|
if adoptPID != 0 {
|
|
t.Errorf("expected adoptPID=0 on error, got %d", adoptPID)
|
|
}
|
|
}
|
|
|
|
func TestMaxDoltServers(t *testing.T) {
|
|
t.Run("standalone", func(t *testing.T) {
|
|
orig := os.Getenv("GT_ROOT")
|
|
os.Unsetenv("GT_ROOT")
|
|
defer func() {
|
|
if orig != "" {
|
|
os.Setenv("GT_ROOT", orig)
|
|
}
|
|
}()
|
|
|
|
// CWD must be outside any orchestrator workspace for standalone test
|
|
origWd, err := os.Getwd()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.Chdir(t.TempDir()); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer os.Chdir(origWd)
|
|
|
|
if max := maxDoltServers(); max != 3 {
|
|
t.Errorf("expected 3 in standalone mode, got %d", max)
|
|
}
|
|
})
|
|
|
|
t.Run("orchestrator_same_as_standalone", func(t *testing.T) {
|
|
// After daemon removal, GT_ROOT no longer affects maxDoltServers
|
|
t.Setenv("GT_ROOT", t.TempDir())
|
|
|
|
if max := maxDoltServers(); max != 3 {
|
|
t.Errorf("expected 3 (daemon removed, no special GT_ROOT handling), got %d", max)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestIsProcessInDir(t *testing.T) {
|
|
if runtime.GOOS == "windows" {
|
|
t.Skip("isProcessInDir always returns false on Windows (CWD not exposed)")
|
|
}
|
|
// Our own process should have a CWD we can check
|
|
cwd, err := os.Getwd()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Our PID should be in our CWD
|
|
if !isProcessInDir(os.Getpid(), cwd) {
|
|
t.Log("isProcessInDir returned false for own process CWD (lsof may not be available)")
|
|
}
|
|
|
|
// Our PID should NOT be in a random temp dir
|
|
if isProcessInDir(os.Getpid(), t.TempDir()) {
|
|
t.Error("isProcessInDir should return false for wrong directory")
|
|
}
|
|
|
|
// Dead PID should return false
|
|
if isProcessInDir(99999999, cwd) {
|
|
t.Error("isProcessInDir should return false for dead PID")
|
|
}
|
|
}
|
|
|
|
func TestCountDoltProcesses(t *testing.T) {
|
|
// Just verify it doesn't panic and returns a non-negative number
|
|
count := countDoltProcesses()
|
|
if count < 0 {
|
|
t.Errorf("countDoltProcesses returned negative: %d", count)
|
|
}
|
|
}
|
|
|
|
func TestFindPIDOnPortEmpty(t *testing.T) {
|
|
// A port nobody is listening on should return 0
|
|
pid := findPIDOnPort(19999)
|
|
if pid != 0 {
|
|
t.Errorf("expected 0 for unused port, got %d", pid)
|
|
}
|
|
}
|
|
|
|
func TestPortFileReadWrite(t *testing.T) {
|
|
dir := t.TempDir()
|
|
|
|
// No file yet
|
|
if port := readPortFile(dir); port != 0 {
|
|
t.Errorf("expected 0 for missing port file, got %d", port)
|
|
}
|
|
|
|
// Write and read back
|
|
if err := writePortFile(dir, 13500); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if port := readPortFile(dir); port != 13500 {
|
|
t.Errorf("expected 13500, got %d", port)
|
|
}
|
|
|
|
// Corrupt file
|
|
if err := os.WriteFile(portPath(dir), []byte("garbage"), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if port := readPortFile(dir); port != 0 {
|
|
t.Errorf("expected 0 for corrupt port file, got %d", port)
|
|
}
|
|
}
|
|
|
|
func TestIsRunningReadsPortFile(t *testing.T) {
|
|
dir := t.TempDir()
|
|
|
|
// Write a port file with a custom port
|
|
if err := writePortFile(dir, 13999); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Write a stale PID — IsRunning will clean up, but let's verify port file is read
|
|
// when a valid process exists. Since we can't easily fake a running dolt process,
|
|
// just verify the port file read function works correctly.
|
|
port := readPortFile(dir)
|
|
if port != 13999 {
|
|
t.Errorf("expected port 13999 from port file, got %d", port)
|
|
}
|
|
}
|
|
|
|
// --- IsRunning port-zero orphan recovery ---
|
|
|
|
func TestIsRunningOrphanNoPortFile(t *testing.T) {
|
|
// When PID file exists but process is dead and no port file,
|
|
// IsRunning should clean up and return Running=false.
|
|
// (The orphan kill path for *live* processes requires a real dolt server,
|
|
// but the dead-PID cleanup path exercises the same code structure.)
|
|
dir := t.TempDir()
|
|
t.Setenv("GT_ROOT", "")
|
|
t.Setenv("BEADS_DOLT_SERVER_PORT", "")
|
|
|
|
// Write PID file with dead PID, no port file
|
|
if err := os.WriteFile(pidPath(dir), []byte("99999999"), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
state, err := IsRunning(dir)
|
|
if err != nil {
|
|
t.Fatalf("IsRunning error: %v", err)
|
|
}
|
|
if state.Running {
|
|
t.Error("expected Running=false for dead PID with no port file")
|
|
}
|
|
// PID file should be cleaned up
|
|
if _, err := os.Stat(pidPath(dir)); !os.IsNotExist(err) {
|
|
t.Error("expected PID file to be removed")
|
|
}
|
|
}
|
|
|
|
func TestCleanupStateFiles(t *testing.T) {
|
|
dir := t.TempDir()
|
|
|
|
// Create all state files
|
|
for _, path := range []string{
|
|
pidPath(dir),
|
|
portPath(dir),
|
|
} {
|
|
if err := os.WriteFile(path, []byte("test"), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
cleanupStateFiles(dir)
|
|
|
|
for _, path := range []string{
|
|
pidPath(dir),
|
|
portPath(dir),
|
|
} {
|
|
if _, err := os.Stat(path); !os.IsNotExist(err) {
|
|
t.Errorf("expected %s to be removed", filepath.Base(path))
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestStopNotRunningCleansUpStateFiles verifies that calling Stop when the server
|
|
// is not running still removes leftover PID/port files, so bd dolt status won't
|
|
// report stale state (GH#2670).
|
|
func TestStopNotRunningCleansUpStateFiles(t *testing.T) {
|
|
dir := t.TempDir()
|
|
|
|
// Create stale PID/port files pointing to a non-existent process
|
|
if err := os.WriteFile(pidPath(dir), []byte("999999999"), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(portPath(dir), []byte("13307"), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Stop should return ErrServerNotRunning but still clean up files
|
|
err := Stop(dir)
|
|
if !errors.Is(err, ErrServerNotRunning) {
|
|
t.Fatalf("expected ErrServerNotRunning, got: %v", err)
|
|
}
|
|
|
|
// Verify state files were cleaned up
|
|
if _, statErr := os.Stat(pidPath(dir)); !os.IsNotExist(statErr) {
|
|
t.Error("PID file should be removed after Stop on dead server")
|
|
}
|
|
if _, statErr := os.Stat(portPath(dir)); !os.IsNotExist(statErr) {
|
|
t.Error("port file should be removed after Stop on dead server")
|
|
}
|
|
}
|
|
|
|
// TestCleanupStateFilesReturnsError verifies that cleanupStateFiles returns
|
|
// errors when removal fails for reasons other than NotExist (e.g., permission denied).
|
|
func TestCleanupStateFilesReturnsError(t *testing.T) {
|
|
if runtime.GOOS == "windows" {
|
|
t.Skip("chmod not effective on Windows")
|
|
}
|
|
dir := t.TempDir()
|
|
|
|
// Create a PID file then make the directory read-only so removal fails.
|
|
if err := os.WriteFile(pidPath(dir), []byte("12345"), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.Chmod(dir, 0555); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { os.Chmod(dir, 0755) })
|
|
|
|
err := cleanupStateFiles(dir)
|
|
if err == nil {
|
|
t.Error("expected error when directory is read-only, got nil")
|
|
}
|
|
}
|
|
|
|
// TestCleanupStateFilesNoFiles verifies cleanupStateFiles returns nil
|
|
// when no state files exist (already clean).
|
|
func TestCleanupStateFilesNoFiles(t *testing.T) {
|
|
dir := t.TempDir()
|
|
err := cleanupStateFiles(dir)
|
|
if err != nil {
|
|
t.Errorf("expected nil for missing files, got: %v", err)
|
|
}
|
|
}
|
|
|
|
// TestStopNoStateFiles verifies Stop on an empty directory (no PID/port files)
|
|
// returns ErrServerNotRunning with no cleanup errors.
|
|
func TestStopNoStateFiles(t *testing.T) {
|
|
dir := t.TempDir()
|
|
err := Stop(dir)
|
|
if !errors.Is(err, ErrServerNotRunning) {
|
|
t.Fatalf("expected ErrServerNotRunning, got: %v", err)
|
|
}
|
|
// Should be the pure sentinel since there are no files to fail on.
|
|
remaining := IgnoreNotRunning(err)
|
|
if remaining != nil {
|
|
t.Errorf("expected no cleanup errors, got: %v", remaining)
|
|
}
|
|
}
|
|
|
|
// TestStopNotRunningWithCleanupError verifies that Stop returns both the
|
|
// sentinel and cleanup errors when the server is not running but state
|
|
// files can't be removed.
|
|
func TestStopNotRunningWithCleanupError(t *testing.T) {
|
|
if runtime.GOOS == "windows" {
|
|
t.Skip("chmod not effective on Windows")
|
|
}
|
|
dir := t.TempDir()
|
|
|
|
// Create stale PID file, then make dir read-only.
|
|
if err := os.WriteFile(pidPath(dir), []byte("999999999"), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.Chmod(dir, 0555); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { os.Chmod(dir, 0755) })
|
|
|
|
err := Stop(dir)
|
|
if !errors.Is(err, ErrServerNotRunning) {
|
|
t.Fatalf("expected ErrServerNotRunning in error, got: %v", err)
|
|
}
|
|
// Should also contain the cleanup error.
|
|
remaining := IgnoreNotRunning(err)
|
|
if remaining == nil {
|
|
t.Error("expected cleanup error to be preserved, got nil")
|
|
}
|
|
}
|
|
|
|
func TestKillStaleServersPreservesOtherRepoServers(t *testing.T) {
|
|
t.Setenv("BEADS_DOLT_AUTO_START", "") // ensure auto-start guard doesn't short-circuit
|
|
dir := t.TempDir()
|
|
canonicalPID := 111
|
|
sameRepoOrphanPID := 222
|
|
otherRepoPID := 333
|
|
|
|
if err := os.WriteFile(pidPath(dir), []byte(strconv.Itoa(canonicalPID)), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
var killed []int
|
|
got, err := killStaleServersForDir(
|
|
dir,
|
|
[]int{canonicalPID, sameRepoOrphanPID, otherRepoPID},
|
|
func(pid int, doltDir string) bool {
|
|
if doltDir != ResolveDoltDir(dir) {
|
|
t.Fatalf("unexpected dolt dir: got %q want %q", doltDir, ResolveDoltDir(dir))
|
|
}
|
|
return pid == canonicalPID || pid == sameRepoOrphanPID
|
|
},
|
|
func(pid int) error {
|
|
killed = append(killed, pid)
|
|
return nil
|
|
},
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("killStaleServersForDir error: %v", err)
|
|
}
|
|
if len(got) != 1 || got[0] != sameRepoOrphanPID {
|
|
t.Fatalf("killed=%v, want [%d]", got, sameRepoOrphanPID)
|
|
}
|
|
if len(killed) != 1 || killed[0] != sameRepoOrphanPID {
|
|
t.Fatalf("kill callback got %v, want [%d]", killed, sameRepoOrphanPID)
|
|
}
|
|
}
|
|
|
|
func TestKillStaleServersWithoutCanonicalPIDIsNoop(t *testing.T) {
|
|
// Without a PID file, beads has no record of starting a server.
|
|
// killStaleServersForDir should be a no-op to avoid killing
|
|
// externally-managed servers (systemd, other repos, etc).
|
|
dir := t.TempDir()
|
|
sameRepoOrphanPID := 222
|
|
otherRepoPID := 333
|
|
|
|
var killed []int
|
|
got, err := killStaleServersForDir(
|
|
dir,
|
|
[]int{sameRepoOrphanPID, otherRepoPID},
|
|
func(pid int, _ string) bool {
|
|
return pid == sameRepoOrphanPID
|
|
},
|
|
func(pid int) error {
|
|
killed = append(killed, pid)
|
|
return nil
|
|
},
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("killStaleServersForDir error: %v", err)
|
|
}
|
|
if len(got) != 0 {
|
|
t.Fatalf("killed=%v, want [] (no PID file means nothing is stale)", got)
|
|
}
|
|
if len(killed) != 0 {
|
|
t.Fatalf("kill callback got %v, want [] (no PID file means nothing is stale)", killed)
|
|
}
|
|
}
|
|
|
|
func TestKillStaleServersSkipsExplicitPort(t *testing.T) {
|
|
// When metadata.json has an explicit port, the server is externally
|
|
// managed and killStaleServersForDir should be a complete no-op.
|
|
dir := t.TempDir()
|
|
|
|
// Write a metadata.json with an explicit port
|
|
metadataPath := filepath.Join(dir, "metadata.json")
|
|
if err := os.WriteFile(metadataPath, []byte(`{"dolt_server_port": 3307}`), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Write a PID file (would normally trigger stale cleanup)
|
|
canonicalPID := 111
|
|
if err := os.WriteFile(pidPath(dir), []byte(strconv.Itoa(canonicalPID)), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
orphanPID := 222
|
|
var killed []int
|
|
got, err := killStaleServersForDir(
|
|
dir,
|
|
[]int{canonicalPID, orphanPID},
|
|
func(pid int, _ string) bool { return true },
|
|
func(pid int) error {
|
|
killed = append(killed, pid)
|
|
return nil
|
|
},
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("killStaleServersForDir error: %v", err)
|
|
}
|
|
if len(got) != 0 {
|
|
t.Fatalf("killed=%v, want [] (explicit port = externally managed)", got)
|
|
}
|
|
}
|
|
|
|
func TestKillStaleServersSkipsAutoStartDisabled(t *testing.T) {
|
|
// When BEADS_DOLT_AUTO_START=0, the server is externally managed
|
|
// and killStaleServersForDir should be a complete no-op.
|
|
dir := t.TempDir()
|
|
t.Setenv("BEADS_DOLT_AUTO_START", "0")
|
|
|
|
// Write a PID file
|
|
canonicalPID := 111
|
|
if err := os.WriteFile(pidPath(dir), []byte(strconv.Itoa(canonicalPID)), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
orphanPID := 222
|
|
var killed []int
|
|
got, err := killStaleServersForDir(
|
|
dir,
|
|
[]int{canonicalPID, orphanPID},
|
|
func(pid int, _ string) bool { return true },
|
|
func(pid int) error {
|
|
killed = append(killed, pid)
|
|
return nil
|
|
},
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("killStaleServersForDir error: %v", err)
|
|
}
|
|
if len(got) != 0 {
|
|
t.Fatalf("killed=%v, want [] (auto-start disabled = externally managed)", got)
|
|
}
|
|
}
|
|
|
|
func TestIsAutoStartDisabled(t *testing.T) {
|
|
tests := []struct {
|
|
envVal string
|
|
want bool
|
|
}{
|
|
// strconv.ParseBool falsy values → disabled
|
|
{"0", true},
|
|
{"f", true},
|
|
{"F", true},
|
|
{"false", true},
|
|
{"FALSE", true},
|
|
{"False", true},
|
|
// backward-compat "off" (case-insensitive) → disabled
|
|
{"off", true},
|
|
{"OFF", true},
|
|
{"Off", true},
|
|
// whitespace-trimmed falsy values → disabled
|
|
{" 0 ", true},
|
|
{" false ", true},
|
|
{"\toff\n", true},
|
|
// whitespace-trimmed truthy value → enabled (not disabled)
|
|
{" true ", false},
|
|
// strconv.ParseBool truthy values → enabled (not disabled)
|
|
{"1", false},
|
|
{"t", false},
|
|
{"T", false},
|
|
{"true", false},
|
|
{"TRUE", false},
|
|
{"True", false},
|
|
// empty / unset → enabled (not disabled)
|
|
{"", false},
|
|
// unrecognized values → enabled (fail-open, not disabled)
|
|
{"no", false},
|
|
{"disabled", false},
|
|
{"nope", false},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run("env="+tt.envVal, func(t *testing.T) {
|
|
t.Setenv("BEADS_DOLT_AUTO_START", tt.envVal)
|
|
if got := IsAutoStartDisabled(); got != tt.want {
|
|
t.Errorf("IsAutoStartDisabled() = %v, want %v", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestIsAutoStartDisabled_Sources verifies that disable is OR-ed across
|
|
// env and config: either source can independently disable auto-start, and
|
|
// there is no way to force-enable via one source when the other says disabled.
|
|
func TestIsAutoStartDisabled_Sources(t *testing.T) {
|
|
// Initialize config so config.Set/GetString works.
|
|
t.Chdir(t.TempDir())
|
|
if err := config.Initialize(); err != nil {
|
|
t.Fatalf("config.Initialize: %v", err)
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
env string
|
|
cfg string
|
|
want bool
|
|
}{
|
|
{"env_disabled_config_enabled", "0", "true", true}, // env wins
|
|
{"env_empty_config_disabled", "", "false", true}, // config kicks in
|
|
{"env_empty_config_off", "", "off", true}, // config "off" works
|
|
{"env_empty_config_OFF", "", "OFF", true}, // config case-insensitive
|
|
{"env_empty_config_0", "", "0", true}, // config "0"
|
|
{"env_enabled_config_disabled", "1", "false", true}, // config still disables; env can't force-enable
|
|
{"both_empty", "", "", false}, // neither set
|
|
{"env_off_config_true", "off", "true", true}, // env wins
|
|
// config with ParseBool-expanded values
|
|
{"env_empty_config_f", "", "f", true}, // config "f"
|
|
{"env_empty_config_F", "", "F", true}, // config "F"
|
|
{"env_t_config_empty", "t", "", false}, // env truthy, config unset
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
t.Setenv("BEADS_DOLT_AUTO_START", tt.env)
|
|
config.Set("dolt.auto-start", tt.cfg)
|
|
defer config.Set("dolt.auto-start", "")
|
|
if got := IsAutoStartDisabled(); got != tt.want {
|
|
t.Errorf("IsAutoStartDisabled() = %v, want %v (env=%q, cfg=%q)",
|
|
got, tt.want, tt.env, tt.cfg)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestIgnoreNotRunning(t *testing.T) {
|
|
cleanupErr := errors.New("permission denied")
|
|
|
|
tests := []struct {
|
|
name string
|
|
err error
|
|
wantNil bool
|
|
wantMsg string
|
|
}{
|
|
{"nil", nil, true, ""},
|
|
{"pure_sentinel", ErrServerNotRunning, true, ""},
|
|
{"joined_sentinel_nil", errors.Join(ErrServerNotRunning, nil), true, ""},
|
|
{"joined_sentinel_cleanup", errors.Join(ErrServerNotRunning, cleanupErr), false, "permission denied"},
|
|
{"unrelated_error", errors.New("connection refused"), false, "connection refused"},
|
|
{"single_wrapped_sentinel", fmt.Errorf("stop: %w", ErrServerNotRunning), true, ""},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got := IgnoreNotRunning(tt.err)
|
|
if tt.wantNil {
|
|
if got != nil {
|
|
t.Errorf("IgnoreNotRunning() = %v, want nil", got)
|
|
}
|
|
} else {
|
|
if got == nil {
|
|
t.Fatal("IgnoreNotRunning() = nil, want error")
|
|
}
|
|
if !strings.Contains(got.Error(), tt.wantMsg) {
|
|
t.Errorf("IgnoreNotRunning() = %q, want containing %q", got, tt.wantMsg)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestFlushWorkingSetUnreachable(t *testing.T) {
|
|
// FlushWorkingSet should return an error when the server is not reachable.
|
|
err := FlushWorkingSet("127.0.0.1", 19998)
|
|
if err == nil {
|
|
t.Error("expected error when server is unreachable")
|
|
}
|
|
if !strings.Contains(err.Error(), "not reachable") {
|
|
t.Errorf("expected 'not reachable' in error, got: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestIsDoltProcessDeadPID(t *testing.T) {
|
|
// A non-existent PID should return false (ps will fail)
|
|
if isDoltProcess(99999999) {
|
|
t.Error("expected isDoltProcess to return false for dead PID")
|
|
}
|
|
}
|
|
|
|
func TestIsDoltProcessSelf(t *testing.T) {
|
|
// Our own process is not a dolt sql-server, so should return false
|
|
if isDoltProcess(os.Getpid()) {
|
|
t.Error("expected isDoltProcess to return false for non-dolt process")
|
|
}
|
|
}
|
|
|
|
// --- Ephemeral port tests ---
|
|
|
|
func TestDefaultConfigReturnsZeroForStandalone(t *testing.T) {
|
|
// DefaultConfig must return port 0 for standalone mode (no configured
|
|
// port source). Start() will allocate an ephemeral port from the OS,
|
|
// giving each project a unique port without hash collisions (GH#2098).
|
|
t.Setenv("GT_ROOT", "")
|
|
t.Setenv("BEADS_DOLT_SERVER_PORT", "")
|
|
|
|
dir := t.TempDir()
|
|
cfg := DefaultConfig(dir)
|
|
if cfg.Port != 0 {
|
|
t.Errorf("DefaultConfig should return port 0 (ephemeral) for standalone, got %d",
|
|
cfg.Port)
|
|
}
|
|
}
|
|
|
|
func TestDefaultConfigEnvVarOverridesEphemeral(t *testing.T) {
|
|
// Explicit env var should always take precedence over ephemeral.
|
|
t.Setenv("BEADS_DOLT_SERVER_PORT", "15000")
|
|
dir := t.TempDir()
|
|
cfg := DefaultConfig(dir)
|
|
if cfg.Port != 15000 {
|
|
t.Errorf("expected env var port 15000, got %d", cfg.Port)
|
|
}
|
|
}
|
|
|
|
func TestDefaultConfigPortFileTakesPrecedence(t *testing.T) {
|
|
// Port file (written by Start) should take precedence over ephemeral.
|
|
t.Setenv("GT_ROOT", "")
|
|
t.Setenv("BEADS_DOLT_SERVER_PORT", "")
|
|
|
|
dir := t.TempDir()
|
|
if err := writePortFile(dir, 14567); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
cfg := DefaultConfig(dir)
|
|
if cfg.Port != 14567 {
|
|
t.Errorf("expected port file port 14567, got %d", cfg.Port)
|
|
}
|
|
}
|
|
|
|
func TestReadPortFile_Empty(t *testing.T) {
|
|
// ReadPortFile on a directory with no port file should return 0.
|
|
dir := t.TempDir()
|
|
if p := ReadPortFile(dir); p != 0 {
|
|
t.Errorf("expected 0 for missing port file, got %d", p)
|
|
}
|
|
}
|
|
|
|
func TestReadPortFile_Valid(t *testing.T) {
|
|
dir := t.TempDir()
|
|
if err := writePortFile(dir, 12345); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if p := ReadPortFile(dir); p != 12345 {
|
|
t.Errorf("expected 12345, got %d", p)
|
|
}
|
|
}
|
|
|
|
// TestReadPortFile_IgnoresConfigYaml verifies that ReadPortFile only reads
|
|
// the port file, NOT config.yaml. This is the crux of the GH#2336 fix:
|
|
// bd init uses ReadPortFile instead of DefaultConfig to avoid inheriting
|
|
// another project's port from config.yaml or global config.
|
|
func TestReadPortFile_IgnoresConfigYaml(t *testing.T) {
|
|
dir := t.TempDir()
|
|
|
|
// Write a config.yaml with a dolt port (simulating another project's config)
|
|
configPath := filepath.Join(dir, "config.yaml")
|
|
if err := os.WriteFile(configPath, []byte("dolt:\n port: 9999\n"), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// ReadPortFile must return 0 — it should ONLY read the port file,
|
|
// not config.yaml. This prevents cross-project leakage during init.
|
|
if p := ReadPortFile(dir); p != 0 {
|
|
t.Errorf("ReadPortFile should ignore config.yaml, got port %d", p)
|
|
}
|
|
}
|
|
|
|
// --- Pre-v56 dolt database detection tests (GH#2137) ---
|
|
|
|
func TestIsPreV56DoltDir_NoMarker(t *testing.T) {
|
|
doltDir := t.TempDir()
|
|
dotDolt := filepath.Join(doltDir, ".dolt")
|
|
if err := os.MkdirAll(dotDolt, 0750); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// .dolt/ exists but no .bd-dolt-ok marker → pre-v56
|
|
if !IsPreV56DoltDir(doltDir) {
|
|
t.Error("expected pre-v56 detection when .dolt/ exists without marker")
|
|
}
|
|
}
|
|
|
|
func TestIsPreV56DoltDir_WithMarker(t *testing.T) {
|
|
doltDir := t.TempDir()
|
|
dotDolt := filepath.Join(doltDir, ".dolt")
|
|
if err := os.MkdirAll(dotDolt, 0750); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// Write the marker
|
|
if err := os.WriteFile(filepath.Join(doltDir, bdDoltMarker), []byte("ok\n"), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if IsPreV56DoltDir(doltDir) {
|
|
t.Error("expected NOT pre-v56 when marker exists")
|
|
}
|
|
}
|
|
|
|
func TestIsPreV56DoltDir_NoDotDolt(t *testing.T) {
|
|
doltDir := t.TempDir()
|
|
// No .dolt/ at all → not pre-v56 (nothing to recover)
|
|
if IsPreV56DoltDir(doltDir) {
|
|
t.Error("expected NOT pre-v56 when .dolt/ doesn't exist")
|
|
}
|
|
}
|
|
|
|
func TestEnsureDoltInit_SeedsMarker(t *testing.T) {
|
|
doltDir := t.TempDir()
|
|
dotDolt := filepath.Join(doltDir, ".dolt", "noms")
|
|
if err := os.MkdirAll(dotDolt, 0750); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// No marker → simulates existing database
|
|
|
|
// ensureDoltInit should seed the marker (non-destructive)
|
|
if err := ensureDoltInit(doltDir); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// After seeding, should no longer be detected as pre-v56
|
|
if IsPreV56DoltDir(doltDir) {
|
|
t.Error("expected marker to be seeded for existing database")
|
|
}
|
|
|
|
// .dolt/ should still exist (not deleted)
|
|
if _, err := os.Stat(filepath.Join(doltDir, ".dolt")); os.IsNotExist(err) {
|
|
t.Error("expected .dolt/ to still exist after seeding")
|
|
}
|
|
}
|
|
|
|
func TestRecoverPreV56DoltDir(t *testing.T) {
|
|
doltDir := t.TempDir()
|
|
dotDolt := filepath.Join(doltDir, ".dolt", "noms")
|
|
if err := os.MkdirAll(dotDolt, 0750); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// Write a sentinel file to verify deletion
|
|
sentinel := filepath.Join(doltDir, ".dolt", "sentinel.txt")
|
|
if err := os.WriteFile(sentinel, []byte("old data"), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// RecoverPreV56DoltDir should remove the old .dolt/ and reinitialize
|
|
recovered, err := RecoverPreV56DoltDir(doltDir)
|
|
if err != nil {
|
|
// dolt might not be installed; check if .dolt/ was at least removed
|
|
if _, statErr := os.Stat(sentinel); !os.IsNotExist(statErr) {
|
|
t.Error("expected old .dolt/ contents to be removed during recovery")
|
|
}
|
|
t.Skipf("recovery partially completed (dolt init may have failed): %v", err)
|
|
}
|
|
if !recovered {
|
|
t.Error("expected recovery to be performed")
|
|
}
|
|
|
|
// Old sentinel should be gone
|
|
if _, err := os.Stat(sentinel); !os.IsNotExist(err) {
|
|
t.Error("expected old .dolt/ contents to be removed during recovery")
|
|
}
|
|
}
|
|
|
|
func TestRecoverPreV56DoltDir_WithMarker(t *testing.T) {
|
|
doltDir := t.TempDir()
|
|
if err := os.MkdirAll(filepath.Join(doltDir, ".dolt"), 0750); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// Write marker → should NOT recover
|
|
if err := os.WriteFile(filepath.Join(doltDir, bdDoltMarker), []byte("ok\n"), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
recovered, err := RecoverPreV56DoltDir(doltDir)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if recovered {
|
|
t.Error("expected no recovery when marker exists")
|
|
}
|
|
}
|
|
|
|
func TestRecoverPreV56DoltDir_NoDotDolt(t *testing.T) {
|
|
doltDir := t.TempDir()
|
|
// No .dolt/ at all → should NOT recover
|
|
|
|
recovered, err := RecoverPreV56DoltDir(doltDir)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if recovered {
|
|
t.Error("expected no recovery when .dolt/ doesn't exist")
|
|
}
|
|
}
|
|
|
|
func TestEnsureDoltInit_WritesMarker(t *testing.T) {
|
|
doltDir := t.TempDir()
|
|
// Fresh init — no .dolt/ yet
|
|
|
|
// ensureDoltInit should create .dolt/ and write the marker
|
|
err := ensureDoltInit(doltDir)
|
|
if err != nil {
|
|
// dolt might not be installed in test env; skip marker check
|
|
t.Skipf("dolt init failed (dolt may not be installed): %v", err)
|
|
}
|
|
|
|
markerPath := filepath.Join(doltDir, bdDoltMarker)
|
|
if _, err := os.Stat(markerPath); os.IsNotExist(err) {
|
|
t.Error("expected .bd-dolt-ok marker to be written after successful dolt init")
|
|
}
|
|
}
|
|
|
|
// --- Shared Server Mode Tests (GH#2377) ---
|
|
|
|
func TestIsSharedServerMode_Default(t *testing.T) {
|
|
t.Setenv("BEADS_DOLT_SHARED_SERVER", "")
|
|
config.ResetForTesting()
|
|
if IsSharedServerMode() {
|
|
t.Error("expected per-project mode by default")
|
|
}
|
|
}
|
|
|
|
func TestIsSharedServerMode_EnvVar1(t *testing.T) {
|
|
t.Setenv("BEADS_DOLT_SHARED_SERVER", "1")
|
|
if !IsSharedServerMode() {
|
|
t.Error("expected shared server mode with BEADS_DOLT_SHARED_SERVER=1")
|
|
}
|
|
}
|
|
|
|
func TestIsSharedServerMode_EnvVarTrue(t *testing.T) {
|
|
t.Setenv("BEADS_DOLT_SHARED_SERVER", "true")
|
|
if !IsSharedServerMode() {
|
|
t.Error("expected shared server mode with BEADS_DOLT_SHARED_SERVER=true")
|
|
}
|
|
}
|
|
|
|
func TestIsSharedServerMode_EnvVarTRUE(t *testing.T) {
|
|
t.Setenv("BEADS_DOLT_SHARED_SERVER", "TRUE")
|
|
if !IsSharedServerMode() {
|
|
t.Error("expected shared server mode with BEADS_DOLT_SHARED_SERVER=TRUE (case-insensitive)")
|
|
}
|
|
}
|
|
|
|
func TestIsSharedServerMode_EnvVar0(t *testing.T) {
|
|
t.Setenv("BEADS_DOLT_SHARED_SERVER", "0")
|
|
config.ResetForTesting()
|
|
if IsSharedServerMode() {
|
|
t.Error("expected per-project mode with BEADS_DOLT_SHARED_SERVER=0")
|
|
}
|
|
}
|
|
|
|
func TestSharedServerDir(t *testing.T) {
|
|
dir, err := SharedServerDir()
|
|
if err != nil {
|
|
t.Fatalf("SharedServerDir: %v", err)
|
|
}
|
|
home, _ := os.UserHomeDir()
|
|
expected := filepath.Join(home, ".beads", "shared-server")
|
|
if dir != expected {
|
|
t.Errorf("SharedServerDir = %q, want %q", dir, expected)
|
|
}
|
|
info, err := os.Stat(dir)
|
|
if err != nil || !info.IsDir() {
|
|
t.Errorf("expected directory to exist: %s", dir)
|
|
}
|
|
}
|
|
|
|
func TestSharedDoltDir(t *testing.T) {
|
|
dir, err := SharedDoltDir()
|
|
if err != nil {
|
|
t.Fatalf("SharedDoltDir: %v", err)
|
|
}
|
|
home, _ := os.UserHomeDir()
|
|
expected := filepath.Join(home, ".beads", "shared-server", "dolt")
|
|
if dir != expected {
|
|
t.Errorf("SharedDoltDir = %q, want %q", dir, expected)
|
|
}
|
|
info, err := os.Stat(dir)
|
|
if err != nil || !info.IsDir() {
|
|
t.Errorf("expected directory to exist: %s", dir)
|
|
}
|
|
}
|
|
|
|
func TestSharedServerDir_EnvOverride(t *testing.T) {
|
|
tmp := t.TempDir()
|
|
t.Setenv("BEADS_SHARED_SERVER_DIR", tmp)
|
|
dir, err := SharedServerDir()
|
|
if err != nil {
|
|
t.Fatalf("SharedServerDir: %v", err)
|
|
}
|
|
if dir != tmp {
|
|
t.Errorf("SharedServerDir = %q, want %q (from BEADS_SHARED_SERVER_DIR)", dir, tmp)
|
|
}
|
|
}
|
|
|
|
func TestSharedDoltDir_EnvOverride(t *testing.T) {
|
|
tmp := t.TempDir()
|
|
t.Setenv("BEADS_SHARED_SERVER_DIR", tmp)
|
|
dir, err := SharedDoltDir()
|
|
if err != nil {
|
|
t.Fatalf("SharedDoltDir: %v", err)
|
|
}
|
|
expected := filepath.Join(tmp, "dolt")
|
|
if dir != expected {
|
|
t.Errorf("SharedDoltDir = %q, want %q", dir, expected)
|
|
}
|
|
}
|
|
|
|
func TestResolveServerDir_PerProject(t *testing.T) {
|
|
t.Setenv("BEADS_DOLT_SHARED_SERVER", "")
|
|
config.ResetForTesting()
|
|
result := resolveServerDir("/some/project/.beads")
|
|
if result != "/some/project/.beads" {
|
|
t.Errorf("expected per-project dir, got %s", result)
|
|
}
|
|
}
|
|
|
|
func TestResolveServerDir_SharedMode(t *testing.T) {
|
|
t.Setenv("BEADS_DOLT_SHARED_SERVER", "1")
|
|
result := resolveServerDir("/some/project/.beads")
|
|
home, _ := os.UserHomeDir()
|
|
expected := filepath.Join(home, ".beads", "shared-server")
|
|
if result != expected {
|
|
t.Errorf("resolveServerDir with shared mode = %q, want %q", result, expected)
|
|
}
|
|
}
|
|
|
|
func TestDefaultConfig_SharedModeFixedPort(t *testing.T) {
|
|
t.Setenv("BEADS_DOLT_SHARED_SERVER", "1")
|
|
t.Setenv("BEADS_DOLT_SERVER_PORT", "")
|
|
dir := t.TempDir()
|
|
cfg := DefaultConfig(dir)
|
|
if cfg.Port != DefaultSharedServerPort {
|
|
t.Errorf("shared mode: expected port %d (DefaultSharedServerPort), got %d", DefaultSharedServerPort, cfg.Port)
|
|
}
|
|
}
|
|
|
|
func TestDefaultConfig_SharedModeGeneralPortOverrides(t *testing.T) {
|
|
t.Setenv("BEADS_DOLT_SHARED_SERVER", "1")
|
|
t.Setenv("BEADS_DOLT_SERVER_PORT", "5000")
|
|
t.Setenv("GT_ROOT", "")
|
|
dir := t.TempDir()
|
|
cfg := DefaultConfig(dir)
|
|
if cfg.Port != 5000 {
|
|
t.Errorf("BEADS_DOLT_SERVER_PORT should override shared mode default, got %d", cfg.Port)
|
|
}
|
|
}
|
|
|
|
func TestDefaultSharedServerPort_DiffersFromDefault(t *testing.T) {
|
|
if DefaultSharedServerPort == configfile.DefaultDoltServerPort {
|
|
t.Errorf("DefaultSharedServerPort (%d) must differ from DefaultDoltServerPort (%d) to avoid orchestrator conflict",
|
|
DefaultSharedServerPort, configfile.DefaultDoltServerPort)
|
|
}
|
|
}
|
|
|
|
func TestDefaultConfig_SharedModeBeadsDir(t *testing.T) {
|
|
t.Setenv("BEADS_DOLT_SHARED_SERVER", "1")
|
|
t.Setenv("BEADS_DOLT_SERVER_PORT", "")
|
|
cfg := DefaultConfig("/some/project/.beads")
|
|
home, _ := os.UserHomeDir()
|
|
expected := filepath.Join(home, ".beads", "shared-server")
|
|
if cfg.BeadsDir != expected {
|
|
t.Errorf("DefaultConfig.BeadsDir = %q, want %q", cfg.BeadsDir, expected)
|
|
}
|
|
}
|
|
|
|
// --- ServerMode tests ---
|
|
|
|
func TestResolveServerMode_Default(t *testing.T) {
|
|
t.Setenv("BEADS_DOLT_SHARED_SERVER", "")
|
|
t.Setenv("BEADS_DOLT_SERVER_MODE", "")
|
|
config.ResetForTesting()
|
|
|
|
dir := t.TempDir()
|
|
mode := ResolveServerMode(dir)
|
|
if mode != ServerModeOwned {
|
|
t.Errorf("expected ServerModeOwned for empty dir, got %v", mode)
|
|
}
|
|
}
|
|
|
|
func TestResolveServerMode_SharedServer(t *testing.T) {
|
|
t.Setenv("BEADS_DOLT_SHARED_SERVER", "1")
|
|
t.Setenv("BEADS_DOLT_SERVER_MODE", "")
|
|
|
|
dir := t.TempDir()
|
|
mode := ResolveServerMode(dir)
|
|
if mode != ServerModeExternal {
|
|
t.Errorf("expected ServerModeExternal with shared server, got %v", mode)
|
|
}
|
|
}
|
|
|
|
func TestResolveServerMode_ExplicitPort(t *testing.T) {
|
|
t.Setenv("BEADS_DOLT_SHARED_SERVER", "")
|
|
t.Setenv("BEADS_DOLT_SERVER_MODE", "")
|
|
config.ResetForTesting()
|
|
|
|
dir := t.TempDir()
|
|
// Write metadata.json with explicit port
|
|
metaCfg := &configfile.Config{
|
|
DoltServerPort: 3307,
|
|
}
|
|
if err := metaCfg.Save(dir); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
mode := ResolveServerMode(dir)
|
|
if mode != ServerModeExternal {
|
|
t.Errorf("expected ServerModeExternal with explicit port, got %v", mode)
|
|
}
|
|
}
|
|
|
|
func TestResolveServerMode_ServerModeEnv(t *testing.T) {
|
|
t.Setenv("BEADS_DOLT_SHARED_SERVER", "")
|
|
t.Setenv("BEADS_DOLT_SERVER_MODE", "1")
|
|
config.ResetForTesting()
|
|
|
|
dir := t.TempDir()
|
|
mode := ResolveServerMode(dir)
|
|
if mode != ServerModeExternal {
|
|
t.Errorf("expected ServerModeExternal with BEADS_DOLT_SERVER_MODE=1, got %v", mode)
|
|
}
|
|
}
|
|
|
|
func TestResolveServerMode_EmbeddedMode(t *testing.T) {
|
|
t.Setenv("BEADS_DOLT_SHARED_SERVER", "")
|
|
t.Setenv("BEADS_DOLT_SERVER_MODE", "")
|
|
config.ResetForTesting()
|
|
|
|
dir := t.TempDir()
|
|
// Write metadata.json with embedded mode
|
|
metaCfg := &configfile.Config{
|
|
DoltMode: "embedded",
|
|
}
|
|
if err := metaCfg.Save(dir); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
mode := ResolveServerMode(dir)
|
|
if mode != ServerModeEmbedded {
|
|
t.Errorf("expected ServerModeEmbedded with dolt_mode=embedded, got %v", mode)
|
|
}
|
|
}
|
|
|
|
func TestServerMode_String(t *testing.T) {
|
|
tests := []struct {
|
|
mode ServerMode
|
|
want string
|
|
}{
|
|
{ServerModeOwned, "owned"},
|
|
{ServerModeExternal, "external"},
|
|
{ServerModeEmbedded, "embedded"},
|
|
{ServerMode(99), "ServerMode(99)"},
|
|
}
|
|
for _, tc := range tests {
|
|
if got := tc.mode.String(); got != tc.want {
|
|
t.Errorf("ServerMode(%d).String() = %q, want %q", int(tc.mode), got, tc.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDefaultConfig_IncludesMode(t *testing.T) {
|
|
t.Setenv("BEADS_DOLT_SHARED_SERVER", "")
|
|
t.Setenv("BEADS_DOLT_SERVER_MODE", "")
|
|
t.Setenv("BEADS_DOLT_SERVER_PORT", "")
|
|
config.ResetForTesting()
|
|
|
|
dir := t.TempDir()
|
|
cfg := DefaultConfig(dir)
|
|
if cfg.Mode != ServerModeOwned {
|
|
t.Errorf("expected DefaultConfig.Mode = Owned for empty dir, got %v", cfg.Mode)
|
|
}
|
|
}
|
|
|
|
// --- Upgrade regression tests (GH#2949) ---
|
|
// Verify that runtime env vars override stale metadata.json dolt_mode=embedded
|
|
// so that upgrades don't silently switch repos into embedded mode.
|
|
|
|
func TestResolveServerMode_SharedServerOverridesStaleEmbedded(t *testing.T) {
|
|
// Simulate the GH#2949 bug: metadata.json has dolt_mode=embedded but
|
|
// the user has BEADS_DOLT_SHARED_SERVER enabled. Before the fix,
|
|
// ResolveServerMode returned ServerModeEmbedded; after, ServerModeExternal.
|
|
dir := t.TempDir()
|
|
beadsDir := filepath.Join(dir, ".beads")
|
|
if err := os.MkdirAll(beadsDir, 0750); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
cfg := &configfile.Config{
|
|
Database: "dolt",
|
|
Backend: "dolt",
|
|
DoltMode: configfile.DoltModeEmbedded,
|
|
}
|
|
if err := cfg.Save(beadsDir); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
t.Setenv("BEADS_DOLT_SHARED_SERVER", "1")
|
|
t.Setenv("BEADS_DOLT_SERVER_MODE", "")
|
|
config.ResetForTesting()
|
|
|
|
got := ResolveServerMode(beadsDir)
|
|
if got != ServerModeExternal {
|
|
t.Errorf("ResolveServerMode with shared-server + stale embedded = %v, want ServerModeExternal", got)
|
|
}
|
|
}
|
|
|
|
func TestResolveServerMode_ServerModeEnvOverridesStaleEmbedded(t *testing.T) {
|
|
dir := t.TempDir()
|
|
beadsDir := filepath.Join(dir, ".beads")
|
|
if err := os.MkdirAll(beadsDir, 0750); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
cfg := &configfile.Config{
|
|
Database: "dolt",
|
|
Backend: "dolt",
|
|
DoltMode: configfile.DoltModeEmbedded,
|
|
}
|
|
if err := cfg.Save(beadsDir); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
t.Setenv("BEADS_DOLT_SERVER_MODE", "1")
|
|
t.Setenv("BEADS_DOLT_SHARED_SERVER", "")
|
|
config.ResetForTesting()
|
|
|
|
got := ResolveServerMode(beadsDir)
|
|
if got != ServerModeExternal {
|
|
t.Errorf("ResolveServerMode with SERVER_MODE=1 + stale embedded = %v, want ServerModeExternal", got)
|
|
}
|
|
}
|
|
|
|
func TestResolveServerMode_EmbeddedHonoredWithoutServerEnv(t *testing.T) {
|
|
// When no server env vars are set, metadata.json embedded mode is correct.
|
|
dir := t.TempDir()
|
|
beadsDir := filepath.Join(dir, ".beads")
|
|
if err := os.MkdirAll(beadsDir, 0750); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
cfg := &configfile.Config{
|
|
Database: "dolt",
|
|
Backend: "dolt",
|
|
DoltMode: configfile.DoltModeEmbedded,
|
|
}
|
|
if err := cfg.Save(beadsDir); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
t.Setenv("BEADS_DOLT_SERVER_MODE", "")
|
|
t.Setenv("BEADS_DOLT_SHARED_SERVER", "")
|
|
config.ResetForTesting()
|
|
|
|
got := ResolveServerMode(beadsDir)
|
|
if got != ServerModeEmbedded {
|
|
t.Errorf("ResolveServerMode with no server env = %v, want ServerModeEmbedded", got)
|
|
}
|
|
}
|
|
|
|
func TestReadyTimeout(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
envValue string
|
|
setEnv bool
|
|
want time.Duration
|
|
}{
|
|
{"unset defaults to 10s", "", false, 10 * time.Second},
|
|
{"empty string defaults to 10s", "", true, 10 * time.Second},
|
|
{"valid integer seconds", "120", true, 120 * time.Second},
|
|
{"whitespace is trimmed", " 60 ", true, 60 * time.Second},
|
|
{"invalid string falls back", "notanumber", true, 10 * time.Second},
|
|
{"zero falls back", "0", true, 10 * time.Second},
|
|
{"negative falls back", "-5", true, 10 * time.Second},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
if tt.setEnv {
|
|
t.Setenv("BEADS_DOLT_READY_TIMEOUT", tt.envValue)
|
|
} else {
|
|
// Save and restore any pre-existing value so we don't
|
|
// leak env state into subsequent tests.
|
|
if prev, ok := os.LookupEnv("BEADS_DOLT_READY_TIMEOUT"); ok {
|
|
t.Cleanup(func() { os.Setenv("BEADS_DOLT_READY_TIMEOUT", prev) })
|
|
}
|
|
os.Unsetenv("BEADS_DOLT_READY_TIMEOUT")
|
|
}
|
|
got := readyTimeout()
|
|
if got != tt.want {
|
|
t.Errorf("readyTimeout() = %v, want %v", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestBuildDoltServerArgs verifies the argv constructed for `dolt sql-server`
|
|
// always includes a non-info --loglevel and the expected host/port. This
|
|
// pins the fix for the field report where dolt-server.log ballooned to
|
|
// hundreds of MB with `msg=NewConnection` / `msg=ConnectionClosed` spam
|
|
// because dolt logs connection open/close at INFO by default.
|
|
//
|
|
// If this test fails because someone intentionally lowered verbosity back
|
|
// to info/debug/trace, please instead pick a different mitigation (e.g.
|
|
// dolt YAML config) and update doltServerLogLevel plus this test together.
|
|
func TestBuildDoltServerArgs(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
host string
|
|
port int
|
|
wantHost string
|
|
wantPort string
|
|
}{
|
|
{
|
|
name: "loopback ipv4 with ephemeral-style port",
|
|
host: "127.0.0.1",
|
|
port: 54321,
|
|
wantHost: "127.0.0.1",
|
|
wantPort: "54321",
|
|
},
|
|
{
|
|
name: "localhost hostname with default dolt port",
|
|
host: "localhost",
|
|
port: 3306,
|
|
wantHost: "localhost",
|
|
wantPort: "3306",
|
|
},
|
|
{
|
|
name: "ipv6 loopback with low port",
|
|
host: "::1",
|
|
port: 1024,
|
|
wantHost: "::1",
|
|
wantPort: "1024",
|
|
},
|
|
}
|
|
|
|
// Levels that MUST NOT appear — anything at or below info re-introduces
|
|
// the NewConnection/ConnectionClosed noise we are trying to suppress.
|
|
forbiddenLevels := []string{"trace", "debug", "info"}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
args := buildDoltServerArgs(tc.host, tc.port)
|
|
|
|
if len(args) == 0 || args[0] != "sql-server" {
|
|
t.Fatalf("args[0] = %q, want %q; full args: %v",
|
|
firstOrEmpty(args), "sql-server", args)
|
|
}
|
|
|
|
// -H <host>
|
|
hostIdx := indexOf(args, "-H")
|
|
if hostIdx < 0 || hostIdx+1 >= len(args) {
|
|
t.Fatalf("missing -H <host> in args: %v", args)
|
|
}
|
|
if got := args[hostIdx+1]; got != tc.wantHost {
|
|
t.Errorf("host = %q, want %q", got, tc.wantHost)
|
|
}
|
|
|
|
// -P <port>
|
|
portIdx := indexOf(args, "-P")
|
|
if portIdx < 0 || portIdx+1 >= len(args) {
|
|
t.Fatalf("missing -P <port> in args: %v", args)
|
|
}
|
|
if got := args[portIdx+1]; got != tc.wantPort {
|
|
t.Errorf("port = %q, want %q", got, tc.wantPort)
|
|
}
|
|
|
|
// --loglevel=<level> — the actual fix.
|
|
logLevel, ok := findLogLevel(args)
|
|
if !ok {
|
|
t.Fatalf("missing --loglevel flag in args; got: %v", args)
|
|
}
|
|
for _, bad := range forbiddenLevels {
|
|
if logLevel == bad {
|
|
t.Errorf("--loglevel=%s is too verbose; "+
|
|
"dolt logs NewConnection/ConnectionClosed at INFO, "+
|
|
"which caused the ~380MB dolt-server.log field report. "+
|
|
"Use warning/error/fatal instead.", logLevel)
|
|
}
|
|
}
|
|
// Sanity-check we're using a level dolt actually accepts.
|
|
validLevels := map[string]bool{
|
|
"trace": true, "debug": true, "info": true,
|
|
"warning": true, "error": true, "fatal": true,
|
|
}
|
|
if !validLevels[logLevel] {
|
|
t.Errorf("--loglevel=%s is not a valid dolt log level "+
|
|
"(valid: trace, debug, info, warning, error, fatal)",
|
|
logLevel)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestWaitForReady(t *testing.T) {
|
|
// Allocate an ephemeral port, then release it so we can re-bind later.
|
|
tmpListener, err := net.Listen("tcp", "127.0.0.1:0")
|
|
if err != nil {
|
|
t.Fatalf("could not allocate ephemeral port: %v", err)
|
|
}
|
|
addr := tmpListener.Addr().(*net.TCPAddr)
|
|
host := "127.0.0.1"
|
|
port := addr.Port
|
|
if err := tmpListener.Close(); err != nil {
|
|
t.Fatalf("could not release ephemeral port: %v", err)
|
|
}
|
|
|
|
// Spawn a goroutine that delays binding the port. This simulates a
|
|
// "slow server" -- the TCP listener is not yet bound when waitForReady
|
|
// is first called.
|
|
bindAfter := 200 * time.Millisecond
|
|
listenerReady := make(chan net.Listener, 1)
|
|
go func() {
|
|
time.Sleep(bindAfter)
|
|
ln, listenErr := net.Listen("tcp", net.JoinHostPort(host, strconv.Itoa(port)))
|
|
if listenErr != nil {
|
|
close(listenerReady)
|
|
return
|
|
}
|
|
listenerReady <- ln
|
|
}()
|
|
t.Cleanup(func() {
|
|
ln, ok := <-listenerReady
|
|
if ok && ln != nil {
|
|
_ = ln.Close()
|
|
}
|
|
})
|
|
|
|
// NOTE: subtests must run in declaration order (the default for
|
|
// non-parallel subtests). "times out" runs before the goroutine binds
|
|
// the port; "succeeds" runs after.
|
|
t.Run("times out when server not ready in time", func(t *testing.T) {
|
|
// 50ms is well under the 200ms bind delay, so this MUST time out.
|
|
if err := waitForReady(host, port, 50*time.Millisecond); err == nil {
|
|
t.Errorf("expected timeout error, got nil")
|
|
}
|
|
})
|
|
|
|
t.Run("succeeds when server becomes ready in time", func(t *testing.T) {
|
|
// 2 seconds is well over the remaining bind delay; gives comfortable margin.
|
|
if err := waitForReady(host, port, 2*time.Second); err != nil {
|
|
t.Errorf("expected nil error, got: %v", err)
|
|
}
|
|
})
|
|
}
|
|
|
|
// TestDoltServerLogLevelConstant pins doltServerLogLevel to a non-chatty
|
|
// value. It complements TestBuildDoltServerArgs by guarding the constant
|
|
// directly, so a refactor that stops calling buildDoltServerArgs cannot
|
|
// silently regress the fix.
|
|
func TestDoltServerLogLevelConstant(t *testing.T) {
|
|
switch doltServerLogLevel {
|
|
case "warning", "error", "fatal":
|
|
// ok — these all suppress INFO-level NewConnection noise.
|
|
default:
|
|
t.Errorf("doltServerLogLevel = %q; must be one of "+
|
|
"warning/error/fatal to suppress NewConnection/ConnectionClosed "+
|
|
"log spam (see dolt-connection-log-verbosity field report)",
|
|
doltServerLogLevel)
|
|
}
|
|
}
|
|
|
|
// indexOf returns the index of the first occurrence of needle in haystack,
|
|
// or -1 if not found. Local helper to keep the test self-contained.
|
|
func indexOf(haystack []string, needle string) int {
|
|
for i, s := range haystack {
|
|
if s == needle {
|
|
return i
|
|
}
|
|
}
|
|
return -1
|
|
}
|
|
|
|
// findLogLevel extracts the value of a --loglevel=<v> or --loglevel <v>
|
|
// flag from argv. Returns the value and true if found.
|
|
func findLogLevel(args []string) (string, bool) {
|
|
const prefix = "--loglevel="
|
|
for i, a := range args {
|
|
if strings.HasPrefix(a, prefix) {
|
|
return strings.TrimPrefix(a, prefix), true
|
|
}
|
|
if a == "--loglevel" && i+1 < len(args) {
|
|
return args[i+1], true
|
|
}
|
|
// Short form -l <level>
|
|
if a == "-l" && i+1 < len(args) {
|
|
return args[i+1], true
|
|
}
|
|
}
|
|
return "", false
|
|
}
|
|
|
|
func firstOrEmpty(s []string) string {
|
|
if len(s) == 0 {
|
|
return ""
|
|
}
|
|
return s[0]
|
|
}
|
|
|
|
func TestGlobalDatabaseConstants(t *testing.T) {
|
|
if GlobalDatabaseName == "" {
|
|
t.Error("GlobalDatabaseName must not be empty")
|
|
}
|
|
if GlobalDatabaseName != "beads_global" {
|
|
t.Errorf("GlobalDatabaseName = %q, want %q", GlobalDatabaseName, "beads_global")
|
|
}
|
|
if GlobalIssuePrefix == "" {
|
|
t.Error("GlobalIssuePrefix must not be empty")
|
|
}
|
|
if GlobalIssuePrefix != "global" {
|
|
t.Errorf("GlobalIssuePrefix = %q, want %q", GlobalIssuePrefix, "global")
|
|
}
|
|
if GlobalProjectID == "" {
|
|
t.Error("GlobalProjectID must not be empty")
|
|
}
|
|
if GlobalProjectID != "00000000-0000-0000-0000-000000000000" {
|
|
t.Errorf("GlobalProjectID = %q, want sentinel UUID", GlobalProjectID)
|
|
}
|
|
}
|
|
|
|
func TestEnsureGlobalDatabase_ServerNotReachable(t *testing.T) {
|
|
// EnsureGlobalDatabase should return an error when the server is not reachable.
|
|
err := EnsureGlobalDatabase("127.0.0.1", 19999, "root", "")
|
|
if err == nil {
|
|
t.Error("expected error when server is not reachable")
|
|
}
|
|
}
|