beads/cmd/bd/context_cmd_test.go
collins ac9ac70911 feat: add bd context command and safe-first error guidance (fix-merge PR #2496)
Add bd context command showing effective backend identity (beads dir, repo
root, dolt mode, server endpoint, database, project ID, role) without requiring
DB open -- useful for degraded-state diagnostics. Supports --json.

Update error messages across 13 commands to suggest bd doctor for diagnosis
before bd init for reset, preventing unsafe destructive recovery paths.

Fix: use cfg.GetDoltServerPort() instead of doltserver.DefaultConfig() for
correct port resolution in context command. Add env var isolation in tests
to prevent BEADS_DOLT_PORT interference.

Co-Authored-By: matt wilkie <maphew@gmail.com>
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-03-10 17:32:36 -07:00

296 lines
9.1 KiB
Go

package main
import (
"encoding/json"
"os"
"path/filepath"
"testing"
"github.com/steveyegge/beads/internal/configfile"
)
// TestContextInfo_ServerModeIdentity verifies that loading a server-mode
// metadata.json produces a config whose identity fields (host, port, database,
// mode) match what was persisted. Drift scenario: GH#2438.
func TestContextInfo_ServerModeIdentity(t *testing.T) {
// Unset env vars that override config port values
t.Setenv("BEADS_DOLT_SERVER_PORT", "")
t.Setenv("BEADS_DOLT_PORT", "")
t.Setenv("BEADS_DOLT_SERVER_HOST", "")
t.Setenv("BEADS_DOLT_SERVER_DATABASE", "")
tmpDir := t.TempDir()
beadsDir := filepath.Join(tmpDir, ".beads")
if err := os.MkdirAll(beadsDir, 0755); err != nil {
t.Fatalf("mkdir: %v", err)
}
cfg := &configfile.Config{
Database: "dolt",
DoltMode: "server",
DoltServerHost: "192.168.1.50",
DoltServerPort: 3309,
DoltDatabase: "project_beads",
ProjectID: "proj-abc123",
}
if err := cfg.Save(beadsDir); err != nil {
t.Fatalf("save config: %v", err)
}
loaded, err := configfile.Load(beadsDir)
if err != nil {
t.Fatalf("load config: %v", err)
}
if loaded == nil {
t.Fatal("loaded config is nil")
}
if got := loaded.GetDoltMode(); got != "server" {
t.Errorf("DoltMode: got %q, want %q", got, "server")
}
if !loaded.IsDoltServerMode() {
t.Error("IsDoltServerMode() returned false, want true")
}
if got := loaded.GetDoltServerHost(); got != "192.168.1.50" {
t.Errorf("ServerHost: got %q, want %q", got, "192.168.1.50")
}
if got := loaded.GetDoltServerPort(); got != 3309 {
t.Errorf("ServerPort: got %d, want %d", got, 3309)
}
if got := loaded.GetDoltDatabase(); got != "project_beads" {
t.Errorf("Database: got %q, want %q", got, "project_beads")
}
}
// TestContextInfo_EmbeddedModeIdentity verifies that the default (embedded)
// mode config reports embedded mode with no server host/port overrides.
func TestContextInfo_EmbeddedModeIdentity(t *testing.T) {
tmpDir := t.TempDir()
beadsDir := filepath.Join(tmpDir, ".beads")
if err := os.MkdirAll(beadsDir, 0755); err != nil {
t.Fatalf("mkdir: %v", err)
}
cfg := &configfile.Config{
Database: "dolt",
}
if err := cfg.Save(beadsDir); err != nil {
t.Fatalf("save config: %v", err)
}
loaded, err := configfile.Load(beadsDir)
if err != nil {
t.Fatalf("load config: %v", err)
}
if loaded == nil {
t.Fatal("loaded config is nil")
}
if got := loaded.GetDoltMode(); got != "embedded" {
t.Errorf("DoltMode: got %q, want %q", got, "embedded")
}
if loaded.IsDoltServerMode() {
t.Error("IsDoltServerMode() returned true for embedded config")
}
// Embedded mode should have empty host/port in the raw struct
if loaded.DoltServerHost != "" {
t.Errorf("DoltServerHost should be empty for embedded, got %q", loaded.DoltServerHost)
}
if loaded.DoltServerPort != 0 {
t.Errorf("DoltServerPort should be 0 for embedded, got %d", loaded.DoltServerPort)
}
}
// TestContextInfo_DataDirOverride verifies that a custom dolt_data_dir set in
// metadata.json is reflected when loaded. Uses a relative path since Save()
// strips absolute paths (GH#2251).
func TestContextInfo_DataDirOverride(t *testing.T) {
tmpDir := t.TempDir()
beadsDir := filepath.Join(tmpDir, ".beads")
if err := os.MkdirAll(beadsDir, 0755); err != nil {
t.Fatalf("mkdir: %v", err)
}
// Save() strips absolute DoltDataDir, so write JSON directly to test
// that the field round-trips for relative paths.
cfg := &configfile.Config{
Database: "dolt",
DoltDataDir: "custom-data",
}
if err := cfg.Save(beadsDir); err != nil {
t.Fatalf("save config: %v", err)
}
loaded, err := configfile.Load(beadsDir)
if err != nil {
t.Fatalf("load config: %v", err)
}
if loaded == nil {
t.Fatal("loaded config is nil")
}
if got := loaded.GetDoltDataDir(); got != "custom-data" {
t.Errorf("DoltDataDir: got %q, want %q", got, "custom-data")
}
// Also verify that an absolute path set via env var overrides the config
t.Run("AbsoluteViaEnv", func(t *testing.T) {
t.Setenv("BEADS_DOLT_DATA_DIR", "/mnt/fast-ssd/dolt-data")
if got := loaded.GetDoltDataDir(); got != "/mnt/fast-ssd/dolt-data" {
t.Errorf("DoltDataDir with env override: got %q, want %q", got, "/mnt/fast-ssd/dolt-data")
}
})
}
// TestContextInfo_ProjectIDPresent verifies that project_id from metadata.json
// appears in the loaded config and would be surfaced in ContextInfo.
func TestContextInfo_ProjectIDPresent(t *testing.T) {
tmpDir := t.TempDir()
beadsDir := filepath.Join(tmpDir, ".beads")
if err := os.MkdirAll(beadsDir, 0755); err != nil {
t.Fatalf("mkdir: %v", err)
}
cfg := &configfile.Config{
Database: "dolt",
ProjectID: "proj-deadbeef-1234",
}
if err := cfg.Save(beadsDir); err != nil {
t.Fatalf("save config: %v", err)
}
loaded, err := configfile.Load(beadsDir)
if err != nil {
t.Fatalf("load config: %v", err)
}
if loaded == nil {
t.Fatal("loaded config is nil")
}
if loaded.ProjectID != "proj-deadbeef-1234" {
t.Errorf("ProjectID: got %q, want %q", loaded.ProjectID, "proj-deadbeef-1234")
}
// Verify it would populate ContextInfo correctly
info := ContextInfo{
Backend: configfile.BackendDolt,
DoltMode: loaded.GetDoltMode(),
Database: loaded.GetDoltDatabase(),
ProjectID: loaded.ProjectID,
}
if info.ProjectID != "proj-deadbeef-1234" {
t.Errorf("ContextInfo.ProjectID: got %q, want %q", info.ProjectID, "proj-deadbeef-1234")
}
}
// TestContextInfo_EnvVarOverrides verifies that BEADS_DOLT_SERVER_HOST env var
// overrides the value from metadata.json. This is the drift vector from
// GH#2438: env vars and config can diverge silently.
func TestContextInfo_EnvVarOverrides(t *testing.T) {
tmpDir := t.TempDir()
beadsDir := filepath.Join(tmpDir, ".beads")
if err := os.MkdirAll(beadsDir, 0755); err != nil {
t.Fatalf("mkdir: %v", err)
}
cfg := &configfile.Config{
Database: "dolt",
DoltMode: "server",
DoltServerHost: "192.168.1.50",
DoltServerPort: 3309,
DoltDatabase: "project_beads",
}
if err := cfg.Save(beadsDir); err != nil {
t.Fatalf("save config: %v", err)
}
loaded, err := configfile.Load(beadsDir)
if err != nil {
t.Fatalf("load config: %v", err)
}
// Before env override: host comes from config
if got := loaded.GetDoltServerHost(); got != "192.168.1.50" {
t.Errorf("before override: got %q, want %q", got, "192.168.1.50")
}
// Set env var override — simulates drift between config file and runtime
t.Setenv("BEADS_DOLT_SERVER_HOST", "10.0.0.99")
if got := loaded.GetDoltServerHost(); got != "10.0.0.99" {
t.Errorf("after BEADS_DOLT_SERVER_HOST override: got %q, want %q", got, "10.0.0.99")
}
// The config struct still has the original value — this is the drift
if loaded.DoltServerHost != "192.168.1.50" {
t.Errorf("struct field should still be %q, got %q", "192.168.1.50", loaded.DoltServerHost)
}
// Verify port override works similarly
t.Setenv("BEADS_DOLT_SERVER_PORT", "3310")
if got := loaded.GetDoltServerPort(); got != 3310 {
t.Errorf("after BEADS_DOLT_SERVER_PORT override: got %d, want %d", got, 3310)
}
// Verify database override works similarly
t.Setenv("BEADS_DOLT_SERVER_DATABASE", "other_db")
if got := loaded.GetDoltDatabase(); got != "other_db" {
t.Errorf("after BEADS_DOLT_SERVER_DATABASE override: got %q, want %q", got, "other_db")
}
// Build a ContextInfo the same way context_cmd.go does and verify
// it reflects the env-overridden values (the "effective" identity)
info := ContextInfo{
Backend: configfile.BackendDolt,
DoltMode: loaded.GetDoltMode(),
ServerHost: loaded.GetDoltServerHost(),
ServerPort: loaded.GetDoltServerPort(),
Database: loaded.GetDoltDatabase(),
}
if info.ServerHost != "10.0.0.99" {
t.Errorf("ContextInfo.ServerHost: got %q, want %q", info.ServerHost, "10.0.0.99")
}
if info.ServerPort != 3310 {
t.Errorf("ContextInfo.ServerPort: got %d, want %d", info.ServerPort, 3310)
}
if info.Database != "other_db" {
t.Errorf("ContextInfo.Database: got %q, want %q", info.Database, "other_db")
}
}
// TestContextInfo_SaveStripAbsoluteDataDir verifies Save() strips absolute
// DoltDataDir paths (GH#2251 guard). This is relevant to drift because an
// absolute path in metadata.json would propagate to other clones and cause
// data loss.
func TestContextInfo_SaveStripAbsoluteDataDir(t *testing.T) {
tmpDir := t.TempDir()
beadsDir := filepath.Join(tmpDir, ".beads")
if err := os.MkdirAll(beadsDir, 0755); err != nil {
t.Fatalf("mkdir: %v", err)
}
cfg := &configfile.Config{
Database: "dolt",
DoltDataDir: "/absolute/path/dolt-data",
}
if err := cfg.Save(beadsDir); err != nil {
t.Fatalf("save config: %v", err)
}
// Read raw JSON to verify absolute path was stripped
data, err := os.ReadFile(filepath.Join(beadsDir, configfile.ConfigFileName))
if err != nil {
t.Fatalf("read config: %v", err)
}
var raw map[string]json.RawMessage
if err := json.Unmarshal(data, &raw); err != nil {
t.Fatalf("unmarshal: %v", err)
}
if _, exists := raw["dolt_data_dir"]; exists {
var val string
if err := json.Unmarshal(raw["dolt_data_dir"], &val); err == nil && val != "" {
t.Errorf("absolute DoltDataDir should be stripped from saved JSON, got %q", val)
}
}
}