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
404 lines
12 KiB
Go
404 lines
12 KiB
Go
//go:build cgo && e2e
|
|
|
|
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"io"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/steveyegge/beads/internal/storage/dolt"
|
|
"github.com/steveyegge/beads/internal/types"
|
|
)
|
|
|
|
var cliCoverageMutex sync.Mutex
|
|
|
|
func runBDForCoverage(t *testing.T, dir string, args ...string) (stdout string, stderr string) {
|
|
t.Helper()
|
|
|
|
cliCoverageMutex.Lock()
|
|
defer cliCoverageMutex.Unlock()
|
|
|
|
oldStdout := os.Stdout
|
|
oldStderr := os.Stderr
|
|
oldDir, _ := os.Getwd()
|
|
oldArgs := os.Args
|
|
|
|
if err := os.Chdir(dir); err != nil {
|
|
t.Fatalf("chdir %s: %v", dir, err)
|
|
}
|
|
|
|
rOut, wOut, _ := os.Pipe()
|
|
rErr, wErr, _ := os.Pipe()
|
|
os.Stdout = wOut
|
|
os.Stderr = wErr
|
|
|
|
// Ensure direct mode.
|
|
oldNoDaemon, noDaemonWasSet := os.LookupEnv("BEADS_NO_DAEMON")
|
|
os.Setenv("BEADS_NO_DAEMON", "1")
|
|
defer func() {
|
|
if noDaemonWasSet {
|
|
_ = os.Setenv("BEADS_NO_DAEMON", oldNoDaemon)
|
|
} else {
|
|
os.Unsetenv("BEADS_NO_DAEMON")
|
|
}
|
|
}()
|
|
|
|
// Mark tests explicitly.
|
|
oldTestMode, testModeWasSet := os.LookupEnv("BEADS_TEST_MODE")
|
|
os.Setenv("BEADS_TEST_MODE", "1")
|
|
defer func() {
|
|
if testModeWasSet {
|
|
_ = os.Setenv("BEADS_TEST_MODE", oldTestMode)
|
|
} else {
|
|
os.Unsetenv("BEADS_TEST_MODE")
|
|
}
|
|
}()
|
|
|
|
// Ensure all commands (including init) operate on the temp workspace DB.
|
|
db := filepath.Join(dir, ".beads", "beads.db")
|
|
beadsDir := filepath.Join(dir, ".beads")
|
|
oldBeadsDir, beadsDirWasSet := os.LookupEnv("BEADS_DIR")
|
|
os.Setenv("BEADS_DIR", beadsDir)
|
|
defer func() {
|
|
if beadsDirWasSet {
|
|
_ = os.Setenv("BEADS_DIR", oldBeadsDir)
|
|
} else {
|
|
os.Unsetenv("BEADS_DIR")
|
|
}
|
|
}()
|
|
|
|
oldDB, dbWasSet := os.LookupEnv("BEADS_DB")
|
|
os.Setenv("BEADS_DB", db)
|
|
defer func() {
|
|
if dbWasSet {
|
|
_ = os.Setenv("BEADS_DB", oldDB)
|
|
} else {
|
|
os.Unsetenv("BEADS_DB")
|
|
}
|
|
}()
|
|
oldBDDB, bdDBWasSet := os.LookupEnv("BD_DB")
|
|
os.Setenv("BD_DB", db)
|
|
defer func() {
|
|
if bdDBWasSet {
|
|
_ = os.Setenv("BD_DB", oldBDDB)
|
|
} else {
|
|
os.Unsetenv("BD_DB")
|
|
}
|
|
}()
|
|
|
|
// Ensure actor is set so label operations record audit fields.
|
|
oldActor, actorWasSet := os.LookupEnv("BD_ACTOR")
|
|
os.Setenv("BD_ACTOR", "test-user")
|
|
defer func() {
|
|
if actorWasSet {
|
|
_ = os.Setenv("BD_ACTOR", oldActor)
|
|
} else {
|
|
os.Unsetenv("BD_ACTOR")
|
|
}
|
|
}()
|
|
oldBeadsActor, beadsActorWasSet := os.LookupEnv("BEADS_ACTOR")
|
|
os.Setenv("BEADS_ACTOR", "test-user")
|
|
defer func() {
|
|
if beadsActorWasSet {
|
|
_ = os.Setenv("BEADS_ACTOR", oldBeadsActor)
|
|
} else {
|
|
os.Unsetenv("BEADS_ACTOR")
|
|
}
|
|
}()
|
|
|
|
rootCmd.SetArgs(args)
|
|
os.Args = append([]string{"bd"}, args...)
|
|
|
|
err := rootCmd.Execute()
|
|
|
|
// Close and clean up all global state to prevent contamination between tests.
|
|
if store != nil {
|
|
store.Close()
|
|
store = nil
|
|
}
|
|
// Reset all global flags and state (keep aligned with integration cli_fast_test).
|
|
dbPath = ""
|
|
actor = ""
|
|
jsonOutput = false
|
|
sandboxMode = false
|
|
rootCtx = nil
|
|
rootCancel = nil
|
|
|
|
// Give SQLite time to release file locks.
|
|
time.Sleep(10 * time.Millisecond)
|
|
|
|
_ = wOut.Close()
|
|
_ = wErr.Close()
|
|
os.Stdout = oldStdout
|
|
os.Stderr = oldStderr
|
|
_ = os.Chdir(oldDir)
|
|
os.Args = oldArgs
|
|
rootCmd.SetArgs(nil)
|
|
|
|
var outBuf, errBuf bytes.Buffer
|
|
_, _ = io.Copy(&outBuf, rOut)
|
|
_, _ = io.Copy(&errBuf, rErr)
|
|
_ = rOut.Close()
|
|
_ = rErr.Close()
|
|
|
|
stdout = outBuf.String()
|
|
stderr = errBuf.String()
|
|
|
|
if err != nil {
|
|
t.Fatalf("bd %v failed: %v\nStdout: %s\nStderr: %s", args, err, stdout, stderr)
|
|
}
|
|
|
|
return stdout, stderr
|
|
}
|
|
|
|
func extractJSONPayload(s string) string {
|
|
if i := strings.IndexAny(s, "[{"); i >= 0 {
|
|
return s[i:]
|
|
}
|
|
return s
|
|
}
|
|
|
|
func parseCreatedIssueID(t *testing.T, out string) string {
|
|
t.Helper()
|
|
|
|
p := extractJSONPayload(out)
|
|
var m map[string]interface{}
|
|
if err := json.Unmarshal([]byte(p), &m); err != nil {
|
|
t.Fatalf("parse create JSON: %v\n%s", err, out)
|
|
}
|
|
id, _ := m["id"].(string)
|
|
if id == "" {
|
|
t.Fatalf("missing id in create output: %s", out)
|
|
}
|
|
return id
|
|
}
|
|
|
|
func TestCoverage_ShowUpdateClose(t *testing.T) {
|
|
if testing.Short() {
|
|
t.Skip("skipping CLI coverage test in short mode")
|
|
}
|
|
|
|
dir := t.TempDir()
|
|
runBDForCoverage(t, dir, "init", "--prefix", "test", "--quiet")
|
|
|
|
out, _ := runBDForCoverage(t, dir, "create", "Show coverage issue", "-p", "1", "--json")
|
|
id := parseCreatedIssueID(t, out)
|
|
|
|
// Exercise update label flows (add -> set -> add/remove).
|
|
runBDForCoverage(t, dir, "update", id, "--add-label", "old", "--json")
|
|
runBDForCoverage(t, dir, "update", id, "--set-labels", "a,b", "--add-label", "c", "--remove-label", "a", "--json")
|
|
runBDForCoverage(t, dir, "update", id, "--remove-label", "old", "--json")
|
|
|
|
// Show JSON output and verify labels were applied.
|
|
showOut, _ := runBDForCoverage(t, dir, "show", "--allow-stale", id, "--json")
|
|
showPayload := extractJSONPayload(showOut)
|
|
|
|
var details []map[string]interface{}
|
|
if err := json.Unmarshal([]byte(showPayload), &details); err != nil {
|
|
// Some commands may emit a single object; fall back to object parse.
|
|
var single map[string]interface{}
|
|
if err2 := json.Unmarshal([]byte(showPayload), &single); err2 != nil {
|
|
t.Fatalf("parse show JSON: %v / %v\n%s", err, err2, showOut)
|
|
}
|
|
details = []map[string]interface{}{single}
|
|
}
|
|
if len(details) != 1 {
|
|
t.Fatalf("expected 1 issue, got %d", len(details))
|
|
}
|
|
labelsAny, ok := details[0]["labels"]
|
|
if !ok {
|
|
t.Fatalf("expected labels in show output: %s", showOut)
|
|
}
|
|
labelsBytes, _ := json.Marshal(labelsAny)
|
|
labelsStr := string(labelsBytes)
|
|
if !strings.Contains(labelsStr, "b") || !strings.Contains(labelsStr, "c") {
|
|
t.Fatalf("expected labels b and c, got %s", labelsStr)
|
|
}
|
|
if strings.Contains(labelsStr, "a") || strings.Contains(labelsStr, "old") {
|
|
t.Fatalf("expected labels a and old to be absent, got %s", labelsStr)
|
|
}
|
|
|
|
// Show text output.
|
|
showText, _ := runBDForCoverage(t, dir, "show", "--allow-stale", id)
|
|
if !strings.Contains(showText, "Show coverage issue") {
|
|
t.Fatalf("expected show output to contain title, got: %s", showText)
|
|
}
|
|
|
|
// Multi-ID show should print both issues.
|
|
out2, _ := runBDForCoverage(t, dir, "create", "Second issue", "-p", "2", "--json")
|
|
id2 := parseCreatedIssueID(t, out2)
|
|
multi, _ := runBDForCoverage(t, dir, "show", "--allow-stale", id, id2)
|
|
if !strings.Contains(multi, "Show coverage issue") || !strings.Contains(multi, "Second issue") {
|
|
t.Fatalf("expected multi-show output to include both titles, got: %s", multi)
|
|
}
|
|
if !strings.Contains(multi, "─") {
|
|
t.Fatalf("expected multi-show output to include a separator line, got: %s", multi)
|
|
}
|
|
|
|
// Close and verify JSON output.
|
|
closeOut, _ := runBDForCoverage(t, dir, "close", id, "--reason", "Done", "--json")
|
|
closePayload := extractJSONPayload(closeOut)
|
|
var closed []map[string]interface{}
|
|
if err := json.Unmarshal([]byte(closePayload), &closed); err != nil {
|
|
t.Fatalf("parse close JSON: %v\n%s", err, closeOut)
|
|
}
|
|
if len(closed) != 1 {
|
|
t.Fatalf("expected 1 closed issue, got %d", len(closed))
|
|
}
|
|
if status, _ := closed[0]["status"].(string); status != string(types.StatusClosed) {
|
|
t.Fatalf("expected status closed, got %q", status)
|
|
}
|
|
}
|
|
|
|
func TestCoverage_TemplateAndPinnedProtections(t *testing.T) {
|
|
if testing.Short() {
|
|
t.Skip("skipping CLI coverage test in short mode")
|
|
}
|
|
|
|
dir := t.TempDir()
|
|
runBDForCoverage(t, dir, "init", "--prefix", "test", "--quiet")
|
|
|
|
// Create a pinned issue and verify close requires --force.
|
|
out, _ := runBDForCoverage(t, dir, "create", "Pinned issue", "-p", "1", "--json")
|
|
pinnedID := parseCreatedIssueID(t, out)
|
|
runBDForCoverage(t, dir, "update", pinnedID, "--status", string(types.StatusPinned), "--json")
|
|
_, closeErr := runBDForCoverage(t, dir, "close", pinnedID, "--reason", "Done")
|
|
if !strings.Contains(closeErr, "cannot close pinned issue") {
|
|
t.Fatalf("expected pinned close to be rejected, stderr: %s", closeErr)
|
|
}
|
|
|
|
forceOut, _ := runBDForCoverage(t, dir, "close", pinnedID, "--force", "--reason", "Done", "--json")
|
|
forcePayload := extractJSONPayload(forceOut)
|
|
var closed []map[string]interface{}
|
|
if err := json.Unmarshal([]byte(forcePayload), &closed); err != nil {
|
|
t.Fatalf("parse close JSON: %v\n%s", err, forceOut)
|
|
}
|
|
if len(closed) != 1 {
|
|
t.Fatalf("expected 1 closed issue, got %d", len(closed))
|
|
}
|
|
|
|
// Insert a template issue directly and verify update/close protect it.
|
|
dbFile := filepath.Join(dir, ".beads", "beads.db")
|
|
s, err := dolt.New(context.Background(), &dolt.Config{Path: dbFile})
|
|
if err != nil {
|
|
t.Skipf("skipping: Dolt server not available: %v", err)
|
|
}
|
|
ctx := context.Background()
|
|
template := &types.Issue{
|
|
Title: "Template issue",
|
|
Status: types.StatusOpen,
|
|
Priority: 2,
|
|
IssueType: types.TypeTask,
|
|
IsTemplate: true,
|
|
}
|
|
if err := s.CreateIssue(ctx, template, "test-user"); err != nil {
|
|
s.Close()
|
|
t.Fatalf("CreateIssue: %v", err)
|
|
}
|
|
created, err := s.GetIssue(ctx, template.ID)
|
|
if err != nil {
|
|
s.Close()
|
|
t.Fatalf("GetIssue(template): %v", err)
|
|
}
|
|
if created == nil || !created.IsTemplate {
|
|
s.Close()
|
|
t.Fatalf("expected inserted issue to be IsTemplate=true, got %+v", created)
|
|
}
|
|
_ = s.Close()
|
|
|
|
showOut, _ := runBDForCoverage(t, dir, "show", "--allow-stale", template.ID, "--json")
|
|
showPayload := extractJSONPayload(showOut)
|
|
var showDetails []map[string]interface{}
|
|
if err := json.Unmarshal([]byte(showPayload), &showDetails); err != nil {
|
|
t.Fatalf("parse show JSON: %v\n%s", err, showOut)
|
|
}
|
|
if len(showDetails) != 1 {
|
|
t.Fatalf("expected 1 issue from show, got %d", len(showDetails))
|
|
}
|
|
// Re-open the DB after running the CLI to confirm is_template persisted.
|
|
s2, err := dolt.New(context.Background(), &dolt.Config{Path: dbFile})
|
|
if err != nil {
|
|
t.Skipf("skipping: Dolt server not available: %v", err)
|
|
}
|
|
postShow, err := s2.GetIssue(context.Background(), template.ID)
|
|
_ = s2.Close()
|
|
if err != nil {
|
|
t.Fatalf("GetIssue(template, post-show): %v", err)
|
|
}
|
|
if postShow == nil || !postShow.IsTemplate {
|
|
t.Fatalf("expected template to remain IsTemplate=true post-show, got %+v", postShow)
|
|
}
|
|
if v, ok := showDetails[0]["is_template"]; ok {
|
|
if b, ok := v.(bool); !ok || !b {
|
|
t.Fatalf("expected show JSON is_template=true, got %v", v)
|
|
}
|
|
} else {
|
|
t.Fatalf("expected show JSON to include is_template=true, got: %s", showOut)
|
|
}
|
|
|
|
_, updErr := runBDForCoverage(t, dir, "update", template.ID, "--title", "New title")
|
|
if !strings.Contains(updErr, "cannot update template") {
|
|
t.Fatalf("expected template update to be rejected, stderr: %s", updErr)
|
|
}
|
|
_, closeTemplateErr := runBDForCoverage(t, dir, "close", template.ID, "--reason", "Done")
|
|
if !strings.Contains(closeTemplateErr, "cannot close template") {
|
|
t.Fatalf("expected template close to be rejected, stderr: %s", closeTemplateErr)
|
|
}
|
|
}
|
|
|
|
func TestCoverage_ShowThread(t *testing.T) {
|
|
if testing.Short() {
|
|
t.Skip("skipping CLI coverage test in short mode")
|
|
}
|
|
|
|
dir := t.TempDir()
|
|
runBDForCoverage(t, dir, "init", "--prefix", "test", "--quiet")
|
|
|
|
dbFile := filepath.Join(dir, ".beads", "beads.db")
|
|
s, err := dolt.New(context.Background(), &dolt.Config{Path: dbFile})
|
|
if err != nil {
|
|
t.Skipf("skipping: Dolt server not available: %v", err)
|
|
}
|
|
ctx := context.Background()
|
|
|
|
root := &types.Issue{Title: "Root message", IssueType: "message", Status: types.StatusOpen, Sender: "alice", Assignee: "bob"}
|
|
reply1 := &types.Issue{Title: "Re: Root", IssueType: "message", Status: types.StatusOpen, Sender: "bob", Assignee: "alice"}
|
|
reply2 := &types.Issue{Title: "Re: Re: Root", IssueType: "message", Status: types.StatusOpen, Sender: "alice", Assignee: "bob"}
|
|
if err := s.CreateIssue(ctx, root, "test-user"); err != nil {
|
|
s.Close()
|
|
t.Fatalf("CreateIssue root: %v", err)
|
|
}
|
|
if err := s.CreateIssue(ctx, reply1, "test-user"); err != nil {
|
|
s.Close()
|
|
t.Fatalf("CreateIssue reply1: %v", err)
|
|
}
|
|
if err := s.CreateIssue(ctx, reply2, "test-user"); err != nil {
|
|
s.Close()
|
|
t.Fatalf("CreateIssue reply2: %v", err)
|
|
}
|
|
if err := s.AddDependency(ctx, &types.Dependency{IssueID: reply1.ID, DependsOnID: root.ID, Type: types.DepRepliesTo, ThreadID: root.ID}, "test-user"); err != nil {
|
|
s.Close()
|
|
t.Fatalf("AddDependency reply1->root: %v", err)
|
|
}
|
|
if err := s.AddDependency(ctx, &types.Dependency{IssueID: reply2.ID, DependsOnID: reply1.ID, Type: types.DepRepliesTo, ThreadID: root.ID}, "test-user"); err != nil {
|
|
s.Close()
|
|
t.Fatalf("AddDependency reply2->reply1: %v", err)
|
|
}
|
|
_ = s.Close()
|
|
|
|
out, _ := runBDForCoverage(t, dir, "show", "--allow-stale", reply2.ID, "--thread")
|
|
if !strings.Contains(out, "Thread") || !strings.Contains(out, "Total: 3 messages") {
|
|
t.Fatalf("expected thread output, got: %s", out)
|
|
}
|
|
if !strings.Contains(out, root.ID) || !strings.Contains(out, reply1.ID) || !strings.Contains(out, reply2.ID) {
|
|
t.Fatalf("expected thread output to include message IDs, got: %s", out)
|
|
}
|
|
}
|