playwright-rs 0.12.3

Rust bindings for Microsoft Playwright
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

use crate::test_server::TestServer;
use std::sync::{Arc, Mutex};

#[tokio::test]
async fn test_route_fetch_basic() {
    let server = TestServer::start().await;
    let (_pw, browser, page) = crate::common::setup().await;

    let fetch_status = Arc::new(Mutex::new(0u16));
    let status_clone = fetch_status.clone();

    page.route("**/", move |route| {
        let status = status_clone.clone();
        async move {
            // Fetch the actual response via APIRequestContext
            let response = route.fetch(None).await?;
            *status.lock().unwrap() = response.status();

            // Fulfill with the fetched status
            route
                .fulfill(Some(
                    playwright_rs::FulfillOptions::builder()
                        .status(response.status())
                        .build(),
                ))
                .await
        }
    })
    .await
    .expect("Failed to set up route");

    page.goto(&format!("{}/", server.url()), None)
        .await
        .expect("Failed to navigate");

    let status = *fetch_status.lock().unwrap();
    assert_eq!(status, 200, "Fetched response should have status 200");

    browser.close().await.expect("Failed to close browser");
    server.shutdown();
}

#[tokio::test]
async fn test_route_fetch_response_methods() {
    let server = TestServer::start().await;
    let (_pw, browser, page) = crate::common::setup().await;

    let response_ok = Arc::new(Mutex::new(false));
    let has_body = Arc::new(Mutex::new(false));
    let ok_clone = response_ok.clone();
    let body_clone = has_body.clone();

    page.route("**/", move |route| {
        let ok = ok_clone.clone();
        let body = body_clone.clone();
        async move {
            let response = route.fetch(None).await?;

            // Test FetchResponse methods
            *ok.lock().unwrap() = response.ok();
            *body.lock().unwrap() = !response.body().is_empty();

            assert!(response.ok(), "200 response should be ok()");
            assert!(!response.headers().is_empty(), "Should have headers");

            route
                .fulfill(Some(
                    playwright_rs::FulfillOptions::builder()
                        .status(response.status())
                        .build(),
                ))
                .await
        }
    })
    .await
    .expect("Failed to set up route");

    page.goto(&format!("{}/", server.url()), None)
        .await
        .expect("Failed to navigate");

    assert!(*response_ok.lock().unwrap(), "Response should have been ok");
    assert!(*has_body.lock().unwrap(), "Response should have a body");

    browser.close().await.expect("Failed to close browser");
    server.shutdown();
}

#[tokio::test]
async fn test_route_fetch_with_context_route() {
    let server = TestServer::start().await;
    let (_pw, browser, context) = crate::common::setup_context().await;

    let fetch_status = Arc::new(Mutex::new(0u16));
    let status_clone = fetch_status.clone();

    // Use context-level route with fetch
    context
        .route("**/", move |route| {
            let status = status_clone.clone();
            async move {
                let response = route.fetch(None).await?;
                *status.lock().unwrap() = response.status();
                route
                    .fulfill(Some(
                        playwright_rs::FulfillOptions::builder()
                            .status(response.status())
                            .build(),
                    ))
                    .await
            }
        })
        .await
        .expect("Failed to set up context route");

    let page = context.new_page().await.expect("Failed to create page");
    page.goto(&format!("{}/", server.url()), None)
        .await
        .expect("Failed to navigate");

    let status = *fetch_status.lock().unwrap();
    assert_eq!(
        status, 200,
        "Context-level route.fetch() should get status 200"
    );

    context.close().await.expect("Failed to close context");
    browser.close().await.expect("Failed to close browser");
    server.shutdown();
}