beads/cmd/bd/version_tracking_test.go
Julian Knutsen 8951ca56ba
fix(version): refuse Go pseudo-version predecessors in pre-0.56 recovery (#7000)
#6153 taught the doctor version helpers to accept a leading "v"
(GH#6152). recoverPreV56IfNeeded reused IsValidSemver as the gate that
kept the v-prefixed Go pseudo-versions from #5650 off the path that
deletes .dolt, so that protection went with it: a major-0 pseudo-version
such as v0.0.0-<ts>-<hash> or v0.55.5-0.<ts>-<hash> now passes the
validity check and compares below 0.56.0. The .bd-dolt-ok marker only
stops the rebuild for databases bd 0.58.0 or later has served; 0.56.x
and 0.57.x never wrote it.

Refuse pseudo-versions explicitly with golang.org/x/mod/module, after
normalizing the stamp the way the doctor helpers read it, so the
spelling of a stamp never decides whether its database is deleted. A
pseudo-version's numbers bound the build from below only, so they can
never show that a workspace predates 0.56. This also refuses a bare
pseudo-version (0.0.0-<ts>-<hash>), which the digit scan has always
accepted. A v-prefixed release such as v0.55.4 still recovers.

Post-merge review follow-up for #6153.

Co-authored-by: Eddie the Engineer <adopt-pr@gascity.local>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-01 01:32:02 -07:00

646 lines
21 KiB
Go

//go:build cgo
package main
import (
"os"
"path/filepath"
"testing"
"github.com/steveyegge/beads/internal/git"
)
func TestGetVersionsSince(t *testing.T) {
// Get current version counts dynamically from versionChanges
latestVersion := versionChanges[0].Version // First element is latest
oldestVersion := versionChanges[len(versionChanges)-1].Version // Last element is oldest
versionsAfterOldest := len(versionChanges) - 1 // All except oldest
tests := []struct {
name string
sinceVersion string
expectedCount int
description string
}{
{
name: "empty version returns all",
sinceVersion: "",
expectedCount: len(versionChanges),
description: "Should return all versions when sinceVersion is empty",
},
{
name: "version not in changelog",
sinceVersion: "0.1.0",
expectedCount: len(versionChanges),
description: "Should return all versions when sinceVersion not found",
},
{
name: "oldest version in changelog",
sinceVersion: oldestVersion,
expectedCount: versionsAfterOldest,
description: "Should return versions newer than oldest",
},
{
name: "latest version returns empty",
sinceVersion: latestVersion,
expectedCount: 0,
description: "Should return empty slice when already on latest in changelog",
},
{
name: "brew HEAD stamp returns empty",
sinceVersion: "HEAD-f925f3f",
expectedCount: 0,
description: "A --HEAD stamp names no changelog entry and must not dump the full history",
},
{
name: "bare brew HEAD stamp returns empty",
sinceVersion: "HEAD",
expectedCount: 0,
description: "A bare HEAD stamp names no changelog entry and must not dump the full history",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := getVersionsSince(tt.sinceVersion)
if len(result) != tt.expectedCount {
t.Errorf("getVersionsSince(%q) returned %d versions, want %d: %s",
tt.sinceVersion, len(result), tt.expectedCount, tt.description)
}
})
}
}
func TestDisplayVersion(t *testing.T) {
tests := []struct {
name string
version string
want string
}{
{name: "release", version: "1.3.0", want: "v1.3.0"},
{name: "pre-release", version: "1.3.0-rc.1", want: "v1.3.0-rc.1"},
{name: "brew HEAD stamp", version: "HEAD-f925f3f", want: "HEAD-f925f3f"},
{name: "bare brew HEAD stamp", version: "HEAD", want: "HEAD"},
{name: "brew HEAD stamp with revision", version: "HEAD-f925f3f_1", want: "HEAD-f925f3f_1"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := displayVersion(tt.version); got != tt.want {
t.Fatalf("displayVersion(%q) = %q, want %q", tt.version, got, tt.want)
}
})
}
}
func TestGetVersionsSinceOrder(t *testing.T) {
// Test that versions are returned in chronological order (oldest first)
// versionChanges array is newest-first, but getVersionsSince returns oldest-first
oldestVersion := versionChanges[len(versionChanges)-1].Version
result := getVersionsSince(oldestVersion)
expectedCount := len(versionChanges) - 1
if len(result) != expectedCount {
t.Fatalf("Expected %d versions after %s, got %d", expectedCount, oldestVersion, len(result))
}
// Verify chronological order by checking dates increase (or are equal for same-day releases)
for i := 1; i < len(result); i++ {
prev := result[i-1]
curr := result[i]
// Simple date comparison (YYYY-MM-DD format)
if curr.Date < prev.Date {
t.Errorf("Versions not in chronological order: %s (%s) should come before %s (%s)",
prev.Version, prev.Date, curr.Version, curr.Date)
}
}
// First version after oldest should be second-to-last in versionChanges
// Last version should be the first in versionChanges (latest)
if len(result) > 0 {
expectedFirst := versionChanges[len(versionChanges)-2].Version
expectedLast := versionChanges[0].Version
if result[0].Version != expectedFirst {
t.Errorf("First version = %s, want %s", result[0].Version, expectedFirst)
}
if result[len(result)-1].Version != expectedLast {
t.Errorf("Last version = %s, want %s", result[len(result)-1].Version, expectedLast)
}
}
}
func TestTrackBdVersion_NoBeadsDir(t *testing.T) {
// Reset global state for test isolation
ensureCleanGlobalState(t)
// Save original state
origUpgradeDetected := versionUpgradeDetected
origPreviousVersion := previousVersion
defer func() {
versionUpgradeDetected = origUpgradeDetected
previousVersion = origPreviousVersion
}()
// Reset state to ensure clean starting point
versionUpgradeDetected = false
previousVersion = ""
// Change to temp directory with no .beads
tmpDir := t.TempDir()
t.Chdir(tmpDir)
// Reset git caches so IsWorktree() returns fresh results for the temp dir
git.ResetCaches()
// Set BEADS_DIR to temp directory to prevent FindBeadsDir from walking up
// or finding the worktree's main repository .beads directory
t.Setenv("BEADS_DIR", tmpDir)
// trackBdVersion should silently succeed
trackBdVersion()
// Should not detect upgrade when no .beads dir exists
if versionUpgradeDetected {
t.Error("Expected no upgrade detection when .beads directory doesn't exist")
}
}
func TestTrackBdVersion_FirstRun(t *testing.T) {
// Reset global state for test isolation
ensureCleanGlobalState(t)
// Create temp .beads directory with a project file (bd-420)
// FindBeadsDir now requires actual project files, not just directory existence
tmpDir := t.TempDir()
beadsDir := filepath.Join(tmpDir, ".beads")
if err := os.MkdirAll(beadsDir, 0755); err != nil {
t.Fatalf("Failed to create .beads: %v", err)
}
// Create a database file so FindBeadsDir finds this directory
dbPath := filepath.Join(beadsDir, "beads.db")
if err := os.WriteFile(dbPath, []byte{}, 0644); err != nil {
t.Fatalf("Failed to create db file: %v", err)
}
// Set BEADS_DIR to force FindBeadsDir to use our temp directory
// This prevents finding the actual .beads in a git worktree
t.Setenv("BEADS_DIR", beadsDir)
// Change to temp directory
t.Chdir(tmpDir)
// Save original state
origUpgradeDetected := versionUpgradeDetected
origPreviousVersion := previousVersion
defer func() {
versionUpgradeDetected = origUpgradeDetected
previousVersion = origPreviousVersion
}()
// Reset state
versionUpgradeDetected = false
previousVersion = ""
// trackBdVersion should create .local_version
trackBdVersion()
// Should not detect upgrade on first run
if versionUpgradeDetected {
t.Error("Expected no upgrade detection on first run")
}
// Should have created .local_version with current version
localVersionPath := filepath.Join(beadsDir, localVersionFile)
localVersion := readLocalVersion(localVersionPath)
if localVersion != Version {
t.Errorf(".local_version = %q, want %q", localVersion, Version)
}
}
func TestTrackBdVersion_UpgradeDetection(t *testing.T) {
// Reset global state for test isolation
ensureCleanGlobalState(t)
// Create temp .beads directory
tmpDir := t.TempDir()
beadsDir := filepath.Join(tmpDir, ".beads")
if err := os.MkdirAll(beadsDir, 0755); err != nil {
t.Fatalf("Failed to create .beads: %v", err)
}
// Set BEADS_DIR to force FindBeadsDir to use our temp directory
// This prevents finding the actual .beads in a git worktree
t.Setenv("BEADS_DIR", beadsDir)
// Change to temp directory
t.Chdir(tmpDir)
// Create minimal metadata.json so FindBeadsDir can find the directory (bd-420)
metadataPath := filepath.Join(beadsDir, "metadata.json")
if err := os.WriteFile(metadataPath, []byte(`{"database":"beads.db"}`), 0600); err != nil {
t.Fatalf("Failed to create metadata.json: %v", err)
}
// Create .local_version with old version (simulating previous bd run)
localVersionPath := filepath.Join(beadsDir, localVersionFile)
if err := writeLocalVersion(localVersionPath, "0.22.0"); err != nil {
t.Fatalf("Failed to write local version: %v", err)
}
// Save original state
origUpgradeDetected := versionUpgradeDetected
origPreviousVersion := previousVersion
defer func() {
versionUpgradeDetected = origUpgradeDetected
previousVersion = origPreviousVersion
}()
// Reset state
versionUpgradeDetected = false
previousVersion = ""
// trackBdVersion should detect upgrade
trackBdVersion()
// Should detect upgrade
if !versionUpgradeDetected {
t.Error("Expected upgrade detection when version changed")
}
if previousVersion != "0.22.0" {
t.Errorf("previousVersion = %q, want %q", previousVersion, "0.22.0")
}
// Should have updated .local_version to current version
localVersion := readLocalVersion(localVersionPath)
if localVersion != Version {
t.Errorf(".local_version = %q, want %q", localVersion, Version)
}
}
func TestTrackBdVersion_DowngradeIgnored(t *testing.T) {
// Reset global state for test isolation
ensureCleanGlobalState(t)
// Create temp .beads directory
tmpDir := t.TempDir()
beadsDir := filepath.Join(tmpDir, ".beads")
if err := os.MkdirAll(beadsDir, 0755); err != nil {
t.Fatalf("Failed to create .beads: %v", err)
}
// Set BEADS_DIR to force FindBeadsDir to use our temp directory
t.Setenv("BEADS_DIR", beadsDir)
// Change to temp directory
t.Chdir(tmpDir)
// Create minimal metadata.json so FindBeadsDir can find the directory
metadataPath := filepath.Join(beadsDir, "metadata.json")
if err := os.WriteFile(metadataPath, []byte(`{"database":"beads.db"}`), 0600); err != nil {
t.Fatalf("Failed to create metadata.json: %v", err)
}
// Create .local_version with a NEWER version than current (simulating downgrade)
localVersionPath := filepath.Join(beadsDir, localVersionFile)
if err := writeLocalVersion(localVersionPath, "99.99.99"); err != nil {
t.Fatalf("Failed to write local version: %v", err)
}
// Save original state
origUpgradeDetected := versionUpgradeDetected
origPreviousVersion := previousVersion
defer func() {
versionUpgradeDetected = origUpgradeDetected
previousVersion = origPreviousVersion
}()
// Reset state
versionUpgradeDetected = false
previousVersion = ""
// trackBdVersion should NOT detect upgrade (this is a downgrade)
trackBdVersion()
if versionUpgradeDetected {
t.Error("Expected no upgrade detection when version is a downgrade")
}
if previousVersion != "" {
t.Errorf("previousVersion = %q, want empty string for downgrade", previousVersion)
}
// Should still update .local_version to current version
localVersion := readLocalVersion(localVersionPath)
if localVersion != Version {
t.Errorf(".local_version = %q, want %q", localVersion, Version)
}
}
// newTrackingWorkspace prepares the minimal .beads a trackBdVersion call needs
// and pins the globals it mutates, returning the .local_version path.
func newTrackingWorkspace(t *testing.T, lastVersion, binVersion string) string {
t.Helper()
ensureCleanGlobalState(t)
tmpDir := t.TempDir()
beadsDir := filepath.Join(tmpDir, ".beads")
if err := os.MkdirAll(beadsDir, 0755); err != nil {
t.Fatalf("Failed to create .beads: %v", err)
}
t.Setenv("BEADS_DIR", beadsDir)
t.Chdir(tmpDir)
metadataPath := filepath.Join(beadsDir, "metadata.json")
if err := os.WriteFile(metadataPath, []byte(`{"database":"beads.db"}`), 0600); err != nil {
t.Fatalf("Failed to create metadata.json: %v", err)
}
localVersionPath := filepath.Join(beadsDir, localVersionFile)
if err := writeLocalVersion(localVersionPath, lastVersion); err != nil {
t.Fatalf("Failed to write local version: %v", err)
}
origVersion, origDetected, origPrevious := Version, versionUpgradeDetected, previousVersion
t.Cleanup(func() {
Version, versionUpgradeDetected, previousVersion = origVersion, origDetected, origPrevious
})
Version = binVersion
versionUpgradeDetected = false
previousVersion = ""
return localVersionPath
}
// TestTrackBdVersion_HeadStampChangeDetectedAsUpgrade covers the stamp changes
// CompareVersions cannot see: it reads every HEAD stamp as 0.0.0, so a HEAD
// reinstall looked like no change and a release-to-HEAD move looked like a
// downgrade. Both skipped the one-shot post-upgrade reconciliation entirely.
func TestTrackBdVersion_HeadStampChangeDetectedAsUpgrade(t *testing.T) {
tests := []struct {
name string
lastVersion string
binVersion string
wantDetected bool
}{
{name: "HEAD stamp to different HEAD stamp", lastVersion: "HEAD-423afdc", binVersion: "HEAD-f925f3f", wantDetected: true},
{name: "release to HEAD stamp", lastVersion: "1.1.2", binVersion: "HEAD-f925f3f", wantDetected: true},
{name: "HEAD stamp to release", lastVersion: "HEAD-423afdc", binVersion: "1.3.0", wantDetected: true},
{name: "same HEAD stamp", lastVersion: "HEAD-f925f3f", binVersion: "HEAD-f925f3f", wantDetected: false},
{name: "non-HEAD garbage change stays undetected", lastVersion: "not-a-version", binVersion: "also-not-one", wantDetected: false},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
localVersionPath := newTrackingWorkspace(t, tt.lastVersion, tt.binVersion)
trackBdVersion()
if versionUpgradeDetected != tt.wantDetected {
t.Errorf("versionUpgradeDetected = %v, want %v", versionUpgradeDetected, tt.wantDetected)
}
wantPrevious := ""
if tt.wantDetected {
wantPrevious = tt.lastVersion
}
if previousVersion != wantPrevious {
t.Errorf("previousVersion = %q, want %q", previousVersion, wantPrevious)
}
if got := readLocalVersion(localVersionPath); got != tt.binVersion {
t.Errorf(".local_version = %q, want %q", got, tt.binVersion)
}
})
}
}
// TestTrackBdVersion_HeadStampNeverReachesPreV56Recovery walks the whole
// #5603 shape end to end: a workspace last touched by a Homebrew --HEAD build,
// a .dolt with no .bd-dolt-ok marker, and a release install on top. Detection
// and the recovery gate have to compose — widening detection is what puts a
// HEAD stamp into previousVersion in the first place.
func TestTrackBdVersion_HeadStampNeverReachesPreV56Recovery(t *testing.T) {
newTrackingWorkspace(t, "HEAD-f925f3f", "1.3.0")
doltDir, sentinel := writePreV56DoltFixture(t)
trackBdVersion()
if !versionUpgradeDetected {
t.Fatal("installing a release over a --HEAD build should register as an upgrade")
}
if previousVersion != "HEAD-f925f3f" {
t.Fatalf("previousVersion = %q, want the HEAD stamp", previousVersion)
}
recoverPreV56IfNeeded(previousVersion, doltDir)
if _, err := os.Stat(sentinel); err != nil {
t.Fatalf("a --HEAD predecessor routed a live workspace into the pre-v56 recovery: %v", err)
}
}
func TestTrackBdVersion_SameVersion(t *testing.T) {
// Create temp .beads directory
tmpDir := t.TempDir()
beadsDir := filepath.Join(tmpDir, ".beads")
if err := os.MkdirAll(beadsDir, 0755); err != nil {
t.Fatalf("Failed to create .beads: %v", err)
}
// Override BEADS_DIR so FindBeadsDir() returns our temp .beads,
// not the rig's .beads (which happens in worktree environments).
t.Setenv("BEADS_DIR", beadsDir)
// Change to temp directory
t.Chdir(tmpDir)
// Create .local_version with current version
localVersionPath := filepath.Join(beadsDir, localVersionFile)
if err := writeLocalVersion(localVersionPath, Version); err != nil {
t.Fatalf("Failed to write local version: %v", err)
}
// Save original state
origUpgradeDetected := versionUpgradeDetected
origPreviousVersion := previousVersion
defer func() {
versionUpgradeDetected = origUpgradeDetected
previousVersion = origPreviousVersion
}()
// Reset state
versionUpgradeDetected = false
previousVersion = ""
// trackBdVersion should not detect upgrade
trackBdVersion()
// Should not detect upgrade
if versionUpgradeDetected {
t.Error("Expected no upgrade detection when version is the same")
}
}
func TestMaybeShowUpgradeNotification(t *testing.T) {
// Save original state
origUpgradeDetected := versionUpgradeDetected
origPreviousVersion := previousVersion
origUpgradeAcknowledged := upgradeAcknowledged
defer func() {
versionUpgradeDetected = origUpgradeDetected
previousVersion = origPreviousVersion
upgradeAcknowledged = origUpgradeAcknowledged
}()
// Test: No upgrade detected - should not modify acknowledged flag
versionUpgradeDetected = false
upgradeAcknowledged = false
previousVersion = ""
maybeShowUpgradeNotification()
if upgradeAcknowledged {
t.Error("Should not set acknowledged flag when no upgrade detected")
}
// Test: Upgrade detected but already acknowledged - should not change state
versionUpgradeDetected = true
upgradeAcknowledged = true
previousVersion = "0.22.0"
maybeShowUpgradeNotification()
if !upgradeAcknowledged {
t.Error("Should keep acknowledged flag when already acknowledged")
}
// Test: Upgrade detected and not acknowledged - should set acknowledged flag
versionUpgradeDetected = true
upgradeAcknowledged = false
previousVersion = "0.22.0"
maybeShowUpgradeNotification()
if !upgradeAcknowledged {
t.Error("Should mark as acknowledged after showing notification")
}
// Calling again should keep acknowledged flag set
prevAck := upgradeAcknowledged
maybeShowUpgradeNotification()
if upgradeAcknowledged != prevAck {
t.Error("Should not change acknowledged state on subsequent calls")
}
}
// writePreV56DoltFixture builds the workspace shape RecoverPreV56DoltDir
// destroys: a .dolt/ directory with no .bd-dolt-ok compatibility marker. It
// returns a path inside .dolt/ whose survival tells the caller whether the
// recovery ran.
func writePreV56DoltFixture(t *testing.T) (doltDir, sentinel string) {
t.Helper()
doltDir = t.TempDir()
sentinel = filepath.Join(doltDir, ".dolt", "sentinel.txt")
if err := os.MkdirAll(filepath.Dir(sentinel), 0o750); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(sentinel, []byte("live workspace data"), 0o600); err != nil {
t.Fatal(err)
}
return doltDir, sentinel
}
// TestRecoverPreV56IfNeeded_OnlySemverPredecessorsAreRecovered pins the
// destructive edge from #5603/#5625/#5650: only a release older than 0.56.0
// may hand its workspace to the path that deletes .dolt.
//
// - CompareVersions reads any unparsable version part as 0, so the Homebrew
// --HEAD stamp compares as pre-0.56 and must fail the validity check.
// - A Go pseudo-version passes the validity check since the GH#6152 fix,
// and a major-0 one can compare below 0.56.0, but its numbers only bound
// the build from below. It must be refused on its own, with or without
// the "v".
// - A v-prefixed release is a genuine predecessor and still recovers.
func TestRecoverPreV56IfNeeded_OnlySemverPredecessorsAreRecovered(t *testing.T) {
tests := []struct {
name string
previous string
wantRecovery bool
}{
{name: "brew HEAD stamp", previous: "HEAD-f925f3f"},
{name: "bare brew HEAD stamp", previous: "HEAD"},
{name: "brew HEAD stamp with revision", previous: "HEAD-f925f3f_1"},
{name: "go pseudo-version", previous: "v1.1.1-0.20260805093327-bf97b73749ac"},
{name: "go pseudo-version with no tag in reach", previous: "v0.0.0-20260805093327-bf97b73749ac"},
{name: "go pseudo-version after a pre-0.56 tag", previous: "v0.55.5-0.20260101000000-abcdefabcdef"},
{name: "go pseudo-version without its v", previous: "0.0.0-20260805093327-bf97b73749ac"},
{name: "go pseudo-version with surrounding space", previous: " v0.0.0-20260805093327-bf97b73749ac\n"},
{name: "unreadable witness", previous: "not-a-version"},
{name: "no predecessor", previous: ""},
{name: "current release", previous: "1.1.2"},
{name: "0.56.0 itself", previous: "0.56.0"},
{name: "pre-0.56 release", previous: "0.55.4", wantRecovery: true},
{name: "v-prefixed pre-0.56 release", previous: "v0.55.4", wantRecovery: true},
{name: "pre-0.56 pre-release", previous: "0.55.4-rc.1", wantRecovery: true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
doltDir, sentinel := writePreV56DoltFixture(t)
recoverPreV56IfNeeded(tt.previous, doltDir)
_, err := os.Stat(sentinel)
if tt.wantRecovery {
// The reinitializing `dolt init` may fail in a bare
// environment; the removal that precedes it is the assertion.
if !os.IsNotExist(err) {
t.Fatalf("predecessor %q: expected pre-v56 recovery to rebuild .dolt, but %s survived", tt.previous, sentinel)
}
return
}
if err != nil {
t.Fatalf("predecessor %q: pre-v56 recovery deleted a live .dolt: %v", tt.previous, err)
}
})
}
}
func TestAutoMigrateOnVersionBump_NoUpgrade(t *testing.T) {
// Save original state
origUpgradeDetected := versionUpgradeDetected
defer func() {
versionUpgradeDetected = origUpgradeDetected
}()
// Reset state - no upgrade detected
versionUpgradeDetected = false
// Should return early without doing anything
autoMigrateOnVersionBump(t.TempDir())
// Test passes if no panic occurs
}
func TestAutoMigrateOnVersionBump_NoDatabase(t *testing.T) {
// Create temp directory (no database file inside)
tmpDir := t.TempDir()
// Save original state
origUpgradeDetected := versionUpgradeDetected
defer func() {
versionUpgradeDetected = origUpgradeDetected
}()
// Simulate version upgrade
versionUpgradeDetected = true
// Should handle gracefully when database doesn't exist
autoMigrateOnVersionBump(tmpDir)
// Test passes if no panic occurs
}
// NOTE: TestAutoMigrateOnVersionBump_MigratesVersion, TestAutoMigrateOnVersionBump_AlreadyMigrated,
// TestAutoMigrateOnVersionBump_RefusesDowngrade, and TestAutoMigrateOnVersionBump_TracksMaxVersion
// were removed because they depended on the SQLite storage backend (sqlite.New) for round-trip
// persistence testing through autoMigrateOnVersionBump -> dolt.NewFromConfig.
// Automatic schema migration is exercised here through the Dolt backend.
// Dolt-based migration testing is covered by TestInitDoltMetadata in init_test.go.