beads/cmd/bd/sql_test.go
beads/crew/emma 51bb65644b fix(test): comprehensive Dolt skip guards across all test files
Bulk convert t.Fatalf to t.Skipf for dolt.New() connection errors in
16 test files (44 call sites). Tests now gracefully skip when Dolt
server is not available instead of failing CI.

Also improve skipIfNoDolt to check testDoltServerPort (handles macOS
CI where dolt binary exists but no server is running).

Files fixed: cli_coverage_show_test, contributor_routing_e2e_test,
doctor/{database,fix/metadata_dolt,maintenance_cgo,migration_validation,
validation}_test, gitlab_integration_test, init_test, migrate_test,
move_test, rename_prefix{,_repair}_test, sql_test, status_test,
update_metadata_test.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Executed-By: beads/crew/emma
Rig: beads
Role: crew
2026-02-22 21:53:11 -08:00

176 lines
4.2 KiB
Go

//go:build cgo
package main
import (
"context"
"encoding/json"
"os"
"path/filepath"
"strings"
"testing"
"github.com/steveyegge/beads/internal/storage/dolt"
"github.com/steveyegge/beads/internal/types"
)
func TestSqlCommand(t *testing.T) {
tempDir := t.TempDir()
testDBPath := filepath.Join(tempDir, ".beads", "test.db")
if err := os.MkdirAll(filepath.Dir(testDBPath), 0755); err != nil {
t.Fatalf("Failed to create .beads directory: %v", err)
}
testStore, err := dolt.New(context.Background(), &dolt.Config{Path: testDBPath})
if err != nil {
t.Skipf("skipping: Dolt server not available: %v", err)
}
defer testStore.Close()
ctx := context.Background()
if err := testStore.SetConfig(ctx, "issue_prefix", "test"); err != nil {
t.Fatalf("Failed to set issue prefix: %v", err)
}
// Create test data
testIssues := []*types.Issue{
{
Title: "Test issue one",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeTask,
},
{
Title: "Test issue two",
Status: types.StatusClosed,
Priority: 2,
IssueType: types.TypeBug,
},
}
for _, issue := range testIssues {
if err := testStore.CreateIssue(ctx, issue, "test"); err != nil {
t.Fatalf("Failed to create test issue: %v", err)
}
}
// Save/restore globals
oldStore := store
oldCtx := rootCtx
oldJSON := jsonOutput
defer func() {
store = oldStore
rootCtx = oldCtx
jsonOutput = oldJSON
}()
store = testStore
rootCtx = ctx
t.Run("select count", func(t *testing.T) {
jsonOutput = true
output := captureStdout(t, func() error {
sqlCmd.Run(sqlCmd, []string{"SELECT COUNT(*) as count FROM issues"})
return nil
})
var result []map[string]interface{}
if err := json.Unmarshal([]byte(output), &result); err != nil {
t.Fatalf("Failed to parse JSON output: %v\nOutput: %s", err, output)
}
if len(result) != 1 {
t.Fatalf("Expected 1 row, got %d", len(result))
}
count, ok := result[0]["count"]
if !ok {
t.Fatal("Missing 'count' column in result")
}
if count.(float64) != 2 {
t.Errorf("Expected count=2, got %v", count)
}
})
t.Run("select with filter", func(t *testing.T) {
jsonOutput = true
output := captureStdout(t, func() error {
sqlCmd.Run(sqlCmd, []string{`SELECT id, title FROM issues WHERE status = 'open'`})
return nil
})
var result []map[string]interface{}
if err := json.Unmarshal([]byte(output), &result); err != nil {
t.Fatalf("Failed to parse JSON output: %v\nOutput: %s", err, output)
}
if len(result) != 1 {
t.Fatalf("Expected 1 open issue, got %d", len(result))
}
title := result[0]["title"].(string)
if title != "Test issue one" {
t.Errorf("Expected 'Test issue one', got %q", title)
}
})
t.Run("empty result json", func(t *testing.T) {
jsonOutput = true
output := captureStdout(t, func() error {
sqlCmd.Run(sqlCmd, []string{`SELECT * FROM issues WHERE title = 'nonexistent'`})
return nil
})
var result []map[string]interface{}
if err := json.Unmarshal([]byte(output), &result); err != nil {
t.Fatalf("Failed to parse JSON output: %v\nOutput: %s", err, output)
}
if len(result) != 0 {
t.Errorf("Expected 0 rows, got %d", len(result))
}
})
t.Run("table output", func(t *testing.T) {
jsonOutput = false
output := captureStdout(t, func() error {
sqlCmd.Run(sqlCmd, []string{"SELECT COUNT(*) as count FROM issues"})
return nil
})
if !strings.Contains(output, "count") {
t.Errorf("Expected table header 'count' in output: %s", output)
}
if !strings.Contains(output, "(1 rows)") {
t.Errorf("Expected '(1 rows)' in output: %s", output)
}
})
t.Run("empty table output", func(t *testing.T) {
jsonOutput = false
output := captureStdout(t, func() error {
sqlCmd.Run(sqlCmd, []string{`SELECT * FROM issues WHERE title = 'nonexistent'`})
return nil
})
if !strings.Contains(output, "(0 rows)") {
t.Errorf("Expected '(0 rows)' in output: %s", output)
}
})
}
func TestSqlCommandInit(t *testing.T) {
found := false
for _, cmd := range rootCmd.Commands() {
if cmd.Use == "sql <query>" {
found = true
if cmd.GroupID != "maint" {
t.Errorf("Expected GroupID 'maint', got %q", cmd.GroupID)
}
break
}
}
if !found {
t.Error("sql command not registered with rootCmd")
}
}