Method request_driver_version

rust/src/grid.rs:108–193

(&mut self)

    }

    fn request_driver_version(&mut self) -> Result<String, Error> {
        let is_nightly = self.is_nightly(self.get_driver_version());
        let major_driver_version_binding = self.get_major_driver_version();
        let major_driver_version = major_driver_version_binding.as_str();
        let cache_path = self.get_cache_path()?;
        let mut metadata = get_metadata(self.get_logger(), &cache_path);

        match get_driver_version_from_metadata(
            &metadata.drivers,
            self.driver_name,
            major_driver_version,
        ) {
            Some(driver_version) => {
                self.log.trace(format!(
                    "Driver TTL is valid. Getting {} version from metadata",
                    &self.driver_name
                ));
                Ok(driver_version)
            }
            _ => {
                self.assert_online_or_err(OFFLINE_REQUEST_ERR_MSG)?;

                let selenium_releases = parse_json_from_url::<Vec<SeleniumRelease>>(
                    self.get_http_client(),
                    MIRROR_URL,
                )?;

                let filtered_releases: Vec<SeleniumRelease> = selenium_releases
                    .into_iter()
                    .filter(|r| {
                        r.assets.iter().any(|url| {
                            if is_nightly {
                                url.browser_download_url.contains(SNAPSHOT)
                            } else {
                                url.browser_download_url.contains(GRID_RELEASE)
                                    && !url.browser_download_url.contains(SNAPSHOT)
                            }
                        })
                    })
                    .collect();

                if !filtered_releases.is_empty() {
                    let assets = &filtered_releases.first().unwrap().assets;
                    let driver_releases: Vec<&Assets> = assets
                        .iter()
                        .filter(|url| {
                            url.browser_download_url.contains(GRID_RELEASE)
                                && url.browser_download_url.contains(GRID_EXTENSION)
                        })
                        .collect();
                    let driver_url = &driver_releases.last().unwrap().browser_download_url;
                    self.driver_url = Some(driver_url.to_string());

                    let index_release =
                        driver_url.rfind(GRID_RELEASE).unwrap() + GRID_RELEASE.len() + 1;
                    let driver_version = if is_nightly {
                        let index_jar = driver_url.rfind(GRID_EXTENSION).unwrap() - 1;
                        driver_url.as_str()[index_release..index_jar].to_string()