use std::path::Path;
use std::time::{Duration, SystemTime};
use serde::{Deserialize, Serialize};
use tokio::fs;
const FALLBACK_CHROME_VERSION: &str = "131.0.0.0";
#[derive(Debug, Clone, Serialize, Deserialize)]
struct UserAgentMetadata {
chrome_version: String,
last_updated: SystemTime,
}
async fn fetch_latest_chrome_version() -> String {
let sources = vec![
"https://googlechromelabs.github.io/chrome-for-testing/last-known-good-versions-with-downloads.json",
"https://chromedriver.storage.googleapis.com/LATEST_RELEASE",
];
for source in sources {
match try_fetch_chrome_version(source).await {
Ok(version) => {
log::debug!("Fetched Chrome version {version} from {source}");
return version;
}
Err(e) => {
log::debug!("Failed to fetch Chrome version from {source}: {e}");
}
}
}
log::warn!(
"Failed to fetch latest Chrome version from all sources, using fallback: {FALLBACK_CHROME_VERSION}"
);
FALLBACK_CHROME_VERSION.to_string()
}
async fn try_fetch_chrome_version(url: &str) -> Result<String, anyhow::Error> {
use crate::initialization::build_download_client;
let client = build_download_client(Duration::from_secs(5))?;
let response = client.get(url).send().await?;
if !response.status().is_success() {
return Err(anyhow::anyhow!("HTTP {}", response.status()));
}
let text = response.text().await?;
if url.contains("LATEST_RELEASE") {
let version = text.trim();
let major = version.split('.').next().unwrap_or(version);
Ok(format!("{major}.0.0.0"))
} else if url.contains("chrome-for-testing") {
#[derive(Deserialize)]
struct ChromeVersions {
channels: Option<ChromeChannels>,
}
#[derive(Deserialize)]
struct ChromeChannels {
#[serde(rename = "Stable")]
stable: Option<ChromeVersion>,
}
#[derive(Deserialize)]
struct ChromeVersion {
version: String,
}
let versions: ChromeVersions = serde_json::from_str(&text)?;
if let Some(channels) = versions.channels {
if let Some(stable) = channels.stable {
let major = stable
.version
.split('.')
.next()
.unwrap_or(&stable.version)
.to_string();
return Ok(format!("{major}.0.0.0"));
}
}
Err(anyhow::anyhow!("No stable version found in JSON"))
} else {
Ok(text.trim().to_string())
}
}
pub async fn get_chrome_version(cache_dir: Option<&Path>) -> String {
let cache_path = cache_dir.map_or_else(
|| crate::cache_paths::user_agent_dir(&crate::cache_paths::resolve_cache_root(None)),
std::path::Path::to_path_buf,
);
if let Ok(version) = load_from_cache(&cache_path).await {
return version;
}
let version = fetch_latest_chrome_version().await;
if let Err(e) = save_to_cache(&cache_path, &version).await {
log::debug!("Failed to save User-Agent cache: {e}");
}
version
}
async fn load_from_cache(cache_dir: &Path) -> Result<String, anyhow::Error> {
let metadata_path = cache_dir.join("version.json");
if !metadata_path.exists() {
return Err(anyhow::anyhow!("Cache not found"));
}
let metadata_json = fs::read_to_string(&metadata_path).await?;
let metadata: UserAgentMetadata = serde_json::from_str(&metadata_json)?;
if crate::utils::cache::cache_ttl_exceeded(
metadata.last_updated,
crate::config::USER_AGENT_CACHE_TTL_SECS,
false,
) {
return Err(anyhow::anyhow!("Cache expired"));
}
Ok(metadata.chrome_version)
}
async fn save_to_cache(cache_dir: &Path, version: &str) -> Result<(), anyhow::Error> {
fs::create_dir_all(cache_dir).await?;
let metadata = UserAgentMetadata {
chrome_version: version.to_string(),
last_updated: SystemTime::now(),
};
let metadata_path = cache_dir.join("version.json");
let metadata_json = serde_json::to_string_pretty(&metadata)?;
crate::utils::cache::write_atomic(&metadata_path, metadata_json.as_bytes()).await?;
Ok(())
}
pub fn generate_user_agent(chrome_version: &str) -> String {
format!(
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/{chrome_version} Safari/537.36"
)
}
pub async fn get_default_user_agent(cache_dir: Option<&Path>) -> String {
let chrome_version = get_chrome_version(cache_dir).await;
generate_user_agent(&chrome_version)
}
#[cfg(test)]
mod tests {
use super::*;
use std::time::{Duration, SystemTime};
use tempfile::TempDir;
#[test]
fn test_generate_user_agent() {
let version = "131.0.0.0";
let ua = generate_user_agent(version);
assert!(ua.contains("Chrome/131.0.0.0"));
assert!(ua.contains("Mozilla/5.0"));
assert!(ua.contains("Windows NT 10.0"));
}
#[tokio::test]
async fn test_get_chrome_version_fallback() {
let temp_dir = TempDir::new().unwrap();
let cache_dir = temp_dir.path();
let version = get_chrome_version(Some(cache_dir)).await;
assert!(!version.is_empty());
assert!(version.contains('.'));
}
#[tokio::test]
async fn test_load_from_cache_missing_file() {
let temp_dir = TempDir::new().unwrap();
let cache_dir = temp_dir.path();
let result = load_from_cache(cache_dir).await;
assert!(result.is_err());
assert!(result.unwrap_err().to_string().contains("Cache not found"));
}
#[tokio::test]
async fn test_load_from_cache_expired() {
let temp_dir = TempDir::new().unwrap();
let cache_dir = temp_dir.path();
let metadata = UserAgentMetadata {
chrome_version: "100.0.0.0".to_string(),
last_updated: SystemTime::now() - Duration::from_secs(31 * 24 * 60 * 60), };
let metadata_path = cache_dir.join("version.json");
std::fs::create_dir_all(cache_dir).unwrap();
let metadata_json = serde_json::to_string_pretty(&metadata).unwrap();
std::fs::write(&metadata_path, metadata_json).unwrap();
let result = load_from_cache(cache_dir).await;
assert!(result.is_err());
assert!(result.unwrap_err().to_string().contains("Cache expired"));
}
#[tokio::test]
async fn test_load_from_cache_valid() {
let temp_dir = TempDir::new().unwrap();
let cache_dir = temp_dir.path();
let metadata = UserAgentMetadata {
chrome_version: "131.0.0.0".to_string(),
last_updated: SystemTime::now() - Duration::from_secs(24 * 60 * 60), };
let metadata_path = cache_dir.join("version.json");
std::fs::create_dir_all(cache_dir).unwrap();
let metadata_json = serde_json::to_string_pretty(&metadata).unwrap();
std::fs::write(&metadata_path, metadata_json).unwrap();
let result = load_from_cache(cache_dir).await;
assert!(result.is_ok());
assert_eq!(result.unwrap(), "131.0.0.0");
}
#[tokio::test]
async fn test_save_to_cache() {
let temp_dir = TempDir::new().unwrap();
let cache_dir = temp_dir.path();
let version = "131.0.0.0";
let result = save_to_cache(cache_dir, version).await;
assert!(result.is_ok());
let metadata_path = cache_dir.join("version.json");
assert!(metadata_path.exists());
let loaded = load_from_cache(cache_dir).await;
assert!(loaded.is_ok());
assert_eq!(loaded.unwrap(), version);
}
#[tokio::test]
async fn test_save_to_cache_malformed_json() {
let temp_dir = TempDir::new().unwrap();
let cache_dir = temp_dir.path();
let metadata_path = cache_dir.join("version.json");
std::fs::create_dir_all(cache_dir).unwrap();
std::fs::write(&metadata_path, "{ invalid json }").unwrap();
let result = load_from_cache(cache_dir).await;
assert!(result.is_err());
}
#[tokio::test]
async fn test_get_default_user_agent() {
let temp_dir = TempDir::new().unwrap();
let cache_dir = temp_dir.path();
let ua = get_default_user_agent(Some(cache_dir)).await;
assert!(ua.contains("Chrome/"));
assert!(ua.contains("Mozilla/5.0"));
}
#[test]
fn test_try_fetch_chrome_version_latest_release_format() {
let version_text = "131.0.6778.85";
let major = version_text.split('.').next().unwrap_or(version_text);
let formatted = format!("{}.0.0.0", major);
assert_eq!(formatted, "131.0.0.0");
}
#[test]
fn test_try_fetch_chrome_version_json_format() {
let json = r#"{
"channels": {
"Stable": {
"version": "131.0.6778.85"
}
}
}"#;
#[derive(serde::Deserialize)]
struct ChromeVersions {
channels: Option<ChromeChannels>,
}
#[derive(serde::Deserialize)]
struct ChromeChannels {
#[serde(rename = "Stable")]
stable: Option<ChromeVersion>,
}
#[derive(serde::Deserialize)]
struct ChromeVersion {
version: String,
}
let versions: ChromeVersions = serde_json::from_str(json).unwrap();
if let Some(channels) = versions.channels {
if let Some(stable) = channels.stable {
let major = stable.version.split('.').next().unwrap_or(&stable.version);
let formatted = format!("{}.0.0.0", major);
assert_eq!(formatted, "131.0.0.0");
}
}
}
#[test]
fn test_try_fetch_chrome_version_json_missing_stable() {
let json = r#"{
"channels": {
"Beta": {
"version": "132.0.6778.85"
}
}
}"#;
#[derive(serde::Deserialize)]
struct ChromeVersions {
channels: Option<ChromeChannels>,
}
#[derive(serde::Deserialize)]
struct ChromeChannels {
#[serde(rename = "Stable")]
stable: Option<ChromeVersion>,
}
#[derive(serde::Deserialize)]
struct ChromeVersion {
#[allow(dead_code)]
version: String,
}
let versions: ChromeVersions = serde_json::from_str(json).unwrap();
if let Some(channels) = versions.channels {
assert!(channels.stable.is_none());
}
}
#[test]
fn test_try_fetch_chrome_version_json_missing_version_field() {
let json = r#"{
"channels": {
"Stable": {}
}
}"#;
#[derive(serde::Deserialize)]
struct ChromeVersions {
#[allow(dead_code)]
channels: Option<ChromeChannels>,
}
#[derive(serde::Deserialize)]
struct ChromeChannels {
#[serde(rename = "Stable")]
#[allow(dead_code)]
stable: Option<ChromeVersion>,
}
#[derive(serde::Deserialize)]
struct ChromeVersion {
#[allow(dead_code)]
version: String,
}
let result: Result<ChromeVersions, _> = serde_json::from_str(json);
assert!(result.is_err());
}
#[test]
fn test_try_fetch_chrome_version_json_empty_channels() {
let json = r#"{
"channels": {}
}"#;
#[derive(serde::Deserialize)]
struct ChromeVersions {
channels: Option<ChromeChannels>,
}
#[derive(serde::Deserialize)]
struct ChromeChannels {
#[serde(rename = "Stable")]
stable: Option<ChromeVersion>,
}
#[derive(serde::Deserialize)]
struct ChromeVersion {
#[allow(dead_code)]
version: String,
}
let versions: ChromeVersions = serde_json::from_str(json).unwrap();
if let Some(channels) = versions.channels {
assert!(channels.stable.is_none());
}
}
#[test]
fn test_try_fetch_chrome_version_latest_release_empty_string() {
let version_text = "";
let major = version_text.split('.').next().unwrap_or(version_text);
let formatted = format!("{}.0.0.0", major);
assert_eq!(formatted, ".0.0.0");
}
#[test]
fn test_try_fetch_chrome_version_latest_release_no_dots() {
let version_text = "131";
let major = version_text.split('.').next().unwrap_or(version_text);
let formatted = format!("{}.0.0.0", major);
assert_eq!(formatted, "131.0.0.0");
}
#[test]
fn test_load_from_cache_missing_chrome_version_field() {
let json = r#"{
"last_updated": "2024-01-01T00:00:00Z"
}"#;
let result: Result<UserAgentMetadata, _> = serde_json::from_str(json);
assert!(result.is_err());
}
#[tokio::test]
async fn test_load_from_cache_invalid_timestamp() {
let temp_dir = TempDir::new().unwrap();
let cache_dir = temp_dir.path();
let metadata = UserAgentMetadata {
chrome_version: "131.0.0.0".to_string(),
last_updated: SystemTime::now() + Duration::from_secs(24 * 60 * 60), };
let metadata_path = cache_dir.join("version.json");
std::fs::create_dir_all(cache_dir).unwrap();
let metadata_json = serde_json::to_string_pretty(&metadata).unwrap();
std::fs::write(&metadata_path, metadata_json).unwrap();
let result = load_from_cache(cache_dir).await;
assert!(result.is_ok());
}
#[tokio::test]
async fn test_save_to_cache_directory_creation() {
let temp_dir = TempDir::new().unwrap();
let cache_dir = temp_dir.path().join("nested").join("cache");
assert!(!cache_dir.exists());
let version = "131.0.0.0";
let result = save_to_cache(&cache_dir, version).await;
assert!(result.is_ok());
assert!(cache_dir.exists());
assert!(cache_dir.join("version.json").exists());
}
#[tokio::test]
async fn test_get_chrome_version_cache_fresh() {
let temp_dir = TempDir::new().unwrap();
let cache_dir = temp_dir.path();
let metadata = UserAgentMetadata {
chrome_version: "131.0.0.0".to_string(),
last_updated: SystemTime::now() - Duration::from_secs(24 * 60 * 60), };
let metadata_path = cache_dir.join("version.json");
std::fs::create_dir_all(cache_dir).unwrap();
let metadata_json = serde_json::to_string_pretty(&metadata).unwrap();
std::fs::write(&metadata_path, metadata_json).unwrap();
let version = get_chrome_version(Some(cache_dir)).await;
assert_eq!(version, "131.0.0.0");
}
#[tokio::test]
async fn test_get_chrome_version_cache_expired() {
let temp_dir = TempDir::new().unwrap();
let cache_dir = temp_dir.path();
let metadata = UserAgentMetadata {
chrome_version: "100.0.0.0".to_string(), last_updated: SystemTime::now() - Duration::from_secs(31 * 24 * 60 * 60), };
let metadata_path = cache_dir.join("version.json");
std::fs::create_dir_all(cache_dir).unwrap();
let metadata_json = serde_json::to_string_pretty(&metadata).unwrap();
std::fs::write(&metadata_path, metadata_json).unwrap();
let version = get_chrome_version(Some(cache_dir)).await;
assert_ne!(version, "100.0.0.0");
assert!(!version.is_empty());
}
#[tokio::test]
async fn test_try_fetch_chrome_version_http_error() {
use httptest::{matchers::*, responders::*, Expectation, Server};
let server = Server::run();
server.expect(
Expectation::matching(request::method_path("GET", "/error"))
.respond_with(status_code(500).body("Internal Server Error")),
);
let url = server.url("/error").to_string();
let result = try_fetch_chrome_version(&url).await;
assert!(result.is_err());
assert!(result.unwrap_err().to_string().contains("HTTP 500"));
}
#[tokio::test]
async fn test_try_fetch_chrome_version_invalid_json() {
use httptest::{matchers::*, responders::*, Expectation, Server};
let server = Server::run();
let url_path = "/chrome-for-testing/invalid";
server.expect(
Expectation::matching(request::method_path("GET", url_path)).respond_with(
status_code(200)
.insert_header("Content-Type", "application/json")
.body("{ invalid json }"),
),
);
let url = server.url(url_path).to_string();
let result = try_fetch_chrome_version(&url).await;
assert!(result.is_err());
let error_msg = result.unwrap_err().to_string();
assert!(
error_msg.contains("JSON")
|| error_msg.contains("parse")
|| error_msg.contains("invalid")
|| error_msg.contains("deserialize")
|| error_msg.contains("expected")
|| error_msg.contains("key")
|| error_msg.contains("string")
|| error_msg.contains("line")
|| error_msg.contains("column"),
"Error message should indicate parsing failure: {}",
error_msg
);
}
#[tokio::test]
async fn test_try_fetch_chrome_version_empty_response() {
use httptest::{matchers::*, responders::*, Expectation, Server};
let server = Server::run();
let url_path = "/LATEST_RELEASE/empty";
server.expect(
Expectation::matching(request::method_path("GET", url_path))
.respond_with(status_code(200).body("")),
);
let url = server.url(url_path).to_string();
let result = try_fetch_chrome_version(&url).await;
assert_eq!(
result.expect("empty LATEST_RELEASE body should parse"),
".0.0.0"
);
}
}