mirror of
https://github.com/lexmount/moli.git
synced 2026-11-18 16:08:37 +00:00
Compile renderer tests without DevTools and run the standalone consumer against a local fixture. Route Service Worker client notifications through WorkerNavigator in worker realms.
277 lines
11 KiB
Rust
277 lines
11 KiB
Rust
use anyhow::{Result, ensure};
|
|
use axum::{Router, http::header::CONTENT_TYPE, response::Html, routing::get};
|
|
use moli_core::LayoutPolicy;
|
|
use moli_core::page::{RendererCaptureScreenshotReply, RendererPrintToPdfReply};
|
|
use moli_core::runtime::{Browser, BrowserConfig, RenderedDomWaitUntil};
|
|
use std::time::Duration;
|
|
use tokio::net::TcpListener;
|
|
|
|
fn main() -> Result<()> {
|
|
tokio::runtime::Builder::new_current_thread()
|
|
.enable_io()
|
|
.enable_time()
|
|
.build()?
|
|
.block_on(run())
|
|
}
|
|
|
|
async fn run() -> Result<()> {
|
|
let browser =
|
|
Browser::new(BrowserConfig::default().with_layout_policy(LayoutPolicy::OnDemand))?;
|
|
let script_attributes = if std::env::args().any(|arg| arg == "script") {
|
|
"defer"
|
|
} else {
|
|
r#"type="module""#
|
|
};
|
|
let source = r#"
|
|
const b = document.createElement('button');
|
|
b.textContent = 'Moli runtime';
|
|
document.body.appendChild(b);
|
|
let n = 0; b.onclick = () => n++; b.click();
|
|
if (n !== 1) throw new Error('DOM activation failed');
|
|
const range = document.createRange(); range.selectNodeContents(b);
|
|
getSelection().addRange(range);
|
|
if (getSelection().isCollapsed) throw new Error('DOM selection failed');
|
|
getSelection().removeAllRanges();
|
|
const input = document.createElement('input'); document.body.appendChild(input);
|
|
input.value = 'abc'; input.setSelectionRange(1, 2); input.setRangeText('Z');
|
|
if (input.value !== 'aZc') throw new Error('text selection failed');
|
|
globalThis.__probeDomOK = true;
|
|
"#;
|
|
let router = Router::new()
|
|
.route(
|
|
"/",
|
|
get(move || async move {
|
|
Html(format!(
|
|
r#"<!doctype html><script {script_attributes} src="/probe.js"></script><body></body>"#
|
|
))
|
|
}),
|
|
)
|
|
.route(
|
|
"/probe.js",
|
|
get(move || async move { ([(CONTENT_TYPE, "text/javascript")], source) }),
|
|
)
|
|
.route(
|
|
"/probe-sw.js",
|
|
get(|| async {
|
|
(
|
|
[(CONTENT_TYPE, "text/javascript")],
|
|
"self.addEventListener('install', e => e.waitUntil(self.skipWaiting())); self.addEventListener('activate', e => e.waitUntil(self.clients.claim()));",
|
|
)
|
|
}),
|
|
)
|
|
.route(
|
|
"/probe-shared-worker.js",
|
|
get(|| async {
|
|
(
|
|
[(CONTENT_TYPE, "text/javascript")],
|
|
r#"self.onconnect = ({ports: [port]}) => {
|
|
port.onmessage = async () => {
|
|
port.postMessage(await (await fetch('/probe-worker-resource')).text());
|
|
};
|
|
};"#,
|
|
)
|
|
}),
|
|
)
|
|
.route("/probe-worker-resource", get(|| async { "native-worker-network" }));
|
|
let listener = TcpListener::bind("127.0.0.1:0").await?;
|
|
let base_url = format!("http://{}", listener.local_addr()?);
|
|
tokio::spawn(async move { axum::serve(listener, router).await });
|
|
let mut page = browser
|
|
.fetch_with_wait_until(
|
|
&base_url,
|
|
RenderedDomWaitUntil::Idle,
|
|
Duration::from_secs(5),
|
|
)
|
|
.await?;
|
|
browser
|
|
.wait_for_selector(&mut page, "button", Duration::from_secs(2))
|
|
.await?;
|
|
browser
|
|
.wait_for_script_truthy(
|
|
&mut page,
|
|
"document.querySelector('button') !== null",
|
|
Duration::from_secs(2),
|
|
)
|
|
.await?;
|
|
let evaluation = page
|
|
.evaluate_runtime_expression_async("globalThis.__probeDomOK === true ? 6 * 7 : 0")
|
|
.await?;
|
|
let value = ["/result/result/value", "/result/value", "/value"]
|
|
.into_iter()
|
|
.find_map(|path| evaluation.pointer(path))
|
|
.and_then(|value| value.as_i64());
|
|
ensure!(value == Some(42), "unexpected evaluation: {evaluation}");
|
|
let promise = page
|
|
.evaluate_runtime_expression_with_await_async("Promise.resolve(42)", true)
|
|
.await?;
|
|
let value = ["/result/result/value", "/result/value", "/value"]
|
|
.into_iter()
|
|
.find_map(|path| promise.pointer(path))
|
|
.and_then(|value| value.as_i64());
|
|
ensure!(
|
|
value == Some(42),
|
|
"unexpected promise evaluation: {promise}"
|
|
);
|
|
let page_and_shared_worker_fetch = page
|
|
.evaluate_runtime_expression_with_await_async(
|
|
r#"(() => {
|
|
const worker = new SharedWorker('/probe-shared-worker.js');
|
|
globalThis.__probeSharedWorker = worker;
|
|
globalThis.__probeSharedWorkerFetch = () => new Promise((resolve, reject) => {
|
|
worker.onerror = reject;
|
|
worker.port.onmessage = event => resolve(event.data);
|
|
worker.port.postMessage('network');
|
|
});
|
|
return Promise.all([
|
|
fetch('/probe-worker-resource').then(response => response.text()),
|
|
__probeSharedWorkerFetch()
|
|
]).then(results => results.join('|'));
|
|
})()"#,
|
|
true,
|
|
)
|
|
.await?;
|
|
ensure!(
|
|
["/result/result/value", "/result/value", "/value"]
|
|
.into_iter()
|
|
.find_map(|path| page_and_shared_worker_fetch.pointer(path))
|
|
.and_then(|value| value.as_str())
|
|
== Some("native-worker-network|native-worker-network"),
|
|
"unexpected Page or SharedWorker fetch result: {page_and_shared_worker_fetch}"
|
|
);
|
|
let environment = moli_core::ProcessEnvironmentOwner::default();
|
|
page.evaluate_runtime_expression_with_await_async(
|
|
r#"new Promise(resolve => {
|
|
const source = `
|
|
self.onmessage = async event => {
|
|
if (event.data === 'network') {
|
|
const url = ${JSON.stringify(location.origin + '/probe-worker-resource')};
|
|
const text = await (await fetch(url)).text();
|
|
const xhrText = await new Promise((done, fail) => {
|
|
const xhr = new XMLHttpRequest(); xhr.open('GET', url);
|
|
xhr.onload = () => done(xhr.responseText); xhr.onerror = fail; xhr.send();
|
|
});
|
|
self.postMessage(text + '|' + xhrText);
|
|
} else {
|
|
self.postMessage(Intl.DateTimeFormat().resolvedOptions().timeZone);
|
|
}
|
|
};
|
|
self.postMessage('ready');
|
|
`;
|
|
const worker = new Worker(URL.createObjectURL(new Blob([source], {type: 'text/javascript'})));
|
|
globalThis.__probeWorker = worker;
|
|
globalThis.__probeWorkerRequest = (kind = 'timezone') => new Promise(done => {
|
|
worker.onmessage = event => done(event.data); worker.postMessage(kind);
|
|
});
|
|
worker.onmessage = () => resolve(true);
|
|
})"#,
|
|
true,
|
|
).await?;
|
|
let network = page
|
|
.evaluate_runtime_expression_with_await_async("__probeWorkerRequest('network')", true)
|
|
.await?;
|
|
let value = ["/result/result/value", "/result/value", "/value"]
|
|
.into_iter()
|
|
.find_map(|path| network.pointer(path))
|
|
.and_then(|value| value.as_str());
|
|
ensure!(
|
|
value == Some("native-worker-network|native-worker-network"),
|
|
"unexpected Worker fetch/XHR result: {network}"
|
|
);
|
|
for timezone in ["Asia/Tokyo", "Europe/Paris"] {
|
|
environment.set_timezone(Some(timezone))?;
|
|
let result = page
|
|
.evaluate_runtime_expression_async("Intl.DateTimeFormat().resolvedOptions().timeZone")
|
|
.await?;
|
|
let value = ["/result/result/value", "/result/value", "/value"]
|
|
.into_iter()
|
|
.find_map(|path| result.pointer(path))
|
|
.and_then(|value| value.as_str());
|
|
ensure!(
|
|
value == Some(timezone),
|
|
"timezone notification failed: {result}"
|
|
);
|
|
let result = page
|
|
.evaluate_runtime_expression_with_await_async("__probeWorkerRequest()", true)
|
|
.await?;
|
|
let value = ["/result/result/value", "/result/value", "/value"]
|
|
.into_iter()
|
|
.find_map(|path| result.pointer(path))
|
|
.and_then(|value| value.as_str());
|
|
ensure!(
|
|
value == Some(timezone),
|
|
"worker timezone notification failed: {result}"
|
|
);
|
|
}
|
|
page.evaluate_runtime_expression_async("__probeWorker.terminate()")
|
|
.await?;
|
|
let registration = page.evaluate_runtime_expression_with_await_async(
|
|
"navigator.serviceWorker.register('/probe-sw.js').then(() => navigator.serviceWorker.ready).then(r => Boolean(r.active))",
|
|
true,
|
|
).await?;
|
|
ensure!(
|
|
["/result/result/value", "/result/value", "/value"]
|
|
.into_iter()
|
|
.find_map(|path| registration.pointer(path))
|
|
.and_then(|value| value.as_bool())
|
|
== Some(true),
|
|
"service worker registration failed: {registration}"
|
|
);
|
|
browser
|
|
.wait_for_script_truthy(
|
|
&mut page,
|
|
"navigator.serviceWorker.controller !== null",
|
|
Duration::from_secs(5),
|
|
)
|
|
.await?;
|
|
let controlled_worker = page
|
|
.evaluate_runtime_expression_with_await_async(
|
|
"__probeSharedWorkerFetch().finally(() => __probeSharedWorker.port.close())",
|
|
true,
|
|
)
|
|
.await?;
|
|
ensure!(
|
|
["/result/result/value", "/result/value", "/value"]
|
|
.into_iter()
|
|
.find_map(|path| controlled_worker.pointer(path))
|
|
.and_then(|value| value.as_str())
|
|
== Some("native-worker-network"),
|
|
"SharedWorker fetch failed after ServiceWorker claim: {controlled_worker}"
|
|
);
|
|
let screenshot = page.start_capture_screenshot()?.wait().await?;
|
|
let screenshot = page.finish_capture_screenshot(screenshot)?;
|
|
match screenshot {
|
|
RendererCaptureScreenshotReply::Captured(image) => {
|
|
ensure!(image.bytes.starts_with(b"\x89PNG"), "invalid screenshot");
|
|
if let Some(directory) = std::env::var_os("MOLI_PROBE_ARTIFACT_DIR") {
|
|
std::fs::create_dir_all(&directory)?;
|
|
std::fs::write(
|
|
std::path::Path::new(&directory).join("probe.png"),
|
|
&image.bytes,
|
|
)?;
|
|
}
|
|
}
|
|
other => anyhow::bail!("screenshot failed: {other:?}"),
|
|
}
|
|
let pdf = page.start_print_to_pdf(Default::default())?.wait().await?;
|
|
match page.finish_print_to_pdf(pdf)? {
|
|
RendererPrintToPdfReply::Printed(bytes) => {
|
|
ensure!(bytes.starts_with(b"%PDF-"), "invalid PDF");
|
|
if let Some(directory) = std::env::var_os("MOLI_PROBE_ARTIFACT_DIR") {
|
|
std::fs::create_dir_all(&directory)?;
|
|
std::fs::write(std::path::Path::new(&directory).join("probe.pdf"), &bytes)?;
|
|
}
|
|
}
|
|
other => anyhow::bail!("PDF failed: {other:?}"),
|
|
}
|
|
#[cfg(feature = "devtools")]
|
|
{
|
|
page.dispatch_runtime_protocol_message_async(r#"{"id":1,"method":"Runtime.enable"}"#)
|
|
.await?;
|
|
}
|
|
println!(
|
|
"probe-ok devtools={} host_eval=true promise=true wait=true environment=true page_fetch=true dedicated_worker=true shared_worker=true service_worker=true png=true pdf=true",
|
|
cfg!(feature = "devtools")
|
|
);
|
|
Ok(())
|
|
}
|