adk_browser/
config.rs

1//! Browser configuration options.
2
3use serde::{Deserialize, Serialize};
4
5/// Configuration for browser sessions.
6#[derive(Debug, Clone, Serialize, Deserialize)]
7pub struct BrowserConfig {
8    /// WebDriver server URL (e.g., "http://localhost:4444")
9    pub webdriver_url: String,
10
11    /// Browser type to use
12    pub browser: BrowserType,
13
14    /// Run in headless mode (no visible window)
15    pub headless: bool,
16
17    /// Viewport width in pixels
18    pub viewport_width: u32,
19
20    /// Viewport height in pixels
21    pub viewport_height: u32,
22
23    /// Page load timeout in seconds
24    pub page_load_timeout_secs: u64,
25
26    /// Script execution timeout in seconds
27    pub script_timeout_secs: u64,
28
29    /// Implicit wait timeout in seconds
30    pub implicit_wait_secs: u64,
31
32    /// User agent string override
33    pub user_agent: Option<String>,
34
35    /// Additional browser arguments
36    pub browser_args: Vec<String>,
37}
38
39/// Supported browser types.
40#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
41#[serde(rename_all = "lowercase")]
42pub enum BrowserType {
43    Chrome,
44    Firefox,
45    Safari,
46    Edge,
47}
48
49impl Default for BrowserConfig {
50    fn default() -> Self {
51        Self {
52            webdriver_url: "http://localhost:4444".to_string(),
53            browser: BrowserType::Chrome,
54            headless: true,
55            viewport_width: 1920,
56            viewport_height: 1080,
57            page_load_timeout_secs: 30,
58            script_timeout_secs: 30,
59            implicit_wait_secs: 10,
60            user_agent: None,
61            browser_args: Vec::new(),
62        }
63    }
64}
65
66impl BrowserConfig {
67    /// Create a new config with default values.
68    pub fn new() -> Self {
69        Self::default()
70    }
71
72    /// Set the WebDriver URL.
73    pub fn webdriver_url(mut self, url: impl Into<String>) -> Self {
74        self.webdriver_url = url.into();
75        self
76    }
77
78    /// Set the browser type.
79    pub fn browser(mut self, browser: BrowserType) -> Self {
80        self.browser = browser;
81        self
82    }
83
84    /// Enable or disable headless mode.
85    pub fn headless(mut self, headless: bool) -> Self {
86        self.headless = headless;
87        self
88    }
89
90    /// Set the viewport size.
91    pub fn viewport(mut self, width: u32, height: u32) -> Self {
92        self.viewport_width = width;
93        self.viewport_height = height;
94        self
95    }
96
97    /// Set page load timeout.
98    pub fn page_load_timeout(mut self, secs: u64) -> Self {
99        self.page_load_timeout_secs = secs;
100        self
101    }
102
103    /// Set a custom user agent.
104    pub fn user_agent(mut self, ua: impl Into<String>) -> Self {
105        self.user_agent = Some(ua.into());
106        self
107    }
108
109    /// Add a browser argument.
110    pub fn add_arg(mut self, arg: impl Into<String>) -> Self {
111        self.browser_args.push(arg.into());
112        self
113    }
114}
115
116#[cfg(test)]
117mod tests {
118    use super::*;
119
120    #[test]
121    fn test_default_config() {
122        let config = BrowserConfig::default();
123        assert_eq!(config.webdriver_url, "http://localhost:4444");
124        assert!(config.headless);
125        assert_eq!(config.viewport_width, 1920);
126    }
127
128    #[test]
129    fn test_builder() {
130        let config =
131            BrowserConfig::new().browser(BrowserType::Firefox).headless(false).viewport(1280, 720);
132
133        assert_eq!(config.browser, BrowserType::Firefox);
134        assert!(!config.headless);
135        assert_eq!(config.viewport_width, 1280);
136    }
137}