beads/cmd/bd/protocol/preservation_test.go
beads/refinery c8f61cb208 fix(tests): align tests with cross-type blocking validation
- Protocol tests: use `comments add` instead of nonexistent `comment` command
- critical_paths_test: use epic (not task) for epic-blocks-epic relationship
- template_test: use DepRelated instead of DepBlocks for cross-type "wrong dep"
  scenarios, since cross-type blocking is now rejected by storage validation

Fixes tests broken by the cross-type blocking validation added in GH#1495.

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

Executed-By: beads/refinery
Rig: beads
Role: refinery
2026-03-03 11:05:50 -08:00

181 lines
6.1 KiB
Go

package protocol
import "testing"
// TestProtocol_LabelsPreservedAcrossUpdate asserts that labels added to an
// issue are not lost when the issue is updated.
func TestProtocol_LabelsPreservedAcrossUpdate(t *testing.T) {
t.Parallel()
w := newWorkspace(t)
id := w.create("--title", "Labeled issue", "--type", "task")
w.run("label", "add", id, "frontend")
w.run("label", "add", id, "urgent")
// Update an unrelated field
w.run("update", id, "--title", "Labeled issue (renamed)")
issue := w.showJSON(id)
requireStringSetEqual(t, getStringSlice(issue, "labels"),
[]string{"frontend", "urgent"}, "labels after title update")
}
// TestProtocol_DepsPreservedAcrossUpdate asserts that dependencies are not
// lost when an issue is updated.
func TestProtocol_DepsPreservedAcrossUpdate(t *testing.T) {
t.Parallel()
w := newWorkspace(t)
idA := w.create("--title", "Blocker", "--type", "task")
idB := w.create("--title", "Blocked", "--type", "task")
w.run("dep", "add", idB, idA)
// Update an unrelated field
w.run("update", idB, "--title", "Blocked (renamed)")
issue := w.showJSON(idB)
requireDepEdgesEqual(t, getObjectSlice(issue, "dependencies"),
[]depEdge{{issueID: idB, dependsOnID: idA}}, "deps after title update")
}
// TestProtocol_CommentsPreservedAcrossUpdate asserts that comments are not
// lost when an issue is updated.
func TestProtocol_CommentsPreservedAcrossUpdate(t *testing.T) {
t.Parallel()
w := newWorkspace(t)
id := w.create("--title", "Commented issue", "--type", "task")
w.run("comments", "add", id, "Important design note")
w.run("comments", "add", id, "Follow-up from review")
// Update an unrelated field
w.run("update", id, "--title", "Commented issue (renamed)")
issue := w.showJSON(id)
requireCommentTextsEqual(t, getObjectSlice(issue, "comments"),
[]string{"Important design note", "Follow-up from review"},
"comments after title update")
}
// TestProtocol_ScalarUpdatePreservesRelationalData asserts that updating
// scalar fields (title, priority, description, assignee, notes) does NOT
// silently drop labels, dependencies, or comments from an issue.
//
// Invariant: for any issue with labels L, deps D, and comments C,
// running bd update <id> --title "..." must leave L, D, and C unchanged.
//
// This is the single most important data-integrity invariant. A violation
// means any routine update can cause silent data loss.
func TestProtocol_ScalarUpdatePreservesRelationalData(t *testing.T) {
t.Parallel()
w := newWorkspace(t)
id1 := w.create("--title", "Data-rich issue", "--type", "feature", "--priority", "1")
id2 := w.create("--title", "Dep target", "--type", "task")
// Set up relational data
w.run("label", "add", id1, "important")
w.run("label", "add", id1, "v2")
w.run("label", "add", id1, "frontend")
w.run("dep", "add", id1, id2)
w.run("comments", "add", id1, "Design review notes")
w.run("comments", "add", id1, "Implementation started")
// Rapid-fire scalar updates — each must preserve relational data
w.run("update", id1, "--title", "Data-rich issue v2")
w.run("update", id1, "--priority", "0")
w.run("update", id1, "--description", "Updated description")
w.run("update", id1, "--assignee", "alice")
w.run("update", id1, "--notes", "Updated notes")
// Verify via show --json
issue := w.showJSON(id1)
t.Run("labels_preserved", func(t *testing.T) {
requireStringSetEqual(t, getStringSlice(issue, "labels"),
[]string{"important", "v2", "frontend"},
"labels after 5 scalar updates")
})
t.Run("deps_preserved", func(t *testing.T) {
requireDepEdgesEqual(t, getObjectSlice(issue, "dependencies"),
[]depEdge{{issueID: id1, dependsOnID: id2}},
"deps after 5 scalar updates")
})
t.Run("comments_preserved", func(t *testing.T) {
requireCommentTextsEqual(t, getObjectSlice(issue, "comments"),
[]string{"Design review notes", "Implementation started"},
"comments after 5 scalar updates")
})
}
// TestProtocol_StatusTransitionsPreserveLabels asserts that cycling through
// status transitions does not lose labels.
//
// Invariant: labels, deps, comments survive all status transitions.
func TestProtocol_StatusTransitionsPreserveLabels(t *testing.T) {
t.Parallel()
w := newWorkspace(t)
a := w.create("--title", "Status cycle", "--type", "task", "--priority", "2")
w.run("label", "add", a, "test-label")
w.run("comments", "add", a, "Important note")
// open → in_progress → open → closed → reopen
w.run("update", a, "--status", "in_progress")
w.run("update", a, "--status", "open")
w.run("close", a)
w.run("reopen", a)
shown := w.showJSON(a)
// Labels preserved
labels := getStringSlice(shown, "labels")
if len(labels) != 1 || labels[0] != "test-label" {
t.Errorf("labels after status cycle: got %v, want [test-label]", labels)
}
// Comments preserved
comments := getObjectSlice(shown, "comments")
if len(comments) != 1 {
t.Errorf("comments after status cycle: got %d, want 1", len(comments))
}
}
// TestProtocol_DeleteCleansUpDeps asserts that deleting an issue removes
// all references to it from other issues' dependency lists.
//
// Invariant: after bd delete X, no other issue should have X in its
// dependencies as shown by bd show --json.
func TestProtocol_DeleteCleansUpDeps(t *testing.T) {
t.Parallel()
w := newWorkspace(t)
idA := w.create("--title", "Survivor A", "--type", "task")
idB := w.create("--title", "Will be deleted", "--type", "task")
idC := w.create("--title", "Survivor C", "--type", "task")
w.run("dep", "add", idB, idA) // B depends on A
w.run("dep", "add", idC, idB) // C depends on B
w.run("delete", idB, "--force")
// B should not be queryable after deletion
_, err := w.tryRun("show", idB, "--json")
if err == nil {
t.Errorf("deleted issue %s should not be queryable via show", idB)
}
// Surviving issues should not reference B in their dependencies
for _, survivorID := range []string{idA, idC} {
issue := w.showJSON(survivorID)
deps := getObjectSlice(issue, "dependencies")
for _, dep := range deps {
depID, _ := dep["depends_on_id"].(string)
if depID == "" {
depID, _ = dep["id"].(string)
}
if depID == idB {
t.Errorf("issue %s still has dangling dependency on deleted %s", survivorID, idB)
}
}
}
}