test: cover req id search json metadata

Author: buger

tests/json_format_tests.rs

@@ -95,6 +95,76 @@ function validateTerm(term) {
     create_test_file(root_dir, "src/multi_term.js", multi_term_content);
 }
 
+fn create_requirement_fixture(root_dir: &TempDir) {
+    let service_ts = r#"export class PolicyService {
+  // Implements: SYS-REQ-424
+  async evaluatePolicy(input: string): Promise<boolean> {
+    return input.length > 0 && input !== "deny";
+  }
+}
+
+// Implements: SYS-REQ-425
+export const normalizeDecision = (raw: string) => {
+  return raw.trim().toLowerCase();
+};
+"#;
+    create_test_file(root_dir, "web/src/service.ts", service_ts);
+
+    let service_test_ts = r#"import { describe, it, expect, test } from "vitest";
+
+// Verifies: SYS-REQ-424 [boundary]
+test("accepts valid policy", () => {
+  expect(true && true).toBe(true);
+});
+
+// MCDC SYS-REQ-424: input_valid=T, not_denied=T => TRUE
+it("records witness row", () => {
+  expect(true).toBe(true);
+});
+
+describe("normalization", () => {
+  // Verifies: SYS-REQ-425
+  it("normalizes decisions", () => {
+    expect(" ALLOW ".trim().toLowerCase()).toBe("allow");
+  });
+});
+"#;
+    create_test_file(
+        root_dir,
+        "web/src/__tests__/service.test.ts",
+        service_test_ts,
+    );
+
+    let demo_go = r#"package demo
+
+// Implements: SYS-REQ-426
+func RunDemo(flag bool) bool {
+    return flag
+}
+"#;
+    create_test_file(root_dir, "pkg/demo/demo.go", demo_go);
+
+    let noise_ts = r#"export const literalOnly = "Implements: SYS-REQ-427";
+
+export function unrelated() {
+  return "SYS-REQ-428";
+}
+
+// SYS-REQ-429 appears here without an annotation verb.
+export function looseComment() {
+  return true;
+}
+"#;
+    create_test_file(root_dir, "web/src/noise.ts", noise_ts);
+}
+
+fn find_result<'a>(results: &'a [Value], predicate: impl Fn(&'a Value) -> bool) -> &'a Value {
+    results
+        .iter()
+        .find(|result| predicate(result))
+        .expect("expected search result was not found")
+}
+
 #[test]
 fn test_json_output_format_basic() {
     let temp_dir = TempDir::new().expect("Failed to create temp dir");
@@ -190,6 +260,138 @@ fn test_json_output_format_basic() {
     );
 }
 
+#[test]
+fn test_search_json_no_merge_reports_req_id_source_metadata() {
+    let temp_dir = TempDir::new().expect("Failed to create temp dir");
+    create_requirement_fixture(&temp_dir);
+
+    let output = Command::new("cargo")
+        .args([
+            "run",
+            "--quiet",
+            "--",
+            "search",
+            "--allow-tests",
+            "--strict-elastic-syntax",
+            "--max-results",
+            "20",
+            "--no-merge",
+            "--format",
+            "json",
+            r#""SYS-REQ-424" OR "SYS-REQ-425""#,
+            temp_dir.path().to_str().unwrap(),
+        ])
+        .output()
+        .expect("Failed to execute command");
+
+    assert!(
+        output.status.success(),
+        "search command failed: {}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let json_str = extract_json_from_output(&stdout);
+    let json_result: Value = serde_json::from_str(json_str).expect("Failed to parse JSON output");
+    let results = json_result
+        .get("results")
+        .and_then(Value::as_array)
+        .expect("results should be an array");
+
+    assert_eq!(
+        results.len(),
+        5,
+        "expected one result per semantic-ish block"
+    );
+
+    let method_result = find_result(results, |result| {
+        result
+            .get("code")
+            .and_then(Value::as_str)
+            .is_some_and(|code| code.contains("evaluatePolicy") && code.contains("SYS-REQ-424"))
+    });
+    assert_eq!(
+        method_result.get("language").and_then(Value::as_str),
+        Some("typescript")
+    );
+    assert_eq!(
+        method_result.get("node_type").and_then(Value::as_str),
+        Some("method_definition")
+    );
+    assert_eq!(
+        method_result.get("owner_symbol").and_then(Value::as_str),
+        Some("evaluatePolicy")
+    );
+    assert_eq!(
+        method_result.get("scope").and_then(Value::as_str),
+        Some("function")
+    );
+
+    let arrow_result = find_result(results, |result| {
+        result
+            .get("code")
+            .and_then(Value::as_str)
+            .is_some_and(|code| code.contains("normalizeDecision") && code.contains("SYS-REQ-425"))
+    });
+    assert_eq!(
+        arrow_result.get("node_type").and_then(Value::as_str),
+        Some("export_statement")
+    );
+    assert_eq!(
+        arrow_result.get("owner_symbol").and_then(Value::as_str),
+        Some("normalizeDecision")
+    );
+    assert_eq!(
+        arrow_result.get("scope").and_then(Value::as_str),
+        Some("function")
+    );
+
+    let callback_result = find_result(results, |result| {
+        result
+            .get("code")
+            .and_then(Value::as_str)
+            .is_some_and(|code| code.contains("test(\"accepts valid policy\""))
+    });
+    assert_eq!(
+        callback_result.get("node_type").and_then(Value::as_str),
+        Some("arrow_function")
+    );
+    assert_eq!(
+        callback_result.get("scope").and_then(Value::as_str),
+        Some("test")
+    );
+    assert_eq!(
+        callback_result.get("is_test").and_then(Value::as_bool),
+        Some(true)
+    );
+
+    let leading_comments = callback_result
+        .get("leading_comments")
+        .and_then(Value::as_array)
+        .expect("callback result should expose leading comments");
+    assert_eq!(
+        leading_comments[0].get("text").and_then(Value::as_str),
+        Some("// Verifies: SYS-REQ-424 [boundary]")
+    );
+
+    let matches = callback_result
+        .get("matches")
+        .and_then(Value::as_array)
+        .expect("callback result should expose classified matches");
+    assert_eq!(
+        matches[0].get("text").and_then(Value::as_str),
+        Some("SYS-REQ-424")
+    );
+    assert_eq!(
+        matches[0].get("kind").and_then(Value::as_str),
+        Some("comment")
+    );
+    assert_eq!(
+        matches[0].get("comment_role").and_then(Value::as_str),
+        Some("leading")
+    );
+}
+
 #[test]
 fn test_json_output_with_special_characters() {
     let temp_dir = TempDir::new().expect("Failed to create temp dir");