huskies: merge 842

server/src/http/workflow/bug_ops/tests.rs

@@ -0,0 +1,487 @@
+//! Tests for bug, spike, and refactor pipeline-item operations.
+
+use super::bug::{create_bug_file, extract_bug_name_from_content, list_bug_files};
+use super::refactor::{create_refactor_file, list_refactor_files};
+use super::spike::create_spike_file;
+use crate::io::story_metadata::parse_front_matter;
+use std::fs;
+
+fn setup_git_repo(root: &std::path::Path) {
+    std::process::Command::new("git")
+        .args(["init"])
+        .current_dir(root)
+        .output()
+        .unwrap();
+    std::process::Command::new("git")
+        .args(["config", "user.email", "test@test.com"])
+        .current_dir(root)
+        .output()
+        .unwrap();
+    std::process::Command::new("git")
+        .args(["config", "user.name", "Test"])
+        .current_dir(root)
+        .output()
+        .unwrap();
+    std::process::Command::new("git")
+        .args(["commit", "--allow-empty", "-m", "init"])
+        .current_dir(root)
+        .output()
+        .unwrap();
+}
+
+// ── Bug file helper tests ──────────────────────────────────────────────────
+
+#[test]
+fn next_item_number_starts_at_1_when_empty_bugs() {
+    let tmp = tempfile::tempdir().unwrap();
+    assert!(super::super::next_item_number(tmp.path()).unwrap() >= 1);
+}
+
+#[test]
+fn next_item_number_increments_from_existing_bugs() {
+    crate::db::ensure_content_store();
+    let tmp = tempfile::tempdir().unwrap();
+    let backlog = tmp.path().join(".huskies/work/1_backlog");
+    fs::create_dir_all(&backlog).unwrap();
+    fs::write(backlog.join("1_bug_crash.md"), "").unwrap();
+    fs::write(backlog.join("3_bug_another.md"), "").unwrap();
+    // Also write to content store so next_item_number sees them.
+    crate::db::write_item_with_content("1_bug_crash", "1_backlog", "---\nname: Crash\n---\n");
+    crate::db::write_item_with_content("3_bug_another", "1_backlog", "---\nname: Another\n---\n");
+    assert!(super::super::next_item_number(tmp.path()).unwrap() >= 4);
+}
+
+#[test]
+fn next_item_number_scans_archived_too() {
+    crate::db::ensure_content_store();
+    let tmp = tempfile::tempdir().unwrap();
+    let backlog = tmp.path().join(".huskies/work/1_backlog");
+    let archived = tmp.path().join(".huskies/work/5_done");
+    fs::create_dir_all(&backlog).unwrap();
+    fs::create_dir_all(&archived).unwrap();
+    fs::write(archived.join("5_bug_old.md"), "").unwrap();
+    // Also write to content store so next_item_number sees it.
+    crate::db::write_item_with_content("5_bug_old", "5_done", "---\nname: Old Bug\n---\n");
+    assert!(super::super::next_item_number(tmp.path()).unwrap() >= 6);
+}
+
+#[test]
+fn list_bug_files_no_crash_on_missing_dir() {
+    // list_bug_files now reads from the global CRDT, not the filesystem.
+    // Verify it does not panic when called with a non-existent project root.
+    let tmp = tempfile::tempdir().unwrap();
+    let result = list_bug_files(tmp.path());
+    assert!(result.is_ok());
+}
+
+#[test]
+fn list_bug_files_excludes_archive_subdir() {
+    let tmp = tempfile::tempdir().unwrap();
+    crate::db::ensure_content_store();
+    // Bug in backlog (should appear).
+    crate::db::write_item_with_content(
+        "7001_bug_open",
+        "1_backlog",
+        "---\nname: Open Bug\n---\n# Bug 7001: Open Bug\n",
+    );
+    // Bug in done (should NOT appear — list_bug_files only returns Backlog).
+    crate::db::write_item_with_content(
+        "7002_bug_closed",
+        "5_done",
+        "---\nname: Closed Bug\n---\n# Bug 7002: Closed Bug\n",
+    );
+
+    let result = list_bug_files(tmp.path()).unwrap();
+    assert!(
+        result
+            .iter()
+            .any(|(id, name)| id == "7001_bug_open" && name == "Open Bug")
+    );
+    assert!(!result.iter().any(|(id, _)| id == "7002_bug_closed"));
+}
+
+#[test]
+fn list_bug_files_sorted_by_id() {
+    let tmp = tempfile::tempdir().unwrap();
+    crate::db::ensure_content_store();
+    crate::db::write_item_with_content(
+        "7013_bug_third",
+        "1_backlog",
+        "---\nname: Third\n---\n# Bug 7013: Third\n",
+    );
+    crate::db::write_item_with_content(
+        "7011_bug_first",
+        "1_backlog",
+        "---\nname: First\n---\n# Bug 7011: First\n",
+    );
+    crate::db::write_item_with_content(
+        "7012_bug_second",
+        "1_backlog",
+        "---\nname: Second\n---\n# Bug 7012: Second\n",
+    );
+
+    let result = list_bug_files(tmp.path()).unwrap();
+    // Find positions of our three bugs in the sorted result.
+    let pos_first = result
+        .iter()
+        .position(|(id, _)| id == "7011_bug_first")
+        .unwrap();
+    let pos_second = result
+        .iter()
+        .position(|(id, _)| id == "7012_bug_second")
+        .unwrap();
+    let pos_third = result
+        .iter()
+        .position(|(id, _)| id == "7013_bug_third")
+        .unwrap();
+    assert!(pos_first < pos_second);
+    assert!(pos_second < pos_third);
+}
+
+#[test]
+fn extract_bug_name_from_content_parses_heading() {
+    let content = "# Bug 1: Login page crashes\n\n## Description\n";
+    let name = extract_bug_name_from_content(content).unwrap();
+    assert_eq!(name, "Login page crashes");
+}
+
+#[test]
+fn create_bug_file_writes_correct_content() {
+    let tmp = tempfile::tempdir().unwrap();
+    setup_git_repo(tmp.path());
+
+    let bug_id = create_bug_file(
+        tmp.path(),
+        "Login Crash",
+        "The login page crashes on submit.",
+        "1. Go to /login\n2. Click submit",
+        "Page crashes with 500 error",
+        "Login succeeds",
+        Some(&["Login form submits without error".to_string()]),
+        None,
+    )
+    .unwrap();
+
+    assert!(
+        bug_id.chars().all(|c| c.is_ascii_digit()),
+        "bug ID must be numeric-only, got: {bug_id}"
+    );
+
+    // Check content exists (either in DB or filesystem).
+    let contents = crate::db::read_content(&bug_id)
+        .or_else(|| {
+            let filepath = tmp
+                .path()
+                .join(format!(".huskies/work/1_backlog/{bug_id}.md"));
+            fs::read_to_string(filepath).ok()
+        })
+        .expect("bug content should exist");
+
+    assert!(
+        contents.starts_with("---\ntype: bug\nname: \"Login Crash\"\n---"),
+        "bug file must start with YAML front matter including type field"
+    );
+    assert!(
+        contents.contains("Login Crash"),
+        "content should mention bug name"
+    );
+    assert!(contents.contains("## Description"));
+    assert!(contents.contains("The login page crashes on submit."));
+    assert!(contents.contains("## How to Reproduce"));
+    assert!(contents.contains("1. Go to /login"));
+    assert!(contents.contains("## Actual Result"));
+    assert!(contents.contains("Page crashes with 500 error"));
+    assert!(contents.contains("## Expected Result"));
+    assert!(contents.contains("Login succeeds"));
+    assert!(contents.contains("## Acceptance Criteria"));
+    assert!(contents.contains("- [ ] Login form submits without error"));
+}
+
+#[test]
+fn create_bug_file_rejects_empty_name() {
+    let tmp = tempfile::tempdir().unwrap();
+    let result = create_bug_file(
+        tmp.path(),
+        "!!!",
+        "desc",
+        "steps",
+        "actual",
+        "expected",
+        None,
+        None,
+    );
+    assert!(result.is_err());
+    assert!(result.unwrap_err().contains("alphanumeric"));
+}
+
+#[test]
+fn create_bug_file_uses_default_acceptance_criterion() {
+    let tmp = tempfile::tempdir().unwrap();
+    setup_git_repo(tmp.path());
+
+    let bug_id = create_bug_file(
+        tmp.path(),
+        "Some Bug",
+        "desc",
+        "steps",
+        "actual",
+        "expected",
+        None,
+        None,
+    )
+    .unwrap();
+
+    let contents = crate::db::read_content(&bug_id).expect("bug content should exist");
+
+    assert!(
+        contents.starts_with("---\ntype: bug\nname: \"Some Bug\"\n---"),
+        "bug file must have YAML front matter with type field"
+    );
+    assert!(contents.contains("- [ ] Bug is fixed and verified"));
+}
+
+// ── create_spike_file tests ────────────────────────────────────────────────
+
+#[test]
+fn create_spike_file_writes_correct_content() {
+    let tmp = tempfile::tempdir().unwrap();
+
+    let spike_id =
+        create_spike_file(tmp.path(), "Filesystem Watcher Architecture", None, &[]).unwrap();
+
+    assert!(
+        spike_id.chars().all(|c| c.is_ascii_digit()),
+        "spike ID must be numeric-only, got: {spike_id}"
+    );
+
+    let contents = crate::db::read_content(&spike_id).expect("spike content should exist");
+
+    assert!(
+        contents.starts_with("---\ntype: spike\nname: \"Filesystem Watcher Architecture\"\n---"),
+        "spike file must start with YAML front matter including type field"
+    );
+    assert!(
+        contents.contains("Filesystem Watcher Architecture"),
+        "content should mention spike name"
+    );
+    assert!(contents.contains("## Question"));
+    assert!(contents.contains("## Hypothesis"));
+    assert!(contents.contains("## Timebox"));
+    assert!(contents.contains("## Investigation Plan"));
+    assert!(contents.contains("## Findings"));
+    assert!(contents.contains("## Recommendation"));
+}
+
+#[test]
+fn create_spike_file_uses_description_when_provided() {
+    let tmp = tempfile::tempdir().unwrap();
+    let description = "What is the best approach for watching filesystem events?";
+
+    let spike_id =
+        create_spike_file(tmp.path(), "FS Watcher Spike", Some(description), &[]).unwrap();
+
+    let contents = crate::db::read_content(&spike_id)
+        .or_else(|| {
+            let filepath = tmp
+                .path()
+                .join(format!(".huskies/work/1_backlog/{spike_id}.md"));
+            fs::read_to_string(filepath).ok()
+        })
+        .expect("spike content should exist");
+    assert!(contents.contains(description));
+}
+
+#[test]
+fn create_spike_file_uses_placeholder_when_no_description() {
+    let tmp = tempfile::tempdir().unwrap();
+    let spike_id = create_spike_file(tmp.path(), "My Spike", None, &[]).unwrap();
+
+    let contents = crate::db::read_content(&spike_id)
+        .or_else(|| {
+            let filepath = tmp
+                .path()
+                .join(format!(".huskies/work/1_backlog/{spike_id}.md"));
+            fs::read_to_string(filepath).ok()
+        })
+        .expect("spike content should exist");
+    assert!(contents.contains("## Question\n\n- TBD\n"));
+}
+
+#[test]
+fn create_spike_file_rejects_empty_name() {
+    let tmp = tempfile::tempdir().unwrap();
+    let result = create_spike_file(tmp.path(), "!!!", None, &[]);
+    assert!(result.is_err());
+    assert!(result.unwrap_err().contains("alphanumeric"));
+}
+
+#[test]
+fn create_spike_file_with_special_chars_in_name_produces_valid_yaml() {
+    let tmp = tempfile::tempdir().unwrap();
+    let name = "Spike: compare \"fast\" vs slow encoders";
+    let result = create_spike_file(tmp.path(), name, None, &[]);
+    assert!(result.is_ok(), "create_spike_file failed: {result:?}");
+
+    let spike_id = result.unwrap();
+    let contents = crate::db::read_content(&spike_id)
+        .or_else(|| {
+            let backlog = tmp.path().join(".huskies/work/1_backlog");
+            fs::read_to_string(backlog.join(format!("{spike_id}.md"))).ok()
+        })
+        .expect("spike content should exist");
+
+    let meta = parse_front_matter(&contents).expect("front matter should be valid YAML");
+    assert_eq!(meta.name.as_deref(), Some(name));
+}
+
+#[test]
+fn create_spike_file_increments_from_existing_items() {
+    let tmp = tempfile::tempdir().unwrap();
+    crate::db::ensure_content_store();
+    // Seed a high-numbered item into the CRDT so next_item_number goes beyond it.
+    crate::db::write_item_with_content(
+        "7050_story_existing",
+        "1_backlog",
+        "---\nname: Existing\n---\n",
+    );
+
+    let spike_id = create_spike_file(tmp.path(), "My Spike", None, &[]).unwrap();
+    assert!(
+        spike_id.chars().all(|c| c.is_ascii_digit()),
+        "spike ID must be numeric-only, got: {spike_id}"
+    );
+    let num: u32 = spike_id.parse().unwrap();
+    assert!(
+        num >= 7051,
+        "expected spike number >= 7051, got: {spike_id}"
+    );
+}
+
+// ── Bug 640: create_bug_file / create_refactor_file depends_on tests ────────
+
+#[test]
+fn create_bug_file_with_depends_on_writes_front_matter_array() {
+    let tmp = tempfile::tempdir().unwrap();
+    setup_git_repo(tmp.path());
+
+    let bug_id = create_bug_file(
+        tmp.path(),
+        "Dep Bug",
+        "desc",
+        "steps",
+        "actual",
+        "expected",
+        None,
+        Some(&[42, 43]),
+    )
+    .unwrap();
+
+    let contents = crate::db::read_content(&bug_id)
+        .or_else(|| {
+            let filepath = tmp
+                .path()
+                .join(format!(".huskies/work/1_backlog/{bug_id}.md"));
+            fs::read_to_string(filepath).ok()
+        })
+        .expect("bug content should exist");
+
+    assert!(
+        contents.contains("depends_on: [42, 43]"),
+        "front matter should contain depends_on array: {contents}"
+    );
+    assert!(
+        !contents.contains("depends_on: \"["),
+        "depends_on must not be quoted string: {contents}"
+    );
+
+    let meta = parse_front_matter(&contents).expect("front matter should be valid YAML");
+    assert_eq!(meta.depends_on, Some(vec![42, 43]));
+}
+
+#[test]
+fn create_bug_file_without_depends_on_omits_field() {
+    let tmp = tempfile::tempdir().unwrap();
+    setup_git_repo(tmp.path());
+
+    let bug_id = create_bug_file(
+        tmp.path(),
+        "No Dep Bug",
+        "desc",
+        "steps",
+        "actual",
+        "expected",
+        None,
+        None,
+    )
+    .unwrap();
+
+    let contents = crate::db::read_content(&bug_id)
+        .or_else(|| {
+            let filepath = tmp
+                .path()
+                .join(format!(".huskies/work/1_backlog/{bug_id}.md"));
+            fs::read_to_string(filepath).ok()
+        })
+        .expect("bug content should exist");
+
+    assert!(
+        !contents.contains("depends_on"),
+        "front matter must not contain depends_on when not provided: {contents}"
+    );
+}
+
+#[test]
+fn create_refactor_file_with_depends_on_writes_front_matter_array() {
+    let tmp = tempfile::tempdir().unwrap();
+    setup_git_repo(tmp.path());
+
+    let refactor_id =
+        create_refactor_file(tmp.path(), "Dep Refactor", None, None, Some(&[99])).unwrap();
+
+    let contents = crate::db::read_content(&refactor_id)
+        .or_else(|| {
+            let filepath = tmp
+                .path()
+                .join(format!(".huskies/work/1_backlog/{refactor_id}.md"));
+            fs::read_to_string(filepath).ok()
+        })
+        .expect("refactor content should exist");
+
+    assert!(
+        contents.contains("depends_on: [99]"),
+        "front matter should contain depends_on array: {contents}"
+    );
+
+    let meta = parse_front_matter(&contents).expect("front matter should be valid YAML");
+    assert_eq!(meta.depends_on, Some(vec![99]));
+}
+
+#[test]
+fn create_refactor_file_without_depends_on_omits_field() {
+    let tmp = tempfile::tempdir().unwrap();
+    setup_git_repo(tmp.path());
+
+    let refactor_id =
+        create_refactor_file(tmp.path(), "No Dep Refactor", None, None, None).unwrap();
+
+    let contents = crate::db::read_content(&refactor_id)
+        .or_else(|| {
+            let filepath = tmp
+                .path()
+                .join(format!(".huskies/work/1_backlog/{refactor_id}.md"));
+            fs::read_to_string(filepath).ok()
+        })
+        .expect("refactor content should exist");
+
+    assert!(
+        !contents.contains("depends_on"),
+        "front matter must not contain depends_on when not provided: {contents}"
+    );
+}
+
+#[test]
+fn list_refactor_files_returns_ok() {
+    let tmp = tempfile::tempdir().unwrap();
+    let result = list_refactor_files(tmp.path());
+    assert!(result.is_ok());
+}