@tishlang/tish-format 3.6.0 → 3.7.1

package/crates/tish_test/src/registry.rs

@@ -0,0 +1,235 @@
+//! Suite tree registry — collect-then-run (Jest/Bun model).
+
+use std::cell::RefCell;
+use std::sync::atomic::{AtomicBool, Ordering};
+
+use tishlang_core::Value;
+
+static ONLY_MODE: AtomicBool = AtomicBool::new(false);
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum TestMode {
+    Normal,
+    Skip,
+    Todo,
+    Only,
+    Failing,
+}
+
+#[derive(Clone)]
+pub struct TestCase {
+    pub name: String,
+    pub full_name: String,
+    pub callback: Value,
+    pub mode: TestMode,
+    pub timeout_ms: Option<u64>,
+    pub tags: Vec<String>,
+    pub file: String,
+}
+
+#[derive(Clone)]
+pub struct SuiteNode {
+    pub name: String,
+    pub mode: TestMode,
+    pub before_all: Vec<Value>,
+    pub after_all: Vec<Value>,
+    pub before_each: Vec<Value>,
+    pub after_each: Vec<Value>,
+    pub tests: Vec<TestCase>,
+    pub children: Vec<SuiteNode>,
+}
+
+impl SuiteNode {
+    pub fn new(name: impl Into<String>) -> Self {
+        Self {
+            name: name.into(),
+            mode: TestMode::Normal,
+            before_all: Vec::new(),
+            after_all: Vec::new(),
+            before_each: Vec::new(),
+            after_each: Vec::new(),
+            tests: Vec::new(),
+            children: Vec::new(),
+        }
+    }
+}
+
+struct CollectState {
+    root: SuiteNode,
+    /// Stack of indices into nested children from root.
+    path: Vec<usize>,
+    current_file: String,
+    collecting: bool,
+    /// Errors thrown by `describe` bodies during collection. A throw here would otherwise
+    /// silently drop every test after it, so the runner reports these as failures.
+    errors: Vec<String>,
+}
+
+impl CollectState {
+    fn new() -> Self {
+        Self {
+            root: SuiteNode::new(""),
+            path: Vec::new(),
+            current_file: String::new(),
+            collecting: false,
+            errors: Vec::new(),
+        }
+    }
+
+    fn current_mut(&mut self) -> &mut SuiteNode {
+        let mut node = &mut self.root;
+        for &i in &self.path {
+            node = &mut node.children[i];
+        }
+        node
+    }
+}
+
+thread_local! {
+    static STATE: RefCell<CollectState> = RefCell::new(CollectState::new());
+}
+
+pub fn begin_collect(file: &str) {
+    STATE.with(|s| {
+        let mut st = s.borrow_mut();
+        *st = CollectState::new();
+        st.current_file = file.to_string();
+        st.collecting = true;
+    });
+    ONLY_MODE.store(false, Ordering::SeqCst);
+}
+
+pub fn end_collect() -> SuiteNode {
+    STATE.with(|s| {
+        let mut st = s.borrow_mut();
+        st.collecting = false;
+        std::mem::replace(&mut st.root, SuiteNode::new(""))
+    })
+}
+
+/// Errors thrown by `describe` bodies during the last collection pass.
+pub fn take_collect_errors() -> Vec<String> {
+    STATE.with(|s| std::mem::take(&mut s.borrow_mut().errors))
+}
+
+pub fn is_collecting() -> bool {
+    STATE.with(|s| s.borrow().collecting)
+}
+
+fn full_name_for(suite_path: &[String], test_name: &str) -> String {
+    let mut parts = suite_path.to_vec();
+    parts.push(test_name.to_string());
+    parts
+        .into_iter()
+        .filter(|p| !p.is_empty())
+        .collect::<Vec<_>>()
+        .join(" > ")
+}
+
+/// Names of the suites currently on the collect stack, outermost first.
+fn suite_path_names(st: &CollectState) -> Vec<String> {
+    let mut names = Vec::new();
+    let mut node = &st.root;
+    names.push(node.name.clone());
+    for &i in &st.path {
+        node = &node.children[i];
+        names.push(node.name.clone());
+    }
+    names
+}
+
+pub fn push_describe(name: &str, mode: TestMode, body: &Value) {
+    // `describe.only` narrows the run exactly like `test.only` (Jest/Bun): registering one
+    // puts the whole file in only-mode so unmarked suites are filtered out.
+    if mode == TestMode::Only {
+        ONLY_MODE.store(true, Ordering::SeqCst);
+    }
+    let pushed = STATE.with(|s| {
+        let mut st = s.borrow_mut();
+        if !st.collecting {
+            return false;
+        }
+        let child = SuiteNode {
+            name: name.to_string(),
+            mode,
+            ..SuiteNode::new(name)
+        };
+        let idx = {
+            let cur = st.current_mut();
+            cur.children.push(child);
+            cur.children.len() - 1
+        };
+        st.path.push(idx);
+        true
+    });
+    if !pushed {
+        return;
+    }
+    // Run describe body immediately (Jest model). A throw here would silently drop every
+    // remaining registration in the body, so record it — the runner turns it into a failure.
+    let _ = tishlang_core::take_pending_throw();
+    let _ = tishlang_core::value_call(body, &[]);
+    let thrown = tishlang_core::take_pending_throw();
+    STATE.with(|s| {
+        let mut st = s.borrow_mut();
+        st.path.pop();
+        if let Some(err) = thrown {
+            let full = full_name_for(&suite_path_names(&st), name);
+            st.errors.push(format!(
+                "{full} (collecting): {}\n  Tests registered after this point in the describe body were skipped.",
+                err.to_display_string()
+            ));
+        }
+    });
+}
+
+pub fn add_test(
+    name: &str,
+    mode: TestMode,
+    body: Value,
+    timeout_ms: Option<u64>,
+    tags: Vec<String>,
+) {
+    if mode == TestMode::Only {
+        ONLY_MODE.store(true, Ordering::SeqCst);
+    }
+    STATE.with(|s| {
+        let mut st = s.borrow_mut();
+        if !st.collecting {
+            return;
+        }
+        let path = suite_path_names(&st);
+        let file = st.current_file.clone();
+        let case = TestCase {
+            name: name.to_string(),
+            full_name: full_name_for(&path, name),
+            callback: body,
+            mode,
+            timeout_ms,
+            tags,
+            file,
+        };
+        st.current_mut().tests.push(case);
+    });
+}
+
+pub fn add_hook(kind: &str, body: Value) {
+    STATE.with(|s| {
+        let mut st = s.borrow_mut();
+        if !st.collecting {
+            return;
+        }
+        let cur = st.current_mut();
+        match kind {
+            "beforeAll" | "before" => cur.before_all.push(body),
+            "afterAll" | "after" => cur.after_all.push(body),
+            "beforeEach" => cur.before_each.push(body),
+            "afterEach" => cur.after_each.push(body),
+            _ => {}
+        }
+    });
+}
+
+pub fn only_mode() -> bool {
+    ONLY_MODE.load(Ordering::SeqCst)
+}

package/crates/tish_test/src/report.rs

@@ -0,0 +1,312 @@
+//! Console / dots / JUnit reporters for `tish test`.
+
+use std::fs;
+use std::io::{self, Write};
+use std::path::Path;
+use std::time::Duration;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum TestStatus {
+    Pass,
+    Fail,
+    Skip,
+    Todo,
+    /// Excluded by name/tag/`--only` filters — not printed or counted.
+    Filtered,
+}
+
+#[derive(Clone, Debug)]
+pub struct TestResultRecord {
+    pub full_name: String,
+    pub file: String,
+    pub status: TestStatus,
+    pub duration: Duration,
+    pub message: Option<String>,
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct RunSummary {
+    pub passed: usize,
+    pub failed: usize,
+    pub skipped: usize,
+    pub todo: usize,
+    pub results: Vec<TestResultRecord>,
+}
+
+impl RunSummary {
+    pub fn record(&mut self, r: TestResultRecord) {
+        match r.status {
+            TestStatus::Pass => self.passed += 1,
+            TestStatus::Fail => self.failed += 1,
+            TestStatus::Skip => self.skipped += 1,
+            TestStatus::Todo => self.todo += 1,
+            TestStatus::Filtered => {
+                // Omitted from counts and reporters.
+                return;
+            }
+        }
+        self.results.push(r);
+    }
+
+    pub fn total(&self) -> usize {
+        self.passed + self.failed + self.skipped + self.todo
+    }
+
+    pub fn success(&self) -> bool {
+        self.failed == 0
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ReporterKind {
+    Console,
+    Dots,
+}
+
+pub struct ConsoleReporter {
+    kind: ReporterKind,
+    out: io::Stdout,
+    /// File header already printed for the current file, so console output groups by file.
+    current_file: Option<String>,
+}
+
+impl ConsoleReporter {
+    pub fn new(kind: ReporterKind) -> Self {
+        Self {
+            kind,
+            out: io::stdout(),
+            current_file: None,
+        }
+    }
+
+    pub fn on_result(&mut self, r: &TestResultRecord) {
+        match self.kind {
+            ReporterKind::Dots => {
+                let ch = match r.status {
+                    TestStatus::Pass => '.',
+                    TestStatus::Fail => 'F',
+                    TestStatus::Skip => 's',
+                    TestStatus::Todo => 't',
+                    TestStatus::Filtered => return,
+                };
+                let _ = write!(self.out, "{}", ch);
+                let _ = self.out.flush();
+            }
+            ReporterKind::Console => {
+                let label = match r.status {
+                    TestStatus::Pass => "PASS",
+                    TestStatus::Fail => "FAIL",
+                    TestStatus::Skip => "SKIP",
+                    TestStatus::Todo => "TODO",
+                    TestStatus::Filtered => return,
+                };
+                // Compare the *displayed* path: a collection error carries the path as given on
+                // the command line, while test records carry the canonicalized one.
+                let short = short_path(&r.file);
+                if !short.is_empty() && self.current_file.as_deref() != Some(short.as_str()) {
+                    let _ = writeln!(self.out, "\n{short}");
+                    self.current_file = Some(short);
+                }
+                let ms = r.duration.as_secs_f64() * 1000.0;
+                let _ = writeln!(self.out, "  {} {} ({:.1}ms)", label, r.full_name, ms);
+                if let Some(msg) = &r.message {
+                    for line in format_failure(msg).lines() {
+                        let _ = writeln!(self.out, "    {}", line);
+                    }
+                }
+            }
+        }
+    }
+
+    pub fn finish(&mut self, summary: &RunSummary) {
+        if self.kind == ReporterKind::Dots {
+            let _ = writeln!(self.out);
+        }
+        // Every reporter replays failures at the end. `dots` previously printed a bare `F`
+        // and no diagnostics at all.
+        let failures: Vec<&TestResultRecord> = summary
+            .results
+            .iter()
+            .filter(|r| r.status == TestStatus::Fail)
+            .collect();
+        if !failures.is_empty() {
+            let _ = writeln!(self.out, "\nFailures:\n");
+            for (i, r) in failures.iter().enumerate() {
+                let _ = writeln!(self.out, "  {}) {}", i + 1, r.full_name);
+                if !r.file.is_empty() {
+                    let _ = writeln!(self.out, "     {}", short_path(&r.file));
+                }
+                if let Some(msg) = &r.message {
+                    for line in format_failure(msg).lines() {
+                        let _ = writeln!(self.out, "     {}", line);
+                    }
+                }
+                let _ = writeln!(self.out);
+            }
+        }
+        let _ = writeln!(
+            self.out,
+            "Tests: {} passed, {} failed, {} skipped, {} todo ({})",
+            summary.passed,
+            summary.failed,
+            summary.skipped,
+            summary.todo,
+            summary.total()
+        );
+    }
+}
+
+/// Render a thrown value's display string readably.
+///
+/// `Value::to_display_string` on an `AssertionError` yields the whole object literal
+/// (`{code: …, message: expect(…)…, actual: …}`) with the useful part buried mid-line. Pull the
+/// message out and lead with it.
+pub(crate) fn format_failure(msg: &str) -> String {
+    let trimmed = msg.trim();
+    if !(trimmed.starts_with('{') && trimmed.ends_with('}')) {
+        return msg.to_string();
+    }
+    let Some(message) = extract_field(trimmed, "message") else {
+        return msg.to_string();
+    };
+    let name = extract_field(trimmed, "name").unwrap_or_else(|| "Error".to_string());
+    let mut out = format!("{name}: {message}");
+    // Keep the structured comparison fields, one per line, after the message.
+    for field in ["operator", "expected", "actual"] {
+        if let Some(v) = extract_field(trimmed, field) {
+            if !v.contains('\n') {
+                out.push_str(&format!("\n  {field}: {v}"));
+            }
+        }
+    }
+    out
+}
+
+/// Render a failure as a GitHub Actions annotation message.
+///
+/// Annotations are what a reviewer sees inline on the diff, so they get the same readable
+/// formatting as the console. GitHub also terminates the command at the first newline, so a
+/// multi-line message must be percent-escaped or the annotation is truncated to its first line
+/// and the rest leaks into the log as noise.
+pub(crate) fn gh_annotation(msg: &str) -> String {
+    format_failure(msg)
+        .replace('%', "%25")
+        .replace('\r', "%0D")
+        .replace('\n', "%0A")
+}
+
+/// Read `<key>: <value>` out of a displayed object literal. Values run to the next `, <key>: `
+/// at brace depth 0, which is how `to_display_string` separates them.
+fn extract_field(s: &str, key: &str) -> Option<String> {
+    let body = s.strip_prefix('{')?.strip_suffix('}')?;
+    let needle = format!("{key}: ");
+    let start = if body.starts_with(&needle) {
+        0
+    } else {
+        body.find(&format!(", {needle}"))? + 2
+    };
+    let rest = &body[start + needle.len()..];
+    let bytes = rest.as_bytes();
+    let (mut depth, mut i) = (0i32, 0usize);
+    while i < bytes.len() {
+        match bytes[i] {
+            b'{' | b'[' => depth += 1,
+            b'}' | b']' => depth -= 1,
+            // A comma ends the value only when the next token looks like `key: ` — message
+            // text is full of commas.
+            b',' if depth == 0 && starts_with_key(&rest[i + 1..]) => break,
+            _ => {}
+        }
+        i += 1;
+    }
+    Some(rest[..i].trim().to_string())
+}
+
+/// Does `s` begin with `<identifier>: `?
+fn starts_with_key(s: &str) -> bool {
+    let s = s.trim_start();
+    match s.split_once(": ") {
+        Some((k, _)) => {
+            !k.is_empty()
+                && k.chars()
+                    .all(|c| c.is_alphanumeric() || c == '_' || c == '$')
+        }
+        None => false,
+    }
+}
+
+fn short_path(p: &str) -> String {
+    if let Ok(cwd) = std::env::current_dir() {
+        if let Ok(rel) = Path::new(p).strip_prefix(&cwd) {
+            if let Some(s) = rel.to_str() {
+                return s.to_string();
+            }
+        }
+    }
+    p.to_string()
+}
+
+/// Write a minimal JUnit XML report.
+pub fn write_junit_xml(path: &Path, summary: &RunSummary) -> io::Result<()> {
+    if let Some(parent) = path.parent() {
+        fs::create_dir_all(parent)?;
+    }
+    let mut xml = String::new();
+    xml.push_str(r#"<?xml version="1.0" encoding="UTF-8"?>"#);
+    xml.push('\n');
+    xml.push_str(&format!(
+        r#"<testsuites tests="{}" failures="{}" skipped="{}">"#,
+        summary.total(),
+        summary.failed,
+        summary.skipped + summary.todo
+    ));
+    xml.push('\n');
+    xml.push_str(r#"  <testsuite name="tish test">"#);
+    xml.push('\n');
+    for r in &summary.results {
+        let time = r.duration.as_secs_f64();
+        xml.push_str(&format!(
+            r#"    <testcase name="{}" classname="{}" time="{:.6}">"#,
+            xml_escape(&r.full_name),
+            xml_escape(&r.file),
+            time
+        ));
+        xml.push('\n');
+        match r.status {
+            TestStatus::Fail => {
+                let msg = r.message.as_deref().unwrap_or("failed");
+                xml.push_str(&format!(
+                    "      <failure message=\"{}\">{}</failure>\n",
+                    xml_escape(msg),
+                    xml_escape(msg)
+                ));
+            }
+            TestStatus::Skip | TestStatus::Todo => {
+                xml.push_str("      <skipped/>\n");
+            }
+            TestStatus::Pass | TestStatus::Filtered => {}
+        }
+        xml.push_str("    </testcase>\n");
+    }
+    xml.push_str("  </testsuite>\n</testsuites>\n");
+    fs::write(path, xml)
+}
+
+/// Escape for XML, dropping control characters. A failure message carrying an ANSI escape or a
+/// NUL would otherwise produce a JUnit file no parser accepts.
+fn xml_escape(s: &str) -> String {
+    let mut out = String::with_capacity(s.len());
+    for c in s.chars() {
+        match c {
+            '&' => out.push_str("&amp;"),
+            '<' => out.push_str("&lt;"),
+            '>' => out.push_str("&gt;"),
+            '"' => out.push_str("&quot;"),
+            '\'' => out.push_str("&apos;"),
+            '\t' | '\n' | '\r' => out.push(c),
+            c if (c as u32) < 0x20 || (c as u32) == 0x7f => out.push(' '),
+            c => out.push(c),
+        }
+    }
+    out
+}