Skip to content

armgit / moli

Public Imported from GitHub
0

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

test: cover input ack cleanup on page replacement

ldm0f283d437a5fc
diff --git a/moli-protocol/src/conn/dispatch.rs b/moli-protocol/src/conn/dispatch.rs
index 28e1aa45c..2a9d7ca49 100644
--- a/moli-protocol/src/conn/dispatch.rs
+++ b/moli-protocol/src/conn/dispatch.rs
@@ -186,6 +186,14 @@ impl PendingCdpCommandDispatch {
self.inner.name()
}
+ #[cfg(test)]
+ pub(crate) fn hold_input_renderer_ack_for_test(&mut self) -> bool {
+ match &mut self.inner {
+ PendingCdpCommandDispatchKind::Input(pending) => pending.hold_renderer_ack_for_test(),
+ _ => false,
+ }
+ }
+
pub fn command_id(&self) -> Option<u64> {
match &self.inner {
PendingCdpCommandDispatchKind::Runtime(pending) => pending.command_id(),
diff --git a/moli-protocol/src/domains/input.rs b/moli-protocol/src/domains/input.rs
index bbf591c66..9cb4d5040 100644
--- a/moli-protocol/src/domains/input.rs
+++ b/moli-protocol/src/domains/input.rs
@@ -132,6 +132,8 @@ enum PendingInputCommandKind {
enum PendingInputOperation {
Page(PendingPageCommand),
+ #[cfg(test)]
+ RendererAckHeldForTest,
}
enum CompletedInputOperation {
@@ -187,6 +189,23 @@ impl PendingInputCommandDispatch {
) => CompletedInputOperation::PageResidenceUnavailable,
}
}
+ #[cfg(test)]
+ PendingInputOperation::RendererAckHeldForTest => {
+ match wait_for_renderer_input_or_page_replacement(
+ std::future::pending::<std::convert::Infallible>(),
+ self.owner_observer,
+ )
+ .await
+ {
+ RendererInputWaitOutcome::Completed(never) => match never {},
+ RendererInputWaitOutcome::PageResidence(
+ TargetPageResidenceObservation::Superseded,
+ ) => CompletedInputOperation::PageResidenceSuperseded,
+ RendererInputWaitOutcome::PageResidence(
+ TargetPageResidenceObservation::Unavailable,
+ ) => CompletedInputOperation::PageResidenceUnavailable,
+ }
+ }
};
CompletedInputCommandDispatch {
command_id: self.command_id,
@@ -196,6 +215,20 @@ impl PendingInputCommandDispatch {
completed,
}
}
+
+ #[cfg(test)]
+ pub(crate) fn hold_renderer_ack_for_test(&mut self) -> bool {
+ // The command has already crossed the real JSON/domain admission path
+ // and been enqueued in the renderer. Replacing only its reply receiver
+ // gives lifecycle smoke tests a deterministic outstanding callback;
+ // public CDP intentionally cannot pause that callback while also
+ // scheduling a replacement of the same Page owner.
+ if !self.kind.uses_renderer_host_ack_cleanup() || self.owner_observer.is_none() {
+ return false;
+ }
+ self.pending = PendingInputOperation::RendererAckHeldForTest;
+ true
+ }
}
impl CompletedInputCommandDispatch {
diff --git a/moli-protocol/src/domains/input/tests.rs b/moli-protocol/src/domains/input/tests.rs
index 689f72347..033474ac4 100644
--- a/moli-protocol/src/domains/input/tests.rs
+++ b/moli-protocol/src/domains/input/tests.rs
@@ -365,6 +365,54 @@ async fn pending_mouse_event_acknowledges_when_page_is_replaced_before_renderer_
assert!(completed.protocol_events.is_empty());
}
+#[tokio::test(flavor = "multi_thread")]
+async fn completed_renderer_ack_wins_when_page_replacement_is_already_observable() {
+ let mut ctx = TestContext::new();
+ with_loaded_document(&mut ctx, "<body>origin</body>").await;
+
+ let original_owner = ctx
+ .conn
+ .target_page_residence_identity_for_session(None)
+ .expect("the original Page should have a residence identity");
+ let observer = ctx
+ .conn
+ .register_target_page_residence_observer_for_session(None, &original_owner);
+ ctx.install_navigation_fixture_for_session_owner(
+ "data:text/html,<body>replacement-after-ack</body>",
+ None,
+ )
+ .await;
+
+ let outcome = wait_for_renderer_input_or_page_replacement(
+ std::future::ready("renderer-ack"),
+ Some(observer),
+ )
+ .await;
+ assert!(matches!(
+ outcome,
+ RendererInputWaitOutcome::Completed("renderer-ack")
+ ));
+}
+
+#[test]
+fn renderer_host_ack_cleanup_is_limited_to_mouse_and_key_callbacks() {
+ for kind in [
+ PendingInputCommandKind::DispatchMouseEvent,
+ PendingInputCommandKind::DispatchKeyEvent,
+ ] {
+ assert!(kind.uses_renderer_host_ack_cleanup());
+ }
+
+ for kind in [
+ PendingInputCommandKind::DispatchTouchEvent,
+ PendingInputCommandKind::DispatchDragEvent,
+ PendingInputCommandKind::SynthesizeTapGesture,
+ PendingInputCommandKind::InsertText,
+ ] {
+ assert!(!kind.uses_renderer_host_ack_cleanup());
+ }
+}
+
#[tokio::test(flavor = "multi_thread")]
async fn coordinate_mouse_event_without_document_still_reports_no_document_loaded() {
let mut ctx = TestContext::new();
diff --git a/moli-protocol/src/domains/target/tests/tests_cdp_chromium_imports/p0_input.rs b/moli-protocol/src/domains/target/tests/tests_cdp_chromium_imports/p0_input.rs
index 5d10adf46..149b059cd 100644
--- a/moli-protocol/src/domains/target/tests/tests_cdp_chromium_imports/p0_input.rs
+++ b/moli-protocol/src/domains/target/tests/tests_cdp_chromium_imports/p0_input.rs
@@ -1,7 +1,81 @@
use super::super::tests_cdp_smoke_fixture::SmokeFixtureServer;
use super::super::*;
use super::support::CdpPageHarness;
+use crate::conn::CdpCommandTaskStep;
use serde_json::json;
+use std::time::Duration;
+
+async fn expect_page_replacement_cleans_up_pending_input_ack(
+ ctx: &mut TestContext,
+ page: &CdpPageHarness,
+ command_id: u64,
+ method: &str,
+ params: Value,
+ replacement_marker: &str,
+) {
+ let original_owner = ctx
+ .conn
+ .target_page_residence_identity_for_session(Some(&page.session_id))
+ .expect("the input command should have a Page owner");
+ let raw = json!({
+ "id": command_id,
+ "method": method,
+ "sessionId": page.session_id,
+ "params": params
+ })
+ .to_string();
+ let mut pending = match ctx.conn.start_command_dispatch(&raw) {
+ CdpCommandTaskStep::Pending(pending) => pending,
+ CdpCommandTaskStep::Complete(_) => {
+ panic!("{method} should wait for a renderer ACK")
+ }
+ };
+ assert_eq!(pending.kind_name(), "Input");
+ assert!(
+ pending.hold_input_renderer_ack_for_test(),
+ "{method} should use Chromium's renderer-host ACK cleanup queue"
+ );
+
+ let mut completion = Box::pin(pending.wait());
+ assert!(
+ tokio::time::timeout(Duration::from_millis(25), &mut completion)
+ .await
+ .is_err(),
+ "{method} must not reply before either its renderer ACK or Page replacement"
+ );
+
+ let replacement_url = format!(
+ "data:text/html,<body data-marker='{replacement_marker}'>{replacement_marker}</body>"
+ );
+ ctx.install_navigation_fixture_for_session_owner(&replacement_url, Some(&page.session_id))
+ .await;
+ let replacement_owner = ctx
+ .conn
+ .target_page_residence_identity_for_session(Some(&page.session_id))
+ .expect("the replacement should install a Page owner");
+ assert_ne!(original_owner, replacement_owner);
+
+ let completed = tokio::time::timeout(Duration::from_secs(5), &mut completion)
+ .await
+ .unwrap_or_else(|_| panic!("{method} did not acknowledge Page replacement"));
+ let step = ctx.conn.complete_pending_command_dispatch(completed).await;
+ let (messages, scheduler_events) = ctx.complete_command_task_step_for_test(step).await;
+ assert!(scheduler_events.is_empty());
+ assert_eq!(
+ messages,
+ vec![json!({
+ "id": command_id,
+ "result": {},
+ "sessionId": page.session_id
+ })]
+ );
+ assert_eq!(
+ page.evaluate_string(ctx, command_id + 1, "document.body.dataset.marker")
+ .await,
+ replacement_marker,
+ "the original CDP session should remain usable on the replacement Page"
+ );
+}
// P0 browser contract source:
// Chromium Input.dispatchKeyEvent plus Playwright keyboard typing basics.
@@ -59,3 +133,67 @@ async fn rust_cdp_p0_input_dispatch_key_event_inserts_text() {
r#"[{"type":"keydown","key":"A","code":"KeyA","shiftKey":true}]"#
);
}
+
+// Chromium source:
+// content/browser/devtools/protocol/input_handler.cc InputInjector::Cleanup().
+#[tokio::test(flavor = "multi_thread")]
+async fn rust_cdp_p0_input_mouse_and_key_acknowledge_page_replacement() {
+ let fixture = SmokeFixtureServer::start().await;
+ let mut ctx = TestContext::new_with_target_discovery(false);
+ let page = CdpPageHarness::attach(&mut ctx, 138_100).await;
+
+ page.navigate(&mut ctx, 138_105, fixture.url("/plain?input-mouse-cleanup"))
+ .await;
+ page.evaluate_value(
+ &mut ctx,
+ 138_106,
+ r#"
+ document.body.innerHTML = '<button style="position:absolute;left:0;top:0;width:80px;height:80px">go</button>';
+ 'ready'
+ "#,
+ )
+ .await;
+ expect_page_replacement_cleans_up_pending_input_ack(
+ &mut ctx,
+ &page,
+ 138_107,
+ "Input.dispatchMouseEvent",
+ json!({
+ "type": "mousePressed",
+ "x": 20,
+ "y": 20,
+ "button": "left",
+ "buttons": 1,
+ "clickCount": 1
+ }),
+ "mouse-replacement",
+ )
+ .await;
+
+ page.navigate(&mut ctx, 138_109, fixture.url("/plain?input-key-cleanup"))
+ .await;
+ page.evaluate_value(
+ &mut ctx,
+ 138_110,
+ r#"
+ document.body.innerHTML = '<input id="field">';
+ document.getElementById('field').focus();
+ 'ready'
+ "#,
+ )
+ .await;
+ expect_page_replacement_cleans_up_pending_input_ack(
+ &mut ctx,
+ &page,
+ 138_111,
+ "Input.dispatchKeyEvent",
+ json!({
+ "type": "keyDown",
+ "key": "K",
+ "code": "KeyK",
+ "text": "K"
+ }),
+ "key-replacement",
+ )
+ .await;
+}