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

johnandersen777.bsky.social/vuln-notif

0
0
main
986 lines · 29.8 KB Raw History
//! Golden tests for deterministic canonical software identity.

use std::collections::BTreeSet;

use serde_json::{Value, json};
use vuln_notif::identity::aliases::{AliasTable, aliases};
use vuln_notif::identity::observe::{observations_from_cve, parse_cpe};
use vuln_notif::identity::{
    CanonicalIdentity, IdentityClass, ObservedProduct, canonical_slug, canonicalize,
    canonicalize_all, identity_key_for, normalize_token, split_channel_version, truncate64,
};

const RHEL: &str = "red-hat-enterprise-linux";

fn observed(vendor: &str, product: &str) -> ObservedProduct {
    ObservedProduct {
        source: "test".to_owned(),
        vendor: vendor.to_owned(),
        product: product.to_owned(),
        ..ObservedProduct::default()
    }
}

fn with_version(observation: ObservedProduct, version: &str) -> ObservedProduct {
    ObservedProduct {
        version: Some(version.to_owned()),
        ..observation
    }
}

fn with_part(observation: ObservedProduct, part: &str) -> ObservedProduct {
    ObservedProduct {
        part: Some(part.to_owned()),
        ..observation
    }
}

fn from_cpe(raw: &str) -> ObservedProduct {
    parse_cpe(raw)
        .unwrap_or_else(|| panic!("parse {raw}"))
        .to_observed("test")
}

fn canonical(observation: &ObservedProduct) -> CanonicalIdentity {
    canonicalize(observation).unwrap_or_else(|| panic!("no identity for {observation:?}"))
}

#[allow(clippy::too_many_arguments)]
fn assert_identity(
    observation: &ObservedProduct,
    class: IdentityClass,
    vendor: &str,
    family: &str,
    slug: &str,
    channel: Option<&str>,
    version: Option<&str>,
) {
    let identity = canonical(observation);
    assert_eq!(identity.class, class, "{observation:?}");
    assert_eq!(identity.canonical_vendor, vendor, "{observation:?}");
    assert_eq!(identity.canonical_family, family, "{observation:?}");
    assert_eq!(identity.slug, slug, "{observation:?}");
    assert_eq!(identity.channel.as_deref(), channel, "{observation:?}");
    assert_eq!(identity.version.as_deref(), version, "{observation:?}");
    assert_eq!(
        identity.identity_key,
        format!("{}:{vendor}:{family}", class.as_str()),
        "{observation:?}"
    );
}

#[test]
fn rhel_variants_collapse_to_one_project() {
    let cases: [(&str, &str, Option<&str>, Option<&str>); 21] = [
        ("enterprise_linux", "6.0", Some("6"), None),
        ("enterprise_linux", "7.0", Some("7"), None),
        ("enterprise_linux", "8.0", Some("8"), None),
        ("enterprise_linux", "9.0", Some("9"), None),
        ("enterprise_linux", "10.0", Some("10"), Some("10.0")),
        ("enterprise_linux", "9.4", Some("9"), Some("9.4")),
        ("enterprise_linux", "8.10", Some("8"), Some("8.10")),
        ("enterprise_linux_eus", "8", Some("8-eus"), None),
        ("enterprise_linux_aus", "9", Some("9-aus"), None),
        ("enterprise_linux_tus", "9", Some("9-tus"), None),
        ("enterprise_linux_sap", "9", Some("9-sap"), None),
        ("enterprise_linux_rt", "9", Some("9-rt"), None),
        ("enterprise_linux_nfv", "9", Some("9-nfv"), None),
        ("enterprise_linux_av", "9", Some("9-av"), None),
        ("enterprise_linux_crb", "9", Some("9-crb"), None),
        ("enterprise_linux_desktop", "9", Some("9-desktop"), None),
        (
            "enterprise_linux_workstation",
            "9",
            Some("9-workstation"),
            None,
        ),
        ("enterprise_linux_hpc", "9", Some("9-hpc"), None),
        ("rhel_els", "6", Some("6-els"), None),
        ("enterprise_linux_for_sap", "9", Some("9-sap"), None),
        ("codeready_linux_builder", "8", Some("8"), None),
    ];
    for (product, version, channel, version_ref) in cases {
        let observation = with_version(observed("redhat", product), version);
        assert_identity(
            &observation,
            IdentityClass::Os,
            "red-hat",
            RHEL,
            RHEL,
            channel,
            version_ref,
        );
    }
}

#[test]
fn rhel_arch_tokens_append_to_channel() {
    let base = with_version(observed("redhat", "enterprise_linux"), "9.4");
    for arch in ["aarch64", "ppc64le", "ppc64", "s390x"] {
        let observation = ObservedProduct {
            target_hw: Some(arch.to_owned()),
            ..base.clone()
        };
        let channel = format!("9-{arch}");
        assert_identity(
            &observation,
            IdentityClass::Os,
            "red-hat",
            RHEL,
            RHEL,
            Some(&channel),
            Some("9.4"),
        );
    }
    let default_arch = ObservedProduct {
        target_hw: Some("x86_64".to_owned()),
        ..base
    };
    assert_identity(
        &default_arch,
        IdentityClass::Os,
        "red-hat",
        RHEL,
        RHEL,
        Some("9"),
        Some("9.4"),
    );
}

#[test]
fn rhel_legacy_text_and_cpe_variants_merge() {
    assert_identity(
        &from_cpe("cpe:2.3:o:redhat:enterprise_linux:8.0:*:*:*:*:*:*:*"),
        IdentityClass::Os,
        "red-hat",
        RHEL,
        RHEL,
        Some("8"),
        None,
    );
    assert_identity(
        &from_cpe("cpe:/o:redhat:rhel_els:6"),
        IdentityClass::Os,
        "red-hat",
        RHEL,
        RHEL,
        Some("6-els"),
        None,
    );
    assert_identity(
        &with_version(observed("Red Hat", "Red Hat Enterprise Linux 9"), "9.4"),
        IdentityClass::Os,
        "red-hat",
        RHEL,
        RHEL,
        Some("9"),
        Some("9.4"),
    );
    assert_identity(
        &with_version(observed("redhat", "redhat_enterprise_linux"), "9.0"),
        IdentityClass::Os,
        "red-hat",
        RHEL,
        RHEL,
        Some("9"),
        None,
    );
    assert_identity(
        &with_version(observed("redhat", "redhat_enterprise_linux_eus"), "8"),
        IdentityClass::Os,
        "red-hat",
        RHEL,
        RHEL,
        Some("8-eus"),
        None,
    );
    assert_identity(
        &with_version(observed("redhat", "redhat_rhel_els"), "6"),
        IdentityClass::Os,
        "red-hat",
        RHEL,
        RHEL,
        Some("6-els"),
        None,
    );
    assert_identity(
        &with_version(observed("redhat", "red_hat_enterprise_linux"), "9.4"),
        IdentityClass::Os,
        "red-hat",
        RHEL,
        RHEL,
        Some("9"),
        Some("9.4"),
    );
    assert_identity(
        &with_version(observed("redhat", "enterprise_linux_for_x86_64"), "8"),
        IdentityClass::Os,
        "red-hat",
        RHEL,
        RHEL,
        Some("8"),
        None,
    );

    // `part` is excluded from the identity key: the `a` observation merges
    // into the curated `o` class.
    let part_o = from_cpe("cpe:2.3:o:redhat:enterprise_linux:8.0:*:*:*:*:*:*:*");
    let part_a = from_cpe("cpe:2.3:a:redhat:enterprise_linux:8.0:*:*:*:*:*:*:*");
    let identities = canonicalize_all(&[part_o, part_a]);
    assert_eq!(identities.len(), 1);
    assert_eq!(
        identities[0].identity_key,
        "os:red-hat:red-hat-enterprise-linux"
    );
    assert_eq!(identities[0].slug, RHEL);
}

#[test]
fn keycloak_build_sso_erlang_gleam_and_mbedtls() {
    assert_identity(
        &with_part(
            with_version(observed("redhat", "build_of_keycloak"), "26.0"),
            "a",
        ),
        IdentityClass::App,
        "red-hat",
        "build-of-keycloak",
        "red-hat-build-of-keycloak",
        Some("26"),
        Some("26.0"),
    );
    assert_identity(
        &with_part(
            with_version(observed("redhat", "red_hat_single_sign_on"), "7"),
            "a",
        ),
        IdentityClass::App,
        "red-hat",
        "single-sign-on",
        "red-hat-single-sign-on",
        Some("7"),
        None,
    );
    assert_identity(
        &with_part(with_version(observed("erlang", "erlang_otp"), "27.0"), "a"),
        IdentityClass::App,
        "erlang",
        "erlang-otp",
        "erlang-otp",
        Some("27"),
        Some("27.0"),
    );
    assert_identity(
        &with_part(with_version(observed("gleam", "gleam"), "1.4.1"), "a"),
        IdentityClass::App,
        "gleam-lang",
        "gleam",
        "gleam-lang-gleam",
        Some("1"),
        Some("1.4.1"),
    );
    assert_identity(
        &with_part(with_version(observed("arm", "mbed_tls"), "2.28.8"), "a"),
        IdentityClass::App,
        "trustedfirmware",
        "mbedtls",
        "trustedfirmware-mbedtls",
        Some("2"),
        Some("2.28.8"),
    );
    assert_identity(
        &with_part(
            with_version(observed("AVB Disc Soft", "daemon_tools_lite"), "7.1.0"),
            "a",
        ),
        IdentityClass::App,
        "disc-soft",
        "daemon-tools",
        "disc-soft-daemon-tools",
        Some("7"),
        Some("7.1.0"),
    );
}

#[test]
fn window_iphone_ubuntu_centos_and_fedora() {
    // Windows is curated OS even when the CPE part is `a`.
    assert_identity(
        &with_part(observed("Microsoft", "Windows 11"), "a"),
        IdentityClass::Os,
        "microsoft",
        "windows",
        "microsoft-windows",
        Some("11"),
        None,
    );
    assert_identity(
        &with_part(with_version(observed("microsoft", "windows"), "11"), "a"),
        IdentityClass::Os,
        "microsoft",
        "windows",
        "microsoft-windows",
        Some("11"),
        None,
    );

    // Unlisted product families never split trailing text as a version.
    assert_identity(
        &with_part(observed("Apple", "iPhone 15"), "h"),
        IdentityClass::Hardware,
        "apple",
        "iphone-15",
        "apple-iphone-15",
        None,
        None,
    );

    assert_identity(
        &with_version(observed("Canonical", "Ubuntu Linux"), "20.04"),
        IdentityClass::Os,
        "ubuntu",
        "ubuntu",
        "ubuntu",
        Some("20-04"),
        Some("20.04"),
    );

    let stream_text = with_version(observed("CentOS", "CentOS Stream"), "9");
    let stream_text_version = observed("centos", "centos_stream_9");
    let streams = canonicalize_all(&[stream_text, stream_text_version]);
    assert_eq!(streams.len(), 1);
    assert_eq!(streams[0].canonical_family, "centos-stream");
    assert_eq!(streams[0].slug, "centos-stream");
    assert_eq!(streams[0].channel.as_deref(), Some("9"));
    assert_eq!(streams[0].class, IdentityClass::Os);

    let fedora_text = with_version(observed("fedoraproject", "Fedora"), "40");
    let fedora_trailing = observed("fedoraproject", "fedora_40");
    let fedoras = canonicalize_all(&[fedora_text, fedora_trailing]);
    assert_eq!(fedoras.len(), 1);
    assert_eq!(fedoras[0].canonical_vendor, "fedora");
    assert_eq!(fedoras[0].slug, "fedora");
    assert_eq!(fedoras[0].channel.as_deref(), Some("40"));
}

#[test]
fn hardware_and_firmware_classes() {
    assert_identity(
        &with_part(observed("Acme", "Widget"), "h"),
        IdentityClass::Hardware,
        "acme",
        "widget",
        "acme-widget",
        None,
        None,
    );
    assert_identity(
        &observed("Acme", "Router Firmware"),
        IdentityClass::Firmware,
        "acme",
        "router-firmware",
        "acme-router-firmware",
        None,
        None,
    );
}

#[test]
fn placeholder_identities_are_dropped() {
    for (vendor, product) in [
        ("n/a", "n/a"),
        ("n/a", "product"),
        ("vendor", "n/a"),
        ("any", "thing"),
        ("unknown", "thing"),
        ("*", "*"),
        ("-", "-"),
        ("vendor", "unknown"),
        ("", "product"),
        ("vendor", ""),
    ] {
        assert_eq!(
            canonicalize(&observed(vendor, product)),
            None,
            "{vendor}/{product}"
        );
    }
}

#[test]
fn vendor_and_product_aliases_merge() {
    let inputs = [
        with_version(observed("Red Hat", "Red Hat Enterprise Linux 9"), "9.0"),
        with_version(observed("redhat", "enterprise_linux"), "9.0"),
        with_version(observed("red_hat", "enterprise_linux_9"), "9.0"),
    ];
    let identities = canonicalize_all(&inputs);
    assert_eq!(identities.len(), 1);
    assert_eq!(identities[0].canonical_vendor, "red-hat");
    assert_eq!(identities[0].canonical_family, RHEL);
    assert_eq!(identities[0].slug, RHEL);
    assert_eq!(identities[0].channel.as_deref(), Some("9"));

    let table = aliases();
    assert_eq!(
        table.vendors.get("redhat").map(String::as_str),
        Some("red-hat")
    );
    assert_eq!(
        table.vendors.get("red-hat").map(String::as_str),
        Some("red-hat")
    );
    assert_eq!(
        table.vendors.get("fedoraproject").map(String::as_str),
        Some("fedora")
    );
    assert_eq!(
        table.vendors.get("gleam").map(String::as_str),
        Some("gleam-lang")
    );
    assert_eq!(
        table.products.get("build-keycloak").map(String::as_str),
        Some("build-of-keycloak")
    );
    assert_eq!(
        table
            .products
            .get("red-hat-single-sign-on")
            .map(String::as_str),
        Some("single-sign-on")
    );
    assert_eq!(
        table.products.get("daemon-tools-lite").map(String::as_str),
        Some("daemon-tools")
    );
    assert_eq!(table.class_overrides.get(RHEL), Some(&IdentityClass::Os));
}

#[test]
fn collisions_are_order_independent_and_use_stable_hashes() {
    let application = with_part(observed("Acme", "Widget"), "a");
    let hardware = with_part(observed("Acme", "Widget"), "h");
    let identities = canonicalize_all(&[application.clone(), hardware.clone()]);
    assert_eq!(identities.len(), 2);
    let application_identity = identities
        .iter()
        .find(|identity| identity.class == IdentityClass::App)
        .expect("application identity");
    let hardware_identity = identities
        .iter()
        .find(|identity| identity.class == IdentityClass::Hardware)
        .expect("hardware identity");
    assert_eq!(application_identity.slug, "acme-widget");
    assert_eq!(hardware_identity.slug, "acme-widget-586dad");
    assert_eq!(canonicalize_all(&[hardware, application]), identities);
}

#[test]
fn truncation_collisions_use_stable_hash_suffix() {
    let suffix = "x".repeat(80);
    let alpha = observed("acme", &format!("widget-{suffix}-alpha"));
    let beta = observed("acme", &format!("widget-{suffix}-beta"));
    let identities = canonicalize_all(&[alpha.clone(), beta.clone()]);
    assert_eq!(identities.len(), 2);
    let owner = identities
        .iter()
        .find(|identity| identity.slug == "acme-widget")
        .expect("identity owning the truncated base slug");
    let suffixed = identities
        .iter()
        .find(|identity| identity.slug != "acme-widget")
        .expect("identity with a collision suffix");
    assert_eq!(
        owner.identity_key,
        format!("app:acme:widget-{suffix}-alpha")
    );
    assert_eq!(suffixed.slug, "acme-widget-0a56f7");
    assert!(suffixed.slug.len() <= 64);
    assert_eq!(canonicalize_all(&[beta, alpha]), identities);
}

#[test]
fn truncate64_cuts_at_hyphen_boundary() {
    assert_eq!(truncate64("short-slug"), "short-slug");
    let hyphenated = format!("{}-{}", "a".repeat(60), "b".repeat(20));
    assert_eq!(truncate64(&hyphenated), "a".repeat(60));
    let solid = "c".repeat(80);
    assert_eq!(truncate64(&solid), "c".repeat(64));
    let long_slug = canonical_slug("acme", &format!("widget-{}", "x".repeat(80)));
    assert!(long_slug.len() <= 64);
    assert!(!long_slug.ends_with('-'));
}

#[test]
fn token_and_slug_helpers() {
    assert_eq!(normalize_token("Red Hat"), "red-hat");
    assert_eq!(normalize_token("n/a"), "n-a");
    assert_eq!(normalize_token("*"), "");
    assert_eq!(normalize_token(r"enterprise\_linux"), "enterprise-linux");
    assert_eq!(normalize_token("RedHat"), "redhat");

    assert_eq!(
        canonical_slug("Red Hat", "Enterprise Linux"),
        "red-hat-enterprise-linux"
    );
    assert_eq!(
        canonical_slug("red-hat", "red-hat-enterprise-linux"),
        "red-hat-enterprise-linux"
    );
    assert_eq!(canonical_slug("ubuntu", "ubuntu"), "ubuntu");
}

#[test]
fn channel_version_split_rules() {
    assert_eq!(split_channel_version("9"), (Some("9".to_owned()), None));
    assert_eq!(split_channel_version("9.0"), (Some("9".to_owned()), None));
    assert_eq!(
        split_channel_version("9.4"),
        (Some("9".to_owned()), Some("9.4".to_owned()))
    );
    assert_eq!(
        split_channel_version("8.10"),
        (Some("8".to_owned()), Some("8.10".to_owned()))
    );
    assert_eq!(
        split_channel_version("10.0"),
        (Some("10".to_owned()), Some("10.0".to_owned()))
    );
    assert_eq!(
        split_channel_version("26.0"),
        (Some("26".to_owned()), Some("26.0".to_owned()))
    );
    assert_eq!(
        split_channel_version("20.04"),
        (Some("20".to_owned()), Some("20.04".to_owned()))
    );
    assert_eq!(split_channel_version(""), (None, None));
}

#[test]
fn cve_observations_collapse_to_one_project() {
    let cve = json!({
        "configurations": [{
            "nodes": [{"cpeMatch": [
                {"criteria": "cpe:2.3:o:redhat:enterprise_linux:8.0:*:*:*:*:*:*:*",
                 "versionStartIncluding": "8.0", "versionEndExcluding": "8.6"},
                {"criteria": "cpe:2.3:o:redhat:enterprise_linux:8.0:*:*:*:*:*:*:*",
                 "versionStartIncluding": "8.0", "versionEndExcluding": "8.6"}
            ]}]
        }],
        "affected": [{
            "vendor": "Red Hat",
            "product": "Red Hat Enterprise Linux 8",
            "cpes": ["cpe:2.3:o:redhat:enterprise_linux:8.0:*:*:*:*:*:*:*"]
        }]
    });
    let observations = observations_from_cve(&cve);
    // Deduped criteria + affected entry + affected CPE.
    assert_eq!(observations.len(), 3);
    let identities = canonicalize_all(&observations);
    assert_eq!(identities.len(), 1);
    assert_eq!(identities[0].slug, RHEL);
    assert_eq!(
        identities[0].identity_key,
        "os:red-hat:red-hat-enterprise-linux"
    );
    assert_eq!(identities[0].channel.as_deref(), Some("8"));
}

#[test]
fn purl2cpe_full_component_parser_keeps_compact_key() {
    use vuln_notif::db::purl2cpe::{cpe_components, cpe_product_key};

    assert_eq!(
        cpe_product_key("cpe:2.3:a:acme:widget:1.0:*:*:*:*:*:*:*").as_deref(),
        Some("a:acme:widget")
    );
    let components = cpe_components("cpe:/o:redhat:rhel_els:6").expect("parsed components");
    assert_eq!(components.vendor.as_deref(), Some("redhat"));
    assert_eq!(components.product.as_deref(), Some("rhel_els"));
    assert_eq!(components.version.as_deref(), Some("6"));
    assert_eq!(components.part.as_deref(), Some("o"));
}

fn load_fixture(name: &str) -> Value {
    let path = format!(
        "{}/tests/fixtures/identity/{name}",
        env!("CARGO_MANIFEST_DIR")
    );
    let raw = std::fs::read_to_string(&path)
        .unwrap_or_else(|error| panic!("read fixture {path}: {error}"));
    serde_json::from_str(&raw).unwrap_or_else(|error| panic!("parse fixture {path}: {error}"))
}

fn strings(value: &Value) -> BTreeSet<String> {
    value
        .as_array()
        .unwrap_or_else(|| panic!("expected array, got {value}"))
        .iter()
        .map(|item| {
            item.as_str()
                .unwrap_or_else(|| panic!("expected string, got {item}"))
                .to_owned()
        })
        .collect()
}

#[test]
fn rhel_golden_cves_converge_to_one_project_and_key() {
    let cves = load_fixture("rhel_cves.json");
    let expected = load_fixture("rhel_expected.json");
    let project = expected["project"].as_str().expect("project");
    let key = expected["identity_key"].as_str().expect("identity key");
    let cves = cves.as_array().expect("CVE array");
    let expected_cves = expected["cves"].as_array().expect("expected CVE array");
    assert_eq!(cves.len(), expected_cves.len(), "fixture coverage");

    let mut all_channels = BTreeSet::new();
    let mut all_versions = BTreeSet::new();
    for expected_cve in expected_cves {
        let id = expected_cve["id"].as_str().expect("expected CVE id");
        let cve = cves
            .iter()
            .find(|cve| cve["id"].as_str() == Some(id))
            .unwrap_or_else(|| panic!("missing CVE fixture {id}"));

        let observations = observations_from_cve(cve);
        assert!(!observations.is_empty(), "{id}: no observations");
        for observation in &observations {
            let identity = canonicalize(observation)
                .unwrap_or_else(|| panic!("{id}: no identity for {observation:?}"));
            assert_eq!(identity.canonical_family, project, "{id}");
            assert_eq!(identity.slug, project, "{id}");
            assert_eq!(identity.identity_key, key, "{id}");
            assert_eq!(identity.class, IdentityClass::Os, "{id}");
        }

        let identities = canonicalize_all(&observations);
        let keys: BTreeSet<&str> = identities
            .iter()
            .map(|identity| identity.identity_key.as_str())
            .collect();
        assert_eq!(keys, BTreeSet::from([key]), "{id}: one identity key");

        let channels: BTreeSet<String> = identities
            .iter()
            .filter_map(|identity| identity.channel.clone())
            .collect();
        let versions: BTreeSet<String> = identities
            .iter()
            .filter_map(|identity| identity.version.clone())
            .collect();
        assert_eq!(
            channels,
            strings(&expected_cve["channels"]),
            "{id}: channels"
        );
        assert_eq!(
            versions,
            strings(&expected_cve["versions"]),
            "{id}: versions"
        );

        let mut reversed = observations.clone();
        reversed.reverse();
        assert_eq!(canonicalize_all(&reversed), identities, "{id}: order");

        all_channels.extend(channels);
        all_versions.extend(versions);
    }

    for channel in [
        "6",
        "6-els",
        "7",
        "8",
        "8-eus",
        "9",
        "9-aarch64",
        "9-aus",
        "9-ppc64",
        "9-ppc64le",
        "9-rt",
        "9-sap",
        "9-s390x",
        "9-tus",
        "10",
    ] {
        assert!(
            all_channels.contains(channel),
            "goldens miss channel {channel}"
        );
    }
    for version in ["8.4", "8.10", "9.2", "9.4", "10.0"] {
        assert!(
            all_versions.contains(version),
            "goldens miss version {version}"
        );
    }
}

#[test]
fn identity_key_for_returns_key_without_collisions() {
    assert_eq!(
        identity_key_for(&with_version(
            observed("Red Hat", "Red Hat Enterprise Linux 9"),
            "9.4"
        ))
        .as_deref(),
        Some("os:red-hat:red-hat-enterprise-linux")
    );
    assert_eq!(
        identity_key_for(&observed("Acme", "Widget")).as_deref(),
        Some("app:acme:widget")
    );
    assert_eq!(identity_key_for(&observed("n/a", "n/a")), None);
}

#[test]
fn vendor_spellings_split_and_converge() {
    let observations: Vec<ObservedProduct> = [
        "Red Hat",
        "redhat",
        "red_hat",
        "Red Hat, Inc.",
        "redhat, inc.",
    ]
    .iter()
    .map(|vendor| with_version(observed(vendor, "enterprise_linux"), "9.0"))
    .collect();
    let identities = canonicalize_all(&observations);
    assert_eq!(identities.len(), 1);
    assert_eq!(identities[0].canonical_vendor, "red-hat");
    assert_eq!(identities[0].canonical_family, RHEL);
    assert_eq!(
        identities[0].identity_key,
        "os:red-hat:red-hat-enterprise-linux"
    );
    assert_eq!(canonicalize_all(&observations[..3]).len(), 1);
}

#[test]
fn product_aliases_split_streams_and_versions() {
    assert_identity(
        &with_version(observed("redhat", "openshift_container_platform"), "4.12"),
        IdentityClass::App,
        "red-hat",
        "openshift-container-platform",
        "red-hat-openshift-container-platform",
        Some("4"),
        Some("4.12"),
    );
    let openshift = canonicalize_all(&[
        with_version(observed("redhat", "openshift"), "4.12"),
        with_version(observed("redhat", "openshift_container_platform"), "4.12"),
    ]);
    assert_eq!(openshift.len(), 1);
    assert_eq!(
        openshift[0].canonical_family,
        "openshift-container-platform"
    );

    assert_identity(
        &with_version(observed("Red Hat", "Red Hat build of Keycloak"), "26.0"),
        IdentityClass::App,
        "red-hat",
        "build-of-keycloak",
        "red-hat-build-of-keycloak",
        Some("26"),
        Some("26.0"),
    );
    assert_identity(
        &with_version(observed("redhat", "red_hat_sso"), "7.6"),
        IdentityClass::App,
        "red-hat",
        "single-sign-on",
        "red-hat-single-sign-on",
        Some("7"),
        Some("7.6"),
    );
    assert_identity(
        &with_version(
            observed("redhat", "jboss_enterprise_application_platform"),
            "8.0",
        ),
        IdentityClass::App,
        "red-hat",
        "jboss-eap",
        "red-hat-jboss-eap",
        Some("8"),
        None,
    );
    assert_identity(
        &with_version(observed("redhat", "ansible_automation_platform"), "2.4"),
        IdentityClass::App,
        "red-hat",
        "ansible-automation-platform",
        "red-hat-ansible-automation-platform",
        Some("2"),
        Some("2.4"),
    );

    let erlang = canonicalize_all(&[
        observed("erlang", "Erlang"),
        observed("erlang", "erlang_otp"),
    ]);
    assert_eq!(erlang.len(), 1);
    assert_eq!(erlang[0].identity_key, "app:erlang:erlang-otp");
    assert_eq!(erlang[0].slug, "erlang-otp");
}

#[test]
fn platform_goldens_cover_os_and_hardware() {
    assert_identity(
        &observed("Microsoft", "Windows 11"),
        IdentityClass::Os,
        "microsoft",
        "windows",
        "microsoft-windows",
        Some("11"),
        None,
    );
    assert_identity(
        &with_part(observed("Apple", "iPhone 15"), "h"),
        IdentityClass::Hardware,
        "apple",
        "iphone-15",
        "apple-iphone-15",
        None,
        None,
    );
    assert_identity(
        &observed("Canonical", "Ubuntu 20.04"),
        IdentityClass::Os,
        "ubuntu",
        "ubuntu",
        "ubuntu",
        Some("20-04"),
        Some("20.04"),
    );
    assert_identity(
        &observed("CentOS", "CentOS Stream 9"),
        IdentityClass::Os,
        "centos",
        "centos-stream",
        "centos-stream",
        Some("9"),
        None,
    );
    assert_identity(
        &observed("CentOS", "CentOS Linux 7"),
        IdentityClass::Os,
        "centos",
        "centos",
        "centos",
        Some("7"),
        None,
    );
    assert_identity(
        &observed("fedoraproject", "Fedora Linux 40"),
        IdentityClass::Os,
        "fedora",
        "fedora",
        "fedora",
        Some("40"),
        None,
    );
    assert_identity(
        &with_part(observed("Acme", "Widget"), "h"),
        IdentityClass::Hardware,
        "acme",
        "widget",
        "acme-widget",
        None,
        None,
    );
    assert_identity(
        &with_part(observed("Acme", "Router Firmware"), "h"),
        IdentityClass::Firmware,
        "acme",
        "router-firmware",
        "acme-router-firmware",
        None,
        None,
    );
}

#[test]
fn cpe22_packed_edition_is_parsed() {
    let cpe = parse_cpe("cpe:/a:acme:widget:1.0:upd:~sw_ed~target_sw~target_hw~other:en").unwrap();
    assert_eq!(cpe.edition, None);
    assert_eq!(cpe.sw_edition.as_deref(), Some("sw_ed"));
    assert_eq!(cpe.target_sw.as_deref(), Some("target_sw"));
    assert_eq!(cpe.target_hw.as_deref(), Some("target_hw"));
    assert_eq!(cpe.other.as_deref(), Some("other"));
}

#[test]
fn canonicalize_all_is_order_independent_for_mixed_inputs() {
    let mut observations = vec![
        with_part(
            with_version(observed("redhat", "enterprise_linux_eus"), "8.4"),
            "o",
        ),
        with_part(
            with_version(observed("Red Hat", "Red Hat Enterprise Linux 9"), "9.4"),
            "a",
        ),
        with_part(observed("Acme", "Widget"), "a"),
        with_part(observed("Acme", "Widget"), "h"),
        with_version(observed("fedoraproject", "Fedora 40"), "40"),
        with_version(observed("Canonical", "Ubuntu 20.04"), "20.04"),
        observed("Apple", "iPhone 15"),
    ];
    let forward = canonicalize_all(&observations);
    observations.reverse();
    assert_eq!(canonicalize_all(&observations), forward);
    observations.rotate_left(3);
    assert_eq!(canonicalize_all(&observations), forward);
}

#[test]
fn alias_table_rejects_duplicates_and_invalid_keys() {
    let duplicate_vendor = r#"{
        "vendors": {"acme": "acme", "acme": "acme"},
        "products": {"widget": "widget"},
        "families": {"widget": "acme"},
        "versioned_families": ["widget"],
        "class_overrides": {"widget": "app"}
    }"#;
    let error = AliasTable::from_json(duplicate_vendor).expect_err("duplicate vendor");
    assert!(error.contains("duplicate key"), "{error}");

    let duplicate_versioned = r#"{
        "vendors": {"acme": "acme"},
        "products": {"widget": "widget"},
        "families": {"widget": "acme"},
        "versioned_families": ["widget", "widget"],
        "class_overrides": {"widget": "app"}
    }"#;
    let error = AliasTable::from_json(duplicate_versioned).expect_err("duplicate family");
    assert!(error.contains("duplicate entry"), "{error}");

    let invalid_key = r#"{
        "vendors": {"Acme Inc": "acme"},
        "products": {"widget": "widget"},
        "families": {"widget": "acme"},
        "versioned_families": ["widget"],
        "class_overrides": {"widget": "app"}
    }"#;
    let error = AliasTable::from_json(invalid_key).expect_err("invalid key");
    assert!(error.contains("not normalized"), "{error}");

    let unknown_family = r#"{
        "vendors": {"acme": "acme"},
        "products": {"widget": "missing"},
        "families": {"widget": "acme"},
        "versioned_families": ["widget"],
        "class_overrides": {"widget": "app"}
    }"#;
    let error = AliasTable::from_json(unknown_family).expect_err("unknown family");
    assert!(error.contains("unknown family"), "{error}");

    AliasTable::from_json(include_str!("../data/identity/aliases.json"))
        .expect("embedded alias table is valid");
}