mustardscript 0.1.0 → 0.1.1

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

@@ -1,553 +0,0 @@
-use super::*;
-
-#[test]
-fn runs_arithmetic_and_locals() {
-    let value = run(r#"
-            const a = 4;
-            const b = 3;
-            a * b + 2;
-            "#);
-    assert_eq!(
-        value,
-        StructuredValue::Number(StructuredNumber::Finite(14.0))
-    );
-}
-
-#[test]
-fn runs_string_relational_comparisons_with_lexicographic_ordering() {
-    let value = run(
-        r#"
-            const left = "az";
-            const right = "ba";
-            [left < right, left <= left, right > left, right >= right];
-            "#,
-    );
-    assert_eq!(
-        value,
-        StructuredValue::Array(vec![
-            StructuredValue::Bool(true),
-            StructuredValue::Bool(true),
-            StructuredValue::Bool(true),
-            StructuredValue::Bool(true),
-        ])
-    );
-}
-
-#[test]
-fn runs_logical_assignment_with_short_circuit_semantics() {
-    let value = run(
-        r#"
-            let orAssign = 0;
-            const orAssignResult = (orAssign ||= 4);
-            let orKeep = 7;
-            const orKeepResult = (orKeep ||= 9);
-            let andAssign = 3;
-            const andAssignResult = (andAssign &&= 5);
-            let andKeep = 0;
-            const andKeepResult = (andKeep &&= 9);
-
-            const counts = { object: 0, key: 0, rhs: 0 };
-            const record = { slot: 0, gate: 2 };
-            function object() {
-              counts.object += 1;
-              return record;
-            }
-            function key() {
-              counts.key += 1;
-              return "slot";
-            }
-            function rhs(value) {
-              counts.rhs += 1;
-              return value;
-            }
-
-            const computedOrAssign = (object()[key()] ||= rhs(6));
-            const computedOrKeep = (object()[key()] ||= rhs(7));
-            const staticAndAssign = (object().gate &&= rhs(8));
-            record.gate = 0;
-            const staticAndKeep = (object().gate &&= rhs(9));
-
-            [
-              orAssign,
-              orAssignResult,
-              orKeep,
-              orKeepResult,
-              andAssign,
-              andAssignResult,
-              andKeep,
-              andKeepResult,
-              computedOrAssign,
-              computedOrKeep,
-              staticAndAssign,
-              staticAndKeep,
-              counts.object,
-              counts.key,
-              counts.rhs,
-              record.slot,
-              record.gate,
-            ];
-            "#,
-    );
-    assert_eq!(
-        value,
-        StructuredValue::Array(vec![
-            StructuredValue::Number(StructuredNumber::Finite(4.0)),
-            StructuredValue::Number(StructuredNumber::Finite(4.0)),
-            StructuredValue::Number(StructuredNumber::Finite(7.0)),
-            StructuredValue::Number(StructuredNumber::Finite(7.0)),
-            StructuredValue::Number(StructuredNumber::Finite(5.0)),
-            StructuredValue::Number(StructuredNumber::Finite(5.0)),
-            StructuredValue::Number(StructuredNumber::Finite(0.0)),
-            StructuredValue::Number(StructuredNumber::Finite(0.0)),
-            StructuredValue::Number(StructuredNumber::Finite(6.0)),
-            StructuredValue::Number(StructuredNumber::Finite(6.0)),
-            StructuredValue::Number(StructuredNumber::Finite(8.0)),
-            StructuredValue::Number(StructuredNumber::Finite(0.0)),
-            StructuredValue::Number(StructuredNumber::Finite(4.0)),
-            StructuredValue::Number(StructuredNumber::Finite(2.0)),
-            StructuredValue::Number(StructuredNumber::Finite(3.0)),
-            StructuredValue::Number(StructuredNumber::Finite(6.0)),
-            StructuredValue::Number(StructuredNumber::Finite(0.0)),
-        ])
-    );
-}
-
-#[test]
-fn runs_functions_and_closures() {
-    let value = run(r#"
-            function makeAdder(x) {
-              return (y) => x + y;
-            }
-            const add2 = makeAdder(2);
-            add2(5);
-            "#);
-    assert_eq!(
-        value,
-        StructuredValue::Number(StructuredNumber::Finite(7.0))
-    );
-}
-
-#[test]
-fn runs_arrays_objects_and_member_access() {
-    let value = run(r#"
-            const values = [1, 2];
-            const record = { total: values[0] + values[1] };
-            record.total;
-            "#);
-    assert_eq!(
-        value,
-        StructuredValue::Number(StructuredNumber::Finite(3.0))
-    );
-}
-
-#[test]
-fn runs_for_in_over_plain_objects_and_arrays() {
-    let value = run(r#"
-            const object = { beta: 2, alpha: 1 };
-            const array = [10, 20];
-            array.extra = 30;
-            const objectKeys = [];
-            for (const key in object) {
-              objectKeys[objectKeys.length] = key;
-            }
-            const arrayKeys = [];
-            for (const key in array) {
-              arrayKeys[arrayKeys.length] = key;
-            }
-            [objectKeys, arrayKeys];
-            "#);
-    assert_eq!(
-        value,
-        StructuredValue::Array(vec![
-            StructuredValue::Array(vec![
-                StructuredValue::String("alpha".to_string()),
-                StructuredValue::String("beta".to_string()),
-            ]),
-            StructuredValue::Array(vec![
-                StructuredValue::String("0".to_string()),
-                StructuredValue::String("1".to_string()),
-                StructuredValue::String("extra".to_string()),
-            ]),
-        ])
-    );
-}
-
-#[test]
-fn for_in_supports_assignment_target_headers() {
-    let value = run(r#"
-            const record = { current: "" };
-            for (record.current in { beta: 2, alpha: 1 }) {
-            }
-            record.current;
-            "#);
-    assert_eq!(value, StructuredValue::String("beta".to_string()));
-}
-
-#[test]
-fn runs_branching_loops_and_switch() {
-    let value = run(r#"
-            let total = 0;
-            let i = 0;
-            while (i < 4) {
-              total += i;
-              i += 1;
-            }
-            do {
-              total += 1;
-            } while (false);
-            for (let j = 0; j < 2; j += 1) {
-              if (j === 0) {
-                continue;
-              }
-              total += j;
-            }
-            switch (total) {
-              case 8:
-                total += 1;
-                break;
-              default:
-                total = 0;
-            }
-            total;
-            "#);
-    assert_eq!(
-        value,
-        StructuredValue::Number(StructuredNumber::Finite(9.0))
-    );
-}
-
-#[test]
-fn for_in_snapshots_keys_and_survives_resumption() {
-    let program = compile(r#"
-            let total = 0;
-            for (const key in { beta: 2, alpha: 1 }) {
-              total += fetch_data(key);
-            }
-            total;
-            "#)
-    .expect("source should compile");
-
-    let first = match start(
-        &program,
-        ExecutionOptions {
-            inputs: IndexMap::new(),
-            capabilities: vec!["fetch_data".to_string()],
-            limits: RuntimeLimits::default(),
-            cancellation_token: None,
-        },
-    )
-    .expect("start should suspend")
-    {
-        ExecutionStep::Suspended(suspension) => suspension,
-        ExecutionStep::Completed(value) => panic!("expected suspension, got {value:?}"),
-    };
-    assert_eq!(first.capability, "fetch_data");
-    assert_eq!(
-        first.args,
-        vec![StructuredValue::String("alpha".to_string())]
-    );
-
-    let encoded = dump_snapshot(&first.snapshot).expect("snapshot should serialize");
-    let loaded = load_snapshot(&encoded).expect("snapshot should deserialize");
-
-    let second = match resume_with_options(
-        loaded,
-        ResumePayload::Value(StructuredValue::Number(StructuredNumber::Finite(10.0))),
-        ResumeOptions {
-            cancellation_token: None,
-            snapshot_policy: Some(snapshot_policy(
-                &["fetch_data"],
-                RuntimeLimits::default(),
-            )),
-        },
-    )
-    .expect("resume should work")
-    {
-        ExecutionStep::Suspended(suspension) => suspension,
-        ExecutionStep::Completed(value) => panic!("expected second suspension, got {value:?}"),
-    };
-    assert_eq!(second.capability, "fetch_data");
-    assert_eq!(
-        second.args,
-        vec![StructuredValue::String("beta".to_string())]
-    );
-
-    match resume(second.snapshot, ResumePayload::Value(StructuredValue::Number(
-        StructuredNumber::Finite(20.0),
-    )))
-    .expect("final resume should work")
-    {
-        ExecutionStep::Completed(value) => {
-            assert_eq!(value, StructuredValue::Number(StructuredNumber::Finite(30.0)));
-        }
-        other => panic!("expected completion, got {other:?}"),
-    }
-}
-
-#[test]
-fn for_in_rejects_unsupported_rhs_values() {
-    let program = compile(
-        r#"
-        for (const key in new Map()) {
-          key;
-        }
-        "#,
-    )
-    .expect("source should compile");
-
-    let error = execute(&program, ExecutionOptions::default()).expect_err("execution should fail");
-    assert!(
-        error
-            .to_string()
-            .contains("Object helpers currently only support plain objects and arrays")
-    );
-}
-
-#[test]
-fn runs_math_and_json_builtins() {
-    let value = run(r#"
-            const encoded = JSON.stringify({ value: Math.max(1, 9, 4) });
-            JSON.parse(encoded).value;
-            "#);
-    assert_eq!(
-        value,
-        StructuredValue::Number(StructuredNumber::Finite(9.0))
-    );
-}
-
-#[test]
-fn preserves_supported_enumeration_order_for_json_stringify() {
-    let value = run(r#"
-            const record = {};
-            record.beta = "b";
-            record[10] = "ten";
-            record.alpha = "a";
-            record[2] = "two";
-            record["01"] = "leading";
-            const values = ["c", "d"];
-            values.extra = "ignored";
-            JSON.stringify({ record, values });
-            "#);
-    assert_eq!(
-        value,
-        StructuredValue::String(
-            r#"{"record":{"2":"two","10":"ten","beta":"b","alpha":"a","01":"leading"},"values":["c","d"]}"#
-                .to_string()
-        )
-    );
-}
-
-#[test]
-fn runs_object_literals_with_computed_keys_methods_and_spread() {
-    let value = run(
-        r#"
-            const key = "value";
-            const extra = [3];
-            extra.label = "ok";
-            const record = {
-              alpha: 1,
-              [key]: 2,
-              total(step) {
-                return this.alpha + this[key] + step;
-              },
-              ...null,
-              ...extra,
-              ...{ beta: 4 },
-            };
-            [record.value, record[0], record.label, record.total(5), record.beta];
-            "#,
-    );
-    assert_eq!(
-        value,
-        StructuredValue::Array(vec![
-            StructuredValue::Number(StructuredNumber::Finite(2.0)),
-            StructuredValue::Number(StructuredNumber::Finite(3.0)),
-            StructuredValue::String("ok".to_string()),
-            StructuredValue::Number(StructuredNumber::Finite(8.0)),
-            StructuredValue::Number(StructuredNumber::Finite(4.0)),
-        ])
-    );
-}
-
-#[test]
-fn runs_array_spread_and_spread_arguments() {
-    let value = run(
-        r#"
-            const values = [2, 4];
-            const sparse = [2, , 4];
-            const extra = new Set("ab");
-            const box = {
-              base: 10,
-              total(...args) {
-                return this.base + args[0] + args[1] + args[2] + args[3];
-              },
-            };
-            const array = [1, ...sparse, ...extra, 5];
-            const built = new Array(...values, 9);
-            [
-              array,
-              box.total(...values, 6),
-              [1, ...sparse][2],
-              Math.max(...values, 3),
-              built,
-              ({ missing: null }).missing?.(...values),
-            ];
-            "#,
-    );
-    assert_eq!(
-        value,
-        StructuredValue::Array(vec![
-            StructuredValue::Array(vec![
-                StructuredValue::Number(StructuredNumber::Finite(1.0)),
-                StructuredValue::Number(StructuredNumber::Finite(2.0)),
-                StructuredValue::Null,
-                StructuredValue::Number(StructuredNumber::Finite(4.0)),
-                StructuredValue::String("a".to_string()),
-                StructuredValue::String("b".to_string()),
-                StructuredValue::Number(StructuredNumber::Finite(5.0)),
-            ]),
-            StructuredValue::Number(StructuredNumber::Finite(22.0)),
-            StructuredValue::Null,
-            StructuredValue::Number(StructuredNumber::Finite(4.0)),
-            StructuredValue::Array(vec![
-                StructuredValue::Number(StructuredNumber::Finite(2.0)),
-                StructuredValue::Number(StructuredNumber::Finite(4.0)),
-                StructuredValue::Number(StructuredNumber::Finite(9.0)),
-            ]),
-            StructuredValue::Undefined,
-        ])
-    );
-}
-
-#[test]
-fn spread_fails_closed_for_unsupported_iterables() {
-    let program = compile(
-        r#"
-            const object = { alpha: 1 };
-            [ [...object], Math.max(...object) ];
-            "#,
-    )
-    .expect("spread should lower");
-    let error = execute(&program, ExecutionOptions::default())
-        .expect_err("unsupported spread sources should fail closed at runtime");
-    assert!(
-        error
-            .to_string()
-            .contains("value is not iterable in the supported surface")
-    );
-}
-
-#[test]
-fn runs_sparse_arrays_across_helpers_and_json() {
-    let value = run(
-        r#"
-            const values = [1, , undefined, 4];
-            const callbackIndexes = [];
-            values.forEach((value, index) => {
-              callbackIndexes[callbackIndexes.length] = index;
-            });
-            const sliced = values.slice(0, 4);
-            const mapped = values.map((value, index) => value ?? (index + 10));
-            JSON.stringify({
-              length: values.length,
-              holeIsUndefined: values[1] === undefined,
-              hasHole: 1 in values,
-              hasUndefined: 2 in values,
-              keys: Object.keys(values),
-              entries: Object.entries(values),
-              iterated: Array.from(values.values()),
-              includesUndefined: values.includes(undefined),
-              indexOfUndefined: values.indexOf(undefined),
-              joined: values.join("-"),
-              json: JSON.stringify(values),
-              callbackIndexes,
-              slicedHasHole: 1 in sliced,
-              mappedHasHole: 1 in mapped,
-              mappedKeys: Object.keys(mapped),
-            });
-            "#,
-    );
-    assert_eq!(
-        value,
-        StructuredValue::String(
-            r#"{"length":4,"holeIsUndefined":true,"hasHole":false,"hasUndefined":true,"keys":["0","2","3"],"entries":[["0",1],["2",null],["3",4]],"iterated":[1,null,null,4],"includesUndefined":true,"indexOfUndefined":2,"joined":"1---4","json":"[1,null,null,4]","callbackIndexes":[0,2,3],"slicedHasHole":false,"mappedHasHole":false,"mappedKeys":["0","2","3"]}"#
-                .to_string()
-        )
-    );
-}
-
-#[test]
-fn structured_inputs_preserve_sparse_array_holes() {
-    let program = compile(
-        r#"
-            [
-              Object.keys(value),
-              value[0] === undefined,
-              0 in value,
-              1 in value,
-              value[1],
-              JSON.stringify(value),
-            ];
-            "#,
-    )
-    .expect("source should compile");
-
-    let value = execute(
-        &program,
-        ExecutionOptions {
-            inputs: IndexMap::from([(
-                "value".to_string(),
-                StructuredValue::Array(vec![
-                    StructuredValue::Hole,
-                    StructuredValue::Number(StructuredNumber::Finite(2.0)),
-                    StructuredValue::Hole,
-                ]),
-            )]),
-            ..ExecutionOptions::default()
-        },
-    )
-    .expect("program should run");
-
-    assert_eq!(
-        value,
-        StructuredValue::Array(vec![
-            StructuredValue::Array(vec![StructuredValue::String("1".to_string())]),
-            StructuredValue::Bool(true),
-            StructuredValue::Bool(false),
-            StructuredValue::Bool(true),
-            StructuredValue::Number(StructuredNumber::Finite(2.0)),
-            StructuredValue::String("[null,2,null]".to_string()),
-        ])
-    );
-}
-
-#[test]
-fn object_spread_fails_closed_for_unsupported_sources() {
-    let program = compile("({ ...1 });").expect("object spread should lower");
-    let error = execute(&program, ExecutionOptions::default())
-        .expect_err("unsupported object spread sources should fail closed at runtime");
-    assert!(
-        error
-            .to_string()
-            .contains("object spread currently only supports plain objects and arrays")
-    );
-}
-
-#[test]
-fn enforces_instruction_budget() {
-    let program = compile("while (true) {}").expect("source should compile");
-    let error = execute(
-        &program,
-        ExecutionOptions {
-            inputs: IndexMap::new(),
-            capabilities: Vec::new(),
-            limits: RuntimeLimits {
-                instruction_budget: 100,
-                ..RuntimeLimits::default()
-            },
-            cancellation_token: None,
-        },
-    )
-    .expect_err("infinite loop should exhaust budget");
-    assert!(error.to_string().contains("instruction budget exhausted"));
-}