Selenium Manager is a command-line tool and Rust library that provides automated browser and driver management for Selenium WebDriver. It automatically downloads, configures, and manages browser drivers (ChromeDriver, GeckoDriver, EdgeDriver, etc.) and browsers for Selenium WebDriver tests across multiple platforms.
selenium-manager = "0.4.33"use selenium_manager::{
SeleniumManager,
get_manager_by_browser, get_manager_by_driver,
clear_cache
};
use selenium_manager::config::ManagerConfig;
use selenium_manager::logger::Logger;
use selenium_manager::chrome::ChromeManager;
use selenium_manager::firefox::FirefoxManager;
use selenium_manager::edge::EdgeManager;
use selenium_manager::safari::SafariManager;
use selenium_manager::safaritp::SafariTPManager;
use selenium_manager::iexplorer::IExplorerManager;
use selenium_manager::grid::GridManager;
use std::path::PathBuf;
use std::collections::HashMap;
use reqwest::Client;
use anyhow::{Result, Error};
use std::sync::mpsc::{Sender, Receiver};# Download ChromeDriver for Chrome
selenium-manager --browser chrome
# Download GeckoDriver for Firefox
selenium-manager --browser firefox
# Download EdgeDriver for specific browser version
selenium-manager --browser edge --browser-version 120
# Use as driver manager
selenium-manager --driver chromedriver
# Selenium Grid support
selenium-manager --griduse selenium_manager::{get_manager_by_browser, SeleniumManager};
use anyhow::Result;
fn main() -> Result<()> {
// Create manager for Chrome
let mut manager = get_manager_by_browser("chrome".to_string())?;
// Set up browser and driver
let driver_path = manager.setup()?;
println!("Driver available at: {}", driver_path.display());
Ok(())
}Selenium Manager follows a trait-based architecture:
Command-line interface with comprehensive browser and driver management capabilities.
struct Cli {
browser: Option<String>, // Browser name
driver: Option<String>, // Driver name
grid: Option<String>, // Selenium Grid
browser_version: Option<String>, // Browser version
driver_version: Option<String>, // Driver version
output: String, // Output format
offline: bool, // Offline mode
cache_path: Option<String>, // Cache directory
// ... additional CLI options
}Automated management of web browsers including download, installation, and version detection.
trait SeleniumManager {
// Browser information
fn get_browser_name(&self) -> &str;
fn get_browser_names_in_path(&self) -> Vec<&str>;
fn get_browser_path_map(&self) -> HashMap<BrowserPath, &str>;
// Browser discovery and version detection
fn discover_browser_version(&mut self) -> Result<Option<String>, Error>;
fn request_browser_version(&mut self) -> Result<Option<String>, Error>;
fn detect_browser_path(&mut self) -> Option<PathBuf>;
// Browser downloading
fn download_browser(&mut self, browser_version: &str) -> Result<Option<PathBuf>, Error>;
fn get_browser_binary_path(&mut self, browser_version: &str) -> Result<PathBuf, Error>;
fn get_browser_url_for_download(&mut self, browser_version: &str) -> Result<String, Error>;
fn get_browser_label_for_download(&self, browser_version: &str) -> Result<Option<&str>, Error>;
fn get_min_browser_version_for_download(&self) -> Result<i32, Error>;
// Browser download control
fn is_download_browser(&self) -> bool;
fn set_download_browser(&mut self, download_browser: bool);
}Automated downloading and setup of WebDriver executables for different browsers.
trait SeleniumManager {
// Driver information
fn get_driver_name(&self) -> &str;
fn get_platform_label(&self) -> &str;
// Driver version resolution
fn request_driver_version(&mut self) -> Result<String, Error>;
fn request_latest_browser_version_from_online(&mut self, browser_version: &str) -> Result<String, Error>;
fn request_fixed_browser_version_from_online(&mut self, browser_version: &str) -> Result<String, Error>;
// Driver downloading and paths
fn get_driver_url(&mut self) -> Result<String, Error>;
fn download_driver(&mut self) -> Result<(), Error>;
fn get_driver_path_in_cache(&self) -> Result<PathBuf, Error>;
// Main setup method
fn setup(&mut self) -> Result<PathBuf, Error>;
}Specific implementations for different browsers with their unique requirements.
impl ChromeManager {
pub fn new() -> Result<Box<Self>, Error>;
}
impl FirefoxManager {
pub fn new() -> Result<Box<Self>, Error>;
}
impl EdgeManager {
pub fn new() -> Result<Box<Self>, Error>;
pub fn new_with_name(browser_name: String) -> Result<Box<Self>, Error>;
}
impl SafariManager {
pub fn new() -> Result<Box<Self>, Error>;
}
impl SafariTPManager {
pub fn new() -> Result<Box<Self>, Error>;
}
impl IExplorerManager {
pub fn new() -> Result<Box<Self>, Error>;
}
impl GridManager {
pub fn new(grid_version: String) -> Result<Box<Self>, Error>;
}Comprehensive configuration management for customizing behavior.
trait SeleniumManager {
// Configuration management
fn get_config(&self) -> &ManagerConfig;
fn get_config_mut(&mut self) -> &mut ManagerConfig;
fn set_config(&mut self, config: ManagerConfig);
// HTTP client management
fn get_http_client(&self) -> &Client;
fn set_http_client(&mut self, http_client: Client);
// Logger management
fn get_logger(&self) -> &Logger;
fn set_logger(&mut self, log: Logger);
// Communication channels
fn get_sender(&self) -> &Sender<String>;
fn get_receiver(&self) -> &Receiver<String>;
// Version getters and setters
fn get_browser_version(&self) -> &str;
fn set_browser_version(&mut self, browser_version: String);
fn get_driver_version(&self) -> &str;
fn set_driver_version(&mut self, driver_version: String);
fn get_browser_path(&self) -> &str;
fn set_browser_path(&mut self, browser_path: String);
fn get_driver_mirror_url(&self) -> &str;
fn set_driver_mirror_url(&mut self, mirror_url: String);
fn get_browser_mirror_url(&self) -> &str;
fn set_browser_mirror_url(&mut self, mirror_url: String);
// Utility version checking methods
fn get_major_browser_version(&self) -> String;
fn get_major_driver_version(&self) -> String;
fn is_browser_version_stable(&self) -> bool;
fn is_browser_version_unstable(&self) -> bool;
fn is_browser_version_empty(&self) -> bool;
fn is_browser_version_specific(&self) -> bool;
// Browser type checks
fn is_safari(&self) -> bool;
fn is_iexplorer(&self) -> bool;
fn is_grid(&self) -> bool;
fn is_firefox(&self) -> bool;
fn is_edge(&self) -> bool;
fn is_webview2(&self) -> bool;
fn is_snap(&self, browser_path: &str) -> bool;
fn get_snap_path(&self) -> Option<PathBuf>;
}impl Logger {
pub fn new() -> Logger;
pub fn create(output: &str, debug: bool, trace: bool, log_level: &str) -> Logger;
}fn get_manager_by_browser(browser_name: String) -> Result<Box<dyn SeleniumManager>, Error>;
fn get_manager_by_driver(driver_name: String) -> Result<Box<dyn SeleniumManager>, Error>;fn clear_cache(log: &Logger, path: &str);
fn create_http_client(timeout: u64, proxy: &str) -> Result<Client, Error>;trait SeleniumManager {
// OS and architecture
fn get_os(&self) -> &str;
fn set_os(&mut self, os: String);
fn get_arch(&self) -> &str;
fn set_arch(&mut self, arch: String);
// Cache and path management
fn get_cache_path(&self) -> Result<String, Error>;
fn set_cache_path(&mut self, cache_path: String);
fn get_browser_path_or_latest_from_cache(&self) -> String;
// Timeout and network configuration
fn get_timeout(&self) -> u64;
fn set_timeout(&mut self, timeout: u64) -> Result<(), Error>;
fn set_proxy(&mut self, proxy: String) -> Result<(), Error>;
fn is_offline(&self) -> bool;
fn set_offline(&mut self, offline: bool);
// Driver specific configuration
fn get_driver_name_with_extension(&self) -> String;
fn is_fallback_driver_from_cache(&self) -> bool;
fn set_fallback_driver_from_cache(&mut self, fallback: bool);
fn find_best_driver_from_cache(&self) -> Result<Option<PathBuf>, Error>;
// Browser download and configuration flags
fn is_force_browser_download(&self) -> bool;
fn set_force_browser_download(&mut self, force: bool);
fn is_avoid_browser_download(&self) -> bool;
fn set_avoid_browser_download(&mut self, avoid: bool);
fn is_skip_driver_in_path(&self) -> bool;
fn set_skip_driver_in_path(&mut self, skip: bool);
fn is_skip_browser_in_path(&self) -> bool;
fn set_skip_browser_in_path(&mut self, skip: bool);
// Statistics and metadata
fn stats(&mut self) -> Result<(), Error>;
fn set_selenium_version(&mut self, version: String);
fn set_language_binding(&mut self, binding: String);
fn set_avoid_stats(&mut self, avoid: bool);
// TTL management
fn get_ttl(&self) -> u64;
fn set_ttl(&mut self, ttl: u64);
}pub enum BrowserPath {
// Platform-specific browser paths enumeration
}
pub struct ManagerConfig {
pub cache_path: String,
pub fallback_driver_from_cache: bool,
pub browser_version: String,
pub driver_version: String,
pub browser_path: String,
pub driver_mirror_url: String,
pub browser_mirror_url: String,
pub os: String,
pub arch: String,
pub proxy: String,
pub timeout: u64,
pub ttl: u64,
pub offline: bool,
pub force_browser_download: bool,
pub avoid_browser_download: bool,
pub language_binding: String,
pub selenium_version: String,
pub avoid_stats: bool,
pub skip_driver_in_path: bool,
pub skip_browser_in_path: bool,
}
impl ManagerConfig {
pub fn default(browser_name: &str, driver_name: &str) -> ManagerConfig;
}const REQUEST_TIMEOUT_SEC: u64 = 300;
const STABLE: &str = "stable";
const BETA: &str = "beta";
const DEV: &str = "dev";
const CANARY: &str = "canary";
const NIGHTLY: &str = "nightly";
const ESR: &str = "esr";
const TTL_SEC: u64 = 3600;
const SM_BETA_LABEL: &str = "0.";All functions return Result<T, anyhow::Error> for comprehensive error handling. Common error scenarios include: