Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

6.8 KB
Raw Blame
use super::*;

#[tokio::test]
async fn worker_performance_observer_delivery_follows_registration_order_after_reobserve() {
    ensure_v8();
    let source = format!(
        "({}).then(result => {{ postMessage(result); close(); }}, error => {{ postMessage({{ error: String(error) }}); close(); }});",
        include_str!("../../../../tests/fixtures/performance-observer-registration-order.js"),
    );
    let mut handle = spawn_worker(
        source,
        "test://performance-observer-registration-order".into(),
    );
    let message = timeout(TIMEOUT, handle.recv())
        .await
        .expect("registered observer delivery timed out")
        .expect("worker closed before reporting registration order");
    assert_eq!(
        expect_post_json(message),
        r#"["second:initial","first:initial","first:reobserved","second:reobserved"]"#,
    );
}

#[tokio::test]
async fn worker_webidl_callback_execution_preserves_api_exception_policies() {
    ensure_v8();
    let source = format!(
        "({}).then(result => {{ postMessage(result); close(); }}, error => {{ postMessage({{ error: String(error) }}); close(); }});",
        include_str!("../../../../tests/fixtures/webidl-callback-execution.js"),
    );
    let mut handle = spawn_worker(source, "https://callback-execution.test/worker.js".into());
    let message = timeout(TIMEOUT, handle.recv())
        .await
        .expect("shared callback policy probe timed out")
        .expect("worker closed before reporting callback policies");
    assert_eq!(
        expect_post_json(message),
        r#"{"policyThrow":true,"policyConversionThrow":true,"streamThrow":true,"streamConversionThrow":true,"notifications":["microtask"]}"#,
    );
}

#[tokio::test]
async fn worker_close_preserves_queued_microtasks_and_synchronous_callback_apis() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        queueMicrotask(() => {
            const events = [];
            const policy = trustedTypes.createPolicy('after-close', {
                createHTML(input) { return input; }
            });
            events.push(String(policy.createHTML('policy-after-close')));
            new ReadableStream({ start(controller) {
                events.push('stream-after-close');
                controller.close();
            }});
            postMessage(events);
        });
        close();
        "#
        .into(),
        "https://callback-execution.test/worker-close.js".into(),
    );
    let message = timeout(TIMEOUT, handle.recv())
        .await
        .expect("post-close microtask probe timed out")
        .expect("worker closed before draining queued microtasks");
    assert_eq!(
        expect_post_json(message),
        r#"["policy-after-close","stream-after-close"]"#
    );
    assert!(timeout(TIMEOUT, handle.recv()).await.unwrap().is_none());
}

#[tokio::test]
async fn worker_performance_observer_delivery_preserves_batches_and_reentrant_registration() {
    ensure_v8();
    let source = format!(
        "({}).then(result => {{ postMessage(result); close(); }}, error => {{ postMessage({{ error: String(error) }}); close(); }});",
        include_str!("../../../../tests/fixtures/performance-observer-delivery.js"),
    );
    let mut handle = spawn_worker(source, "test://performance-observer-delivery".into());
    let message = timeout(TIMEOUT, handle.recv())
        .await
        .expect("PerformanceObserver delivery timed out")
        .expect("worker closed before reporting delivery");
    assert_eq!(
        expect_post_json(message),
        r#"{"batches":[["first","second"],["after-reobserve"]],"taken":["taken-during-callback"],"proxyCalls":2}"#,
    );
}

#[tokio::test]
async fn worker_performance_observer_exception_routes_through_worker_error_and_can_reobserve() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        const events = [];
        const failure = new Error('performance-observer-error');
        let calls = 0;
        const observer = new PerformanceObserver(list => {
            events.push('callback:' + list.getEntries().map(entry => entry.name).join(','));
            if (++calls === 1) throw failure;
            observer.disconnect();
            postMessage(events);
            close();
        });
        self.addEventListener('error', event => {
            events.push('error:' + (event.error === failure) + ':' + (event.currentTarget === self));
            event.preventDefault();
            observer.disconnect();
            observer.observe({ type: 'mark' });
            performance.mark('after-error');
        });
        observer.observe({ type: 'mark' });
        performance.mark('before-error');
        "#
        .into(),
        "test://performance-observer-error".into(),
    );
    let message = timeout(TIMEOUT, handle.recv())
        .await
        .expect("PerformanceObserver error timed out")
        .expect("worker closed before reporting error recovery");
    assert_eq!(
        expect_post_json(message),
        r#"["callback:before-error","error:true:true","callback:after-error"]"#,
    );
    assert!(
        timeout(TIMEOUT, handle.recv()).await.unwrap().is_none(),
        "preventDefault must suppress the parent error report",
    );
}

#[tokio::test]
async fn worker_performance_observer_unhandled_exception_is_reported_to_parent() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        new PerformanceObserver(() => {
            throw new Error('unhandled-performance-observer-error');
        }).observe({ type: 'mark' });
        performance.mark('before-error');
        "#
        .into(),
        "test://performance-observer-unhandled-error".into(),
    );
    let message = timeout(TIMEOUT, handle.recv())
        .await
        .expect("PerformanceObserver parent error timed out")
        .expect("worker closed before reporting unhandled error");
    let WorkerToParentMessage::Error { message, phase, .. } = message else {
        panic!("expected worker error report, received {message:?}");
    };
    assert!(message.contains("unhandled-performance-observer-error"));
    assert_eq!(phase, WorkerErrorPhase::Runtime);
}

#[tokio::test]
async fn worker_performance_observer_does_not_deliver_after_close() {
    ensure_v8();
    let mut handle = spawn_worker(
        r#"
        new PerformanceObserver(() => postMessage('unexpected-delivery'))
            .observe({ type: 'mark' });
        performance.mark('queued-before-close');
        close();
        postMessage('closed');
        "#
        .into(),
        "test://performance-observer-close".into(),
    );
    let message = timeout(TIMEOUT, handle.recv())
        .await
        .expect("worker close timed out")
        .expect("worker closed before reporting completion");
    assert_eq!(expect_post_json(message), r#""closed""#);
    assert!(
        timeout(TIMEOUT, handle.recv()).await.unwrap().is_none(),
        "closed workers must discard pending observer deliveries",
    );
}