9ddd7a2620
Add `bd config validate` command to validate sync-related configuration: - sync.mode: validates values (local, git-branch, external) - conflict.strategy: validates values (lww, manual, ours, theirs) - federation.sovereignty: validates values (none, isolated, federated) - federation.remote: ensures set when sync.mode is 'external' - Remote URL format: validates dolthub://, gs://, s3://, file://, etc. Also validates existing config via doctor.CheckConfigValues (sync.branch, routing.mode, etc.) Closes: hq-ew1mbr.29 Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
455 lines
13 KiB
Go
455 lines
13 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/steveyegge/beads/internal/config"
|
|
"github.com/steveyegge/beads/internal/storage/sqlite"
|
|
)
|
|
|
|
func TestConfigCommands(t *testing.T) {
|
|
ctx := context.Background()
|
|
store, cleanup := setupTestDB(t)
|
|
defer cleanup()
|
|
|
|
// Test SetConfig
|
|
err := store.SetConfig(ctx, "test.key", "test-value")
|
|
if err != nil {
|
|
t.Fatalf("SetConfig failed: %v", err)
|
|
}
|
|
|
|
// Test GetConfig
|
|
value, err := store.GetConfig(ctx, "test.key")
|
|
if err != nil {
|
|
t.Fatalf("GetConfig failed: %v", err)
|
|
}
|
|
if value != "test-value" {
|
|
t.Errorf("Expected 'test-value', got '%s'", value)
|
|
}
|
|
|
|
// Test GetConfig for non-existent key
|
|
value, err = store.GetConfig(ctx, "nonexistent.key")
|
|
if err != nil {
|
|
t.Fatalf("GetConfig for nonexistent key failed: %v", err)
|
|
}
|
|
if value != "" {
|
|
t.Errorf("Expected empty string for nonexistent key, got '%s'", value)
|
|
}
|
|
|
|
// Test SetConfig update
|
|
err = store.SetConfig(ctx, "test.key", "updated-value")
|
|
if err != nil {
|
|
t.Fatalf("SetConfig update failed: %v", err)
|
|
}
|
|
value, err = store.GetConfig(ctx, "test.key")
|
|
if err != nil {
|
|
t.Fatalf("GetConfig after update failed: %v", err)
|
|
}
|
|
if value != "updated-value" {
|
|
t.Errorf("Expected 'updated-value', got '%s'", value)
|
|
}
|
|
|
|
// Test GetAllConfig
|
|
err = store.SetConfig(ctx, "jira.url", "https://example.atlassian.net")
|
|
if err != nil {
|
|
t.Fatalf("SetConfig for jira.url failed: %v", err)
|
|
}
|
|
err = store.SetConfig(ctx, "jira.project", "PROJ")
|
|
if err != nil {
|
|
t.Fatalf("SetConfig for jira.project failed: %v", err)
|
|
}
|
|
|
|
config, err := store.GetAllConfig(ctx)
|
|
if err != nil {
|
|
t.Fatalf("GetAllConfig failed: %v", err)
|
|
}
|
|
|
|
// Should have at least our test keys (may have default compaction config too)
|
|
if len(config) < 3 {
|
|
t.Errorf("Expected at least 3 config entries, got %d", len(config))
|
|
}
|
|
|
|
if config["test.key"] != "updated-value" {
|
|
t.Errorf("Expected 'updated-value' for test.key, got '%s'", config["test.key"])
|
|
}
|
|
if config["jira.url"] != "https://example.atlassian.net" {
|
|
t.Errorf("Expected jira.url in config, got '%s'", config["jira.url"])
|
|
}
|
|
if config["jira.project"] != "PROJ" {
|
|
t.Errorf("Expected jira.project in config, got '%s'", config["jira.project"])
|
|
}
|
|
|
|
// Test DeleteConfig
|
|
err = store.DeleteConfig(ctx, "test.key")
|
|
if err != nil {
|
|
t.Fatalf("DeleteConfig failed: %v", err)
|
|
}
|
|
|
|
value, err = store.GetConfig(ctx, "test.key")
|
|
if err != nil {
|
|
t.Fatalf("GetConfig after delete failed: %v", err)
|
|
}
|
|
if value != "" {
|
|
t.Errorf("Expected empty string after delete, got '%s'", value)
|
|
}
|
|
|
|
// Test DeleteConfig for non-existent key (should not error)
|
|
err = store.DeleteConfig(ctx, "nonexistent.key")
|
|
if err != nil {
|
|
t.Fatalf("DeleteConfig for nonexistent key failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestConfigNamespaces(t *testing.T) {
|
|
ctx := context.Background()
|
|
store, cleanup := setupTestDB(t)
|
|
defer cleanup()
|
|
|
|
// Test various namespace conventions
|
|
namespaces := map[string]string{
|
|
"jira.url": "https://example.atlassian.net",
|
|
"jira.project": "PROJ",
|
|
"jira.status_map.todo": "open",
|
|
"linear.team_id": "team-123",
|
|
"github.org": "myorg",
|
|
"custom.my_integration.field": "value",
|
|
}
|
|
|
|
for key, val := range namespaces {
|
|
err := store.SetConfig(ctx, key, val)
|
|
if err != nil {
|
|
t.Fatalf("SetConfig for %s failed: %v", key, err)
|
|
}
|
|
}
|
|
|
|
// Verify all set correctly
|
|
for key, expected := range namespaces {
|
|
value, err := store.GetConfig(ctx, key)
|
|
if err != nil {
|
|
t.Fatalf("GetConfig for %s failed: %v", key, err)
|
|
}
|
|
if value != expected {
|
|
t.Errorf("Expected '%s' for %s, got '%s'", expected, key, value)
|
|
}
|
|
}
|
|
|
|
// Test GetAllConfig returns all
|
|
config, err := store.GetAllConfig(ctx)
|
|
if err != nil {
|
|
t.Fatalf("GetAllConfig failed: %v", err)
|
|
}
|
|
|
|
for key, expected := range namespaces {
|
|
if config[key] != expected {
|
|
t.Errorf("Expected '%s' for %s in GetAllConfig, got '%s'", expected, key, config[key])
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestYamlOnlyConfigWithoutDatabase verifies that yaml-only config keys
|
|
// (like no-db, no-daemon) can be set/get without requiring a SQLite database.
|
|
// This is the fix for GH#536 - the chicken-and-egg problem where you couldn't
|
|
// run `bd config set no-db true` without first having a database.
|
|
func TestYamlOnlyConfigWithoutDatabase(t *testing.T) {
|
|
// Create a temp directory with only config.yaml (no database)
|
|
tmpDir, err := os.MkdirTemp("", "bd-test-yaml-config-*")
|
|
if err != nil {
|
|
t.Fatalf("Failed to create temp dir: %v", err)
|
|
}
|
|
defer os.RemoveAll(tmpDir)
|
|
|
|
beadsDir := filepath.Join(tmpDir, ".beads")
|
|
if err := os.MkdirAll(beadsDir, 0755); err != nil {
|
|
t.Fatalf("Failed to create .beads dir: %v", err)
|
|
}
|
|
|
|
// Create config.yaml with a prefix but NO database
|
|
configPath := filepath.Join(beadsDir, "config.yaml")
|
|
if err := os.WriteFile(configPath, []byte("prefix: test\n"), 0644); err != nil {
|
|
t.Fatalf("Failed to create config.yaml: %v", err)
|
|
}
|
|
|
|
// Create empty issues.jsonl (simulates fresh clone)
|
|
jsonlPath := filepath.Join(beadsDir, "issues.jsonl")
|
|
if err := os.WriteFile(jsonlPath, []byte(""), 0644); err != nil {
|
|
t.Fatalf("Failed to create issues.jsonl: %v", err)
|
|
}
|
|
|
|
// Test that IsYamlOnlyKey correctly identifies yaml-only keys
|
|
yamlOnlyKeys := []string{"no-db", "no-daemon", "no-auto-flush", "json", "sync.branch", "routing.mode"}
|
|
for _, key := range yamlOnlyKeys {
|
|
if !config.IsYamlOnlyKey(key) {
|
|
t.Errorf("Expected %q to be a yaml-only key", key)
|
|
}
|
|
}
|
|
|
|
// Test that non-yaml-only keys are correctly identified
|
|
nonYamlKeys := []string{"jira.url", "linear.team_id", "status.custom"}
|
|
for _, key := range nonYamlKeys {
|
|
if config.IsYamlOnlyKey(key) {
|
|
t.Errorf("Expected %q to NOT be a yaml-only key", key)
|
|
}
|
|
}
|
|
}
|
|
|
|
// setupTestDB creates a temporary test database
|
|
func setupTestDB(t *testing.T) (*sqlite.SQLiteStorage, func()) {
|
|
tmpDir, err := os.MkdirTemp("", "bd-test-config-*")
|
|
if err != nil {
|
|
t.Fatalf("Failed to create temp dir: %v", err)
|
|
}
|
|
|
|
testDB := filepath.Join(tmpDir, "test.db")
|
|
store, err := sqlite.New(context.Background(), testDB)
|
|
if err != nil {
|
|
os.RemoveAll(tmpDir)
|
|
t.Fatalf("Failed to create test database: %v", err)
|
|
}
|
|
|
|
// CRITICAL (bd-166): Set issue_prefix to prevent "database not initialized" errors
|
|
ctx := context.Background()
|
|
if err := store.SetConfig(ctx, "issue_prefix", "bd"); err != nil {
|
|
store.Close()
|
|
os.RemoveAll(tmpDir)
|
|
t.Fatalf("Failed to set issue_prefix: %v", err)
|
|
}
|
|
|
|
cleanup := func() {
|
|
store.Close()
|
|
os.RemoveAll(tmpDir)
|
|
}
|
|
|
|
return store, cleanup
|
|
}
|
|
|
|
// TestIsValidRemoteURL tests the remote URL validation function
|
|
func TestIsValidRemoteURL(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
url string
|
|
expected bool
|
|
}{
|
|
// Valid URLs
|
|
{"dolthub scheme", "dolthub://org/repo", true},
|
|
{"gs scheme", "gs://bucket/path", true},
|
|
{"s3 scheme", "s3://bucket/path", true},
|
|
{"file scheme", "file:///path/to/repo", true},
|
|
{"https scheme", "https://github.com/user/repo", true},
|
|
{"http scheme", "http://github.com/user/repo", true},
|
|
{"ssh scheme", "ssh://git@github.com/user/repo", true},
|
|
{"git ssh format", "git@github.com:user/repo.git", true},
|
|
{"git ssh with underscore", "git@gitlab.example_host.com:user/repo.git", true},
|
|
|
|
// Invalid URLs
|
|
{"empty string", "", false},
|
|
{"no scheme", "github.com/user/repo", false},
|
|
{"invalid scheme", "ftp://server/path", false},
|
|
{"malformed git ssh", "git@:repo", false},
|
|
{"just path", "/path/to/repo", false},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got := isValidRemoteURL(tt.url)
|
|
if got != tt.expected {
|
|
t.Errorf("isValidRemoteURL(%q) = %v, want %v", tt.url, got, tt.expected)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestValidateSyncConfig tests the sync config validation function
|
|
func TestValidateSyncConfig(t *testing.T) {
|
|
// Create a temp directory for testing
|
|
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)
|
|
}
|
|
|
|
t.Run("valid empty config", func(t *testing.T) {
|
|
// Create minimal config.yaml
|
|
configContent := `prefix: test
|
|
`
|
|
if err := os.WriteFile(filepath.Join(beadsDir, "config.yaml"), []byte(configContent), 0644); err != nil {
|
|
t.Fatalf("Failed to write config.yaml: %v", err)
|
|
}
|
|
|
|
issues := validateSyncConfig(tmpDir)
|
|
if len(issues) != 0 {
|
|
t.Errorf("Expected no issues for valid empty config, got: %v", issues)
|
|
}
|
|
})
|
|
|
|
t.Run("invalid sync.mode", func(t *testing.T) {
|
|
configContent := `prefix: test
|
|
sync:
|
|
mode: "invalid-mode"
|
|
`
|
|
if err := os.WriteFile(filepath.Join(beadsDir, "config.yaml"), []byte(configContent), 0644); err != nil {
|
|
t.Fatalf("Failed to write config.yaml: %v", err)
|
|
}
|
|
|
|
issues := validateSyncConfig(tmpDir)
|
|
found := false
|
|
for _, issue := range issues {
|
|
if strings.Contains(issue, "sync.mode") {
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
if !found {
|
|
t.Errorf("Expected issue about sync.mode, got: %v", issues)
|
|
}
|
|
})
|
|
|
|
t.Run("invalid conflict.strategy", func(t *testing.T) {
|
|
configContent := `prefix: test
|
|
conflict:
|
|
strategy: "invalid-strategy"
|
|
`
|
|
if err := os.WriteFile(filepath.Join(beadsDir, "config.yaml"), []byte(configContent), 0644); err != nil {
|
|
t.Fatalf("Failed to write config.yaml: %v", err)
|
|
}
|
|
|
|
issues := validateSyncConfig(tmpDir)
|
|
found := false
|
|
for _, issue := range issues {
|
|
if strings.Contains(issue, "conflict.strategy") {
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
if !found {
|
|
t.Errorf("Expected issue about conflict.strategy, got: %v", issues)
|
|
}
|
|
})
|
|
|
|
t.Run("invalid federation.sovereignty", func(t *testing.T) {
|
|
configContent := `prefix: test
|
|
federation:
|
|
sovereignty: "invalid-value"
|
|
`
|
|
if err := os.WriteFile(filepath.Join(beadsDir, "config.yaml"), []byte(configContent), 0644); err != nil {
|
|
t.Fatalf("Failed to write config.yaml: %v", err)
|
|
}
|
|
|
|
issues := validateSyncConfig(tmpDir)
|
|
found := false
|
|
for _, issue := range issues {
|
|
if strings.Contains(issue, "federation.sovereignty") {
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
if !found {
|
|
t.Errorf("Expected issue about federation.sovereignty, got: %v", issues)
|
|
}
|
|
})
|
|
|
|
t.Run("external mode without remote", func(t *testing.T) {
|
|
configContent := `prefix: test
|
|
sync:
|
|
mode: "external"
|
|
`
|
|
if err := os.WriteFile(filepath.Join(beadsDir, "config.yaml"), []byte(configContent), 0644); err != nil {
|
|
t.Fatalf("Failed to write config.yaml: %v", err)
|
|
}
|
|
|
|
issues := validateSyncConfig(tmpDir)
|
|
found := false
|
|
for _, issue := range issues {
|
|
if strings.Contains(issue, "federation.remote") && strings.Contains(issue, "required") {
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
if !found {
|
|
t.Errorf("Expected issue about federation.remote being required, got: %v", issues)
|
|
}
|
|
})
|
|
|
|
t.Run("invalid remote URL", func(t *testing.T) {
|
|
configContent := `prefix: test
|
|
federation:
|
|
remote: "invalid-url"
|
|
`
|
|
if err := os.WriteFile(filepath.Join(beadsDir, "config.yaml"), []byte(configContent), 0644); err != nil {
|
|
t.Fatalf("Failed to write config.yaml: %v", err)
|
|
}
|
|
|
|
issues := validateSyncConfig(tmpDir)
|
|
found := false
|
|
for _, issue := range issues {
|
|
if strings.Contains(issue, "federation.remote") && strings.Contains(issue, "not a valid remote URL") {
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
if !found {
|
|
t.Errorf("Expected issue about invalid remote URL, got: %v", issues)
|
|
}
|
|
})
|
|
|
|
t.Run("valid sync config", func(t *testing.T) {
|
|
configContent := `prefix: test
|
|
sync:
|
|
mode: "git-branch"
|
|
conflict:
|
|
strategy: "lww"
|
|
federation:
|
|
sovereignty: "federated"
|
|
remote: "https://github.com/user/beads-data.git"
|
|
`
|
|
if err := os.WriteFile(filepath.Join(beadsDir, "config.yaml"), []byte(configContent), 0644); err != nil {
|
|
t.Fatalf("Failed to write config.yaml: %v", err)
|
|
}
|
|
|
|
issues := validateSyncConfig(tmpDir)
|
|
if len(issues) != 0 {
|
|
t.Errorf("Expected no issues for valid config, got: %v", issues)
|
|
}
|
|
})
|
|
}
|
|
|
|
// TestFindBeadsRepoRoot tests the repo root finding function
|
|
func TestFindBeadsRepoRoot(t *testing.T) {
|
|
// Create a temp directory structure
|
|
tmpDir := t.TempDir()
|
|
beadsDir := filepath.Join(tmpDir, ".beads")
|
|
subDir := filepath.Join(tmpDir, "sub", "dir")
|
|
|
|
if err := os.MkdirAll(beadsDir, 0755); err != nil {
|
|
t.Fatalf("Failed to create .beads dir: %v", err)
|
|
}
|
|
if err := os.MkdirAll(subDir, 0755); err != nil {
|
|
t.Fatalf("Failed to create sub dir: %v", err)
|
|
}
|
|
|
|
t.Run("from repo root", func(t *testing.T) {
|
|
got := findBeadsRepoRoot(tmpDir)
|
|
if got != tmpDir {
|
|
t.Errorf("findBeadsRepoRoot(%q) = %q, want %q", tmpDir, got, tmpDir)
|
|
}
|
|
})
|
|
|
|
t.Run("from subdirectory", func(t *testing.T) {
|
|
got := findBeadsRepoRoot(subDir)
|
|
if got != tmpDir {
|
|
t.Errorf("findBeadsRepoRoot(%q) = %q, want %q", subDir, got, tmpDir)
|
|
}
|
|
})
|
|
|
|
t.Run("not in repo", func(t *testing.T) {
|
|
noRepoDir := t.TempDir()
|
|
got := findBeadsRepoRoot(noRepoDir)
|
|
if got != "" {
|
|
t.Errorf("findBeadsRepoRoot(%q) = %q, want empty string", noRepoDir, got)
|
|
}
|
|
})
|
|
}
|