Skip to content

Commit

Permalink
[rust] Download older and unstable version of Chrome for Testing (#11678
Browse files Browse the repository at this point in the history 
)
  • Loading branch information
@bonigarcia
bonigarcia committed Jul 25, 2023
1 parent deeedb1 commit d86b1d4
Show file tree
Hide file tree
Showing 9 changed files with 295 additions and 118 deletions.
228 changes: 169 additions & 59 deletions rust/src/chrome.rs
View file

Large diffs are not rendered by default.

17 changes: 9 additions & 8 deletions rust/src/edge.rs
View file
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
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
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
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
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
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
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

0 comments on commit d86b1d4

Please sign in to comment.