mustardscript 0.1.0 → 0.1.2

package/crates/mustard/src/runtime/tests/async_host.rs

@@ -1,104 +0,0 @@
-use super::*;
-
-#[test]
-fn suspends_and_resumes_host_capability_calls() {
-    let suspension = suspend(
-        r#"
-            const value = fetch_data(41);
-            value + 1;
-            "#,
-        &["fetch_data"],
-    );
-    assert_eq!(suspension.capability, "fetch_data");
-    assert_eq!(
-        suspension.args,
-        vec![number(41.0)]
-    );
-
-    let resumed = resume(
-        suspension.snapshot,
-        ResumePayload::Value(number(41.0)),
-    )
-    .expect("resume should succeed");
-
-    match resumed {
-        ExecutionStep::Completed(value) => {
-            assert_eq!(value, number(42.0));
-        }
-        other => panic!("expected completion, got {other:?}"),
-    }
-}
-
-#[test]
-fn console_callbacks_resume_with_undefined_guest_results() {
-    let suspension = suspend(
-        r#"
-            const logged = console.log(41);
-            logged === undefined ? 2 : 0;
-            "#,
-        &["console.log"],
-    );
-    assert_eq!(suspension.capability, "console.log");
-    assert_eq!(
-        suspension.args,
-        vec![number(41.0)]
-    );
-
-    let resumed = resume(
-        suspension.snapshot,
-        ResumePayload::Value(StructuredValue::String("ignored".to_string())),
-    )
-    .expect("resume should ignore host return values for console callbacks");
-
-    match resumed {
-        ExecutionStep::Completed(value) => {
-            assert_eq!(value, number(2.0));
-        }
-        other => panic!("expected completion, got {other:?}"),
-    }
-}
-
-#[test]
-fn catches_host_errors_after_resume() {
-    let suspension = suspend(
-        r#"
-            let captured;
-            try {
-              fetch_data(1);
-            } catch (error) {
-              captured = [error.name, error.message, error.code, error.details.status];
-            }
-            captured;
-            "#,
-        &["fetch_data"],
-    );
-
-    let resumed = resume(
-        suspension.snapshot,
-        ResumePayload::Error(HostError {
-            name: "CapabilityError".to_string(),
-            message: "upstream failed".to_string(),
-            code: Some("E_UPSTREAM".to_string()),
-            details: Some(StructuredValue::Object(IndexMap::from([(
-                "status".to_string(),
-                number(503.0),
-            )]))),
-        }),
-    )
-    .expect("guest catch should handle resumed host errors");
-
-    match resumed {
-        ExecutionStep::Completed(value) => {
-            assert_eq!(
-                value,
-                StructuredValue::Array(vec![
-                    StructuredValue::String("CapabilityError".to_string()),
-                    StructuredValue::String("upstream failed".to_string()),
-                    StructuredValue::String("E_UPSTREAM".to_string()),
-                    number(503.0),
-                ])
-            );
-        }
-        other => panic!("expected completion, got {other:?}"),
-    }
-}

package/crates/mustard/src/runtime/tests/collections.rs

@@ -1,50 +0,0 @@
-use super::*;
-
-#[test]
-fn maps_preserve_insertion_order_and_same_value_zero_updates() {
-    let program = lower_to_bytecode(&compile("0;").expect("source should compile"))
-        .expect("lowering should succeed");
-    let mut runtime = Runtime::new(program, ExecutionOptions::default()).expect("runtime init");
-    let map = runtime.insert_map(Vec::new()).expect("map should allocate");
-    let object = runtime
-        .insert_object(IndexMap::new(), ObjectKind::Plain)
-        .expect("object should allocate");
-
-    runtime
-        .map_set(map, Value::String("alpha".to_string()), Value::Number(1.0))
-        .expect("alpha insert should succeed");
-    runtime
-        .map_set(
-            map,
-            Value::Number(f64::NAN),
-            Value::String("nan".to_string()),
-        )
-        .expect("nan insert should succeed");
-    runtime
-        .map_set(map, Value::Number(-0.0), Value::String("zero".to_string()))
-        .expect("negative zero insert should succeed");
-    runtime
-        .map_set(map, Value::Object(object), Value::Bool(true))
-        .expect("object key insert should succeed");
-    runtime
-        .map_set(map, Value::String("alpha".to_string()), Value::Number(2.0))
-        .expect("alpha update should keep insertion order");
-    runtime
-        .map_set(
-            map,
-            Value::Number(0.0),
-            Value::String("zero-updated".to_string()),
-        )
-        .expect("positive zero update should reuse the existing entry");
-
-    let entries = &runtime.maps.get(map).expect("map should exist").entries;
-    assert_eq!(entries.len(), 4);
-    assert!(matches!(entries[0].key, Value::String(ref value) if value == "alpha"));
-    assert!(matches!(entries[0].value, Value::Number(value) if value == 2.0));
-    assert!(matches!(entries[1].key, Value::Number(value) if value.is_nan()));
-    assert!(matches!(entries[1].value, Value::String(ref value) if value == "nan"));
-    assert!(matches!(entries[2].key, Value::Number(value) if value == 0.0));
-    assert!(matches!(entries[2].value, Value::String(ref value) if value == "zero-updated"));
-    assert!(matches!(entries[3].key, Value::Object(key) if key == object));
-    assert!(matches!(entries[3].value, Value::Bool(true)));
-}

package/crates/mustard/src/runtime/tests/diagnostics.rs

@@ -1,36 +0,0 @@
-use super::*;
-
-#[test]
-fn lowering_errors_preserve_source_spans() {
-    let program = compile("continue;").expect("source should compile");
-    let error =
-        lower_to_bytecode(&program).expect_err("continue outside a loop should fail lowering");
-    let rendered = error.to_string();
-    assert!(rendered.contains("`continue` used outside of a loop"));
-    assert!(rendered.contains("[0..9]"));
-}
-
-#[test]
-fn runtime_errors_include_guest_tracebacks() {
-    let program = compile(
-        r#"
-            function outer() {
-              return inner();
-            }
-            function inner() {
-              const value = null;
-              return value.answer;
-            }
-            outer();
-            "#,
-    )
-    .expect("source should compile");
-    let error = execute(&program, ExecutionOptions::default())
-        .expect_err("nullish property access should fail");
-    let rendered = error.to_string();
-    assert!(rendered.contains("TypeError: cannot read properties of nullish value"));
-    assert!(rendered.contains("at inner ["));
-    assert!(rendered.contains("at outer ["));
-    assert!(rendered.contains("at <script> ["));
-    assert!(!rendered.contains(".rs"));
-}

package/crates/mustard/src/runtime/tests/exceptions.rs

@@ -1,122 +0,0 @@
-use super::*;
-
-#[test]
-fn runs_throw_try_catch_and_finally() {
-    let value = run(r#"
-            let log = [];
-            try {
-              log[log.length] = "body";
-              throw new Error("boom");
-            } catch (error) {
-              log[log.length] = error.name;
-              log[log.length] = error.message;
-            } finally {
-              log[log.length] = "finally";
-            }
-            log;
-            "#);
-    assert_eq!(
-        value,
-        StructuredValue::Array(vec![
-            StructuredValue::String("body".to_string()),
-            StructuredValue::String("Error".to_string()),
-            StructuredValue::String("boom".to_string()),
-            StructuredValue::String("finally".to_string()),
-        ])
-    );
-}
-
-#[test]
-fn catches_runtime_type_errors_as_guest_errors() {
-    let value = run(r#"
-            let captured;
-            try {
-              const value = null;
-              value.answer;
-            } catch (error) {
-              captured = [error.name, error.message];
-            }
-            captured;
-            "#);
-    assert_eq!(
-        value,
-        StructuredValue::Array(vec![
-            StructuredValue::String("TypeError".to_string()),
-            StructuredValue::String("cannot read properties of nullish value".to_string()),
-        ])
-    );
-}
-
-#[test]
-fn finally_runs_for_return_break_and_continue() {
-    let value = run(r#"
-            let events = [];
-            function earlyReturn() {
-              try {
-                return "body";
-              } finally {
-                events[events.length] = "return";
-              }
-            }
-            let index = 0;
-            while (index < 2) {
-              index += 1;
-              try {
-                if (index === 1) {
-                  continue;
-                }
-                break;
-              } finally {
-                events[events.length] = index;
-              }
-            }
-            [earlyReturn(), events];
-            "#);
-    assert_eq!(
-        value,
-        StructuredValue::Array(vec![
-            StructuredValue::String("body".to_string()),
-            StructuredValue::Array(vec![
-                StructuredValue::Number(StructuredNumber::Finite(1.0)),
-                StructuredValue::Number(StructuredNumber::Finite(2.0)),
-                StructuredValue::String("return".to_string()),
-            ]),
-        ])
-    );
-}
-
-#[test]
-fn nested_exception_unwind_preserves_finally_order() {
-    let value = run(r#"
-            let events = [];
-            function nested() {
-              try {
-                try {
-                  events[events.length] = "inner-body";
-                  throw new Error("boom");
-                } catch (error) {
-                  events[events.length] = error.message;
-                  throw new TypeError("wrapped");
-                } finally {
-                  events[events.length] = "inner-finally";
-                }
-              } catch (error) {
-                events[events.length] = error.name;
-              } finally {
-                events[events.length] = "outer-finally";
-              }
-              return events;
-            }
-            nested();
-            "#);
-    assert_eq!(
-        value,
-        StructuredValue::Array(vec![
-            StructuredValue::String("inner-body".to_string()),
-            StructuredValue::String("boom".to_string()),
-            StructuredValue::String("inner-finally".to_string()),
-            StructuredValue::String("TypeError".to_string()),
-            StructuredValue::String("outer-finally".to_string()),
-        ])
-    );
-}