[rust] Download older and unstable version of Chrome for Testing (#11678)

bonigarcia · bonigarcia · commit d86b1d442f79 · 2023-07-25T15:33:49.000+02:00
diff --git a/rust/src/chrome.rs b/rust/src/chrome.rs
diff --git 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<String, Box<dyn Error>> {
-        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
@@ -158,12 +158,15 @@ impl SeleniumManager for FirefoxManager {
     }
 
     fn request_driver_version(&mut self) -> Result<String, Box<dyn Error>> {
-        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
@@ -95,12 +95,15 @@ impl SeleniumManager for GridManager {
     }
 
     fn request_driver_version(&mut self) -> Result<String, Box<dyn Error>> {
-        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
@@ -99,12 +99,15 @@ impl SeleniumManager for IExplorerManager {
     }
 
     fn request_driver_version(&mut self) -> Result<String, Box<dyn Error>> {
-        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
@@ -133,7 +133,7 @@ pub trait SeleniumManager {
     // ----------------------------------------------------------
 
     fn download_driver(&mut self) -> Result<(), Box<dyn Error>> {
-        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<String, Box<dyn Error>> {
-        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
@@ -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<String> {
     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<String> {
     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
@@ -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
