396 lines
11 KiB
Go
396 lines
11 KiB
Go
package beads_test
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"net"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/steveyegge/beads"
|
|
"github.com/steveyegge/beads/internal/testutil"
|
|
)
|
|
|
|
// testServerPort is the port of the shared test Dolt server (0 = not running).
|
|
var testServerPort int
|
|
|
|
func TestMain(m *testing.M) {
|
|
os.Setenv("BEADS_TEST_MODE", "1")
|
|
if err := testutil.EnsureDoltContainerForTestMain(); err != nil {
|
|
fmt.Fprintf(os.Stderr, "WARN: %v, skipping Dolt tests\n", err)
|
|
} else {
|
|
defer testutil.TerminateDoltContainer()
|
|
testServerPort = testutil.DoltContainerPortInt()
|
|
}
|
|
|
|
code := m.Run()
|
|
|
|
os.Unsetenv("BEADS_DOLT_PORT")
|
|
os.Unsetenv("BEADS_TEST_MODE")
|
|
os.Exit(code)
|
|
}
|
|
|
|
func skipIfNoDolt(t *testing.T) {
|
|
t.Helper()
|
|
testutil.RequireDoltBinary(t)
|
|
}
|
|
|
|
func skipIfNoDoltServer(t *testing.T) {
|
|
t.Helper()
|
|
if testServerPort == 0 {
|
|
t.Skip("Test Dolt server not available, skipping test")
|
|
}
|
|
addr := fmt.Sprintf("127.0.0.1:%d", testServerPort)
|
|
conn, err := net.DialTimeout("tcp", addr, 200*time.Millisecond)
|
|
if err != nil {
|
|
t.Skipf("Dolt server not running on %s, skipping test", addr)
|
|
}
|
|
_ = conn.Close()
|
|
}
|
|
|
|
func TestOpen(t *testing.T) {
|
|
skipIfNoDoltServer(t)
|
|
|
|
tmpDir := t.TempDir()
|
|
dbPath := filepath.Join(tmpDir, "test-dolt")
|
|
|
|
ctx := context.Background()
|
|
store, err := beads.Open(ctx, dbPath)
|
|
if err != nil {
|
|
t.Fatalf("Open failed: %v", err)
|
|
}
|
|
defer store.Close()
|
|
|
|
if store == nil {
|
|
t.Error("expected non-nil storage")
|
|
}
|
|
}
|
|
|
|
func TestFindDatabasePath(t *testing.T) {
|
|
// This will return empty string in test environment without a database
|
|
path := beads.FindDatabasePath()
|
|
// Just verify it doesn't panic
|
|
_ = path
|
|
}
|
|
|
|
func TestFindBeadsDir(t *testing.T) {
|
|
// This will return empty string or a valid path
|
|
dir := beads.FindBeadsDir()
|
|
// Just verify it doesn't panic
|
|
_ = dir
|
|
}
|
|
|
|
func TestOpenFromConfig_Embedded(t *testing.T) {
|
|
// This test requires a running Dolt server (embedded mode is not yet implemented;
|
|
// New() always connects via MySQL protocol to dolt sql-server).
|
|
skipIfNoDoltServer(t)
|
|
|
|
// Create a .beads dir with metadata.json configured for embedded mode
|
|
tmpDir := t.TempDir()
|
|
beadsDir := filepath.Join(tmpDir, ".beads")
|
|
if err := os.MkdirAll(beadsDir, 0755); err != nil {
|
|
t.Fatalf("failed to create .beads dir: %v", err)
|
|
}
|
|
|
|
metadata := `{"backend":"dolt","database":"dolt","dolt_database":"testdb","dolt_mode":"embedded"}`
|
|
if err := os.WriteFile(filepath.Join(beadsDir, "metadata.json"), []byte(metadata), 0644); err != nil {
|
|
t.Fatalf("failed to write metadata.json: %v", err)
|
|
}
|
|
|
|
ctx := context.Background()
|
|
store, err := beads.OpenFromConfig(ctx, beadsDir)
|
|
if err != nil {
|
|
t.Fatalf("OpenFromConfig (embedded) failed: %v", err)
|
|
}
|
|
defer store.Close()
|
|
|
|
if store == nil {
|
|
t.Error("expected non-nil storage")
|
|
}
|
|
}
|
|
|
|
func TestOpenFromConfig_DefaultsToEmbedded(t *testing.T) {
|
|
// This test requires a running Dolt server (embedded mode is not yet implemented;
|
|
// New() always connects via MySQL protocol to dolt sql-server).
|
|
skipIfNoDoltServer(t)
|
|
|
|
// metadata.json without dolt_mode should default to embedded
|
|
tmpDir := t.TempDir()
|
|
beadsDir := filepath.Join(tmpDir, ".beads")
|
|
if err := os.MkdirAll(beadsDir, 0755); err != nil {
|
|
t.Fatalf("failed to create .beads dir: %v", err)
|
|
}
|
|
|
|
metadata := `{"backend":"dolt","database":"dolt"}`
|
|
if err := os.WriteFile(filepath.Join(beadsDir, "metadata.json"), []byte(metadata), 0644); err != nil {
|
|
t.Fatalf("failed to write metadata.json: %v", err)
|
|
}
|
|
|
|
ctx := context.Background()
|
|
store, err := beads.OpenFromConfig(ctx, beadsDir)
|
|
if err != nil {
|
|
t.Fatalf("OpenFromConfig (default) failed: %v", err)
|
|
}
|
|
defer store.Close()
|
|
|
|
if store == nil {
|
|
t.Error("expected non-nil storage")
|
|
}
|
|
}
|
|
|
|
func TestOpenFromConfig_ServerModeFailsWithoutServer(t *testing.T) {
|
|
// Server mode should fail-fast when no server is listening.
|
|
// Temporarily unset BEADS_DOLT_PORT/BEADS_TEST_MODE so the config port
|
|
// isn't overridden by applyConfigDefaults to the test server.
|
|
if prev := os.Getenv("BEADS_DOLT_PORT"); prev != "" {
|
|
os.Unsetenv("BEADS_DOLT_PORT")
|
|
t.Cleanup(func() { os.Setenv("BEADS_DOLT_PORT", prev) })
|
|
}
|
|
if prev := os.Getenv("BEADS_TEST_MODE"); prev != "" {
|
|
os.Unsetenv("BEADS_TEST_MODE")
|
|
t.Cleanup(func() { os.Setenv("BEADS_TEST_MODE", prev) })
|
|
}
|
|
|
|
tmpDir := t.TempDir()
|
|
beadsDir := filepath.Join(tmpDir, ".beads")
|
|
if err := os.MkdirAll(beadsDir, 0755); err != nil {
|
|
t.Fatalf("failed to create .beads dir: %v", err)
|
|
}
|
|
|
|
// Dynamically find an unused port by binding to :0 then closing
|
|
ln, err := net.Listen("tcp", "127.0.0.1:0")
|
|
if err != nil {
|
|
t.Fatalf("failed to find free port: %v", err)
|
|
}
|
|
freePort := ln.Addr().(*net.TCPAddr).Port
|
|
ln.Close()
|
|
|
|
metadata := fmt.Sprintf(`{"backend":"dolt","database":"dolt","dolt_mode":"server","dolt_server_host":"127.0.0.1","dolt_server_port":%d}`, freePort)
|
|
if err := os.WriteFile(filepath.Join(beadsDir, "metadata.json"), []byte(metadata), 0644); err != nil {
|
|
t.Fatalf("failed to write metadata.json: %v", err)
|
|
}
|
|
|
|
ctx := context.Background()
|
|
_, openErr := beads.OpenFromConfig(ctx, beadsDir)
|
|
if openErr == nil {
|
|
t.Fatal("OpenFromConfig (server mode) should fail when no server is running")
|
|
}
|
|
// Should contain "unreachable" from the fail-fast TCP check
|
|
if !strings.Contains(openErr.Error(), "unreachable") {
|
|
t.Errorf("expected 'unreachable' in error, got: %v", openErr)
|
|
}
|
|
}
|
|
|
|
func TestOpenFromConfig_NoMetadata(t *testing.T) {
|
|
skipIfNoDoltServer(t)
|
|
// Missing metadata.json should use defaults (server mode)
|
|
tmpDir := t.TempDir()
|
|
beadsDir := filepath.Join(tmpDir, ".beads")
|
|
if err := os.MkdirAll(beadsDir, 0755); err != nil {
|
|
t.Fatalf("failed to create .beads dir: %v", err)
|
|
}
|
|
|
|
ctx := context.Background()
|
|
store, err := beads.OpenFromConfig(ctx, beadsDir)
|
|
if err != nil {
|
|
t.Fatalf("OpenFromConfig (no metadata) failed: %v", err)
|
|
}
|
|
defer store.Close()
|
|
|
|
if store == nil {
|
|
t.Error("expected non-nil storage")
|
|
}
|
|
}
|
|
|
|
func TestOpenBestAvailable_ServerMode(t *testing.T) {
|
|
skipIfNoDoltServer(t)
|
|
|
|
tmpDir := t.TempDir()
|
|
beadsDir := filepath.Join(tmpDir, ".beads")
|
|
if err := os.MkdirAll(beadsDir, 0755); err != nil {
|
|
t.Fatalf("failed to create .beads dir: %v", err)
|
|
}
|
|
|
|
metadata := fmt.Sprintf(`{"backend":"dolt","database":"dolt","dolt_mode":"server","dolt_server_host":"127.0.0.1","dolt_server_port":%d}`, testServerPort)
|
|
if err := os.WriteFile(filepath.Join(beadsDir, "metadata.json"), []byte(metadata), 0644); err != nil {
|
|
t.Fatalf("failed to write metadata.json: %v", err)
|
|
}
|
|
|
|
ctx := context.Background()
|
|
store, err := beads.OpenBestAvailable(ctx, beadsDir)
|
|
if err != nil {
|
|
t.Fatalf("OpenBestAvailable (server mode) failed: %v", err)
|
|
}
|
|
defer store.Close()
|
|
|
|
if store == nil {
|
|
t.Error("expected non-nil storage")
|
|
}
|
|
}
|
|
|
|
func TestOpenBestAvailable_ServerMode_FailsWithoutServer(t *testing.T) {
|
|
// OpenBestAvailable in server mode should propagate the fail-fast error.
|
|
if prev := os.Getenv("BEADS_DOLT_PORT"); prev != "" {
|
|
os.Unsetenv("BEADS_DOLT_PORT")
|
|
t.Cleanup(func() { os.Setenv("BEADS_DOLT_PORT", prev) })
|
|
}
|
|
if prev := os.Getenv("BEADS_TEST_MODE"); prev != "" {
|
|
os.Unsetenv("BEADS_TEST_MODE")
|
|
t.Cleanup(func() { os.Setenv("BEADS_TEST_MODE", prev) })
|
|
}
|
|
|
|
tmpDir := t.TempDir()
|
|
beadsDir := filepath.Join(tmpDir, ".beads")
|
|
if err := os.MkdirAll(beadsDir, 0755); err != nil {
|
|
t.Fatalf("failed to create .beads dir: %v", err)
|
|
}
|
|
|
|
ln, err := net.Listen("tcp", "127.0.0.1:0")
|
|
if err != nil {
|
|
t.Fatalf("failed to find free port: %v", err)
|
|
}
|
|
freePort := ln.Addr().(*net.TCPAddr).Port
|
|
ln.Close()
|
|
|
|
metadata := fmt.Sprintf(`{"backend":"dolt","database":"dolt","dolt_mode":"server","dolt_server_host":"127.0.0.1","dolt_server_port":%d}`, freePort)
|
|
if err := os.WriteFile(filepath.Join(beadsDir, "metadata.json"), []byte(metadata), 0644); err != nil {
|
|
t.Fatalf("failed to write metadata.json: %v", err)
|
|
}
|
|
|
|
ctx := context.Background()
|
|
_, openErr := beads.OpenBestAvailable(ctx, beadsDir)
|
|
if openErr == nil {
|
|
t.Fatal("OpenBestAvailable (server mode) should fail when no server is running")
|
|
}
|
|
if !strings.Contains(openErr.Error(), "unreachable") {
|
|
t.Errorf("expected 'unreachable' in error, got: %v", openErr)
|
|
}
|
|
}
|
|
|
|
func TestFindAllDatabases(t *testing.T) {
|
|
// This scans the file system, just verify it doesn't panic
|
|
dbs := beads.FindAllDatabases()
|
|
// Should return a slice (possibly empty)
|
|
if dbs == nil {
|
|
t.Error("expected non-nil slice")
|
|
}
|
|
}
|
|
|
|
// Test that exported constants have correct values
|
|
func TestConstants(t *testing.T) {
|
|
// Status constants
|
|
if beads.StatusOpen != "open" {
|
|
t.Errorf("StatusOpen = %q, want %q", beads.StatusOpen, "open")
|
|
}
|
|
if beads.StatusInProgress != "in_progress" {
|
|
t.Errorf("StatusInProgress = %q, want %q", beads.StatusInProgress, "in_progress")
|
|
}
|
|
if beads.StatusBlocked != "blocked" {
|
|
t.Errorf("StatusBlocked = %q, want %q", beads.StatusBlocked, "blocked")
|
|
}
|
|
if beads.StatusClosed != "closed" {
|
|
t.Errorf("StatusClosed = %q, want %q", beads.StatusClosed, "closed")
|
|
}
|
|
|
|
// IssueType constants
|
|
if beads.TypeBug != "bug" {
|
|
t.Errorf("TypeBug = %q, want %q", beads.TypeBug, "bug")
|
|
}
|
|
if beads.TypeFeature != "feature" {
|
|
t.Errorf("TypeFeature = %q, want %q", beads.TypeFeature, "feature")
|
|
}
|
|
if beads.TypeTask != "task" {
|
|
t.Errorf("TypeTask = %q, want %q", beads.TypeTask, "task")
|
|
}
|
|
if beads.TypeEpic != "epic" {
|
|
t.Errorf("TypeEpic = %q, want %q", beads.TypeEpic, "epic")
|
|
}
|
|
|
|
// DependencyType constants
|
|
if beads.DepBlocks != "blocks" {
|
|
t.Errorf("DepBlocks = %q, want %q", beads.DepBlocks, "blocks")
|
|
}
|
|
if beads.DepRelated != "related" {
|
|
t.Errorf("DepRelated = %q, want %q", beads.DepRelated, "related")
|
|
}
|
|
}
|
|
|
|
func TestPublicAPITypeAssertions(t *testing.T) {
|
|
skipIfNoDoltServer(t)
|
|
|
|
tmpDir := t.TempDir()
|
|
dbPath := filepath.Join(tmpDir, "test-dolt")
|
|
|
|
ctx := context.Background()
|
|
store, err := beads.Open(ctx, dbPath)
|
|
if err != nil {
|
|
t.Fatalf("Open failed: %v", err)
|
|
}
|
|
defer store.Close()
|
|
|
|
t.Run("RemoteStore", func(t *testing.T) {
|
|
rs, ok := store.(beads.RemoteStore)
|
|
if !ok {
|
|
t.Fatal("store does not satisfy beads.RemoteStore")
|
|
}
|
|
// Verify a method is callable (no remotes configured, so empty list)
|
|
remotes, err := rs.ListRemotes(ctx)
|
|
if err != nil {
|
|
t.Fatalf("ListRemotes failed: %v", err)
|
|
}
|
|
_ = remotes
|
|
})
|
|
|
|
t.Run("SyncStore", func(t *testing.T) {
|
|
_, ok := store.(beads.SyncStore)
|
|
if !ok {
|
|
t.Fatal("store does not satisfy beads.SyncStore")
|
|
}
|
|
})
|
|
|
|
t.Run("VersionControlReader", func(t *testing.T) {
|
|
vcr, ok := store.(beads.VersionControlReader)
|
|
if !ok {
|
|
t.Fatal("store does not satisfy beads.VersionControlReader")
|
|
}
|
|
|
|
branch, err := vcr.CurrentBranch(ctx)
|
|
if err != nil {
|
|
t.Fatalf("CurrentBranch failed: %v", err)
|
|
}
|
|
if branch == "" {
|
|
t.Error("expected non-empty branch name")
|
|
}
|
|
|
|
commit, err := vcr.GetCurrentCommit(ctx)
|
|
if err != nil {
|
|
t.Fatalf("GetCurrentCommit failed: %v", err)
|
|
}
|
|
if commit == "" {
|
|
t.Error("expected non-empty commit hash")
|
|
}
|
|
|
|
exists, err := vcr.CommitExists(ctx, commit)
|
|
if err != nil {
|
|
t.Fatalf("CommitExists failed: %v", err)
|
|
}
|
|
if !exists {
|
|
t.Errorf("CommitExists(%s) = false, want true", commit)
|
|
}
|
|
|
|
status, err := vcr.Status(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Status failed: %v", err)
|
|
}
|
|
_ = status
|
|
|
|
logs, err := vcr.Log(ctx, 5)
|
|
if err != nil {
|
|
t.Fatalf("Log failed: %v", err)
|
|
}
|
|
_ = logs
|
|
})
|
|
}
|