1023 lines
27 KiB
Go
1023 lines
27 KiB
Go
//go:build cgo
|
|
|
|
package main
|
|
|
|
import (
|
|
"bufio"
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/steveyegge/beads/internal/testutil"
|
|
"github.com/steveyegge/beads/internal/types"
|
|
)
|
|
|
|
func TestExportToFile(t *testing.T) {
|
|
if testDoltServerPort == 0 {
|
|
t.Skip("Dolt test server not available")
|
|
}
|
|
if testutil.DoltContainerCrashed() {
|
|
t.Skipf("Dolt test server crashed: %v", testutil.DoltContainerCrashError())
|
|
}
|
|
|
|
ensureTestMode(t)
|
|
saved := saveAndRestoreGlobals(t)
|
|
_ = saved
|
|
|
|
tmpDir := t.TempDir()
|
|
beadsDir := filepath.Join(tmpDir, ".beads")
|
|
if err := os.MkdirAll(beadsDir, 0755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
origWd, _ := os.Getwd()
|
|
if err := os.Chdir(tmpDir); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = os.Chdir(origWd) })
|
|
|
|
dbName := uniqueTestDBName(t)
|
|
testDBPath := filepath.Join(beadsDir, "dolt")
|
|
writeTestMetadata(t, testDBPath, dbName)
|
|
s := newTestStore(t, testDBPath)
|
|
store = s
|
|
storeMutex.Lock()
|
|
storeActive = true
|
|
storeMutex.Unlock()
|
|
t.Cleanup(func() {
|
|
store = nil
|
|
storeMutex.Lock()
|
|
storeActive = false
|
|
storeMutex.Unlock()
|
|
})
|
|
|
|
ctx := context.Background()
|
|
rootCtx = ctx
|
|
|
|
// Create test issues
|
|
if _, err := s.DB().ExecContext(ctx, `INSERT INTO issues (id, title, description, design, acceptance_criteria, notes, status, priority, issue_type) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
|
|
"exp-1", "Export Issue 1", "description one", "", "", "", "open", 1, "task"); err != nil {
|
|
t.Fatalf("insert issue 1: %v", err)
|
|
}
|
|
if _, err := s.DB().ExecContext(ctx, `INSERT INTO issues (id, title, description, design, acceptance_criteria, notes, status, priority, issue_type) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
|
|
"exp-2", "Export Issue 2", "description two", "", "", "", "closed", 2, "bug"); err != nil {
|
|
t.Fatalf("insert issue 2: %v", err)
|
|
}
|
|
|
|
// Add a label
|
|
if _, err := s.DB().ExecContext(ctx, `INSERT INTO labels (issue_id, label) VALUES (?, ?)`,
|
|
"exp-1", "important"); err != nil {
|
|
t.Fatalf("insert label: %v", err)
|
|
}
|
|
|
|
// Export to file
|
|
exportFile := filepath.Join(tmpDir, "export.jsonl")
|
|
exportOutput = exportFile
|
|
exportAll = false
|
|
exportIncludeInfra = false
|
|
exportScrub = false
|
|
t.Cleanup(func() { exportOutput = "" })
|
|
|
|
if err := runExport(nil, nil); err != nil {
|
|
t.Fatalf("runExport: %v", err)
|
|
}
|
|
|
|
// Verify file was created
|
|
if _, err := os.Stat(exportFile); os.IsNotExist(err) {
|
|
t.Fatal("export file not created")
|
|
}
|
|
|
|
// Read and verify content
|
|
data, err := os.ReadFile(exportFile)
|
|
if err != nil {
|
|
t.Fatalf("read export file: %v", err)
|
|
}
|
|
|
|
lines := splitJSONL(data)
|
|
if len(lines) != 2 {
|
|
t.Fatalf("expected 2 lines, got %d", len(lines))
|
|
}
|
|
|
|
// Parse first issue and check fields
|
|
var issue1 map[string]interface{}
|
|
if err := json.Unmarshal(lines[0], &issue1); err != nil {
|
|
t.Fatalf("parse line 0: %v", err)
|
|
}
|
|
|
|
// One of the two issues should have the label
|
|
foundLabel := false
|
|
for _, line := range lines {
|
|
var iss map[string]interface{}
|
|
json.Unmarshal(line, &iss)
|
|
if labels, ok := iss["labels"].([]interface{}); ok && len(labels) > 0 {
|
|
if labels[0].(string) == "important" {
|
|
foundLabel = true
|
|
}
|
|
}
|
|
}
|
|
if !foundLabel {
|
|
t.Error("expected to find 'important' label in exported issues")
|
|
}
|
|
}
|
|
|
|
func TestExportToStdout(t *testing.T) {
|
|
if testDoltServerPort == 0 {
|
|
t.Skip("Dolt test server not available")
|
|
}
|
|
if testutil.DoltContainerCrashed() {
|
|
t.Skipf("Dolt test server crashed: %v", testutil.DoltContainerCrashError())
|
|
}
|
|
|
|
ensureTestMode(t)
|
|
saved := saveAndRestoreGlobals(t)
|
|
_ = saved
|
|
|
|
tmpDir := t.TempDir()
|
|
beadsDir := filepath.Join(tmpDir, ".beads")
|
|
if err := os.MkdirAll(beadsDir, 0755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
origWd, _ := os.Getwd()
|
|
if err := os.Chdir(tmpDir); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = os.Chdir(origWd) })
|
|
|
|
dbName := uniqueTestDBName(t)
|
|
testDBPath := filepath.Join(beadsDir, "dolt")
|
|
writeTestMetadata(t, testDBPath, dbName)
|
|
s := newTestStore(t, testDBPath)
|
|
store = s
|
|
storeMutex.Lock()
|
|
storeActive = true
|
|
storeMutex.Unlock()
|
|
t.Cleanup(func() {
|
|
store = nil
|
|
storeMutex.Lock()
|
|
storeActive = false
|
|
storeMutex.Unlock()
|
|
})
|
|
|
|
ctx := context.Background()
|
|
rootCtx = ctx
|
|
|
|
// Create a test issue
|
|
if _, err := s.DB().ExecContext(ctx, `INSERT INTO issues (id, title, description, design, acceptance_criteria, notes, status, priority, issue_type) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
|
|
"exp-3", "Stdout Export", "testing stdout", "", "", "", "open", 1, "task"); err != nil {
|
|
t.Fatalf("insert issue: %v", err)
|
|
}
|
|
|
|
// Capture stdout
|
|
oldStdout := os.Stdout
|
|
r, w, _ := os.Pipe()
|
|
os.Stdout = w
|
|
|
|
exportOutput = ""
|
|
exportAll = false
|
|
exportIncludeInfra = false
|
|
exportScrub = false
|
|
|
|
err := runExport(nil, nil)
|
|
|
|
w.Close()
|
|
os.Stdout = oldStdout
|
|
|
|
if err != nil {
|
|
t.Fatalf("runExport: %v", err)
|
|
}
|
|
|
|
// Read captured output
|
|
scanner := bufio.NewScanner(r)
|
|
var lines []string
|
|
for scanner.Scan() {
|
|
lines = append(lines, scanner.Text())
|
|
}
|
|
|
|
if len(lines) != 1 {
|
|
t.Fatalf("expected 1 line on stdout, got %d", len(lines))
|
|
}
|
|
|
|
var issue map[string]interface{}
|
|
if err := json.Unmarshal([]byte(lines[0]), &issue); err != nil {
|
|
t.Fatalf("parse stdout line: %v", err)
|
|
}
|
|
if issue["title"] != "Stdout Export" {
|
|
t.Errorf("expected title 'Stdout Export', got %v", issue["title"])
|
|
}
|
|
}
|
|
|
|
func TestExportScrub(t *testing.T) {
|
|
if testDoltServerPort == 0 {
|
|
t.Skip("Dolt test server not available")
|
|
}
|
|
if testutil.DoltContainerCrashed() {
|
|
t.Skipf("Dolt test server crashed: %v", testutil.DoltContainerCrashError())
|
|
}
|
|
|
|
ensureTestMode(t)
|
|
saved := saveAndRestoreGlobals(t)
|
|
_ = saved
|
|
|
|
tmpDir := t.TempDir()
|
|
beadsDir := filepath.Join(tmpDir, ".beads")
|
|
if err := os.MkdirAll(beadsDir, 0755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
origWd, _ := os.Getwd()
|
|
if err := os.Chdir(tmpDir); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = os.Chdir(origWd) })
|
|
|
|
dbName := uniqueTestDBName(t)
|
|
testDBPath := filepath.Join(beadsDir, "dolt")
|
|
writeTestMetadata(t, testDBPath, dbName)
|
|
s := newTestStore(t, testDBPath)
|
|
store = s
|
|
storeMutex.Lock()
|
|
storeActive = true
|
|
storeMutex.Unlock()
|
|
t.Cleanup(func() {
|
|
store = nil
|
|
storeMutex.Lock()
|
|
storeActive = false
|
|
storeMutex.Unlock()
|
|
})
|
|
|
|
ctx := context.Background()
|
|
rootCtx = ctx
|
|
|
|
// Create a real issue and a test pollution issue
|
|
if _, err := s.DB().ExecContext(ctx, `INSERT INTO issues (id, title, description, design, acceptance_criteria, notes, status, priority, issue_type) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
|
|
"exp-4", "Real Issue", "real work", "", "", "", "open", 1, "task"); err != nil {
|
|
t.Fatalf("insert real issue: %v", err)
|
|
}
|
|
if _, err := s.DB().ExecContext(ctx, `INSERT INTO issues (id, title, description, design, acceptance_criteria, notes, status, priority, issue_type) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
|
|
"exp-5", "test-pollution item", "should be scrubbed", "", "", "", "open", 3, "task"); err != nil {
|
|
t.Fatalf("insert test issue: %v", err)
|
|
}
|
|
|
|
// Export with scrub
|
|
exportFile := filepath.Join(tmpDir, "scrubbed.jsonl")
|
|
exportOutput = exportFile
|
|
exportAll = false
|
|
exportIncludeInfra = false
|
|
exportScrub = true
|
|
t.Cleanup(func() {
|
|
exportOutput = ""
|
|
exportScrub = false
|
|
})
|
|
|
|
if err := runExport(nil, nil); err != nil {
|
|
t.Fatalf("runExport: %v", err)
|
|
}
|
|
|
|
data, err := os.ReadFile(exportFile)
|
|
if err != nil {
|
|
t.Fatalf("read scrubbed file: %v", err)
|
|
}
|
|
|
|
lines := splitJSONL(data)
|
|
if len(lines) != 1 {
|
|
t.Fatalf("expected 1 line after scrub, got %d", len(lines))
|
|
}
|
|
|
|
var issue map[string]interface{}
|
|
json.Unmarshal(lines[0], &issue)
|
|
if issue["title"] != "Real Issue" {
|
|
t.Errorf("expected 'Real Issue', got %v", issue["title"])
|
|
}
|
|
}
|
|
|
|
func TestExportImportRoundTrip(t *testing.T) {
|
|
if testDoltServerPort == 0 {
|
|
t.Skip("Dolt test server not available")
|
|
}
|
|
if testutil.DoltContainerCrashed() {
|
|
t.Skipf("Dolt test server crashed: %v", testutil.DoltContainerCrashError())
|
|
}
|
|
|
|
ensureTestMode(t)
|
|
saved := saveAndRestoreGlobals(t)
|
|
_ = saved
|
|
|
|
tmpDir := t.TempDir()
|
|
beadsDir := filepath.Join(tmpDir, ".beads")
|
|
if err := os.MkdirAll(beadsDir, 0755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
origWd, _ := os.Getwd()
|
|
if err := os.Chdir(tmpDir); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = os.Chdir(origWd) })
|
|
|
|
dbName := uniqueTestDBName(t)
|
|
testDBPath := filepath.Join(beadsDir, "dolt")
|
|
writeTestMetadata(t, testDBPath, dbName)
|
|
s := newTestStore(t, testDBPath)
|
|
store = s
|
|
storeMutex.Lock()
|
|
storeActive = true
|
|
storeMutex.Unlock()
|
|
t.Cleanup(func() {
|
|
store = nil
|
|
storeMutex.Lock()
|
|
storeActive = false
|
|
storeMutex.Unlock()
|
|
})
|
|
|
|
ctx := context.Background()
|
|
rootCtx = ctx
|
|
|
|
// Create a test issue
|
|
if _, err := s.DB().ExecContext(ctx, `INSERT INTO issues (id, title, description, design, acceptance_criteria, notes, status, priority, issue_type) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
|
|
"exp-6", "Round Trip", "round trip test", "", "", "", "open", 1, "feature"); err != nil {
|
|
t.Fatalf("insert issue: %v", err)
|
|
}
|
|
|
|
// Export
|
|
exportFile := filepath.Join(tmpDir, "roundtrip.jsonl")
|
|
exportOutput = exportFile
|
|
exportAll = false
|
|
exportIncludeInfra = false
|
|
exportScrub = false
|
|
t.Cleanup(func() { exportOutput = "" })
|
|
|
|
if err := runExport(nil, nil); err != nil {
|
|
t.Fatalf("export: %v", err)
|
|
}
|
|
|
|
// Verify the exported JSONL can be parsed by the import system
|
|
data, err := os.ReadFile(exportFile)
|
|
if err != nil {
|
|
t.Fatalf("read export: %v", err)
|
|
}
|
|
|
|
scanner := bufio.NewScanner(strings.NewReader(string(data)))
|
|
scanner.Buffer(make([]byte, 0, 1024*1024), 64*1024*1024)
|
|
var count int
|
|
for scanner.Scan() {
|
|
line := scanner.Text()
|
|
if line == "" {
|
|
continue
|
|
}
|
|
var issue map[string]interface{}
|
|
if err := json.Unmarshal([]byte(line), &issue); err != nil {
|
|
t.Fatalf("parse exported JSONL line %d: %v", count, err)
|
|
}
|
|
if issue["id"] == nil || issue["title"] == nil {
|
|
t.Errorf("line %d missing required fields: %v", count, issue)
|
|
}
|
|
count++
|
|
}
|
|
if count != 1 {
|
|
t.Errorf("expected 1 issue, got %d", count)
|
|
}
|
|
}
|
|
|
|
func TestFilterOutPollution(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
tests := []struct {
|
|
title string
|
|
want bool
|
|
}{
|
|
{"Real feature request", false},
|
|
{"test-something", true},
|
|
{"benchmark-perf test", true},
|
|
{"Actual bug fix", false},
|
|
{"tmp-throwaway", true},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
if got := isTestIssue(tt.title); got != tt.want {
|
|
t.Errorf("isTestIssue(%q) = %v, want %v", tt.title, got, tt.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestExportNoHistoryBeadRoundTrip(t *testing.T) {
|
|
// GH#2619: NoHistory beads are stored in the wisps table. The JSONL export
|
|
// must include them with no_history=true, and import must preserve the flag.
|
|
// If no_history is dropped during import, the bead becomes GC-eligible.
|
|
if testDoltServerPort == 0 {
|
|
t.Skip("Dolt test server not available")
|
|
}
|
|
if testutil.DoltContainerCrashed() {
|
|
t.Skipf("Dolt test server crashed: %v", testutil.DoltContainerCrashError())
|
|
}
|
|
|
|
ensureTestMode(t)
|
|
saved := saveAndRestoreGlobals(t)
|
|
_ = saved
|
|
|
|
tmpDir := t.TempDir()
|
|
beadsDir := filepath.Join(tmpDir, ".beads")
|
|
if err := os.MkdirAll(beadsDir, 0755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
origWd, _ := os.Getwd()
|
|
if err := os.Chdir(tmpDir); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = os.Chdir(origWd) })
|
|
|
|
dbName := uniqueTestDBName(t)
|
|
testDBPath := filepath.Join(beadsDir, "dolt")
|
|
writeTestMetadata(t, testDBPath, dbName)
|
|
s := newTestStore(t, testDBPath)
|
|
store = s
|
|
storeMutex.Lock()
|
|
storeActive = true
|
|
storeMutex.Unlock()
|
|
t.Cleanup(func() {
|
|
store = nil
|
|
storeMutex.Lock()
|
|
storeActive = false
|
|
storeMutex.Unlock()
|
|
})
|
|
|
|
ctx := context.Background()
|
|
rootCtx = ctx
|
|
|
|
// Create a NoHistory bead using the store API (routes to wisps table with no_history=1).
|
|
noHistoryBead := &types.Issue{
|
|
Title: "NoHistory export test bead",
|
|
Status: types.StatusOpen,
|
|
Priority: 2,
|
|
IssueType: types.TypeTask,
|
|
NoHistory: true,
|
|
}
|
|
if err := s.CreateIssue(ctx, noHistoryBead, "test"); err != nil {
|
|
t.Fatalf("CreateIssue (NoHistory): %v", err)
|
|
}
|
|
|
|
// Also create a regular issue to ensure the export contains both.
|
|
if _, err := s.DB().ExecContext(ctx, `INSERT INTO issues (id, title, description, design, acceptance_criteria, notes, status, priority, issue_type) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
|
|
"nohistory-regular-1", "Regular issue", "", "", "", "", "open", 1, "task"); err != nil {
|
|
t.Fatalf("insert regular issue: %v", err)
|
|
}
|
|
|
|
// Export to file.
|
|
exportFile := filepath.Join(tmpDir, "nohistory_export.jsonl")
|
|
exportOutput = exportFile
|
|
exportAll = true // include everything
|
|
exportIncludeInfra = false
|
|
exportScrub = false
|
|
t.Cleanup(func() {
|
|
exportOutput = ""
|
|
exportAll = false
|
|
})
|
|
|
|
if err := runExport(nil, nil); err != nil {
|
|
t.Fatalf("runExport: %v", err)
|
|
}
|
|
|
|
data, err := os.ReadFile(exportFile)
|
|
if err != nil {
|
|
t.Fatalf("read export file: %v", err)
|
|
}
|
|
|
|
// Verify the NoHistory bead appears in the export with no_history=true.
|
|
lines := splitJSONL(data)
|
|
if len(lines) < 2 {
|
|
t.Fatalf("expected at least 2 lines in export (regular + NoHistory), got %d", len(lines))
|
|
}
|
|
|
|
var noHistoryLine map[string]interface{}
|
|
for _, line := range lines {
|
|
var rec map[string]interface{}
|
|
if err := json.Unmarshal(line, &rec); err != nil {
|
|
t.Fatalf("parse exported JSONL: %v", err)
|
|
}
|
|
if rec["title"] == "NoHistory export test bead" {
|
|
noHistoryLine = rec
|
|
break
|
|
}
|
|
}
|
|
if noHistoryLine == nil {
|
|
t.Fatal("NoHistory bead not found in exported JSONL — export missed wisps with no_history=true")
|
|
}
|
|
if noHistoryLine["no_history"] != true {
|
|
t.Errorf("exported NoHistory bead has no_history=%v, want true", noHistoryLine["no_history"])
|
|
}
|
|
|
|
// Import the exported JSONL into a fresh store and verify no_history survives.
|
|
tmpDir2 := t.TempDir()
|
|
dbPath2 := filepath.Join(tmpDir2, "dolt")
|
|
store2 := newTestStore(t, dbPath2)
|
|
|
|
count, err := importFromLocalJSONL(ctx, store2, exportFile)
|
|
if err != nil {
|
|
t.Fatalf("importFromLocalJSONL: %v", err)
|
|
}
|
|
if count < 2 {
|
|
t.Errorf("expected at least 2 issues imported, got %d", count)
|
|
}
|
|
|
|
// Retrieve the NoHistory bead from the new store and check the flag.
|
|
imported, err := store2.GetIssue(ctx, noHistoryBead.ID)
|
|
if err != nil {
|
|
t.Fatalf("GetIssue(%s) after import: %v", noHistoryBead.ID, err)
|
|
}
|
|
if !imported.NoHistory {
|
|
t.Error("no_history=true was lost during export→import roundtrip: bead is now GC-eligible")
|
|
}
|
|
if imported.Ephemeral {
|
|
t.Error("NoHistory bead must not become ephemeral=true after roundtrip")
|
|
}
|
|
}
|
|
|
|
func TestExportMemoryDeterminism(t *testing.T) {
|
|
// GH#3474: memory lines must appear in deterministic order across exports.
|
|
// Seeds multiple memories, exports twice to separate files, and asserts
|
|
// byte-for-byte identical output.
|
|
if testDoltServerPort == 0 {
|
|
t.Skip("Dolt test server not available")
|
|
}
|
|
if testutil.DoltContainerCrashed() {
|
|
t.Skipf("Dolt test server crashed: %v", testutil.DoltContainerCrashError())
|
|
}
|
|
|
|
ensureTestMode(t)
|
|
saved := saveAndRestoreGlobals(t)
|
|
_ = saved
|
|
|
|
tmpDir := t.TempDir()
|
|
beadsDir := filepath.Join(tmpDir, ".beads")
|
|
if err := os.MkdirAll(beadsDir, 0755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
origWd, _ := os.Getwd()
|
|
if err := os.Chdir(tmpDir); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = os.Chdir(origWd) })
|
|
|
|
dbName := uniqueTestDBName(t)
|
|
testDBPath := filepath.Join(beadsDir, "dolt")
|
|
writeTestMetadata(t, testDBPath, dbName)
|
|
s := newTestStore(t, testDBPath)
|
|
store = s
|
|
storeMutex.Lock()
|
|
storeActive = true
|
|
storeMutex.Unlock()
|
|
t.Cleanup(func() {
|
|
store = nil
|
|
storeMutex.Lock()
|
|
storeActive = false
|
|
storeMutex.Unlock()
|
|
})
|
|
|
|
ctx := context.Background()
|
|
rootCtx = ctx
|
|
|
|
// Seed 5 memories with keys that would sort differently than insertion order.
|
|
memKeys := []string{"zeta-config", "alpha-note", "mu-decision", "beta-lesson", "omega-context"}
|
|
for _, mk := range memKeys {
|
|
storageKey := "kv.memory." + mk
|
|
if err := s.SetConfig(ctx, storageKey, "value-for-"+mk); err != nil {
|
|
t.Fatalf("SetConfig(%s): %v", storageKey, err)
|
|
}
|
|
}
|
|
|
|
doExport := func(path string) []byte {
|
|
t.Helper()
|
|
exportOutput = path
|
|
exportAll = false
|
|
exportIncludeInfra = false
|
|
exportScrub = false
|
|
exportNoMemories = false
|
|
exportIncludeMemories = true
|
|
if err := runExport(nil, nil); err != nil {
|
|
t.Fatalf("runExport(%s): %v", path, err)
|
|
}
|
|
data, err := os.ReadFile(path)
|
|
if err != nil {
|
|
t.Fatalf("read %s: %v", path, err)
|
|
}
|
|
return data
|
|
}
|
|
|
|
export1 := doExport(filepath.Join(tmpDir, "export1.jsonl"))
|
|
export2 := doExport(filepath.Join(tmpDir, "export2.jsonl"))
|
|
|
|
if string(export1) != string(export2) {
|
|
t.Error("exports are not byte-identical — memory ordering is non-deterministic")
|
|
t.Logf("export1:\n%s", export1)
|
|
t.Logf("export2:\n%s", export2)
|
|
}
|
|
|
|
// Verify memories are present and sorted alphabetically by key.
|
|
lines := splitJSONL(export1)
|
|
var memoryKeys []string
|
|
for _, line := range lines {
|
|
var rec map[string]interface{}
|
|
if err := json.Unmarshal(line, &rec); err != nil {
|
|
t.Fatalf("parse line: %v", err)
|
|
}
|
|
if rec["_type"] == "memory" {
|
|
memoryKeys = append(memoryKeys, rec["key"].(string))
|
|
}
|
|
}
|
|
if len(memoryKeys) != len(memKeys) {
|
|
t.Fatalf("expected %d memory lines, got %d", len(memKeys), len(memoryKeys))
|
|
}
|
|
for i := 1; i < len(memoryKeys); i++ {
|
|
if memoryKeys[i] < memoryKeys[i-1] {
|
|
t.Errorf("memory keys not sorted: %q appears after %q", memoryKeys[i], memoryKeys[i-1])
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestExportNoDuplicateWisps(t *testing.T) {
|
|
// GH#3352: A previous bug caused every wisp to appear twice in the export
|
|
// because export.go ran a separate Ephemeral=true query and appended the
|
|
// results, even though SearchIssues(Ephemeral=nil) already includes wisps.
|
|
// This regression test ensures no duplicate IDs appear in the export and
|
|
// the wisp count matches what was created.
|
|
if testDoltServerPort == 0 {
|
|
t.Skip("Dolt test server not available")
|
|
}
|
|
if testutil.DoltContainerCrashed() {
|
|
t.Skipf("Dolt test server crashed: %v", testutil.DoltContainerCrashError())
|
|
}
|
|
|
|
ensureTestMode(t)
|
|
saved := saveAndRestoreGlobals(t)
|
|
_ = saved
|
|
|
|
tmpDir := t.TempDir()
|
|
beadsDir := filepath.Join(tmpDir, ".beads")
|
|
if err := os.MkdirAll(beadsDir, 0755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
origWd, _ := os.Getwd()
|
|
if err := os.Chdir(tmpDir); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = os.Chdir(origWd) })
|
|
|
|
dbName := uniqueTestDBName(t)
|
|
testDBPath := filepath.Join(beadsDir, "dolt")
|
|
writeTestMetadata(t, testDBPath, dbName)
|
|
s := newTestStore(t, testDBPath)
|
|
store = s
|
|
storeMutex.Lock()
|
|
storeActive = true
|
|
storeMutex.Unlock()
|
|
t.Cleanup(func() {
|
|
store = nil
|
|
storeMutex.Lock()
|
|
storeActive = false
|
|
storeMutex.Unlock()
|
|
})
|
|
|
|
ctx := context.Background()
|
|
rootCtx = ctx
|
|
|
|
// Create regular (persistent) issues.
|
|
for i := 1; i <= 3; i++ {
|
|
id := fmt.Sprintf("duptest-regular-%d", i)
|
|
if _, err := s.DB().ExecContext(ctx,
|
|
`INSERT INTO issues (id, title, description, design, acceptance_criteria, notes, status, priority, issue_type) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
|
|
id, fmt.Sprintf("Regular issue %d", i), "", "", "", "", "open", 2, "task"); err != nil {
|
|
t.Fatalf("insert regular issue %d: %v", i, err)
|
|
}
|
|
}
|
|
|
|
// Create ephemeral wisps via the store API (routes to wisps table).
|
|
wispIDs := make(map[string]bool)
|
|
for i := 1; i <= 3; i++ {
|
|
wisp := &types.Issue{
|
|
Title: fmt.Sprintf("Wisp %d for export dedup", i),
|
|
Status: types.StatusOpen,
|
|
Priority: 2,
|
|
IssueType: types.TypeTask,
|
|
Ephemeral: true,
|
|
}
|
|
if err := s.CreateIssue(ctx, wisp, "test"); err != nil {
|
|
t.Fatalf("CreateIssue (wisp %d): %v", i, err)
|
|
}
|
|
wispIDs[wisp.ID] = true
|
|
}
|
|
|
|
// Export with --all to include everything.
|
|
exportFile := filepath.Join(tmpDir, "dedup_export.jsonl")
|
|
exportOutput = exportFile
|
|
exportAll = true
|
|
exportIncludeInfra = false
|
|
exportScrub = false
|
|
exportNoMemories = true
|
|
t.Cleanup(func() {
|
|
exportOutput = ""
|
|
exportAll = false
|
|
exportNoMemories = false
|
|
})
|
|
|
|
if err := runExport(nil, nil); err != nil {
|
|
t.Fatalf("runExport: %v", err)
|
|
}
|
|
|
|
data, err := os.ReadFile(exportFile)
|
|
if err != nil {
|
|
t.Fatalf("read export file: %v", err)
|
|
}
|
|
|
|
lines := splitJSONL(data)
|
|
|
|
// Parse every line and collect IDs.
|
|
seenIDs := make(map[string]int)
|
|
exportedWispCount := 0
|
|
for _, line := range lines {
|
|
var rec map[string]interface{}
|
|
if err := json.Unmarshal(line, &rec); err != nil {
|
|
t.Fatalf("parse exported JSONL: %v", err)
|
|
}
|
|
id, ok := rec["id"].(string)
|
|
if !ok {
|
|
continue // skip non-issue records (e.g. memories)
|
|
}
|
|
seenIDs[id]++
|
|
if wispIDs[id] {
|
|
exportedWispCount++
|
|
}
|
|
}
|
|
|
|
// Assert no duplicate IDs.
|
|
for id, count := range seenIDs {
|
|
if count > 1 {
|
|
t.Errorf("duplicate export entry for ID %q: appeared %d times", id, count)
|
|
}
|
|
}
|
|
|
|
// Assert all wisps are present exactly once.
|
|
if exportedWispCount != len(wispIDs) {
|
|
t.Errorf("expected %d wisps in export, got %d", len(wispIDs), exportedWispCount)
|
|
}
|
|
|
|
// Assert total count = 3 regular + 3 wisps = 6.
|
|
expectedTotal := 6
|
|
if len(seenIDs) != expectedTotal {
|
|
t.Errorf("expected %d unique issues in export, got %d", expectedTotal, len(seenIDs))
|
|
}
|
|
}
|
|
|
|
func TestExportExcludesMemoriesByDefault(t *testing.T) {
|
|
// GH#3650: bd export must exclude memories by default because they may
|
|
// contain sensitive agent context. Only --include-memories or --all
|
|
// should include them.
|
|
if testDoltServerPort == 0 {
|
|
t.Skip("Dolt test server not available")
|
|
}
|
|
if testutil.DoltContainerCrashed() {
|
|
t.Skipf("Dolt test server crashed: %v", testutil.DoltContainerCrashError())
|
|
}
|
|
|
|
ensureTestMode(t)
|
|
saved := saveAndRestoreGlobals(t)
|
|
_ = saved
|
|
|
|
tmpDir := t.TempDir()
|
|
beadsDir := filepath.Join(tmpDir, ".beads")
|
|
if err := os.MkdirAll(beadsDir, 0755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
origWd, _ := os.Getwd()
|
|
if err := os.Chdir(tmpDir); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = os.Chdir(origWd) })
|
|
|
|
dbName := uniqueTestDBName(t)
|
|
testDBPath := filepath.Join(beadsDir, "dolt")
|
|
writeTestMetadata(t, testDBPath, dbName)
|
|
s := newTestStore(t, testDBPath)
|
|
store = s
|
|
storeMutex.Lock()
|
|
storeActive = true
|
|
storeMutex.Unlock()
|
|
t.Cleanup(func() {
|
|
store = nil
|
|
storeMutex.Lock()
|
|
storeActive = false
|
|
storeMutex.Unlock()
|
|
})
|
|
|
|
ctx := context.Background()
|
|
rootCtx = ctx
|
|
|
|
// Create a persistent issue.
|
|
if _, err := s.DB().ExecContext(ctx,
|
|
`INSERT INTO issues (id, title, description, design, acceptance_criteria, notes, status, priority, issue_type) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
|
|
"memexcl-1", "Regular issue", "", "", "", "", "open", 2, "task"); err != nil {
|
|
t.Fatalf("insert issue: %v", err)
|
|
}
|
|
|
|
// Seed memories.
|
|
for _, mk := range []string{"secret-api-pattern", "debug-session-notes"} {
|
|
storageKey := "kv.memory." + mk
|
|
if err := s.SetConfig(ctx, storageKey, "sensitive-value-for-"+mk); err != nil {
|
|
t.Fatalf("SetConfig(%s): %v", storageKey, err)
|
|
}
|
|
}
|
|
|
|
countMemoryLines := func(data []byte) int {
|
|
count := 0
|
|
scanner := bufio.NewScanner(strings.NewReader(string(data)))
|
|
for scanner.Scan() {
|
|
var rec map[string]interface{}
|
|
if err := json.Unmarshal(scanner.Bytes(), &rec); err != nil {
|
|
continue
|
|
}
|
|
if rec["_type"] == "memory" {
|
|
count++
|
|
}
|
|
}
|
|
return count
|
|
}
|
|
|
|
// Default export: memories must be excluded.
|
|
defaultFile := filepath.Join(tmpDir, "default_export.jsonl")
|
|
exportOutput = defaultFile
|
|
exportAll = false
|
|
exportIncludeInfra = false
|
|
exportScrub = false
|
|
exportNoMemories = false
|
|
exportIncludeMemories = false
|
|
|
|
if err := runExport(nil, nil); err != nil {
|
|
t.Fatalf("runExport (default): %v", err)
|
|
}
|
|
defaultData, err := os.ReadFile(defaultFile)
|
|
if err != nil {
|
|
t.Fatalf("read default export: %v", err)
|
|
}
|
|
if n := countMemoryLines(defaultData); n != 0 {
|
|
t.Errorf("default export: expected 0 memory lines, got %d", n)
|
|
}
|
|
|
|
// --include-memories: memories must appear.
|
|
includeFile := filepath.Join(tmpDir, "include_export.jsonl")
|
|
exportOutput = includeFile
|
|
exportIncludeMemories = true
|
|
if err := runExport(nil, nil); err != nil {
|
|
t.Fatalf("runExport (--include-memories): %v", err)
|
|
}
|
|
includeData, err := os.ReadFile(includeFile)
|
|
if err != nil {
|
|
t.Fatalf("read --include-memories export: %v", err)
|
|
}
|
|
if n := countMemoryLines(includeData); n != 2 {
|
|
t.Errorf("--include-memories export: expected 2 memory lines, got %d", n)
|
|
}
|
|
|
|
// --all: memories must also appear.
|
|
allFile := filepath.Join(tmpDir, "all_export.jsonl")
|
|
exportOutput = allFile
|
|
exportAll = true
|
|
exportIncludeMemories = false
|
|
if err := runExport(nil, nil); err != nil {
|
|
t.Fatalf("runExport (--all): %v", err)
|
|
}
|
|
allData, err := os.ReadFile(allFile)
|
|
if err != nil {
|
|
t.Fatalf("read --all export: %v", err)
|
|
}
|
|
if n := countMemoryLines(allData); n != 2 {
|
|
t.Errorf("--all export: expected 2 memory lines, got %d", n)
|
|
}
|
|
}
|
|
|
|
func TestExportExcludesWispsByDefault(t *testing.T) {
|
|
// GH#3649: bd export must exclude ephemeral wisps by default.
|
|
// Wisps are private/transient and must not reach git history.
|
|
// Only --all should include them.
|
|
if testDoltServerPort == 0 {
|
|
t.Skip("Dolt test server not available")
|
|
}
|
|
if testutil.DoltContainerCrashed() {
|
|
t.Skipf("Dolt test server crashed: %v", testutil.DoltContainerCrashError())
|
|
}
|
|
|
|
ensureTestMode(t)
|
|
saved := saveAndRestoreGlobals(t)
|
|
_ = saved
|
|
|
|
tmpDir := t.TempDir()
|
|
beadsDir := filepath.Join(tmpDir, ".beads")
|
|
if err := os.MkdirAll(beadsDir, 0755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
origWd, _ := os.Getwd()
|
|
if err := os.Chdir(tmpDir); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = os.Chdir(origWd) })
|
|
|
|
dbName := uniqueTestDBName(t)
|
|
testDBPath := filepath.Join(beadsDir, "dolt")
|
|
writeTestMetadata(t, testDBPath, dbName)
|
|
s := newTestStore(t, testDBPath)
|
|
store = s
|
|
storeMutex.Lock()
|
|
storeActive = true
|
|
storeMutex.Unlock()
|
|
t.Cleanup(func() {
|
|
store = nil
|
|
storeMutex.Lock()
|
|
storeActive = false
|
|
storeMutex.Unlock()
|
|
})
|
|
|
|
ctx := context.Background()
|
|
rootCtx = ctx
|
|
|
|
// Create persistent issues.
|
|
for i := 1; i <= 2; i++ {
|
|
id := fmt.Sprintf("wispexcl-regular-%d", i)
|
|
if _, err := s.DB().ExecContext(ctx,
|
|
`INSERT INTO issues (id, title, description, design, acceptance_criteria, notes, status, priority, issue_type) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
|
|
id, fmt.Sprintf("Persistent issue %d", i), "", "", "", "", "open", 2, "task"); err != nil {
|
|
t.Fatalf("insert persistent issue %d: %v", i, err)
|
|
}
|
|
}
|
|
|
|
// Create ephemeral wisps via the store API (routes to wisps table).
|
|
for i := 1; i <= 3; i++ {
|
|
wisp := &types.Issue{
|
|
Title: fmt.Sprintf("Private wisp %d", i),
|
|
Status: types.StatusOpen,
|
|
Priority: 2,
|
|
IssueType: types.TypeTask,
|
|
Ephemeral: true,
|
|
}
|
|
if err := s.CreateIssue(ctx, wisp, "test"); err != nil {
|
|
t.Fatalf("CreateIssue (wisp %d): %v", i, err)
|
|
}
|
|
}
|
|
|
|
// Default export (no --all): wisps must be excluded.
|
|
exportFile := filepath.Join(tmpDir, "default_export.jsonl")
|
|
exportOutput = exportFile
|
|
exportAll = false
|
|
exportIncludeInfra = false
|
|
exportScrub = false
|
|
exportNoMemories = true
|
|
t.Cleanup(func() {
|
|
exportOutput = ""
|
|
exportAll = false
|
|
exportNoMemories = false
|
|
})
|
|
|
|
if err := runExport(nil, nil); err != nil {
|
|
t.Fatalf("runExport (default): %v", err)
|
|
}
|
|
|
|
data, err := os.ReadFile(exportFile)
|
|
if err != nil {
|
|
t.Fatalf("read default export: %v", err)
|
|
}
|
|
defaultLines := splitJSONL(data)
|
|
for _, line := range defaultLines {
|
|
var rec map[string]interface{}
|
|
if err := json.Unmarshal(line, &rec); err != nil {
|
|
t.Fatalf("parse: %v", err)
|
|
}
|
|
if ephemeral, ok := rec["ephemeral"].(bool); ok && ephemeral {
|
|
t.Errorf("default export contains ephemeral wisp: %s", rec["id"])
|
|
}
|
|
}
|
|
if len(defaultLines) != 2 {
|
|
t.Errorf("default export: expected 2 persistent issues, got %d lines", len(defaultLines))
|
|
}
|
|
|
|
// --all export: wisps must be included.
|
|
allFile := filepath.Join(tmpDir, "all_export.jsonl")
|
|
exportOutput = allFile
|
|
exportAll = true
|
|
if err := runExport(nil, nil); err != nil {
|
|
t.Fatalf("runExport (--all): %v", err)
|
|
}
|
|
allData, err := os.ReadFile(allFile)
|
|
if err != nil {
|
|
t.Fatalf("read --all export: %v", err)
|
|
}
|
|
allLines := splitJSONL(allData)
|
|
if len(allLines) != 5 {
|
|
t.Errorf("--all export: expected 5 issues (2 persistent + 3 wisps), got %d", len(allLines))
|
|
}
|
|
}
|