~ knotless Search/
↑↓ move↵ open⇧↵ all results

johnandersen777.bsky.social/vuln-notif

0
0
main
759 lines · 24.0 KB Raw History
//! Composer, CPAN, Apache, Gitee, and GNU source adapters.
//!
//! The adapter modules are included with `#[path]` because `sources/mod.rs` is
//! owned by the integration wave. Every request goes through the scripted
//! [`FakeHttp`] seam; no live network is used.

#![allow(dead_code)]

use std::collections::{HashMap, VecDeque};
use std::sync::{Arc, Mutex};

use async_trait::async_trait;
use serde_json::Value;

use vuln_notif::release::http::RegistryHttp;
use vuln_notif::release::source::{ProjectRef, ReleaseSource, SourceCapabilities, VersionInfo};

mod release {
    pub mod http {
        pub use vuln_notif::release::http::*;
    }
    pub mod source {
        pub use vuln_notif::release::source::*;
    }
    pub mod versioning {
        pub use vuln_notif::release::versioning::*;
    }
}

#[path = "../src/release/sources/apache.rs"]
mod apache;
#[path = "../src/release/sources/composer.rs"]
mod composer;
#[path = "../src/release/sources/cpan.rs"]
mod cpan;
#[path = "../src/release/sources/gitee.rs"]
mod gitee;
#[path = "../src/release/sources/gnu.rs"]
mod gnu;

use apache::ApacheSource;
use composer::ComposerSource;
use cpan::CpanSource;
use gitee::GiteeSource;
use gnu::GnuSource;

const PACKAGIST: &str = include_str!("fixtures/sources/misc/packagist.json");
const METACPAN: &str = include_str!("fixtures/sources/misc/metacpan.json");
const APACHE_INDEX: &str = include_str!("fixtures/sources/misc/apache-index.html");
const GITEE_RELEASES: &str = include_str!("fixtures/sources/misc/gitee-releases.json");
const GNU_INDEX: &str = include_str!("fixtures/sources/misc/gnu-index.html");

const EMPTY_INDEX: &str = r#"<html><body><pre><a href="../">../</a></pre></body></html>"#;

// ---------------------------------------------------------------------------
// Scripted RegistryHttp fake
// ---------------------------------------------------------------------------

#[derive(Clone, Debug)]
enum Reply {
    Json(Value),
    Text(String),
    Size(u64),
    Bytes(Vec<u8>),
}

#[derive(Clone, Debug)]
struct Call {
    method: &'static str,
    url: String,
}

#[derive(Default)]
struct FakeHttp {
    replies: Mutex<HashMap<String, VecDeque<Reply>>>,
    calls: Mutex<Vec<Call>>,
    headers: Mutex<Vec<Vec<(String, String)>>>,
}

impl FakeHttp {
    fn enqueue(&self, url: &str, reply: Reply) {
        self.replies
            .lock()
            .unwrap()
            .entry(url.to_owned())
            .or_default()
            .push_back(reply);
    }

    fn json(&self, url: &str, value: Value) {
        self.enqueue(url, Reply::Json(value));
    }

    fn text(&self, url: &str, value: &str) {
        self.enqueue(url, Reply::Text(value.to_owned()));
    }

    fn calls(&self) -> Vec<Call> {
        self.calls.lock().unwrap().clone()
    }

    fn urls(&self) -> Vec<String> {
        self.calls().into_iter().map(|call| call.url).collect()
    }

    fn header_calls(&self) -> Vec<Vec<(String, String)>> {
        self.headers.lock().unwrap().clone()
    }

    fn take(&self, method: &'static str, url: &str) -> anyhow::Result<Reply> {
        self.calls.lock().unwrap().push(Call {
            method,
            url: url.to_owned(),
        });
        self.replies
            .lock()
            .unwrap()
            .get_mut(url)
            .and_then(VecDeque::pop_front)
            .ok_or_else(|| anyhow::anyhow!("unexpected {method} {url}"))
    }
}

#[async_trait]
impl RegistryHttp for FakeHttp {
    async fn get_json(&self, url: &str) -> anyhow::Result<Value> {
        match self.take("GET", url)? {
            Reply::Json(value) => Ok(value),
            other => Err(anyhow::anyhow!("expected JSON for {url}, got {other:?}")),
        }
    }

    async fn get_json_with_headers(
        &self,
        url: &str,
        headers: &[(String, String)],
    ) -> anyhow::Result<Value> {
        self.headers.lock().unwrap().push(headers.to_vec());
        self.get_json(url).await
    }

    async fn get_text(&self, url: &str) -> anyhow::Result<String> {
        match self.take("GET", url)? {
            Reply::Text(value) => Ok(value),
            other => Err(anyhow::anyhow!("expected text for {url}, got {other:?}")),
        }
    }

    async fn head_size(&self, url: &str) -> anyhow::Result<u64> {
        match self.take("HEAD", url)? {
            Reply::Size(value) => Ok(value),
            other => Err(anyhow::anyhow!("expected size for {url}, got {other:?}")),
        }
    }

    async fn download(&self, url: &str) -> anyhow::Result<Vec<u8>> {
        match self.take("GET", url)? {
            Reply::Bytes(value) => Ok(value),
            other => Err(anyhow::anyhow!("expected bytes for {url}, got {other:?}")),
        }
    }

    async fn post_json(&self, url: &str, _body: &Value) -> anyhow::Result<Value> {
        Err(anyhow::anyhow!("unexpected POST {url}"))
    }
}

fn dyn_http(fake: &Arc<FakeHttp>) -> Arc<dyn RegistryHttp> {
    fake.clone()
}

fn empty_http() -> Arc<dyn RegistryHttp> {
    Arc::new(FakeHttp::default())
}

fn fixture(raw: &str) -> Value {
    serde_json::from_str(raw).expect("fixture JSON")
}

fn project(purl_type: &str, name: &str) -> ProjectRef {
    ProjectRef {
        purl_type: purl_type.to_owned(),
        name: name.to_owned(),
        purl: format!("pkg:{purl_type}/{name}"),
    }
}

fn version(raw: &str, normalized: &str) -> VersionInfo {
    VersionInfo {
        raw: raw.to_owned(),
        version: normalized.to_owned(),
        deprecated: false,
        reason: String::new(),
    }
}

fn versions_of(versions: &[VersionInfo]) -> Vec<&str> {
    versions
        .iter()
        .map(|version| version.version.as_str())
        .collect()
}

fn reason(error: anyhow::Error) -> String {
    format!("{error:#}")
}

// ---------------------------------------------------------------------------
// Capability flags
// ---------------------------------------------------------------------------

#[test]
fn capabilities_match_each_source() {
    assert_eq!(
        ComposerSource::new(empty_http()).capabilities(),
        SourceCapabilities {
            versions: true,
            artifacts: true,
            statuses: true,
            project_meta: true,
        }
    );
    assert_eq!(
        CpanSource::new(empty_http()).capabilities(),
        SourceCapabilities {
            versions: true,
            artifacts: true,
            statuses: false,
            project_meta: true,
        }
    );
    assert_eq!(
        ApacheSource::new(empty_http()).capabilities(),
        SourceCapabilities {
            versions: true,
            artifacts: true,
            statuses: false,
            project_meta: true,
        }
    );
    assert_eq!(
        GiteeSource::new(empty_http()).capabilities(),
        SourceCapabilities {
            versions: true,
            artifacts: true,
            statuses: true,
            project_meta: true,
        }
    );
    assert_eq!(
        GnuSource::new(empty_http()).capabilities(),
        SourceCapabilities {
            versions: true,
            artifacts: true,
            statuses: false,
            project_meta: true,
        }
    );
}

// ---------------------------------------------------------------------------
// Composer / Packagist
// ---------------------------------------------------------------------------

#[tokio::test]
async fn composer_versions_artifacts_and_abandoned_status() {
    let fake = Arc::new(FakeHttp::default());
    let payload = fixture(PACKAGIST);
    let url = "https://packagist.test/p2/acme/widget.json";
    for _ in 0..4 {
        fake.json(url, payload.clone());
    }
    let source = ComposerSource::with_base_url(dyn_http(&fake), "https://packagist.test");
    let project = project("composer", "acme/widget");

    let versions = source.versions(&project).await.expect("composer versions");
    assert_eq!(versions_of(&versions), ["1.2.0", "1.3.0"]);
    assert!(versions.iter().all(|version| version.deprecated));
    assert_eq!(versions[0].raw, "1.2.0");
    assert_eq!(versions[0].reason, "abandoned in favor of acme/new-widget");
    assert!(
        versions.iter().all(|version| version.version != "dev-main"),
        "dev branches are not release versions"
    );

    let latest = source
        .artifacts(&project, &versions[1])
        .await
        .expect("composer artifacts");
    assert_eq!(latest.len(), 1);
    assert_eq!(latest[0].file_name, "widget-1.3.0.zip");
    assert_eq!(
        latest[0].url,
        "https://api.github.com/repos/acme/widget/zipball/def456"
    );
    assert_eq!(latest[0].sha256.as_deref(), Some("a".repeat(64).as_str()));
    assert_eq!(latest[0].size, None);
    assert_eq!(latest[0].mime_type.as_deref(), Some("application/zip"));

    let old = source
        .artifacts(&project, &versions[0])
        .await
        .expect("composer old artifacts");
    assert_eq!(old[0].sha256, None, "a SHA-1 shasum is not a SHA-256");

    let statuses = source
        .statuses(&project, &versions[1])
        .await
        .expect("composer statuses");
    assert_eq!(statuses.len(), 1);
    assert_eq!(statuses[0].status, "deprecated");
    assert_eq!(statuses[0].kind, None);
    assert_eq!(statuses[0].reason, "abandoned in favor of acme/new-widget");
}

#[tokio::test]
async fn composer_project_meta_reports_registry_fields() {
    let fake = Arc::new(FakeHttp::default());
    fake.json(
        "https://packagist.test/p2/acme/widget.json",
        fixture(PACKAGIST),
    );
    let source = ComposerSource::with_base_url(dyn_http(&fake), "https://packagist.test");
    let meta = source
        .project_meta(&project("composer", "acme/widget"))
        .await
        .expect("composer metadata");
    assert_eq!(meta["name"], "acme/widget");
    assert_eq!(meta["homepage"], "https://widget.example");
    assert_eq!(meta["license"][1], "Apache-2.0");
    assert_eq!(meta["repository"], "https://github.com/acme/widget.git");
    assert_eq!(meta["abandoned"], "abandoned in favor of acme/new-widget");
}

// ---------------------------------------------------------------------------
// CPAN / MetaCPAN
// ---------------------------------------------------------------------------

#[tokio::test]
async fn cpan_versions_checksum_and_project_meta() {
    let fake = Arc::new(FakeHttp::default());
    let payload = fixture(METACPAN);
    let search = payload["search"].clone();
    let release = payload["release"].clone();
    let search_url = "https://metacpan.test/v1/release/_search?q=distribution:Acme-Widget&size=100";
    for _ in 0..3 {
        fake.json(search_url, search.clone());
    }
    fake.json("https://metacpan.test/v1/release/Acme-Widget", release);
    let source = CpanSource::with_base_url(dyn_http(&fake), "https://metacpan.test");
    let project = project("cpan", "Acme-Widget");

    let versions = source.versions(&project).await.expect("cpan versions");
    assert_eq!(versions_of(&versions), ["1.01", "1.02"]);

    let latest = source
        .artifacts(&project, &versions[1])
        .await
        .expect("cpan artifacts");
    assert_eq!(latest.len(), 1);
    assert_eq!(latest[0].file_name, "Acme-Widget-1.02.tar.gz");
    assert_eq!(
        latest[0].url,
        "https://cpan.metacpan.org/authors/id/A/AC/Acme-Widget-1.02.tar.gz"
    );
    assert_eq!(latest[0].sha256.as_deref(), Some("b".repeat(64).as_str()));
    assert_eq!(latest[0].size, Some(45123));
    assert_eq!(latest[0].mime_type.as_deref(), Some("application/gzip"));

    let old = source
        .artifacts(&project, &versions[0])
        .await
        .expect("cpan old artifacts");
    assert_eq!(old[0].sha256.as_deref(), Some("c".repeat(64).as_str()));

    let meta = source.project_meta(&project).await.expect("cpan metadata");
    assert_eq!(meta["author"], "ACME");
    assert_eq!(meta["license"][0], "perl_5");
    assert_eq!(meta["status"], "latest");
    assert_eq!(meta["distribution"], "Acme-Widget");
}

// ---------------------------------------------------------------------------
// Apache directory indexes
// ---------------------------------------------------------------------------

fn apache_source(fake: &Arc<FakeHttp>) -> ApacheSource {
    ApacheSource::with_bases(
        dyn_http(fake),
        "https://downloads.apache.test",
        "https://archive.apache.test/dist",
    )
}

#[tokio::test]
async fn apache_versions_union_downloads_and_archive() {
    let fake = Arc::new(FakeHttp::default());
    fake.text("https://downloads.apache.test/widget/", APACHE_INDEX);
    fake.text("https://archive.apache.test/dist/widget/", APACHE_INDEX);
    let source = apache_source(&fake);

    let versions = source
        .versions(&project("apache", "widget"))
        .await
        .expect("apache versions");
    assert_eq!(versions_of(&versions), ["1.0.0", "1.1.0"]);
    assert_eq!(versions[1].raw, "1.1.0");
    assert_eq!(
        fake.urls(),
        [
            "https://downloads.apache.test/widget/",
            "https://archive.apache.test/dist/widget/",
        ]
    );
}

#[tokio::test]
async fn apache_artifacts_parse_version_directory_and_sizes() {
    let fake = Arc::new(FakeHttp::default());
    let top = "https://downloads.apache.test/widget/";
    let dir = "https://downloads.apache.test/widget/1.1.0/";
    fake.text(top, APACHE_INDEX);
    fake.text(dir, APACHE_INDEX);
    let source = apache_source(&fake);

    let artifacts = source
        .artifacts(&project("apache", "widget"), &version("1.1.0", "1.1.0"))
        .await
        .expect("apache artifacts");
    assert_eq!(artifacts.len(), 2);
    assert_eq!(artifacts[0].file_name, "apache-widget-1.1.0-bin.tar.gz");
    assert_eq!(
        artifacts[0].url,
        "https://downloads.apache.test/widget/1.1.0/apache-widget-1.1.0-bin.tar.gz"
    );
    assert_eq!(artifacts[0].size, Some(1536 * 1024));
    assert_eq!(artifacts[0].mime_type.as_deref(), Some("application/gzip"));
    assert_eq!(artifacts[1].file_name, "apache-widget-1.1.0-src.zip");
    assert_eq!(artifacts[1].size, Some(2 * 1024 * 1024));
    assert_eq!(artifacts[1].mime_type.as_deref(), Some("application/zip"));
    assert!(artifacts.iter().all(|artifact| artifact.sha256.is_none()));
    assert!(
        fake.urls().iter().all(|url| !url.ends_with(".sha256")),
        "sidecars stay unfetched unless the policy allows them"
    );
}

#[tokio::test]
async fn apache_sidecar_sha256_only_when_policy_allows() {
    let fake = Arc::new(FakeHttp::default());
    let top = "https://downloads.apache.test/widget/";
    let dir = "https://downloads.apache.test/widget/1.1.0/";
    fake.text(top, APACHE_INDEX);
    fake.text(dir, APACHE_INDEX);
    fake.text(
        "https://downloads.apache.test/widget/1.1.0/apache-widget-1.1.0-bin.tar.gz.sha256",
        &format!("{}  apache-widget-1.1.0-bin.tar.gz\n", "d".repeat(64)),
    );
    let source = apache_source(&fake).allow_sidecar_digests(true);

    let artifacts = source
        .artifacts(&project("apache", "widget"), &version("1.1.0", "1.1.0"))
        .await
        .expect("apache artifacts");
    assert_eq!(
        artifacts[0].sha256.as_deref(),
        Some("d".repeat(64).as_str())
    );
    assert_eq!(
        artifacts[1].sha256, None,
        "the zip has no sidecar; sha512 is never relabeled"
    );
    assert!(
        fake.urls().iter().all(|url| !url.ends_with(".sha512")),
        "a sha512 sidecar cannot fill the sha256 field"
    );
}

#[tokio::test]
async fn apache_artifacts_fall_back_to_archive() {
    let fake = Arc::new(FakeHttp::default());
    fake.text("https://downloads.apache.test/widget/", EMPTY_INDEX);
    fake.text("https://downloads.apache.test/widget/", EMPTY_INDEX);
    fake.text("https://archive.apache.test/dist/widget/", APACHE_INDEX);
    fake.text("https://archive.apache.test/dist/widget/", APACHE_INDEX);
    fake.text(
        "https://archive.apache.test/dist/widget/1.1.0/",
        APACHE_INDEX,
    );
    let source = apache_source(&fake);
    let project = project("apache", "widget");

    let versions = source.versions(&project).await.expect("archive versions");
    assert_eq!(versions_of(&versions), ["1.0.0", "1.1.0"]);

    let artifacts = source
        .artifacts(&project, &version("1.1.0", "1.1.0"))
        .await
        .expect("archive artifacts");
    assert_eq!(artifacts.len(), 2);
    assert_eq!(
        artifacts[0].url,
        "https://archive.apache.test/dist/widget/1.1.0/apache-widget-1.1.0-bin.tar.gz"
    );
}

// ---------------------------------------------------------------------------
// Gitee
// ---------------------------------------------------------------------------

const GITEE_URL: &str = "https://gitee.test/api/v5/repos/acme/widget/releases?page=1&per_page=100";

#[tokio::test]
async fn gitee_versions_assets_prerelease_and_token() {
    let fake = Arc::new(FakeHttp::default());
    let releases = fixture(GITEE_RELEASES);
    for _ in 0..4 {
        fake.json(GITEE_URL, releases.clone());
    }
    let source = GiteeSource::with_base_url(dyn_http(&fake), "https://gitee.test")
        .with_token("secret-token");
    let project = project("gitee", "acme/widget");

    let versions = source.versions(&project).await.expect("gitee versions");
    assert_eq!(versions_of(&versions), ["1.2.0", "1.3.0-rc1"]);
    assert_eq!(versions[0].raw, "v1.2.0");

    let artifacts = source
        .artifacts(&project, &versions[0])
        .await
        .expect("gitee assets");
    assert_eq!(artifacts.len(), 2);
    assert_eq!(artifacts[0].file_name, "widget-1.2.0.tar.gz");
    assert_eq!(
        artifacts[0].url,
        "https://gitee.com/acme/widget/releases/download/v1.2.0/widget-1.2.0.tar.gz"
    );
    assert_eq!(artifacts[0].size, Some(12345));
    assert_eq!(artifacts[0].sha256, None);
    assert_eq!(artifacts[1].file_name, "widget-1.2.0.zip");

    assert!(
        source
            .statuses(&project, &versions[0])
            .await
            .expect("stable statuses")
            .is_empty()
    );
    let statuses = source
        .statuses(&project, &versions[1])
        .await
        .expect("prerelease statuses");
    assert_eq!(statuses.len(), 1);
    assert_eq!(statuses[0].status, "prerelease");
    assert_eq!(statuses[0].reason, "prerelease release");

    assert!(
        fake.urls().iter().all(|url| url == GITEE_URL),
        "the token must not appear in any Gitee URL"
    );
    let headers = fake.header_calls();
    assert!(!headers.is_empty(), "every Gitee request carries a header");
    assert!(
        headers
            .iter()
            .all(|headers| headers
                == &[("Authorization".to_owned(), "Bearer secret-token".to_owned())]),
        "every Gitee request carries the bearer token"
    );
}

#[tokio::test]
async fn gitee_without_token_omits_access_token() {
    let fake = Arc::new(FakeHttp::default());
    let url = "https://gitee.test/api/v5/repos/acme/widget/releases?page=1&per_page=100";
    fake.json(url, fixture(GITEE_RELEASES));
    let source = GiteeSource::with_base_url(dyn_http(&fake), "https://gitee.test");
    source
        .versions(&project("gitee", "acme/widget"))
        .await
        .expect("gitee versions without token");
    assert_eq!(fake.urls(), [url]);
}

// ---------------------------------------------------------------------------
// GNU FTP
// ---------------------------------------------------------------------------

#[tokio::test]
async fn gnu_versions_and_tarballs_ignore_signatures() {
    let fake = Arc::new(FakeHttp::default());
    let index = "https://ftp.gnu.test/gnu/hello/";
    fake.text(index, GNU_INDEX);
    fake.text(index, GNU_INDEX);
    let source = GnuSource::with_base_url(dyn_http(&fake), "https://ftp.gnu.test/gnu");
    let project = project("gnu", "hello");

    let versions = source.versions(&project).await.expect("gnu versions");
    assert_eq!(versions_of(&versions), ["2.9", "2.10", "2.12.1"]);

    let artifacts = source
        .artifacts(&project, &versions[2])
        .await
        .expect("gnu artifacts");
    assert_eq!(artifacts.len(), 2);
    assert_eq!(artifacts[0].file_name, "hello-2.12.1.tar.gz");
    assert_eq!(artifacts[0].size, Some(1024 * 1024));
    assert_eq!(artifacts[0].mime_type.as_deref(), Some("application/gzip"));
    assert_eq!(artifacts[0].sha256, None);
    assert_eq!(artifacts[1].file_name, "hello-2.12.1.tar.xz");
    assert_eq!(artifacts[1].size, Some(700 * 1024));
    assert_eq!(artifacts[1].mime_type.as_deref(), Some("application/x-xz"));
    assert!(
        artifacts
            .iter()
            .all(|artifact| !artifact.file_name.ends_with(".sig")),
        "signature files are not artifacts"
    );
}

// ---------------------------------------------------------------------------
// Unsupported and missing data paths
// ---------------------------------------------------------------------------

#[tokio::test]
async fn sources_report_typed_unsupported_reasons() {
    let apache = ApacheSource::with_bases(
        empty_http(),
        "https://downloads.apache.test",
        "https://archive.apache.test/dist",
    );
    assert!(
        reason(
            apache
                .versions(&project("pypi", "widget"))
                .await
                .unwrap_err()
        )
        .contains("UnknownPurlType")
    );
    assert!(
        reason(
            apache
                .statuses(&project("apache", "widget"), &version("1.1.0", "1.1.0"))
                .await
                .unwrap_err()
        )
        .contains("NoStatuses")
    );

    let cpan = CpanSource::new(empty_http());
    assert!(
        reason(
            cpan.statuses(&project("cpan", "Acme-Widget"), &version("1.02", "1.02"))
                .await
                .unwrap_err()
        )
        .contains("NoStatuses")
    );

    let gnu = GnuSource::new(empty_http());
    assert!(
        reason(gnu.versions(&project("pypi", "hello")).await.unwrap_err())
            .contains("UnknownPurlType")
    );
    assert!(
        reason(
            gnu.statuses(&project("gnu", "hello"), &version("2.12.1", "2.12.1"))
                .await
                .unwrap_err()
        )
        .contains("NoStatuses")
    );

    let composer = ComposerSource::new(empty_http());
    assert!(
        reason(
            composer
                .versions(&project("composer", "widget"))
                .await
                .unwrap_err()
        )
        .contains("vendor/package")
    );
    assert!(
        reason(
            composer
                .versions(&project("pypi", "acme/widget"))
                .await
                .unwrap_err()
        )
        .contains("UnknownPurlType")
    );

    let gitee = GiteeSource::new(empty_http());
    assert!(
        reason(
            gitee
                .versions(&project("gitee", "widget"))
                .await
                .unwrap_err()
        )
        .contains("owner/repo")
    );
}

#[tokio::test]
async fn empty_listings_report_no_versions_and_no_artifacts() {
    let fake = Arc::new(FakeHttp::default());
    for _ in 0..2 {
        fake.text("https://downloads.apache.test/widget/", EMPTY_INDEX);
        fake.text("https://archive.apache.test/dist/widget/", EMPTY_INDEX);
    }
    let source = ApacheSource::with_bases(
        dyn_http(&fake),
        "https://downloads.apache.test",
        "https://archive.apache.test/dist",
    );
    assert!(
        reason(
            source
                .versions(&project("apache", "widget"))
                .await
                .unwrap_err()
        )
        .contains("NoVersions")
    );
    assert!(
        reason(
            source
                .artifacts(&project("apache", "widget"), &version("9.9.9", "9.9.9"))
                .await
                .unwrap_err()
        )
        .contains("NoArtifacts")
    );
    let fake = Arc::new(FakeHttp::default());
    fake.text("https://ftp.gnu.test/gnu/hello/", EMPTY_INDEX);
    let gnu = GnuSource::with_base_url(dyn_http(&fake), "https://ftp.gnu.test/gnu");
    assert!(
        reason(gnu.versions(&project("gnu", "hello")).await.unwrap_err()).contains("NoVersions")
    );

    let fake = Arc::new(FakeHttp::default());
    fake.json(
        "https://gitee.test/api/v5/repos/acme/widget/releases?page=1&per_page=100",
        Value::Array(Vec::new()),
    );
    let gitee = GiteeSource::with_base_url(dyn_http(&fake), "https://gitee.test");
    assert!(
        reason(
            gitee
                .versions(&project("gitee", "acme/widget"))
                .await
                .unwrap_err()
        )
        .contains("NoVersions")
    );
}