jsdet-core 0.1.0

//! Property-based tests for jsdet-core using proptest.
//!
//! These tests verify fundamental invariants:
//! 1. Any valid package.json parses without panic
//! 2. Any JS file sandboxes without escape
//! 3. Resource limits are always enforced
//! 4. Isolation is maintained
//!
//! Every test asserts specific behavior - no `let _ = result`.
use std::sync::Arc;

use jsdet_core::{CompiledModule, EmptyBridge, ExecutionResult, Observation, SandboxConfig};
use proptest::prelude::*;

fn module() -> CompiledModule {
    CompiledModule::new().expect("Fix: CompiledModule::new() should succeed in test setup")
}

fn default_config() -> SandboxConfig {
    SandboxConfig {
        timeout_ms: 5000,
        max_fuel: 100_000_000,
        max_memory_bytes: 16 * 1024 * 1024,
        max_scripts: 100,
        max_script_bytes: 1024 * 1024,
        max_total_script_bytes: 5 * 1024 * 1024,
        ..SandboxConfig::default()
    }
}

/// Assert that execution completed without host crash.
fn assert_no_panic<T>(result: &Result<T, jsdet_core::Error>) {
    // Any Result variant means no panic - this is the invariant
    assert!(
        result.is_ok() || result.is_err(),
        "Fix: Execution must not panic"
    );
}

/// Assert that execution result shows proper resource limiting.
fn assert_resource_bounded(result: &ExecutionResult) {
    // Either completed normally or hit a resource limit
    let resource_limited = result
        .observations
        .iter()
        .any(|o| matches!(o, Observation::ResourceLimit { .. }));

    assert!(
        result.scripts_executed >= 1 || resource_limited,
        "Fix: Should execute at least one script or hit resource limit"
    );
}

// Property 1: Any valid package.json parses without panic

/// Generate valid package.json content strings.
fn valid_package_name() -> impl Strategy<Value = String> {
    // npm package name rules: lowercase, can contain hyphens, @scope/name format
    prop_oneof![
        // Simple names
        "[a-z][a-z0-9-]{0,50}".prop_map(|s| s.to_string()),
        // Scoped packages
        "@[a-z][a-z0-9-]{0,20}/[a-z][a-z0-9-]{0,50}".prop_map(|s| s.to_string()),
    ]
}

fn valid_semver() -> impl Strategy<Value = String> {
    prop_oneof![
        // Simple versions
        "[0-9].[0-9].[0-9]".prop_map(|s| s.to_string()),
        // With tilde
        "~[0-9].[0-9].[0-9]".prop_map(|s| s.to_string()),
        // With caret
        "\\^[0-9].[0-9].[0-9]".prop_map(|s| s.to_string()),
        // Ranges
        ">=[0-9].[0-9].[0-9]".prop_map(|s| s.to_string()),
    ]
}

fn valid_package_json() -> impl Strategy<Value = String> {
    (
        valid_package_name(),
        valid_semver(),
        prop::option::of(valid_semver()),
        prop::bool::ANY,
    )
        .prop_map(|(name, version, dep_version, has_scripts)| {
            let deps = match dep_version {
                Some(v) => format!(r#", "dependencies": {{ "dep-1": "{}" }}"#, v),
                None => String::new(),
            };

            let scripts = if has_scripts {
                r#", "scripts": { "test": "jest", "build": "tsc" }"#.to_string()
            } else {
                String::new()
            };

            format!(
                r#"{{"name": "{}", "version": "{}"{}{}}}"#,
                name, version, deps, scripts
            )
        })
}

proptest! {
    #![proptest_config(ProptestConfig::with_cases(100))]

    /// Property: Any syntactically valid package.json parses without panic.
    #[test]
    fn package_json_parses_without_panic(pkg_json in valid_package_json()) {
        let script = format!("var pkg = {};", pkg_json);

        let result = module().execute(
            &[script],
            Arc::new(EmptyBridge),
            &default_config(),
        );

        // Invariant: Must not panic
        assert_no_panic(&result);

        // If successful, should have executed
        if let Ok(r) = result {
            assert_eq!(r.scripts_executed, 1, "Fix: Valid JSON should execute");
        }
    }
}

proptest! {
    #![proptest_config(ProptestConfig::with_cases(50))]

    /// Property: Malformed but structurally valid JSON doesn't crash.
    #[test]
    fn malformed_json_does_not_crash(jsonish in "\\{[^}]{0,1000}\\}") {
        let script = format!("try {{ var x = {}; }} catch (e) {{}}", jsonish);

        let result = module().execute(
            &[script],
            Arc::new(EmptyBridge),
            &default_config(),
        );

        // Invariant: Must not panic regardless of input
        assert_no_panic(&result);
    }
}

// Property 2: Any JS file sandboxes without escape

/// Generate arbitrary JavaScript code strings.
fn arbitrary_js_expression() -> impl Strategy<Value = String> {
    prop_oneof![
        // Literals
        "null".prop_map(|s| s.to_string()),
        "undefined".prop_map(|s| s.to_string()),
        "true".prop_map(|s| s.to_string()),
        "false".prop_map(|s| s.to_string()),
        "[0-9]{1,10}".prop_map(|s| s.to_string()),
        "\"[a-zA-Z0-9]{0,50}\"".prop_map(|s| s.to_string()),
        // Simple expressions
        "[a-z][a-z0-9]{0,20}".prop_map(|s| s.to_string()),
    ]
}

fn arbitrary_js_statement() -> impl Strategy<Value = String> {
    prop_oneof![
        // Variable declarations
        (arbitrary_js_expression(), arbitrary_js_expression())
            .prop_map(|(name, val)| format!("var {} = {};", name, val)),
        // Function calls (likely to error, but shouldn't crash)
        arbitrary_js_expression().prop_map(|f| format!("{}();", f)),
        // Property access
        (arbitrary_js_expression(), "[a-z][a-z0-9]{0,20}")
            .prop_map(|(obj, prop)| format!("{}.{};", obj, prop)),
        // Try-catch blocks
        arbitrary_js_expression().prop_map(|e| format!("try {{ {} }} catch (e) {{}}", e)),
    ]
}

proptest! {
    #![proptest_config(ProptestConfig::with_cases(100))]

    /// Property: Any JS expression executes without escaping sandbox.
    #[test]
    fn arbitrary_js_executes_safely(statement in arbitrary_js_statement()) {
        let result = module().execute(
            &[statement],
            Arc::new(EmptyBridge),
            &default_config(),
        );

        // Invariant: Must not panic
        assert_no_panic(&result);

        // Invariant: If Ok, should be properly bounded
        if let Ok(r) = result {
            assert_resource_bounded(&r);
        }
    }
}

proptest! {
    #![proptest_config(ProptestConfig::with_cases(50))]

    /// Property: Concatenated random JS doesn't cause crashes.
    #[test]
    fn concatenated_js_executes_safely(statements in prop::collection::vec(arbitrary_js_statement(), 1..20)) {
        let script = statements.join("\n");

        let result = module().execute(
            &[script],
            Arc::new(EmptyBridge),
            &default_config(),
        );

        // Invariant: Must not panic
        assert_no_panic(&result);
    }
}

// Property 3: String operations don't cause crashes

proptest! {
    #![proptest_config(ProptestConfig::with_cases(100))]

    /// Property: Any string can be processed without crash.
    #[test]
    fn string_processing_is_safe(input in "\\PC{0,1000}") {
        let escaped = input.replace('\\', "\\\\").replace('"', "\\\"");
        let script = format!(
            r#"var s = "{}"; var upper = s.toUpperCase(); var lower = s.toLowerCase(); var len = s.length;"#,
            escaped
        );

        let result = module().execute(
            &[script],
            Arc::new(EmptyBridge),
            &default_config(),
        );

        assert_no_panic(&result);

        if let Ok(r) = result {
            assert_eq!(r.scripts_executed, 1);
        }
    }
}

proptest! {
    #![proptest_config(ProptestConfig::with_cases(50))]

    /// Property: String concatenation doesn't cause memory issues.
    #[test]
    fn string_concatenation_is_safe(
        parts in prop::collection::vec("[a-zA-Z0-9]{0,100}", 1..50)
    ) {
        let json_array = serde_json::to_string(&parts).unwrap();
        let script = format!(
            r#"var parts = {}; var result = ''; for (var i = 0; i < parts.length; i++) {{ result += parts[i]; }}"#,
            json_array
        );

        let result = module().execute(
            &[script],
            Arc::new(EmptyBridge),
            &default_config(),
        );

        assert_no_panic(&result);
    }
}

// Property 4: Numeric operations are bounded

proptest! {
    #![proptest_config(ProptestConfig::with_cases(100))]

    /// Property: Any numeric computation doesn't crash.
    #[test]
    fn numeric_operations_are_safe(a in -1e15f64..1e15f64, b in -1e15f64..1e15f64) {
        let script = format!(
            r#"var a = {}; var b = {}; var sum = a + b; var diff = a - b; var prod = a * b; var quot = b !== 0 ? a / b : 0;"#,
            a, b
        );

        let result = module().execute(
            &[script],
            Arc::new(EmptyBridge),
            &default_config(),
        );

        assert_no_panic(&result);
    }
}

proptest! {
    #![proptest_config(ProptestConfig::with_cases(50))]

    /// Property: Extreme numeric values don't crash.
    #[test]
    fn extreme_numeric_values(num in prop::num::f64::ANY) {
        let script = format!(
            r#"var n = {}; var isFinite = Number.isFinite(n); var isNaN = Number.isNaN(n); var str = n.toString();"#,
            num
        );

        let result = module().execute(
            &[script],
            Arc::new(EmptyBridge),
            &default_config(),
        );

        assert_no_panic(&result);
    }
}

// Property 5: Array operations are bounded

proptest! {
    #![proptest_config(ProptestConfig::with_cases(50))]

    /// Property: Array operations don't cause crashes.
    #[test]
    fn array_operations_are_safe(size in 0usize..1000usize) {
        let script = format!(
            r#"var arr = new Array({}); for (var i = 0; i < arr.length; i++) {{ arr[i] = i; }} var mapped = arr.map(function(x) {{ return x * 2; }});"#,
            size
        );

        let result = module().execute(
            &[script],
            Arc::new(EmptyBridge),
            &default_config(),
        );

        assert_no_panic(&result);
    }
}

// Property 6: Object operations don't cause crashes

proptest! {
    #![proptest_config(ProptestConfig::with_cases(50))]

    /// Property: Object manipulation doesn't crash.
    #[test]
    fn object_operations_are_safe(
        keys in prop::collection::vec("[a-z][a-z0-9]{0,20}", 0..50)
    ) {
        let obj_lit = keys
            .iter()
            .enumerate()
            .map(|(i, k)| format!("{}: {}", k, i))
            .collect::<Vec<_>>()
            .join(", ");

        let script = format!(
            r#"var obj = {{ {} }}; var keys = Object.keys(obj); var vals = Object.values(obj); var json = JSON.stringify(obj); var parsed = JSON.parse(json);"#,
            obj_lit
        );

        let result = module().execute(
            &[script],
            Arc::new(EmptyBridge),
            &default_config(),
        );

        assert_no_panic(&result);
    }
}

// Property 7: Execution isolation is maintained

proptest! {
    #![proptest_config(ProptestConfig::with_cases(50))]

    /// Property: State doesn't leak between executions.
    #[test]
    fn execution_isolation_is_maintained(
        first_script in arbitrary_js_statement(),
        second_script in arbitrary_js_statement()
    ) {
        let m = module();
        let bridge = Arc::new(EmptyBridge);
        let config = default_config();

        // First execution
        let r1 = m.execute(&[first_script], bridge.clone(), &config);
        assert_no_panic(&r1);

        // Second execution - must not see state from first
        let r2 = m.execute(
            &[second_script],
            bridge,
            &config,
        );
        assert_no_panic(&r2);

        // Verify second execution ran
        if let Ok(r) = r2 {
            assert!(r.scripts_executed >= 1, "Fix: Second execution should run");
        }
    }
}

// Property 8: Unicode handling is safe

proptest! {
    #![proptest_config(ProptestConfig::with_cases(50))]

    /// Property: Unicode strings don't cause crashes.
    #[test]
    fn unicode_handling_is_safe(
        input in prop::collection::vec(prop::num::u32::ANY, 0..100)
    ) {
        // Convert code points to string, filtering invalid surrogates
        let chars: String = input
            .iter()
            .filter(|&&cp| {
                // Filter out lone surrogates
                !(0xD800..=0xDFFF).contains(&cp)
            })
            .filter_map(|&cp| char::from_u32(cp))
            .collect();

        // Escape backslashes and quotes for JS string literal
        let escaped: String = chars
            .chars()
            .flat_map(|c| {
                match c {
                    '\\' => vec!['\\', '\\'],
                    '"' => vec!['\\', '"'],
                    c => vec![c],
                }
            })
            .collect();

        let script = format!(
            r#"var s = "{}"; var len = s.length; var upper = s.toUpperCase();"#,
            escaped
        );

        let result = module().execute(
            &[script],
            Arc::new(EmptyBridge),
            &default_config(),
        );

        assert_no_panic(&result);
    }
}

// Property 9: Nested structures don't cause stack overflow

proptest! {
    #![proptest_config(ProptestConfig::with_cases(30))]

    /// Property: Deeply nested objects don't cause stack overflow.
    #[test]
    fn nested_objects_are_safe(depth in 0usize..100usize) {
        // Build a deeply nested object literal
        let mut obj = "null".to_string();
        for _ in 0..depth {
            obj = format!("{{nested: {}}}", obj);
        }

        let script = format!(
            r#"var obj = {}; var d = 0; var c = obj; while (c && c.nested) {{ d++; c = c.nested; }}"#,
            obj
        );

        let result = module().execute(
            &[script],
            Arc::new(EmptyBridge),
            &default_config(),
        );

        assert_no_panic(&result);
    }
}

proptest! {
    #![proptest_config(ProptestConfig::with_cases(30))]

    /// Property: Deeply nested arrays don't cause stack overflow.
    #[test]
    fn nested_arrays_are_safe(depth in 0usize..100usize) {
        // Build a deeply nested array literal
        let mut arr = "1".to_string();
        for _ in 0..depth {
            arr = format!("[{}]", arr);
        }

        let script = format!(
            r#"var arr = {}; var f = arr.flat(Infinity);"#,
            arr
        );

        let result = module().execute(
            &[script],
            Arc::new(EmptyBridge),
            &default_config(),
        );

        assert_no_panic(&result);
    }
}

// Property 10: Resource limits are always enforced

proptest! {
    #![proptest_config(ProptestConfig::with_cases(30))]

    /// Property: Any infinite loop is terminated.
    #[test]
    fn infinite_loops_are_terminated(
        max_fuel in 1_000_000u64..50_000_000u64
    ) {
        let config = SandboxConfig {
            max_fuel,
            timeout_ms: 1000,
            ..default_config()
        };

        let result = module().execute(
            &["while(true) { var x = 1; }".into()],
            Arc::new(EmptyBridge),
            &config,
        );

        // Must terminate via fuel or timeout
        match result {
            Ok(r) => {
                let resource_limited = r.observations.iter().any(|o| {
                    matches!(o, Observation::ResourceLimit { .. })
                });
                assert!(
                    resource_limited || r.timed_out,
                    "Fix: Infinite loop must be resource-limited"
                );
            }
            Err(jsdet_core::Error::FuelExhausted { .. }) => {}
            Err(jsdet_core::Error::Timeout { .. }) => {}
            Err(e) => panic!("Fix: Unexpected error: {}", e),
        }
    }
}

// Property 11: JSON operations are safe

proptest! {
    #![proptest_config(ProptestConfig::with_cases(50))]

    /// Property: JSON.stringify/parse round-trip is safe.
    #[test]
    fn json_roundtrip_is_safe(
        num in -1000000i64..1000000i64,
        str in "[a-zA-Z0-9]{0,50}"
    ) {
        let json_str = format!(r#"{{"num": {}, "str": "{}"}}"#, num, str);
        let script = format!(
            r#"var orig = {}; var s = JSON.stringify(orig); var parsed = JSON.parse(s); var dbl = JSON.parse(JSON.stringify(parsed));"#,
            json_str
        );

        let result = module().execute(
            &[script],
            Arc::new(EmptyBridge),
            &default_config(),
        );

        assert_no_panic(&result);

        if let Ok(r) = result {
            assert_eq!(r.scripts_executed, 1);
        }
    }
}

// Property 12: Regular expressions are safe

proptest! {
    #![proptest_config(ProptestConfig::with_cases(30))]

    /// Property: Regex operations don't cause crashes.
    #[test]
    fn regex_operations_are_safe(
        pattern in "[a-zA-Z0-9.*+?]{0,20}",
        input in "[a-zA-Z0-9]{0,100}"
    ) {
        // Use JSON to properly escape the pattern for JS
        let pattern_json = serde_json::to_string(&pattern).unwrap();
        let input_json = serde_json::to_string(&input).unwrap();
        let script = format!(
            "try {{ var re = new RegExp({}); var r = re.test({}); var m = {}.match(re); }} catch (e) {{}}",
            pattern_json, input_json, input_json
        );

        let result = module().execute(
            &[script],
            Arc::new(EmptyBridge),
            &default_config(),
        );

        assert_no_panic(&result);
    }
}