beads/cmd/bd/daemon_socket_test.go
Joe Delfino 78adcf5320 Fix daemon to respect BD_SOCKET environment variable
The daemon loop in runDaemonLoop() was calling rpc.ShortSocketPath()
directly instead of checking for the BD_SOCKET environment variable
first. This caused issues on filesystems where sockets cannot be
created in the .beads directory (e.g., some mounted filesystems
that don't support Unix socket permissions).

The fix checks BD_SOCKET before falling back to the default path
computation, consistent with how getSocketPath() and
getSocketPathForPID() already work.

Added tests to verify the daemon loop respects BD_SOCKET.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-26 03:54:51 +00:00

203 lines
6.7 KiB
Go

package main
import (
"os"
"path/filepath"
"strings"
"testing"
"github.com/steveyegge/beads/internal/rpc"
)
// TestSocketPathEnvOverride verifies that BD_SOCKET env var overrides default socket path.
func TestSocketPathEnvOverride(t *testing.T) {
// Create isolated temp directory
tmpDir := t.TempDir()
customSocket := filepath.Join(tmpDir, "custom.sock")
// Set environment for isolation
t.Setenv("BD_SOCKET", customSocket)
// Verify getSocketPath returns custom path
got := getSocketPath()
if got != customSocket {
t.Errorf("getSocketPath() = %q, want %q", got, customSocket)
}
}
// TestSocketPathForPIDEnvOverride verifies that BD_SOCKET env var overrides PID-derived path.
func TestSocketPathForPIDEnvOverride(t *testing.T) {
// Create isolated temp directory
tmpDir := t.TempDir()
customSocket := filepath.Join(tmpDir, "custom.sock")
// Set environment for isolation
t.Setenv("BD_SOCKET", customSocket)
// Verify getSocketPathForPID returns custom path (ignoring pidFile)
pidFile := "/some/other/path/daemon.pid"
got := getSocketPathForPID(pidFile)
if got != customSocket {
t.Errorf("getSocketPathForPID(%q) = %q, want %q", pidFile, got, customSocket)
}
}
// TestSocketPathDefaultBehavior verifies default behavior when BD_SOCKET is not set.
func TestSocketPathDefaultBehavior(t *testing.T) {
// Ensure BD_SOCKET is not set (t.Setenv restores after test)
t.Setenv("BD_SOCKET", "")
// Verify getSocketPathForPID derives from PID file path
pidFile := "/path/to/.beads/daemon.pid"
got := getSocketPathForPID(pidFile)
want := "/path/to/.beads/bd.sock"
if got != want {
t.Errorf("getSocketPathForPID(%q) = %q, want %q", pidFile, got, want)
}
}
// TestSocketPathForPIDLongPath verifies that long workspace paths use shortened socket paths.
// This fixes GH#1001 where pytest temp directories exceeded macOS's 104-byte socket path limit.
func TestSocketPathForPIDLongPath(t *testing.T) {
t.Setenv("BD_SOCKET", "")
// Create a path that would exceed the 103-byte limit when .beads/bd.sock is appended
// /long/path/.beads/daemon.pid -> workspace is /long/path
// socket would be /long/path/.beads/bd.sock
longWorkspace := "/" + strings.Repeat("a", 90) // 91 bytes
pidFile := filepath.Join(longWorkspace, ".beads", "daemon.pid")
got := getSocketPathForPID(pidFile)
// Should NOT be the natural path (which would be too long)
naturalPath := filepath.Join(longWorkspace, ".beads", "bd.sock")
if got == naturalPath {
t.Errorf("getSocketPathForPID should use short path for long workspaces, got natural path %q (%d bytes)",
got, len(got))
}
// Should be in /tmp/beads-{hash}/
if !strings.HasPrefix(got, "/tmp/beads-") {
t.Errorf("getSocketPathForPID(%q) = %q, want path starting with /tmp/beads-", pidFile, got)
}
// Should end with bd.sock
if !strings.HasSuffix(got, "/bd.sock") {
t.Errorf("getSocketPathForPID(%q) = %q, want path ending with /bd.sock", pidFile, got)
}
// Should be under the limit
if len(got) > 103 {
t.Errorf("getSocketPathForPID returned path of %d bytes, want <= 103", len(got))
}
}
// TestSocketPathForPIDClientDaemonAgreement verifies that getSocketPathForPID
// returns the same path as rpc.ShortSocketPath for the same workspace.
// This is critical - if they disagree, the daemon listens on one path while
// the client tries to connect to another, causing connection failures.
// This test caught the GH#1001 bug where daemon.go used filepath.Join directly
// instead of rpc.ShortSocketPath.
func TestSocketPathForPIDClientDaemonAgreement(t *testing.T) {
t.Setenv("BD_SOCKET", "")
tests := []struct {
name string
workspacePath string
}{
{"short_path", "/home/user/project"},
{"medium_path", "/Users/testuser/Documents/projects/myapp"},
{"long_path", "/" + strings.Repeat("a", 90)}, // Forces short socket path
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// What getSocketPathForPID returns (used by daemon operations)
pidFile := filepath.Join(tt.workspacePath, ".beads", "daemon.pid")
fromPID := getSocketPathForPID(pidFile)
// What rpc.ShortSocketPath returns (used by client via getSocketPath)
fromRPC := rpc.ShortSocketPath(tt.workspacePath)
if fromPID != fromRPC {
t.Errorf("socket path mismatch for workspace %q:\n getSocketPathForPID: %q\n rpc.ShortSocketPath: %q",
tt.workspacePath, fromPID, fromRPC)
}
})
}
}
// TestDaemonLoopSocketPathEnvOverride verifies that the daemon loop respects BD_SOCKET.
// This tests the fix for GH#XXXX where filesystems that don't support sockets in .beads/
// (e.g., some mounted filesystems) couldn't run the daemon.
func TestDaemonLoopSocketPathEnvOverride(t *testing.T) {
// Create isolated temp directory
tmpDir := t.TempDir()
customSocket := filepath.Join(tmpDir, "custom.sock")
// Set environment for isolation
t.Setenv("BD_SOCKET", customSocket)
// Simulate the daemon loop's socket path determination logic
// (same logic as in runDaemonLoop in daemon.go)
workspacePath := "/some/workspace"
socketPath := os.Getenv("BD_SOCKET")
if socketPath == "" {
socketPath = rpc.ShortSocketPath(workspacePath)
}
// Verify the daemon would use the custom socket path
if socketPath != customSocket {
t.Errorf("daemon socket path = %q, want %q", socketPath, customSocket)
}
}
// TestDaemonLoopSocketPathDefault verifies default socket path when BD_SOCKET is not set.
func TestDaemonLoopSocketPathDefault(t *testing.T) {
t.Setenv("BD_SOCKET", "")
workspacePath := "/home/user/project"
// Simulate the daemon loop's socket path determination logic
socketPath := os.Getenv("BD_SOCKET")
if socketPath == "" {
socketPath = rpc.ShortSocketPath(workspacePath)
}
// Should use the default path from rpc.ShortSocketPath
expected := rpc.ShortSocketPath(workspacePath)
if socketPath != expected {
t.Errorf("daemon socket path = %q, want %q", socketPath, expected)
}
}
// TestDaemonSocketIsolation demonstrates that two test instances can use different sockets.
// This is the key pattern for parallel test isolation.
func TestDaemonSocketIsolation(t *testing.T) {
// Simulate two parallel tests with different socket paths
tests := []struct {
name string
sockSuffix string
}{
{"instance_a", "a.sock"},
{"instance_b", "b.sock"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// Each sub-test gets isolated socket path in its own temp dir
socketPath := filepath.Join(t.TempDir(), tt.sockSuffix)
t.Setenv("BD_SOCKET", socketPath)
got := getSocketPath()
if got != socketPath {
t.Errorf("getSocketPath() = %q, want %q", got, socketPath)
}
// Verify paths are unique per instance
if !strings.Contains(got, tt.sockSuffix) {
t.Errorf("getSocketPath() = %q, want it to contain %q", got, tt.sockSuffix)
}
})
}
}