From c0317a5ed672732a9eaac5608ca5cf79b184b1a8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Boni=20Garc=C3=ADa?= <boni.garcia@uc3m.es>
Date: Mon, 31 Jul 2023 10:18:28 +0200
Subject: [PATCH] [rust] Save discovered browser version (network request) in
 local metadata (#12443)

---
 rust/src/chrome.rs | 48 ++++++++++++++++++++++++++++++++++++++++++----
 rust/src/lib.rs    |  8 ++++++--
 2 files changed, 50 insertions(+), 6 deletions(-)

diff --git a/rust/src/chrome.rs b/rust/src/chrome.rs
index 35e3c651f435b..829e9d4250abf 100644
--- a/rust/src/chrome.rs
+++ b/rust/src/chrome.rs
@@ -482,7 +482,43 @@ impl SeleniumManager for ChromeManager {
     }
 
     fn request_browser_version(&mut self) -> Result<Option<String>, Box<dyn Error>> {
-        Ok(Some(self.request_latest_browser_version_from_cft()?))
+        let browser_name = self.browser_name;
+        let browser_version;
+        let major_browser_version = self.get_major_browser_version();
+        let mut metadata = get_metadata(self.get_logger());
+
+        // 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",
+                    browser_name
+                ));
+                browser_version = version;
+                self.set_browser_version(browser_version.clone());
+            }
+            _ => {
+                // If not in metadata, discover version using Chrome for Testing (CfT) endpoints
+                browser_version = self.request_latest_browser_version_from_cft()?;
+
+                let browser_ttl = self.get_browser_ttl();
+                if browser_ttl > 0 {
+                    metadata.browsers.push(create_browser_metadata(
+                        browser_name,
+                        &major_browser_version,
+                        &browser_version,
+                        browser_ttl,
+                    ));
+                    write_metadata(&metadata, self.get_logger());
+                }
+            }
+        }
+
+        Ok(Some(browser_version))
     }
 
     fn get_driver_url(&mut self) -> Result<String, Box<dyn Error>> {
@@ -563,6 +599,7 @@ impl SeleniumManager for ChromeManager {
 
         if !self.is_browser_version_unstable()
             && !self.is_browser_version_stable()
+            && !self.is_browser_version_empty()
             && major_browser_version_int < MIN_CHROME_VERSION_CFT
         {
             return Err(format_three_args(
@@ -590,7 +627,7 @@ impl SeleniumManager for ChromeManager {
             }
             _ => {
                 // If not in metadata, discover version using Chrome for Testing (CfT) endpoints
-                if self.is_browser_version_stable() {
+                if self.is_browser_version_stable() || self.is_browser_version_empty() {
                     browser_version = self.request_latest_browser_version_from_cft()?;
                 } else {
                     browser_version = self.request_fixed_browser_version_from_cft()?;
@@ -598,7 +635,10 @@ impl SeleniumManager for ChromeManager {
                 self.set_browser_version(browser_version.clone());
 
                 let browser_ttl = self.get_browser_ttl();
-                if browser_ttl > 0 && !self.is_browser_version_stable() {
+                if browser_ttl > 0
+                    && !self.is_browser_version_empty()
+                    && !self.is_browser_version_stable()
+                {
                     metadata.browsers.push(create_browser_metadata(
                         browser_name,
                         &major_browser_version,
@@ -626,7 +666,7 @@ impl SeleniumManager for ChromeManager {
             let browser_url = if let Some(url) = self.browser_url.clone() {
                 url
             } else {
-                if self.is_browser_version_stable() {
+                if self.is_browser_version_stable() || self.is_browser_version_empty() {
                     self.request_latest_browser_version_from_cft()?;
                 } else {
                     self.request_fixed_browser_version_from_cft()?;
diff --git a/rust/src/lib.rs b/rust/src/lib.rs
index 872934c11fc03..81eac2a39434e 100644
--- a/rust/src/lib.rs
+++ b/rust/src/lib.rs
@@ -283,6 +283,7 @@ pub trait SeleniumManager {
                                     self.get_browser_name(),
                                     major_online_browser_version,
                                 ));
+                                self.set_browser_version(version);
                             }
                         }
                     } else if !major_browser_version.is_empty()
@@ -433,9 +434,12 @@ pub trait SeleniumManager {
             || browser_version.eq_ignore_ascii_case(CANARY)
     }
 
+    fn is_browser_version_empty(&self) -> bool {
+        self.get_browser_version().is_empty()
+    }
+
     fn is_browser_version_stable(&self) -> bool {
-        let browser_version = self.get_browser_version();
-        browser_version.is_empty() || browser_version.eq_ignore_ascii_case(STABLE)
+        self.get_browser_version().eq_ignore_ascii_case(STABLE)
     }
 
     fn resolve_driver(&mut self) -> Result<PathBuf, Box<dyn Error>> {