browser-commander 0.18.0

Universal browser automation library that supports multiple browser engines with a unified API
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

// @generated by scripts/generate-playwright-protocol.mjs from
// rust/protocol/playwright/*.yml. Do not edit by hand.

#![allow(clippy::all, missing_docs, unused_imports)]

use serde::{Deserialize, Serialize};

use super::*;
use crate::playwright::connection::{
    Binary, Channel, ChannelType, ObjectRef, ProtocolError, ProtocolEvent, Ref,
};

/// Initializer the driver sends when it creates a `Playwright`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PlaywrightInitializer {
    #[serde(rename = "chromium")]
    pub chromium: Ref<BrowserType>,
    #[serde(rename = "firefox")]
    pub firefox: Ref<BrowserType>,
    #[serde(rename = "webkit")]
    pub webkit: Ref<BrowserType>,
    #[serde(rename = "android")]
    pub android: Ref<Android>,
    #[serde(rename = "electron")]
    pub electron: Ref<Electron>,
    #[serde(rename = "utils", default, skip_serializing_if = "Option::is_none")]
    pub utils: Option<Ref<LocalUtils>>,
    #[serde(rename = "preLaunchedBrowser", default, skip_serializing_if = "Option::is_none")]
    pub pre_launched_browser: Option<Ref<Browser>>,
    #[serde(rename = "preConnectedAndroidDevice", default, skip_serializing_if = "Option::is_none")]
    pub pre_connected_android_device: Option<Ref<AndroidDevice>>,
    #[serde(rename = "socksSupport", default, skip_serializing_if = "Option::is_none")]
    pub socks_support: Option<Ref<SocksSupport>>,
}

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PlaywrightNewRequestParamsClientCertificates {
    #[serde(rename = "origin")]
    pub origin: String,
    #[serde(rename = "cert", default, skip_serializing_if = "Option::is_none")]
    pub cert: Option<Binary>,
    #[serde(rename = "key", default, skip_serializing_if = "Option::is_none")]
    pub key: Option<Binary>,
    #[serde(rename = "passphrase", default, skip_serializing_if = "Option::is_none")]
    pub passphrase: Option<String>,
    #[serde(rename = "pfx", default, skip_serializing_if = "Option::is_none")]
    pub pfx: Option<Binary>,
}

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PlaywrightNewRequestParamsProxy {
    #[serde(rename = "server")]
    pub server: String,
    #[serde(rename = "bypass", default, skip_serializing_if = "Option::is_none")]
    pub bypass: Option<String>,
    #[serde(rename = "username", default, skip_serializing_if = "Option::is_none")]
    pub username: Option<String>,
    #[serde(rename = "password", default, skip_serializing_if = "Option::is_none")]
    pub password: Option<String>,
}

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PlaywrightNewRequestParamsStorageState {
    #[serde(rename = "cookies", default, skip_serializing_if = "Option::is_none")]
    pub cookies: Option<Vec<NetworkCookie>>,
    #[serde(rename = "origins", default, skip_serializing_if = "Option::is_none")]
    pub origins: Option<Vec<SetOriginStorage>>,
}

/// Parameters of `Playwright.newRequest` (Create request context).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PlaywrightNewRequestParams {
    #[serde(rename = "baseURL", default, skip_serializing_if = "Option::is_none")]
    pub base_url: Option<String>,
    #[serde(rename = "userAgent", default, skip_serializing_if = "Option::is_none")]
    pub user_agent: Option<String>,
    #[serde(rename = "ignoreHTTPSErrors", default, skip_serializing_if = "Option::is_none")]
    pub ignore_https_errors: Option<bool>,
    #[serde(rename = "extraHTTPHeaders", default, skip_serializing_if = "Option::is_none")]
    pub extra_http_headers: Option<Vec<NameValue>>,
    #[serde(rename = "failOnStatusCode", default, skip_serializing_if = "Option::is_none")]
    pub fail_on_status_code: Option<bool>,
    #[serde(rename = "clientCertificates", default, skip_serializing_if = "Option::is_none")]
    pub client_certificates: Option<Vec<PlaywrightNewRequestParamsClientCertificates>>,
    #[serde(rename = "maxRedirects", default, skip_serializing_if = "Option::is_none")]
    pub max_redirects: Option<i64>,
    #[serde(rename = "httpCredentials", default, skip_serializing_if = "Option::is_none")]
    pub http_credentials: Option<Vec<HttpCredentials>>,
    #[serde(rename = "proxy", default, skip_serializing_if = "Option::is_none")]
    pub proxy: Option<PlaywrightNewRequestParamsProxy>,
    #[serde(rename = "storageState", default, skip_serializing_if = "Option::is_none")]
    pub storage_state: Option<PlaywrightNewRequestParamsStorageState>,
    #[serde(rename = "tracesDir", default, skip_serializing_if = "Option::is_none")]
    pub traces_dir: Option<String>,
}

/// Result of `Playwright.newRequest` (Create request context).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PlaywrightNewRequestResult {
    #[serde(rename = "request")]
    pub request: Ref<APIRequestContext>,
}

/// Events a `Playwright` channel can emit.
#[derive(Debug, Clone, PartialEq)]
pub enum PlaywrightEvent {
    /// An event this binding does not know (a newer driver).
    Unknown {
        /// Event name.
        method: String,
        /// Raw event parameters.
        params: serde_json::Value,
    },
}

impl ProtocolEvent for PlaywrightEvent {
    fn parse(method: &str, params: serde_json::Value) -> Result<Self, serde_json::Error> {
        match method {
            _ => Ok(Self::Unknown { method: method.to_string(), params }),
        }
    }
}

/// Channel for the `Playwright` interface (`playwright.yml`).
#[derive(Debug, Clone)]
pub struct Playwright {
    channel: Channel,
}

impl ChannelType for Playwright {
    const INTERFACE: &'static str = "Playwright";
    type Initializer = PlaywrightInitializer;
    type Event = PlaywrightEvent;

    fn accepts(interface: &str) -> bool {
        matches!(interface, "Playwright")
    }

    fn from_channel(channel: Channel) -> Self {
        Self { channel }
    }

    fn channel(&self) -> &Channel {
        &self.channel
    }
}

impl Playwright {
    /// `Playwright.newRequest` ("Create request context").
    pub async fn new_request(&self, params: PlaywrightNewRequestParams) -> Result<PlaywrightNewRequestResult, ProtocolError> {
        self.channel.send("newRequest", &params).await
    }
}