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
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

use crate::test_server::TestServer;

// ============================================================================
// Response body access tests
// ============================================================================

/// Test that response.body() returns non-empty bytes for a page navigation.
#[tokio::test]
async fn test_response_body() {
    let (_pw, browser, page) = crate::common::setup().await;
    let server = TestServer::start().await;

    let response = page
        .goto(&server.url(), None)
        .await
        .expect("Failed to navigate")
        .expect("Expected a response");

    let body = response.body().await.expect("body() should succeed");
    assert!(!body.is_empty(), "Response body should not be empty");

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

/// Test that response.text() returns the HTML content as a string.
#[tokio::test]
async fn test_response_text() {
    let (_pw, browser, page) = crate::common::setup().await;
    let server = TestServer::start().await;

    let response = page
        .goto(&server.url(), None)
        .await
        .expect("Failed to navigate")
        .expect("Expected a response");

    let text = response.text().await.expect("text() should succeed");
    assert!(
        text.contains("<!DOCTYPE html>") || text.contains("<html"),
        "Response text should contain HTML: {}",
        &text[..text.len().min(200)]
    );

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

/// Test that response.json() parses a JSON endpoint response correctly.
#[tokio::test]
async fn test_response_json() {
    let (_pw, browser, page) = crate::common::setup().await;
    let server = TestServer::start().await;

    // Navigate to the JSON endpoint served by TestServer
    let json_url = format!("{}/api/data.json", server.url());
    let response = page
        .goto(&json_url, None)
        .await
        .expect("Failed to navigate")
        .expect("Expected a response");

    let value: serde_json::Value = response
        .json()
        .await
        .expect("json() should succeed for JSON endpoint");

    assert!(value.is_object(), "Response should parse as a JSON object");
    assert_eq!(
        value.get("status").and_then(|v| v.as_str()),
        Some("ok"),
        "JSON should contain status:ok"
    );

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

/// Test that response.header_value() returns the content-type header.
#[tokio::test]
async fn test_response_header_value() {
    let (_pw, browser, page) = crate::common::setup().await;
    let server = TestServer::start().await;

    let response = page
        .goto(&server.url(), None)
        .await
        .expect("Failed to navigate")
        .expect("Expected a response");

    let content_type = response
        .header_value("content-type")
        .await
        .expect("header_value() should succeed");

    assert!(
        content_type.is_some(),
        "content-type header should be present"
    );
    let ct = content_type.unwrap();
    assert!(
        ct.contains("text/html"),
        "content-type should contain text/html, got: {}",
        ct
    );

    // Test a header that doesn't exist
    let missing = response
        .header_value("x-does-not-exist")
        .await
        .expect("header_value() should succeed even for missing headers");
    assert!(missing.is_none(), "Missing header should return None");

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

/// Test that response.headers_array() returns all headers as name-value pairs.
#[tokio::test]
async fn test_response_headers_array() {
    let (_pw, browser, page) = crate::common::setup().await;
    let server = TestServer::start().await;

    let response = page
        .goto(&server.url(), None)
        .await
        .expect("Failed to navigate")
        .expect("Expected a response");

    let headers = response
        .headers_array()
        .await
        .expect("headers_array() should succeed");

    assert!(
        !headers.is_empty(),
        "headers_array() should return at least one header"
    );

    // Check that each entry has both name and value fields
    for entry in &headers {
        assert!(!entry.name.is_empty(), "Header name should not be empty");
    }

    // Should include content-type
    let has_content_type = headers
        .iter()
        .any(|h| h.name.to_lowercase() == "content-type");
    assert!(
        has_content_type,
        "headers_array() should include content-type"
    );

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

/// Test that response.all_headers() returns a HashMap with headers merged (lowercased keys).
#[tokio::test]
async fn test_response_all_headers() {
    let (_pw, browser, page) = crate::common::setup().await;
    let server = TestServer::start().await;

    let response = page
        .goto(&server.url(), None)
        .await
        .expect("Failed to navigate")
        .expect("Expected a response");

    let all_headers = response
        .all_headers()
        .await
        .expect("all_headers() should succeed");

    assert!(
        !all_headers.is_empty(),
        "all_headers() should return at least one header"
    );

    // content-type key should be present (lowercased)
    assert!(
        all_headers.contains_key("content-type"),
        "all_headers() should contain content-type key, got keys: {:?}",
        all_headers.keys().collect::<Vec<_>>()
    );

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

/// Test that response.http_version() returns a non-empty HTTP version string.
#[tokio::test]
async fn test_response_http_version() {
    let (_pw, browser, page) = crate::common::setup().await;
    let server = TestServer::start().await;

    let response = page
        .goto(&server.url(), None)
        .await
        .expect("Failed to navigate")
        .expect("Expected a response");

    let http_version = response
        .http_version()
        .await
        .expect("http_version() should succeed");

    // HTTP/1.1 for our test server, but accept any HTTP/* format
    assert!(
        http_version.starts_with("HTTP/") || !http_version.is_empty(),
        "http_version should be non-empty, got: {http_version}"
    );

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