This repository has been archived on 2026-11-17. You can view files and clone it, but cannot push or open issues or pull requests.
gitgram-ai/aitimemachine/beads/cmd/bd/context_cmd_test.go
caelum0x 49b183818c Unify gitgram + aitimemachine into the monorepo (de-submodule) and merge vendored engines
Convert gitgram/ and aitimemachine/ from embedded git repos (which showed as
opaque submodule gitlinks on GitHub) into fully-tracked first-party content.

AITM now merges its 7 vendored repos as first-party engines:
- memory: beads (Go task DAG) + context7 (docs SDK), unified into saved_contexts
- git: vendored C git (bundled binary) + gitnexus (in-process code intelligence)
- agentic: a2a (@a2a-js/sdk) + pal (AITM-managed Python subprocess)

Includes the full session's product build: Gitgram web/mobile/backend features,
AITM website/CLI/MCP, the unified memory layer, engine build tooling
(scripts/build-engines.sh, Dockerfile, CI), docs (README, ENGINES.md, ARCHITECTURE.md),
and extensive test suites.

Build artifacts, node_modules, external/, and gemini-cli are gitignored.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-23 14:14:09 +03:00

297 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)
}
}
}