1#![allow(clippy::all, missing_docs, unused_imports)]
5
6use serde::{Deserialize, Serialize};
7
8use super::*;
9use crate::playwright::connection::{
10 Binary, Channel, ChannelType, ObjectRef, ProtocolError, ProtocolEvent, Ref,
11};
12
13#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
14pub enum BrowserInitializerBrowserName {
15 #[default]
16 #[serde(rename = "chromium")]
17 Chromium,
18 #[serde(rename = "firefox")]
19 Firefox,
20 #[serde(rename = "webkit")]
21 Webkit,
22}
23
24#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
26pub struct BrowserInitializer {
27 #[serde(rename = "version")]
28 pub version: String,
29 #[serde(rename = "name")]
30 pub name: String,
31 #[serde(rename = "browserName")]
32 pub browser_name: BrowserInitializerBrowserName,
33}
34
35#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
37pub struct BrowserStartServerParams {
38 #[serde(rename = "title")]
39 pub title: String,
40 #[serde(rename = "workspaceDir", default, skip_serializing_if = "Option::is_none")]
41 pub workspace_dir: Option<String>,
42 #[serde(rename = "metadata", default, skip_serializing_if = "Option::is_none")]
43 pub metadata: Option<serde_json::Value>,
44 #[serde(rename = "host", default, skip_serializing_if = "Option::is_none")]
45 pub host: Option<String>,
46 #[serde(rename = "port", default, skip_serializing_if = "Option::is_none")]
47 pub port: Option<i64>,
48}
49
50#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
52pub struct BrowserStartServerResult {
53 #[serde(rename = "endpoint")]
54 pub endpoint: String,
55}
56
57#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
59pub struct BrowserCloseParams {
60 #[serde(rename = "reason", default, skip_serializing_if = "Option::is_none")]
61 pub reason: Option<String>,
62}
63
64#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
66pub struct BrowserDefaultUserAgentForTestResult {
67 #[serde(rename = "userAgent")]
68 pub user_agent: String,
69}
70
71#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
72pub struct BrowserNewContextParamsProxy {
73 #[serde(rename = "server")]
74 pub server: String,
75 #[serde(rename = "bypass", default, skip_serializing_if = "Option::is_none")]
76 pub bypass: Option<String>,
77 #[serde(rename = "username", default, skip_serializing_if = "Option::is_none")]
78 pub username: Option<String>,
79 #[serde(rename = "password", default, skip_serializing_if = "Option::is_none")]
80 pub password: Option<String>,
81}
82
83#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
84pub struct BrowserNewContextParamsStorageState {
85 #[serde(rename = "cookies", default, skip_serializing_if = "Option::is_none")]
86 pub cookies: Option<Vec<SetNetworkCookie>>,
87 #[serde(rename = "origins", default, skip_serializing_if = "Option::is_none")]
88 pub origins: Option<Vec<SetOriginStorage>>,
89 #[serde(rename = "credentials", default, skip_serializing_if = "Option::is_none")]
90 pub credentials: Option<Vec<VirtualCredential>>,
91}
92
93#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
95pub struct BrowserNewContextParams {
96 #[serde(flatten)]
98 pub context_options: ContextOptions,
99 #[serde(rename = "proxy", default, skip_serializing_if = "Option::is_none")]
100 pub proxy: Option<BrowserNewContextParamsProxy>,
101 #[serde(rename = "storageState", default, skip_serializing_if = "Option::is_none")]
102 pub storage_state: Option<BrowserNewContextParamsStorageState>,
103}
104
105#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
107pub struct BrowserNewContextResult {
108 #[serde(rename = "context")]
109 pub context: Ref<BrowserContext>,
110}
111
112#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
113pub struct BrowserNewContextForReuseParamsProxy {
114 #[serde(rename = "server")]
115 pub server: String,
116 #[serde(rename = "bypass", default, skip_serializing_if = "Option::is_none")]
117 pub bypass: Option<String>,
118 #[serde(rename = "username", default, skip_serializing_if = "Option::is_none")]
119 pub username: Option<String>,
120 #[serde(rename = "password", default, skip_serializing_if = "Option::is_none")]
121 pub password: Option<String>,
122}
123
124#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
125pub struct BrowserNewContextForReuseParamsStorageState {
126 #[serde(rename = "cookies", default, skip_serializing_if = "Option::is_none")]
127 pub cookies: Option<Vec<SetNetworkCookie>>,
128 #[serde(rename = "origins", default, skip_serializing_if = "Option::is_none")]
129 pub origins: Option<Vec<SetOriginStorage>>,
130 #[serde(rename = "credentials", default, skip_serializing_if = "Option::is_none")]
131 pub credentials: Option<Vec<VirtualCredential>>,
132}
133
134#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
136pub struct BrowserNewContextForReuseParams {
137 #[serde(flatten)]
139 pub context_options: ContextOptions,
140 #[serde(rename = "proxy", default, skip_serializing_if = "Option::is_none")]
141 pub proxy: Option<BrowserNewContextForReuseParamsProxy>,
142 #[serde(rename = "storageState", default, skip_serializing_if = "Option::is_none")]
143 pub storage_state: Option<BrowserNewContextForReuseParamsStorageState>,
144}
145
146#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
148pub struct BrowserNewContextForReuseResult {
149 #[serde(rename = "context")]
150 pub context: Ref<BrowserContext>,
151}
152
153#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
155pub struct BrowserDisconnectFromReusedContextParams {
156 #[serde(rename = "reason")]
157 pub reason: String,
158}
159
160#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
162pub struct BrowserNewBrowserCDPSessionResult {
163 #[serde(rename = "session")]
164 pub session: Ref<CDPSession>,
165}
166
167#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
169pub struct BrowserStartTracingParams {
170 #[serde(rename = "page", default, skip_serializing_if = "Option::is_none")]
171 pub page: Option<Ref<Page>>,
172 #[serde(rename = "screenshots", default, skip_serializing_if = "Option::is_none")]
173 pub screenshots: Option<bool>,
174 #[serde(rename = "categories", default, skip_serializing_if = "Option::is_none")]
175 pub categories: Option<Vec<String>>,
176}
177
178#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
180pub struct BrowserStopTracingResult {
181 #[serde(rename = "artifact")]
182 pub artifact: Ref<Artifact>,
183}
184
185#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
187pub struct BrowserContextEventParams {
188 #[serde(rename = "context")]
189 pub context: Ref<BrowserContext>,
190}
191
192#[derive(Debug, Clone, PartialEq)]
194pub enum BrowserEvent {
195 Context(BrowserContextEventParams),
197 Close,
199 Unknown {
201 method: String,
203 params: serde_json::Value,
205 },
206}
207
208impl ProtocolEvent for BrowserEvent {
209 fn parse(method: &str, params: serde_json::Value) -> Result<Self, serde_json::Error> {
210 match method {
211 "context" => Ok(Self::Context(serde_json::from_value(params)?)),
212 "close" => Ok(Self::Close),
213 _ => Ok(Self::Unknown { method: method.to_string(), params }),
214 }
215 }
216}
217
218#[derive(Debug, Clone)]
220pub struct Browser {
221 channel: Channel,
222}
223
224impl ChannelType for Browser {
225 const INTERFACE: &'static str = "Browser";
226 type Initializer = BrowserInitializer;
227 type Event = BrowserEvent;
228
229 fn accepts(interface: &str) -> bool {
230 matches!(interface, "Browser")
231 }
232
233 fn from_channel(channel: Channel) -> Self {
234 Self { channel }
235 }
236
237 fn channel(&self) -> &Channel {
238 &self.channel
239 }
240}
241
242impl Browser {
243 pub async fn start_server(&self, params: BrowserStartServerParams) -> Result<BrowserStartServerResult, ProtocolError> {
245 self.channel.send("startServer", ¶ms).await
246 }
247
248 pub async fn stop_server(&self) -> Result<(), ProtocolError> {
250 self.channel.send_no_result("stopServer", &serde_json::json!({})).await
251 }
252
253 pub async fn close(&self, params: BrowserCloseParams) -> Result<(), ProtocolError> {
255 self.channel.send_no_result("close", ¶ms).await
256 }
257
258 pub async fn kill_for_tests(&self) -> Result<(), ProtocolError> {
260 self.channel.send_no_result("killForTests", &serde_json::json!({})).await
261 }
262
263 pub async fn default_user_agent_for_test(&self) -> Result<BrowserDefaultUserAgentForTestResult, ProtocolError> {
265 self.channel.send("defaultUserAgentForTest", &serde_json::json!({})).await
266 }
267
268 pub async fn new_context(&self, params: BrowserNewContextParams) -> Result<BrowserNewContextResult, ProtocolError> {
270 self.channel.send("newContext", ¶ms).await
271 }
272
273 pub async fn new_context_for_reuse(&self, params: BrowserNewContextForReuseParams) -> Result<BrowserNewContextForReuseResult, ProtocolError> {
275 self.channel.send("newContextForReuse", ¶ms).await
276 }
277
278 pub async fn disconnect_from_reused_context(&self, params: BrowserDisconnectFromReusedContextParams) -> Result<(), ProtocolError> {
280 self.channel.send_no_result("disconnectFromReusedContext", ¶ms).await
281 }
282
283 pub async fn new_browser_cdp_session(&self) -> Result<BrowserNewBrowserCDPSessionResult, ProtocolError> {
285 self.channel.send("newBrowserCDPSession", &serde_json::json!({})).await
286 }
287
288 pub async fn start_tracing(&self, params: BrowserStartTracingParams) -> Result<(), ProtocolError> {
290 self.channel.send_no_result("startTracing", ¶ms).await
291 }
292
293 pub async fn stop_tracing(&self) -> Result<BrowserStopTracingResult, ProtocolError> {
295 self.channel.send("stopTracing", &serde_json::json!({})).await
296 }
297}