Adds issueops.Lifecycle — Create, Update, Close, Reopen — reached from the storage handle via store.IssueLifecycle(), implemented once and shared by the CLI and linked library consumers. Three backends implement it and a shared conformance suite asserts them against one spec. The bd CLI's create, update, close and reopen now route through it. Fixes several defects that predate this change and became visible once the write paths were forced to agree: swallowed metadata-edit failures, a claim applied before field validation, missing value validation on title/priority/estimate, silently dropped create edges to missing targets, infra-typed creates landing in the wrong table, a dropped SourceRepo, closed_by_session written but never read, and a compound update writing twice. Behavior changes needing release notes: create with an occupied explicit id now fails instead of silently overwriting; a compound update is one atomic operation with one hook and one version commit; reparenting replaces all parent edges; reopening something not closed reports nothing to do.
438 lines
13 KiB
Go
438 lines
13 KiB
Go
//go:build cgo
|
|
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/steveyegge/beads/internal/types"
|
|
)
|
|
|
|
// TestMessagingSuite consolidates message lifecycle, dependency types, and thread tests.
|
|
// All subtests share one DB since they create unique IDs and don't conflict.
|
|
func TestMessagingSuite(t *testing.T) {
|
|
t.Parallel()
|
|
tmpDir := t.TempDir()
|
|
testStore := newTestStore(t, filepath.Join(tmpDir, ".beads", "beads.db"))
|
|
ctx := context.Background()
|
|
now := time.Now()
|
|
|
|
// === Lifecycle data ===
|
|
lifecycleMsg := &types.Issue{
|
|
ID: "msg-lifecycle", Title: "Build failed on main",
|
|
Description: "CI pipeline reports failure on commit abc123",
|
|
Status: types.StatusOpen, Priority: 1, IssueType: "message",
|
|
Sender: "ci-bot", Assignee: "dev-team", Ephemeral: true,
|
|
CreatedAt: now, UpdatedAt: now,
|
|
}
|
|
|
|
// === SearchByType data ===
|
|
searchTask := &types.Issue{
|
|
ID: "msg-search-task", Title: "Regular task (search)",
|
|
Status: types.StatusOpen, Priority: 2, IssueType: types.TypeTask,
|
|
CreatedAt: now, UpdatedAt: now,
|
|
}
|
|
searchMsg := &types.Issue{
|
|
ID: "msg-search-msg", Title: "Agent notification (search)",
|
|
Status: types.StatusOpen, Priority: 2, IssueType: "message",
|
|
Sender: "coordinator", Assignee: "worker-1", Ephemeral: true,
|
|
CreatedAt: now.Add(time.Second), UpdatedAt: now.Add(time.Second),
|
|
}
|
|
|
|
// === Supersedes data ===
|
|
v1 := &types.Issue{
|
|
ID: "msg-v1", Title: "Design Doc v1", Description: "Initial design for feature X",
|
|
Status: types.StatusClosed, Priority: 2, IssueType: types.TypeTask,
|
|
CreatedAt: now, UpdatedAt: now,
|
|
}
|
|
v2 := &types.Issue{
|
|
ID: "msg-v2", Title: "Design Doc v2", Description: "Revised design for feature X",
|
|
Status: types.StatusOpen, Priority: 2, IssueType: types.TypeTask,
|
|
CreatedAt: now.Add(time.Hour), UpdatedAt: now.Add(time.Hour),
|
|
}
|
|
|
|
// === Duplicates data ===
|
|
canonical := &types.Issue{
|
|
ID: "msg-canonical", Title: "Auth login fails with SSO",
|
|
Description: "Users can't login via SSO",
|
|
Status: types.StatusOpen, Priority: 1, IssueType: types.TypeBug,
|
|
CreatedAt: now, UpdatedAt: now,
|
|
}
|
|
dup := &types.Issue{
|
|
ID: "msg-dup", Title: "SSO login broken",
|
|
Description: "Single sign-on authentication not working",
|
|
Status: types.StatusOpen, Priority: 1, IssueType: types.TypeBug,
|
|
CreatedAt: now.Add(time.Minute), UpdatedAt: now.Add(time.Minute),
|
|
}
|
|
|
|
// === Thread data ===
|
|
threadOrig := &types.Issue{
|
|
ID: "msg-thread-orig", Title: "Sprint planning discussion",
|
|
Description: "Let's plan the next sprint",
|
|
Status: types.StatusOpen, Priority: 2, IssueType: "message",
|
|
Sender: "lead", Assignee: "team", Ephemeral: true,
|
|
CreatedAt: now, UpdatedAt: now,
|
|
}
|
|
threadReply1 := &types.Issue{
|
|
ID: "msg-thread-r1", Title: "Re: Sprint planning",
|
|
Description: "I can take the auth refactor",
|
|
Status: types.StatusOpen, Priority: 2, IssueType: "message",
|
|
Sender: "worker-1", Assignee: "lead", Ephemeral: true,
|
|
CreatedAt: now.Add(time.Minute), UpdatedAt: now.Add(time.Minute),
|
|
}
|
|
threadReply2 := &types.Issue{
|
|
ID: "msg-thread-r2", Title: "Re: Sprint planning",
|
|
Description: "I'll handle the database migration",
|
|
Status: types.StatusOpen, Priority: 2, IssueType: "message",
|
|
Sender: "worker-2", Assignee: "lead", Ephemeral: true,
|
|
CreatedAt: now.Add(2 * time.Minute), UpdatedAt: now.Add(2 * time.Minute),
|
|
}
|
|
|
|
// === Ephemeral cleanup data ===
|
|
permTask := &types.Issue{
|
|
ID: "msg-perm-task", Title: "Permanent task (eph)",
|
|
Status: types.StatusClosed, Priority: 2, IssueType: types.TypeTask,
|
|
CreatedAt: now, UpdatedAt: now,
|
|
}
|
|
closedEph := &types.Issue{
|
|
ID: "msg-closed-eph", Title: "Old notification (eph)",
|
|
Status: types.StatusClosed, Priority: 3, IssueType: "message",
|
|
Sender: "bot", Ephemeral: true, CreatedAt: now, UpdatedAt: now,
|
|
}
|
|
openEph := &types.Issue{
|
|
ID: "msg-open-eph", Title: "Unread notification (eph)",
|
|
Status: types.StatusOpen, Priority: 2, IssueType: "message",
|
|
Sender: "bot", Ephemeral: true, CreatedAt: now, UpdatedAt: now,
|
|
}
|
|
|
|
// === Sender preservation data ===
|
|
senderMsg := &types.Issue{
|
|
ID: "msg-sender", Title: "Status update",
|
|
Status: types.StatusOpen, Priority: 3, IssueType: "message",
|
|
Sender: "agent-alpha", Assignee: "agent-beta",
|
|
CreatedAt: now, UpdatedAt: now,
|
|
}
|
|
|
|
// Bulk create all issues
|
|
allIssues := []*types.Issue{
|
|
lifecycleMsg, searchTask, searchMsg, v1, v2, canonical, dup,
|
|
threadOrig, threadReply1, threadReply2,
|
|
permTask, closedEph, openEph, senderMsg,
|
|
}
|
|
for _, issue := range allIssues {
|
|
if err := testStore.CreateIssue(ctx, issue, "test"); err != nil {
|
|
t.Fatalf("CreateIssue(%s): %v", issue.ID, err)
|
|
}
|
|
}
|
|
|
|
// Add supersedes dep
|
|
if err := testStore.AddDependency(ctx, &types.Dependency{
|
|
IssueID: v2.ID, DependsOnID: v1.ID, Type: types.DepSupersedes, CreatedAt: now.Add(time.Hour),
|
|
}, "test"); err != nil {
|
|
t.Fatalf("AddDep(supersedes): %v", err)
|
|
}
|
|
|
|
// Add duplicates dep
|
|
if err := testStore.AddDependency(ctx, &types.Dependency{
|
|
IssueID: dup.ID, DependsOnID: canonical.ID, Type: types.DepDuplicates, CreatedAt: now.Add(time.Minute),
|
|
}, "test"); err != nil {
|
|
t.Fatalf("AddDep(duplicates): %v", err)
|
|
}
|
|
// Close the duplicate
|
|
if err := testStore.CloseIssue(ctx, dup.ID, "duplicate", "test", ""); err != nil {
|
|
t.Fatalf("Close dup: %v", err)
|
|
}
|
|
|
|
// Add thread reply deps
|
|
for _, reply := range []*types.Issue{threadReply1, threadReply2} {
|
|
if err := testStore.AddDependency(ctx, &types.Dependency{
|
|
IssueID: reply.ID, DependsOnID: threadOrig.ID, Type: types.DepRepliesTo, CreatedAt: reply.CreatedAt,
|
|
}, "test"); err != nil {
|
|
t.Fatalf("AddDep(replies-to): %v", err)
|
|
}
|
|
}
|
|
|
|
// === Tests ===
|
|
|
|
t.Run("MessageLifecycle", func(t *testing.T) {
|
|
got, err := testStore.GetIssue(ctx, lifecycleMsg.ID)
|
|
if err != nil {
|
|
t.Fatalf("GetIssue: %v", err)
|
|
}
|
|
if got.IssueType != "message" {
|
|
t.Errorf("IssueType = %q, want message", got.IssueType)
|
|
}
|
|
if got.Sender != "ci-bot" {
|
|
t.Errorf("Sender = %q, want ci-bot", got.Sender)
|
|
}
|
|
if !got.Ephemeral {
|
|
t.Error("Expected Ephemeral=true")
|
|
}
|
|
|
|
// Close (ack)
|
|
if err := testStore.CloseIssue(ctx, lifecycleMsg.ID, "acknowledged", "test", ""); err != nil {
|
|
t.Fatalf("CloseIssue (ack): %v", err)
|
|
}
|
|
acked, err := testStore.GetIssue(ctx, lifecycleMsg.ID)
|
|
if err != nil {
|
|
t.Fatalf("GetIssue after ack: %v", err)
|
|
}
|
|
if acked.Status != types.StatusClosed {
|
|
t.Errorf("Status after ack = %q, want closed", acked.Status)
|
|
}
|
|
})
|
|
|
|
t.Run("SearchByType", func(t *testing.T) {
|
|
msgType := types.IssueType("message")
|
|
results, err := testStore.SearchIssues(ctx, "", types.IssueFilter{IssueType: &msgType})
|
|
if err != nil {
|
|
t.Fatalf("SearchIssues: %v", err)
|
|
}
|
|
// Verify our search message is in results
|
|
found := false
|
|
for _, r := range results {
|
|
if r.ID == searchMsg.ID {
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
if !found {
|
|
t.Error("Expected search message in type=message results")
|
|
}
|
|
// Verify task is NOT in results
|
|
for _, r := range results {
|
|
if r.ID == searchTask.ID {
|
|
t.Error("Task should not appear in type=message results")
|
|
}
|
|
}
|
|
})
|
|
|
|
t.Run("SupersedesLink", func(t *testing.T) {
|
|
deps, err := testStore.GetDependencyRecords(ctx, v2.ID)
|
|
if err != nil {
|
|
t.Fatalf("GetDependencyRecords: %v", err)
|
|
}
|
|
found := false
|
|
for _, d := range deps {
|
|
if d.DependsOnID == v1.ID && d.Type == types.DepSupersedes {
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
if !found {
|
|
t.Error("Expected v2 to have supersedes link to v1")
|
|
}
|
|
|
|
// Supersedes should NOT block
|
|
blocked, err := testStore.GetBlockedIssues(ctx, types.WorkFilter{})
|
|
if err != nil {
|
|
t.Fatalf("GetBlockedIssues: %v", err)
|
|
}
|
|
for _, b := range blocked {
|
|
if b.ID == v2.ID {
|
|
t.Error("v2 should NOT be blocked by supersedes link")
|
|
}
|
|
}
|
|
})
|
|
|
|
t.Run("DuplicatesLink", func(t *testing.T) {
|
|
deps, err := testStore.GetDependencyRecords(ctx, dup.ID)
|
|
if err != nil {
|
|
t.Fatalf("GetDependencyRecords: %v", err)
|
|
}
|
|
found := false
|
|
for _, d := range deps {
|
|
if d.DependsOnID == canonical.ID && d.Type == types.DepDuplicates {
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
if !found {
|
|
t.Error("Expected dup to have duplicates link to canonical")
|
|
}
|
|
|
|
got, err := testStore.GetIssue(ctx, canonical.ID)
|
|
if err != nil {
|
|
t.Fatalf("GetIssue canonical: %v", err)
|
|
}
|
|
if got.Status != types.StatusOpen {
|
|
t.Errorf("Canonical should still be open, got %s", got.Status)
|
|
}
|
|
})
|
|
|
|
t.Run("ThreadMultipleReplies", func(t *testing.T) {
|
|
dependents, err := testStore.GetDependents(ctx, threadOrig.ID)
|
|
if err != nil {
|
|
t.Fatalf("GetDependents: %v", err)
|
|
}
|
|
replyCount := 0
|
|
for _, dep := range dependents {
|
|
if dep.ID == threadReply1.ID || dep.ID == threadReply2.ID {
|
|
replyCount++
|
|
}
|
|
}
|
|
if replyCount != 2 {
|
|
t.Errorf("Expected 2 replies, got %d", replyCount)
|
|
}
|
|
|
|
// replies-to should NOT block
|
|
blocked, err := testStore.GetBlockedIssues(ctx, types.WorkFilter{})
|
|
if err != nil {
|
|
t.Fatalf("GetBlockedIssues: %v", err)
|
|
}
|
|
for _, b := range blocked {
|
|
if b.ID == threadReply1.ID || b.ID == threadReply2.ID {
|
|
t.Errorf("Reply %s should NOT be blocked by replies-to", b.ID)
|
|
}
|
|
}
|
|
})
|
|
|
|
t.Run("EphemeralCleanup", func(t *testing.T) {
|
|
// Search for closed ephemeral issues
|
|
statusClosed := types.StatusClosed
|
|
ephTrue := true
|
|
filter := types.IssueFilter{Status: &statusClosed, Ephemeral: &ephTrue}
|
|
closedEphResults, err := testStore.SearchIssues(ctx, "", filter)
|
|
if err != nil {
|
|
t.Fatalf("SearchIssues: %v", err)
|
|
}
|
|
|
|
// Our closedEph should be in results
|
|
found := false
|
|
for _, r := range closedEphResults {
|
|
if r.ID == closedEph.ID {
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
if !found {
|
|
t.Error("Expected closed ephemeral message in results")
|
|
}
|
|
|
|
// Delete it
|
|
result, err := testStore.DeleteIssues(ctx, []string{closedEph.ID}, false, true, false)
|
|
if err != nil {
|
|
t.Fatalf("DeleteIssues: %v", err)
|
|
}
|
|
if result.DeletedCount != 1 {
|
|
t.Errorf("DeletedCount = %d, want 1", result.DeletedCount)
|
|
}
|
|
|
|
// Verify permanent task still exists
|
|
if _, err := testStore.GetIssue(ctx, permTask.ID); err != nil {
|
|
t.Errorf("Permanent task should survive cleanup: %v", err)
|
|
}
|
|
// Verify open ephemeral still exists
|
|
if _, err := testStore.GetIssue(ctx, openEph.ID); err != nil {
|
|
t.Errorf("Open ephemeral should survive cleanup: %v", err)
|
|
}
|
|
})
|
|
|
|
t.Run("SenderPreservation", func(t *testing.T) {
|
|
if err := testStore.UpdateIssue(ctx, senderMsg.ID, map[string]interface{}{
|
|
"description": "Updated status details",
|
|
}, "test"); err != nil {
|
|
t.Fatalf("UpdateIssue: %v", err)
|
|
}
|
|
|
|
got, err := testStore.GetIssue(ctx, senderMsg.ID)
|
|
if err != nil {
|
|
t.Fatalf("GetIssue: %v", err)
|
|
}
|
|
if got.Sender != "agent-alpha" {
|
|
t.Errorf("Sender = %q after update, want agent-alpha", got.Sender)
|
|
}
|
|
if got.Description != "Updated status details" {
|
|
t.Errorf("Description not updated, got %q", got.Description)
|
|
}
|
|
})
|
|
}
|
|
|
|
// TestFindMailDelegate tests the mail delegate resolution logic.
|
|
// Kept separate because it modifies global state (env vars, store).
|
|
func TestFindMailDelegate(t *testing.T) {
|
|
origBeads := os.Getenv("BEADS_MAIL_DELEGATE")
|
|
origBD := os.Getenv("BD_MAIL_DELEGATE")
|
|
defer func() {
|
|
os.Setenv("BEADS_MAIL_DELEGATE", origBeads)
|
|
os.Setenv("BD_MAIL_DELEGATE", origBD)
|
|
}()
|
|
|
|
t.Run("BEADS_MAIL_DELEGATE takes priority", func(t *testing.T) {
|
|
os.Setenv("BEADS_MAIL_DELEGATE", "gt mail")
|
|
os.Setenv("BD_MAIL_DELEGATE", "other mail")
|
|
defer func() {
|
|
os.Unsetenv("BEADS_MAIL_DELEGATE")
|
|
os.Unsetenv("BD_MAIL_DELEGATE")
|
|
}()
|
|
|
|
got := findMailDelegate()
|
|
if got != "gt mail" {
|
|
t.Errorf("findMailDelegate() = %q, want \"gt mail\"", got)
|
|
}
|
|
})
|
|
|
|
t.Run("BD_MAIL_DELEGATE fallback", func(t *testing.T) {
|
|
os.Unsetenv("BEADS_MAIL_DELEGATE")
|
|
os.Setenv("BD_MAIL_DELEGATE", "custom mail")
|
|
defer os.Unsetenv("BD_MAIL_DELEGATE")
|
|
|
|
got := findMailDelegate()
|
|
if got != "custom mail" {
|
|
t.Errorf("findMailDelegate() = %q, want \"custom mail\"", got)
|
|
}
|
|
})
|
|
|
|
t.Run("no delegate returns empty", func(t *testing.T) {
|
|
os.Unsetenv("BEADS_MAIL_DELEGATE")
|
|
os.Unsetenv("BD_MAIL_DELEGATE")
|
|
|
|
oldStore := store
|
|
store = nil
|
|
defer func() { store = oldStore }()
|
|
|
|
got := findMailDelegate()
|
|
if got != "" {
|
|
t.Errorf("findMailDelegate() = %q, want empty string", got)
|
|
}
|
|
})
|
|
}
|
|
|
|
// TestMailDelegateFromConfig tests mail delegate resolution from store config.
|
|
// Kept separate because it modifies global store and rootCtx.
|
|
func TestMailDelegateFromConfig(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
testStore := newTestStore(t, filepath.Join(tmpDir, ".beads", "beads.db"))
|
|
ctx := context.Background()
|
|
|
|
if err := testStore.SetConfig(ctx, "mail.delegate", "gt mail"); err != nil {
|
|
t.Fatalf("SetConfig failed: %v", err)
|
|
}
|
|
|
|
origBeads := os.Getenv("BEADS_MAIL_DELEGATE")
|
|
origBD := os.Getenv("BD_MAIL_DELEGATE")
|
|
os.Unsetenv("BEADS_MAIL_DELEGATE")
|
|
os.Unsetenv("BD_MAIL_DELEGATE")
|
|
defer func() {
|
|
os.Setenv("BEADS_MAIL_DELEGATE", origBeads)
|
|
os.Setenv("BD_MAIL_DELEGATE", origBD)
|
|
}()
|
|
|
|
oldStore := store
|
|
oldCtx := rootCtx
|
|
store = testStore
|
|
rootCtx = ctx
|
|
defer func() {
|
|
store = oldStore
|
|
rootCtx = oldCtx
|
|
}()
|
|
|
|
got := findMailDelegate()
|
|
if got != "gt mail" {
|
|
t.Errorf("findMailDelegate() = %q, want \"gt mail\"", got)
|
|
}
|
|
}
|