provenant/parsers/

rpm_db.rs

// SPDX-FileCopyrightText: Provenant contributors
// SPDX-License-Identifier: Apache-2.0

//! Parser for RPM database files.
//!
//! Extracts installed package metadata from the RPM database maintained by the
//! system package manager, typically located in /var/lib/rpm/.
//!
//! # Supported Formats
//! - /var/lib/rpm/Packages (BerkeleyDB format or SQLite - raw database file)
//! - Other RPM database index files
//!
//! # Key Features
//! - Installed package metadata extraction from system RPM database
//! - Database format detection (BDB vs NDB vs SQLite)
//! - Multi-version package support
//! - Package URL (purl) generation with architecture namespace
//!
//! # Implementation Notes
//! - Database location detection (/var/lib/rpm/Packages or variants)
//! - Native parsing only (no subprocess execution per ADR 0004)
//! - Graceful error handling for unreadable or corrupted databases
//! - Returns package data for each installed package entry

use std::path::Path;

use crate::parser_warn as warn;

use crate::models::{DatasourceId, PackageData, PackageType};
use crate::models::{Dependency, FileReference};
use crate::parsers::utils::{MAX_MANIFEST_SIZE, capped_iteration_limit, truncate_field};

use super::PackageParser;
use super::license_normalization::{
    DeclaredLicenseMatchMetadata, build_declared_license_data, empty_declared_license_data,
};
use super::rpm_db_native::{InstalledRpmDbKind, InstalledRpmPackage, read_installed_rpm_packages};
use super::rpm_parser::infer_rpm_namespace;
use super::rpm_parser::infer_rpm_namespace_from_filename;
use super::rpm_parser::normalize_rpm_declared_license;

const PACKAGE_TYPE: PackageType = PackageType::Rpm;
const RPM_BDB_PATH_SUFFIXES: &[&str] = &["var/lib/rpm/Packages", "usr/lib/sysimage/rpm/Packages"];
const RPM_NDB_PATH_SUFFIXES: &[&str] = &[
    "var/lib/rpm/Packages.db",
    "usr/lib/sysimage/rpm/Packages.db",
];
#[cfg(feature = "rpm-sqlite")]
const RPM_SQLITE_PATH_SUFFIXES: &[&str] = &[
    "var/lib/rpm/rpmdb.sqlite",
    "usr/lib/sysimage/rpm/rpmdb.sqlite",
];

#[derive(Debug)]
struct RpmQueryPackage {
    name: Option<String>,
    epoch: Option<String>,
    version: Option<String>,
    release: Option<String>,
    vendor: Option<String>,
    distribution: Option<String>,
    arch: Option<String>,
    platform: Option<String>,
    size: Option<u64>,
    license: Option<String>,
    source_rpm: Option<String>,
    requires: Vec<String>,
    file_names: Vec<Option<String>>,
    dir_indexes: Vec<u32>,
    base_names: Vec<Option<String>>,
    dir_names: Vec<String>,
}

fn default_package_data(datasource_id: DatasourceId) -> PackageData {
    PackageData {
        package_type: Some(PACKAGE_TYPE),
        datasource_id: Some(datasource_id),
        ..Default::default()
    }
}

pub struct RpmBdbDatabaseParser;

// Keep these cfg-split impls mutually exclusive and complete. `PackageParser`
// impls cannot be composed across feature branches, so the no-default-features
// build must still define the full BDB parser surface here.
#[cfg(feature = "rpm-sqlite")]
impl PackageParser for RpmBdbDatabaseParser {
    const PACKAGE_TYPE: PackageType = PACKAGE_TYPE;

    fn is_match(path: &Path) -> bool {
        path_matches_any_suffix(path, RPM_BDB_PATH_SUFFIXES)
    }

    fn extract_packages(path: &Path) -> Vec<PackageData> {
        match parse_rpm_database(path, DatasourceId::RpmInstalledDatabaseBdb) {
            Ok(pkgs) if !pkgs.is_empty() => pkgs,
            Ok(_) => vec![default_package_data(DatasourceId::RpmInstalledDatabaseBdb)],
            Err(e) => {
                warn!("Failed to parse RPM BDB database {:?}: {}", path, e);
                vec![default_package_data(DatasourceId::RpmInstalledDatabaseBdb)]
            }
        }
    }

    fn metadata() -> Vec<super::metadata::ParserMetadata> {
        vec![super::metadata::ParserMetadata {
            description: "RPM installed package database",
            file_patterns: &[
                "**/var/lib/rpm/Packages",
                "**/usr/lib/sysimage/rpm/Packages",
                "**/var/lib/rpm/Packages.db",
                "**/usr/lib/sysimage/rpm/Packages.db",
                "**/var/lib/rpm/rpmdb.sqlite",
                "**/usr/lib/sysimage/rpm/rpmdb.sqlite",
            ],
            package_type: "rpm",
            primary_language: "",
            documentation_url: Some("https://rpm.org/"),
        }]
    }
}

#[cfg(not(feature = "rpm-sqlite"))]
impl PackageParser for RpmBdbDatabaseParser {
    const PACKAGE_TYPE: PackageType = PACKAGE_TYPE;

    fn is_match(path: &Path) -> bool {
        path_matches_any_suffix(path, RPM_BDB_PATH_SUFFIXES)
    }

    fn extract_packages(path: &Path) -> Vec<PackageData> {
        match parse_rpm_database(path, DatasourceId::RpmInstalledDatabaseBdb) {
            Ok(pkgs) if !pkgs.is_empty() => pkgs,
            Ok(_) => vec![default_package_data(DatasourceId::RpmInstalledDatabaseBdb)],
            Err(e) => {
                warn!("Failed to parse RPM BDB database {:?}: {}", path, e);
                vec![default_package_data(DatasourceId::RpmInstalledDatabaseBdb)]
            }
        }
    }

    fn metadata() -> Vec<super::metadata::ParserMetadata> {
        vec![super::metadata::ParserMetadata {
            description: "RPM installed package database",
            file_patterns: &[
                "**/var/lib/rpm/Packages",
                "**/usr/lib/sysimage/rpm/Packages",
                "**/var/lib/rpm/Packages.db",
                "**/usr/lib/sysimage/rpm/Packages.db",
            ],
            package_type: "rpm",
            primary_language: "",
            documentation_url: Some("https://rpm.org/"),
        }]
    }
}

pub struct RpmNdbDatabaseParser;

impl PackageParser for RpmNdbDatabaseParser {
    const PACKAGE_TYPE: PackageType = PACKAGE_TYPE;

    fn is_match(path: &Path) -> bool {
        path_matches_any_suffix(path, RPM_NDB_PATH_SUFFIXES)
    }

    fn extract_packages(path: &Path) -> Vec<PackageData> {
        match parse_rpm_database(path, DatasourceId::RpmInstalledDatabaseNdb) {
            Ok(pkgs) if !pkgs.is_empty() => pkgs,
            Ok(_) => vec![default_package_data(DatasourceId::RpmInstalledDatabaseNdb)],
            Err(e) => {
                warn!("Failed to parse RPM NDB database {:?}: {}", path, e);
                vec![default_package_data(DatasourceId::RpmInstalledDatabaseNdb)]
            }
        }
    }
}

#[cfg(feature = "rpm-sqlite")]
pub struct RpmSqliteDatabaseParser;

#[cfg(feature = "rpm-sqlite")]
impl PackageParser for RpmSqliteDatabaseParser {
    const PACKAGE_TYPE: PackageType = PACKAGE_TYPE;

    fn is_match(path: &Path) -> bool {
        path_matches_any_suffix(path, RPM_SQLITE_PATH_SUFFIXES)
    }

    fn extract_packages(path: &Path) -> Vec<PackageData> {
        match parse_rpm_database(path, DatasourceId::RpmInstalledDatabaseSqlite) {
            Ok(pkgs) if !pkgs.is_empty() => pkgs,
            Ok(_) => vec![default_package_data(
                DatasourceId::RpmInstalledDatabaseSqlite,
            )],
            Err(e) => {
                warn!("Failed to parse RPM SQLite database {:?}: {}", path, e);
                vec![default_package_data(
                    DatasourceId::RpmInstalledDatabaseSqlite,
                )]
            }
        }
    }
}

fn parse_rpm_database(
    path: &Path,
    datasource_id: DatasourceId,
) -> Result<Vec<PackageData>, String> {
    let metadata = std::fs::metadata(path)
        .map_err(|e| format!("Cannot stat RPM database file {:?}: {}", path, e))?;

    if metadata.len() > MAX_MANIFEST_SIZE {
        return Err(format!(
            "RPM database file {:?} is {} bytes, exceeding the {} byte limit",
            path,
            metadata.len(),
            MAX_MANIFEST_SIZE
        ));
    }

    let native_kind = native_kind_for_datasource(datasource_id)?;
    match read_installed_rpm_packages(path, native_kind) {
        Ok(packages) => {
            let limit = capped_iteration_limit(packages.len(), "rpm_db native packages");
            Ok(packages
                .into_iter()
                .take(limit)
                .map(native_package_to_query_package)
                .map(|pkg| build_package_data(pkg, datasource_id))
                .collect())
        }
        Err(native_error) => Err(format!(
            "native installed RPM reader failed for {:?}: {}",
            path, native_error
        )),
    }
}

fn path_matches_suffix(path: &Path, suffix: &str) -> bool {
    path.to_string_lossy().replace('\\', "/").ends_with(suffix)
}

fn path_matches_any_suffix(path: &Path, suffixes: &[&str]) -> bool {
    suffixes
        .iter()
        .any(|suffix| path_matches_suffix(path, suffix))
}

fn native_kind_for_datasource(datasource_id: DatasourceId) -> Result<InstalledRpmDbKind, String> {
    match datasource_id {
        DatasourceId::RpmInstalledDatabaseBdb => Ok(InstalledRpmDbKind::Bdb),
        DatasourceId::RpmInstalledDatabaseNdb => Ok(InstalledRpmDbKind::Ndb),
        DatasourceId::RpmInstalledDatabaseSqlite => Ok(InstalledRpmDbKind::Sqlite),
        other => Err(format!(
            "unexpected datasource for installed RPM DB: {other:?}"
        )),
    }
}

fn native_package_to_query_package(package: InstalledRpmPackage) -> RpmQueryPackage {
    let requires_limit = capped_iteration_limit(package.requires.len(), "rpm_db package requires");
    let file_names_limit =
        capped_iteration_limit(package.file_names.len(), "rpm_db package file_names");
    let base_names_limit =
        capped_iteration_limit(package.base_names.len(), "rpm_db package base_names");
    let dir_names_limit =
        capped_iteration_limit(package.dir_names.len(), "rpm_db package dir_names");
    RpmQueryPackage {
        name: truncate_optional_string(Some(package.name)),
        epoch: Some(package.epoch.to_string()),
        version: truncate_optional_string(Some(package.version)),
        release: truncate_optional_string(Some(package.release)),
        vendor: truncate_optional_string(Some(package.vendor)),
        distribution: truncate_optional_string(Some(package.distribution)),
        arch: truncate_optional_string(Some(package.arch)),
        platform: truncate_optional_string(Some(package.platform)),
        size: (package.size > 0).then_some(u64::from(package.size)),
        license: truncate_optional_string(Some(package.license)),
        source_rpm: truncate_optional_string(Some(package.source_rpm)),
        requires: package
            .requires
            .into_iter()
            .take(requires_limit)
            .map(truncate_field)
            .collect(),
        file_names: package
            .file_names
            .into_iter()
            .take(file_names_limit)
            .map(|s| Some(truncate_field(s)))
            .collect(),
        dir_indexes: package.dir_indexes,
        base_names: package
            .base_names
            .into_iter()
            .take(base_names_limit)
            .map(|s| Some(truncate_field(s)))
            .collect(),
        dir_names: package
            .dir_names
            .into_iter()
            .take(dir_names_limit)
            .map(truncate_field)
            .collect(),
    }
}

fn truncate_optional_string(value: Option<String>) -> Option<String> {
    value
        .map(truncate_field)
        .and_then(|v| normalize_optional_string(Some(v)))
}

fn build_version_release(version: &str, release: &str) -> Option<String> {
    if version.is_empty() {
        return None;
    }

    let mut vr = String::from(version);

    if !release.is_empty() {
        vr.push('-');
        vr.push_str(release);
    }

    Some(vr)
}

fn build_file_references(
    base_names: &[Option<String>],
    dir_indexes: &[u32],
    dir_names: &[String],
) -> Vec<FileReference> {
    if base_names.is_empty() || dir_names.is_empty() {
        return Vec::new();
    }

    let limit = capped_iteration_limit(
        base_names.len().min(dir_indexes.len()),
        "rpm_db file references",
    );
    base_names
        .iter()
        .zip(dir_indexes.iter())
        .take(limit)
        .filter_map(|(basename, &dir_idx)| {
            let dirname = dir_names.get(dir_idx as usize)?;
            let basename = basename.as_deref().unwrap_or_default();
            let path = format!("{}{}", dirname, basename);
            if path.is_empty() || path == "/" {
                return None;
            }
            Some(FileReference {
                path,
                size: None,
                sha1: None,
                md5: None,
                sha256: None,
                sha512: None,
                extra_data: None,
            })
        })
        .collect()
}

fn build_file_references_from_paths(paths: &[Option<String>]) -> Vec<FileReference> {
    let limit = capped_iteration_limit(paths.len(), "rpm_db file references from paths");
    paths
        .iter()
        .take(limit)
        .filter_map(|path| {
            let path = path.as_deref()?.trim();
            if path.is_empty() || path == "/" {
                return None;
            }

            Some(FileReference {
                path: path.to_string(),
                size: None,
                sha1: None,
                md5: None,
                sha256: None,
                sha512: None,
                extra_data: None,
            })
        })
        .collect()
}

fn build_package_data(pkg: RpmQueryPackage, datasource_id: DatasourceId) -> PackageData {
    let name = normalize_optional_string(pkg.name).map(truncate_field);
    let version_raw = normalize_optional_string(pkg.version).map(truncate_field);
    let release = normalize_optional_string(pkg.release).map(truncate_field);
    let version = build_version_release(
        version_raw.as_deref().unwrap_or_default(),
        release.as_deref().unwrap_or_default(),
    );
    // The rpm epoch is emitted as an `?epoch=` qualifier rather than folded
    // into the version (e.g. `2:1.0-1`).
    let epoch_value = parse_epoch(pkg.epoch);
    let epoch = (epoch_value > 0).then(|| epoch_value.to_string());

    let vendor = normalize_optional_string(pkg.vendor)
        .map(truncate_field)
        .or_else(|| normalize_optional_string(pkg.distribution).map(truncate_field));
    let source_rpm = normalize_optional_string(pkg.source_rpm).map(truncate_field);
    let namespace =
        infer_rpm_namespace(None, vendor.as_deref(), release.as_deref(), None).or_else(|| {
            source_rpm
                .as_deref()
                .and_then(|source_rpm| infer_rpm_namespace_from_filename(Path::new(source_rpm)))
        });

    let architecture = normalize_optional_string(pkg.arch)
        .map(truncate_field)
        .or_else(|| infer_platform_architecture(pkg.platform.as_deref()));
    let requires_limit = capped_iteration_limit(pkg.requires.len(), "rpm_db package dependencies");
    let dependencies = pkg
        .requires
        .into_iter()
        .take(requires_limit)
        .filter_map(|require| build_dependency(&require))
        .collect();
    let extracted_license_statement = normalize_optional_string(pkg.license).map(truncate_field);
    let (declared_license_expression, declared_license_expression_spdx, license_detections) =
        extracted_license_statement
            .as_deref()
            .and_then(normalize_rpm_declared_license)
            .map(|normalized| {
                build_declared_license_data(
                    normalized,
                    DeclaredLicenseMatchMetadata::single_line(
                        extracted_license_statement.as_deref().unwrap_or_default(),
                    ),
                )
            })
            .map(|(expr, spdx, detections)| {
                (
                    expr.map(truncate_field),
                    spdx.map(truncate_field),
                    detections,
                )
            })
            .unwrap_or_else(empty_declared_license_data);
    let source_packages = source_rpm.clone().into_iter().collect();
    let file_references = {
        let from_dir_components =
            build_file_references(&pkg.base_names, &pkg.dir_indexes, &pkg.dir_names);
        if from_dir_components.is_empty() {
            build_file_references_from_paths(&pkg.file_names)
        } else {
            from_dir_components
        }
    };
    let purl = build_package_purl(
        name.as_deref(),
        namespace.as_deref(),
        version.as_deref(),
        architecture.as_deref(),
        epoch.as_deref(),
    );

    PackageData {
        datasource_id: Some(datasource_id),
        package_type: Some(PACKAGE_TYPE),
        namespace,
        name,
        version,
        qualifiers: {
            let mut q = std::collections::HashMap::new();
            if let Some(arch) = &architecture {
                q.insert("arch".to_string(), arch.clone());
            }
            if let Some(epoch) = &epoch {
                q.insert("epoch".to_string(), epoch.clone());
            }
            (!q.is_empty()).then_some(q)
        },
        subpath: None,
        primary_language: None,
        description: None,
        release_date: None,
        parties: Vec::new(),
        keywords: Vec::new(),
        homepage_url: None,
        download_url: None,
        size: pkg.size.filter(|size| *size > 0),
        sha1: None,
        md5: None,
        sha256: None,
        sha512: None,
        bug_tracking_url: None,
        code_view_url: None,
        vcs_url: None,
        copyright: None,
        holder: None,
        declared_license_expression,
        declared_license_expression_spdx,
        license_detections,
        other_license_expression: None,
        other_license_expression_spdx: None,
        other_license_detections: Vec::new(),
        extracted_license_statement,
        notice_text: None,
        source_packages,
        file_references,
        is_private: false,
        is_virtual: false,
        extra_data: None,
        dependencies,
        repository_homepage_url: None,
        repository_download_url: None,
        api_data_url: None,
        purl,
    }
}

fn build_dependency(require: &str) -> Option<Dependency> {
    let require = require.trim();
    if require.is_empty() || require.starts_with("rpmlib(") || require.starts_with("config(") {
        return None;
    }

    let purl = packageurl::PackageUrl::new(PACKAGE_TYPE.as_str(), require)
        .ok()
        .map(|p| p.to_string());

    Some(Dependency {
        purl,
        extracted_requirement: None,
        scope: Some("requires".to_string()),
        is_runtime: Some(true),
        is_optional: Some(false),
        is_pinned: Some(false),
        is_direct: Some(true),
        resolved_package: None,
        extra_data: None,
    })
}

fn build_package_purl(
    name: Option<&str>,
    namespace: Option<&str>,
    version: Option<&str>,
    arch: Option<&str>,
    epoch: Option<&str>,
) -> Option<String> {
    let name = name?;
    let mut purl = packageurl::PackageUrl::new(PACKAGE_TYPE.as_str(), name).ok()?;

    if let Some(namespace) = namespace {
        purl.with_namespace(namespace).ok()?;
    }

    if let Some(version) = version {
        purl.with_version(version).ok()?;
    }

    if let Some(arch) = arch {
        purl.add_qualifier("arch", arch).ok()?;
    }

    // The rpm epoch is a qualifier, not part of the version.
    if let Some(epoch) = epoch {
        purl.add_qualifier("epoch", epoch).ok()?;
    }

    Some(purl.to_string())
}

fn normalize_optional_string(value: Option<String>) -> Option<String> {
    value.and_then(|value| {
        let trimmed = value.trim();
        if trimmed.is_empty() || trimmed == "(none)" || trimmed == "[]" {
            None
        } else {
            Some(trimmed.to_string())
        }
    })
}

fn parse_epoch(value: Option<String>) -> u32 {
    normalize_optional_string(value)
        .and_then(|value| value.parse::<u32>().ok())
        .unwrap_or(0)
}

fn infer_platform_architecture(platform: Option<&str>) -> Option<String> {
    let platform = platform?.trim();
    if platform.is_empty() {
        return None;
    }

    platform
        .split_once('-')
        .map(|(arch, _)| arch)
        .filter(|arch| !arch.is_empty())
        .map(|arch| arch.to_string())
}

#[cfg(test)]
mod tests {
    use super::*;

    use crate::models::DatasourceId;
    use std::path::PathBuf;

    #[test]
    fn test_bdb_parser_is_match() {
        assert!(RpmBdbDatabaseParser::is_match(&PathBuf::from(
            "/var/lib/rpm/Packages"
        )));
        assert!(RpmBdbDatabaseParser::is_match(&PathBuf::from(
            "rootfs/var/lib/rpm/Packages"
        )));
        assert!(RpmBdbDatabaseParser::is_match(&PathBuf::from(
            "/usr/lib/sysimage/rpm/Packages"
        )));
        assert!(!RpmBdbDatabaseParser::is_match(&PathBuf::from(
            "/var/lib/rpm/Packages.db"
        )));
        assert!(!RpmBdbDatabaseParser::is_match(&PathBuf::from(
            "lib/modules/datasource/deb/__fixtures__/Packages"
        )));
        assert!(!RpmBdbDatabaseParser::is_match(&PathBuf::from("Packages")));
        assert!(!RpmBdbDatabaseParser::is_match(&PathBuf::from(
            "testdata/rpm/var/lib/rpm/Packages.expected.json"
        )));
    }

    #[test]
    fn test_ndb_parser_is_match() {
        assert!(RpmNdbDatabaseParser::is_match(&PathBuf::from(
            "usr/lib/sysimage/rpm/Packages.db"
        )));
        assert!(RpmNdbDatabaseParser::is_match(&PathBuf::from(
            "/rootfs/usr/lib/sysimage/rpm/Packages.db"
        )));
        assert!(!RpmNdbDatabaseParser::is_match(&PathBuf::from(
            "usr/lib/rpm/Packages"
        )));
        assert!(RpmNdbDatabaseParser::is_match(&PathBuf::from(
            "var/lib/rpm/Packages.db"
        )));
        assert!(!RpmNdbDatabaseParser::is_match(&PathBuf::from(
            "testdata/rpm/usr/lib/sysimage/rpm/Packages.db.expected.json"
        )));
    }

    #[cfg(feature = "rpm-sqlite")]
    #[test]
    fn test_sqlite_parser_is_match() {
        assert!(RpmSqliteDatabaseParser::is_match(&PathBuf::from(
            "var/lib/rpm/rpmdb.sqlite"
        )));
        assert!(RpmSqliteDatabaseParser::is_match(&PathBuf::from(
            "/rootfs/var/lib/rpm/rpmdb.sqlite"
        )));
        assert!(RpmSqliteDatabaseParser::is_match(&PathBuf::from(
            "/rootfs/usr/lib/sysimage/rpm/rpmdb.sqlite"
        )));
        assert!(!RpmSqliteDatabaseParser::is_match(&PathBuf::from(
            "/var/lib/rpm/Packages"
        )));
        assert!(!RpmSqliteDatabaseParser::is_match(&PathBuf::from(
            "testdata/rpm/rpmdb.sqlite.expected.json"
        )));
        assert!(!RpmSqliteDatabaseParser::is_match(&PathBuf::from(
            "testdata/rpm/rpmdb.sqlite-shm"
        )));
        assert!(!RpmSqliteDatabaseParser::is_match(&PathBuf::from(
            "testdata/rpm/rpmdb.sqlite-wal"
        )));
    }

    #[test]
    fn test_build_version_release_full() {
        // Epoch is no longer folded into the version; it is an `?epoch=` qualifier.
        assert_eq!(
            build_version_release("1.0.0", "1.el7"),
            Some("1.0.0-1.el7".to_string())
        );
    }

    #[test]
    fn test_build_version_release_no_release() {
        assert_eq!(
            build_version_release("1.0.0", ""),
            Some("1.0.0".to_string())
        );
    }

    #[test]
    fn test_build_version_release_empty() {
        assert_eq!(build_version_release("", ""), None);
    }

    #[cfg(feature = "rpm-sqlite")]
    #[test]
    fn test_parse_rpm_database_sqlite() {
        let test_file = PathBuf::from("testdata/rpm/rpmdb.sqlite");

        let pkg = RpmSqliteDatabaseParser::extract_first_package(&test_file);

        assert_eq!(pkg.package_type, Some(PackageType::Rpm));
        assert_eq!(
            pkg.datasource_id,
            Some(DatasourceId::RpmInstalledDatabaseSqlite)
        );
        assert!(pkg.name.is_some());
    }

    #[cfg(feature = "rpm-sqlite")]
    #[test]
    fn test_parse_rpm_database_sqlite_preserves_release_in_version() {
        let test_file = PathBuf::from("testdata/rpm/rpmdb.sqlite");

        let pkg = RpmSqliteDatabaseParser::extract_first_package(&test_file);

        assert!(
            pkg.version
                .as_ref()
                .is_some_and(|version| version.contains('-'))
        );
    }

    #[test]
    fn test_build_file_references_skips_invalid_entries() {
        let file_refs = build_file_references(
            &[
                Some("valid".to_string()),
                Some("".to_string()),
                Some("ignored".to_string()),
            ],
            &[0, 0, u32::MAX],
            &["/usr/bin/".to_string()],
        );

        assert_eq!(file_refs.len(), 2);
        assert_eq!(file_refs[0].path, "/usr/bin/valid");
        assert_eq!(file_refs[1].path, "/usr/bin/");
    }

    #[test]
    fn test_build_package_data_falls_back_to_file_names() {
        let package = build_package_data(
            RpmQueryPackage {
                name: Some("libgcc".to_string()),
                epoch: None,
                version: Some("13.1.1".to_string()),
                release: Some("2.fc38".to_string()),
                vendor: Some("Fedora Project".to_string()),
                distribution: None,
                arch: Some("x86_64".to_string()),
                platform: None,
                size: Some(235748),
                license: Some("GPLv3+".to_string()),
                source_rpm: Some("gcc-13.1.1-2.fc38.src.rpm".to_string()),
                requires: Vec::new(),
                file_names: vec![
                    Some("/usr/share/licenses/libgcc/COPYING".to_string()),
                    Some("/usr/share/licenses/libgcc/COPYING.RUNTIME".to_string()),
                ],
                dir_indexes: Vec::new(),
                base_names: Vec::new(),
                dir_names: Vec::new(),
            },
            DatasourceId::RpmInstalledDatabaseSqlite,
        );

        assert_eq!(package.file_references.len(), 2);
        assert_eq!(
            package.file_references[0].path,
            "/usr/share/licenses/libgcc/COPYING"
        );
        assert_eq!(
            package.file_references[1].path,
            "/usr/share/licenses/libgcc/COPYING.RUNTIME"
        );
    }

    #[test]
    fn test_build_package_data_uses_distribution_for_namespace() {
        let package = build_package_data(
            RpmQueryPackage {
                name: Some("libgcc".to_string()),
                epoch: None,
                version: Some("13.1.1".to_string()),
                release: Some("2.fc38".to_string()),
                vendor: None,
                distribution: Some("Fedora Project".to_string()),
                arch: Some("x86_64".to_string()),
                platform: None,
                size: Some(235748),
                license: Some("GPLv3+".to_string()),
                source_rpm: Some("gcc-13.1.1-2.fc38.src.rpm".to_string()),
                requires: Vec::new(),
                file_names: vec![Some("/usr/share/licenses/libgcc/COPYING".to_string())],
                dir_indexes: Vec::new(),
                base_names: Vec::new(),
                dir_names: Vec::new(),
            },
            DatasourceId::RpmInstalledDatabaseSqlite,
        );

        assert_eq!(package.namespace.as_deref(), Some("fedora"));
    }

    #[test]
    fn test_build_package_data_normalizes_declared_license_expression() {
        let package = build_package_data(
            RpmQueryPackage {
                name: Some("libgcc".to_string()),
                epoch: None,
                version: Some("13.1.1".to_string()),
                release: Some("2.fc38".to_string()),
                vendor: Some("Fedora Project".to_string()),
                distribution: None,
                arch: Some("x86_64".to_string()),
                platform: None,
                size: Some(235748),
                license: Some("LGPLv2".to_string()),
                source_rpm: Some("gcc-13.1.1-2.fc38.src.rpm".to_string()),
                requires: Vec::new(),
                file_names: Vec::new(),
                dir_indexes: Vec::new(),
                base_names: Vec::new(),
                dir_names: Vec::new(),
            },
            DatasourceId::RpmInstalledDatabaseSqlite,
        );

        assert_eq!(
            package.declared_license_expression.as_deref(),
            Some("lgpl-2.0")
        );
        assert_eq!(
            package.declared_license_expression_spdx.as_deref(),
            Some("LGPL-2.0-only")
        );
        assert_eq!(package.license_detections.len(), 1);
    }

    #[test]
    fn test_build_package_data_uses_source_rpm_for_namespace() {
        let package = build_package_data(
            RpmQueryPackage {
                name: Some("libgcc".to_string()),
                epoch: None,
                version: Some("13.1.1".to_string()),
                release: None,
                vendor: None,
                distribution: None,
                arch: Some("x86_64".to_string()),
                platform: None,
                size: Some(235748),
                license: Some("GPLv3+".to_string()),
                source_rpm: Some("gcc-13.1.1-2.fc38.src.rpm".to_string()),
                requires: Vec::new(),
                file_names: vec![Some("/usr/share/licenses/libgcc/COPYING".to_string())],
                dir_indexes: Vec::new(),
                base_names: Vec::new(),
                dir_names: Vec::new(),
            },
            DatasourceId::RpmInstalledDatabaseSqlite,
        );

        assert_eq!(package.namespace.as_deref(), Some("fedora"));
    }

    #[test]
    fn test_build_package_data_uses_platform_for_architecture() {
        let package = build_package_data(
            RpmQueryPackage {
                name: Some("libgcc".to_string()),
                epoch: None,
                version: Some("13.1.1".to_string()),
                release: None,
                vendor: None,
                distribution: None,
                arch: None,
                platform: Some("x86_64-redhat-linux".to_string()),
                size: Some(235748),
                license: Some("GPLv3+".to_string()),
                source_rpm: Some("gcc-13.1.1-2.fc38.src.rpm".to_string()),
                requires: Vec::new(),
                file_names: vec![Some("/usr/share/licenses/libgcc/COPYING".to_string())],
                dir_indexes: Vec::new(),
                base_names: Vec::new(),
                dir_names: Vec::new(),
            },
            DatasourceId::RpmInstalledDatabaseSqlite,
        );

        assert_eq!(
            package.qualifiers.as_ref().and_then(|q| q.get("arch")),
            Some(&"x86_64".to_string())
        );
    }
}