@tishlang/tish-format 3.6.0 → 3.7.1

package/crates/tish_test/src/mocks.rs

@@ -0,0 +1,270 @@
+//! `mock` / `spyOn` with call tracking.
+
+use tishlang_core::{value_call, Arc, ObjectMap, Value, VmRef};
+
+use std::cell::RefCell;
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+thread_local! {
+    static MOCKS: RefCell<Vec<MockHandle>> = const { RefCell::new(Vec::new()) };
+}
+
+struct MockHandle {
+    meta: Value,
+    restore: Option<(Value, String, Value)>,
+}
+
+static MOCK_SEQ: AtomicUsize = AtomicUsize::new(1);
+
+fn next_mock_id() -> usize {
+    MOCK_SEQ.fetch_add(1, Ordering::SeqCst)
+}
+
+fn empty_calls_array() -> Value {
+    Value::Array(VmRef::new(Vec::new()))
+}
+
+fn bump_calls(meta: &Value, args: &[Value]) {
+    let Value::Object(o) = meta else {
+        return;
+    };
+    let mut b = o.borrow_mut();
+    if !b.strings.contains_key("calls") {
+        b.strings.insert(Arc::from("calls"), empty_calls_array());
+    }
+    if let Some(Value::Array(arr)) = b.strings.get("calls") {
+        arr.borrow_mut()
+            .push(Value::Array(VmRef::new(args.to_vec())));
+    }
+    let count = match b.strings.get("calls") {
+        Some(Value::Array(a)) => a.borrow().len() as f64,
+        _ => 0.0,
+    };
+    b.strings
+        .insert(Arc::from("callCount"), Value::Number(count));
+}
+
+fn make_mock_meta(impl_fn: Value) -> Value {
+    let id = next_mock_id();
+    let mut m = ObjectMap::default();
+    m.insert(Arc::from("mockId"), Value::Number(id as f64));
+    m.insert(Arc::from("calls"), empty_calls_array());
+    m.insert(Arc::from("callCount"), Value::Number(0.0));
+    m.insert(Arc::from("implementation"), impl_fn.clone());
+    let meta = Value::object(m);
+    if let Value::Object(o) = &meta {
+        let o_clear = o.clone();
+        let o_reset = o.clone();
+        let impl_reset = impl_fn;
+        o.borrow_mut().strings.insert(
+            Arc::from("mockClear"),
+            Value::native(move |_args: &[Value]| {
+                let mut b = o_clear.borrow_mut();
+                b.strings.insert(Arc::from("calls"), empty_calls_array());
+                b.strings.insert(Arc::from("callCount"), Value::Number(0.0));
+                Value::Null
+            }),
+        );
+        o.borrow_mut().strings.insert(
+            Arc::from("mockReset"),
+            Value::native(move |_args: &[Value]| {
+                let mut b = o_reset.borrow_mut();
+                b.strings.insert(Arc::from("calls"), empty_calls_array());
+                b.strings.insert(Arc::from("callCount"), Value::Number(0.0));
+                b.strings
+                    .insert(Arc::from("implementation"), impl_reset.clone());
+                Value::Null
+            }),
+        );
+    }
+    meta
+}
+
+fn wrap_mock_fn(meta: Value) -> Value {
+    let meta_call = meta.clone();
+    Value::native(move |args: &[Value]| {
+        bump_calls(&meta_call, args);
+        let impl_fn = match &meta_call {
+            Value::Object(o) => o
+                .borrow()
+                .strings
+                .get("implementation")
+                .cloned()
+                .unwrap_or(Value::Null),
+            _ => Value::Null,
+        };
+        value_call(&impl_fn, args)
+    })
+}
+
+/// Set `implementation` on a mock's metadata object.
+fn set_implementation(meta: &Value, f: Value) {
+    if let Value::Object(o) = meta {
+        o.borrow_mut()
+            .strings
+            .insert(Arc::from("implementation"), f);
+    }
+}
+
+/// Jest/Bun put `mockClear` / `mockImplementation` / `mockReturnValue` on the mock function
+/// itself, not on `.mock`. Attach both so either spelling works.
+fn attach_mock_controls(outer: &mut ObjectMap, meta: &Value) {
+    if let Value::Object(o) = meta {
+        for name in ["mockClear", "mockReset"] {
+            let existing = o.borrow().strings.get(name).cloned();
+            if let Some(f) = existing {
+                outer.insert(Arc::from(name), f);
+            }
+        }
+    }
+    let m_impl = meta.clone();
+    outer.insert(
+        Arc::from("mockImplementation"),
+        Value::native(move |args: &[Value]| {
+            set_implementation(&m_impl, args.first().cloned().unwrap_or(Value::Null));
+            Value::Null
+        }),
+    );
+    let m_once = meta.clone();
+    outer.insert(
+        Arc::from("mockImplementationOnce"),
+        Value::native(move |args: &[Value]| {
+            set_implementation(&m_once, args.first().cloned().unwrap_or(Value::Null));
+            Value::Null
+        }),
+    );
+    let m_ret = meta.clone();
+    outer.insert(
+        Arc::from("mockReturnValue"),
+        Value::native(move |args: &[Value]| {
+            let v = args.first().cloned().unwrap_or(Value::Null);
+            set_implementation(&m_ret, Value::native(move |_a: &[Value]| v.clone()));
+            Value::Null
+        }),
+    );
+    let m_res = meta.clone();
+    outer.insert(
+        Arc::from("mockResolvedValue"),
+        Value::native(move |args: &[Value]| {
+            let v = args.first().cloned().unwrap_or(Value::Null);
+            // No promise construction here: a resolved value is what `await` yields anyway.
+            set_implementation(&m_res, Value::native(move |_a: &[Value]| v.clone()));
+            Value::Null
+        }),
+    );
+}
+
+/// `mock(fn?)` — callable mock object with `.mock.calls` / `.mockClear`.
+pub fn mock(args: &[Value]) -> Value {
+    let impl_fn = args
+        .first()
+        .cloned()
+        .unwrap_or_else(|| Value::native(|_a: &[Value]| Value::Null));
+    let meta = make_mock_meta(impl_fn);
+    let call = wrap_mock_fn(meta.clone());
+    let mut outer = ObjectMap::default();
+    outer.insert(Arc::from("__call"), call);
+    outer.insert(Arc::from("mock"), meta.clone());
+    attach_mock_controls(&mut outer, &meta);
+    let obj = Value::object(outer);
+    MOCKS.with(|m| {
+        m.borrow_mut().push(MockHandle {
+            meta,
+            restore: None,
+        });
+    });
+    obj
+}
+
+/// `spyOn(obj, methodName)` — wraps a method; restore via `restoreAllMocks`.
+pub fn spy_on(args: &[Value]) -> Value {
+    let target = args.first().cloned().unwrap_or(Value::Null);
+    let prop = args
+        .get(1)
+        .map(|v| v.to_display_string())
+        .unwrap_or_default();
+    let original = match &target {
+        Value::Object(o) => o
+            .borrow()
+            .strings
+            .get(prop.as_str())
+            .cloned()
+            .unwrap_or(Value::Null),
+        _ => Value::Null,
+    };
+    let meta = make_mock_meta(original.clone());
+    let call = wrap_mock_fn(meta.clone());
+    let mut outer = ObjectMap::default();
+    outer.insert(Arc::from("__call"), call);
+    outer.insert(Arc::from("mock"), meta.clone());
+    attach_mock_controls(&mut outer, &meta);
+    let spy = Value::object(outer);
+    if !matches!(target, Value::Object(_)) {
+        // Silently returning an unattached spy made the whole test a no-op.
+        tishlang_core::set_pending_throw(crate::assert::assertion_error(
+            format!(
+                "spyOn(target, {prop:?}): target is not an object ({})",
+                target.to_display_string()
+            ),
+            Some(target.clone()),
+            None,
+            "spyOn",
+            true,
+        ));
+        return Value::Null;
+    }
+    if let Value::Object(o) = &target {
+        o.borrow_mut()
+            .strings
+            .insert(Arc::from(prop.as_str()), spy.clone());
+    }
+    MOCKS.with(|m| {
+        m.borrow_mut().push(MockHandle {
+            meta,
+            restore: Some((target, prop, original)),
+        });
+    });
+    spy
+}
+
+pub fn clear_all_mocks(_args: &[Value]) -> Value {
+    MOCKS.with(|m| {
+        for h in m.borrow().iter() {
+            if let Value::Object(o) = &h.meta {
+                let mut b = o.borrow_mut();
+                b.strings.insert(Arc::from("calls"), empty_calls_array());
+                b.strings.insert(Arc::from("callCount"), Value::Number(0.0));
+            }
+        }
+    });
+    Value::Null
+}
+
+pub fn restore_all_mocks(_args: &[Value]) -> Value {
+    MOCKS.with(|m| {
+        let mut list = m.borrow_mut();
+        // Restore newest-first: spying twice on one method must land back on the ORIGINAL,
+        // not on the first spy.
+        for h in list.drain(..).rev() {
+            if let Some((Value::Object(o), prop, original)) = h.restore {
+                o.borrow_mut()
+                    .strings
+                    .insert(Arc::from(prop.as_str()), original);
+            }
+        }
+    });
+    Value::Null
+}
+
+/// Drop all mock/spy handles between test files (restore spies first).
+pub fn reset_mock_registry() {
+    let _ = restore_all_mocks(&[]);
+}
+
+pub fn mock_native(args: &[Value]) -> Value {
+    mock(args)
+}
+
+pub fn spy_on_native(args: &[Value]) -> Value {
+    spy_on(args)
+}

package/crates/tish_test/src/module.rs

@@ -0,0 +1,318 @@
+//! `tish:test` and `tish:assert` module export maps.
+
+use tishlang_core::{value_call, Arc, ObjectMap, Value};
+
+use crate::assert::assert_object;
+use crate::expect::expect_object;
+use crate::mocks::{clear_all_mocks, mock, restore_all_mocks, spy_on};
+use crate::registry::{add_hook, add_test, push_describe, TestMode};
+
+fn name_and_fn(args: &[Value]) -> (String, Value) {
+    match args.len() {
+        0 => (String::new(), Value::Null),
+        1 => {
+            if matches!(args[0], Value::Function(_) | Value::Object(_)) {
+                ("<anonymous>".into(), args[0].clone())
+            } else {
+                (args[0].to_display_string(), Value::Null)
+            }
+        }
+        _ => {
+            let name = args[0].to_display_string();
+            let body = args.last().cloned().unwrap_or(Value::Null);
+            (name, body)
+        }
+    }
+}
+
+fn opts_object(args: &[Value]) -> Option<Value> {
+    if args.len() >= 3 {
+        if let Value::Object(_) = &args[1] {
+            return Some(args[1].clone());
+        }
+    }
+    None
+}
+
+fn timeout_from_args(args: &[Value]) -> Option<u64> {
+    let v = opts_object(args)?;
+    let Value::Object(o) = v else {
+        return None;
+    };
+    let n = {
+        let b = o.borrow();
+        b.strings
+            .get("timeout")
+            .and_then(|v| v.as_number())
+            .filter(|n| n.is_finite() && *n >= 0.0)
+    }?;
+    Some(n as u64)
+}
+
+fn tags_from_args(args: &[Value]) -> Vec<String> {
+    let Some(Value::Object(o)) = opts_object(args) else {
+        return Vec::new();
+    };
+    let b = o.borrow();
+    match b.strings.get("tags") {
+        Some(Value::Array(a)) => a.borrow().iter().map(|v| v.to_display_string()).collect(),
+        Some(Value::String(s)) => vec![s.to_string()],
+        _ => Vec::new(),
+    }
+}
+
+fn is_truthy(v: &Value) -> bool {
+    match v {
+        Value::Null => false,
+        Value::Bool(b) => *b,
+        Value::Number(n) => *n != 0.0 && !n.is_nan(),
+        Value::String(s) => !s.is_empty(),
+        _ => true,
+    }
+}
+
+fn row_args(row: &Value) -> Vec<Value> {
+    match row {
+        Value::Array(a) => a.borrow().clone(),
+        Value::NumberArray(a) => a.borrow().to_values(),
+        other => vec![other.clone()],
+    }
+}
+
+fn format_each_name(template: &str, row: &Value, index: usize) -> String {
+    if !template.contains('%') {
+        return format!("{template} [{index}]");
+    }
+    let args = row_args(row);
+    let mut out = String::new();
+    let mut chars = template.chars().peekable();
+    let mut ai = 0usize;
+    while let Some(c) = chars.next() {
+        if c == '%' {
+            match chars.peek().copied() {
+                Some('#') => {
+                    chars.next();
+                    out.push_str(&index.to_string());
+                }
+                Some('s') | Some('i') | Some('d') | Some('p') | Some('j') => {
+                    chars.next();
+                    let v = args.get(ai).cloned().unwrap_or(Value::Null);
+                    ai += 1;
+                    out.push_str(&v.to_display_string());
+                }
+                Some('%') => {
+                    chars.next();
+                    out.push('%');
+                }
+                _ => out.push('%'),
+            }
+        } else {
+            out.push(c);
+        }
+    }
+    out
+}
+
+fn make_test_call(mode: TestMode) -> Value {
+    Value::native(move |args: &[Value]| {
+        let (name, body) = name_and_fn(args);
+        let timeout = timeout_from_args(args);
+        let tags = tags_from_args(args);
+        // Parallel `test.concurrent` is deferred (single-threaded VM); `{ concurrent: true }`
+        // is accepted and ignored so Bun/Jest suites port without edits.
+        add_test(&name, mode, body, timeout, tags);
+        Value::Null
+    })
+}
+
+fn make_each_call(mode: TestMode) -> Value {
+    Value::native(move |args: &[Value]| {
+        let table = args.first().cloned().unwrap_or(Value::Null);
+        Value::native(move |inner: &[Value]| {
+            let (name_tmpl, body) = name_and_fn(inner);
+            let timeout = timeout_from_args(inner);
+            let rows: Vec<Value> = match &table {
+                Value::Array(a) => a.borrow().clone(),
+                Value::NumberArray(a) => a.borrow().to_values(),
+                other => vec![other.clone()],
+            };
+            for (i, row) in rows.into_iter().enumerate() {
+                let name = format_each_name(&name_tmpl, &row, i);
+                let body = body.clone();
+                let row_for_call = row;
+                let wrapped = Value::native(move |_a: &[Value]| {
+                    let call_args = row_args(&row_for_call);
+                    value_call(&body, &call_args)
+                });
+                add_test(&name, mode, wrapped, timeout, Vec::new());
+            }
+            Value::Null
+        })
+    })
+}
+
+fn attach_each(target: &mut ObjectMap, mode: TestMode) {
+    target.insert(Arc::from("each"), make_each_call(mode));
+}
+
+fn test_object() -> Value {
+    let mut m = ObjectMap::default();
+    m.insert(Arc::from("__call"), make_test_call(TestMode::Normal));
+    attach_each(&mut m, TestMode::Normal);
+    m.insert(Arc::from("skipIf"), {
+        Value::native(|args: &[Value]| {
+            let skip = args.first().map(is_truthy).unwrap_or(false);
+            make_test_call(if skip {
+                TestMode::Skip
+            } else {
+                TestMode::Normal
+            })
+        })
+    });
+    m.insert(Arc::from("skip"), {
+        let mut o = ObjectMap::default();
+        o.insert(Arc::from("__call"), make_test_call(TestMode::Skip));
+        attach_each(&mut o, TestMode::Skip);
+        Value::object(o)
+    });
+    m.insert(Arc::from("only"), {
+        let mut o = ObjectMap::default();
+        o.insert(Arc::from("__call"), make_test_call(TestMode::Only));
+        attach_each(&mut o, TestMode::Only);
+        Value::object(o)
+    });
+    m.insert(Arc::from("todo"), {
+        let mut o = ObjectMap::default();
+        o.insert(
+            Arc::from("__call"),
+            Value::native(|args: &[Value]| {
+                let name = args
+                    .first()
+                    .map(|v| v.to_display_string())
+                    .unwrap_or_else(|| "<todo>".into());
+                add_test(&name, TestMode::Todo, Value::Null, None, Vec::new());
+                Value::Null
+            }),
+        );
+        Value::object(o)
+    });
+    m.insert(Arc::from("failing"), {
+        let mut o = ObjectMap::default();
+        o.insert(Arc::from("__call"), make_test_call(TestMode::Failing));
+        attach_each(&mut o, TestMode::Failing);
+        Value::object(o)
+    });
+    Value::object(m)
+}
+
+fn make_describe_call(mode: TestMode) -> Value {
+    Value::native(move |args: &[Value]| {
+        let name = args
+            .first()
+            .map(|v| v.to_display_string())
+            .unwrap_or_default();
+        let body = args.get(1).cloned().unwrap_or(Value::Null);
+        push_describe(&name, mode, &body);
+        Value::Null
+    })
+}
+
+fn describe_object() -> Value {
+    let mut m = ObjectMap::default();
+    m.insert(Arc::from("__call"), make_describe_call(TestMode::Normal));
+    m.insert(Arc::from("skip"), {
+        let mut o = ObjectMap::default();
+        o.insert(Arc::from("__call"), make_describe_call(TestMode::Skip));
+        Value::object(o)
+    });
+    m.insert(Arc::from("only"), {
+        let mut o = ObjectMap::default();
+        o.insert(Arc::from("__call"), make_describe_call(TestMode::Only));
+        Value::object(o)
+    });
+    // `describe.each` — table-driven suites (same table shape as `test.each`).
+    m.insert(
+        Arc::from("each"),
+        Value::native(move |args: &[Value]| {
+            let table = args.first().cloned().unwrap_or(Value::Null);
+            Value::native(move |inner: &[Value]| {
+                let name_tmpl = inner
+                    .first()
+                    .map(|v| v.to_display_string())
+                    .unwrap_or_default();
+                let body = inner.get(1).cloned().unwrap_or(Value::Null);
+                let rows: Vec<Value> = match &table {
+                    Value::Array(a) => a.borrow().clone(),
+                    Value::NumberArray(a) => a.borrow().to_values(),
+                    other => vec![other.clone()],
+                };
+                for (i, row) in rows.into_iter().enumerate() {
+                    let name = format_each_name(&name_tmpl, &row, i);
+                    let body = body.clone();
+                    let row_for_call = row;
+                    let wrapped = Value::native(move |_a: &[Value]| {
+                        let call_args = row_args(&row_for_call);
+                        value_call(&body, &call_args)
+                    });
+                    push_describe(&name, TestMode::Normal, &wrapped);
+                }
+                Value::Null
+            })
+        }),
+    );
+    Value::object(m)
+}
+
+fn hook(kind: &'static str) -> Value {
+    Value::native(move |args: &[Value]| {
+        let body = args.first().cloned().unwrap_or(Value::Null);
+        add_hook(kind, body);
+        Value::Null
+    })
+}
+
+/// Named exports for `import { … } from "tish:test"`.
+pub fn test_module() -> ObjectMap {
+    let test = test_object();
+    let describe = describe_object();
+    let expect = expect_object();
+
+    let mut m = ObjectMap::default();
+    m.insert(Arc::from("describe"), describe.clone());
+    m.insert(Arc::from("suite"), describe);
+    m.insert(Arc::from("test"), test.clone());
+    m.insert(Arc::from("it"), test);
+    m.insert(Arc::from("expect"), expect);
+    m.insert(Arc::from("beforeAll"), hook("beforeAll"));
+    m.insert(Arc::from("afterAll"), hook("afterAll"));
+    m.insert(Arc::from("beforeEach"), hook("beforeEach"));
+    m.insert(Arc::from("afterEach"), hook("afterEach"));
+    m.insert(Arc::from("before"), hook("before"));
+    m.insert(Arc::from("after"), hook("after"));
+    m.insert(Arc::from("mock"), Value::native(mock));
+    m.insert(Arc::from("spyOn"), Value::native(spy_on));
+    m.insert(Arc::from("clearAllMocks"), Value::native(clear_all_mocks));
+    m.insert(
+        Arc::from("restoreAllMocks"),
+        Value::native(restore_all_mocks),
+    );
+    let default_test = m.get("test").cloned().unwrap_or(Value::Null);
+    m.insert(Arc::from("default"), default_test);
+    m
+}
+
+/// Named + default exports for `tish:assert` / `node:assert`.
+pub fn assert_module() -> ObjectMap {
+    let assert = assert_object();
+    let mut m = ObjectMap::default();
+    if let Value::Object(o) = &assert {
+        for (k, v) in o.borrow().strings.iter() {
+            if k.as_ref() != "__call" {
+                m.insert(Arc::clone(k), v.clone());
+            }
+        }
+    }
+    m.insert(Arc::from("assert"), assert.clone());
+    m.insert(Arc::from("default"), assert);
+    m
+}