voa-core 0.4.1

//! System mode tests
//!
//! Also see <https://uapi-group.org/specifications/specs/file_hierarchy_for_the_verification_of_os_artifacts/#system-mode>

use std::io::Read;

use log::warn;
use testresult::TestResult;
use voa_core::{
    Voa,
    identifiers::{Context, CustomContext, Mode, Os, Purpose, Role, Technology},
};

/// List information about verifiers in the system load paths
/// for os=arch, purpose=packages, context=default, technology=openpgp.
///
/// This test does nothing fancy, except follow a symlink. It mostly tests the happy path.
#[test]
fn list_verifiers() -> TestResult {
    crate::init_logger();

    const SETUP: &[crate::TestObject] = &[
        crate::TestObject::Path("/usr/local/share/voa/arch/packages/default/openpgp/"),
        crate::TestObject::File("/usr/local/share/voa/arch/packages/default/openpgp/foo.pgp"),
        crate::TestObject::Path("/etc/voa/arch/packages/default/openpgp/"),
        crate::TestObject::SymLink(
            "/usr/local/share/voa/arch/packages/default/openpgp/foo.pgp",
            "/etc/voa/arch/packages/default/openpgp/foo.pgp",
        ),
    ];

    crate::setup(SETUP)?;

    let voa = Voa::new();
    let verifiers = voa.lookup(
        Os::new("arch".parse()?, None, None, None, None),
        Purpose::new(Role::Packages, Mode::ArtifactVerifier),
        Context::Default,
        Technology::Openpgp,
    );

    warn!("Found verifiers: {verifiers:#?}");

    assert_eq!(verifiers.len(), 1);
    crate::compare_expected(
        &verifiers,
        &["/usr/local/share/voa/arch/packages/default/openpgp/foo.pgp"],
    );

    // Superficially inspect the set of VoaLocations (we expect two load paths to have matched)
    let (_, vec) = verifiers.iter().next().unwrap();
    assert_eq!(vec.len(), 2);
    let voa_loc = vec[0].voa_location();
    assert_eq!(*voa_loc.technology(), Technology::Openpgp);

    Ok(())
}

/// VOA setup in which one load path directory location is oddly occupied by a file.
/// Such an (invalid) VOA load path triggers informational log output, but is otherwise ineffectual.
#[test]
fn illegal_file_for_load_path() -> TestResult {
    crate::init_logger();

    const SETUP: &[crate::TestObject] = &[
        crate::TestObject::File("/etc/voa"), // Bogus file instead of directory
        crate::TestObject::Path("/usr/local/share/voa/arch/packages/default/openpgp/"),
        crate::TestObject::File("/usr/local/share/voa/arch/packages/default/openpgp/foo.pgp"),
    ];

    crate::setup(SETUP)?;

    let voa = Voa::new();

    // Verifiers should contain "foo.pgp"
    let verifiers = voa.lookup(
        Os::new("arch".parse()?, None, None, None, None),
        Purpose::new(Role::Packages, Mode::ArtifactVerifier),
        Context::Default,
        Technology::Openpgp,
    );

    warn!("Found verifiers: {verifiers:#?}");

    assert_eq!(verifiers.len(), 1);
    crate::compare_expected(
        &verifiers,
        &["/usr/local/share/voa/arch/packages/default/openpgp/foo.pgp"],
    );

    Ok(())
}

/// VOA setup in which a verifier directory contains a directory instead of a verifier file.
/// Such an (invalid) VOA setup triggers informational log output, but is otherwise inconsequential.
#[test]
fn illegal_dir_for_verifier() -> TestResult {
    crate::init_logger();

    const SETUP: &[crate::TestObject] = &[crate::TestObject::Path(
        "/usr/local/share/voa/arch/packages/default/openpgp/foo.pgp",
    ) /* bogus "verifier dir" */];

    crate::setup(SETUP)?;

    let voa = Voa::new();

    // Verifiers should contain "foo.pgp"
    let verifiers = voa.lookup(
        Os::new("arch".parse()?, None, None, None, None),
        Purpose::new(Role::Packages, Mode::ArtifactVerifier),
        Context::Default,
        Technology::Openpgp,
    );

    assert!(verifiers.is_empty());

    Ok(())
}

/// VOA setup in which a verifier directory contains a verifier symlink that points to a directory.
/// Such an (invalid) VOA setup triggers informational log output, but is otherwise inconsequential.
#[test]
fn illegal_dir_at_verifier_symlink() -> TestResult {
    crate::init_logger();

    const SETUP: &[crate::TestObject] = &[
        crate::TestObject::Path("/usr/local/share/voa/arch/packages/custom/openpgp/foo.pgp"), /* bogus "verifier dir" */
        crate::TestObject::Path("/etc/voa/arch/packages/default/openpgp/"),
        crate::TestObject::SymLink(
            "/usr/local/share/voa/arch/packages/custom/openpgp/foo.pgp",
            "/etc/voa/arch/packages/default/openpgp/foo.pgp",
        ),
    ];

    crate::setup(SETUP)?;

    let voa = Voa::new();

    // Verifiers should contain "foo.pgp"
    let verifiers = voa.lookup(
        Os::new("arch".parse()?, None, None, None, None),
        Purpose::new(Role::Packages, Mode::ArtifactVerifier),
        Context::Default,
        Technology::Openpgp,
    );

    assert!(verifiers.is_empty());

    Ok(())
}

/// A symlink that points to a verifier outside the load paths
#[test]
fn invalid_verifier_symlink() -> TestResult {
    crate::init_logger();

    const SETUP: &[crate::TestObject] = &[
        crate::TestObject::Path("/usr/local/share/voa/arch/packages/default/openpgp/"),
        crate::TestObject::File("/tmp/foo.pgp"),
        crate::TestObject::SymLink(
            "/tmp/foo.pgp",
            "/usr/local/share/voa/arch/packages/default/openpgp/foo.pgp",
        ),
    ];

    crate::setup(SETUP)?;

    let voa = Voa::new();
    let verifiers = voa.lookup(
        Os::new("arch".parse()?, None, None, None, None),
        Purpose::new(Role::Packages, Mode::ArtifactVerifier),
        Context::Default,
        Technology::Openpgp,
    );

    assert!(verifiers.is_empty());

    Ok(())
}

/// VOA setup with a symlink that intermittently escapes outside the load paths
#[test]
fn invalid_dir_symlink() -> TestResult {
    crate::init_logger();

    // We start with a verifier in the "default" context in
    // "/usr/local/share/voa/arch/packages/default/openpgp/"
    //
    // Then we set up a symlink contraption that tries to use this verifier from
    // "/etc/voa/arch/packages/custom/"
    //
    // However, the symlink setup intermediately escapes from the load path into "/tmp/custom".
    // So the verifier cannot be loaded via the "custom" context in VOA.
    const SETUP: &[crate::TestObject] = &[
        crate::TestObject::Path("/usr/local/share/voa/arch/packages/default/openpgp/"),
        crate::TestObject::File("/usr/local/share/voa/arch/packages/default/openpgp/foo.pgp"),
        crate::TestObject::Path("/etc/voa/arch/packages/"),
        crate::TestObject::Path("/tmp/custom/"),
        crate::TestObject::SymLink("/tmp/custom/", "/etc/voa/arch/packages/custom"),
        crate::TestObject::SymLink(
            "/usr/local/share/voa/arch/packages/default/openpgp/",
            "/tmp/custom/openpgp",
        ),
    ];

    crate::setup(SETUP)?;

    let voa = Voa::new();

    // Try to load the verifier in the "custom" context, which will fail
    // because the symlink setup is invalid
    let verifiers = voa.lookup(
        Os::new("arch".parse()?, None, None, None, None),
        Purpose::new(Role::Packages, Mode::ArtifactVerifier),
        Context::Custom(CustomContext::new("custom".parse()?)),
        Technology::Openpgp,
    );

    assert!(verifiers.is_empty());

    Ok(())
}

/// VOA setup with a symlink that illegally points to a file where a directory is expected
#[test]
fn invalid_file_at_symlink() -> TestResult {
    crate::init_logger();

    const SETUP: &[crate::TestObject] = &[
        crate::TestObject::Path("/usr/local/share/voa/arch/packages/default/"),
        crate::TestObject::File("/usr/local/share/voa/arch/packages/default/openpgp"), /* Bogus file! */
        crate::TestObject::Path("/etc/voa/arch/packages/custom/"),
        crate::TestObject::SymLink(
            "/usr/local/share/voa/arch/packages/default/openpgp",
            "/etc/voa/arch/packages/custom/openpgp",
        ),
    ];

    crate::setup(SETUP)?;

    let voa = Voa::new();

    // Try to load the verifier in the "custom" context, which will fail
    // because the symlink setup is invalid
    let verifiers = voa.lookup(
        Os::new("arch".parse()?, None, None, None, None),
        Purpose::new(Role::Packages, Mode::ArtifactVerifier),
        Context::Custom(CustomContext::new("custom".parse()?)),
        Technology::Openpgp,
    );

    assert!(verifiers.is_empty());

    Ok(())
}

/// A wild character device appears in the VOA hierarchy, and is ignored (and logged about)
#[test]
fn invalid_fifo() -> TestResult {
    use std::ffi::CString;

    crate::init_logger();

    const SETUP: &[crate::TestObject] = &[
        crate::TestObject::Path("/usr/local/share/voa/arch/packages/default/openpgp"),
        // NOTE: a character device will be created in this directory as `foo.pgp`, below!
        crate::TestObject::Path("/etc/voa/arch/packages/default/openpgp/"),
        crate::TestObject::SymLink(
            "/usr/local/share/voa/arch/packages/default/openpgp/foo.pgp",
            "/etc/voa/arch/packages/default/openpgp/foo.pgp",
        ),
    ];

    crate::setup(SETUP)?;

    // "verifier" that is actually a character device
    let verifier_file = "/usr/local/share/voa/arch/packages/default/openpgp/foo.pgp";

    let c_str = CString::new(verifier_file).unwrap();
    let c_chr = c_str.as_ptr();

    let mode = 0o644 | libc::S_IFIFO;
    let dev = libc::makedev(0, 0);

    unsafe {
        let errno = libc::mknod(c_chr, mode, dev);

        if errno == -1 {
            let c_str = CString::new("mknod").unwrap();
            libc::perror(c_str.as_ptr());
        }
    };

    eprintln!("made FIFO node");

    let voa = Voa::new();

    // Try to load the verifier in the "custom" context, which will fail
    // because the symlink setup is invalid
    let verifiers = voa.lookup(
        Os::new("arch".parse()?, None, None, None, None),
        Purpose::new(Role::Packages, Mode::ArtifactVerifier),
        Context::Default,
        Technology::Openpgp,
    );

    assert!(verifiers.is_empty());

    Ok(())
}

/// VOA setup with a symlink that masks a verifier.
/// All copies of verifiers with that name should not be returned as a result.
#[test]
fn masking() -> TestResult {
    crate::init_logger();

    const SETUP: &[crate::TestObject] = &[
        crate::TestObject::Path("/etc/voa/arch/packages/default/openpgp/"),
        crate::TestObject::File("/etc/voa/arch/packages/default/openpgp/foo.pgp"),
        crate::TestObject::File("/etc/voa/arch/packages/default/openpgp/bar.pgp"),
        crate::TestObject::Path("/usr/local/share/voa/arch/packages/default/openpgp/"),
        crate::TestObject::File("/usr/local/share/voa/arch/packages/default/openpgp/foo.pgp"),
        crate::TestObject::Path("/run/voa/arch/packages/default/openpgp/"),
        crate::TestObject::SymLink(
            "/dev/null",
            "/run/voa/arch/packages/default/openpgp/foo.pgp",
        ),
    ];

    crate::setup(SETUP)?;

    let voa = Voa::new();

    // Verifiers should not contain "foo.pgp" because it is masked in one load path
    let verifiers = voa.lookup(
        Os::new("arch".parse()?, None, None, None, None),
        Purpose::new(Role::Packages, Mode::ArtifactVerifier),
        Context::Default,
        Technology::Openpgp,
    );

    warn!("Found verifiers: {verifiers:#?}");

    assert_eq!(verifiers.len(), 1);
    crate::compare_expected(
        &verifiers,
        &["/etc/voa/arch/packages/default/openpgp/bar.pgp"],
    );

    Ok(())
}

/// VOA setup with a symlink that seemingly attempts to mask a verifier.
/// However, the masking is ineffective because it takes place in a non-writeable load path.
#[test]
fn ineffective_masking() -> TestResult {
    crate::init_logger();

    const SETUP: &[crate::TestObject] = &[
        crate::TestObject::Path("/etc/voa/arch/packages/default/openpgp/"),
        crate::TestObject::File("/etc/voa/arch/packages/default/openpgp/foo.pgp"),
        crate::TestObject::Path("/usr/local/share/voa/arch/packages/default/openpgp/"),
        crate::TestObject::SymLink(
            "/dev/null",
            "/usr/local/share/voa/arch/packages/default/openpgp/foo.pgp",
        ),
    ];

    crate::setup(SETUP)?;

    let voa = Voa::new();

    // Verifiers should not contain "foo.pgp" because it is masked in one load path
    let verifiers = voa.lookup(
        Os::new("arch".parse()?, None, None, None, None),
        Purpose::new(Role::Packages, Mode::ArtifactVerifier),
        Context::Default,
        Technology::Openpgp,
    );

    warn!("Found verifiers: {verifiers:#?}");

    assert_eq!(verifiers.len(), 1);
    crate::compare_expected(
        &verifiers,
        &["/etc/voa/arch/packages/default/openpgp/foo.pgp"],
    );

    Ok(())
}

/// VOA setup with a symlink that seemingly attempts to mask a directory.
/// Such an (invalid) masking symlink triggers a warning, but is otherwise ineffectual.
#[test]
fn masking_warn_for_directory() -> TestResult {
    crate::init_logger();

    const SETUP: &[crate::TestObject] = &[
        crate::TestObject::Path("/etc/voa/arch/packages/default/"),
        crate::TestObject::Path("/usr/local/share/voa/arch/packages/default/openpgp/"),
        crate::TestObject::File("/usr/local/share/voa/arch/packages/default/openpgp/foo.pgp"),
        crate::TestObject::SymLink("/dev/null", "/etc/voa/arch/packages/default/openpgp"),
    ];

    crate::setup(SETUP)?;

    let voa = Voa::new();

    // Verifiers should contain "foo.pgp"
    let verifiers = voa.lookup(
        Os::new("arch".parse()?, None, None, None, None),
        Purpose::new(Role::Packages, Mode::ArtifactVerifier),
        Context::Default,
        Technology::Openpgp,
    );

    warn!("Found verifiers: {verifiers:#?}");

    assert_eq!(verifiers.len(), 1);
    crate::compare_expected(
        &verifiers,
        &["/usr/local/share/voa/arch/packages/default/openpgp/foo.pgp"],
    );

    Ok(())
}

/// VOA setup with a file that is linked via a chain of two symlinks.
#[test]
fn symlink_multihop_file() -> TestResult {
    crate::init_logger();

    const SETUP: &[crate::TestObject] = &[
        crate::TestObject::Path("/etc/voa/arch/packages/default/openpgp/"),
        crate::TestObject::Path("/etc/voa/arch/packages/custom1/openpgp/"),
        crate::TestObject::Path("/etc/voa/arch/packages/custom2/openpgp/"),
        crate::TestObject::File("/etc/voa/arch/packages/default/openpgp/foo.pgp"),
        crate::TestObject::SymLink(
            "/etc/voa/arch/packages/default/openpgp/foo.pgp",
            "/etc/voa/arch/packages/custom1/openpgp/foo.pgp",
        ),
        crate::TestObject::SymLink(
            "/etc/voa/arch/packages/custom1/openpgp/foo.pgp",
            "/etc/voa/arch/packages/custom2/openpgp/foo.pgp",
        ),
    ];

    crate::setup(SETUP)?;

    let voa = Voa::new();

    // Try to load verifiers via "custom2", which should return foo.pgp,
    // which points to the default context via an intermediate hop in the "custom1" context.
    let verifiers = voa.lookup(
        Os::new("arch".parse()?, None, None, None, None),
        Purpose::new(Role::Packages, Mode::ArtifactVerifier),
        Context::Custom(CustomContext::new("custom2".parse()?)),
        Technology::Openpgp,
    );

    warn!("Found verifiers: {verifiers:#?}");

    assert_eq!(verifiers.len(), 1);
    crate::compare_expected(
        &verifiers,
        &["/etc/voa/arch/packages/default/openpgp/foo.pgp"],
    );

    Ok(())
}

/// VOA setup with a cycle of two file-symlinks.
/// Will not terminate without cycle detection!
#[test]
fn symlink_cycle_file() -> TestResult {
    crate::init_logger();

    const SETUP: &[crate::TestObject] = &[
        crate::TestObject::Path("/etc/voa/arch/packages/custom1/openpgp/"),
        crate::TestObject::Path("/etc/voa/arch/packages/custom2/openpgp/"),
        crate::TestObject::SymLink(
            "/etc/voa/arch/packages/custom2/openpgp/foo.pgp",
            "/etc/voa/arch/packages/custom1/openpgp/foo.pgp",
        ),
        crate::TestObject::SymLink(
            "/etc/voa/arch/packages/custom1/openpgp/foo.pgp",
            "/etc/voa/arch/packages/custom2/openpgp/foo.pgp",
        ),
    ];

    crate::setup(SETUP)?;

    let voa = Voa::new();

    // Try to load verifiers via "custom2", which should only find a symlink loop and return empty.
    let verifiers = voa.lookup(
        Os::new("arch".parse()?, None, None, None, None),
        Purpose::new(Role::Packages, Mode::ArtifactVerifier),
        Context::Custom(CustomContext::new("custom2".parse()?)),
        Technology::Openpgp,
    );

    assert!(verifiers.is_empty());

    Ok(())
}

/// VOA setup with a directory that is linked via a chain of two symlinks.
#[test]
fn symlink_multihop_dir() -> TestResult {
    crate::init_logger();

    const SETUP: &[crate::TestObject] = &[
        crate::TestObject::Path("/etc/voa/arch/packages/default/openpgp/"),
        crate::TestObject::Path("/etc/voa/arch/packages/custom1/"),
        crate::TestObject::Path("/etc/voa/arch/packages/custom2/"),
        crate::TestObject::File("/etc/voa/arch/packages/default/openpgp/foo.pgp"),
        crate::TestObject::SymLink(
            "/etc/voa/arch/packages/default/openpgp",
            "/etc/voa/arch/packages/custom1/openpgp",
        ),
        crate::TestObject::SymLink(
            "/etc/voa/arch/packages/custom1/openpgp",
            "/etc/voa/arch/packages/custom2/openpgp",
        ),
    ];

    crate::setup(SETUP)?;

    let voa = Voa::new();

    // Try to load verifiers via "custom2", which should return foo.pgp,
    // which points to the default context via an intermediate hop in the "custom1" context.
    let verifiers = voa.lookup(
        Os::new("arch".parse()?, None, None, None, None),
        Purpose::new(Role::Packages, Mode::ArtifactVerifier),
        Context::Custom(CustomContext::new("custom2".parse()?)),
        Technology::Openpgp,
    );

    warn!("Found verifiers: {verifiers:#?}");

    assert_eq!(verifiers.len(), 1);
    crate::compare_expected(
        &verifiers,
        &["/etc/voa/arch/packages/default/openpgp/foo.pgp"],
    );

    Ok(())
}

/// VOA setup with a cycle of two dir-symlinks.
/// Will not terminate without cycle detection!
#[test]
fn symlink_cycle_dir() -> TestResult {
    crate::init_logger();

    const SETUP: &[crate::TestObject] = &[
        crate::TestObject::Path("/etc/voa/arch/packages/custom1/"),
        crate::TestObject::Path("/etc/voa/arch/packages/custom2/"),
        crate::TestObject::SymLink(
            "/etc/voa/arch/packages/custom2/openpgp",
            "/etc/voa/arch/packages/custom1/openpgp",
        ),
        crate::TestObject::SymLink(
            "/etc/voa/arch/packages/custom1/openpgp",
            "/etc/voa/arch/packages/custom2/openpgp",
        ),
    ];

    crate::setup(SETUP)?;

    let voa = Voa::new();

    // Try to load verifiers via "custom2", which should only find a symlink loop and return empty.
    let verifiers = voa.lookup(
        Os::new("arch".parse()?, None, None, None, None),
        Purpose::new(Role::Packages, Mode::ArtifactVerifier),
        Context::Custom(CustomContext::new("custom2".parse()?)),
        Technology::Openpgp,
    );

    assert!(verifiers.is_empty());

    Ok(())
}

/// VOA setup with a valid symlink between load paths.
///
/// Finds a verifier in `/usr/local/share/voa` via a symlink from `/etc/voa`.
#[test]
fn symlink_between_load_paths_valid() -> TestResult {
    crate::init_logger();

    const SETUP: &[crate::TestObject] = &[
        crate::TestObject::Path("/usr/local/share/voa/arch/packages/default/openpgp/"),
        crate::TestObject::File("/usr/local/share/voa/arch/packages/default/openpgp/foo.pgp"),
        crate::TestObject::Path("/etc/voa/arch/packages/custom1/"),
        crate::TestObject::SymLink(
            "/usr/local/share/voa/arch/packages/default/openpgp",
            "/etc/voa/arch/packages/custom1/openpgp",
        ),
    ];

    crate::setup(SETUP)?;

    let voa = Voa::new();

    // Try to load verifiers via "custom1", which should return foo.pgp from the
    // `/usr/local/share` load path.
    let verifiers = voa.lookup(
        Os::new("arch".parse()?, None, None, None, None),
        Purpose::new(Role::Packages, Mode::ArtifactVerifier),
        Context::Custom(CustomContext::new("custom1".parse()?)),
        Technology::Openpgp,
    );

    warn!("Found verifiers: {verifiers:#?}");

    assert_eq!(verifiers.len(), 1);
    crate::compare_expected(
        &verifiers,
        &["/usr/local/share/voa/arch/packages/default/openpgp/foo.pgp"],
    );

    Ok(())
}

/// VOA setup with an invalid symlink between load paths.
///
/// A verifier in `/etc/voa` is symlinked from `/usr/local/share/voa`, and doesn't get accepted
/// because load paths may only symlink to load paths with lower priority
/// (https://uapi-group.org/specifications/specs/file_hierarchy_for_the_verification_of_os_artifacts/#symlinking).
#[test]
fn symlink_between_load_paths_invalid() -> TestResult {
    crate::init_logger();

    const SETUP: &[crate::TestObject] = &[
        crate::TestObject::Path("/etc/voa/arch/packages/default/openpgp/"),
        crate::TestObject::File("/etc/voa/arch/packages/default/openpgp/foo.pgp"),
        crate::TestObject::Path("/usr/local/share/voa/arch/packages/custom1/"),
        crate::TestObject::SymLink(
            "/etc/voa/arch/packages/default/openpgp",
            "/usr/local/share/voa/arch/packages/custom1/openpgp",
        ),
    ];

    crate::setup(SETUP)?;

    let voa = Voa::new();

    // Try to load verifiers via "custom1", which should return no verifiers because linking from
    // `/usr/local/share/voa` to `/etc/voa/` is not legal.
    let verifiers = voa.lookup(
        Os::new("arch".parse()?, None, None, None, None),
        Purpose::new(Role::Packages, Mode::ArtifactVerifier),
        Context::Custom(CustomContext::new("custom1".parse()?)),
        Technology::Openpgp,
    );

    warn!("Found verifiers: {verifiers:#?}");

    assert!(verifiers.is_empty());

    Ok(())
}

/// VOA setup with a valid relative symlink between load paths.
///
/// Finds a verifier in `/usr/local/share/voa` via a symlink from `/etc/voa`.
#[test]
fn relative_symlink_between_load_paths_valid() -> TestResult {
    crate::init_logger();

    const SETUP: &[crate::TestObject] = &[
        crate::TestObject::Path("/usr/local/share/voa/arch/packages/default/openpgp/"),
        crate::TestObject::File("/usr/local/share/voa/arch/packages/default/openpgp/foo.pgp"),
        crate::TestObject::Path("/etc/voa/arch/packages/custom1/"),
        crate::TestObject::SymLink(
            "../../../../../../usr/local/share/voa/arch/packages/default/openpgp",
            "/etc/voa/arch/packages/custom1/openpgp",
        ),
    ];

    crate::setup(SETUP)?;

    let voa = Voa::new();

    // Try to load verifiers via "custom1", which should return foo.pgp from the
    // `/usr/local/share` load path.
    let verifiers = voa.lookup(
        Os::new("arch".parse()?, None, None, None, None),
        Purpose::new(Role::Packages, Mode::ArtifactVerifier),
        Context::Custom(CustomContext::new("custom1".parse()?)),
        Technology::Openpgp,
    );

    warn!("Found verifiers: {verifiers:#?}");

    assert_eq!(verifiers.len(), 1);
    crate::compare_expected(
        &verifiers,
        &["/usr/local/share/voa/arch/packages/default/openpgp/foo.pgp"],
    );

    Ok(())
}

/// VOA setup with an invalid relative symlink between load paths.
///
/// A verifier in `/etc/voa` is symlinked from `/usr/local/share/voa`, and doesn't get accepted
/// because load paths may only symlink to load paths with lower priority
/// (https://uapi-group.org/specifications/specs/file_hierarchy_for_the_verification_of_os_artifacts/#symlinking).
#[test]
fn relative_symlink_between_load_paths_invalid() -> TestResult {
    crate::init_logger();

    const SETUP: &[crate::TestObject] = &[
        crate::TestObject::Path("/etc/voa/arch/packages/default/openpgp/"),
        crate::TestObject::File("/etc/voa/arch/packages/default/openpgp/foo.pgp"),
        crate::TestObject::Path("/usr/local/share/voa/arch/packages/custom1/"),
        crate::TestObject::SymLink(
            "../../../../../../../../etc/voa/arch/packages/default/openpgp",
            "/usr/local/share/voa/arch/packages/custom1/openpgp",
        ),
    ];

    crate::setup(SETUP)?;

    let voa = Voa::new();

    // Try to load verifiers via "custom1", which should return no verifiers because linking from
    // `/usr/local/share/voa` to `/etc/voa/` is not legal.
    let verifiers = voa.lookup(
        Os::new("arch".parse()?, None, None, None, None),
        Purpose::new(Role::Packages, Mode::ArtifactVerifier),
        Context::Custom(CustomContext::new("custom1".parse()?)),
        Technology::Openpgp,
    );

    warn!("Found verifiers: {verifiers:#?}");

    assert!(verifiers.is_empty());

    Ok(())
}

/// VOA setup with a verifier that contains data.
///
/// We find the verifier, read it, and check that it contains the expected data.
#[test]
fn read_verifier() -> TestResult {
    crate::init_logger();

    // Set up the verifier and write data into it
    const SETUP: &[crate::TestObject] = &[
        crate::TestObject::Path("/etc/voa/arch/packages/default/openpgp/"),
        crate::TestObject::FileWithContent(
            "/etc/voa/arch/packages/default/openpgp/foo.pgp",
            b"hello world",
        ),
    ];

    crate::setup(SETUP)?;

    // Find the verifier and read its data
    let voa = Voa::new();

    let mut verifiers = voa.lookup(
        Os::new("arch".parse()?, None, None, None, None),
        Purpose::new(Role::Packages, Mode::ArtifactVerifier),
        Context::Default,
        Technology::Openpgp,
    );

    warn!("Found verifiers: {verifiers:#?}");

    assert_eq!(verifiers.len(), 1);

    let mut verifier = &verifiers
        .first_entry()
        .unwrap()
        .get()
        .first()
        .unwrap()
        .open()?;

    let mut s = String::new();
    let _ = verifier.read_to_string(&mut s)?;

    assert_eq!(s, "hello world");

    Ok(())
}