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

use playwright_rs::protocol::Playwright;

#[tokio::test]
async fn test_playwright_launch() {
    crate::common::init_tracing();
    // Launch Playwright
    let playwright = Playwright::launch()
        .await
        .expect("Failed to launch Playwright");

    // Verify we can access browser types
    let chromium = playwright.chromium();
    assert_eq!(chromium.name(), "chromium");
    assert!(!chromium.executable_path().is_empty());

    let firefox = playwright.firefox();
    assert_eq!(firefox.name(), "firefox");
    assert!(!firefox.executable_path().is_empty());

    let webkit = playwright.webkit();
    assert_eq!(webkit.name(), "webkit");
    assert!(!webkit.executable_path().is_empty());

    tracing::info!("✅ Playwright launched successfully!");
    tracing::info!("   Chromium: {}", chromium.executable_path());
    tracing::info!("   Firefox: {}", firefox.executable_path());
    tracing::info!("   WebKit: {}", webkit.executable_path());
}

/// Test that multiple Playwright instances can be created
///
/// Verifies that we can create multiple independent Playwright instances,
/// each with their own connection to separate server processes.
#[tokio::test]
async fn test_multiple_playwright_instances() {
    crate::common::init_tracing();
    // Launch first instance
    let playwright1 = Playwright::launch()
        .await
        .expect("Failed to launch first Playwright instance");

    // Launch second instance
    let playwright2 = Playwright::launch()
        .await
        .expect("Failed to launch second Playwright instance");

    // Verify both instances work independently
    assert_eq!(playwright1.chromium().name(), "chromium");
    assert_eq!(playwright2.chromium().name(), "chromium");
}

/// Test error handling: Error::ServerNotFound variant is defined and displays correctly.
#[tokio::test]
async fn test_launch_with_driver_not_found() {
    use playwright_rs::Error;

    let error = Error::ServerNotFound;
    let error_message = error.to_string();
    assert!(error_message.contains("Playwright server not found"));
}

/// Test graceful cleanup: dropping a Playwright instance allows creating a new one.
#[tokio::test]
async fn test_graceful_cleanup_on_drop() {
    crate::common::init_tracing();
    // Create a Playwright instance in a scope
    {
        let playwright = Playwright::launch()
            .await
            .expect("Failed to launch Playwright");

        assert_eq!(playwright.chromium().name(), "chromium");

        // Playwright instance will be dropped here
    }

    // Verify we can create another instance after the first was dropped
    let playwright2 = Playwright::launch()
        .await
        .expect("Failed to launch second Playwright instance");

    assert_eq!(playwright2.chromium().name(), "chromium");

    tracing::info!("✅ Graceful cleanup verified - can create new instance after drop!");
}

/// Test that playwright.devices() returns a non-empty map.
#[tokio::test]
async fn test_playwright_devices_not_empty() {
    crate::common::init_tracing();
    let playwright = Playwright::launch()
        .await
        .expect("Failed to launch Playwright");

    let devices = playwright.devices();
    assert!(
        !devices.is_empty(),
        "devices() should return a non-empty map"
    );
}

/// Test that a known device like "iPhone 13" exists with expected fields.
#[tokio::test]
async fn test_playwright_devices_iphone() {
    crate::common::init_tracing();
    let playwright = Playwright::launch()
        .await
        .expect("Failed to launch Playwright");

    let devices = playwright.devices();
    let iphone = devices.get("iPhone 13");
    assert!(iphone.is_some(), "devices() should contain 'iPhone 13'");

    let iphone = iphone.unwrap();
    assert!(
        !iphone.user_agent.is_empty(),
        "iPhone 13 user_agent should be non-empty"
    );
    assert!(
        iphone.viewport.width > 0,
        "iPhone 13 viewport width should be positive"
    );
    assert!(
        iphone.viewport.height > 0,
        "iPhone 13 viewport height should be positive"
    );
    assert!(
        iphone.device_scale_factor > 0.0,
        "iPhone 13 device_scale_factor should be positive"
    );
    assert!(iphone.is_mobile, "iPhone 13 should be mobile");
    assert!(iphone.has_touch, "iPhone 13 should have touch");
    assert_eq!(
        iphone.default_browser_type, "webkit",
        "iPhone 13 default browser should be webkit"
    );
}