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

johnandersen777.bsky.social/vuln-notif

0
0
main
855 lines · 26.3 KB Raw History
//! Extras-mode end-to-end: every adapter family publishes one release, filters
//! are honored, unsupported purl types are typed skips, dry runs write nothing,
//! `all` runs the modes in order, Gitee uses a bearer header, and re-runs are
//! idempotent.
//!
//! Every network seam is local: `RegistryHttp`, `GitHttp`, `ManifestHttp`, and
//! `DockerHttp` fakes serve checked-in fixtures.

mod common;

use std::collections::BTreeMap;
use std::sync::{Arc, Mutex};

use async_trait::async_trait;
use serde_json::{Value, json};
use tokio::sync::mpsc;

use common::FakePds;
use vuln_notif::constants::{
    CHANNEL_COLLECTION, MANIFEST_COLLECTION, PROJECT_COLLECTION, STATUS_COLLECTION,
    VERSION_COLLECTION,
};
use vuln_notif::db::DbHandle;
use vuln_notif::db::model::SoftwareMark;
use vuln_notif::pds::Publisher;
use vuln_notif::release::artifacts::ArtifactResolver;
use vuln_notif::release::http::RegistryHttp;
use vuln_notif::release::metadata::PROJECT_META_COLLECTION;
use vuln_notif::release::source::SourceTransports;
use vuln_notif::release::sources::distro::{ManifestHttp, ManifestResponse};
use vuln_notif::release::sources::docker::{DockerHttp, DockerResponse};
use vuln_notif::release::sources::github::{GitHttp, GitResponse};
use vuln_notif::release::{
    AffectedConfig, ExtrasConfig, ExtrasCounters, ReleaseConfig, ReleaseCursor, sync_all_with_http,
    sync_extras_with_cursor_resolver,
};
use vuln_notif::runtime::events::ProgressEvent;

const REPO: &str = common::REPO;
const ARTIFACT: &[u8] = b"extras-artifact-bytes";
const DIGEST: &str = "611c8fe2f5bcb9805410df9018ba22d84c75b323fcae33051677f6e2457cc2e7";

const PYPI_FIXTURE: &str = include_str!("fixtures/release_extras/pypi.json");
const GITHUB_RELEASE: &str = include_str!("fixtures/release_extras/github_release.json");
const GITHUB_PRERELEASE: &str = include_str!("fixtures/release_extras/github_prerelease.json");
const GITHUB_REPO: &str = include_str!("fixtures/release_extras/github_repo.json");
const RHEL_LIFECYCLE: &str = include_str!("fixtures/release_extras/rhel_lifecycle.json");
const DOCKER_TAGS: &str = include_str!("fixtures/release_extras/docker_tags.json");
const DOCKER_MANIFEST: &str = include_str!("fixtures/release_extras/docker_manifest.json");
const COMPOSER: &str = include_str!("fixtures/release_extras/composer.json");
const GITEE_RELEASES: &str = include_str!("fixtures/release_extras/gitee_releases.json");
const ENDOFLIFE_PRODUCTS: &str = include_str!("fixtures/release_extras/endoflife_products.json");
const ENDOFLIFE_RELEASES: &str = include_str!("fixtures/release_extras/endoflife_releases.json");

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

// ---------------------------------------------------------------------------
// Fakes
// ---------------------------------------------------------------------------

type HeaderCall = (String, Vec<(String, String)>);

#[derive(Default)]
struct ExtrasHttp {
    urls: Mutex<Vec<String>>,
    header_calls: Mutex<Vec<HeaderCall>>,
}

impl ExtrasHttp {
    fn urls(&self) -> Vec<String> {
        self.urls.lock().unwrap().clone()
    }

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

    fn route(&self, url: &str) -> anyhow::Result<Value> {
        self.urls.lock().unwrap().push(url.to_owned());
        if url.contains("pypi.org") {
            return Ok(fixture(PYPI_FIXTURE));
        }
        if url.contains("api.deps.dev") {
            return Ok(json!({
                "versions": [{"versionKey": {"version": "1.0.0"}}]
            }));
        }
        if url.contains("access.redhat.com") {
            return Ok(fixture(RHEL_LIFECYCLE));
        }
        if url.contains("/products/") {
            return Ok(fixture(ENDOFLIFE_RELEASES));
        }
        if url.ends_with("/products") {
            return Ok(fixture(ENDOFLIFE_PRODUCTS));
        }
        if url.contains("packagist.example") {
            return Ok(fixture(COMPOSER));
        }
        if url.contains("gitee.com") {
            return Ok(fixture(GITEE_RELEASES));
        }
        anyhow::bail!("unexpected JSON request {url}")
    }
}

#[async_trait]
impl RegistryHttp for ExtrasHttp {
    async fn get_json(&self, url: &str) -> anyhow::Result<Value> {
        self.route(url)
    }

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

    async fn get_text(&self, url: &str) -> anyhow::Result<String> {
        anyhow::bail!("unexpected text request {url}")
    }

    async fn head_size(&self, _url: &str) -> anyhow::Result<u64> {
        Ok(ARTIFACT.len() as u64)
    }

    async fn download(&self, _url: &str) -> anyhow::Result<Vec<u8>> {
        Ok(ARTIFACT.to_vec())
    }
}

#[derive(Default)]
struct FakeGit {
    calls: Mutex<Vec<String>>,
}

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

#[async_trait]
impl GitHttp for FakeGit {
    async fn get_json(
        &self,
        url: &str,
        _headers: &[(String, String)],
    ) -> anyhow::Result<GitResponse> {
        self.calls.lock().unwrap().push(url.to_owned());
        let body = if url.contains("/releases/tags/") {
            if url.contains("1.3.0") {
                fixture(GITHUB_PRERELEASE)
            } else {
                fixture(GITHUB_RELEASE)
            }
        } else if url.contains("/releases?") {
            let prerelease = fixture(GITHUB_PRERELEASE);
            let release = fixture(GITHUB_RELEASE);
            json!([prerelease, release])
        } else if url.contains("/tags?") {
            json!([{"name": "v1.2.0"}, {"name": "v1.3.0-rc.1"}])
        } else if url.contains("/repos/") {
            fixture(GITHUB_REPO)
        } else {
            anyhow::bail!("unexpected git request {url}")
        };
        Ok(GitResponse {
            status: 200,
            headers: BTreeMap::new(),
            body,
        })
    }
}

#[derive(Default)]
struct FakeManifest;

#[async_trait]
impl ManifestHttp for FakeManifest {
    async fn fetch_manifest(&self, _url: &str, _accept: &str) -> anyhow::Result<ManifestResponse> {
        Ok(ManifestResponse {
            status: 200,
            digest: Some(format!("sha256:{DIGEST}")),
            body: fixture(DOCKER_MANIFEST),
        })
    }
}

#[derive(Default)]
struct FakeDocker;

#[async_trait]
impl DockerHttp for FakeDocker {
    async fn get(
        &self,
        url: &str,
        _headers: &[(String, String)],
    ) -> anyhow::Result<DockerResponse> {
        if url.contains("/token?") {
            return Ok(DockerResponse {
                status: 200,
                headers: BTreeMap::new(),
                body: json!({"token": "anonymous"}),
            });
        }
        if url.contains("/tags/list") {
            return Ok(DockerResponse {
                status: 200,
                headers: BTreeMap::new(),
                body: fixture(DOCKER_TAGS),
            });
        }
        if url.contains("/manifests/") {
            let mut headers = BTreeMap::new();
            headers.insert(
                "docker-content-digest".to_owned(),
                format!("sha256:{DIGEST}"),
            );
            headers.insert("content-length".to_owned(), ARTIFACT.len().to_string());
            return Ok(DockerResponse {
                status: 200,
                headers,
                body: fixture(DOCKER_MANIFEST),
            });
        }
        anyhow::bail!("unexpected docker request {url}")
    }
}

// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------

async fn open_db(temp: &tempfile::TempDir) -> DbHandle {
    let db = DbHandle::open(temp.path().join("extras.db"))
        .await
        .expect("db");
    db.commit().await.expect("schema commit");
    db
}

async fn publisher(pds: &Arc<FakePds>, db: &DbHandle) -> Publisher {
    let publisher = common::make_publisher(pds.clone(), db);
    publisher.login().await.expect("publisher login");
    publisher
}

async fn seed_project(db: &DbHandle, slug: &str, purl: &str, vendor: &str, product: &str) {
    db.mark_software(SoftwareMark {
        repo_did: REPO.to_owned(),
        slug: slug.to_owned(),
        part: "a".to_owned(),
        vendor: vendor.to_owned(),
        product: product.to_owned(),
        project_uri: String::new(),
        project_cid: String::new(),
        software_uri: format!("at://{REPO}/com.nahdig.software/{slug}"),
        software_cid: "bafysoftware".to_owned(),
    })
    .await
    .expect("software");
    db.mark_purl(
        REPO,
        purl,
        slug,
        &format!("at://{REPO}/com.nahdig.purl/{slug}"),
        "bafypurl",
    )
    .await
    .expect("purl");
    db.commit().await.expect("seed commit");
}

fn extras_config(ecosystems: &[&str], sources: &[&str]) -> ExtrasConfig {
    ExtrasConfig {
        repo_did: REPO.to_owned(),
        limit: 10,
        recheck_seconds: 0.0,
        ecosystems: ecosystems.iter().map(|value| (*value).to_owned()).collect(),
        sources: sources.iter().map(|value| (*value).to_owned()).collect(),
        artifact_max_bytes: 0,
        dry_run: false,
        source_base_url: None,
        github_token: None,
        gitlab_token: None,
        gitee_token: None,
    }
}

async fn run_extras(
    db: &DbHandle,
    publisher: &Publisher,
    http: Arc<ExtrasHttp>,
    transports: SourceTransports,
    config: ExtrasConfig,
) -> ExtrasCounters {
    let resolver = ArtifactResolver::new(http.clone()).with_cache(db.clone(), REPO);
    let (events, mut rx) = mpsc::channel(128);
    let counters = sync_extras_with_cursor_resolver(
        publisher,
        db,
        &config,
        &mut ReleaseCursor::default(),
        events,
        http,
        &resolver,
        &transports,
    )
    .await
    .expect("extras sync");
    while rx.try_recv().is_ok() {}
    counters
}

fn records(pds: &FakePds, collection: &str) -> Vec<Value> {
    pds.store()
        .into_iter()
        .filter(|((entry_collection, _), _)| entry_collection == collection)
        .map(|(_, value)| value)
        .collect()
}

// ---------------------------------------------------------------------------
// One project per adapter family
// ---------------------------------------------------------------------------

#[tokio::test]
async fn pypi_project_publishes_project_manifest_version_channel_meta_and_status() {
    let temp = tempfile::tempdir().expect("temp dir");
    let db = open_db(&temp).await;
    let pds = FakePds::new();
    let publisher = publisher(&pds, &db).await;
    seed_project(&db, "acme-widget", "pkg:pypi/acme-widget", "acme", "widget").await;

    let counters = run_extras(
        &db,
        &publisher,
        Arc::new(ExtrasHttp::default()),
        SourceTransports::default(),
        extras_config(&[], &[]),
    )
    .await;

    assert_eq!(counters.projects_checked, 1);
    assert_eq!(counters.projects_created, 1);
    assert_eq!(counters.versions_created, 1);
    assert_eq!(counters.manifests_created, 1);
    assert_eq!(counters.statuses_created, 1);
    assert_eq!(counters.failures, 0);

    assert_eq!(
        pds.record(PROJECT_COLLECTION, "acme-widget")
            .expect("project record")["name"],
        json!("acme-widget")
    );
    // 1.1.0 is the newest stable release; 2.0.0rc1 is a prerelease.
    let version = pds
        .record(VERSION_COLLECTION, "acme-widget:1.1.0")
        .expect("version record");
    let manifest_uri = version["manifest"]["uri"].as_str().expect("manifest uri");
    assert!(manifest_uri.contains("/software.release.manifest/"));
    assert_eq!(records(&pds, MANIFEST_COLLECTION).len(), 1);
    let channel = pds
        .record(CHANNEL_COLLECTION, "acme-widget:latest")
        .expect("channel record");
    assert_eq!(
        channel["version"]["uri"],
        json!(format!(
            "at://{REPO}/{VERSION_COLLECTION}/acme-widget:1.1.0"
        ))
    );
    assert_eq!(channel["name"], json!("latest"));

    let meta = pds
        .record(PROJECT_META_COLLECTION, "acme-widget")
        .expect("project meta");
    assert_eq!(meta["description"], json!("ACME widget"));
    assert_eq!(meta["license"], json!("MIT"));
    assert_eq!(meta["homepage"], json!("https://acme.example/widget"));

    let statuses = records(&pds, STATUS_COLLECTION);
    assert_eq!(statuses.len(), 1);
    assert_eq!(statuses[0]["status"], json!("yanked"));
    assert_eq!(statuses[0]["kind"], json!("security"));
    assert_eq!(
        statuses[0]["subject"],
        json!(format!(
            "at://{REPO}/{VERSION_COLLECTION}/acme-widget:1.1.0"
        ))
    );
}

#[tokio::test]
async fn github_project_publishes_records() {
    let temp = tempfile::tempdir().expect("temp dir");
    let db = open_db(&temp).await;
    let pds = FakePds::new();
    let publisher = publisher(&pds, &db).await;
    seed_project(
        &db,
        "acme-widget-gh",
        "pkg:github/acme/widget",
        "acme",
        "widget",
    )
    .await;

    let git = Arc::new(FakeGit::default());
    let transports = SourceTransports {
        git: Some(git.clone()),
        ..SourceTransports::default()
    };
    let counters = run_extras(
        &db,
        &publisher,
        Arc::new(ExtrasHttp::default()),
        transports,
        extras_config(&["github"], &[]),
    )
    .await;

    assert_eq!(counters.versions_created, 1);
    assert_eq!(counters.failures, 0);
    assert!(
        pds.record(VERSION_COLLECTION, "acme-widget-gh:1.2.0")
            .is_some(),
        "newest stable GitHub release is 1.2.0"
    );
    assert!(
        pds.record(CHANNEL_COLLECTION, "acme-widget-gh:latest")
            .is_some()
    );
    assert_eq!(records(&pds, MANIFEST_COLLECTION).len(), 1);
    let meta = pds
        .record(PROJECT_META_COLLECTION, "acme-widget-gh")
        .expect("project meta");
    assert_eq!(meta["repository"], json!("https://github.com/acme/widget"));
    assert_eq!(meta["license"], json!("MIT"));
    assert!(!git.calls().is_empty());
}

#[tokio::test]
async fn distro_project_publishes_records() {
    let temp = tempfile::tempdir().expect("temp dir");
    let db = open_db(&temp).await;
    let pds = FakePds::new();
    let publisher = publisher(&pds, &db).await;
    seed_project(
        &db,
        "redhat-enterprise-linux",
        "pkg:rpm/redhat/enterprise_linux",
        "Red Hat",
        "Red Hat Enterprise Linux",
    )
    .await;

    let transports = SourceTransports {
        manifest: Some(Arc::new(FakeManifest)),
        ..SourceTransports::default()
    };
    let counters = run_extras(
        &db,
        &publisher,
        Arc::new(ExtrasHttp::default()),
        transports,
        extras_config(&["rpm"], &[]),
    )
    .await;

    assert_eq!(counters.versions_created, 1);
    assert_eq!(counters.failures, 0);
    let versions = db
        .list_release_versions_for_project(REPO, "redhat-enterprise-linux")
        .await
        .expect("version rows");
    assert_eq!(versions.len(), 1);
    assert!(
        pds.record(
            VERSION_COLLECTION,
            &format!("redhat-enterprise-linux:{}", versions[0].version)
        )
        .is_some()
    );
    assert!(
        pds.record(CHANNEL_COLLECTION, "redhat-enterprise-linux:latest")
            .is_some()
    );
    assert_eq!(records(&pds, MANIFEST_COLLECTION).len(), 1);
    let meta = pds
        .record(PROJECT_META_COLLECTION, "redhat-enterprise-linux")
        .expect("project meta");
    assert_eq!(meta["name"], json!("redhat-enterprise-linux"));
}

#[tokio::test]
async fn docker_project_publishes_records() {
    let temp = tempfile::tempdir().expect("temp dir");
    let db = open_db(&temp).await;
    let pds = FakePds::new();
    let publisher = publisher(&pds, &db).await;
    seed_project(
        &db,
        "acme-widget-oci",
        "pkg:docker/acme/widget",
        "acme",
        "widget",
    )
    .await;

    let transports = SourceTransports {
        docker: Some(Arc::new(FakeDocker)),
        ..SourceTransports::default()
    };
    let counters = run_extras(
        &db,
        &publisher,
        Arc::new(ExtrasHttp::default()),
        transports,
        extras_config(&["docker"], &[]),
    )
    .await;

    assert_eq!(counters.versions_created, 1);
    assert_eq!(counters.failures, 0);
    assert!(
        pds.record(VERSION_COLLECTION, "acme-widget-oci:1.0.0")
            .is_some()
    );
    assert!(
        pds.record(CHANNEL_COLLECTION, "acme-widget-oci:latest")
            .is_some()
    );
    assert_eq!(records(&pds, MANIFEST_COLLECTION).len(), 1);
    let meta = pds
        .record(PROJECT_META_COLLECTION, "acme-widget-oci")
        .expect("project meta");
    assert_eq!(meta["repository"], json!("acme/widget"));
}

// ---------------------------------------------------------------------------
// Filters and typed skips
// ---------------------------------------------------------------------------

#[tokio::test]
async fn ecosystem_filter_skips_other_purl_types() {
    let temp = tempfile::tempdir().expect("temp dir");
    let db = open_db(&temp).await;
    let pds = FakePds::new();
    let publisher = publisher(&pds, &db).await;
    seed_project(&db, "acme-widget", "pkg:pypi/acme-widget", "acme", "widget").await;
    seed_project(
        &db,
        "acme-widget-gh",
        "pkg:github/acme/widget",
        "acme",
        "widget",
    )
    .await;

    let counters = run_extras(
        &db,
        &publisher,
        Arc::new(ExtrasHttp::default()),
        SourceTransports::default(),
        extras_config(&["pypi"], &[]),
    )
    .await;

    assert_eq!(counters.projects_checked, 1);
    assert_eq!(counters.skipped, 0);
    assert_eq!(counters.projects_created, 1);
    assert!(pds.record(PROJECT_COLLECTION, "acme-widget").is_some());
    assert!(pds.record(PROJECT_COLLECTION, "acme-widget-gh").is_none());
}

#[tokio::test]
async fn source_filter_matches_adapter_names() {
    let temp = tempfile::tempdir().expect("temp dir");
    let db = open_db(&temp).await;
    let pds = FakePds::new();
    let publisher = publisher(&pds, &db).await;
    seed_project(&db, "acme-widget", "pkg:pypi/acme-widget", "acme", "widget").await;
    seed_project(
        &db,
        "acme-widget-php",
        "pkg:composer/acme/widget",
        "acme",
        "widget",
    )
    .await;

    let mut config = extras_config(&[], &["composer"]);
    config.source_base_url = Some("https://packagist.example".to_owned());
    let counters = run_extras(
        &db,
        &publisher,
        Arc::new(ExtrasHttp::default()),
        SourceTransports::default(),
        config,
    )
    .await;

    assert_eq!(counters.projects_checked, 1);
    assert_eq!(counters.skipped, 0);
    assert_eq!(counters.projects_created, 1);
    assert!(pds.record(PROJECT_COLLECTION, "acme-widget-php").is_some());
    assert!(pds.record(PROJECT_COLLECTION, "acme-widget").is_none());
}

#[tokio::test]
async fn unsupported_purl_type_is_a_typed_skip() {
    let temp = tempfile::tempdir().expect("temp dir");
    let db = open_db(&temp).await;
    let pds = FakePds::new();
    let publisher = publisher(&pds, &db).await;
    seed_project(&db, "acme-conan", "pkg:conan/acme-widget", "acme", "widget").await;

    let counters = run_extras(
        &db,
        &publisher,
        Arc::new(ExtrasHttp::default()),
        SourceTransports::default(),
        extras_config(&[], &[]),
    )
    .await;

    assert_eq!(counters.projects_checked, 1);
    assert_eq!(counters.unsupported, 1);
    assert_eq!(counters.failures, 0);
    assert_eq!(pds.count("putRecord"), 0);
    let state = db
        .get_release_project_state(REPO, "acme-conan")
        .await
        .expect("state query")
        .expect("state row");
    assert!(
        state
            .unsupported_reason
            .unwrap_or_default()
            .contains("UnknownPurlType")
    );
}

#[tokio::test]
async fn dry_run_makes_zero_writes() {
    let temp = tempfile::tempdir().expect("temp dir");
    let db = open_db(&temp).await;
    let pds = FakePds::new();
    let publisher = publisher(&pds, &db).await;
    seed_project(&db, "acme-widget", "pkg:pypi/acme-widget", "acme", "widget").await;

    let mut config = extras_config(&[], &[]);
    config.dry_run = true;
    let counters = run_extras(
        &db,
        &publisher,
        Arc::new(ExtrasHttp::default()),
        SourceTransports::default(),
        config,
    )
    .await;

    assert_eq!(counters.projects_checked, 1);
    assert_eq!(counters.skipped, 1);
    assert_eq!(counters.versions_created, 0);
    assert_eq!(pds.count("putRecord"), 0);
    assert!(pds.store().is_empty());
}

// ---------------------------------------------------------------------------
// All mode
// ---------------------------------------------------------------------------

#[tokio::test]
async fn all_runs_modes_in_order_with_separate_counters() {
    let temp = tempfile::tempdir().expect("temp dir");
    let db = open_db(&temp).await;
    let pds = FakePds::new();
    let publisher = publisher(&pds, &db).await;
    seed_project(&db, "acme-widget", "pkg:pypi/acme-widget", "acme", "widget").await;
    seed_project(
        &db,
        "acme-widget-php",
        "pkg:composer/acme/widget",
        "acme",
        "widget",
    )
    .await;
    let osv_dir = tempfile::tempdir().expect("osv dir");

    let mut extras = extras_config(&["composer"], &[]);
    extras.source_base_url = Some("https://packagist.example".to_owned());
    let (events, mut rx) = mpsc::channel(256);
    let counters = sync_all_with_http(
        &publisher,
        &db,
        &ReleaseConfig {
            repo_did: REPO.to_owned(),
            limit: 10,
            recheck_seconds: 0.0,
        },
        &AffectedConfig {
            repo_did: REPO.to_owned(),
            limit: 10,
            recheck_seconds: 0.0,
            ecosystems: Vec::new(),
            sources: Vec::new(),
            concurrency: 1,
            osv_online: false,
            osv_bulk_dir: Some(osv_dir.path().to_path_buf()),
        },
        None,
        &extras,
        &mut ReleaseCursor::default(),
        events,
        Arc::new(ExtrasHttp::default()),
    )
    .await
    .expect("all mode");

    let mut order = Vec::new();
    while let Ok(event) = rx.try_recv() {
        match event {
            ProgressEvent::ReleasePhaseStarted { mode, .. } => order.push(mode),
            ProgressEvent::ReleaseExtrasStarted { .. } => order.push("extras"),
            _ => {}
        }
    }
    assert_eq!(order, vec!["latest", "affected", "extras"]);

    // Separate counters: latest saw both candidates (the composer purl has no
    // deps.dev release system), affected visited both, extras processed only
    // the composer project.
    assert_eq!(counters.latest.projects_checked, 2);
    assert_eq!(counters.latest.versions_created, 1);
    assert_eq!(counters.affected.projects_checked, 2);
    assert_eq!(counters.extras.projects_checked, 1);
    assert_eq!(counters.extras.projects_created, 1);
    assert_eq!(counters.extras.versions_created, 1);
    assert!(counters.history.is_none(), "history limit 0 skips history");
    assert!(counters.artifacts.downloads >= 2);
    assert!(pds.record(PROJECT_COLLECTION, "acme-widget-php").is_some());
    assert!(pds.record(PROJECT_COLLECTION, "acme-widget").is_some());
}

// ---------------------------------------------------------------------------
// Gitee auth header
// ---------------------------------------------------------------------------

#[tokio::test]
async fn gitee_uses_bearer_header_and_no_token_in_url() {
    let temp = tempfile::tempdir().expect("temp dir");
    let db = open_db(&temp).await;
    let pds = FakePds::new();
    let publisher = publisher(&pds, &db).await;
    seed_project(
        &db,
        "acme-widget-gitee",
        "pkg:gitee/acme/widget",
        "acme",
        "widget",
    )
    .await;

    let http = Arc::new(ExtrasHttp::default());
    let mut config = extras_config(&["gitee"], &[]);
    config.gitee_token = Some("secret-token".to_owned());
    let counters = run_extras(
        &db,
        &publisher,
        http.clone(),
        SourceTransports::default(),
        config,
    )
    .await;

    assert_eq!(counters.versions_created, 1);
    let calls = http.header_calls();
    assert!(!calls.is_empty(), "gitee must call the header-aware seam");
    for (url, headers) in &calls {
        assert!(
            !url.contains("secret-token") && !url.contains("access_token"),
            "token leaked into URL: {url}"
        );
        assert!(
            headers.iter().any(|(name, value)| {
                name.eq_ignore_ascii_case("authorization") && value == "Bearer secret-token"
            }),
            "missing bearer header on {url}: {headers:?}"
        );
    }
    // No other adapter URL may carry the token either.
    for url in http.urls() {
        assert!(!url.contains("secret-token") && !url.contains("access_token"));
    }
}

// ---------------------------------------------------------------------------
// Idempotency
// ---------------------------------------------------------------------------

#[tokio::test]
async fn second_run_is_idempotent() {
    let temp = tempfile::tempdir().expect("temp dir");
    let db = open_db(&temp).await;
    let pds = FakePds::new();
    let publisher = publisher(&pds, &db).await;
    seed_project(
        &db,
        "acme-widget-php",
        "pkg:composer/acme/widget",
        "acme",
        "widget",
    )
    .await;

    let mut config = extras_config(&["composer"], &[]);
    config.source_base_url = Some("https://packagist.example".to_owned());
    let first = run_extras(
        &db,
        &publisher,
        Arc::new(ExtrasHttp::default()),
        SourceTransports::default(),
        config.clone(),
    )
    .await;
    assert_eq!(first.versions_created, 1);
    let puts_after_first = pds.count("putRecord");
    let records_after_first = pds.store().len();
    assert!(puts_after_first >= 5);

    let second = run_extras(
        &db,
        &publisher,
        Arc::new(ExtrasHttp::default()),
        SourceTransports::default(),
        config,
    )
    .await;
    assert_eq!(second.unchanged, 1);
    assert_eq!(second.versions_created, 0);
    assert_eq!(second.manifests_created, 0);
    assert_eq!(second.failures, 0);
    assert_eq!(pds.count("putRecord"), puts_after_first);
    assert_eq!(pds.store().len(), records_after_first);
}