test(kanban): prove server-first asset isolation

req: performance/006

examples/kanban/Cargo.toml

@@ -35,8 +35,9 @@ tokio = { version = "1", features = ["macros", "net", "rt-multi-thread", "time"]
 hemplate = { path = "../../../hemplate/hemplate" }
 
 [dev-dependencies]
-scraper = "0.23"
 hemx-test = { path = "../../hemx-test" }
+scraper = "0.23"
+thirtyfour = "0.35"
 
 [build-dependencies]
 hemx-build = { path = "../../hemx-build" }

examples/kanban/src/main.rs

@@ -122,7 +122,9 @@ async fn main() {
         .route(runtime_js_path(), get(runtime))
         .with_state(state);
 
-    let addr = SocketAddr::from(([127, 0, 0, 1], 3001));
+    let addr = std::env::var("HEMX_KANBAN_ADDR")
+        .map(|value| value.parse::<SocketAddr>().expect("valid HEMX_KANBAN_ADDR"))
+        .unwrap_or_else(|_| SocketAddr::from(([127, 0, 0, 1], 3001)));
     let listener = tokio::net::TcpListener::bind(addr).await.unwrap();
     println!("hemx Kanban example: http://{addr}");
     axum::serve(listener, app).await.unwrap();

examples/kanban/tests/browser_e2e.rs

@@ -0,0 +1,97 @@
+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()
+}