Skip to content

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

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Jul 25, 2023
Merged

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

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
228 changes: 169 additions & 59 deletions rust/src/chrome.rs
View file
Open in desktop

Large diffs are not rendered by default.

17 changes: 9 additions & 8 deletions rust/src/edge.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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!(
Expand All @@ -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 {}",
Expand All @@ -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!(
Expand All @@ -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,
Expand Down
15 changes: 9 additions & 6 deletions rust/src/firefox.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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",
Expand All @@ -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,
Expand Down
13 changes: 8 additions & 5 deletions rust/src/grid.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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",
Expand Down Expand Up @@ -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,
Expand Down
15 changes: 9 additions & 6 deletions rust/src/iexplorer.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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",
Expand Down Expand Up @@ -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,
Expand Down
75 changes: 50 additions & 25 deletions rust/src/lib.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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) =
Expand All @@ -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))
Expand Down Expand Up @@ -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() {
Expand All @@ -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);
}
}
Expand All @@ -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!(
Expand Down Expand Up @@ -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) {
Expand Down
22 changes: 15 additions & 7 deletions rust/src/metadata.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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,
Expand Down Expand Up @@ -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
Expand All @@ -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
Expand All @@ -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,
Expand Down
27 changes: 26 additions & 1 deletion rust/tests/chrome_download_tests.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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",
Expand All @@ -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);
Expand Down
Loading