[rust] Refactor logic to discover driver version in Firefox module using match

Author: bonigarcia

rust/src/firefox.rs

@@ -216,54 +216,57 @@ impl SeleniumManager for FirefoxManager {
             _ => {
                 self.assert_online_or_err(OFFLINE_REQUEST_ERR_MSG)?;
 
-                let driver_releases_result = parse_json_from_url::<GeckodriverReleases>(
+                let driver_version = match parse_json_from_url::<GeckodriverReleases>(
                     self.get_http_client(),
                     DRIVER_VERSIONS_URL.to_string(),
-                );
-                let driver_version = if driver_releases_result.is_ok() {
-                    let driver_releases = driver_releases_result.unwrap();
-                    let major_browser_version_int =
-                        major_browser_version.parse::<u32>().unwrap_or_default();
-                    let filtered_versions: Vec<String> = driver_releases
-                        .geckodriver_releases
-                        .into_iter()
-                        .filter(|r| {
-                            major_browser_version_int >= r.min_firefox_version
-                                && (r.max_firefox_version.is_none()
-                                    || (r.max_firefox_version.is_some()
-                                        && major_browser_version_int
-                                            <= r.max_firefox_version.unwrap()))
-                        })
-                        .map(|r| r.geckodriver_version)
-                        .collect();
-                    self.log.debug(format!(
-                        "Valid {} versions for {} {}: {:?}",
-                        &self.driver_name,
-                        &self.browser_name,
-                        major_browser_version_int,
-                        filtered_versions
-                    ));
-                    if filtered_versions.is_empty() {
-                        return Err(anyhow!(format!(
-                            "Not valid {} version found for {} {}",
-                            &self.driver_name, &self.browser_name, major_browser_version_int
-                        )));
-                    } else {
-                        filtered_versions.first().unwrap().to_string()
+                ) {
+                    Ok(driver_releases) => {
+                        let major_browser_version_int =
+                            major_browser_version.parse::<u32>().unwrap_or_default();
+                        let filtered_versions: Vec<String> = driver_releases
+                            .geckodriver_releases
+                            .into_iter()
+                            .filter(|r| {
+                                major_browser_version_int >= r.min_firefox_version
+                                    && (r.max_firefox_version.is_none()
+                                        || (r.max_firefox_version.is_some()
+                                            && major_browser_version_int
+                                                <= r.max_firefox_version.unwrap()))
+                            })
+                            .map(|r| r.geckodriver_version)
+                            .collect();
+                        self.log.debug(format!(
+                            "Valid {} versions for {} {}: {:?}",
+                            &self.driver_name,
+                            &self.browser_name,
+                            major_browser_version_int,
+                            filtered_versions
+                        ));
+                        if filtered_versions.is_empty() {
+                            return Err(anyhow!(format!(
+                                "Not valid {} version found for {} {}",
+                                &self.driver_name, &self.browser_name, major_browser_version_int
+                            )));
+                        } else {
+                            filtered_versions.first().unwrap().to_string()
+                        }
+                    }
+                    Err(err) => {
+                        self.log.warn(format!(
+                            "Problem reading {} versions: {}. Using latest {} version",
+                            &self.driver_name, err, &self.driver_name,
+                        ));
+                        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(),
+                        )?
                     }
-                } else {
-                    self.log.warn(format!(
-                        "Problem reading {} versions: {}. Using latest {} version",
-                        &self.driver_name,
-                        driver_releases_result.err().unwrap(),
-                        &self.driver_name,
-                    ));
-                    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();