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

johnandersen777.bsky.social/vuln-notif

0
0
main
1443 lines · 48.8 KB Raw History
//! Release ingestion parity tests: version/purl rules, deps.dev selection,
//! per-registry artifacts, retry behavior, and a full fake-PDS sync.

use std::collections::HashMap;
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::{Arc, Mutex};

use async_trait::async_trait;
use serde_json::{Value, json};
use tokio::sync::mpsc;
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};

use vuln_notif::constants::{
    CHANNEL_COLLECTION, MANIFEST_COLLECTION, PROJECT_COLLECTION, STATUS_COLLECTION,
    VERSION_COLLECTION,
};
use vuln_notif::db::DbHandle;
use vuln_notif::db::model::{SoftwareIdentityMark, SoftwareMark};
use vuln_notif::log::{Level, Logger};
use vuln_notif::pds::{PdsApi, Publisher, PublisherConfig, RateGovernor, XrpcResponse};
use vuln_notif::records::{cidv1_raw, digest_rkey, sha256_hex};
use vuln_notif::release::artifact::{
    Artifact, cargo_artifact, choose_purl, gem_artifact, go_escape, golang_artifact,
    maven_artifact, normalize_version, npm_artifact, nuget_artifact, parse_purl, pypi_artifact,
};
use vuln_notif::release::http::{RegistryHttp, ReqwestRegistryHttp};
use vuln_notif::release::records::{
    LATEST_CHANNEL, channel_record, channel_rkey, manifest_record, manifest_rkey, project_record,
    status_record, status_rkey, version_record, version_rkey,
};
use vuln_notif::release::{
    ReleaseConfig, ReleaseCursor, select_release, sync_releases_with_http,
    sync_releases_with_http_cursor,
};
use vuln_notif::runtime::events::ProgressEvent;
use vuln_notif::time::RealTime;

const DEPSDEV_FIXTURE: &str = include_str!("fixtures/registries/depsdev.json");
const NPM_FIXTURE: &str = include_str!("fixtures/registries/npm.json");
const PYPI_FIXTURE: &str = include_str!("fixtures/registries/pypi.json");
const CARGO_FIXTURE: &str = include_str!("fixtures/registries/cargo.json");
const GEM_FIXTURE: &str = include_str!("fixtures/registries/gem.json");
const MAVEN_FIXTURE: &str = include_str!("fixtures/registries/maven-metadata.xml");
const NUGET_FIXTURE: &str = include_str!("fixtures/registries/nuget-index.json");

const AAAA: &str = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
const BBBB: &str = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";

// ---------------------------------------------------------------------------
// Fake registry HTTP seam
// ---------------------------------------------------------------------------

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

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

impl FakeHttp {
    fn new(routes: Vec<(String, Reply)>) -> Self {
        Self {
            replies: Mutex::new(routes.into_iter().collect()),
            calls: Mutex::new(Vec::new()),
        }
    }

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

    fn take(&self, kind: &str, url: &str) -> anyhow::Result<Reply> {
        self.calls.lock().unwrap().push(format!("{kind} {url}"));
        self.replies
            .lock()
            .unwrap()
            .get(url)
            .cloned()
            .ok_or_else(|| anyhow::anyhow!("unexpected {kind} {url}"))
    }
}

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

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

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

fn routes<S: Into<String>>(items: Vec<(S, Reply)>) -> FakeHttp {
    FakeHttp::new(
        items
            .into_iter()
            .map(|(url, reply)| (url.into(), reply))
            .collect(),
    )
}

fn json_route(url: &str, fixture: &str) -> (String, Reply) {
    (
        url.to_owned(),
        Reply::Json(serde_json::from_str(fixture).unwrap()),
    )
}

// ---------------------------------------------------------------------------
// Version normalization, purl parsing and selection
// ---------------------------------------------------------------------------

#[test]
fn version_normalizer_and_purl_choice() {
    assert_eq!(normalize_version("4.18.1").as_deref(), Some("4.18.1"));
    assert_eq!(
        normalize_version("v1.2.3-RC1").as_deref(),
        Some("v1.2.3-rc1")
    );
    assert_eq!(
        normalize_version("1.0.0+build.1").as_deref(),
        Some("1.0.0-build.1")
    );
    assert_eq!(normalize_version("1!2.0"), None);
    assert_eq!(normalize_version("1:2.0"), None);
    assert_eq!(normalize_version(&"x".repeat(65)), None);
    assert_eq!(normalize_version("  "), None);
    assert_eq!(
        normalize_version("1.0.0 beta_2").as_deref(),
        Some("1.0.0-beta-2")
    );
    assert_eq!(normalize_version("a..b"), None);

    let chosen = choose_purl(
        &[
            "pkg:npm/%40scope/other-widget".to_owned(),
            "pkg:pypi/widget".to_owned(),
        ],
        "widget",
    )
    .expect("purl chosen");
    assert_eq!(chosen.r#type, "pypi");
    assert_eq!(chosen.name, "widget");

    let npm = parse_purl("pkg:npm/%40scope/other-widget@1.2.3").expect("npm purl");
    assert_eq!(npm.r#type, "npm");
    assert_eq!(npm.name, "@scope/other-widget");
    assert_eq!(npm.raw, "pkg:npm/%40scope/other-widget@1.2.3");

    let maven = parse_purl("pkg:maven/com.acme/widget@1.2.3").expect("maven purl");
    assert_eq!(maven.name, "com.acme:widget");

    let subpath = parse_purl("pkg:gem/widget#sub/path?x=1").expect("subpath purl");
    assert_eq!(subpath.name, "widget");

    assert_eq!(parse_purl("pkg:unknown/widget"), None);
    assert_eq!(parse_purl("widget"), None);
    assert_eq!(
        go_escape("github.com/Acme/Widget"),
        "github.com/!acme/!widget"
    );
}

#[test]
fn release_selection_uses_default_then_fallbacks() {
    let fixture: Value = serde_json::from_str(DEPSDEV_FIXTURE).unwrap();
    let versions = fixture["versions"].as_array().unwrap();
    let selected = select_release(versions).expect("selected");
    assert_eq!(selected.raw, "1.2.3");
    assert_eq!(selected.version, "1.2.3");
    assert!(!selected.deprecated);
    assert_eq!(selected.reason, "");

    let unrepresentable_default = vec![
        json!({"versionKey": {"version": "1!2.0"}, "isDefault": true, "isDeprecated": false}),
        json!({"versionKey": {"version": "1.2.1"}, "isDefault": false, "isDeprecated": false}),
    ];
    let selected = select_release(&unrepresentable_default).expect("fallback");
    assert_eq!(selected.raw, "1.2.1");

    let deprecated_default = vec![
        json!({
            "versionKey": {"version": "1.0.0"},
            "isDefault": true,
            "isDeprecated": true,
            "deprecatedReason": "old release",
        }),
        json!({"versionKey": {"version": "0.9.0"}, "isDefault": false, "isDeprecated": false}),
    ];
    let selected = select_release(&deprecated_default).expect("non-deprecated fallback");
    assert_eq!(selected.raw, "0.9.0");
    assert!(!selected.deprecated);

    let only_deprecated = vec![json!({
        "versionKey": {"version": "1.0.0"},
        "isDefault": true,
        "isDeprecated": true,
        "deprecatedReason": "old release",
    })];
    let selected = select_release(&only_deprecated).expect("deprecated selected");
    assert!(selected.deprecated);
    assert_eq!(selected.reason, "old release");

    let no_versions = vec![json!({"versionKey": {}})];
    assert!(select_release(&no_versions).is_none());
}

// ---------------------------------------------------------------------------
// Record and rkey builders
// ---------------------------------------------------------------------------

#[test]
fn release_record_builders_match_the_wire_contract() {
    let artifact = Artifact {
        file_name: "acme_widget-1.2.3-py3-none-any.whl".to_owned(),
        url: "https://files.example/acme_widget-1.2.3-py3-none-any.whl".to_owned(),
        sha256: sha256_hex(b"artifact-bytes"),
        size: 14,
        mime_type: "application/zip".to_owned(),
    };
    let artifact_cid = artifact.cid();
    let project_uri = "at://did:plc:test/software.release.project/acme-widget";
    let manifest_uri = "at://did:plc:test/software.release.manifest/abc123";
    let manifest_cid = "bafymanifest";
    let version_uri = "at://did:plc:test/software.release.version/acme-widget:1.2.3";
    let version_cid = "bafyversion";

    assert_eq!(
        project_record("acme-widget"),
        json!({"$type": "software.release.project", "name": "acme-widget"})
    );

    assert_eq!(
        manifest_rkey("acme-widget", &artifact),
        digest_rkey(&[
            "manifest",
            "acme-widget",
            &artifact_cid,
            &artifact.url,
            "14",
        ])
    );
    assert_eq!(
        manifest_record(project_uri, &artifact),
        json!({
            "$type": "software.release.manifest",
            "project": project_uri,
            "artifacts": [{
                "$type": "software.release.defs#httpArtifact",
                "fileName": "acme_widget-1.2.3-py3-none-any.whl",
                "url": "https://files.example/acme_widget-1.2.3-py3-none-any.whl",
                "cid": artifact_cid,
                "size": 14,
                "mimeType": "application/zip",
            }],
        })
    );

    assert_eq!(version_rkey("acme-widget", "1.2.3"), "acme-widget:1.2.3");
    assert_eq!(
        version_record(project_uri, "1.2.3", manifest_uri, manifest_cid),
        json!({
            "$type": "software.release.version",
            "project": project_uri,
            "version": "1.2.3",
            "manifest": {"uri": manifest_uri, "cid": manifest_cid},
        })
    );

    assert_eq!(
        channel_rkey("acme-widget", LATEST_CHANNEL),
        "acme-widget:latest"
    );
    assert_eq!(
        channel_record(project_uri, LATEST_CHANNEL, version_uri, version_cid),
        json!({
            "$type": "software.release.channel",
            "project": project_uri,
            "name": "latest",
            "version": {"uri": version_uri, "cid": version_cid},
        })
    );

    assert_eq!(
        status_rkey(version_uri, "deprecated", "old release"),
        digest_rkey(&["status", version_uri, "deprecated", "old release"])
    );
    assert_eq!(
        status_record(version_uri, "deprecated", "old release"),
        json!({
            "$type": "software.release.status",
            "subject": version_uri,
            "status": "deprecated",
            "kind": "superseded",
            "reason": "old release",
        })
    );
    assert_eq!(
        status_record(version_uri, "active", ""),
        json!({
            "$type": "software.release.status",
            "subject": version_uri,
            "status": "active",
        })
    );
    assert_eq!(
        status_record(version_uri, "deprecated", ""),
        json!({
            "$type": "software.release.status",
            "subject": version_uri,
            "status": "deprecated",
        })
    );
}

// ---------------------------------------------------------------------------
// Per-ecosystem artifact fetchers
// ---------------------------------------------------------------------------

#[tokio::test]
async fn npm_artifact_streams_and_hashes_tarball() {
    let metadata = "https://registry.npmjs.org/acme-widget";
    let tarball = "https://registry.npmjs.org/acme-widget/-/acme-widget-1.2.3.tgz";
    let http = routes(vec![
        json_route(metadata, NPM_FIXTURE),
        (tarball.to_owned(), Reply::Bytes(b"tarball-bytes".to_vec())),
    ]);
    let artifact = npm_artifact(&http, "acme-widget", "1.2.3")
        .await
        .expect("npm artifact");
    assert_eq!(artifact.file_name, "acme-widget-1.2.3.tgz");
    assert_eq!(artifact.url, tarball);
    assert_eq!(artifact.sha256, sha256_hex(b"tarball-bytes"));
    assert_eq!(artifact.size, 13);
    assert_eq!(artifact.mime_type, "application/gzip");
    assert_eq!(artifact.cid(), cidv1_raw(&sha256_hex(b"tarball-bytes")));
}

#[tokio::test]
async fn npm_quote_keeps_scope_and_encodes_space() {
    let metadata = "https://registry.npmjs.org/@scope/my%20widget";
    let tarball = "https://cdn.example/pkg-1.2.3.tgz";
    let payload = json!({
        "versions": {"1.2.3": {"dist": {"tarball": tarball}}},
    });
    let http = routes(vec![
        (metadata.to_owned(), Reply::Json(payload)),
        (tarball.to_owned(), Reply::Bytes(b"x".to_vec())),
    ]);
    let artifact = npm_artifact(&http, "@scope/my widget", "1.2.3")
        .await
        .expect("scoped npm artifact");
    assert_eq!(artifact.file_name, "pkg-1.2.3.tgz");
    assert!(http.calls().contains(&format!("json {metadata}")));
}

#[tokio::test]
async fn pypi_artifact_prefers_non_yanked_wheel() {
    let metadata = "https://pypi.org/pypi/acme-widget/json";
    let http = routes(vec![json_route(metadata, PYPI_FIXTURE)]);
    let artifact = pypi_artifact(&http, "acme-widget", "1.2.3")
        .await
        .expect("pypi artifact");
    assert_eq!(artifact.file_name, "acme_widget-1.2.3-py3-none-any.whl");
    assert_eq!(
        artifact.url,
        "https://files.pythonhosted.org/packages/ee/ff/acme_widget-1.2.3-py3-none-any.whl"
    );
    assert_eq!(artifact.sha256, BBBB);
    assert_eq!(artifact.size, 12345);
    assert_eq!(artifact.mime_type, "application/zip");
    assert_eq!(http.calls(), vec![format!("json {metadata}")]);
}

#[tokio::test]
async fn cargo_artifact_uses_declared_digest() {
    let metadata = "https://crates.io/api/v1/crates/acme-widget";
    let http = routes(vec![json_route(metadata, CARGO_FIXTURE)]);
    let artifact = cargo_artifact(&http, "acme-widget", "1.2.3")
        .await
        .expect("cargo artifact");
    assert_eq!(artifact.file_name, "acme-widget-1.2.3.crate");
    assert_eq!(
        artifact.url,
        "https://static.crates.io/crates/acme-widget/acme-widget-1.2.3.crate"
    );
    assert_eq!(artifact.sha256, AAAA);
    assert_eq!(artifact.size, 14567);
    assert_eq!(artifact.mime_type, "application/gzip");
}

#[tokio::test]
async fn gem_artifact_uses_declared_size_and_heads_when_missing() {
    let metadata = "https://rubygems.org/api/v1/versions/acme-widget.json";
    let http = routes(vec![json_route(metadata, GEM_FIXTURE)]);
    let artifact = gem_artifact(&http, "acme-widget", "1.2.3")
        .await
        .expect("gem artifact");
    assert_eq!(artifact.file_name, "acme-widget-1.2.3.gem");
    assert_eq!(
        artifact.url,
        "https://rubygems.org/gems/acme-widget-1.2.3.gem"
    );
    assert_eq!(artifact.sha256, AAAA);
    assert_eq!(artifact.size, 15678);
    assert_eq!(artifact.mime_type, "application/gzip");

    let gem_url = "https://rubygems.org/gems/acme-widget-1.2.3.gem";
    let payload = json!([{
        "number": "1.2.3",
        "gem_uri": gem_url,
        "sha": BBBB,
        "size": 0,
        "yanked": false,
    }]);
    let http = routes(vec![
        (metadata.to_owned(), Reply::Json(payload)),
        (gem_url.to_owned(), Reply::Size(4242)),
    ]);
    let artifact = gem_artifact(&http, "acme-widget", "1.2.3")
        .await
        .expect("gem head fallback");
    assert_eq!(artifact.size, 4242);
    assert!(http.calls().contains(&format!("head {gem_url}")));
}

#[tokio::test]
async fn maven_artifact_reads_metadata_and_hashes_jar() {
    let metadata = "https://repo1.maven.org/maven2/com/acme/acme-widget/maven-metadata.xml";
    let jar = "https://repo1.maven.org/maven2/com/acme/acme-widget/1.2.3/acme-widget-1.2.3.jar";
    let http = routes(vec![
        (metadata.to_owned(), Reply::Text(MAVEN_FIXTURE.to_owned())),
        (jar.to_owned(), Reply::Bytes(b"jar-bytes".to_vec())),
    ]);
    let artifact = maven_artifact(&http, "com.acme:acme-widget", "1.2.3")
        .await
        .expect("maven artifact");
    assert_eq!(artifact.file_name, "acme-widget-1.2.3.jar");
    assert_eq!(artifact.url, jar);
    assert_eq!(artifact.sha256, sha256_hex(b"jar-bytes"));
    assert_eq!(artifact.size, 9);
    assert_eq!(artifact.mime_type, "application/java-archive");

    let http = routes(vec![
        (metadata.to_owned(), Reply::Text(MAVEN_FIXTURE.to_owned())),
        (jar.to_owned(), Reply::Bytes(b"jar-bytes".to_vec())),
    ]);
    let error = maven_artifact(&http, "com.acme:acme-widget", "9.9.9")
        .await
        .expect_err("missing maven version");
    assert!(error.to_string().contains("maven version missing"));

    // Metadata absence (HTTP failure) falls through to the direct URL.
    let http = routes(vec![
        (metadata.to_owned(), Reply::Error("HTTP 404".to_owned())),
        (jar.to_owned(), Reply::Bytes(b"jar-bytes".to_vec())),
    ]);
    let artifact = maven_artifact(&http, "com.acme:acme-widget", "1.2.3")
        .await
        .expect("maven without metadata");
    assert_eq!(artifact.sha256, sha256_hex(b"jar-bytes"));
}

#[tokio::test]
async fn nuget_artifact_lowercases_package_url() {
    let index = "https://api.nuget.org/v3-flatcontainer/acme.widget/index.json";
    let package =
        "https://api.nuget.org/v3-flatcontainer/acme.widget/1.2.3/acme.widget.1.2.3.nupkg";
    let http = routes(vec![
        (
            index.to_owned(),
            Reply::Json(serde_json::from_str(NUGET_FIXTURE).unwrap()),
        ),
        (package.to_owned(), Reply::Bytes(b"nupkg".to_vec())),
    ]);
    let artifact = nuget_artifact(&http, "Acme.Widget", "1.2.3")
        .await
        .expect("nuget artifact");
    assert_eq!(artifact.file_name, "acme.widget.1.2.3.nupkg");
    assert_eq!(artifact.url, package);
    assert_eq!(artifact.sha256, sha256_hex(b"nupkg"));
    assert_eq!(artifact.size, 5);
    assert_eq!(artifact.mime_type, "application/zip");

    let http = routes(vec![(
        index.to_owned(),
        Reply::Json(serde_json::from_str(NUGET_FIXTURE).unwrap()),
    )]);
    let error = nuget_artifact(&http, "Acme.Widget", "9.9.9")
        .await
        .expect_err("missing nuget version");
    assert!(error.to_string().contains("nuget version missing"));
}

#[tokio::test]
async fn golang_artifact_escapes_uppercase() {
    let module = "github.com/Acme/Widget";
    let escaped = "github.com/!acme/!widget";
    let url = "https://proxy.golang.org/github.com/!acme/!widget/@v/v1.2.3.zip";
    let http = routes(vec![(url.to_owned(), Reply::Bytes(b"zip".to_vec()))]);
    let artifact = golang_artifact(&http, module, "v1.2.3")
        .await
        .expect("go artifact");
    assert_eq!(artifact.file_name, "Widget-v1.2.3.zip");
    assert_eq!(artifact.url, url);
    assert_eq!(artifact.sha256, sha256_hex(b"zip"));
    assert_eq!(artifact.size, 3);
    assert_eq!(artifact.mime_type, "application/zip");
    assert!(http.calls().contains(&format!("download {url}")));
    assert_eq!(go_escape(module), escaped);
}

#[tokio::test]
async fn registry_missing_yanked_and_not_found_errors() {
    let npm_error = routes(vec![(
        "https://registry.npmjs.org/acme-missing".to_owned(),
        Reply::Error("HTTP 404 for npm".to_owned()),
    )]);
    let error = npm_artifact(&npm_error, "acme-missing", "1.2.3")
        .await
        .expect_err("npm 404");
    assert!(error.to_string().contains("HTTP 404"));

    let cargo = routes(vec![json_route(
        "https://crates.io/api/v1/crates/acme-widget",
        CARGO_FIXTURE,
    )]);
    let error = cargo_artifact(&cargo, "acme-widget", "1.2.2")
        .await
        .expect_err("cargo yanked");
    assert!(error.to_string().contains("crates artifact missing"));

    let gem = routes(vec![json_route(
        "https://rubygems.org/api/v1/versions/acme-widget.json",
        GEM_FIXTURE,
    )]);
    let error = gem_artifact(&gem, "acme-widget", "1.2.2")
        .await
        .expect_err("gem yanked");
    assert!(error.to_string().contains("rubygems artifact missing"));

    let pypi_payload = json!({
        "releases": {
            "1.2.3": [{
                "filename": "acme_widget-1.2.3-py3-none-any.whl",
                "url": "https://files.example/acme.whl",
                "size": 1,
                "digests": {"sha256": AAAA},
                "packagetype": "bdist_wheel",
                "yanked": true,
            }]
        }
    });
    let pypi = routes(vec![(
        "https://pypi.org/pypi/acme-widget/json".to_owned(),
        Reply::Json(pypi_payload),
    )]);
    let error = pypi_artifact(&pypi, "acme-widget", "1.2.3")
        .await
        .expect_err("pypi yanked");
    assert!(error.to_string().contains("pypi artifact missing"));
}

#[tokio::test]
async fn registry_http_retries_rate_limit_then_succeeds() {
    let server = MockServer::start().await;
    Mock::given(method("GET"))
        .and(path("/pkg"))
        .respond_with(ResponseTemplate::new(429))
        .up_to_n_times(1)
        .mount(&server)
        .await;
    Mock::given(method("GET"))
        .and(path("/pkg"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({"ok": true})))
        .mount(&server)
        .await;

    let http = ReqwestRegistryHttp::new().expect("http client");
    let url = format!("{}/pkg", server.uri());
    let value = http.get_json(&url).await.expect("retry succeeds");
    assert_eq!(value["ok"], true);
    assert_eq!(server.received_requests().await.unwrap().len(), 2);
}

#[tokio::test]
async fn registry_http_does_not_retry_404() {
    let server = MockServer::start().await;
    Mock::given(method("GET"))
        .respond_with(ResponseTemplate::new(404))
        .mount(&server)
        .await;

    let http = ReqwestRegistryHttp::new().expect("http client");
    let error = http
        .get_json(&format!("{}/missing", server.uri()))
        .await
        .expect_err("404 is not retried");
    assert!(error.to_string().contains("404"));
    assert_eq!(server.received_requests().await.unwrap().len(), 1);
}

// ---------------------------------------------------------------------------
// Full sync against a fake PDS
// ---------------------------------------------------------------------------

type Put = (String, String, Value);

#[derive(Default)]
struct FakePds {
    puts: Mutex<Vec<Put>>,
    calls: AtomicU64,
}

#[async_trait]
impl PdsApi for FakePds {
    async fn create_session(&self, handle: &str, _password: &str) -> anyhow::Result<XrpcResponse> {
        Ok(XrpcResponse {
            status: 200,
            body: json!({
                "did": "did:plc:test",
                "handle": handle,
                "accessJwt": "access-token",
                "refreshJwt": "refresh-token",
            }),
            ..XrpcResponse::default()
        })
    }

    async fn refresh_session(&self, _refresh_jwt: &str) -> anyhow::Result<XrpcResponse> {
        self.create_session("alice.test", "").await
    }

    async fn get_record(
        &self,
        _repo: &str,
        _collection: &str,
        _rkey: &str,
        _access_jwt: &str,
    ) -> anyhow::Result<XrpcResponse> {
        Ok(XrpcResponse {
            status: 404,
            body: json!({"error": "NotFound", "message": "Record not found"}),
            ..XrpcResponse::default()
        })
    }

    async fn create_record(
        &self,
        _repo: &str,
        collection: &str,
        rkey: &str,
        record: &Value,
        _access_jwt: &str,
    ) -> anyhow::Result<XrpcResponse> {
        self.put_record("", collection, rkey, record, "").await
    }

    async fn put_record(
        &self,
        _repo: &str,
        collection: &str,
        rkey: &str,
        record: &Value,
        _access_jwt: &str,
    ) -> anyhow::Result<XrpcResponse> {
        let call = self.calls.fetch_add(1, Ordering::Relaxed);
        self.puts
            .lock()
            .unwrap()
            .push((collection.to_owned(), rkey.to_owned(), record.clone()));
        Ok(XrpcResponse {
            status: 200,
            body: json!({
                "uri": format!("at://did:plc:test/{collection}/{rkey}"),
                "cid": format!("bafyfake{call}"),
            }),
            ..XrpcResponse::default()
        })
    }

    async fn apply_writes(
        &self,
        _repo: &str,
        _writes: &[Value],
        _access_jwt: &str,
    ) -> anyhow::Result<XrpcResponse> {
        Ok(XrpcResponse {
            status: 200,
            body: json!({"results": []}),
            ..XrpcResponse::default()
        })
    }

    async fn upload_blob(
        &self,
        _bytes: &[u8],
        _mime_type: &str,
        _access_jwt: &str,
    ) -> anyhow::Result<XrpcResponse> {
        Ok(XrpcResponse {
            status: 200,
            body: json!({"blob": {}}),
            ..XrpcResponse::default()
        })
    }
}

async fn make_publisher(db: &DbHandle, api: Arc<dyn PdsApi>) -> Publisher {
    let governor = Arc::new(RateGovernor::new(
        db.clone(),
        1_000_000.0,
        1_000_000.0,
        1_000_000.0,
        Arc::new(RealTime),
    ));
    let config = PublisherConfig {
        pds_url: "http://127.0.0.1:1".to_owned(),
        handle: "alice.test".to_owned(),
        app_password: "app-pw".to_owned(),
        collection: "com.nahdig.cve.nvdV2".to_owned(),
        timeout_secs: 5.0,
        governor,
    };
    Publisher::with_api(
        config,
        api,
        Logger::stderr(Level::Error),
        Arc::new(RealTime),
    )
    .expect("publisher")
}

fn find_put(puts: &[Put], collection: &str) -> Put {
    puts.iter()
        .find(|(name, _, _)| name == collection)
        .cloned()
        .unwrap_or_else(|| panic!("missing put for {collection}"))
}

fn find_puts<'a>(puts: &'a [Put], collection: &'a str) -> Vec<&'a Put> {
    puts.iter()
        .filter(|(name, _, _)| name == collection)
        .collect()
}

fn drain_events(receiver: &mut mpsc::Receiver<ProgressEvent>) -> Vec<ProgressEvent> {
    let mut events = Vec::new();
    while let Ok(event) = receiver.try_recv() {
        events.push(event);
    }
    events
}

fn completed_stats(events: &[ProgressEvent]) -> Option<&vuln_notif::release::ReleaseCounters> {
    events.iter().find_map(|event| match event {
        ProgressEvent::ReleasePhaseCompleted { stats } => Some(stats),
        _ => None,
    })
}

fn deprecated_versions() -> Value {
    json!({
        "versions": [
            {
                "versionKey": {"version": "1.2.3"},
                "isDefault": true,
                "isDeprecated": true,
                "deprecatedReason": "superseded by 1.2.4",
            },
            {
                "versionKey": {"version": "1.2.2"},
                "isDefault": false,
                "isDeprecated": true,
                "deprecatedReason": "superseded by 1.2.3",
            },
        ]
    })
}

fn active_versions() -> Value {
    json!({
        "versions": [{
            "versionKey": {"version": "1.2.3"},
            "isDefault": true,
            "isDeprecated": false,
            "deprecatedReason": "",
        }]
    })
}

#[tokio::test]
async fn sync_records_links_and_idempotent_rerun() {
    let repo_did = "did:plc:test";
    let temp = tempfile::tempdir().expect("temp dir");
    let db = DbHandle::open(temp.path().join("release-parity.db"))
        .await
        .expect("db");
    db.mark_software(SoftwareMark {
        repo_did: repo_did.to_owned(),
        slug: "acme-widget".to_owned(),
        part: "a".to_owned(),
        vendor: "acme".to_owned(),
        product: "widget".to_owned(),
        project_uri: String::new(),
        project_cid: String::new(),
        software_uri: "at://did:plc:test/com.nahdig.software/acme-widget".to_owned(),
        software_cid: "bafysoftware".to_owned(),
    })
    .await
    .expect("mark software");
    db.mark_purl(
        repo_did,
        "pkg:pypi/acme-widget",
        "acme-widget",
        "at://did:plc:test/com.nahdig.purl/acme",
        "bafypurl",
    )
    .await
    .expect("mark purl");
    db.commit().await.expect("commit seed");

    let pds = Arc::new(FakePds::default());
    let publisher = make_publisher(&db, pds.clone()).await;
    let config = ReleaseConfig {
        repo_did: repo_did.to_owned(),
        limit: 0,
        recheck_seconds: 0.0,
    };
    let (events_tx, mut receiver) = mpsc::channel(16);

    // First run: deprecated default creates the deprecated status record.
    let http = Arc::new(routes(vec![
        (
            "https://api.deps.dev/v3/systems/PYPI/packages/acme-widget".to_owned(),
            Reply::Json(deprecated_versions()),
        ),
        json_route("https://pypi.org/pypi/acme-widget/json", PYPI_FIXTURE),
    ]));
    let http: Arc<dyn RegistryHttp> = http.clone();
    let counters = sync_releases_with_http(&publisher, &db, &config, events_tx.clone(), http)
        .await
        .expect("first sync");

    assert_eq!(counters.projects_checked, 1);
    assert_eq!(counters.projects_created, 1);
    assert_eq!(counters.versions_created, 1);
    assert_eq!(counters.channels_created, 1);
    assert_eq!(counters.statuses_created, 1);
    assert_eq!(counters.unchanged, 0);
    assert_eq!(counters.skipped, 0);
    assert_eq!(counters.failures, 0);

    let events = drain_events(&mut receiver);
    assert!(matches!(
        events.first(),
        Some(ProgressEvent::ReleasePhaseStarted { .. })
    ));
    assert_eq!(completed_stats(&events).unwrap().versions_created, 1);

    let project = db
        .get_release_project(repo_did, "acme-widget")
        .await
        .expect("project query")
        .expect("project row");
    assert_eq!(project.purl, "pkg:pypi/acme-widget");
    assert_eq!(project.system, "PYPI");
    assert_eq!(project.latest_version.as_deref(), Some("1.2.3"));
    assert_eq!(project.latest_version_raw.as_deref(), Some("1.2.3"));
    assert_eq!(
        project.project_uri.as_deref(),
        Some("at://did:plc:test/software.release.project/acme-widget")
    );
    assert_eq!(
        project.version_uri.as_deref(),
        Some("at://did:plc:test/software.release.version/acme-widget:1.2.3")
    );
    assert_eq!(
        project.channel_uri.as_deref(),
        Some("at://did:plc:test/software.release.channel/acme-widget:latest")
    );

    let puts = pds.puts.lock().unwrap().clone();
    assert_eq!(puts.len(), 5);
    let artifact_cid = cidv1_raw(BBBB);
    let artifact_url =
        "https://files.pythonhosted.org/packages/ee/ff/acme_widget-1.2.3-py3-none-any.whl";
    let manifest_rkey = digest_rkey(&[
        "manifest",
        "acme-widget",
        &artifact_cid,
        artifact_url,
        "12345",
    ]);

    let (project_collection, project_rkey, project_record) = find_put(&puts, PROJECT_COLLECTION);
    assert_eq!(project_collection.as_str(), PROJECT_COLLECTION);
    assert_eq!(project_rkey, "acme-widget");
    assert_eq!(
        project_record,
        json!({"$type": "software.release.project", "name": "acme-widget"})
    );

    let (_, manifest_rkey_actual, manifest_record) = find_put(&puts, MANIFEST_COLLECTION);
    assert_eq!(manifest_rkey_actual, manifest_rkey);
    assert_eq!(
        manifest_record,
        json!({
            "$type": "software.release.manifest",
            "project": project.project_uri.clone().unwrap(),
            "artifacts": [{
                "$type": "software.release.defs#httpArtifact",
                "fileName": "acme_widget-1.2.3-py3-none-any.whl",
                "url": artifact_url,
                "cid": artifact_cid,
                "size": 12345,
                "mimeType": "application/zip",
            }],
        })
    );

    let (_, version_rkey, version_record) = find_put(&puts, VERSION_COLLECTION);
    assert_eq!(version_rkey, "acme-widget:1.2.3");
    assert_eq!(
        version_record,
        json!({
            "$type": "software.release.version",
            "project": project.project_uri.clone().unwrap(),
            "version": "1.2.3",
            "manifest": {
                "uri": project.manifest_uri.clone().unwrap(),
                "cid": project.manifest_cid.clone().unwrap(),
            },
        })
    );

    let (_, channel_rkey, channel_record) = find_put(&puts, CHANNEL_COLLECTION);
    assert_eq!(channel_rkey, "acme-widget:latest");
    assert_eq!(
        channel_record,
        json!({
            "$type": "software.release.channel",
            "project": project.project_uri.clone().unwrap(),
            "name": "latest",
            "version": {
                "uri": project.version_uri.clone().unwrap(),
                "cid": project.version_cid.clone().unwrap(),
            },
        })
    );

    let (_, _, status_record) = find_put(&puts, STATUS_COLLECTION);
    assert_eq!(
        status_record,
        json!({
            "$type": "software.release.status",
            "subject": project.version_uri.clone().unwrap(),
            "status": "deprecated",
            "kind": "superseded",
            "reason": "superseded by 1.2.4",
        })
    );
    assert!(
        db.get_release_status(
            repo_did,
            project.version_uri.as_ref().unwrap(),
            "deprecated"
        )
        .await
        .expect("status query")
        .is_some()
    );

    let outgoing = |uri: Option<&str>| {
        let db = db.clone();
        let repo_did = repo_did.to_owned();
        let uri = uri.unwrap().to_owned();
        async move {
            db.outgoing(&repo_did, &uri)
                .await
                .expect("outgoing links")
                .into_iter()
                .map(|row| (row.path, row.subject_uri))
                .collect::<Vec<_>>()
        }
    };
    let manifest_links = outgoing(project.manifest_uri.as_deref()).await;
    assert!(manifest_links.contains(&("project".to_owned(), project.project_uri.clone().unwrap())));
    let version_links = outgoing(project.version_uri.as_deref()).await;
    assert!(version_links.contains(&("project".to_owned(), project.project_uri.clone().unwrap())));
    assert!(version_links.contains(&(
        "manifest.uri".to_owned(),
        project.manifest_uri.clone().unwrap()
    )));
    let channel_links = outgoing(project.channel_uri.as_deref()).await;
    assert!(channel_links.contains(&(
        "version.uri".to_owned(),
        project.version_uri.clone().unwrap()
    )));

    // Second run: same version becomes active; transition status is additive.
    let http = Arc::new(routes(vec![(
        "https://api.deps.dev/v3/systems/PYPI/packages/acme-widget".to_owned(),
        Reply::Json(active_versions()),
    )]));
    let http: Arc<dyn RegistryHttp> = http.clone();
    let counters = sync_releases_with_http(&publisher, &db, &config, events_tx.clone(), http)
        .await
        .expect("second sync");
    assert_eq!(counters.statuses_created, 1);
    assert_eq!(counters.versions_created, 0);
    assert_eq!(counters.channels_created, 0);
    assert_eq!(counters.projects_created, 1);
    assert_eq!(counters.unchanged, 0);
    assert_eq!(counters.failures, 0);
    drain_events(&mut receiver);

    let puts = pds.puts.lock().unwrap().clone();
    // The software row has no project ref, so every non-unchanged pass re-puts
    // the idempotent project record.
    assert_eq!(puts.len(), 7);
    assert_eq!(find_puts(&puts, PROJECT_COLLECTION).len(), 2);
    let statuses = find_puts(&puts, STATUS_COLLECTION);
    assert_eq!(statuses.len(), 2);
    let active = statuses
        .iter()
        .find(|put| put.2["status"] == "active")
        .expect("active status");
    assert_eq!(
        active.2,
        json!({
            "$type": "software.release.status",
            "subject": project.version_uri.clone().unwrap(),
            "status": "active",
        })
    );

    // Third run: project/channel/version and both statuses are current.
    let http = Arc::new(routes(vec![(
        "https://api.deps.dev/v3/systems/PYPI/packages/acme-widget".to_owned(),
        Reply::Json(active_versions()),
    )]));
    let http: Arc<dyn RegistryHttp> = http.clone();
    let counters = sync_releases_with_http(&publisher, &db, &config, events_tx, http)
        .await
        .expect("third sync");
    assert_eq!(counters.unchanged, 1);
    assert_eq!(counters.versions_created, 0);
    assert_eq!(counters.channels_created, 0);
    assert_eq!(counters.statuses_created, 0);
    assert_eq!(counters.projects_created, 0);
    assert_eq!(counters.failures, 0);
    assert_eq!(pds.puts.lock().unwrap().len(), 7);
}

// ---------------------------------------------------------------------------
// Canonical identity and release-limit rotation
// ---------------------------------------------------------------------------

async fn seed_canonical_software(
    db: &DbHandle,
    repo_did: &str,
    raw_slug: &str,
    canonical_slug: &str,
) {
    db.mark_software(SoftwareMark {
        repo_did: repo_did.to_owned(),
        slug: raw_slug.to_owned(),
        part: "a".to_owned(),
        vendor: "acme".to_owned(),
        product: "widget".to_owned(),
        project_uri: String::new(),
        project_cid: String::new(),
        software_uri: format!("at://{repo_did}/com.nahdig.software/{raw_slug}"),
        software_cid: "bafysoftware".to_owned(),
    })
    .await
    .expect("mark software");
    db.mark_software_identity(SoftwareIdentityMark {
        repo_did: repo_did.to_owned(),
        raw_slug: raw_slug.to_owned(),
        canonical_slug: canonical_slug.to_owned(),
        identity_key: Some(canonical_slug.to_owned()),
        source: Some("test".to_owned()),
        confidence: Some(1.0),
    })
    .await
    .expect("mark identity");
}

async fn open_release_db(path: &std::path::Path) -> DbHandle {
    DbHandle::open(path).await.expect("db")
}

#[tokio::test]
async fn canonical_aliases_create_one_project_and_no_duplicate_writes() {
    let repo_did = "did:plc:test";
    let temp = tempfile::tempdir().expect("temp dir");
    let db = open_release_db(&temp.path().join("release-canonical.db")).await;
    seed_canonical_software(&db, repo_did, "acme-widget-old", "acme-widget").await;
    seed_canonical_software(&db, repo_did, "acme-widget-new", "acme-widget").await;
    db.mark_purl(
        repo_did,
        "pkg:pypi/acme-widget",
        "acme-widget",
        "at://did:plc:test/com.nahdig.purl/acme",
        "bafypurl",
    )
    .await
    .expect("mark purl");
    db.commit().await.expect("commit seed");

    let pds = Arc::new(FakePds::default());
    let publisher = make_publisher(&db, pds.clone()).await;
    let config = ReleaseConfig {
        repo_did: repo_did.to_owned(),
        limit: 0,
        recheck_seconds: 0.0,
    };
    let depsdev = "https://api.deps.dev/v3/systems/PYPI/packages/acme-widget";
    let pypi = "https://pypi.org/pypi/acme-widget/json";
    let mut cursor = ReleaseCursor::default();
    let (events_tx, _receiver) = mpsc::channel(16);
    let http: Arc<dyn RegistryHttp> = Arc::new(routes(vec![
        json_route(depsdev, DEPSDEV_FIXTURE),
        json_route(pypi, PYPI_FIXTURE),
    ]));
    let counters =
        sync_releases_with_http_cursor(&publisher, &db, &config, &mut cursor, events_tx, http)
            .await
            .expect("canonical sync");

    // Two raw aliases collapse into one canonical candidate and project.
    assert_eq!(counters.projects_checked, 1);
    assert_eq!(counters.projects_created, 1);
    assert_eq!(counters.versions_created, 1);
    assert_eq!(counters.channels_created, 1);
    assert_eq!(counters.skipped, 0);
    assert_eq!(counters.unsupported_no_purl, 0);
    assert_eq!(counters.failures, 0);

    let puts = pds.puts.lock().unwrap().clone();
    assert_eq!(puts.len(), 4, "project, manifest, version, channel");
    let (_, project_rkey, project_value) = find_put(&puts, PROJECT_COLLECTION);
    assert_eq!(project_rkey, "acme-widget");
    assert_eq!(
        project_value,
        json!({"$type": "software.release.project", "name": "acme-widget"})
    );
    // Manifest rkeys are content digests; its project ref must still point at
    // the canonical project record.
    let (_, _, manifest_value) = find_put(&puts, MANIFEST_COLLECTION);
    assert_eq!(
        manifest_value["project"],
        "at://did:plc:test/software.release.project/acme-widget"
    );
    assert_eq!(find_put(&puts, VERSION_COLLECTION).1, "acme-widget:1.2.3");
    assert_eq!(find_put(&puts, CHANNEL_COLLECTION).1, "acme-widget:latest");

    let project = db
        .get_release_project(repo_did, "acme-widget")
        .await
        .expect("project query")
        .expect("canonical project");
    assert_eq!(project.latest_version.as_deref(), Some("1.2.3"));
    assert!(
        db.get_release_project(repo_did, "acme-widget-old")
            .await
            .expect("raw project query")
            .is_none(),
        "raw aliases must not own release projects"
    );

    let state = db
        .get_release_project_state(repo_did, "acme-widget")
        .await
        .expect("state query")
        .expect("canonical state");
    assert_eq!(
        state.canonical_purl.as_deref(),
        Some("pkg:pypi/acme-widget")
    );
    assert_eq!(state.source.as_deref(), Some("pypi"));
    assert!(state.checked_at.is_some());
    assert!(state.unsupported_reason.is_none());

    // Second identical pass is unchanged and writes nothing.
    let mut cursor = ReleaseCursor::default();
    let (events_tx, _receiver) = mpsc::channel(16);
    let http: Arc<dyn RegistryHttp> = Arc::new(routes(vec![
        json_route(depsdev, DEPSDEV_FIXTURE),
        json_route(pypi, PYPI_FIXTURE),
    ]));
    let counters =
        sync_releases_with_http_cursor(&publisher, &db, &config, &mut cursor, events_tx, http)
            .await
            .expect("second canonical sync");
    assert_eq!(counters.unchanged, 1);
    assert_eq!(counters.projects_created, 0);
    assert_eq!(counters.versions_created, 0);
    assert_eq!(counters.channels_created, 0);
    assert_eq!(pds.puts.lock().unwrap().len(), 4);
}

#[tokio::test]
async fn legacy_full_at_uri_purl_slug_joins_and_is_canonicalized() {
    let repo_did = "did:plc:test";
    let temp = tempfile::tempdir().expect("temp dir");
    let db = open_release_db(&temp.path().join("release-legacy-purl.db")).await;
    seed_canonical_software(&db, repo_did, "rhel-8-raw", "red-hat-enterprise-linux").await;
    // Old caches stored the full AT-URI rather than the slug.
    db.mark_purl(
        repo_did,
        "pkg:pypi/acme-widget",
        &format!("at://{repo_did}/com.nahdig.software/red-hat-enterprise-linux"),
        "at://did:plc:test/com.nahdig.purl/acme",
        "bafypurl",
    )
    .await
    .expect("mark legacy purl");
    db.commit().await.expect("commit seed");

    let pds = Arc::new(FakePds::default());
    let publisher = make_publisher(&db, pds.clone()).await;
    let config = ReleaseConfig {
        repo_did: repo_did.to_owned(),
        limit: 0,
        recheck_seconds: 0.0,
    };
    let (events_tx, _receiver) = mpsc::channel(16);
    let http: Arc<dyn RegistryHttp> = Arc::new(routes(vec![
        json_route(
            "https://api.deps.dev/v3/systems/PYPI/packages/acme-widget",
            DEPSDEV_FIXTURE,
        ),
        json_route("https://pypi.org/pypi/acme-widget/json", PYPI_FIXTURE),
    ]));
    let counters = sync_releases_with_http(&publisher, &db, &config, events_tx, http)
        .await
        .expect("legacy purl sync");

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

    let puts = pds.puts.lock().unwrap().clone();
    assert_eq!(
        find_put(&puts, PROJECT_COLLECTION).1,
        "red-hat-enterprise-linux"
    );
    assert_eq!(
        find_put(&puts, VERSION_COLLECTION).1,
        "red-hat-enterprise-linux:1.2.3"
    );
    assert_eq!(
        find_put(&puts, CHANNEL_COLLECTION).1,
        "red-hat-enterprise-linux:latest"
    );
    assert!(
        db.get_release_project(repo_did, "rhel-8-raw")
            .await
            .expect("raw project query")
            .is_none()
    );
}

#[tokio::test]
async fn release_limit_rotation_reaches_later_projects() {
    let repo_did = "did:plc:test";
    let temp = tempfile::tempdir().expect("temp dir");
    let db = open_release_db(&temp.path().join("release-rotation.db")).await;
    for slug in ["acme-a", "acme-b", "acme-c"] {
        seed_canonical_software(&db, repo_did, &format!("{slug}-raw"), slug).await;
    }
    db.commit().await.expect("commit seed");

    let pds = Arc::new(FakePds::default());
    let publisher = make_publisher(&db, pds.clone()).await;
    let config = ReleaseConfig {
        repo_did: repo_did.to_owned(),
        limit: 1,
        recheck_seconds: 0.0,
    };
    let fake = Arc::new(FakeHttp::default());
    let http: Arc<dyn RegistryHttp> = fake.clone();
    let mut cursor = ReleaseCursor::default();
    let (events_tx, mut receiver) = mpsc::channel(16);

    let first = sync_releases_with_http_cursor(
        &publisher,
        &db,
        &config,
        &mut cursor,
        events_tx.clone(),
        http.clone(),
    )
    .await
    .expect("first page");
    assert_eq!(first.projects_checked, 1);
    assert_eq!(first.unsupported_no_purl, 1);
    assert_eq!(first.failures, 0);
    assert_eq!(cursor.after_slug.as_deref(), Some("acme-a"));
    assert!(
        db.get_release_project_state(repo_did, "acme-a")
            .await
            .expect("state a")
            .is_some()
    );

    let second = sync_releases_with_http_cursor(
        &publisher,
        &db,
        &config,
        &mut cursor,
        events_tx.clone(),
        http.clone(),
    )
    .await
    .expect("second page");
    assert_eq!(second.unsupported_no_purl, 1);
    assert_eq!(cursor.after_slug.as_deref(), Some("acme-b"));
    assert!(
        db.get_release_project_state(repo_did, "acme-b")
            .await
            .expect("state b")
            .is_some()
    );
    assert!(
        db.get_release_project_state(repo_did, "acme-c")
            .await
            .expect("state c")
            .is_none(),
        "the later project is not starved behind the first page"
    );

    let third =
        sync_releases_with_http_cursor(&publisher, &db, &config, &mut cursor, events_tx, http)
            .await
            .expect("third page");
    assert_eq!(third.unsupported_no_purl, 1);
    assert_eq!(cursor.after_slug.as_deref(), Some("acme-c"));
    assert!(
        db.get_release_project_state(repo_did, "acme-c")
            .await
            .expect("state c")
            .is_some()
    );

    let events = drain_events(&mut receiver);
    assert_eq!(completed_stats(&events).unwrap().unsupported_no_purl, 1);
    assert!(fake.calls().is_empty(), "no source calls without a purl");
    assert!(pds.puts.lock().unwrap().is_empty());
}

#[tokio::test]
async fn no_purl_os_project_is_typed_unsupported_not_a_failure() {
    let repo_did = "did:plc:test";
    let temp = tempfile::tempdir().expect("temp dir");
    let db = open_release_db(&temp.path().join("release-no-purl.db")).await;
    seed_canonical_software(&db, repo_did, "rhel-8-raw", "red-hat-enterprise-linux").await;
    // `rpm` is a distro purl type, not a deps.dev release ecosystem.
    db.mark_purl(
        repo_did,
        "pkg:rpm/redhat/enterprise_linux",
        "red-hat-enterprise-linux",
        "at://did:plc:test/com.nahdig.purl/enterprise-linux",
        "bafypurl",
    )
    .await
    .expect("mark rpm purl");
    db.commit().await.expect("commit seed");

    let pds = Arc::new(FakePds::default());
    let publisher = make_publisher(&db, pds.clone()).await;
    let config = ReleaseConfig {
        repo_did: repo_did.to_owned(),
        limit: 0,
        recheck_seconds: 0.0,
    };
    let (events_tx, mut receiver) = mpsc::channel(16);
    let fake = Arc::new(FakeHttp::default());
    let http: Arc<dyn RegistryHttp> = fake.clone();
    let counters = sync_releases_with_http(&publisher, &db, &config, events_tx, http)
        .await
        .expect("no-purl phase still completes");

    assert_eq!(counters.projects_checked, 1);
    assert_eq!(counters.unsupported_no_purl, 1);
    assert_eq!(counters.skipped, 0);
    assert_eq!(counters.failures, 0);
    assert_eq!(counters.projects_created, 0);
    let events = drain_events(&mut receiver);
    assert_eq!(
        completed_stats(&events).unwrap().unsupported_no_purl,
        1,
        "phase completion carries the typed counter"
    );
    assert!(fake.calls().is_empty());
    assert!(pds.puts.lock().unwrap().is_empty());

    let state = db
        .get_release_project_state(repo_did, "red-hat-enterprise-linux")
        .await
        .expect("state query")
        .expect("unsupported state");
    assert!(state.canonical_purl.is_none());
    assert!(state.checked_at.is_some());
    assert_eq!(state.unsupported_reason.as_deref(), Some("no_purl"));
}