browser_commander/playwright/protocol/
web_socket_route.rs1#![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, Default, PartialEq, Serialize, Deserialize)]
15pub struct WebSocketRouteInitializer {
16 #[serde(rename = "url")]
17 pub url: String,
18 #[serde(rename = "protocols")]
19 pub protocols: Vec<String>,
20}
21
22#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
24pub struct WebSocketRouteSendToPageParams {
25 #[serde(rename = "message")]
26 pub message: String,
27 #[serde(rename = "isBase64")]
28 pub is_base64: bool,
29}
30
31#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
33pub struct WebSocketRouteSendToServerParams {
34 #[serde(rename = "message")]
35 pub message: String,
36 #[serde(rename = "isBase64")]
37 pub is_base64: bool,
38}
39
40#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
42pub struct WebSocketRouteClosePageParams {
43 #[serde(rename = "code", default, skip_serializing_if = "Option::is_none")]
44 pub code: Option<i64>,
45 #[serde(rename = "reason", default, skip_serializing_if = "Option::is_none")]
46 pub reason: Option<String>,
47 #[serde(rename = "wasClean")]
48 pub was_clean: bool,
49}
50
51#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
53pub struct WebSocketRouteCloseServerParams {
54 #[serde(rename = "code", default, skip_serializing_if = "Option::is_none")]
55 pub code: Option<i64>,
56 #[serde(rename = "reason", default, skip_serializing_if = "Option::is_none")]
57 pub reason: Option<String>,
58 #[serde(rename = "wasClean")]
59 pub was_clean: bool,
60}
61
62#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
64pub struct WebSocketRouteMessageFromPageEventParams {
65 #[serde(rename = "message")]
66 pub message: String,
67 #[serde(rename = "isBase64")]
68 pub is_base64: bool,
69}
70
71#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
73pub struct WebSocketRouteMessageFromServerEventParams {
74 #[serde(rename = "message")]
75 pub message: String,
76 #[serde(rename = "isBase64")]
77 pub is_base64: bool,
78}
79
80#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
82pub struct WebSocketRouteClosePageEventParams {
83 #[serde(rename = "code", default, skip_serializing_if = "Option::is_none")]
84 pub code: Option<i64>,
85 #[serde(rename = "reason", default, skip_serializing_if = "Option::is_none")]
86 pub reason: Option<String>,
87 #[serde(rename = "wasClean")]
88 pub was_clean: bool,
89}
90
91#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
93pub struct WebSocketRouteCloseServerEventParams {
94 #[serde(rename = "code", default, skip_serializing_if = "Option::is_none")]
95 pub code: Option<i64>,
96 #[serde(rename = "reason", default, skip_serializing_if = "Option::is_none")]
97 pub reason: Option<String>,
98 #[serde(rename = "wasClean")]
99 pub was_clean: bool,
100}
101
102#[derive(Debug, Clone, PartialEq)]
104pub enum WebSocketRouteEvent {
105 MessageFromPage(WebSocketRouteMessageFromPageEventParams),
107 MessageFromServer(WebSocketRouteMessageFromServerEventParams),
109 ClosePage(WebSocketRouteClosePageEventParams),
111 CloseServer(WebSocketRouteCloseServerEventParams),
113 Unknown {
115 method: String,
117 params: serde_json::Value,
119 },
120}
121
122impl ProtocolEvent for WebSocketRouteEvent {
123 fn parse(method: &str, params: serde_json::Value) -> Result<Self, serde_json::Error> {
124 match method {
125 "messageFromPage" => Ok(Self::MessageFromPage(serde_json::from_value(params)?)),
126 "messageFromServer" => Ok(Self::MessageFromServer(serde_json::from_value(params)?)),
127 "closePage" => Ok(Self::ClosePage(serde_json::from_value(params)?)),
128 "closeServer" => Ok(Self::CloseServer(serde_json::from_value(params)?)),
129 _ => Ok(Self::Unknown { method: method.to_string(), params }),
130 }
131 }
132}
133
134#[derive(Debug, Clone)]
136pub struct WebSocketRoute {
137 channel: Channel,
138}
139
140impl ChannelType for WebSocketRoute {
141 const INTERFACE: &'static str = "WebSocketRoute";
142 type Initializer = WebSocketRouteInitializer;
143 type Event = WebSocketRouteEvent;
144
145 fn accepts(interface: &str) -> bool {
146 matches!(interface, "WebSocketRoute")
147 }
148
149 fn from_channel(channel: Channel) -> Self {
150 Self { channel }
151 }
152
153 fn channel(&self) -> &Channel {
154 &self.channel
155 }
156}
157
158impl WebSocketRoute {
159 pub async fn connect(&self) -> Result<(), ProtocolError> {
161 self.channel.send_no_result("connect", &serde_json::json!({})).await
162 }
163
164 pub async fn ensure_opened(&self) -> Result<(), ProtocolError> {
166 self.channel.send_no_result("ensureOpened", &serde_json::json!({})).await
167 }
168
169 pub async fn send_to_page(&self, params: WebSocketRouteSendToPageParams) -> Result<(), ProtocolError> {
171 self.channel.send_no_result("sendToPage", ¶ms).await
172 }
173
174 pub async fn send_to_server(&self, params: WebSocketRouteSendToServerParams) -> Result<(), ProtocolError> {
176 self.channel.send_no_result("sendToServer", ¶ms).await
177 }
178
179 pub async fn close_page(&self, params: WebSocketRouteClosePageParams) -> Result<(), ProtocolError> {
181 self.channel.send_no_result("closePage", ¶ms).await
182 }
183
184 pub async fn close_server(&self, params: WebSocketRouteCloseServerParams) -> Result<(), ProtocolError> {
186 self.channel.send_no_result("closeServer", ¶ms).await
187 }
188}