slhx agent
98 lines
3.9 KiB
Rust
98 lines
3.9 KiB
Rust
use hemx_test::TestProcess;
|
|
use std::net::TcpListener;
|
|
use std::process::Command;
|
|
use std::time::Duration;
|
|
use thirtyfour::prelude::*;
|
|
|
|
const STARTUP_TIMEOUT: Duration = Duration::from_secs(12);
|
|
|
|
#[tokio::test]
|
|
async fn server_first_route_does_not_load_optional_client_assets() -> WebDriverResult<()> {
|
|
// test req: performance/006
|
|
let app_port = available_port();
|
|
let app_addr = format!("127.0.0.1:{app_port}");
|
|
let mut app = Command::new(env!("CARGO_BIN_EXE_hemx-kanban-example"));
|
|
app.env("HEMX_KANBAN_ADDR", &app_addr);
|
|
let _app = TestProcess::start(app, "hemx-kanban", &app_addr, STARTUP_TIMEOUT)
|
|
.expect("start ready hemx-kanban");
|
|
|
|
let webdriver_port = available_port();
|
|
let webdriver_addr = format!("127.0.0.1:{webdriver_port}");
|
|
let mut webdriver = Command::new("geckodriver");
|
|
webdriver.arg("--port").arg(webdriver_port.to_string());
|
|
let _webdriver = TestProcess::start(webdriver, "geckodriver", &webdriver_addr, STARTUP_TIMEOUT)
|
|
.expect("start ready geckodriver");
|
|
|
|
let mut caps = DesiredCapabilities::firefox();
|
|
caps.set_headless()?;
|
|
let driver = WebDriver::new(&format!("http://{webdriver_addr}"), caps).await?;
|
|
let result = async {
|
|
driver.goto(&format!("http://{app_addr}/")).await?;
|
|
driver.find(By::Css("section[data-hemx-root='kanban']")).await?;
|
|
let loaded = driver
|
|
.execute_async(
|
|
r#"
|
|
const done = arguments[arguments.length - 1];
|
|
navigator.serviceWorker.getRegistrations().then(async (registrations) => {
|
|
const databases = indexedDB.databases ? await indexedDB.databases() : [];
|
|
done({
|
|
resources: performance.getEntriesByType('resource').map((entry) => new URL(entry.name).pathname),
|
|
scripts: [...document.scripts].map((script) => ({ src: new URL(script.src).pathname, type: script.type })),
|
|
clientRoots: document.querySelectorAll('[data-hemx-client-module]').length,
|
|
serviceWorkers: registrations.length,
|
|
databases: databases.map((database) => database.name),
|
|
});
|
|
}).catch((error) => done({ error: String(error) }));
|
|
"#,
|
|
Vec::new(),
|
|
)
|
|
.await?
|
|
.json()
|
|
.clone();
|
|
|
|
assert!(loaded["error"].is_null(), "browser inspection failed: {loaded}");
|
|
assert_eq!(loaded["clientRoots"], 0);
|
|
assert_eq!(loaded["serviceWorkers"], 0);
|
|
assert_eq!(loaded["databases"].as_array().map(Vec::len), Some(0));
|
|
let scripts = loaded["scripts"].as_array().expect("document scripts");
|
|
assert_eq!(scripts.len(), 1);
|
|
let runtime_path = scripts[0]["src"].as_str().expect("runtime script path");
|
|
assert!(
|
|
runtime_path.starts_with("/hemx.") && runtime_path.ends_with(".js"),
|
|
"unexpected server runtime asset: {loaded}"
|
|
);
|
|
assert_eq!(scripts[0]["type"], "");
|
|
let resources = loaded["resources"]
|
|
.as_array()
|
|
.expect("resource timing entries")
|
|
.iter()
|
|
.filter_map(|value| value.as_str())
|
|
.collect::<Vec<_>>();
|
|
assert!(resources.contains(&runtime_path), "runtime was not loaded: {loaded}");
|
|
for optional in [
|
|
"/hemx.client.js",
|
|
"/kanban_client.js",
|
|
"/kanban_client_bg.wasm",
|
|
"/app.js",
|
|
"/offline.js",
|
|
] {
|
|
assert!(
|
|
!resources.contains(&optional),
|
|
"server-first route loaded optional client asset {optional}: {loaded}"
|
|
);
|
|
}
|
|
Ok(())
|
|
}
|
|
.await;
|
|
let quit = driver.quit().await;
|
|
result.and(quit)
|
|
}
|
|
|
|
fn available_port() -> u16 {
|
|
TcpListener::bind("127.0.0.1:0")
|
|
.expect("reserve browser test port")
|
|
.local_addr()
|
|
.expect("browser test address")
|
|
.port()
|
|
}
|