do-memory-mcp 0.1.46

//! Tests for the sandbox module.

use serde_json::json;
use tokio::time::{Duration, timeout};

use super::*;
use crate::types::{ErrorType, ExecutionContext, ExecutionResult, SecurityViolationType};

/// Create a test execution context
fn create_test_context() -> ExecutionContext {
    ExecutionContext::new("test".to_string(), json!({}))
}

/// Set environment once for tests to disable WASM
#[allow(unsafe_code)]
fn set_once() {
    static ONCE: std::sync::Once = std::sync::Once::new();
    ONCE.call_once(|| {
        // SAFETY: test-only env var manipulation
        unsafe {
            std::env::set_var("MCP_USE_WASM", "false");
        }
    });
}

#[tokio::test]
async fn test_simple_execution() {
    set_once();
    // Skip in CI where Node.js sandbox may be unavailable or flaky
    if std::env::var("CI").is_ok() {
        return;
    }
    let sandbox = CodeSandbox::new(SandboxConfig::default()).unwrap();
    let code = "return 1 + 1;";
    let context = create_test_context();

    let result = sandbox.execute(code, context).await.unwrap();

    match result {
        ExecutionResult::Success { .. } => {
            // Success expected
        }
        other => panic!("Expected success, got: {:?}", other),
    }
}

#[tokio::test]
async fn test_console_output() {
    set_once();
    if std::env::var("CI").is_ok() {
        return;
    }
    let sandbox = CodeSandbox::new(SandboxConfig::default()).unwrap();
    let code = r#"
        console.log("Hello");
        console.log("World");
        return "done";
    "#;
    let context = create_test_context();

    let result = sandbox.execute(code, context).await.unwrap();

    match result {
        ExecutionResult::Success { stdout, .. } => {
            assert!(stdout.contains("Hello"));
            assert!(stdout.contains("World"));
        }
        other => panic!("Expected success, got: {:?}", other),
    }
}

#[tokio::test]
async fn test_timeout_enforcement() {
    timeout(Duration::from_secs(10), async {
        set_once();
        let config = SandboxConfig {
            max_execution_time_ms: 500, // 500ms timeout
            ..Default::default()
        };

        let sandbox = CodeSandbox::new(config).unwrap();
        let code = r#"
        let sum = 0;
        for (let i = 0; i !== 10000000000; i++) {
            sum += i;
            if (i % 1000000 === 0) {
                const x = sum;
            }
        }
        return sum;
    "#;
        let context = create_test_context();

        let result = sandbox.execute(code, context).await.unwrap();

        match result {
            ExecutionResult::Timeout { .. } => {
                // Timeout expected
            }
            other => panic!("Expected timeout, got: {:?}", other),
        }
    })
    .await
    .expect("Test timed out after 10 seconds");
}

#[tokio::test]
async fn test_filesystem_blocking() {
    timeout(Duration::from_secs(10), async {
        set_once();
        let sandbox = CodeSandbox::new(SandboxConfig::default()).unwrap();
        let code = r#"
        const fs = require('fs');
        fs.readFileSync('/etc/passwd');
    "#;
        let context = create_test_context();

        let result = sandbox.execute(code, context).await.unwrap();

        match result {
            ExecutionResult::SecurityViolation {
                violation_type: SecurityViolationType::FileSystemAccess,
                ..
            } => {
                // Security violation expected
            }
            other => panic!("Expected security violation, got: {:?}", other),
        }
    })
    .await
    .expect("Test timed out after 10 seconds");
}

#[tokio::test]
async fn test_network_blocking() {
    timeout(Duration::from_secs(10), async {
        set_once();
        let sandbox = CodeSandbox::new(SandboxConfig::default()).unwrap();
        let code = r#"
        const https = require('https');
        https.get('https://example.com');
    "#;
        let context = create_test_context();

        let result = sandbox.execute(code, context).await.unwrap();

        match result {
            ExecutionResult::SecurityViolation {
                violation_type: SecurityViolationType::NetworkAccess,
                ..
            } => {
                // Security violation expected
            }
            other => panic!("Expected security violation, got: {:?}", other),
        }
    })
    .await
    .expect("Test timed out after 10 seconds");
}

#[tokio::test]
async fn test_process_execution_blocking() {
    set_once();
    let sandbox = CodeSandbox::new(SandboxConfig::default()).unwrap();
    let code = r#"
        const { exec } = require('child_process');
        exec('ls -la');
    "#;
    let context = create_test_context();

    let result = sandbox.execute(code, context).await.unwrap();

    match result {
        ExecutionResult::SecurityViolation {
            violation_type: SecurityViolationType::ProcessExecution,
            ..
        } => {
            // Security violation expected
        }
        other => panic!("Expected security violation, got: {:?}", other),
    }
}

#[tokio::test]
async fn test_security_bypass_attempts() {
    set_once();
    let sandbox = CodeSandbox::new(SandboxConfig::default()).unwrap();
    let context = create_test_context();

    // 1. Whitespace bypass
    let code1 = "const fs = require (  'fs'   );";
    let result1 = sandbox.execute(code1, context.clone()).await.unwrap();
    assert!(matches!(
        result1,
        ExecutionResult::SecurityViolation {
            violation_type: SecurityViolationType::FileSystemAccess,
            ..
        }
    ));

    // 2. Template literal bypass
    let code2 = "const fs = require(`fs`);";
    let result2 = sandbox.execute(code2, context.clone()).await.unwrap();
    assert!(matches!(
        result2,
        ExecutionResult::SecurityViolation {
            violation_type: SecurityViolationType::FileSystemAccess,
            ..
        }
    ));

    // 3. Newline bypass
    let code3 = "const fs = require(\n'fs'\n);";
    let result3 = sandbox.execute(code3, context.clone()).await.unwrap();
    assert!(matches!(
        result3,
        ExecutionResult::SecurityViolation {
            violation_type: SecurityViolationType::FileSystemAccess,
            ..
        }
    ));

    // 4. Malicious code (Function constructor)
    let code4 = "const f = new Function('return process');";
    let result4 = sandbox.execute(code4, context.clone()).await.unwrap();
    assert!(matches!(
        result4,
        ExecutionResult::SecurityViolation {
            violation_type: SecurityViolationType::MaliciousCode,
            ..
        }
    ));

    // 5. Runtime obfuscation bypass (split string)
    // This should NOT be caught by detect_security_violations (static analysis),
    // but should fail at runtime because 'require' is shadowed and deleted.
    let code5 = "const r = 'req' + 'uire'; const fs = global[r]('fs');";
    let result5 = sandbox.execute(code5, context.clone()).await.unwrap();
    match result5 {
        ExecutionResult::Error { .. } => {
            // Expected runtime error since require is not available
            // (exact message varies by Node.js version)
        }
        other => panic!(
            "Expected runtime error for split-string bypass, got: {:?}",
            other
        ),
    }
}

#[tokio::test]
async fn test_infinite_loop_detection() {
    timeout(Duration::from_secs(10), async {
        set_once();
        let sandbox = CodeSandbox::new(SandboxConfig::default()).unwrap();
        let code = "while(true) {}";
        let context = create_test_context();

        let result = sandbox.execute(code, context).await.unwrap();

        match result {
            ExecutionResult::SecurityViolation {
                violation_type: SecurityViolationType::InfiniteLoop,
                ..
            } => {
                // Security violation expected
            }
            other => panic!("Expected security violation, got: {:?}", other),
        }
    })
    .await
    .expect("Test timed out after 10 seconds");
}

#[tokio::test]
async fn test_eval_blocking() {
    set_once();
    let sandbox = CodeSandbox::new(SandboxConfig::default()).unwrap();
    let code = r#"eval("malicious code");"#;
    let context = create_test_context();

    let result = sandbox.execute(code, context).await.unwrap();

    match result {
        ExecutionResult::SecurityViolation {
            violation_type: SecurityViolationType::MaliciousCode,
            ..
        } => {
            // Security violation expected
        }
        other => panic!("Expected security violation, got: {:?}", other),
    }
}

#[tokio::test]
async fn test_syntax_error() {
    set_once();
    if std::env::var("CI").is_ok() {
        return;
    }
    let sandbox = CodeSandbox::new(SandboxConfig::default()).unwrap();
    let code = "const x = ;"; // Invalid syntax
    let context = create_test_context();

    let result = sandbox.execute(code, context).await.unwrap();

    match &result {
        ExecutionResult::Error {
            error_type: ErrorType::Syntax,
            ..
        }
        | ExecutionResult::Error {
            error_type: ErrorType::Runtime,
            ..
        } => {
            // Syntax error expected; newer JS runtimes report as Runtime error
        }
        other => panic!("Expected syntax/runtime error, got: {:?}", other),
    }
}

#[tokio::test]
async fn test_runtime_error() {
    set_once();
    if std::env::var("CI").is_ok() {
        return;
    }
    let sandbox = CodeSandbox::new(SandboxConfig::default()).unwrap();
    let code = r#"
        throw new Error("Runtime error");
    "#;
    let context = create_test_context();

    let result = sandbox.execute(code, context).await.unwrap();

    match result {
        ExecutionResult::Error {
            error_type: ErrorType::Runtime,
            message,
            ..
        } => {
            assert!(message.contains("Runtime error"));
        }
        other => panic!("Expected runtime error, got: {:?}", other),
    }
}

/// Verify the secure wrapper deletes dangerous globals at runtime.
/// This is a pure-Rust test that does NOT require Node.js, so it runs in CI.
/// It validates the defense-in-depth approach: even if static regex checks
/// are bypassed via runtime obfuscation, the globals are unavailable.
#[test]
fn test_wrapper_deletes_dangerous_globals() {
    set_once();
    let sandbox = CodeSandbox::new(SandboxConfig::default()).unwrap();
    let wrapper = sandbox
        .create_secure_wrapper("1+1", &create_test_context())
        .unwrap();

    // Core dangerous globals must be deleted from the global scope
    assert!(
        wrapper.contains("delete global.process"),
        "Wrapper must delete global.process"
    );
    assert!(
        wrapper.contains("delete global.require"),
        "Wrapper must delete global.require"
    );
    assert!(
        wrapper.contains("delete global.eval"),
        "Wrapper must delete global.eval to prevent runtime obfuscation bypass"
    );
    assert!(
        wrapper.contains("delete global.Function"),
        "Wrapper must delete global.Function to prevent runtime obfuscation bypass"
    );
}

/// Verify the pre-flight Node.js check works.
/// When node is available, CodeSandbox::new succeeds; when unavailable, it errors.
#[tokio::test]
async fn test_preflight_node_check() {
    set_once();
    if which::which("node").is_ok() {
        let result = CodeSandbox::new(SandboxConfig::default());
        assert!(
            result.is_ok(),
            "CodeSandbox::new should succeed when node is available"
        );
    } else {
        // Node not in PATH — should return an error, not panic
        let result = CodeSandbox::new(SandboxConfig::default());
        assert!(
            result.is_err(),
            "CodeSandbox::new should error when node is not in PATH"
        );
    }
}

/// Verify runtime blocking of eval/Function when static regex is bypassed.
/// Requires Node.js, so skipped in CI.
#[tokio::test]
async fn test_eval_runtime_blocking() {
    timeout(Duration::from_secs(10), async {
        set_once();
        if std::env::var("CI").is_ok() {
            return;
        }
        let sandbox = CodeSandbox::new(SandboxConfig::default()).unwrap();
        let context = create_test_context();

        // Runtime obfuscation bypass of eval via dynamic property access.
        // Static regex should NOT catch this (split string), but eval is
        // deleted from global scope so it should fail at runtime.
        let code = "const e = 'ev' + 'al'; global[e]('process');";
        let result = sandbox.execute(code, context.clone()).await.unwrap();
        match result {
            ExecutionResult::Error { message, .. } => {
                assert!(
                    message.contains("is not a function")
                        || message.contains("is not defined")
                        || message.contains("cannot read")
                );
            }
            other => panic!("Expected runtime error for eval bypass, got: {:?}", other),
        }

        // Same for Function constructor via runtime obfuscation
        let code2 = "const f = global['Fun' + 'ction']('return process');";
        let result2 = sandbox.execute(code2, context).await.unwrap();
        match result2 {
            ExecutionResult::Error { message, .. } => {
                assert!(
                    message.contains("is not a function")
                        || message.contains("is not defined")
                        || message.contains("cannot read")
                );
            }
            other => panic!(
                "Expected runtime error for Function bypass, got: {:?}",
                other
            ),
        }
    })
    .await
    .expect("Test timed out after 10 seconds");
}

#[tokio::test]
async fn test_code_length_limit() {
    set_once();
    let sandbox = CodeSandbox::new(SandboxConfig::default()).unwrap();
    let code = "a".repeat(100_001); // Exceeds 100KB limit
    let context = create_test_context();

    let result = sandbox.execute(&code, context).await.unwrap();

    match result {
        ExecutionResult::SecurityViolation { .. } => {
            // Security violation expected
        }
        other => panic!("Expected security violation, got: {:?}", other),
    }
}