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, Default, PartialEq, Serialize, Deserialize)]
15pub struct TracingInitializer {}
16
17#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
19pub struct TracingTracingStartParams {
20 #[serde(rename = "name", default, skip_serializing_if = "Option::is_none")]
21 pub name: Option<String>,
22 #[serde(rename = "snapshots", default, skip_serializing_if = "Option::is_none")]
23 pub snapshots: Option<bool>,
24 #[serde(rename = "screenshots", default, skip_serializing_if = "Option::is_none")]
25 pub screenshots: Option<bool>,
26 #[serde(rename = "live", default, skip_serializing_if = "Option::is_none")]
27 pub live: Option<bool>,
28}
29
30#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
32pub struct TracingTracingStartChunkParams {
33 #[serde(rename = "name", default, skip_serializing_if = "Option::is_none")]
34 pub name: Option<String>,
35 #[serde(rename = "title", default, skip_serializing_if = "Option::is_none")]
36 pub title: Option<String>,
37}
38
39#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
41pub struct TracingTracingStartChunkResult {
42 #[serde(rename = "traceName")]
43 pub trace_name: String,
44}
45
46#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
47pub struct TracingTracingGroupParamsLocation {
48 #[serde(rename = "file")]
49 pub file: String,
50 #[serde(rename = "line", default, skip_serializing_if = "Option::is_none")]
51 pub line: Option<i64>,
52 #[serde(rename = "column", default, skip_serializing_if = "Option::is_none")]
53 pub column: Option<i64>,
54}
55
56#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
58pub struct TracingTracingGroupParams {
59 #[serde(rename = "name")]
60 pub name: String,
61 #[serde(rename = "location", default, skip_serializing_if = "Option::is_none")]
62 pub location: Option<TracingTracingGroupParamsLocation>,
63}
64
65#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
66pub enum TracingTracingStopChunkParamsMode {
67 #[default]
68 #[serde(rename = "archive")]
69 Archive,
70 #[serde(rename = "discard")]
71 Discard,
72 #[serde(rename = "entries")]
73 Entries,
74}
75
76#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
78pub struct TracingTracingStopChunkParams {
79 #[serde(rename = "mode")]
80 pub mode: TracingTracingStopChunkParamsMode,
81}
82
83#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
85pub struct TracingTracingStopChunkResult {
86 #[serde(rename = "artifact", default, skip_serializing_if = "Option::is_none")]
87 pub artifact: Option<Ref<Artifact>>,
88 #[serde(rename = "entries", default, skip_serializing_if = "Option::is_none")]
89 pub entries: Option<Vec<NameValue>>,
90}
91
92#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
94pub struct TracingHarStartParams {
95 #[serde(rename = "page", default, skip_serializing_if = "Option::is_none")]
96 pub page: Option<Ref<Page>>,
97 #[serde(rename = "options")]
98 pub options: RecordHarOptions,
99}
100
101#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
103pub struct TracingHarStartResult {
104 #[serde(rename = "harId")]
105 pub har_id: String,
106}
107
108#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
109pub enum TracingHarExportParamsMode {
110 #[default]
111 #[serde(rename = "archive")]
112 Archive,
113 #[serde(rename = "entries")]
114 Entries,
115}
116
117#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
119pub struct TracingHarExportParams {
120 #[serde(rename = "harId", default, skip_serializing_if = "Option::is_none")]
121 pub har_id: Option<String>,
122 #[serde(rename = "mode")]
123 pub mode: TracingHarExportParamsMode,
124}
125
126#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
128pub struct TracingHarExportResult {
129 #[serde(rename = "artifact", default, skip_serializing_if = "Option::is_none")]
130 pub artifact: Option<Ref<Artifact>>,
131 #[serde(rename = "entries", default, skip_serializing_if = "Option::is_none")]
132 pub entries: Option<Vec<NameValue>>,
133}
134
135#[derive(Debug, Clone, PartialEq)]
137pub enum TracingEvent {
138 Unknown {
140 method: String,
142 params: serde_json::Value,
144 },
145}
146
147impl ProtocolEvent for TracingEvent {
148 fn parse(method: &str, params: serde_json::Value) -> Result<Self, serde_json::Error> {
149 match method {
150 _ => Ok(Self::Unknown { method: method.to_string(), params }),
151 }
152 }
153}
154
155#[derive(Debug, Clone)]
157pub struct Tracing {
158 channel: Channel,
159}
160
161impl ChannelType for Tracing {
162 const INTERFACE: &'static str = "Tracing";
163 type Initializer = TracingInitializer;
164 type Event = TracingEvent;
165
166 fn accepts(interface: &str) -> bool {
167 matches!(interface, "Tracing")
168 }
169
170 fn from_channel(channel: Channel) -> Self {
171 Self { channel }
172 }
173
174 fn channel(&self) -> &Channel {
175 &self.channel
176 }
177}
178
179impl Tracing {
180 pub async fn tracing_start(&self, params: TracingTracingStartParams) -> Result<(), ProtocolError> {
182 self.channel.send_no_result("tracingStart", ¶ms).await
183 }
184
185 pub async fn tracing_start_chunk(&self, params: TracingTracingStartChunkParams) -> Result<TracingTracingStartChunkResult, ProtocolError> {
187 self.channel.send("tracingStartChunk", ¶ms).await
188 }
189
190 pub async fn tracing_group(&self, params: TracingTracingGroupParams) -> Result<(), ProtocolError> {
192 self.channel.send_no_result("tracingGroup", ¶ms).await
193 }
194
195 pub async fn tracing_group_end(&self) -> Result<(), ProtocolError> {
197 self.channel.send_no_result("tracingGroupEnd", &serde_json::json!({})).await
198 }
199
200 pub async fn tracing_stop_chunk(&self, params: TracingTracingStopChunkParams) -> Result<TracingTracingStopChunkResult, ProtocolError> {
202 self.channel.send("tracingStopChunk", ¶ms).await
203 }
204
205 pub async fn tracing_stop(&self) -> Result<(), ProtocolError> {
207 self.channel.send_no_result("tracingStop", &serde_json::json!({})).await
208 }
209
210 pub async fn har_start(&self, params: TracingHarStartParams) -> Result<TracingHarStartResult, ProtocolError> {
212 self.channel.send("harStart", ¶ms).await
213 }
214
215 pub async fn har_export(&self, params: TracingHarExportParams) -> Result<TracingHarExportResult, ProtocolError> {
217 self.channel.send("harExport", ¶ms).await
218 }
219}