diff --git a/rust/src/chrome.rs b/rust/src/chrome.rs index 84b479b3f527d..aa2fec4a83253 100644 --- a/rust/src/chrome.rs +++ b/rust/src/chrome.rs @@ -49,6 +49,10 @@ const GOOD_VERSIONS_ENDPOINT: &str = "known-good-versions-with-downloads.json"; const LATEST_VERSIONS_ENDPOINT: &str = "last-known-good-versions-with-downloads.json"; const CFT_MACOS_APP_NAME: &str = "Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing"; +const MIN_CHROME_VERSION_CFT: i32 = 113; +const MIN_CHROMEDRIVER_VERSION_CFT: i32 = 115; +const UNAVAILABLE_CFT_ERROR_MESSAGE: &str = + "{} {} not available for download in Chrome for Testing (minimum version: {})"; pub struct ChromeManager { pub browser_name: &'static str, @@ -56,7 +60,8 @@ pub struct ChromeManager { pub config: ManagerConfig, pub http_client: Client, pub log: Logger, - pub download_url: Option, + pub driver_url: Option, + pub browser_url: Option, } impl ChromeManager { @@ -72,7 +77,8 @@ impl ChromeManager { http_client: create_http_client(default_timeout, default_proxy)?, config, log: Logger::default(), - download_url: None, + driver_url: None, + browser_url: None, })) } @@ -141,11 +147,73 @@ impl ChromeManager { platform_url )); let browser_version = stable_channel.version; - self.download_url = Some(platform_url.first().unwrap().url.to_string()); + self.browser_url = Some(platform_url.first().unwrap().url.to_string()); Ok(browser_version) } + fn request_fixed_browser_version_from_cft(&mut self) -> Result> { + let browser_name = self.browser_name; + let mut browser_version = self.get_browser_version().to_string(); + let major_browser_version = self.get_major_browser_version(); + self.get_logger().trace(format!( + "Using Chrome for Testing (CfT) endpoints to find out {} {}", + browser_name, major_browser_version + )); + + if self.is_browser_version_unstable() { + let versions_with_downloads = self + .request_versions_from_cft::( + self.create_latest_versions_url(), + )?; + let channel = if browser_version.eq_ignore_ascii_case(BETA) { + versions_with_downloads.channels.beta + } else if browser_version.eq_ignore_ascii_case(DEV) { + versions_with_downloads.channels.dev + } else { + versions_with_downloads.channels.canary + }; + browser_version = channel.version; + let platform_url: Vec<&PlatformUrl> = channel + .downloads + .chrome + .iter() + .filter(|p| p.platform.eq_ignore_ascii_case(self.get_platform_label())) + .collect(); + self.browser_url = Some(platform_url.first().unwrap().url.to_string()); + + Ok(browser_version) + } else { + let all_versions = self.request_versions_from_cft::( + self.create_good_versions_url(), + )?; + let filtered_versions: Vec = all_versions + .versions + .into_iter() + .filter(|r| r.version.starts_with(major_browser_version.as_str())) + .collect(); + if filtered_versions.is_empty() { + return Err(format_three_args( + UNAVAILABLE_CFT_ERROR_MESSAGE, + browser_name, + &major_browser_version, + &MIN_CHROME_VERSION_CFT.to_string(), + ) + .into()); + } + let last_browser = filtered_versions.last().unwrap(); + let platform_url: Vec<&PlatformUrl> = last_browser + .downloads + .chrome + .iter() + .filter(|p| p.platform.eq_ignore_ascii_case(self.get_platform_label())) + .collect(); + self.browser_url = Some(platform_url.first().unwrap().url.to_string()); + + Ok(last_browser.version.to_string()) + } + } + fn request_latest_driver_version_from_cft(&mut self) -> Result> { let driver_name = self.driver_name; self.get_logger().trace(format!( @@ -179,12 +247,12 @@ impl ChromeManager { self.get_driver_name(), platform_url )); - self.download_url = Some(platform_url.first().unwrap().url.to_string()); + self.driver_url = Some(platform_url.first().unwrap().url.to_string()); Ok(stable_channel.version) } - fn request_good_version_from_cft(&mut self) -> Result> { + fn request_good_driver_version_from_cft(&mut self) -> Result> { let browser_or_driver_version = if self.get_driver_version().is_empty() { self.get_browser_version() } else { @@ -203,10 +271,11 @@ impl ChromeManager { .filter(|r| r.version.starts_with(version_for_filtering.as_str())) .collect(); if filtered_versions.is_empty() { - return Err(format!( - "{} {} not available", + return Err(format_three_args( + UNAVAILABLE_CFT_ERROR_MESSAGE, self.get_driver_name(), - version_for_filtering + &version_for_filtering, + &MIN_CHROMEDRIVER_VERSION_CFT.to_string(), ) .into()); } @@ -221,7 +290,7 @@ impl ChromeManager { .filter(|p| p.platform.eq_ignore_ascii_case(self.get_platform_label())) .collect(); self.log.trace(format!("URLs for CfT: {:?}", url)); - self.download_url = Some(url.first().unwrap().url.to_string()); + self.driver_url = Some(url.first().unwrap().url.to_string()); Ok(driver_version.version.to_string()) } @@ -252,6 +321,15 @@ impl ChromeManager { .join(self.get_platform_label()) .join(self.get_browser_version()) } + + fn get_browser_binary_path_in_cache(&self) -> PathBuf { + let browser_in_cache = self.get_browser_path_in_cache(); + if MACOS.is(self.get_os()) { + browser_in_cache.join(CFT_MACOS_APP_NAME) + } else { + browser_in_cache.join(self.get_browser_name_with_extension()) + } + } } impl SeleniumManager for ChromeManager { @@ -349,12 +427,15 @@ impl SeleniumManager for ChromeManager { } fn request_driver_version(&mut self) -> Result> { - let browser_version_binding = self.get_major_browser_version(); - let browser_version = browser_version_binding.as_str(); + let major_browser_version_binding = self.get_major_browser_version(); + let major_browser_version = major_browser_version_binding.as_str(); let mut metadata = get_metadata(self.get_logger()); - match get_driver_version_from_metadata(&metadata.drivers, self.driver_name, browser_version) - { + match get_driver_version_from_metadata( + &metadata.drivers, + self.driver_name, + major_browser_version, + ) { Some(driver_version) => { self.log.trace(format!( "Driver TTL is valid. Getting {} version from metadata", @@ -365,27 +446,30 @@ impl SeleniumManager for ChromeManager { _ => { self.assert_online_or_err(OFFLINE_REQUEST_ERR_MSG)?; - let major_browser_version = browser_version.parse::().unwrap_or_default(); - let driver_version = if !browser_version.is_empty() && major_browser_version < 115 { - // For old versions (chromedriver 114-), the traditional method should work: - // https://chromedriver.chromium.org/downloads - self.request_driver_version_from_latest( - self.create_latest_release_with_version_url(), - )? - } else if browser_version.is_empty() { - // For discovering the latest driver version, the CfT endpoints are also used - self.request_latest_driver_version_from_cft()? - } else { - // As of chromedriver 115+, the metadata for version discovery are published - // by the "Chrome for Testing" (CfT) JSON endpoints: - // https://googlechromelabs.github.io/chrome-for-testing/ - self.request_good_version_from_cft()? - }; + let major_browser_version_int = + major_browser_version.parse::().unwrap_or_default(); + let driver_version = + if !major_browser_version.is_empty() && major_browser_version_int < 115 { + // For old versions (chromedriver 114-), the traditional method should work: + // https://chromedriver.chromium.org/downloads + self.request_driver_version_from_latest( + self.create_latest_release_with_version_url(), + )? + } else if major_browser_version.is_empty() { + // For discovering the latest driver version, the CfT endpoints are also used + self.request_latest_driver_version_from_cft()? + } else { + // As of chromedriver 115+, the metadata for version discovery are published + // by the "Chrome for Testing" (CfT) JSON endpoints: + // https://googlechromelabs.github.io/chrome-for-testing/ + self.request_good_driver_version_from_cft()? + }; let driver_ttl = self.get_driver_ttl(); - if driver_ttl > 0 && !browser_version.is_empty() && !driver_version.is_empty() { + if driver_ttl > 0 && !major_browser_version.is_empty() && !driver_version.is_empty() + { metadata.drivers.push(create_driver_metadata( - browser_version, + major_browser_version, self.driver_name, &driver_version, driver_ttl, @@ -403,14 +487,14 @@ impl SeleniumManager for ChromeManager { .parse::() .unwrap_or_default(); - if major_driver_version >= 115 && self.download_url.is_none() { + if major_driver_version >= MIN_CHROMEDRIVER_VERSION_CFT && self.driver_url.is_none() { // This case happens when driver_version is set (e.g. using CLI flag) - self.request_good_version_from_cft()?; + self.request_good_driver_version_from_cft()?; } // As of Chrome 115+, the driver URL is already gathered thanks to the CfT endpoints - if self.download_url.is_some() { - return Ok(self.download_url.as_ref().unwrap().to_string()); + if self.driver_url.is_some() { + return Ok(self.driver_url.as_ref().unwrap().to_string()); } let driver_version = self.get_driver_version(); @@ -468,11 +552,31 @@ impl SeleniumManager for ChromeManager { fn download_browser(&mut self) -> Result, Box> { let browser_name = self.browser_name; - - // Checking latest version of Chrome for Testing (CfT) + let browser_version_unstable = self.is_browser_version_unstable(); let mut metadata = get_metadata(self.get_logger()); - let browser_version; - match get_browser_version_from_metadata(&metadata.browsers, browser_name) { + let mut browser_version = self.get_browser_version().to_string(); + let major_browser_version = self.get_major_browser_version(); + let major_browser_version_int = major_browser_version.parse::().unwrap_or_default(); + + if !browser_version_unstable + && !major_browser_version.is_empty() + && major_browser_version_int < MIN_CHROME_VERSION_CFT + { + return Err(format_three_args( + UNAVAILABLE_CFT_ERROR_MESSAGE, + browser_name, + &major_browser_version, + &MIN_CHROME_VERSION_CFT.to_string(), + ) + .into()); + } + + // First, browser version is checked in the local metadata + match get_browser_version_from_metadata( + &metadata.browsers, + browser_name, + &major_browser_version, + ) { Some(version) => { self.get_logger().trace(format!( "Browser with valid TTL. Getting {} version from metadata", @@ -482,12 +586,17 @@ impl SeleniumManager for ChromeManager { self.set_browser_version(browser_version.clone()); } _ => { - browser_version = self.request_latest_browser_version_from_cft()?; - self.set_browser_version(browser_version.clone()); + // If not in metadata, discover version using Chrome for Testing (CfT) endpoints + if browser_version.is_empty() { + browser_version = self.request_latest_browser_version_from_cft()?; + } else { + browser_version = self.request_fixed_browser_version_from_cft()?; + } let browser_ttl = self.get_browser_ttl(); if browser_ttl > 0 && !browser_version.is_empty() { metadata.browsers.push(create_browser_metadata( browser_name, + &major_browser_version, &browser_version, browser_ttl, )); @@ -499,48 +608,49 @@ impl SeleniumManager for ChromeManager { "Required browser: {} {}", browser_name, browser_version )); + self.set_browser_version(browser_version.clone()); - // Checking if that browser version is in the cache - let browser_path_in_cache = Self::get_browser_path_in_cache(self); - let browser_path = if MACOS.is(self.get_os()) { - Some(browser_path_in_cache.join(CFT_MACOS_APP_NAME)) - } else { - Some(browser_path_in_cache.join(self.get_browser_name_with_extension())) - }; - if browser_path.clone().unwrap().exists() { + // Checking if browser version is in the cache + let browser_binary_path = self.get_browser_binary_path_in_cache(); + if browser_binary_path.exists() { self.get_logger().debug(format!( "{} {} already in the cache", browser_name, browser_version )); } else { // If browser is not in the cache, download it - let download_url = if let Some(url) = self.download_url.clone() { + let browser_url = if let Some(url) = self.browser_url.clone() { url } else { - self.request_latest_browser_version_from_cft()?; - self.download_url.clone().unwrap() + if browser_version.is_empty() { + self.request_latest_browser_version_from_cft()?; + } else { + self.request_fixed_browser_version_from_cft()?; + } + self.browser_url.clone().unwrap() }; self.get_logger().debug(format!( "Downloading {} {} from {}", self.get_browser_name(), self.get_browser_version(), - download_url + browser_url )); let (_tmp_folder, driver_zip_file) = - download_to_tmp_folder(self.get_http_client(), download_url, self.get_logger())?; + download_to_tmp_folder(self.get_http_client(), browser_url, self.get_logger())?; uncompress( &driver_zip_file, - &browser_path_in_cache, + &self.get_browser_path_in_cache(), self.get_logger(), None, )?; } - if browser_path.is_some() { - self.set_browser_path(path_buf_to_string(browser_path.clone().unwrap())); + if browser_binary_path.exists() { + self.set_browser_path(path_buf_to_string(browser_binary_path.clone())); + Ok(Some(browser_binary_path)) + } else { + Ok(None) } - - Ok(browser_path) } } diff --git a/rust/src/edge.rs b/rust/src/edge.rs index 98c8c307c7777..f496b3b196fdd 100644 --- a/rust/src/edge.rs +++ b/rust/src/edge.rs @@ -160,13 +160,13 @@ impl SeleniumManager for EdgeManager { } fn request_driver_version(&mut self) -> Result> { - let mut browser_version = self.get_major_browser_version(); + let mut major_browser_version = self.get_major_browser_version(); let mut metadata = get_metadata(self.get_logger()); match get_driver_version_from_metadata( &metadata.drivers, self.driver_name, - browser_version.as_str(), + major_browser_version.as_str(), ) { Some(driver_version) => { self.log.trace(format!( @@ -178,7 +178,7 @@ impl SeleniumManager for EdgeManager { _ => { self.assert_online_or_err(OFFLINE_REQUEST_ERR_MSG)?; - if browser_version.is_empty() { + if major_browser_version.is_empty() { let latest_stable_url = format!("{}{}", DRIVER_URL, LATEST_STABLE); self.log.debug(format!( "Reading {} latest version from {}", @@ -189,17 +189,18 @@ impl SeleniumManager for EdgeManager { latest_stable_url, self.get_logger(), )?; - browser_version = self.get_major_version(latest_driver_version.as_str())?; + major_browser_version = + self.get_major_version(latest_driver_version.as_str())?; self.log.debug(format!( "Latest {} major version is {}", - &self.driver_name, browser_version + &self.driver_name, major_browser_version )); } let driver_url = format!( "{}{}_{}_{}", DRIVER_URL, LATEST_RELEASE, - browser_version, + major_browser_version, self.get_os().to_uppercase() ); self.log.debug(format!( @@ -210,9 +211,9 @@ impl SeleniumManager for EdgeManager { read_version_from_link(self.get_http_client(), driver_url, self.get_logger())?; let driver_ttl = self.get_driver_ttl(); - if driver_ttl > 0 && !browser_version.is_empty() { + if driver_ttl > 0 && !major_browser_version.is_empty() { metadata.drivers.push(create_driver_metadata( - browser_version.as_str(), + major_browser_version.as_str(), self.driver_name, &driver_version, driver_ttl, diff --git a/rust/src/firefox.rs b/rust/src/firefox.rs index 319c111bacf08..2ab4594118465 100644 --- a/rust/src/firefox.rs +++ b/rust/src/firefox.rs @@ -158,12 +158,15 @@ impl SeleniumManager for FirefoxManager { } fn request_driver_version(&mut self) -> Result> { - let browser_version_binding = self.get_major_browser_version(); - let browser_version = browser_version_binding.as_str(); + let major_browser_version_binding = self.get_major_browser_version(); + let major_browser_version = major_browser_version_binding.as_str(); let mut metadata = get_metadata(self.get_logger()); - match get_driver_version_from_metadata(&metadata.drivers, self.driver_name, browser_version) - { + match get_driver_version_from_metadata( + &metadata.drivers, + self.driver_name, + major_browser_version, + ) { Some(driver_version) => { self.log.trace(format!( "Driver TTL is valid. Getting {} version from metadata", @@ -179,9 +182,9 @@ impl SeleniumManager for FirefoxManager { read_redirect_from_link(self.get_http_client(), latest_url, self.get_logger())?; let driver_ttl = self.get_driver_ttl(); - if driver_ttl > 0 && !browser_version.is_empty() { + if driver_ttl > 0 && !major_browser_version.is_empty() { metadata.drivers.push(create_driver_metadata( - browser_version, + major_browser_version, self.driver_name, &driver_version, driver_ttl, diff --git a/rust/src/grid.rs b/rust/src/grid.rs index 83a3e478d46f1..7ccd1a444a1db 100644 --- a/rust/src/grid.rs +++ b/rust/src/grid.rs @@ -95,12 +95,15 @@ impl SeleniumManager for GridManager { } fn request_driver_version(&mut self) -> Result> { - let browser_version_binding = self.get_major_browser_version(); - let browser_version = browser_version_binding.as_str(); + let major_browser_version_binding = self.get_major_browser_version(); + let major_browser_version = major_browser_version_binding.as_str(); let mut metadata = get_metadata(self.get_logger()); - match get_driver_version_from_metadata(&metadata.drivers, self.driver_name, browser_version) - { + match get_driver_version_from_metadata( + &metadata.drivers, + self.driver_name, + major_browser_version, + ) { Some(driver_version) => { self.log.trace(format!( "Driver TTL is valid. Getting {} version from metadata", @@ -148,7 +151,7 @@ impl SeleniumManager for GridManager { let driver_ttl = self.get_driver_ttl(); if driver_ttl > 0 { metadata.drivers.push(create_driver_metadata( - browser_version, + major_browser_version, self.driver_name, &driver_version, driver_ttl, diff --git a/rust/src/iexplorer.rs b/rust/src/iexplorer.rs index ebaab73ad8007..f6264930ad3e2 100644 --- a/rust/src/iexplorer.rs +++ b/rust/src/iexplorer.rs @@ -99,12 +99,15 @@ impl SeleniumManager for IExplorerManager { } fn request_driver_version(&mut self) -> Result> { - let browser_version_binding = self.get_major_browser_version(); - let browser_version = browser_version_binding.as_str(); + let major_browser_version_binding = self.get_major_browser_version(); + let major_browser_version = major_browser_version_binding.as_str(); let mut metadata = get_metadata(self.get_logger()); - match get_driver_version_from_metadata(&metadata.drivers, self.driver_name, browser_version) - { + match get_driver_version_from_metadata( + &metadata.drivers, + self.driver_name, + major_browser_version, + ) { Some(driver_version) => { self.log.trace(format!( "Driver TTL is valid. Getting {} version from metadata", @@ -146,9 +149,9 @@ impl SeleniumManager for IExplorerManager { )?; let driver_ttl = self.get_driver_ttl(); - if driver_ttl > 0 && !browser_version.is_empty() { + if driver_ttl > 0 && !major_browser_version.is_empty() { metadata.drivers.push(create_driver_metadata( - browser_version, + major_browser_version, self.driver_name, &driver_version, driver_ttl, diff --git a/rust/src/lib.rs b/rust/src/lib.rs index d2856738a660f..b65bf59bce24a 100644 --- a/rust/src/lib.rs +++ b/rust/src/lib.rs @@ -133,7 +133,7 @@ pub trait SeleniumManager { // ---------------------------------------------------------- fn download_driver(&mut self) -> Result<(), Box> { - let driver_url = Self::get_driver_url(self)?; + let driver_url = self.get_driver_url()?; self.get_logger() .debug(format!("Driver URL: {}", driver_url)); let (_tmp_folder, driver_zip_file) = @@ -159,9 +159,10 @@ pub trait SeleniumManager { let mut browser_version = self.get_browser_version(); if browser_version.eq_ignore_ascii_case(CANARY) { browser_version = NIGHTLY; - } else if browser_version.is_empty() { + } else if !self.is_browser_version_unstable() { browser_version = STABLE; } + let browser_path = self .get_browser_path_map() .get(&BrowserPath::new(str_to_os(self.get_os()), browser_version)) @@ -247,11 +248,11 @@ pub trait SeleniumManager { } fn discover_driver_version(&mut self) -> Result> { - if self.is_force_browser_download() { - self.download_browser()?; - } - let browser_version = self.get_major_browser_version(); - if browser_version.is_empty() || self.is_browser_version_unstable() { + let mut download_browser = self.is_force_browser_download(); + let major_browser_version = self.get_major_browser_version(); + + // First, we try to discover the browser version + if !download_browser { match self.discover_browser_version() { Some(version) => { if !self.is_safari() { @@ -260,6 +261,20 @@ pub trait SeleniumManager { self.get_browser_name(), version )); + } + let discovered_major_browser_version = + self.get_major_version(&version).unwrap_or_default(); + if !major_browser_version.is_empty() + && !self.is_browser_version_unstable() + && !major_browser_version.eq(&discovered_major_browser_version) + { + self.get_logger().debug(format!( + "Discovered browser version ({}) different to specified browser version ({})", + discovered_major_browser_version, + major_browser_version, + )); + download_browser = true; + } else { self.set_browser_version(version); } } @@ -268,25 +283,31 @@ pub trait SeleniumManager { "{} has not been discovered in the system", self.get_browser_name() )); - let browser_path = self.download_browser()?; - if browser_path.is_some() { - self.get_logger().debug(format!( - "{} {} has been downloaded at {}", - self.get_browser_name(), - self.get_browser_version(), - browser_path.unwrap().display() - )); - } else if self.is_browser_version_unstable() { - return Err(format!("Browser version '{browser_version}' not found").into()); - } else if !self.is_iexplorer() && !self.is_grid() { - self.get_logger().warn(format!( - "The version of {} cannot be detected. Trying with latest driver version", - self.get_browser_name() - )); - } + download_browser = true; } } } + + if download_browser { + let browser_path = self.download_browser()?; + if browser_path.is_some() { + self.get_logger().debug(format!( + "{} {} has been downloaded at {}", + self.get_browser_name(), + self.get_browser_version(), + browser_path.unwrap().display() + )); + } else if self.is_browser_version_unstable() { + return Err(format!("Browser version '{major_browser_version}' not found").into()); + } else if !self.is_iexplorer() && !self.is_grid() { + self.get_logger().warn(format!( + "The version of {} cannot be detected. Trying with latest driver version", + self.get_browser_name() + )); + } + } + + // Second, we request the driver version using online metadata let driver_version = self.request_driver_version()?; if driver_version.is_empty() { Err(format!( @@ -557,8 +578,12 @@ pub trait SeleniumManager { } fn get_major_browser_version(&self) -> String { - self.get_major_version(self.get_browser_version()) - .unwrap_or_default() + if self.is_browser_version_unstable() { + self.get_browser_version().to_string() + } else { + self.get_major_version(self.get_browser_version()) + .unwrap_or_default() + } } fn set_browser_version(&mut self, browser_version: String) { diff --git a/rust/src/metadata.rs b/rust/src/metadata.rs index b1407e4598209..2342923b0f6ed 100644 --- a/rust/src/metadata.rs +++ b/rust/src/metadata.rs @@ -31,13 +31,14 @@ const METADATA_FILE: &str = "selenium-manager.json"; #[derive(Serialize, Deserialize)] pub struct Browser { pub browser_name: String, + pub major_browser_version: String, pub browser_version: String, pub browser_ttl: u64, } #[derive(Serialize, Deserialize)] pub struct Driver { - pub browser_version: String, + pub major_browser_version: String, pub driver_name: String, pub driver_version: String, pub driver_ttl: u64, @@ -92,10 +93,13 @@ pub fn get_metadata(log: &Logger) -> Metadata { pub fn get_browser_version_from_metadata( browsers_metadata: &[Browser], browser_name: &str, + major_browser_version: &str, ) -> Option { let browser: Vec<&Browser> = browsers_metadata .iter() - .filter(|b| b.browser_name.eq(browser_name)) + .filter(|b| { + b.browser_name.eq(browser_name) && b.major_browser_version.eq(major_browser_version) + }) .collect(); if browser.is_empty() { None @@ -107,11 +111,13 @@ pub fn get_browser_version_from_metadata( pub fn get_driver_version_from_metadata( drivers_metadata: &[Driver], driver_name: &str, - browser_version: &str, + major_browser_version: &str, ) -> Option { let driver: Vec<&Driver> = drivers_metadata .iter() - .filter(|d| d.driver_name.eq(driver_name) && d.browser_version.eq(browser_version)) + .filter(|d| { + d.driver_name.eq(driver_name) && d.major_browser_version.eq(major_browser_version) + }) .collect(); if driver.is_empty() { None @@ -122,24 +128,26 @@ pub fn get_driver_version_from_metadata( pub fn create_browser_metadata( browser_name: &str, - browser_version: &String, + major_browser_version: &str, + browser_version: &str, browser_ttl: u64, ) -> Browser { Browser { browser_name: browser_name.to_string(), + major_browser_version: major_browser_version.to_string(), browser_version: browser_version.to_string(), browser_ttl: now_unix_timestamp() + browser_ttl, } } pub fn create_driver_metadata( - browser_version: &str, + major_browser_version: &str, driver_name: &str, driver_version: &str, driver_ttl: u64, ) -> Driver { Driver { - browser_version: browser_version.to_string(), + major_browser_version: major_browser_version.to_string(), driver_name: driver_name.to_string(), driver_version: driver_version.to_string(), driver_ttl: now_unix_timestamp() + driver_ttl, diff --git a/rust/tests/chrome_download_tests.rs b/rust/tests/chrome_download_tests.rs index 3355f422d46da..73c09deed618b 100644 --- a/rust/tests/chrome_download_tests.rs +++ b/rust/tests/chrome_download_tests.rs @@ -19,11 +19,12 @@ use assert_cmd::Command; use std::path::Path; use is_executable::is_executable; +use rstest::rstest; use selenium_manager::logger::JsonOutput; use std::str; #[test] -fn chrome_download_test() { +fn chrome_latest_download_test() { let mut cmd = Command::new(env!("CARGO_BIN_EXE_selenium-manager")); cmd.args([ "--browser", @@ -36,6 +37,30 @@ fn chrome_download_test() { .success() .code(0); + assert_driver_and_browser(&mut cmd); +} + +#[rstest] +#[case("113")] +#[case("beta")] +fn chrome_version_download_test(#[case] browser_version: String) { + let mut cmd = Command::new(env!("CARGO_BIN_EXE_selenium-manager")); + cmd.args([ + "--browser", + "chrome", + "--browser-version", + &browser_version, + "--output", + "json", + ]) + .assert() + .success() + .code(0); + + assert_driver_and_browser(&mut cmd); +} + +fn assert_driver_and_browser(cmd: &mut Command) { let stdout = &cmd.unwrap().stdout; let output = str::from_utf8(stdout).unwrap(); println!("{}", output); diff --git a/rust/tests/cli_tests.rs b/rust/tests/cli_tests.rs index a0d1385deecec..bda1072ad284a 100644 --- a/rust/tests/cli_tests.rs +++ b/rust/tests/cli_tests.rs @@ -22,7 +22,6 @@ use std::str; #[rstest] #[case("chrome", "chromedriver", "", "")] -#[case("chrome", "chromedriver", "105", "105.0.5195.52")] #[case("chrome", "chromedriver", "114", "114.0.5735.90")] #[case("chrome", "chromedriver", "115", "115.0.5790")] #[case("edge", "msedgedriver", "", "")]