From e6554d3cc1d56d03b3d7415159f24ce756c1f84e Mon Sep 17 00:00:00 2001 From: gaurav0107 Date: Mon, 25 May 2026 05:07:35 +0530 Subject: [PATCH 1/2] [rust] honor --browser-version in Selenium Manager Electron driver resolution Fixes #17549. ElectronManager::request_driver_version() always read the redirect from electron/electron/releases/latest, discarding any user-supplied --browser-version. Because Electron release tags equal the chromedriver version that ships with that release, when the user pins a concrete browser version we can use it directly and skip the network roundtrip. Stable / unstable / empty browser versions retain the existing /releases/latest fallback. Also gate the metadata cache write on a non-empty major_browser_version, mirroring the chrome.rs guard, so empty-keyed driver entries no longer get persisted. --- rust/src/electron.rs | 33 +++++++++++++++++++++++---------- rust/tests/electron_tests.rs | 18 ++++++++++++++++++ 2 files changed, 41 insertions(+), 10 deletions(-) diff --git a/rust/src/electron.rs b/rust/src/electron.rs index 8f285a2c3dc68..bfc8fd3b2745c 100644 --- a/rust/src/electron.rs +++ b/rust/src/electron.rs @@ -119,17 +119,30 @@ impl SeleniumManager for ElectronManager { Ok(driver_version) } _ => { - self.assert_online_or_err(OFFLINE_REQUEST_ERR_MSG)?; - - let latest_url = format!( - "{}{}", - self.get_driver_mirror_url_or_default(DRIVER_URL), - LATEST_RELEASE - ); - let driver_version = - read_redirect_from_link(self.get_http_client(), latest_url, self.get_logger())?; + // Electron releases are tagged by Electron version, and the + // chromedriver asset shipped in each release matches that tag. + // When the user pins a concrete browser version (e.g. + // `--browser-version 36.2.1`), that version is the driver + // version we want; resolving via `/releases/latest` would + // discard the user's request and return the latest tag instead. + let browser_version = self.get_browser_version().to_string(); + let driver_version = if !browser_version.is_empty() + && !self.is_browser_version_stable() + && !self.is_browser_version_unstable() + { + browser_version + } else { + self.assert_online_or_err(OFFLINE_REQUEST_ERR_MSG)?; + let latest_url = format!( + "{}{}", + self.get_driver_mirror_url_or_default(DRIVER_URL), + LATEST_RELEASE + ); + read_redirect_from_link(self.get_http_client(), latest_url, self.get_logger())? + }; let driver_ttl = self.get_ttl(); - if driver_ttl > 0 { + if driver_ttl > 0 && !major_browser_version.is_empty() && !driver_version.is_empty() + { metadata.drivers.push(create_driver_metadata( major_browser_version, self.driver_name, diff --git a/rust/tests/electron_tests.rs b/rust/tests/electron_tests.rs index c0e6e48cf92e0..d0f390cdd1dcb 100644 --- a/rust/tests/electron_tests.rs +++ b/rust/tests/electron_tests.rs @@ -37,3 +37,21 @@ fn electron_version_test(#[case] driver_version: String) { .assert(); cmd_assert.success(); } + +#[rstest] +#[case("36.2.1")] +fn electron_browser_version_test(#[case] browser_version: String) { + // Regression for issue #17549: when the user pins --browser-version, the + // resolved driver version must be derived from the requested version, not + // from the /releases/latest redirect. + let mut cmd = get_selenium_manager(); + let cmd_assert = cmd + .args([ + "--browser", + "electron", + "--browser-version", + &browser_version, + ]) + .assert(); + cmd_assert.success(); +} From ff16a22c4272b062545f74ac22980a6c633ce546 Mon Sep 17 00:00:00 2001 From: gaurav0107 Date: Mon, 25 May 2026 05:10:16 +0530 Subject: [PATCH 2/2] [rust] strengthen electron --browser-version regression test Assert the resolved driver path actually contains the requested browser version. Without this, the test only verified that selenium manager exits successfully, which the buggy code path also did (it just downloaded the wrong version). Using --output json + the existing get_driver_path helper makes the regression assertion explicit. --- rust/tests/electron_tests.rs | 30 +++++++++++++++++++----------- 1 file changed, 19 insertions(+), 11 deletions(-) diff --git a/rust/tests/electron_tests.rs b/rust/tests/electron_tests.rs index d0f390cdd1dcb..05529be7dcd56 100644 --- a/rust/tests/electron_tests.rs +++ b/rust/tests/electron_tests.rs @@ -15,7 +15,7 @@ // specific language governing permissions and limitations // under the License. -use crate::common::get_selenium_manager; +use crate::common::{get_driver_path, get_selenium_manager}; use rstest::rstest; @@ -43,15 +43,23 @@ fn electron_version_test(#[case] driver_version: String) { fn electron_browser_version_test(#[case] browser_version: String) { // Regression for issue #17549: when the user pins --browser-version, the // resolved driver version must be derived from the requested version, not - // from the /releases/latest redirect. + // from the /releases/latest redirect. Asserting that the resolved driver + // path contains the requested version protects against silently falling + // back to the latest tag. let mut cmd = get_selenium_manager(); - let cmd_assert = cmd - .args([ - "--browser", - "electron", - "--browser-version", - &browser_version, - ]) - .assert(); - cmd_assert.success(); + cmd.args([ + "--browser", + "electron", + "--browser-version", + &browser_version, + "--output", + "json", + ]); + let driver_path = get_driver_path(&mut cmd); + assert!( + driver_path.contains(&browser_version), + "expected resolved driver path to contain requested version {}, got: {}", + browser_version, + driver_path + ); }