beads/cmd/bd/migrate_dolt_mode_test.go
ecuthiell a8003cf6ec
test(cmd/bd): reset repository caches around CWD fixtures (#5747)
* test(cmd/bd): reset repository caches around CWD fixtures (#5746)

Agent-Signature: Codex-unknown-model-unknown-reasoning on behalf of Ewen Cuthiell

* test(cmd/bd): pair the beads/git cache resets at the two remaining chdir fixtures

Maintainer review fixup for the adopt-pr review of #5747 (iteration 1,
synthesis approve, 0 blocker / 0 major).

Takes the single minor finding (Change Impact / Blast Radius). The PR
establishes that a one-sided cache reset around a chdir fixture is a
structural half-fix, but two sites in the same package still encoded
exactly one half each, failing in opposite directions:

- serve_registered_backend_test.go: had the beads-only pattern the PR
  just deleted elsewhere (beads.ResetCaches + bare
  t.Cleanup(beads.ResetCaches)). Converted to the paired closure the PR
  uses, adding git.ResetCaches on both edges. The file was already cited
  as the exemplar for the paired idiom at two other anchors; this was the
  third, unfixed site.
- git_test_helpers.go: runInDir is the package's single helper for this
  contract across 38 call sites, and it reset git only, never beads.
  Added beads.ResetCaches beside both git.ResetCaches calls, and updated
  the doc comment to state why the pair is required. No call-site churn.

Both caches key on the working directory, so clearing one leaves the
other answering for the previous directory.

Validation: go vet ./cmd/bd/ clean at CGO_ENABLED=1; the 22 test
functions that call runInDir plus TestServeRefusesStrictReadonlyOnARegisteredBackend
run 47/47 PASS, 0 SKIP.

Not taken: the optional shared chdirFixture(t, dir) helper the finding
suggests. It would churn all 38 call sites for no behavior change, which
is beyond what a maintainer fixup on an approved PR should carry.

---------

Co-authored-by: Gas City Adopt-PR <adopt-pr@gascity.local>
2026-09-30 18:32:26 -07:00

1129 lines
51 KiB
Go

package main
import (
"bytes"
"encoding/json"
"io"
"os"
"path/filepath"
"strings"
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/steveyegge/beads/internal/beads"
"github.com/steveyegge/beads/internal/config"
"github.com/steveyegge/beads/internal/configfile"
"github.com/steveyegge/beads/internal/git"
"github.com/steveyegge/beads/internal/storage/dbproxy/proxy"
"github.com/steveyegge/beads/internal/storage/dbproxy/server"
"github.com/steveyegge/beads/internal/storage/dbproxy/util"
)
func captureMigrationJSON(t *testing.T, fn func() error) (string, error) {
t.Helper()
stdioMutex.Lock()
defer stdioMutex.Unlock()
old := os.Stdout
r, w, err := os.Pipe()
require.NoError(t, err)
os.Stdout = w
done := make(chan string, 1)
go func() {
var buf bytes.Buffer
_, _ = io.Copy(&buf, r)
done <- buf.String()
}()
callErr := fn()
_ = w.Close()
os.Stdout = old
out := <-done
_ = r.Close()
return out, callErr
}
func snapshotMigrationTree(t *testing.T, roots ...string) map[string][]byte {
t.Helper()
out := map[string][]byte{}
for _, root := range roots {
_ = filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
if strings.HasSuffix(path, ".gate.lock") || strings.HasSuffix(path, migrateLockFileName) {
return nil
}
if err != nil {
return nil
}
switch {
case info.Mode()&os.ModeSymlink != 0:
target, _ := os.Readlink(path)
out[path] = []byte("symlink:" + target)
case info.IsDir():
out[path] = []byte("dir:" + info.Mode().String())
case info.Mode().IsRegular():
b, _ := os.ReadFile(path)
out[path] = append([]byte("file:"+info.Mode().String()+"\x00"), b...)
}
return nil
})
}
return out
}
func migrateModeWorkspace(t *testing.T, mode string) string {
t.Helper()
t.Setenv("BEADS_PROXIED_SERVER_ROOT_PATH", "")
t.Setenv("BEADS_PROXIED_SERVER_CONFIG", "")
t.Setenv("BEADS_PROXIED_SERVER_LOG", "")
t.Setenv("BEADS_DOLT_DATA_DIR", "")
dir := t.TempDir()
beadsDir := filepath.Join(dir, ".beads")
require.NoError(t, os.MkdirAll(beadsDir, 0o755))
require.NoError(t, os.MkdirAll(filepath.Join(beadsDir, "dolt", ".dolt"), 0o755))
require.NoError(t, os.WriteFile(filepath.Join(beadsDir, "dolt", ".dolt", "repo_state.json"), []byte(`{"head":"refs/heads/main","remotes":{},"backups":{},"branches":{}}`), 0o600))
writeMetadataConfig(t, beadsDir, mode, "myproj")
t.Chdir(dir)
beads.ResetCaches()
git.ResetCaches()
t.Cleanup(func() {
beads.ResetCaches()
git.ResetCaches()
})
return beadsDir
}
func touchFile(t *testing.T, path string) {
t.Helper()
require.NoError(t, os.MkdirAll(filepath.Dir(path), 0o755))
require.NoError(t, os.WriteFile(path, []byte("x"), 0o600))
}
func mustReadFile(t *testing.T, path string) []byte {
t.Helper()
b, err := os.ReadFile(path)
require.NoError(t, err)
return b
}
func serverAssetNames() []string {
return []string{"dolt-server.pid", "dolt-server.port", "dolt-server.lock", "dolt-server.log", "dolt-server.log.1"}
}
func proxiedAssetNames() []string {
return []string{"proxy.pid", "proxy.lock", "proxy.log", "proxy-child.pid", "proxy-child.lock", "server.log"}
}
func TestMigrateToProxiedServer_FlipsMode(t *testing.T) {
beadsDir := migrateModeWorkspace(t, configfile.DoltModeServer)
for _, n := range serverAssetNames() {
touchFile(t, filepath.Join(beadsDir, n))
}
touchFile(t, filepath.Join(beadsDir, "dolt-pprof", "cpu.pprof"))
require.NoError(t, runMigrateToProxiedServer(false, 0, false))
cfg, err := configfile.Load(beadsDir)
require.NoError(t, err)
assert.True(t, cfg.IsDoltProxiedServerMode())
assert.Equal(t, "myproj", cfg.GetDoltDatabase())
_, statErr := os.Stat(configfile.ProxiedServerClientInfoPath(beadsDir))
require.NoError(t, statErr, "sidecar must be written")
for _, n := range serverAssetNames() {
_, err := os.Stat(filepath.Join(beadsDir, n))
assert.True(t, os.IsNotExist(err), "server asset %s must be removed", n)
}
_, err = os.Stat(filepath.Join(beadsDir, "dolt-pprof"))
assert.True(t, os.IsNotExist(err), "dolt-pprof/ must be removed")
}
func TestMigrateToProxiedServer_RejectsNonServerMode(t *testing.T) {
migrateModeWorkspace(t, configfile.DoltModeEmbedded)
err := runMigrateToProxiedServer(false, 0, false)
require.Error(t, err)
}
func TestMigrateToProxiedServer_MissingRootFailsClosed(t *testing.T) {
beadsDir := migrateModeWorkspace(t, configfile.DoltModeServer)
require.NoError(t, os.RemoveAll(filepath.Join(beadsDir, "dolt")))
before, err := os.ReadFile(configfile.ConfigPath(beadsDir))
require.NoError(t, err)
require.Error(t, runMigrateToProxiedServer(false, 0, false))
after, err := os.ReadFile(configfile.ConfigPath(beadsDir))
require.NoError(t, err)
assert.Equal(t, before, after)
}
func TestMigrateToProxiedServer_MalformedRootIdentityFailsClosed(t *testing.T) {
beadsDir := migrateModeWorkspace(t, configfile.DoltModeServer)
require.NoError(t, os.WriteFile(filepath.Join(beadsDir, "dolt", ".dolt", "repo_state.json"), []byte("not-json"), 0o600))
require.Error(t, runMigrateToProxiedServer(false, 0, false))
}
func TestMigrateToProxiedServer_InvalidRootIdentityShapesFailClosed(t *testing.T) {
for _, body := range []string{`{}`, `null`, `{"garbage":true}`, `{"head":null,"remotes":{},"backups":{},"branches":{}}`, `{"head":"refs/heads/","remotes":{},"backups":{},"branches":{}}`} {
t.Run(body, func(t *testing.T) {
beadsDir := migrateModeWorkspace(t, configfile.DoltModeServer)
require.NoError(t, os.WriteFile(filepath.Join(beadsDir, "dolt", ".dolt", "repo_state.json"), []byte(body), 0o600))
require.Error(t, runMigrateToProxiedServer(false, 0, false))
})
}
}
func TestMigrateToProxiedServer_DryRunWritesNothing(t *testing.T) {
beadsDir := migrateModeWorkspace(t, configfile.DoltModeServer)
touchFile(t, filepath.Join(beadsDir, "dolt-server.log"))
require.NoError(t, runMigrateToProxiedServer(true, 0, false))
cfg, err := configfile.Load(beadsDir)
require.NoError(t, err)
assert.True(t, cfg.IsDoltServerMode(), "mode must be unchanged in dry-run")
_, statErr := os.Stat(configfile.ProxiedServerClientInfoPath(beadsDir))
assert.True(t, os.IsNotExist(statErr), "sidecar must not be written in dry-run")
_, assetErr := os.Stat(filepath.Join(beadsDir, "dolt-server.log"))
require.NoError(t, assetErr, "dry-run must not delete assets")
}
func TestMigrateToProxiedServer_MalformedWorkspaceYAMLFailsClosed(t *testing.T) {
beadsDir := migrateModeWorkspace(t, configfile.DoltModeServer)
configPath := filepath.Join(beadsDir, "config.yaml")
require.NoError(t, os.WriteFile(configPath, []byte("dolt: ["), 0o600))
before := snapshotMigrationTree(t, beadsDir)
var err error
stderr := captureStderr(t, func() { err = runMigrateToProxiedServer(false, 0, false) })
require.Error(t, err)
assert.Contains(t, strings.ToLower(stderr), "parsing workspace config")
assert.Equal(t, before, snapshotMigrationTree(t, beadsDir))
}
func TestMigrationSharedTopology_ExplicitYAMLOverridesEnvironment(t *testing.T) {
for _, tc := range []struct {
name string
env string
yaml string
want bool
}{
{name: "false overrides true env", env: "1", yaml: "false", want: false},
{name: "true overrides empty env", env: "", yaml: "true", want: true},
} {
t.Run(tc.name, func(t *testing.T) {
beadsDir := migrateModeWorkspace(t, configfile.DoltModeServer)
t.Setenv("BEADS_DOLT_SHARED_SERVER", tc.env)
require.NoError(t, os.WriteFile(filepath.Join(beadsDir, "config.yaml"), []byte("dolt:\n shared-server: "+tc.yaml+"\n"), 0o600))
live, value, present, err := migrationSharedTopology(beadsDir)
require.NoError(t, err)
assert.True(t, present)
assert.Equal(t, tc.want, value)
assert.Equal(t, tc.want, live)
})
}
}
func TestMigrateToProxiedServer_UnreadableWorkspaceYAMLFailsClosed(t *testing.T) {
beadsDir := migrateModeWorkspace(t, configfile.DoltModeServer)
t.Setenv("BEADS_DOLT_SHARED_SERVER", "1")
configPath := filepath.Join(beadsDir, "config.yaml")
require.NoError(t, os.Mkdir(configPath, 0o700))
before := snapshotMigrationTree(t, beadsDir)
var err error
stderr := captureStderr(t, func() { err = runMigrateToProxiedServer(false, 0, false) })
require.Error(t, err)
code, ok := exitCodeFromError(err)
assert.True(t, ok)
assert.Equal(t, 1, code)
assert.Contains(t, strings.ToLower(stderr), "reading workspace config")
assert.Equal(t, before, snapshotMigrationTree(t, beadsDir))
}
func TestMigrateToProxiedServer_AlreadyProxiedRejectsStaleControl(t *testing.T) {
beadsDir := migrateModeWorkspace(t, configfile.DoltModeProxiedServer)
root := filepath.Join(beadsDir, "dolt")
require.NoError(t, configfile.SaveProxiedServerClientInfo(beadsDir, &configfile.ProxiedServerClientInfo{RootPath: root}))
touchFile(t, filepath.Join(root, "proxy.log"))
before := snapshotMigrationTree(t, beadsDir, root)
require.Error(t, runMigrateToProxiedServer(false, 0, false))
assert.Equal(t, before, snapshotMigrationTree(t, beadsDir, root))
}
func TestMigrateToProxiedServer_AlreadyProxiedRejectsBadSidecar(t *testing.T) {
for _, tc := range []struct {
name string
info *configfile.ProxiedServerClientInfo
}{
{"external", &configfile.ProxiedServerClientInfo{RootPath: "/tmp/ext", External: &configfile.ExternalDoltConfig{Host: "db.example", Port: 3307}}},
{"mismatch", &configfile.ProxiedServerClientInfo{RootPath: "/tmp/other"}},
} {
t.Run(tc.name, func(t *testing.T) {
beadsDir := migrateModeWorkspace(t, configfile.DoltModeProxiedServer)
require.NoError(t, configfile.SaveProxiedServerClientInfo(beadsDir, tc.info))
before := snapshotMigrationTree(t, beadsDir)
require.Error(t, runMigrateToProxiedServer(false, 0, false))
assert.Equal(t, before, snapshotMigrationTree(t, beadsDir))
})
}
}
func TestMigrateToProxiedServer_StaleSidecarFailsClosed(t *testing.T) {
rootCases := []struct {
name string
info *configfile.ProxiedServerClientInfo
want string
}{
{
name: "external endpoint",
info: &configfile.ProxiedServerClientInfo{
RootPath: filepath.Join("/", "external-root"),
External: &configfile.ExternalDoltConfig{Host: "db.example", Port: 3307},
},
want: "externally hosted proxied dolt endpoint",
},
{
name: "mismatched local root",
info: &configfile.ProxiedServerClientInfo{RootPath: filepath.Join("/", "another-repo")},
want: "sidecar root",
},
{
name: "matching relative root",
info: &configfile.ProxiedServerClientInfo{RootPath: "dolt"},
want: "exists without a recoverable journal",
},
}
for _, tc := range rootCases {
t.Run(tc.name, func(t *testing.T) {
beadsDir := migrateModeWorkspace(t, configfile.DoltModeServer)
root := filepath.Join(beadsDir, "dolt")
require.NoError(t, configfile.SaveProxiedServerClientInfo(beadsDir, tc.info))
before := snapshotMigrationTree(t, beadsDir, root)
var migrateErr error
stderr := captureStderr(t, func() {
migrateErr = runMigrateToProxiedServer(false, 0, false)
})
require.Error(t, migrateErr)
assert.Contains(t, strings.ToLower(stderr), tc.want)
assert.Equal(t, before, snapshotMigrationTree(t, beadsDir, root))
cfg, err := configfile.Load(beadsDir)
require.NoError(t, err)
assert.True(t, cfg.IsDoltServerMode())
journal, err := loadMigrateJournal(beadsDir)
require.NoError(t, err)
assert.Nil(t, journal)
})
}
}
func TestMigrateToServer_FlipsModeAndRemovesSidecar(t *testing.T) {
beadsDir := migrateModeWorkspace(t, configfile.DoltModeProxiedServer)
require.NoError(t, configfile.SaveProxiedServerClientInfo(beadsDir, &configfile.ProxiedServerClientInfo{}))
rootDir := filepath.Join(beadsDir, "dolt")
require.NoError(t, os.MkdirAll(filepath.Join(rootDir, ".dolt"), 0o755))
require.NoError(t, os.MkdirAll(filepath.Join(rootDir, "myproj", ".dolt"), 0o755))
touchFile(t, filepath.Join(rootDir, "config.yaml"))
for _, n := range proxiedAssetNames() {
touchFile(t, filepath.Join(rootDir, n))
}
require.NoError(t, runMigrateFromProxiedServer(false, false))
cfg, err := configfile.Load(beadsDir)
require.NoError(t, err)
assert.True(t, cfg.IsDoltServerMode())
_, statErr := os.Stat(configfile.ProxiedServerClientInfoPath(beadsDir))
assert.True(t, os.IsNotExist(statErr), "sidecar must be removed")
_, markerErr := os.Stat(filepath.Join(rootDir, ".bd-dolt-ok"))
require.NoError(t, markerErr, "compatibility marker must be written")
for _, n := range proxiedAssetNames() {
_, err := os.Stat(filepath.Join(rootDir, n))
assert.True(t, os.IsNotExist(err), "proxied asset %s must be removed", n)
}
_, dotDoltErr := os.Stat(filepath.Join(rootDir, ".dolt"))
require.NoError(t, dotDoltErr, "shared .dolt must be preserved")
_, dbErr := os.Stat(filepath.Join(rootDir, "myproj", ".dolt"))
require.NoError(t, dbErr, "database subdir must be preserved")
_, configErr := os.Stat(filepath.Join(rootDir, "config.yaml"))
require.NoError(t, configErr, "shared config.yaml must be preserved as the server-mode config")
}
func TestMigrateToServer_KeepsCustomConfig(t *testing.T) {
beadsDir := migrateModeWorkspace(t, configfile.DoltModeProxiedServer)
customConfig := filepath.Join(t.TempDir(), "custom.yaml")
touchFile(t, customConfig)
require.NoError(t, configfile.SaveProxiedServerClientInfo(beadsDir, &configfile.ProxiedServerClientInfo{
ConfigPath: customConfig,
}))
require.NoError(t, os.MkdirAll(filepath.Join(beadsDir, "dolt", ".dolt"), 0o755))
require.NoError(t, runMigrateFromProxiedServer(false, false))
_, err := os.Stat(customConfig)
require.NoError(t, err, "user-supplied config path must not be deleted")
}
func TestMigrateToServer_RejectsNonProxiedMode(t *testing.T) {
migrateModeWorkspace(t, configfile.DoltModeEmbedded)
err := runMigrateFromProxiedServer(false, false)
require.Error(t, err)
}
func TestMigrateMode_RefusesWhenLockHeld(t *testing.T) {
beadsDir := migrateModeWorkspace(t, configfile.DoltModeServer)
held, err := util.TryLock(filepath.Join(beadsDir, migrateLockFileName))
require.NoError(t, err)
require.Error(t, runMigrateToProxiedServer(false, 0, false), "must refuse while the lock is held")
require.Error(t, runMigrateFromProxiedServer(false, false), "must refuse while the lock is held")
cfg, err := configfile.Load(beadsDir)
require.NoError(t, err)
assert.True(t, cfg.IsDoltServerMode(), "mode must be unchanged while blocked")
held.Unlock()
require.NoError(t, runMigrateToProxiedServer(false, 0, false), "must succeed once the lock is released")
}
func TestMigrateToServer_RefusesWhenLifecycleLockHeld(t *testing.T) {
cases := []struct {
name string
rel func(beadsDir string) string
}{
{"proxy.lock", func(b string) string { return filepath.Join(b, "dolt", "proxy.lock") }},
{"proxy-child.lock", func(b string) string { return filepath.Join(b, "dolt", "proxy-child.lock") }},
{"dolt-server.lock", func(b string) string { return filepath.Join(b, "dolt-server.lock") }},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
beadsDir := migrateModeWorkspace(t, configfile.DoltModeProxiedServer)
require.NoError(t, configfile.SaveProxiedServerClientInfo(beadsDir, &configfile.ProxiedServerClientInfo{}))
require.NoError(t, os.MkdirAll(filepath.Join(beadsDir, "dolt", ".dolt"), 0o755))
held, err := util.TryLock(tc.rel(beadsDir))
require.NoError(t, err)
require.Error(t, runMigrateFromProxiedServer(false, false), "must refuse while %s is held", tc.name)
cfg, err := configfile.Load(beadsDir)
require.NoError(t, err)
assert.True(t, cfg.IsDoltProxiedServerMode(), "mode must be unchanged when blocked")
held.Unlock()
require.NoError(t, runMigrateFromProxiedServer(false, false), "must succeed once %s is released", tc.name)
free, err := util.TryLock(tc.rel(beadsDir))
require.NoError(t, err, "%s must be released after a successful migration", tc.name)
free.Unlock()
})
}
}
func TestMigrateMode_DryRunIgnoresLock(t *testing.T) {
beadsDir := migrateModeWorkspace(t, configfile.DoltModeServer)
held, err := util.TryLock(filepath.Join(beadsDir, migrateLockFileName))
require.NoError(t, err)
defer held.Unlock()
require.NoError(t, runMigrateToProxiedServer(true, 0, false), "dry-run must not require the lock")
}
func TestMigrateMode_ReleasesLockAfterSuccess(t *testing.T) {
beadsDir := migrateModeWorkspace(t, configfile.DoltModeServer)
require.NoError(t, runMigrateToProxiedServer(false, 0, false))
_, statErr := os.Stat(filepath.Join(beadsDir, migrateLockFileName))
assert.True(t, os.IsNotExist(statErr), "migrate.lock must be removed after the command completes")
lock, err := util.TryLock(filepath.Join(beadsDir, migrateLockFileName))
require.NoError(t, err, "lock must be released after the command completes")
lock.Unlock()
_ = os.Remove(filepath.Join(beadsDir, migrateLockFileName))
}
func TestMigrateSharedToProxiedServer_RootsAtSharedDir(t *testing.T) {
sharedDir := t.TempDir()
t.Setenv("BEADS_SHARED_SERVER_DIR", sharedDir)
t.Setenv("BEADS_DOLT_SHARED_SERVER", "1")
require.NoError(t, os.MkdirAll(filepath.Join(sharedDir, "dolt", ".dolt"), 0o755))
require.NoError(t, os.WriteFile(filepath.Join(sharedDir, "dolt", ".dolt", "repo_state.json"), []byte(`{"head":"refs/heads/main","remotes":{},"backups":{},"branches":{}}`), 0o600))
beadsDir := migrateModeWorkspace(t, configfile.DoltModeServer)
require.NoError(t, os.WriteFile(filepath.Join(beadsDir, "config.yaml"), []byte("dolt:\n shared-server: true\n"), 0o600))
require.NoError(t, runMigrateToProxiedServer(false, 0, true))
cfg, err := configfile.Load(beadsDir)
require.NoError(t, err)
assert.True(t, cfg.IsDoltProxiedServerMode())
info, err := configfile.LoadProxiedServerClientInfo(beadsDir)
require.NoError(t, err)
require.NotNil(t, info)
assert.Equal(t, filepath.Join(sharedDir, "dolt"), info.RootPath, "proxy must be rooted at the shared dolt dir")
body, _ := os.ReadFile(filepath.Join(beadsDir, "config.yaml"))
assert.NotContains(t, string(body), "shared-server: true", "dolt.shared-server must be turned off")
}
func TestMigrateSharedToProxiedServer_AllCheckpointFaultsRetry(t *testing.T) {
for _, phase := range []migratePhase{migratePrepared, migrateTargetConfigured, migrateOldControlsRetired, migrateVerified, migrateCommitted} {
t.Run(string(phase), func(t *testing.T) {
sharedDir := t.TempDir()
t.Setenv("BEADS_SHARED_SERVER_DIR", sharedDir)
t.Setenv("BEADS_DOLT_SHARED_SERVER", "1")
root := filepath.Join(sharedDir, "dolt")
require.NoError(t, os.MkdirAll(filepath.Join(root, ".dolt"), 0o755))
require.NoError(t, os.WriteFile(filepath.Join(root, ".dolt", "repo_state.json"), []byte(`{"head":"refs/heads/main","remotes":{},"backups":{},"branches":{}}`), 0o600))
sentinel := filepath.Join(root, "migration-sentinel")
touchFile(t, sentinel)
sentinelBefore, err := os.ReadFile(sentinel)
require.NoError(t, err)
beadsDir := migrateModeWorkspace(t, configfile.DoltModeServer)
require.NoError(t, os.WriteFile(filepath.Join(beadsDir, "config.yaml"), []byte("dolt:\n shared-server: true\n"), 0o600))
t.Setenv("BEADS_MIGRATION_FAIL_PHASE", string(phase))
require.Error(t, runMigrateToProxiedServer(false, 0, true))
j, err := loadMigrateJournal(beadsDir)
require.NoError(t, err)
require.NotNil(t, j)
assert.Equal(t, phase, j.Phase)
t.Setenv("BEADS_MIGRATION_FAIL_PHASE", "")
require.NoError(t, runMigrateToProxiedServer(false, 0, true))
after := snapshotMigrationTree(t, beadsDir, root)
require.NoError(t, runMigrateToProxiedServer(false, 0, true))
assert.Equal(t, after, snapshotMigrationTree(t, beadsDir, root), "retry changed durable migration artifacts")
assert.Equal(t, sentinelBefore, mustReadFile(t, sentinel), "migration sentinel changed")
running, _ := proxy.IsRunning(root)
assert.False(t, running, "retry left a proxy process running")
})
}
}
func TestMigrateSharedToProxiedServer_DryRunDoesNotCreateRoot(t *testing.T) {
sharedDir := t.TempDir()
t.Setenv("BEADS_SHARED_SERVER_DIR", sharedDir)
t.Setenv("BEADS_DOLT_SHARED_SERVER", "1")
beadsDir := migrateModeWorkspace(t, configfile.DoltModeServer)
require.NoError(t, os.WriteFile(filepath.Join(beadsDir, "config.yaml"), []byte("dolt:\n shared-server: true\n"), 0o600))
require.NoError(t, runMigrateToProxiedServer(true, 0, true))
_, err := os.Stat(filepath.Join(sharedDir, "dolt"))
assert.True(t, os.IsNotExist(err), "dry-run must not create shared root")
}
func TestMigrateToProxiedServer_RejectsSharedRepo(t *testing.T) {
t.Setenv("BEADS_DOLT_SHARED_SERVER", "1")
migrateModeWorkspace(t, configfile.DoltModeServer)
require.Error(t, runMigrateToProxiedServer(false, 0, false), "non-shared command must reject a shared repo")
}
func TestMigrateSharedToProxiedServer_RejectsNonShared(t *testing.T) {
migrateModeWorkspace(t, configfile.DoltModeServer)
require.Error(t, runMigrateToProxiedServer(false, 0, true), "shared command must reject a non-shared repo")
}
func TestMigrateProxiedToSharedServer_Reverse(t *testing.T) {
sharedDir := t.TempDir()
t.Setenv("BEADS_SHARED_SERVER_DIR", sharedDir)
beadsDir := migrateModeWorkspace(t, configfile.DoltModeProxiedServer)
require.NoError(t, os.WriteFile(filepath.Join(beadsDir, "config.yaml"), []byte("dolt:\n shared-server: false\n"), 0o600))
sharedDolt := filepath.Join(sharedDir, "dolt")
require.NoError(t, os.MkdirAll(filepath.Join(sharedDolt, ".dolt"), 0o755))
require.NoError(t, os.WriteFile(filepath.Join(sharedDolt, ".dolt", "repo_state.json"), []byte(`{"head":"refs/heads/main","remotes":{},"backups":{},"branches":{}}`), 0o600))
require.NoError(t, configfile.SaveProxiedServerClientInfo(beadsDir, &configfile.ProxiedServerClientInfo{RootPath: sharedDolt}))
require.NoError(t, runMigrateFromProxiedServer(false, true))
cfg, err := configfile.Load(beadsDir)
require.NoError(t, err)
assert.True(t, cfg.IsDoltServerMode())
_, statErr := os.Stat(configfile.ProxiedServerClientInfoPath(beadsDir))
assert.True(t, os.IsNotExist(statErr), "sidecar must be removed")
body, _ := os.ReadFile(filepath.Join(beadsDir, "config.yaml"))
assert.Contains(t, string(body), "shared-server: true", "dolt.shared-server must be re-enabled")
}
func TestMigrateFromProxiedToSharedServer_AllCheckpointFaultsRetry(t *testing.T) {
for _, phase := range []migratePhase{migratePrepared, migrateTargetConfigured, migrateOldControlsRetired, migrateVerified, migrateCommitted} {
t.Run(string(phase), func(t *testing.T) {
sharedDir := t.TempDir()
t.Setenv("BEADS_SHARED_SERVER_DIR", sharedDir)
t.Setenv("BEADS_DOLT_SHARED_SERVER", "")
root := filepath.Join(sharedDir, "dolt")
require.NoError(t, os.MkdirAll(filepath.Join(root, ".dolt"), 0o755))
require.NoError(t, os.WriteFile(filepath.Join(root, ".dolt", "repo_state.json"), []byte(`{"head":"refs/heads/main","remotes":{},"backups":{},"branches":{}}`), 0o600))
sentinel := filepath.Join(root, "migration-sentinel")
touchFile(t, sentinel)
sentinelBefore, err := os.ReadFile(sentinel)
require.NoError(t, err)
beadsDir := migrateModeWorkspace(t, configfile.DoltModeProxiedServer)
require.NoError(t, configfile.SaveProxiedServerClientInfo(beadsDir, &configfile.ProxiedServerClientInfo{RootPath: root}))
require.NoError(t, os.WriteFile(filepath.Join(beadsDir, "config.yaml"), []byte("dolt:\n shared-server: false\n"), 0o600))
t.Setenv("BEADS_MIGRATION_FAIL_PHASE", string(phase))
require.Error(t, runMigrateFromProxiedServer(false, true))
j, err := loadMigrateJournal(beadsDir)
require.NoError(t, err)
require.NotNil(t, j)
assert.Equal(t, phase, j.Phase)
assert.Equal(t, 1, j.Attempt)
t.Setenv("BEADS_MIGRATION_FAIL_PHASE", "")
require.NoError(t, runMigrateFromProxiedServer(false, true))
after := snapshotMigrationTree(t, beadsDir, root)
require.NoError(t, runMigrateFromProxiedServer(false, true))
assert.Equal(t, after, snapshotMigrationTree(t, beadsDir, root), "retry changed durable migration artifacts")
assert.Equal(t, sentinelBefore, mustReadFile(t, sentinel), "migration sentinel changed")
running, _ := proxy.IsRunning(root)
assert.False(t, running, "retry left a proxy process running")
cfg, _ := configfile.Load(beadsDir)
assert.True(t, cfg.IsDoltServerMode())
v, ok := config.WorkspaceYamlValue(beadsDir, "dolt.shared-server")
assert.True(t, ok)
assert.Equal(t, "true", strings.ToLower(v))
_, err = os.Stat(configfile.ProxiedServerClientInfoPath(beadsDir))
assert.True(t, os.IsNotExist(err))
})
}
}
func TestMigrateProxiedToSharedServer_DryRunDoesNotCreateRoot(t *testing.T) {
sharedDir := t.TempDir()
t.Setenv("BEADS_SHARED_SERVER_DIR", sharedDir)
beadsDir := migrateModeWorkspace(t, configfile.DoltModeProxiedServer)
sharedDolt := filepath.Join(sharedDir, "dolt")
require.NoError(t, configfile.SaveProxiedServerClientInfo(beadsDir, &configfile.ProxiedServerClientInfo{RootPath: sharedDolt}))
require.NoError(t, runMigrateFromProxiedServer(true, true))
_, err := os.Stat(sharedDolt)
assert.True(t, os.IsNotExist(err), "dry-run must not create shared root")
}
func TestMigrateFromProxiedToServer_RejectsSharedRooted(t *testing.T) {
sharedDir := t.TempDir()
t.Setenv("BEADS_SHARED_SERVER_DIR", sharedDir)
beadsDir := migrateModeWorkspace(t, configfile.DoltModeProxiedServer)
sharedDolt := filepath.Join(sharedDir, "dolt")
require.NoError(t, os.MkdirAll(filepath.Join(sharedDolt, ".dolt"), 0o755))
require.NoError(t, os.WriteFile(filepath.Join(sharedDolt, ".dolt", "repo_state.json"), []byte(`{"head":"refs/heads/main","remotes":{},"backups":{},"branches":{}}`), 0o600))
require.NoError(t, configfile.SaveProxiedServerClientInfo(beadsDir, &configfile.ProxiedServerClientInfo{RootPath: sharedDolt}))
require.Error(t, runMigrateFromProxiedServer(false, false), "non-shared reverse must reject a shared-rooted proxied repo")
}
func TestMigrateToProxiedServer_AlreadyProxiedIsNoop(t *testing.T) {
beadsDir := migrateModeWorkspace(t, configfile.DoltModeProxiedServer)
require.NoError(t, configfile.SaveProxiedServerClientInfo(beadsDir, &configfile.ProxiedServerClientInfo{RootPath: filepath.Join(beadsDir, "dolt")}))
require.NoError(t, runMigrateToProxiedServer(false, 0, false))
cfg, err := configfile.Load(beadsDir)
require.NoError(t, err)
assert.True(t, cfg.IsDoltProxiedServerMode())
}
func TestMigrateSharedToProxiedServer_AlreadyProxiedUsesSharedRootAndStaleEnv(t *testing.T) {
sharedDir := t.TempDir()
t.Setenv("BEADS_SHARED_SERVER_DIR", sharedDir)
t.Setenv("BEADS_DOLT_SHARED_SERVER", "true") // stale ambient state after migration
beadsDir := migrateModeWorkspace(t, configfile.DoltModeProxiedServer)
require.NoError(t, os.WriteFile(filepath.Join(beadsDir, "config.yaml"), []byte("dolt:\n shared-server: false\n"), 0o600))
root := filepath.Join(sharedDir, "dolt")
require.NoError(t, os.MkdirAll(filepath.Join(root, ".dolt"), 0o755))
require.NoError(t, configfile.SaveProxiedServerClientInfo(beadsDir, &configfile.ProxiedServerClientInfo{RootPath: root}))
require.NoError(t, runMigrateToProxiedServer(false, 0, true))
}
func TestMigrateToProxiedServer_AlreadyProxiedAllowsUnlockedLockMarkers(t *testing.T) {
beadsDir := migrateModeWorkspace(t, configfile.DoltModeProxiedServer)
root := filepath.Join(beadsDir, "dolt")
require.NoError(t, configfile.SaveProxiedServerClientInfo(beadsDir, &configfile.ProxiedServerClientInfo{RootPath: root}))
for _, name := range []string{proxy.LockFileName, server.LockFileName} {
touchFile(t, filepath.Join(root, name))
}
require.NoError(t, runMigrateToProxiedServer(false, 0, false))
}
func TestMigrateToProxiedServer_AlreadyProxiedRefusalsAreTyped(t *testing.T) {
cases := []struct {
name string
info *configfile.ProxiedServerClientInfo
control string
}{
{name: "external sidecar", info: &configfile.ProxiedServerClientInfo{RootPath: "/tmp/external", External: &configfile.ExternalDoltConfig{Host: "db.example", Port: 3307}}},
{name: "mismatched sidecar", info: &configfile.ProxiedServerClientInfo{RootPath: "/tmp/other"}},
{name: "stale control", control: proxy.LogFileName},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
beadsDir := migrateModeWorkspace(t, configfile.DoltModeProxiedServer)
root := filepath.Join(beadsDir, "dolt")
if tc.info == nil {
tc.info = &configfile.ProxiedServerClientInfo{RootPath: root}
}
require.NoError(t, configfile.SaveProxiedServerClientInfo(beadsDir, tc.info))
if tc.control != "" {
touchFile(t, filepath.Join(root, tc.control))
}
oldJSON := jsonOutput
jsonOutput = true
t.Cleanup(func() { jsonOutput = oldJSON })
out, err := captureMigrationJSON(t, func() error { return runMigrateToProxiedServer(false, 0, false) })
code, ok := exitCodeFromError(err)
assert.True(t, ok)
assert.Equal(t, 1, code)
var got map[string]any
require.NoError(t, json.Unmarshal([]byte(out), &got), "output=%q", out)
assert.Equal(t, "proxy.migrate.invalid_state", got["code"])
assert.Equal(t, false, got["mutates"])
})
}
}
func TestMigrateToProxiedServer_AlreadyProxiedRefusesHeldLockAsTyped(t *testing.T) {
beadsDir := migrateModeWorkspace(t, configfile.DoltModeProxiedServer)
root := filepath.Join(beadsDir, "dolt")
require.NoError(t, configfile.SaveProxiedServerClientInfo(beadsDir, &configfile.ProxiedServerClientInfo{RootPath: root}))
held, err := util.TryLock(filepath.Join(root, proxy.LockFileName))
require.NoError(t, err)
defer held.Unlock()
oldJSON := jsonOutput
jsonOutput = true
t.Cleanup(func() { jsonOutput = oldJSON })
out, err := captureMigrationJSON(t, func() error { return runMigrateToProxiedServer(false, 0, false) })
code, ok := exitCodeFromError(err)
assert.True(t, ok)
assert.Equal(t, 1, code)
var got map[string]any
require.NoError(t, json.Unmarshal([]byte(out), &got))
assert.Equal(t, "proxy.migrate.invalid_state", got["code"])
assert.Equal(t, false, got["mutates"])
}
func TestMigrateToProxiedServer_RetryAfterCheckpointFault(t *testing.T) {
beadsDir := migrateModeWorkspace(t, configfile.DoltModeServer)
t.Setenv("BEADS_MIGRATION_FAIL_PHASE", string(migrateTargetConfigured))
require.Error(t, runMigrateToProxiedServer(false, 0, false))
j, err := loadMigrateJournal(beadsDir)
require.NoError(t, err)
require.NotNil(t, j)
assert.Equal(t, migrateTargetConfigured, j.Phase)
t.Setenv("BEADS_MIGRATION_FAIL_PHASE", "")
require.NoError(t, runMigrateToProxiedServer(false, 0, false))
j, err = loadMigrateJournal(beadsDir)
assert.NoError(t, err)
assert.Nil(t, j, "successful migration removes its journal")
}
// TestMigrateToProxiedServer_ResumeReplaysRecordedIdleTimeout covers the resume
// case every other fault-retry test misses: the retry replays identical argv, so
// the sidecar is only ever rebuilt in its trivially-consistent form. A resume
// that changes --idle-timeout (or omits it, which resolves differently again)
// must replay the journal's recorded plan. Rebuilding the sidecar from the
// current argv persists the divergence before the equality check detects it, and
// because the rebuild is gated on phase == migratePrepared, re-supplying the
// original value cannot repair it afterwards.
func TestMigrateToProxiedServer_ResumeReplaysRecordedIdleTimeout(t *testing.T) {
for _, tc := range []struct {
name string
resume time.Duration
}{
{name: "changed", resume: 5 * time.Minute},
{name: "omitted", resume: 0},
{name: "never", resume: proxy.IdleTimeoutNever},
} {
t.Run(tc.name, func(t *testing.T) {
beadsDir := migrateModeWorkspace(t, configfile.DoltModeServer)
recorded := 90 * time.Second
t.Setenv("BEADS_MIGRATION_FAIL_PHASE", string(migratePrepared))
require.Error(t, runMigrateToProxiedServer(false, recorded, false))
j, err := loadMigrateJournal(beadsDir)
require.NoError(t, err)
require.NotNil(t, j)
require.Equal(t, migratePrepared, j.Phase)
require.NotNil(t, j.Sidecar)
require.Equal(t, recorded, j.Sidecar.IdleTimeout)
t.Setenv("BEADS_MIGRATION_FAIL_PHASE", "")
require.NoError(t, runMigrateToProxiedServer(false, tc.resume, false))
j, err = loadMigrateJournal(beadsDir)
require.NoError(t, err)
assert.Nil(t, j, "successful migration removes its journal")
info, err := configfile.LoadProxiedServerClientInfo(beadsDir)
require.NoError(t, err)
require.NotNil(t, info)
assert.Equal(t, recorded, info.IdleTimeout, "sidecar must hold the recorded plan, not the resume argv")
// The reverse migration is the documented escape hatch; it compares
// the same two values, so it must also accept the resumed state.
require.NoError(t, runMigrateFromProxiedServer(false, false))
})
}
}
func TestMigrateJournal_UnknownPhaseFailsClosed(t *testing.T) {
beadsDir := migrateModeWorkspace(t, configfile.DoltModeServer)
path := migrateJournalPath(beadsDir)
require.NoError(t, os.WriteFile(path, []byte(`{"version":1,"source_mode":"server","target_mode":"proxied-server","phase":"surprise","attempt":1}`), 0o600))
_, err := loadMigrateJournal(beadsDir)
require.Error(t, err)
}
func TestMigrateToProxiedServer_AllCheckpointFaultsRetry(t *testing.T) {
for _, phase := range []migratePhase{migratePrepared, migrateTargetConfigured, migrateOldControlsRetired, migrateVerified, migrateCommitted} {
t.Run(string(phase), func(t *testing.T) {
beadsDir := migrateModeWorkspace(t, configfile.DoltModeServer)
t.Setenv("BEADS_MIGRATION_FAIL_PHASE", string(phase))
require.Error(t, runMigrateToProxiedServer(false, 0, false))
j, err := loadMigrateJournal(beadsDir)
require.NoError(t, err)
require.NotNil(t, j)
assert.Equal(t, phase, j.Phase)
assert.Equal(t, 1, j.Attempt)
t.Setenv("BEADS_MIGRATION_FAIL_PHASE", "")
require.NoError(t, runMigrateToProxiedServer(false, 0, false))
after := snapshotMigrationTree(t, beadsDir)
j, err = loadMigrateJournal(beadsDir)
require.NoError(t, err)
assert.Nil(t, j)
require.NoError(t, runMigrateToProxiedServer(false, 0, false))
assert.Equal(t, after, snapshotMigrationTree(t, beadsDir))
})
}
}
func TestMigrateFromProxiedServer_MalformedSidecarFailsClosed(t *testing.T) {
beadsDir := migrateModeWorkspace(t, configfile.DoltModeProxiedServer)
require.NoError(t, os.WriteFile(configfile.ProxiedServerClientInfoPath(beadsDir), []byte("{bad"), 0o600))
require.Error(t, runMigrateFromProxiedServer(false, false))
data, err := os.ReadFile(configfile.ConfigPath(beadsDir))
require.NoError(t, err)
assert.Contains(t, string(data), configfile.DoltModeProxiedServer)
}
func TestMigrateFromProxiedServer_AlreadyServerRejectsMalformedSidecar(t *testing.T) {
beadsDir := migrateModeWorkspace(t, configfile.DoltModeServer)
path := configfile.ProxiedServerClientInfoPath(beadsDir)
require.NoError(t, os.WriteFile(path, []byte("{bad"), 0o600))
before := snapshotMigrationTree(t, beadsDir)
var err error
stderr := captureStderr(t, func() { err = runMigrateFromProxiedServer(false, false) })
require.Error(t, err)
assert.Contains(t, strings.ToLower(stderr), "sidecar")
assert.Equal(t, before, snapshotMigrationTree(t, beadsDir))
}
func TestMigrateFromProxiedServer_AlreadyTargetRejectsStaleSidecar(t *testing.T) {
beadsDir := migrateModeWorkspace(t, configfile.DoltModeServer)
require.NoError(t, configfile.SaveProxiedServerClientInfo(beadsDir, &configfile.ProxiedServerClientInfo{RootPath: filepath.Join(beadsDir, "dolt")}))
before := snapshotMigrationTree(t, beadsDir)
var err error
stderr := captureStderr(t, func() { err = runMigrateFromProxiedServer(false, false) })
require.Error(t, err)
assert.Contains(t, strings.ToLower(stderr), "stale")
assert.Equal(t, before, snapshotMigrationTree(t, beadsDir))
}
func TestMigrateFromProxiedToSharedServer_AlreadyTargetRejectsStaleSidecar(t *testing.T) {
sharedDir := t.TempDir()
t.Setenv("BEADS_SHARED_SERVER_DIR", sharedDir)
beadsDir := migrateModeWorkspace(t, configfile.DoltModeServer)
require.NoError(t, os.WriteFile(filepath.Join(beadsDir, "config.yaml"), []byte("dolt:\n shared-server: true\n"), 0o600))
root := filepath.Join(sharedDir, "dolt")
require.NoError(t, os.MkdirAll(filepath.Join(root, ".dolt"), 0o755))
require.NoError(t, os.WriteFile(filepath.Join(root, ".dolt", "repo_state.json"), []byte(`{"head":"refs/heads/main","remotes":{},"backups":{},"branches":{}}`), 0o600))
require.NoError(t, configfile.SaveProxiedServerClientInfo(beadsDir, &configfile.ProxiedServerClientInfo{RootPath: root}))
before := snapshotMigrationTree(t, beadsDir, root)
var err error
stderr := captureStderr(t, func() { err = runMigrateFromProxiedServer(false, true) })
require.Error(t, err)
assert.Contains(t, strings.ToLower(stderr), "stale")
assert.Equal(t, before, snapshotMigrationTree(t, beadsDir, root))
}
func TestMigrateFromProxiedServer_JournalPreservesExternalSidecar(t *testing.T) {
beadsDir := migrateModeWorkspace(t, configfile.DoltModeProxiedServer)
root := filepath.Join(beadsDir, "dolt")
ext := &configfile.ExternalDoltConfig{Host: "db.example", Port: 3307, User: "alice"}
require.NoError(t, configfile.SaveProxiedServerClientInfo(beadsDir, &configfile.ProxiedServerClientInfo{RootPath: root, External: ext}))
require.NoError(t, os.MkdirAll(filepath.Join(root, ".dolt"), 0o755))
require.Error(t, runMigrateFromProxiedServer(false, false), "external endpoint cannot be converted to local server")
got, err := configfile.LoadProxiedServerClientInfo(beadsDir)
require.NoError(t, err)
assert.Equal(t, ext, got.External)
cfg, err := configfile.Load(beadsDir)
require.NoError(t, err)
assert.True(t, cfg.IsDoltProxiedServerMode())
}
func TestMigrateFromProxiedServer_AllCheckpointFaultsRetry(t *testing.T) {
for _, phase := range []migratePhase{migratePrepared, migrateTargetConfigured, migrateOldControlsRetired, migrateVerified, migrateCommitted} {
t.Run(string(phase), func(t *testing.T) {
beadsDir := migrateModeWorkspace(t, configfile.DoltModeProxiedServer)
root := filepath.Join(beadsDir, "dolt")
require.NoError(t, os.MkdirAll(filepath.Join(root, ".dolt"), 0o755))
sentinel := filepath.Join(root, "migration-sentinel")
touchFile(t, sentinel)
sentinelBefore, err := os.ReadFile(sentinel)
require.NoError(t, err)
require.NoError(t, configfile.SaveProxiedServerClientInfo(beadsDir, &configfile.ProxiedServerClientInfo{RootPath: root}))
t.Setenv("BEADS_MIGRATION_FAIL_PHASE", string(phase))
require.Error(t, runMigrateFromProxiedServer(false, false))
t.Setenv("BEADS_MIGRATION_FAIL_PHASE", "")
require.NoError(t, runMigrateFromProxiedServer(false, false))
after := snapshotMigrationTree(t, beadsDir)
assert.Equal(t, sentinelBefore, mustReadFile(t, sentinel), "migration sentinel changed")
j, err := loadMigrateJournal(beadsDir)
require.NoError(t, err)
assert.Nil(t, j)
require.NoError(t, runMigrateFromProxiedServer(false, false))
assert.Equal(t, after, snapshotMigrationTree(t, beadsDir))
})
}
}
func TestMigrateFromProxiedServer_ExternalJournalAlwaysFailsClosed(t *testing.T) {
for _, phase := range []migratePhase{migratePrepared, migrateTargetConfigured, migrateOldControlsRetired, migrateVerified, migrateCommitted} {
t.Run(string(phase), func(t *testing.T) {
beadsDir := migrateModeWorkspace(t, configfile.DoltModeProxiedServer)
root := filepath.Join(beadsDir, "dolt")
require.NoError(t, os.MkdirAll(root, 0o755))
if phase != migratePrepared {
writeMetadataConfig(t, beadsDir, configfile.DoltModeServer, "myproj")
}
wantMode := configfile.DoltModeServer
if phase == migratePrepared {
wantMode = configfile.DoltModeProxiedServer
}
ext := &configfile.ExternalDoltConfig{Host: "db.example", Port: 3307}
j := migrateJournal{Version: 1, SourceMode: configfile.DoltModeProxiedServer, TargetMode: configfile.DoltModeServer, RootPath: root, External: ext, Ownership: "external", Attempt: 1, Phase: phase, Sidecar: &configfile.ProxiedServerClientInfo{RootPath: root, External: ext}}
b, err := json.Marshal(j)
require.NoError(t, err)
require.NoError(t, os.WriteFile(migrateJournalPath(beadsDir), b, 0o600))
require.Error(t, runMigrateFromProxiedServer(false, false))
cfg, err := configfile.Load(beadsDir)
require.NoError(t, err)
assert.Equal(t, wantMode, cfg.GetDoltMode())
})
}
}
func TestMigrateExternalJournalAlwaysFailsClosed_TCPAndUnixForwardReverse(t *testing.T) {
endpoints := []struct {
name string
cfg *configfile.ExternalDoltConfig
}{
{"tcp", &configfile.ExternalDoltConfig{Host: "db.example", Port: 3307}},
{"unix", &configfile.ExternalDoltConfig{Socket: "/tmp/beads-dolt.sock"}},
}
for _, ep := range endpoints {
for _, reverse := range []bool{false, true} {
for _, phase := range []migratePhase{migratePrepared, migrateTargetConfigured, migrateOldControlsRetired, migrateVerified, migrateCommitted} {
t.Run(ep.name+"/"+string(phase), func(t *testing.T) {
beadsDir := migrateModeWorkspace(t, configfile.DoltModeServer)
root := filepath.Join(beadsDir, "dolt")
want := configfile.DoltModeServer
src := configfile.DoltModeServer
target := configfile.DoltModeProxiedServer
if reverse {
src, target = configfile.DoltModeProxiedServer, configfile.DoltModeServer
want = configfile.DoltModeProxiedServer
}
// A prepared journal may legitimately coexist with either
// source or target metadata. Later phases require target
// metadata so validation reaches the ownership refusal.
metadataMode := src
if phase != migratePrepared {
metadataMode = target
}
want = metadataMode
writeMetadataConfig(t, beadsDir, metadataMode, "myproj")
j := migrateJournal{Version: 1, SourceMode: src, TargetMode: target, RootPath: root, External: ep.cfg, Ownership: "external", Attempt: 1, Phase: phase, Sidecar: &configfile.ProxiedServerClientInfo{RootPath: root, External: ep.cfg}}
b, err := json.Marshal(j)
require.NoError(t, err)
require.NoError(t, os.WriteFile(migrateJournalPath(beadsDir), b, 0o600))
treeBefore := snapshotMigrationTree(t, beadsDir, root)
before, _ := os.ReadFile(configfile.ConfigPath(beadsDir))
var migrateErr error
stderr := captureStderr(t, func() {
if reverse {
migrateErr = runMigrateFromProxiedServer(false, false)
} else {
migrateErr = runMigrateToProxiedServer(false, 0, false)
}
})
require.Error(t, migrateErr)
assert.Contains(t, strings.ToLower(stderr), "externally hosted proxied dolt endpoint")
after, _ := os.ReadFile(configfile.ConfigPath(beadsDir))
assert.Equal(t, before, after)
cfg, _ := configfile.Load(beadsDir)
assert.Equal(t, want, cfg.GetDoltMode())
assert.Equal(t, treeBefore, snapshotMigrationTree(t, beadsDir, root))
})
}
}
}
}
func TestMigrateSharedJournalRootMismatchFailsClosed(t *testing.T) {
shared := t.TempDir()
t.Setenv("BEADS_SHARED_SERVER_DIR", shared)
t.Setenv("BEADS_DOLT_SHARED_SERVER", "1")
beadsDir := migrateModeWorkspace(t, configfile.DoltModeServer)
require.NoError(t, os.WriteFile(filepath.Join(beadsDir, "config.yaml"), []byte("dolt:\n shared-server: true\n"), 0o600))
root := filepath.Join(beadsDir, "dolt")
j := migrateJournal{Version: 1, SourceMode: configfile.DoltModeServer, TargetMode: configfile.DoltModeProxiedServer, Shared: true, RootPath: root, Ownership: "managed-local", Attempt: 1, Phase: migratePrepared, Sidecar: &configfile.ProxiedServerClientInfo{RootPath: root}}
b, err := json.Marshal(j)
require.NoError(t, err)
require.NoError(t, os.WriteFile(migrateJournalPath(beadsDir), b, 0o600))
require.Error(t, runMigrateToProxiedServer(false, 0, true))
cfg, err := configfile.Load(beadsDir)
require.NoError(t, err)
assert.True(t, cfg.IsDoltServerMode())
}
func TestMigrateSharedJournalMissingYAMLFailsClosed(t *testing.T) {
shared := t.TempDir()
t.Setenv("BEADS_SHARED_SERVER_DIR", shared)
t.Setenv("BEADS_DOLT_SHARED_SERVER", "1")
beadsDir := migrateModeWorkspace(t, configfile.DoltModeServer)
root := filepath.Join(shared, "dolt")
require.NoError(t, os.MkdirAll(filepath.Join(root, ".dolt"), 0o755))
require.NoError(t, os.WriteFile(filepath.Join(root, ".dolt", "repo_state.json"), []byte(`{"head":"refs/heads/main","remotes":{},"backups":{},"branches":{}}`), 0o600))
j := migrateJournal{Version: 1, SourceMode: configfile.DoltModeServer, TargetMode: configfile.DoltModeProxiedServer, Shared: true, RootPath: root, Ownership: "managed-local", Attempt: 1, Phase: migratePrepared, Sidecar: &configfile.ProxiedServerClientInfo{RootPath: root}}
b, _ := json.Marshal(j)
require.NoError(t, os.WriteFile(migrateJournalPath(beadsDir), b, 0o600))
require.Error(t, runMigrateToProxiedServer(false, 0, true))
}
func TestMigrateNonSharedJournalRejectsPersistedSharedYAML(t *testing.T) {
t.Setenv("BEADS_DOLT_SHARED_SERVER", "1") // stale ambient environment
beadsDir := migrateModeWorkspace(t, configfile.DoltModeProxiedServer)
require.NoError(t, os.WriteFile(filepath.Join(beadsDir, "config.yaml"), []byte("dolt:\n shared-server: true\n"), 0o600))
root := filepath.Join(beadsDir, "dolt")
j := migrateJournal{Version: 1, SourceMode: configfile.DoltModeServer, TargetMode: configfile.DoltModeProxiedServer, RootPath: root, Ownership: "managed-local", Attempt: 1, Phase: migrateTargetConfigured, Sidecar: &configfile.ProxiedServerClientInfo{RootPath: root}}
b, err := json.Marshal(j)
require.NoError(t, err)
require.NoError(t, os.WriteFile(migrateJournalPath(beadsDir), b, 0o600))
err = runMigrateToProxiedServer(false, 0, false)
require.Error(t, err)
}
func TestMigrateJournalSidecarRootMismatchFailsClosed(t *testing.T) {
beadsDir := migrateModeWorkspace(t, configfile.DoltModeServer)
j := migrateJournal{Version: 1, SourceMode: configfile.DoltModeServer, TargetMode: configfile.DoltModeProxiedServer, RootPath: filepath.Join(beadsDir, "dolt"), Ownership: "managed-local", Attempt: 1, Phase: migratePrepared, Sidecar: &configfile.ProxiedServerClientInfo{RootPath: filepath.Join(beadsDir, "other")}}
b, err := json.Marshal(j)
require.NoError(t, err)
require.NoError(t, os.WriteFile(migrateJournalPath(beadsDir), b, 0o600))
_, err = loadMigrateJournal(beadsDir)
require.Error(t, err)
}
func TestMigrateJournalExternalTopologyMismatchFailsClosed(t *testing.T) {
beadsDir := migrateModeWorkspace(t, configfile.DoltModeProxiedServer)
root := filepath.Join(beadsDir, "dolt")
ext := &configfile.ExternalDoltConfig{Host: "db.example", Port: 3307}
for _, tc := range []struct {
name string
ownership string
journal *configfile.ExternalDoltConfig
sidecar *configfile.ExternalDoltConfig
}{
{name: "journal external differs", ownership: "external", journal: &configfile.ExternalDoltConfig{Host: "other.example", Port: 3307}, sidecar: ext},
{name: "journal unexpected external", ownership: "managed-local", journal: ext, sidecar: nil},
} {
t.Run(tc.name, func(t *testing.T) {
j := migrateJournal{Version: 1, SourceMode: configfile.DoltModeProxiedServer, TargetMode: configfile.DoltModeServer, RootPath: root, Ownership: tc.ownership, Attempt: 1, Phase: migratePrepared, External: tc.journal, Sidecar: &configfile.ProxiedServerClientInfo{RootPath: root, External: tc.sidecar}}
b, err := json.Marshal(j)
require.NoError(t, err)
require.NoError(t, os.WriteFile(migrateJournalPath(beadsDir), b, 0o600))
_, err = loadMigrateJournal(beadsDir)
require.Error(t, err)
})
}
}
func TestMigrateJournalLegacyExternalFieldInfersSidecar(t *testing.T) {
beadsDir := migrateModeWorkspace(t, configfile.DoltModeProxiedServer)
root := filepath.Join(beadsDir, "dolt")
ext := &configfile.ExternalDoltConfig{Host: "db.example", Port: 3307}
j := migrateJournal{Version: 1, SourceMode: configfile.DoltModeProxiedServer, TargetMode: configfile.DoltModeServer, RootPath: root, Ownership: "external", Attempt: 1, Phase: migratePrepared, Sidecar: &configfile.ProxiedServerClientInfo{RootPath: root, External: ext}}
b, err := json.Marshal(j)
require.NoError(t, err)
require.NoError(t, os.WriteFile(migrateJournalPath(beadsDir), b, 0o600))
got, err := loadMigrateJournal(beadsDir)
require.NoError(t, err)
require.NotNil(t, got)
assert.Equal(t, ext, got.External)
}
func TestMigrateFromProxiedServer_JournalSidecarChangedFailsClosed(t *testing.T) {
beadsDir := migrateModeWorkspace(t, configfile.DoltModeProxiedServer)
root := filepath.Join(beadsDir, "dolt")
require.NoError(t, os.MkdirAll(filepath.Join(root, ".dolt"), 0o755))
wantSidecar := &configfile.ProxiedServerClientInfo{RootPath: root, LogPath: filepath.Join(root, "server.log")}
gotSidecar := &configfile.ProxiedServerClientInfo{RootPath: root, LogPath: filepath.Join(root, "changed.log")}
require.NoError(t, configfile.SaveProxiedServerClientInfo(beadsDir, gotSidecar))
j := migrateJournal{Version: 1, SourceMode: configfile.DoltModeProxiedServer, TargetMode: configfile.DoltModeServer, RootPath: root, Ownership: "managed-local", Attempt: 1, Phase: migratePrepared, Sidecar: wantSidecar}
b, err := json.Marshal(j)
require.NoError(t, err)
journalPath := migrateJournalPath(beadsDir)
require.NoError(t, os.WriteFile(journalPath, b, 0o600))
before := snapshotMigrationTree(t, beadsDir, root)
var migrateErr error
captureStderr(t, func() { migrateErr = runMigrateFromProxiedServer(false, false) })
require.Error(t, migrateErr)
assert.Equal(t, before, snapshotMigrationTree(t, beadsDir, root))
}
// TestMigrateFromProxiedServer_ForwardJournalAtPreparedIsNotSidecarRefused is
// the complement of the test above, and the reason its guard is scoped to
// reverse journals.
//
// The two directions mean different things by a migratePrepared journal that
// names a sidecar. A reverse journal names one that is already on disk, so a
// mismatch is real corruption -- that is the case above. A forward journal
// names the sidecar it is about to write, and only advances past
// migratePrepared once the write lands, so a crash in that pre-write window
// leaves no sidecar on disk at all. That is the correct state for the phase,
// not a mismatch.
//
// This command is the documented escape hatch out of exactly that wreck: the
// non-proxied-mode refusal is gated on j == nil, so a leftover journal is what
// lets the operator run it with the live mode still on "server". An unscoped
// sidecar check refuses here by naming a missing file, which strands the
// workspace with no way forward and no way back.
func TestMigrateFromProxiedServer_ForwardJournalAtPreparedIsNotSidecarRefused(t *testing.T) {
// Live mode is still the forward migration's source: it flips only after
// the sidecar is written, so a crash before that leaves it untouched.
beadsDir := migrateModeWorkspace(t, configfile.DoltModeServer)
root := filepath.Join(beadsDir, "dolt")
j := migrateJournal{Version: 1, SourceMode: configfile.DoltModeServer, TargetMode: configfile.DoltModeProxiedServer, RootPath: root, Ownership: "managed-local", Attempt: 1, Phase: migratePrepared, Sidecar: &configfile.ProxiedServerClientInfo{RootPath: root}}
b, err := json.Marshal(j)
require.NoError(t, err)
require.NoError(t, os.WriteFile(migrateJournalPath(beadsDir), b, 0o600))
// Precondition: no sidecar on disk, which is what the guard would have
// compared against the journal's.
_, statErr := os.Stat(configfile.ProxiedServerClientInfoPath(beadsDir))
require.True(t, os.IsNotExist(statErr), "precondition: sidecar must be absent, got %v", statErr)
var migrateErr error
stderr := captureStderr(t, func() { migrateErr = runMigrateFromProxiedServer(false, false) })
// Deliberately not asserting success: what this command does next with a
// forward journal is its own behavior and has its own coverage. The pin is
// only that it does not stop at the sidecar comparison, whose message
// would be a lie about the workspace.
if migrateErr != nil {
assert.NotContains(t, stderr, "migration sidecar does not match prepared state")
assert.NotContains(t, migrateErr.Error(), "migration sidecar does not match prepared state")
}
}