chrome-for-testing 0.2.1

Interact with the chrome-for-testing JSON API.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

use chrome_for_testing::api::channel::Channel;
use chrome_for_testing::api::known_good_versions::KnownGoodVersions;
use chrome_for_testing::api::last_known_good_versions::LastKnownGoodVersions;
use chrome_for_testing::api::platform::Platform;
use chrome_for_testing::error::Error;

#[tokio::test]
async fn test_last_known_good_versions() -> Result<(), Error> {
    let client = reqwest::Client::new();
    let versions = LastKnownGoodVersions::fetch(client).await?;

    // Get the stable channel version.
    if let Some(stable) = versions.channels.get(&Channel::Stable) {
        println!("Latest stable version: {}", stable.version);

        // Print download URLs for all platforms.
        for download in &stable.downloads.chrome {
            println!(
                "Available for platform '{}' at: {}",
                download.platform, download.url
            );
        }
    }

    Ok(())
}

#[tokio::test]
async fn test_known_good_versions() -> Result<(), Error> {
    let client = reqwest::Client::new();
    let versions = KnownGoodVersions::fetch(client).await?;

    println!("Found {} Chrome versions", versions.versions.len());

    // Find a specific version.
    let target_version = "131.0.6778.204";
    if let Some(version) = versions
        .versions
        .iter()
        .find(|v| v.version.to_string() == target_version)
    {
        println!(
            "Found version {}: revision {}",
            version.version, version.revision
        );

        let current_platform = Platform::detect().expect("Running on supported platform.");

        println!(
            "Chrome downloads available for {} platforms",
            version.downloads.chrome.len()
        );
        if let Some(download) = version
            .downloads
            .chrome
            .iter()
            .filter(|it| it.platform == current_platform)
            .next()
        {
            println!(
                "Found Chrome download URL for current platform '{current_platform}': {}",
                download.url
            );
        }

        // ChromeDriver downloads may not be available for older versions.
        if let Some(chromedriver_downloads) = &version.downloads.chromedriver {
            println!(
                "ChromeDriver available for {} platforms",
                chromedriver_downloads.len()
            );
            if let Some(download) = chromedriver_downloads
                .iter()
                .filter(|it| it.platform == current_platform)
                .next()
            {
                println!(
                    "Found ChromeDriver download for current platform '{current_platform}': {}",
                    download.url
                );
            }
        } else {
            println!("No ChromeDriver downloads available for this version");
        }
    }

    Ok(())
}