earl-protocol-browser 0.6.3

Browser automation protocol for earl (chromiumoxide)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241

//! Use-case tests: dialog handling (Group 7).
//!
//! Dialogs are triggered via `window.onload` + `setTimeout(..., 100)` so
//! that the Navigate step completes before the dialog fires.  HandleDialog
//! subscribes to `Page.javascriptDialogOpening` events and waits up to the
//! global timeout for a dialog to appear.
mod common;
use common::{Response, execute, skip_if_no_chrome, spawn};
use earl_protocol_browser::PreparedBrowserCommand;
use earl_protocol_browser::schema::BrowserStep;
use std::collections::HashMap;

/// Test 7.1 — handle_dialog accepts an alert.
///
/// The page fires `alert('Hello')` 100 ms after load.  HandleDialog accepts
/// the pending dialog and the step succeeds with `{"ok": true}`.
#[tokio::test]
async fn handle_dialog_accepts_alert() {
    if skip_if_no_chrome() {
        return;
    }

    let _guard = common::chrome_lock().await;

    let mut routes = HashMap::new();
    routes.insert(
        "GET /".to_string(),
        Response::html(
            r#"<html><body><p>loaded</p><script>window.onload = function() { setTimeout(function() { alert('Hello'); }, 100); };</script></body></html>"#,
        ),
    );
    let server = spawn(routes).await;

    let data = PreparedBrowserCommand {
        session_id: None,
        headless: true,
        timeout_ms: 30_000,
        on_failure_screenshot: false,
        steps: vec![
            BrowserStep::Navigate {
                url: server.url("/"),
                expected_status: None,
                timeout_ms: None,
                optional: false,
            },
            BrowserStep::HandleDialog {
                accept: true,
                prompt_text: None,
                optional: false,
            },
        ],
    };

    let result = execute(data)
        .await
        .expect("execute should succeed — dialog should be accepted");
    assert_eq!(
        result["ok"].as_bool(),
        Some(true),
        "HandleDialog result should be {{\"ok\": true}}; got: {result}"
    );
}

/// Test 7.2 — handle_dialog with prompt_text fills the prompt.
///
/// The page opens `window.prompt()` 100 ms after load and writes the
/// returned value to `document.title`.  HandleDialog accepts with `"my-answer"`
/// and the subsequent Evaluate step reads back the title.
#[tokio::test]
async fn handle_dialog_fills_prompt_text() {
    if skip_if_no_chrome() {
        return;
    }

    let _guard = common::chrome_lock().await;

    let mut routes = HashMap::new();
    routes.insert(
        "GET /".to_string(),
        Response::html(
            r#"<html><body><script>window.onload = function() { setTimeout(function() { document.title = window.prompt('Enter value') || ''; }, 100); };</script></body></html>"#,
        ),
    );
    let server = spawn(routes).await;

    let data = PreparedBrowserCommand {
        session_id: None,
        headless: true,
        timeout_ms: 30_000,
        on_failure_screenshot: false,
        steps: vec![
            BrowserStep::Navigate {
                url: server.url("/"),
                expected_status: None,
                timeout_ms: None,
                optional: false,
            },
            BrowserStep::HandleDialog {
                accept: true,
                prompt_text: Some("my-answer".to_string()),
                optional: false,
            },
            // Short wait to let the JS callback finish setting document.title
            // after the dialog is dismissed.
            BrowserStep::WaitFor {
                time: Some(0.2),
                text: None,
                text_gone: None,
                timeout_ms: Some(2000),
                optional: false,
            },
            BrowserStep::Evaluate {
                function: "() => document.title".to_string(),
                r#ref: None,
                timeout_ms: None,
                optional: false,
            },
        ],
    };

    let result = execute(data).await.expect("execute should succeed");
    assert_eq!(
        result["value"].as_str(),
        Some("my-answer"),
        "document.title should equal 'my-answer' after prompt is filled; got: {result}"
    );
}

/// Test 7.3 — handle_dialog rejects a confirm dialog.
///
/// The page opens `window.confirm()` 100 ms after load and sets
/// `document.body.textContent` to `"yes"` or `"no"`.  Dismissing with
/// `accept: false` must produce `"no"`.
#[tokio::test]
async fn handle_dialog_rejects_confirm() {
    if skip_if_no_chrome() {
        return;
    }

    let _guard = common::chrome_lock().await;

    let mut routes = HashMap::new();
    routes.insert(
        "GET /".to_string(),
        Response::html(
            r#"<html><body><script>window.onload = function() { setTimeout(function() { document.body.textContent = window.confirm('Continue?') ? 'yes' : 'no'; }, 100); };</script></body></html>"#,
        ),
    );
    let server = spawn(routes).await;

    let data = PreparedBrowserCommand {
        session_id: None,
        headless: true,
        timeout_ms: 30_000,
        on_failure_screenshot: false,
        steps: vec![
            BrowserStep::Navigate {
                url: server.url("/"),
                expected_status: None,
                timeout_ms: None,
                optional: false,
            },
            BrowserStep::HandleDialog {
                accept: false,
                prompt_text: None,
                optional: false,
            },
            // Wait for the JS callback to update body.textContent after the
            // dialog is dismissed.
            BrowserStep::WaitFor {
                time: None,
                text: Some("no".to_string()),
                text_gone: None,
                timeout_ms: Some(2000),
                optional: false,
            },
            BrowserStep::Evaluate {
                function: "() => document.body.textContent.trim()".to_string(),
                r#ref: None,
                timeout_ms: None,
                optional: false,
            },
        ],
    };

    let result = execute(data).await.expect("execute should succeed");
    assert_eq!(
        result["value"].as_str(),
        Some("no"),
        "body text should be 'no' after confirm is rejected; got: {result}"
    );
}

/// Test 7.4 — HandleDialog times out when no dialog fires (Issue I4).
///
/// Navigate to a plain HTML page with no dialog, then call HandleDialog
/// immediately.  Because no dialog ever fires, the command should time out
/// and return an error mentioning "timeout".
#[tokio::test]
async fn handle_dialog_times_out_when_no_dialog_fires() {
    if skip_if_no_chrome() {
        return;
    }
    let _guard = common::chrome_lock().await;

    let mut routes = HashMap::new();
    routes.insert(
        "GET /".to_string(),
        Response::html("<html><body>no dialog here</body></html>"),
    );
    let server = spawn(routes).await;

    let data = PreparedBrowserCommand {
        session_id: None,
        headless: true,
        timeout_ms: 2_000, // short timeout so the test completes quickly
        on_failure_screenshot: false,
        steps: vec![
            BrowserStep::Navigate {
                url: server.url("/"),
                expected_status: None,
                timeout_ms: None,
                optional: false,
            },
            BrowserStep::HandleDialog {
                accept: true,
                prompt_text: None,
                optional: false,
            },
        ],
    };

    let err = execute(data)
        .await
        .expect_err("HandleDialog should time out when no dialog fires");
    let msg = err.to_string().to_lowercase();
    assert!(
        msg.contains("timeout") || msg.contains("timed out") || msg.contains("time"),
        "error should mention timeout; got: {msg}"
    );
}