use crate::format::{RegistryEntry, RegistryFile};

use super::*;

#[test]
fn mock_simple_init() {
    // (Pass) Should look the same as a fresh 'vet init'.

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (config, audits, imports) = files_inited(&metadata);

    let store = Store::mock(config, audits, imports);
    assert_report_snapshot!("mock-simple-init", metadata, store);
}

#[test]
fn mock_simple_no_exemptions() {
    // (Fail) Should look the same as a fresh 'vet init' but with all 'exemptions' entries deleted.

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (config, audits, imports) = files_no_exemptions(&metadata);

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("mock-simple-no-unaudited", metadata, store);
}

#[test]
fn mock_simple_full_audited() {
    // (Pass) All entries have direct full audits.

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (config, audits, imports) = files_full_audited(&metadata);

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("mock-simple-full-audited", metadata, store);
}

#[test]
fn builtin_simple_init() {
    // (Pass) Should look the same as a fresh 'vet init'.

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (config, audits, imports) = builtin_files_inited(&metadata);

    let store = Store::mock(config, audits, imports);
    assert_report_snapshot!("builtin-simple-init", metadata, store);
}

#[test]
fn builtin_simple_no_exemptions() {
    // (Fail) Should look the same as a fresh 'vet init' but with all 'exemptions' entries deleted.

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (config, audits, imports) = builtin_files_no_exemptions(&metadata);

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin-simple-no-unaudited", metadata, store);
}

#[test]
fn builtin_simple_full_audited() {
    // (Pass) All entries have direct full audits.

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (config, audits, imports) = builtin_files_full_audited(&metadata);

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin-simple-full-audited", metadata, store);
}

#[test]
fn mock_simple_missing_transitive() {
    // (Fail) Missing an audit for a transitive dep

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (config, mut audits, imports) = files_full_audited(&metadata);

    audits
        .audits
        .get_mut("transitive-third-party1")
        .unwrap()
        .clear();

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("mock-simple-missing-transitive", metadata, store);
}

#[test]
fn mock_simple_missing_direct_internal() {
    // (Fail) Missing an audit for a direct dep that has children

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (config, mut audits, imports) = files_full_audited(&metadata);

    audits.audits.get_mut("third-party1").unwrap().clear();

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("mock-simple-missing-direct-internal", metadata, store);
}

#[test]
fn mock_simple_missing_direct_leaf() {
    // (Fail) Missing an entry for direct dep that has no children

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (config, mut audits, imports) = files_full_audited(&metadata);

    audits.audits.get_mut("third-party2").unwrap().clear();

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("mock-simple-missing-direct-leaf", metadata, store);
}

#[test]
fn mock_simple_missing_leaves() {
    // (Fail) Missing all leaf audits (but not the internal)

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (config, mut audits, imports) = files_full_audited(&metadata);

    audits.audits.get_mut("third-party2").unwrap().clear();
    audits
        .audits
        .get_mut("transitive-third-party1")
        .unwrap()
        .clear();

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("mock-simple-missing-leaves", metadata, store);
}

#[test]
fn mock_simple_weaker_transitive_req() {
    // (Pass) A third-party dep with weaker requirements on a child dep

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (mut config, mut audits, imports) = files_full_audited(&metadata);

    let trans_audits = &mut audits.audits.get_mut("transitive-third-party1").unwrap();
    trans_audits.clear();
    trans_audits.push(full_audit(ver(DEFAULT_VER), "weak-reviewed"));

    let direct_audits = &mut audits.audits.get_mut("third-party1").unwrap();
    direct_audits.clear();
    direct_audits.push(full_audit(ver(DEFAULT_VER), "reviewed"));

    config.policy.insert(
        "third-party1".to_string(),
        dep_policy([("transitive-third-party1", ["weak-reviewed"])]),
    );

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("mock-simple-weaker-transitive-req", metadata, store);
}

#[test]
fn mock_simple_weaker_transitive_req_using_implies() {
    // (Pass) A third-party dep with weaker requirements on a child dep
    // but the child dep actually has *super* reqs, to check that implies works

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (mut config, mut audits, imports) = files_full_audited(&metadata);

    let trans_audits = &mut audits.audits.get_mut("transitive-third-party1").unwrap();
    trans_audits.clear();
    trans_audits.push(full_audit(ver(DEFAULT_VER), "strong-reviewed"));

    let direct_audits = &mut audits.audits.get_mut("third-party1").unwrap();
    direct_audits.clear();
    direct_audits.push(full_audit(ver(DEFAULT_VER), "reviewed"));

    config.policy.insert(
        "third-party1".to_string(),
        dep_policy([("transitive-third-party1", ["weak-reviewed"])]),
    );

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!(
        "mock-simple-weaker-transitive-req-using-implies",
        metadata,
        store
    );
}

#[test]
fn mock_simple_lower_version_review() {
    // (Fail) A dep that has a review but for a lower version.

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (config, mut audits, imports) = files_full_audited(&metadata);

    let direct_audits = &mut audits.audits.get_mut("third-party1").unwrap();
    direct_audits.clear();
    direct_audits.push(full_audit(ver(DEFAULT_VER - 1), DEFAULT_CRIT));

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("mock-simple-lower-version-review", metadata, store);
}

#[test]
fn mock_simple_higher_version_review() {
    // (Fail) A dep that has a review but for a higher version.

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (config, mut audits, imports) = files_full_audited(&metadata);

    let direct_audits = &mut audits.audits.get_mut("third-party1").unwrap();
    direct_audits.clear();
    direct_audits.push(full_audit(ver(DEFAULT_VER + 1), DEFAULT_CRIT));

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("mock-simple-higher-version-review", metadata, store);
}

#[test]
fn mock_simple_higher_and_lower_version_review() {
    // (Fail) A dep that has a review but for both a higher and lower version.
    // Once I mock out fake diffs it should prefer the lower one because the
    // system will make application size grow quadratically.

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (config, mut audits, imports) = files_full_audited(&metadata);

    let direct_audits = &mut audits.audits.get_mut("third-party1").unwrap();
    direct_audits.clear();
    direct_audits.push(full_audit(ver(DEFAULT_VER - 1), DEFAULT_CRIT));
    direct_audits.push(full_audit(ver(DEFAULT_VER + 1), DEFAULT_CRIT));

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!(
        "mock-simple-higher-and-lower-version-review",
        metadata,
        store
    );
}

#[test]
fn mock_simple_reviewed_too_weakly() {
    // (Fail) A dep has a review but the criteria is too weak

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (config, mut audits, imports) = files_full_audited(&metadata);

    let trans_audits = &mut audits.audits.get_mut("transitive-third-party1").unwrap();
    trans_audits.clear();
    trans_audits.push(full_audit(ver(DEFAULT_VER), "weak-reviewed"));

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("mock-simple-reviewed-too-weakly", metadata, store);
}

#[test]
fn mock_simple_delta_to_exemptions() {
    // (Pass) A dep has a delta to an exemptions entry

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (mut config, mut audits, imports) = files_full_audited(&metadata);

    let direct_audits = &mut audits.audits.get_mut("third-party1").unwrap();
    direct_audits.clear();
    direct_audits.push(delta_audit(
        ver(DEFAULT_VER - 5),
        ver(DEFAULT_VER),
        DEFAULT_CRIT,
    ));

    let direct_exemptions = &mut config.exemptions;
    direct_exemptions.insert(
        "third-party1".to_string(),
        vec![exemptions(ver(DEFAULT_VER - 5), DEFAULT_CRIT)],
    );

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("mock-simple-delta-to-unaudited", metadata, store);
}

#[test]
fn mock_simple_delta_to_exemptions_overshoot() {
    // (Fail) A dep has a delta but it overshoots the exemptions entry.

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (mut config, mut audits, imports) = files_full_audited(&metadata);

    let direct_audits = &mut audits.audits.get_mut("third-party1").unwrap();
    direct_audits.clear();
    direct_audits.push(delta_audit(
        ver(DEFAULT_VER - 6),
        ver(DEFAULT_VER),
        DEFAULT_CRIT,
    ));

    let direct_exemptions = &mut config.exemptions;
    direct_exemptions.insert(
        "third-party1".to_string(),
        vec![exemptions(ver(DEFAULT_VER - 5), DEFAULT_CRIT)],
    );

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("mock-simple-delta-to-unaudited-overshoot", metadata, store);
}

#[test]
fn mock_simple_delta_to_exemptions_undershoot() {
    // (Fail) A dep has a delta but it undershoots the exemptions entry.

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (mut config, mut audits, imports) = files_full_audited(&metadata);

    let direct_audits = &mut audits.audits.get_mut("third-party1").unwrap();
    direct_audits.clear();
    direct_audits.push(delta_audit(
        ver(DEFAULT_VER - 3),
        ver(DEFAULT_VER),
        DEFAULT_CRIT,
    ));

    let direct_exemptions = &mut config.exemptions;
    direct_exemptions.insert(
        "third-party1".to_string(),
        vec![exemptions(ver(DEFAULT_VER - 5), DEFAULT_CRIT)],
    );

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("mock-simple-delta-to-unaudited-undershoot", metadata, store);
}

#[test]
fn mock_simple_delta_to_full_audit() {
    // (Pass) A dep has a delta to a fully audited entry

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (config, mut audits, imports) = files_full_audited(&metadata);

    let direct_audits = &mut audits.audits.get_mut("third-party1").unwrap();
    direct_audits.clear();
    direct_audits.push(delta_audit(
        ver(DEFAULT_VER - 5),
        ver(DEFAULT_VER),
        DEFAULT_CRIT,
    ));
    direct_audits.push(full_audit(ver(DEFAULT_VER - 5), DEFAULT_CRIT));

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("mock-simple-delta-to-full-audit", metadata, store);
}

#[test]
fn mock_simple_delta_to_full_audit_overshoot() {
    // (Fail) A dep has a delta to a fully audited entry but overshoots

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (config, mut audits, imports) = files_full_audited(&metadata);

    let direct_audits = &mut audits.audits.get_mut("third-party1").unwrap();
    direct_audits.clear();
    direct_audits.push(delta_audit(
        ver(DEFAULT_VER - 6),
        ver(DEFAULT_VER),
        DEFAULT_CRIT,
    ));
    direct_audits.push(full_audit(ver(DEFAULT_VER - 5), DEFAULT_CRIT));

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("mock-simple-delta-to-full-audit-overshoot", metadata, store);
}

#[test]
fn mock_simple_delta_to_full_audit_undershoot() {
    // (Fail) A dep has a delta to a fully audited entry but undershoots

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (config, mut audits, imports) = files_full_audited(&metadata);

    let direct_audits = &mut audits.audits.get_mut("third-party1").unwrap();
    direct_audits.clear();
    direct_audits.push(delta_audit(
        ver(DEFAULT_VER - 3),
        ver(DEFAULT_VER),
        DEFAULT_CRIT,
    ));
    direct_audits.push(full_audit(ver(DEFAULT_VER - 5), DEFAULT_CRIT));

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!(
        "mock-simple-delta-to-full-audit-undershoot",
        metadata,
        store
    );
}

#[test]
fn mock_simple_reverse_delta_to_full_audit() {
    // (Pass) A dep has a *reverse* delta to a fully audited entry

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (config, mut audits, imports) = files_full_audited(&metadata);

    let direct_audits = &mut audits.audits.get_mut("third-party1").unwrap();
    direct_audits.clear();
    direct_audits.push(delta_audit(
        ver(DEFAULT_VER + 5),
        ver(DEFAULT_VER),
        DEFAULT_CRIT,
    ));
    direct_audits.push(full_audit(ver(DEFAULT_VER + 5), DEFAULT_CRIT));

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("mock-simple-reverse-delta-to-full-audit", metadata, store);
}

#[test]
fn mock_simple_reverse_delta_to_exemptions() {
    // (Pass) A dep has a *reverse* delta to an exemptions entry

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (mut config, mut audits, imports) = files_full_audited(&metadata);

    let direct_audits = &mut audits.audits.get_mut("third-party1").unwrap();
    direct_audits.clear();
    direct_audits.push(delta_audit(
        ver(DEFAULT_VER + 5),
        ver(DEFAULT_VER),
        DEFAULT_CRIT,
    ));

    let direct_exemptions = &mut config.exemptions;
    direct_exemptions.insert(
        "third-party1".to_string(),
        vec![exemptions(ver(DEFAULT_VER + 5), DEFAULT_CRIT)],
    );

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("mock-simple-reverse-delta-to-unaudited", metadata, store);
}

#[test]
fn mock_simple_wrongly_reversed_delta_to_exemptions() {
    // (Fail) A dep has a *reverse* delta to an exemptions entry but they needed a normal one

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (mut config, mut audits, imports) = files_full_audited(&metadata);

    let direct_audits = &mut audits.audits.get_mut("third-party1").unwrap();
    direct_audits.clear();
    direct_audits.push(delta_audit(
        ver(DEFAULT_VER),
        ver(DEFAULT_VER - 5),
        DEFAULT_CRIT,
    ));

    let direct_exemptions = &mut config.exemptions;
    direct_exemptions.insert(
        "third-party1".to_string(),
        vec![exemptions(ver(DEFAULT_VER - 5), DEFAULT_CRIT)],
    );

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!(
        "mock-simple-wrongly-reversed-delta-to-unaudited",
        metadata,
        store
    );
}

#[test]
fn mock_simple_wrongly_reversed_delta_to_full_audit() {
    // (Fail) A dep has a *reverse* delta to a fully audited entry but they needed a normal one

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (config, mut audits, imports) = files_full_audited(&metadata);

    let direct_audits = &mut audits.audits.get_mut("third-party1").unwrap();
    direct_audits.clear();
    direct_audits.push(delta_audit(
        ver(DEFAULT_VER),
        ver(DEFAULT_VER - 5),
        DEFAULT_CRIT,
    ));
    direct_audits.push(full_audit(ver(DEFAULT_VER - 5), DEFAULT_CRIT));

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!(
        "mock-simple-wrongly-reversed-delta-to-full-audit",
        metadata,
        store
    );
}

#[test]
fn mock_simple_needed_reversed_delta_to_exemptions() {
    // (Fail) A dep has a delta to an exemptions entry but they needed a reversed one

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (mut config, mut audits, imports) = files_full_audited(&metadata);

    let direct_audits = &mut audits.audits.get_mut("third-party1").unwrap();
    direct_audits.clear();
    direct_audits.push(delta_audit(
        ver(DEFAULT_VER),
        ver(DEFAULT_VER + 5),
        DEFAULT_CRIT,
    ));

    let direct_exemptions = &mut config.exemptions;
    direct_exemptions.insert(
        "third-party1".to_string(),
        vec![exemptions(ver(DEFAULT_VER + 5), DEFAULT_CRIT)],
    );

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!(
        "mock-simple-needed-reversed-delta-to-unaudited",
        metadata,
        store
    );
}

#[test]
fn mock_simple_delta_to_exemptions_too_weak() {
    // (Fail) A dep has a delta to an exemptions entry but it's too weak

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (mut config, mut audits, imports) = files_full_audited(&metadata);

    let direct_audits = &mut audits.audits.get_mut("third-party1").unwrap();
    direct_audits.clear();
    direct_audits.push(delta_audit(
        ver(DEFAULT_VER - 5),
        ver(DEFAULT_VER),
        "weak-reviewed",
    ));

    let direct_exemptions = &mut config.exemptions;
    direct_exemptions.insert(
        "third-party1".to_string(),
        vec![exemptions(ver(DEFAULT_VER - 5), DEFAULT_CRIT)],
    );

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("mock-simple-delta-to-unaudited-too-weak", metadata, store);
}

#[test]
fn mock_simple_delta_to_full_audit_too_weak() {
    // (Fail) A dep has a delta to a fully audited entry but it's too weak

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (config, mut audits, imports) = files_full_audited(&metadata);

    let direct_audits = &mut audits.audits.get_mut("third-party1").unwrap();
    direct_audits.clear();
    direct_audits.push(delta_audit(
        ver(DEFAULT_VER - 5),
        ver(DEFAULT_VER),
        "weak-reviewed",
    ));
    direct_audits.push(full_audit(ver(DEFAULT_VER - 5), DEFAULT_CRIT));

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("mock-simple-delta-to-full-audit-too-weak", metadata, store);
}

#[test]
fn mock_simple_delta_to_too_weak_full_audit() {
    // (Fail) A dep has a delta to a fully audited entry but it's too weak

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (config, mut audits, imports) = files_full_audited(&metadata);

    let direct_audits = &mut audits.audits.get_mut("third-party1").unwrap();
    direct_audits.clear();
    direct_audits.push(delta_audit(
        ver(DEFAULT_VER - 5),
        ver(DEFAULT_VER),
        DEFAULT_CRIT,
    ));
    direct_audits.push(full_audit(ver(DEFAULT_VER - 5), "weak-reviewed"));

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("mock-simple-delta-to-too-weak-full-audit", metadata, store);
}

#[test]
fn mock_complex_inited() {
    // (Fail) Should look the same as a fresh 'vet init' but with all 'exemptions' entries deleted.

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::complex();
    let metadata = mock.metadata();
    let (config, audits, imports) = files_inited(&metadata);

    let store = Store::mock(config, audits, imports);
    assert_report_snapshot!("mock-complex-inited", metadata, store);
}

#[test]
fn mock_complex_no_exemptions() {
    // (Fail) Should look the same as a fresh 'vet init' but with all 'exemptions' entries deleted.

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::complex();
    let metadata = mock.metadata();
    let (config, audits, imports) = files_no_exemptions(&metadata);

    let store = Store::mock(config, audits, imports);
    assert_report_snapshot!("mock-complex-no-unaudited", metadata, store);
}

#[test]
fn mock_complex_full_audited() {
    // (Pass) All entries have direct full audits.

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::complex();
    let metadata = mock.metadata();
    let (config, audits, imports) = files_full_audited(&metadata);

    let store = Store::mock(config, audits, imports);
    assert_report_snapshot!("mock-complex-full-audited", metadata, store);
}

#[test]
fn builtin_complex_inited() {
    // (Fail) Should look the same as a fresh 'vet init' but with all 'exemptions' entries deleted.

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::complex();
    let metadata = mock.metadata();
    let (config, audits, imports) = builtin_files_inited(&metadata);

    let store = Store::mock(config, audits, imports);
    assert_report_snapshot!("builtin-complex-inited", metadata, store);
}

#[test]
fn builtin_complex_no_exemptions() {
    // (Fail) Should look the same as a fresh 'vet init' but with all 'exemptions' entries deleted.

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::complex();
    let metadata = mock.metadata();
    let (config, audits, imports) = builtin_files_no_exemptions(&metadata);

    let store = Store::mock(config, audits, imports);
    assert_report_snapshot!("builtin-complex-no-unaudited", metadata, store);
}

#[test]
fn builtin_complex_full_audited() {
    // (Pass) All entries have direct full audits.

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::complex();
    let metadata = mock.metadata();
    let (config, audits, imports) = builtin_files_full_audited(&metadata);

    let store = Store::mock(config, audits, imports);
    assert_report_snapshot!("builtin-complex-full-audited", metadata, store);
}

#[test]
fn builtin_complex_minimal_audited() {
    // (Pass) All entries have direct full audits.

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::complex();
    let metadata = mock.metadata();
    let (config, audits, imports) = builtin_files_minimal_audited(&metadata);

    let store = Store::mock(config, audits, imports);
    assert_report_snapshot!("builtin-complex-minimal-audited", metadata, store);
}

#[test]
fn mock_complex_missing_core5() {
    // (Fail) Missing an audit for the v5 version of third-core

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::complex();
    let metadata = mock.metadata();
    let (config, mut audits, imports) = files_full_audited(&metadata);

    audits.audits.insert(
        "third-core".to_string(),
        vec![full_audit(ver(DEFAULT_VER), "reviewed")],
    );

    let store = Store::mock(config, audits, imports);
    assert_report_snapshot!("mock-complex-missing-core5", metadata, store);
}

#[test]
fn mock_complex_missing_core10() {
    // (Fail) Missing an audit for the v10 version of third-core

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::complex();
    let metadata = mock.metadata();
    let (config, mut audits, imports) = files_full_audited(&metadata);

    audits.audits.insert(
        "third-core".to_string(),
        vec![full_audit(ver(5), "reviewed")],
    );

    let store = Store::mock(config, audits, imports);
    assert_report_snapshot!("mock-complex-missing-core10", metadata, store);
}

#[test]
fn mock_complex_core10_too_weak() {
    // (Fail) Criteria for core10 is too weak

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::complex();
    let metadata = mock.metadata();
    let (config, mut audits, imports) = files_full_audited(&metadata);

    audits.audits.insert(
        "third-core".to_string(),
        vec![
            full_audit(ver(DEFAULT_VER), "weak-reviewed"),
            full_audit(ver(5), "reviewed"),
        ],
    );

    let store = Store::mock(config, audits, imports);
    assert_report_snapshot!("mock-complex-core10-too-weak", metadata, store);
}

#[test]
fn mock_complex_core10_partially_too_weak() {
    // (Fail) Criteria for core10 is too weak for thirdA but not thirdA and thirdAB (full)

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::complex();
    let metadata = mock.metadata();
    let (mut config, mut audits, imports) = files_full_audited(&metadata);

    audits.audits.insert(
        "third-core".to_string(),
        vec![
            full_audit(ver(DEFAULT_VER), "weak-reviewed"),
            full_audit(ver(5), "reviewed"),
        ],
    );

    let audit_with_weaker_req = full_audit(ver(DEFAULT_VER), "reviewed");
    audits
        .audits
        .insert("thirdA".to_string(), vec![audit_with_weaker_req.clone()]);
    audits
        .audits
        .insert("thirdAB".to_string(), vec![audit_with_weaker_req]);

    config.policy.insert(
        "thirdA".to_string(),
        dep_policy([("third-core", ["weak-reviewed"])]),
    );
    config.policy.insert(
        "thirdAB".to_string(),
        dep_policy([("third-core", ["weak-reviewed"])]),
    );

    let store = Store::mock(config, audits, imports);
    assert_report_snapshot!("mock-complex-core10-partially-too-weak", metadata, store);
}

#[test]
fn mock_complex_core10_partially_too_weak_via_weak_delta() {
    // (Fail) Criteria for core10 is too weak for thirdA but not thirdA and thirdAB (weak delta)

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::complex();
    let metadata = mock.metadata();
    let (mut config, mut audits, imports) = files_full_audited(&metadata);

    audits.audits.insert(
        "third-core".to_string(),
        vec![
            delta_audit(ver(5), ver(DEFAULT_VER), "weak-reviewed"),
            full_audit(ver(5), "reviewed"),
        ],
    );

    let audit_with_weaker_req = full_audit(ver(DEFAULT_VER), "reviewed");
    audits
        .audits
        .insert("thirdA".to_string(), vec![audit_with_weaker_req.clone()]);
    audits
        .audits
        .insert("thirdAB".to_string(), vec![audit_with_weaker_req]);

    config.policy.insert(
        "thirdA".to_string(),
        dep_policy([("third-core", ["weak-reviewed"])]),
    );
    config.policy.insert(
        "thirdAB".to_string(),
        dep_policy([("third-core", ["weak-reviewed"])]),
    );

    let store = Store::mock(config, audits, imports);
    assert_report_snapshot!(
        "mock-complex-core10-partially-too-weak-via-weak-delta",
        metadata,
        store
    );
}

#[test]
fn mock_complex_core10_partially_too_weak_via_strong_delta() {
    // (Fail) Criteria for core10 is too weak for thirdA but not thirdA and thirdAB
    // because there's a strong delta from 5->10 but 0->5 is still weak!

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::complex();
    let metadata = mock.metadata();
    let (mut config, mut audits, imports) = files_full_audited(&metadata);

    audits.audits.insert(
        "third-core".to_string(),
        vec![
            delta_audit(ver(5), ver(DEFAULT_VER), "reviewed"),
            full_audit(ver(5), "weak-reviewed"),
        ],
    );

    let audit_with_weaker_req = full_audit(ver(DEFAULT_VER), "reviewed");
    audits
        .audits
        .insert("thirdA".to_string(), vec![audit_with_weaker_req.clone()]);
    audits
        .audits
        .insert("thirdAB".to_string(), vec![audit_with_weaker_req]);

    config.policy.insert(
        "firstA".to_string(),
        dep_policy([("third-core", ["weak-reviewed"])]),
    );
    config.policy.insert(
        "thirdA".to_string(),
        dep_policy([("third-core", ["weak-reviewed"])]),
    );
    config.policy.insert(
        "thirdAB".to_string(),
        dep_policy([("third-core", ["weak-reviewed"])]),
    );

    let store = Store::mock(config, audits, imports);
    assert_report_snapshot!(
        "mock-complex-core10-partially-too-weak-via-strong-delta",
        metadata,
        store
    );
}

#[test]
fn mock_simple_policy_root_too_strong() {
    // (Fail) Root policy is too strong

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();
    let metadata = mock.metadata();
    let (mut config, audits, imports) = files_full_audited(&metadata);

    config
        .policy
        .insert("root-package".to_string(), self_policy(["strong-reviewed"]));

    let store = Store::mock(config, audits, imports);
    assert_report_snapshot!("simple-policy-root-too-strong", metadata, store);
}

#[test]
fn mock_simple_policy_root_weaker() {
    // (Pass) Root policy weaker than necessary

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();
    let metadata = mock.metadata();
    let (mut config, audits, imports) = files_full_audited(&metadata);

    config
        .policy
        .insert("root-package".to_string(), self_policy(["weak-reviewed"]));

    let store = Store::mock(config, audits, imports);
    assert_report_snapshot!("simple-policy-root-weaker", metadata, store);
}

#[test]
fn mock_simple_policy_first_too_strong() {
    // (Fail) First-party policy is too strong

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();
    let metadata = mock.metadata();
    let (mut config, audits, imports) = files_full_audited(&metadata);

    config
        .policy
        .insert("first-party".to_string(), self_policy(["strong-reviewed"]));

    let store = Store::mock(config, audits, imports);
    assert_report_snapshot!("simple-policy-first-too-strong", metadata, store);
}

#[test]
fn mock_simple_policy_first_weaker() {
    // (Pass) First-party policy weaker than necessary

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();
    let metadata = mock.metadata();
    let (mut config, audits, imports) = files_full_audited(&metadata);

    config
        .policy
        .insert("first-party".to_string(), self_policy(["weak-reviewed"]));

    let store = Store::mock(config, audits, imports);
    assert_report_snapshot!("simple-policy-first-weaker", metadata, store);
}

#[test]
fn mock_simple_policy_root_dep_weaker() {
    // (Pass) root->first-party policy weaker than necessary

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();
    let metadata = mock.metadata();
    let (mut config, audits, imports) = files_full_audited(&metadata);

    config.policy.insert(
        "root-package".to_string(),
        dep_policy([("first-party", ["weak-reviewed"])]),
    );

    let store = Store::mock(config, audits, imports);
    assert_report_snapshot!("simple-policy-root-dep-weaker", metadata, store);
}

#[test]
fn mock_simple_policy_root_dep_too_strong() {
    // (Pass) root->first-party policy stronger than necessary

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();
    let metadata = mock.metadata();
    let (mut config, audits, imports) = files_full_audited(&metadata);

    config.policy.insert(
        "root-package".to_string(),
        dep_policy([("first-party", ["strong-reviewed"])]),
    );

    let store = Store::mock(config, audits, imports);
    assert_report_snapshot!("simple-policy-root-dep-too-strong", metadata, store);
}

#[test]
fn mock_simple_policy_first_dep_weaker() {
    // (Pass) first-party->third-party policy weaker than necessary

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();
    let metadata = mock.metadata();
    let (mut config, audits, imports) = files_full_audited(&metadata);

    config.policy.insert(
        "first-party".to_string(),
        dep_policy([("third-party1", ["weak-reviewed"])]),
    );

    let store = Store::mock(config, audits, imports);
    assert_report_snapshot!("simple-policy-first-dep-weaker", metadata, store);
}

#[test]
fn mock_simple_policy_first_dep_too_strong() {
    // (Pass) first-party->third-party policy too strong

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();
    let metadata = mock.metadata();
    let (mut config, audits, imports) = files_full_audited(&metadata);

    config.policy.insert(
        "first-party".to_string(),
        dep_policy([("third-party1", ["strong-reviewed"])]),
    );

    let store = Store::mock(config, audits, imports);
    assert_report_snapshot!("simple-policy-first-dep-too-strong", metadata, store);
}

#[test]
fn mock_simple_policy_first_dep_stronger() {
    // (Pass) first-party->third-party policy stronger but satisfied

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();
    let metadata = mock.metadata();
    let (mut config, mut audits, imports) = files_full_audited(&metadata);

    config.policy.insert(
        "first-party".to_string(),
        dep_policy([("third-party2", ["strong-reviewed"])]),
    );

    audits.audits.insert(
        "third-party2".to_string(),
        vec![full_audit(ver(DEFAULT_VER), "strong-reviewed")],
    );

    let store = Store::mock(config, audits, imports);
    assert_report_snapshot!("simple-policy-first-dep-stronger", metadata, store);
}

#[test]
fn mock_simple_policy_first_dep_weaker_needed() {
    // (Pass) first-party->third-party policy weaker out of necessity

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();
    let metadata = mock.metadata();
    let (mut config, mut audits, imports) = files_full_audited(&metadata);

    config.policy.insert(
        "first-party".to_string(),
        dep_policy([("third-party1", ["weak-reviewed"])]),
    );

    audits.audits.insert(
        "third-party1".to_string(),
        vec![full_audit(ver(DEFAULT_VER), "weak-reviewed")],
    );

    let store = Store::mock(config, audits, imports);
    assert_report_snapshot!("simple-policy-first-dep-weaker-needed", metadata, store);
}

#[test]
fn mock_simple_policy_first_dep_extra() {
    // (Pass) first-party->third-party policy has extra satisfied criteria

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();
    let metadata = mock.metadata();
    let (mut config, mut audits, imports) = files_full_audited(&metadata);

    config.policy.insert(
        "first-party".to_string(),
        dep_policy([("third-party2", ["reviewed", "fuzzed"])]),
    );

    audits.audits.insert(
        "third-party2".to_string(),
        vec![
            full_audit(ver(DEFAULT_VER), "reviewed"),
            full_audit(ver(DEFAULT_VER), "fuzzed"),
        ],
    );

    let store = Store::mock(config, audits, imports);
    assert_report_snapshot!("simple-policy-first-dep-extra", metadata, store);
}

#[test]
fn mock_simple_policy_first_dep_extra_missing() {
    // (Fail) first-party->third-party policy has extra unsatisfied criteria

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();
    let metadata = mock.metadata();
    let (mut config, mut audits, imports) = files_full_audited(&metadata);

    config.policy.insert(
        "first-party".to_string(),
        dep_policy([("third-party2", ["reviewed", "fuzzed"])]),
    );

    audits.audits.insert(
        "third-party2".to_string(),
        vec![full_audit(ver(DEFAULT_VER), "reviewed")],
    );

    let store = Store::mock(config, audits, imports);
    assert_report_snapshot!("simple-policy-first-dep-extra-missing", metadata, store);
}

#[test]
fn mock_simple_policy_first_extra_partially_missing() {
    // (Fail) first-party policy has extra unsatisfied criteria

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();
    let metadata = mock.metadata();
    let (mut config, mut audits, imports) = files_full_audited(&metadata);

    config.policy.insert(
        "first-party".to_string(),
        self_policy(["reviewed", "fuzzed"]),
    );

    audits.audits.insert(
        "third-party2".to_string(),
        vec![
            full_audit(ver(DEFAULT_VER), "reviewed"),
            full_audit(ver(DEFAULT_VER), "fuzzed"),
        ],
    );

    let store = Store::mock(config, audits, imports);
    assert_report_snapshot!(
        "simple-policy-first-extra-partially-missing",
        metadata,
        store
    );
}

#[test]
fn mock_simple_first_policy_redundant() {
    // (Pass) first-party policy has redundant implied things

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();
    let metadata = mock.metadata();
    let (mut config, audits, imports) = files_full_audited(&metadata);

    config.policy.insert(
        "first-party".to_string(),
        self_policy(["reviewed", "weak-reviewed"]),
    );

    let store = Store::mock(config, audits, imports);
    assert_report_snapshot!("simple-policy-first-policy-redundant", metadata, store);
}

#[test]
fn builtin_simple_deps_inited() {
    // (Pass) Should look the same as a fresh 'vet init'.
    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple_deps();

    let metadata = mock.metadata();
    let (config, audits, imports) = builtin_files_inited(&metadata);

    let store = Store::mock(config, audits, imports);
    assert_report_snapshot!("builtin-simple-deps-init", metadata, store);
}

#[test]
fn builtin_simple_deps_no_exemptions() {
    // (Fail) Should look the same as a fresh 'vet init' but with all 'exemptions' entries deleted.

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple_deps();

    let metadata = mock.metadata();
    let (config, audits, imports) = builtin_files_no_exemptions(&metadata);

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin-simple-deps-no-unaudited", metadata, store);
}

#[test]
fn builtin_simple_deps_full_audited() {
    // (Pass) All entries have direct full audits.

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple_deps();

    let metadata = mock.metadata();
    let (config, audits, imports) = builtin_files_full_audited(&metadata);

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin-simple-deps-full-audited", metadata, store);
}

#[test]
fn builtin_simple_deps_minimal_audited() {
    // (Pass) All entries have direct full audits.

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple_deps();

    let metadata = mock.metadata();
    let (config, audits, imports) = builtin_files_minimal_audited(&metadata);

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin-simple-deps-minimal-audited", metadata, store);
}

#[test]
fn builtin_no_deps() {
    // (Pass) No actual deps
    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::new(vec![MockPackage {
        name: "root-package",
        is_workspace: true,
        is_first_party: true,
        deps: vec![],
        ..Default::default()
    }]);

    let metadata = mock.metadata();
    let (config, audits, imports) = builtin_files_full_audited(&metadata);

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin-no-deps", metadata, store);
}

#[test]
fn builtin_only_first_deps() {
    // (Pass) No actual deps
    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::new(vec![
        MockPackage {
            name: "root-package",
            is_workspace: true,
            is_first_party: true,
            deps: vec![dep("first-party")],
            ..Default::default()
        },
        MockPackage {
            name: "first-party",
            is_first_party: true,
            deps: vec![],
            ..Default::default()
        },
    ]);

    let metadata = mock.metadata();
    let (config, audits, imports) = builtin_files_full_audited(&metadata);

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin-only-first-deps", metadata, store);
}

#[test]
fn builtin_cycle_inited() {
    // (Pass) Should look the same as a fresh 'vet init'.
    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::cycle();

    let metadata = mock.metadata();
    let (config, audits, imports) = builtin_files_inited(&metadata);

    let store = Store::mock(config, audits, imports);
    assert_report_snapshot!("builtin-cycle-inited", metadata, store);
}

#[test]
fn builtin_cycle_exemptions() {
    // (Fail) Should look the same as a fresh 'vet init' but with all 'exemptions' entries deleted.

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::cycle();

    let metadata = mock.metadata();
    let (config, audits, imports) = builtin_files_no_exemptions(&metadata);

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin-cycle-unaudited", metadata, store);
}

#[test]
fn builtin_cycle_full_audited() {
    // (Pass) All entries have direct full audits.

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::cycle();

    let metadata = mock.metadata();
    let (config, audits, imports) = builtin_files_full_audited(&metadata);

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin-cycle-full-audited", metadata, store);
}

#[test]
fn builtin_cycle_minimal_audited() {
    // (Pass) All entries have direct full audits.

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::cycle();

    let metadata = mock.metadata();
    let (config, audits, imports) = builtin_files_minimal_audited(&metadata);

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin-cycle-minimal-audited", metadata, store);
}

#[test]
fn builtin_dev_detection() {
    // (Pass) Check that we properly identify things that are or aren't only dev-deps,
    // even when they're indirect or used in both contexts.

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::dev_detection();

    let metadata = mock.metadata();
    let (config, mut audits, imports) = builtin_files_no_exemptions(&metadata);
    audits.audits.insert(
        "normal".to_string(),
        vec![full_audit(ver(DEFAULT_VER), SAFE_TO_DEPLOY)],
    );
    audits.audits.insert(
        "both".to_string(),
        vec![full_audit(ver(DEFAULT_VER), SAFE_TO_DEPLOY)],
    );
    audits.audits.insert(
        "simple-dev".to_string(),
        vec![full_audit(ver(DEFAULT_VER), SAFE_TO_RUN)],
    );
    audits.audits.insert(
        "simple-dev-indirect".to_string(),
        vec![full_audit(ver(DEFAULT_VER), SAFE_TO_RUN)],
    );
    audits.audits.insert(
        "dev-cycle-direct".to_string(),
        vec![full_audit(ver(DEFAULT_VER), SAFE_TO_RUN)],
    );
    audits.audits.insert(
        "dev-cycle-indirect".to_string(),
        vec![full_audit(ver(DEFAULT_VER), SAFE_TO_RUN)],
    );

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin-dev-detection", metadata, store);
}

#[test]
fn builtin_dev_detection_empty() {
    // (Fail) same as above but without any audits to confirm expectations

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::dev_detection();

    let metadata = mock.metadata();
    let (config, audits, imports) = builtin_files_no_exemptions(&metadata);

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin-dev-detection-empty", metadata, store);
}

#[test]
fn builtin_dev_detection_empty_deeper() {
    // (Fail) same as above but deeper

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::dev_detection();

    let metadata = mock.metadata();
    let (config, audits, imports) = builtin_files_no_exemptions(&metadata);

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin-dev-detection-empty-deeper", metadata, store);
}

#[test]
fn builtin_simple_exemptions_extra() {
    // (Pass) there's an extra unused exemptions entry, but the other is needed
    // (This test could warn if we try to detect "useless exemptions" eagerly)

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (mut config, mut audits, imports) = builtin_files_full_audited(&metadata);

    audits.audits.insert("third-party1".to_string(), vec![]);

    config.exemptions.insert(
        "third-party1".to_string(),
        vec![
            exemptions(ver(5), SAFE_TO_DEPLOY),
            exemptions(ver(DEFAULT_VER), SAFE_TO_DEPLOY),
        ],
    );

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin-simple-unaudited-extra", metadata, store);
}

#[test]
fn builtin_simple_exemptions_not_a_real_dep() {
    // (Pass) there's an exemptions entry for a package that isn't in our tree at all.
    // (This test could warn if we try to detect "useless exemptions" eagerly)

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (mut config, audits, imports) = builtin_files_full_audited(&metadata);

    config.exemptions.insert(
        "fake-dep".to_string(),
        vec![exemptions(ver(DEFAULT_VER), SAFE_TO_DEPLOY)],
    );

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin-simple-not-a-real-dep", metadata, store);
}

#[test]
fn builtin_simple_deps_exemptions_overbroad() {
    // (Pass) the exemptions entry is needed but it's overbroad
    // (This test could warn if we try to detect "useless exemptions" eagerly)

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple_deps();

    let metadata = mock.metadata();
    let (mut config, mut audits, imports) = builtin_files_full_audited(&metadata);

    audits.audits.insert("dev".to_string(), vec![]);

    config.exemptions.insert(
        "dev".to_string(),
        vec![exemptions(ver(DEFAULT_VER), SAFE_TO_DEPLOY)],
    );

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin-simple-unaudited-overbroad", metadata, store);
}

#[test]
fn builtin_complex_exemptions_twins() {
    // (Pass) two versions of a crate exist and both are exemptions and they're needed

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::complex();

    let metadata = mock.metadata();
    let (mut config, mut audits, imports) = builtin_files_full_audited(&metadata);

    audits.audits.insert("third-core".to_string(), vec![]);

    config.exemptions.insert(
        "third-core".to_string(),
        vec![
            exemptions(ver(DEFAULT_VER), SAFE_TO_DEPLOY),
            exemptions(ver(5), SAFE_TO_DEPLOY),
        ],
    );

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin-simple-unaudited-twins", metadata, store);
}

#[test]
fn builtin_complex_exemptions_partial_twins() {
    // (Pass) two versions of a crate exist and one is exemptions and one is audited

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::complex();

    let metadata = mock.metadata();
    let (mut config, mut audits, imports) = builtin_files_full_audited(&metadata);

    audits.audits.insert(
        "third-core".to_string(),
        vec![full_audit(ver(5), SAFE_TO_DEPLOY)],
    );

    config.exemptions.insert(
        "third-core".to_string(),
        vec![exemptions(ver(DEFAULT_VER), SAFE_TO_DEPLOY)],
    );

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin-simple-unaudited-partial-twins", metadata, store);
}

#[test]
fn builtin_simple_exemptions_in_delta() {
    // (Pass) An audited entry overlaps a delta and isn't needed
    // (This test could warn if we try to detect "useless exemptions" eagerly)

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (mut config, mut audits, imports) = builtin_files_full_audited(&metadata);

    audits.audits.insert(
        "third-party1".to_string(),
        vec![
            full_audit(ver(3), SAFE_TO_DEPLOY),
            delta_audit(ver(3), ver(5), SAFE_TO_DEPLOY),
            delta_audit(ver(5), ver(DEFAULT_VER), SAFE_TO_DEPLOY),
        ],
    );

    config.exemptions.insert(
        "third-party1".to_string(),
        vec![exemptions(ver(5), SAFE_TO_DEPLOY)],
    );

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin-simple-unaudited-in-delta", metadata, store);
}

#[test]
fn builtin_simple_exemptions_in_full() {
    // (Pass) An audited entry overlaps a full audit and isn't needed
    // (This test could warn if we try to detect "useless exemptions" eagerly)

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (mut config, mut audits, imports) = builtin_files_full_audited(&metadata);

    audits.audits.insert(
        "third-party1".to_string(),
        vec![
            full_audit(ver(3), SAFE_TO_DEPLOY),
            delta_audit(ver(3), ver(5), SAFE_TO_DEPLOY),
            delta_audit(ver(5), ver(DEFAULT_VER), SAFE_TO_DEPLOY),
        ],
    );

    config.exemptions.insert(
        "third-party1".to_string(),
        vec![exemptions(ver(3), SAFE_TO_DEPLOY)],
    );

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin-simple-unaudited-in-full", metadata, store);
}

#[test]
fn builtin_simple_exemptions_in_direct_full() {
    // (Pass) An audited entry overlaps a full audit which is the cur version and isn't needed
    // (This test used to warn when we tried to detect "useless exemptions" eagerly)

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (mut config, mut audits, imports) = builtin_files_full_audited(&metadata);

    audits.audits.insert(
        "third-party1".to_string(),
        vec![full_audit(ver(DEFAULT_VER), SAFE_TO_DEPLOY)],
    );

    config.exemptions.insert(
        "third-party1".to_string(),
        vec![exemptions(ver(DEFAULT_VER), SAFE_TO_DEPLOY)],
    );

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin-simple-unaudited-in-direct-full", metadata, store);
}

#[test]
fn builtin_simple_exemptions_nested_weaker_req() {
    // (Pass) A dep that has weaker requirements on its dep

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (mut config, mut audits, imports) = builtin_files_full_audited(&metadata);

    audits.audits.insert(
        "third-party1".to_string(),
        vec![
            delta_audit(ver(3), ver(6), SAFE_TO_DEPLOY),
            delta_audit(ver(6), ver(DEFAULT_VER), SAFE_TO_DEPLOY),
        ],
    );
    audits.audits.insert(
        "transitive-third-party1".to_string(),
        vec![
            delta_audit(ver(4), ver(8), SAFE_TO_RUN),
            delta_audit(ver(8), ver(DEFAULT_VER), SAFE_TO_RUN),
        ],
    );

    config.policy.insert(
        "third-party1".to_string(),
        dep_policy([("transitive-third-party1", [SAFE_TO_RUN])]),
    );

    config.exemptions.insert(
        "third-party1".to_string(),
        vec![exemptions(ver(3), SAFE_TO_DEPLOY)],
    );

    config.exemptions.insert(
        "transitive-third-party1".to_string(),
        vec![exemptions(ver(4), SAFE_TO_RUN)],
    );

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!(
        "builtin-simple-unaudited-nested-weaker-req",
        metadata,
        store
    );
}

#[test]
fn builtin_simple_exemptions_nested_stronger_req() {
    // (Pass) A dep that has stronger requirements on its dep

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (mut config, mut audits, imports) = builtin_files_full_audited(&metadata);

    config.policy.insert(
        "first-party".to_string(),
        dep_policy([("third-party1", [SAFE_TO_RUN])]),
    );
    config.policy.insert(
        "third-party1".to_string(),
        dep_policy([("transitive-third-party1", [SAFE_TO_DEPLOY])]),
    );

    audits.audits.insert(
        "third-party1".to_string(),
        vec![
            delta_audit(ver(3), ver(6), SAFE_TO_RUN),
            delta_audit(ver(6), ver(DEFAULT_VER), SAFE_TO_RUN),
        ],
    );
    audits.audits.insert(
        "transitive-third-party1".to_string(),
        vec![
            delta_audit(ver(4), ver(8), SAFE_TO_DEPLOY),
            delta_audit(ver(8), ver(DEFAULT_VER), SAFE_TO_DEPLOY),
        ],
    );

    config.exemptions.insert(
        "third-party1".to_string(),
        vec![exemptions(ver(3), SAFE_TO_RUN)],
    );

    config.exemptions.insert(
        "transitive-third-party1".to_string(),
        vec![exemptions(ver(4), SAFE_TO_DEPLOY)],
    );

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!(
        "builtin-simple-unaudited-nested-stronger-req",
        metadata,
        store
    );
}

#[test]
fn builtin_simple_deps_exemptions_adds_uneeded_criteria() {
    // (Pass) An audited entry overlaps a full audit which is the cur version and isn't needed
    // (This test could warn if we try to detect "useless exemptions" eagerly)

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple_deps();

    let metadata = mock.metadata();
    let (mut config, mut audits, imports) = builtin_files_full_audited(&metadata);

    audits.audits.insert(
        "dev".to_string(),
        vec![
            full_audit(ver(5), SAFE_TO_RUN),
            delta_audit(ver(5), ver(DEFAULT_VER), SAFE_TO_DEPLOY),
        ],
    );

    config
        .exemptions
        .insert("dev".to_string(), vec![exemptions(ver(5), SAFE_TO_DEPLOY)]);

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!(
        "builtin-simple-deps-unaudited-adds-uneeded-criteria",
        metadata,
        store
    );
}

#[test]
fn builtin_dev_detection_exemptions_adds_uneeded_criteria_indirect() {
    // (Pass) An audited entry overlaps a full audit which is the cur version and isn't needed
    // (This test could warn if we try to detect "useless exemptions" eagerly)

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::dev_detection();

    let metadata = mock.metadata();
    let (mut config, mut audits, imports) = builtin_files_minimal_audited(&metadata);

    audits.audits.insert(
        "simple-dev-indirect".to_string(),
        vec![
            full_audit(ver(5), SAFE_TO_RUN),
            delta_audit(ver(5), ver(DEFAULT_VER), SAFE_TO_DEPLOY),
        ],
    );

    config.exemptions.insert(
        "simple-dev-indirect".to_string(),
        vec![exemptions(ver(5), SAFE_TO_DEPLOY)],
    );

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!(
        "builtin-dev-detection-unaudited-adds-uneeded-criteria-indirect",
        metadata,
        store
    );
}

#[test]
fn builtin_dev_detection_cursed_full() {
    // (Pass): dev-indirect has safe-to-run and by policy we only need safe-to-run
    // but dev (its parent) is audited for safe-to-deploy which naively requires the child
    // be safe-to-deploy. However criteria "decomposition" makes this ok, and we do succesfully
    // validate for safe-to-run.
    //
    // This test is "cursed" because it caused some crashes in glitched out the blame system.

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::dev_detection();

    let metadata = mock.metadata();
    let (config, mut audits, imports) = builtin_files_full_audited(&metadata);

    audits.audits.insert(
        "simple-dev-indirect".to_string(),
        vec![
            full_audit(ver(5), SAFE_TO_RUN),
            delta_audit(ver(5), ver(DEFAULT_VER), SAFE_TO_RUN),
            delta_audit(ver(5), ver(DEFAULT_VER), SAFE_TO_DEPLOY),
        ],
    );

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin-dev-detection-cursed-full", metadata, store);
}

#[test]
fn builtin_dev_detection_cursed_minimal() {
    // (Pass): the same as the full cursed one, but without the cursed part.

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::dev_detection();

    let metadata = mock.metadata();
    let (config, mut audits, imports) = builtin_files_minimal_audited(&metadata);

    audits.audits.insert(
        "simple-dev-indirect".to_string(),
        vec![
            full_audit(ver(5), SAFE_TO_RUN),
            delta_audit(ver(5), ver(DEFAULT_VER), SAFE_TO_RUN),
            delta_audit(ver(5), ver(DEFAULT_VER), SAFE_TO_DEPLOY),
        ],
    );

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin-dev-detection-cursed-minimal", metadata, store);
}

#[test]
fn builtin_simple_delta_cycle() {
    // (Pass) simple delta cycle

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (config, mut audits, imports) = builtin_files_full_audited(&metadata);

    audits.audits.insert(
        "third-party1".to_string(),
        vec![
            full_audit(ver(3), SAFE_TO_DEPLOY),
            delta_audit(ver(3), ver(5), SAFE_TO_DEPLOY),
            delta_audit(ver(5), ver(7), SAFE_TO_DEPLOY),
            delta_audit(ver(7), ver(5), SAFE_TO_DEPLOY),
            delta_audit(ver(7), ver(DEFAULT_VER), SAFE_TO_DEPLOY),
        ],
    );

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin-simple-delta-cycle", metadata, store);
}

#[test]
fn builtin_simple_noop_delta() {
    // (Pass) completely pointless noop delta
    // (This test could warn if we try to detect "useless deltas")

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (config, mut audits, imports) = builtin_files_full_audited(&metadata);

    audits.audits.insert(
        "third-party1".to_string(),
        vec![
            full_audit(ver(3), SAFE_TO_DEPLOY),
            delta_audit(ver(3), ver(5), SAFE_TO_DEPLOY),
            delta_audit(ver(5), ver(5), SAFE_TO_DEPLOY),
            delta_audit(ver(5), ver(7), SAFE_TO_DEPLOY),
            delta_audit(ver(7), ver(DEFAULT_VER), SAFE_TO_DEPLOY),
        ],
    );

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin-simple-noop-delta", metadata, store);
}

#[test]
fn builtin_simple_delta_double_cycle() {
    // (Pass) double delta cycle

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (config, mut audits, imports) = builtin_files_full_audited(&metadata);

    audits.audits.insert(
        "third-party1".to_string(),
        vec![
            full_audit(ver(2), SAFE_TO_DEPLOY),
            delta_audit(ver(2), ver(3), SAFE_TO_DEPLOY),
            delta_audit(ver(3), ver(4), SAFE_TO_DEPLOY),
            delta_audit(ver(4), ver(3), SAFE_TO_DEPLOY),
            delta_audit(ver(4), ver(5), SAFE_TO_DEPLOY),
            delta_audit(ver(5), ver(6), SAFE_TO_DEPLOY),
            delta_audit(ver(6), ver(5), SAFE_TO_DEPLOY),
            delta_audit(ver(6), ver(7), SAFE_TO_DEPLOY),
            delta_audit(ver(7), ver(DEFAULT_VER), SAFE_TO_DEPLOY),
        ],
    );

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin-simple-delta-double-cycle", metadata, store);
}

#[test]
fn builtin_simple_delta_broken_double_cycle() {
    // (Fail) double delta cycle that's broken

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (config, mut audits, imports) = builtin_files_full_audited(&metadata);

    audits.audits.insert(
        "third-party1".to_string(),
        vec![
            full_audit(ver(2), SAFE_TO_DEPLOY),
            delta_audit(ver(2), ver(3), SAFE_TO_DEPLOY),
            delta_audit(ver(3), ver(4), SAFE_TO_DEPLOY),
            delta_audit(ver(4), ver(3), SAFE_TO_DEPLOY),
            // broken: delta_audit(ver(4), ver(5), SAFE_TO_DEPLOY),
            delta_audit(ver(5), ver(6), SAFE_TO_DEPLOY),
            delta_audit(ver(6), ver(5), SAFE_TO_DEPLOY),
            delta_audit(ver(6), ver(7), SAFE_TO_DEPLOY),
            delta_audit(ver(7), ver(DEFAULT_VER), SAFE_TO_DEPLOY),
        ],
    );

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin-simple-delta-broken-double-cycle", metadata, store);
}

#[test]
fn builtin_simple_delta_broken_cycle() {
    // (Fail) simple delta cycle that's broken

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (config, mut audits, imports) = builtin_files_full_audited(&metadata);

    audits.audits.insert(
        "third-party1".to_string(),
        vec![
            full_audit(ver(3), SAFE_TO_DEPLOY),
            delta_audit(ver(3), ver(5), SAFE_TO_DEPLOY),
            delta_audit(ver(5), ver(7), SAFE_TO_DEPLOY),
            delta_audit(ver(7), ver(5), SAFE_TO_DEPLOY),
            // broken: delta_audit(ver(7), ver(8), SAFE_TO_DEPLOY),
            delta_audit(ver(8), ver(DEFAULT_VER), SAFE_TO_DEPLOY),
        ],
    );

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin-simple-delta-broken-cycle", metadata, store);
}

#[test]
fn builtin_simple_long_cycle() {
    // (Pass) long delta cycle

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (config, mut audits, imports) = builtin_files_full_audited(&metadata);

    audits.audits.insert(
        "third-party1".to_string(),
        vec![
            full_audit(ver(2), SAFE_TO_DEPLOY),
            delta_audit(ver(2), ver(7), SAFE_TO_DEPLOY),
            delta_audit(ver(7), ver(6), SAFE_TO_DEPLOY),
            delta_audit(ver(6), ver(8), SAFE_TO_DEPLOY),
            delta_audit(ver(8), ver(7), SAFE_TO_DEPLOY),
            delta_audit(ver(8), ver(DEFAULT_VER), SAFE_TO_DEPLOY),
        ],
    );

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin-simple-long-cycle", metadata, store);
}

#[test]
fn builtin_simple_useless_long_cycle() {
    // (Pass) useless long delta cycle

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (config, mut audits, imports) = builtin_files_full_audited(&metadata);

    audits.audits.insert(
        "third-party1".to_string(),
        vec![
            full_audit(ver(2), SAFE_TO_DEPLOY),
            delta_audit(ver(2), ver(7), SAFE_TO_DEPLOY),
            delta_audit(ver(7), ver(6), SAFE_TO_DEPLOY),
            delta_audit(ver(6), ver(8), SAFE_TO_DEPLOY),
            delta_audit(ver(8), ver(7), SAFE_TO_DEPLOY),
            delta_audit(ver(7), ver(DEFAULT_VER), SAFE_TO_DEPLOY),
        ],
    );

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin-simple-useless-long-cycle", metadata, store);
}

#[test]
fn builtin_haunted_init() {
    // (Pass) Should look the same as a fresh 'vet init'.

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::haunted_tree();

    let metadata = mock.metadata();
    let (config, audits, imports) = builtin_files_inited(&metadata);

    let store = Store::mock(config, audits, imports);
    assert_report_snapshot!("builtin-haunted-init", metadata, store);
}

#[test]
fn builtin_haunted_no_exemptions() {
    // (Fail) Should look the same as a fresh 'vet init' but with all 'exemptions' entries deleted.

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::haunted_tree();

    let metadata = mock.metadata();
    let (config, audits, imports) = builtin_files_no_exemptions(&metadata);

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin-haunted-no-unaudited", metadata, store);
}

#[test]
fn builtin_haunted_no_exemptions_deeper() {
    // (Fail) Should look the same as a fresh 'vet init' but with all 'exemptions' entries deleted.

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::haunted_tree();

    let metadata = mock.metadata();
    let (config, audits, imports) = builtin_files_no_exemptions(&metadata);

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin-haunted-no-unaudited-deeper", metadata, store);
}

#[test]
fn builtin_haunted_full_audited() {
    // (Pass) All entries have direct full audits.

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::haunted_tree();

    let metadata = mock.metadata();
    let (config, audits, imports) = builtin_files_full_audited(&metadata);

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin-haunted-full-audited", metadata, store);
}

#[test]
fn builtin_haunted_minimal_audited() {
    // (Pass) All entries have direct minimal audits.

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::haunted_tree();

    let metadata = mock.metadata();
    let (config, audits, imports) = builtin_files_minimal_audited(&metadata);

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin-haunted-minimal-audited", metadata, store);
}

#[test]
fn builtin_simple_audit_as_default_root_no_audit() {
    // (Fail) the root is audit-as-crates-io but has no audits

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (mut config, audits, imports) = builtin_files_inited(&metadata);

    config
        .policy
        .insert("root-package".to_string(), audit_as_policy(Some(true)));

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!(
        "builtin-simple-audit-as-default-root-no-audit",
        metadata,
        store
    );
}

#[test]
fn builtin_simple_audit_as_default_root() {
    // (Pass) the root is audit-as-crates-io and only needs to be safe-to-run

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (mut config, audits, imports) = builtin_files_inited(&metadata);

    config
        .policy
        .insert("root-package".to_string(), audit_as_policy(Some(true)));
    config.exemptions.insert(
        "root-package".to_string(),
        vec![exemptions(ver(DEFAULT_VER), SAFE_TO_DEPLOY)],
    );

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin-simple-audit-as-default-root", metadata, store);
}

#[test]
fn builtin_simple_audit_as_default_root_too_weak() {
    // (Fail) the root is audit-as-crates-io but is only safe-to-run

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (mut config, audits, imports) = builtin_files_inited(&metadata);

    config
        .policy
        .insert("root-package".to_string(), audit_as_policy(Some(true)));
    config.exemptions.insert(
        "root-package".to_string(),
        vec![exemptions(ver(DEFAULT_VER), SAFE_TO_RUN)],
    );

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!(
        "builtin-simple-audit-as-default-root-too-weak",
        metadata,
        store
    );
}

#[test]
fn builtin_simple_audit_as_weaker_root() {
    // (Pass) the root is audit-as-crates-io and only needs to be safe-to-run

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (mut config, audits, imports) = builtin_files_inited(&metadata);

    config.policy.insert(
        "root-package".to_string(),
        audit_as_policy_with(Some(true), |policy| {
            policy.criteria = Some(vec![SAFE_TO_RUN.to_string().into()]);
        }),
    );
    config.exemptions.insert(
        "root-package".to_string(),
        vec![exemptions(ver(DEFAULT_VER), SAFE_TO_RUN)],
    );

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin-simple-audit-as-weaker-root", metadata, store);
}

#[test]
fn builtin_simple_foreign_audited() {
    // (Pass) All entries have direct full audits.

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (mut config, mut audits, mut imports) = builtin_files_full_audited(&metadata);
    imports.audits.insert(FOREIGN.to_owned(), audits.clone());
    config.imports.insert(
        FOREIGN.to_owned(),
        crate::format::RemoteImport {
            url: vec![FOREIGN_URL.to_owned()],
            ..Default::default()
        },
    );
    audits.audits.clear();

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin_simple_foreign_audited", metadata, store);
}

#[test]
fn mock_simple_foreign_audited_pun_no_mapping() {
    // (Fail) All entries have direct full audits, but there isn't a mapping so the names don't match
    // NOTE: it's possible this situation merits a "help" message"?

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (mut config, mut audits, imports) = files_full_audited(&metadata);

    let mut network = Network::new_mock();
    network.mock_serve_toml(FOREIGN_URL, &audits);

    config.imports.insert(
        FOREIGN.to_owned(),
        crate::format::RemoteImport {
            url: vec![FOREIGN_URL.to_owned()],
            ..Default::default()
        },
    );
    audits.audits.clear();

    let store = Store::mock_online(
        &mock_cfg(&metadata),
        config,
        audits,
        imports,
        &network,
        true,
    )
    .unwrap();

    assert_report_snapshot!(
        "mock_simple_foreign_audited_pun_no_mapping",
        metadata,
        store
    );
}

#[test]
fn mock_simple_foreign_audited_pun_mapped() {
    // (Pass) All entries have direct full audits, and are mapped in

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (mut config, mut audits, imports) = files_full_audited(&metadata);

    let mut network = Network::new_mock();
    network.mock_serve_toml(FOREIGN_URL, &audits);

    config.imports.insert(
        FOREIGN.to_owned(),
        crate::format::RemoteImport {
            url: vec![FOREIGN_URL.to_owned()],
            criteria_map: [(
                DEFAULT_CRIT.to_owned().into(),
                vec![DEFAULT_CRIT.to_owned().into()],
            )]
            .into_iter()
            .collect(),
            ..Default::default()
        },
    );
    audits.audits.clear();

    let store = Store::mock_online(
        &mock_cfg(&metadata),
        config,
        audits,
        imports,
        &network,
        true,
    )
    .unwrap();

    assert_report_snapshot!("mock_simple_foreign_audited_pun_mapped", metadata, store);
}

#[test]
fn mock_simple_foreign_audited_pun_wrong_mapped() {
    // (Fail) All entries have direct full audits, and are mapped in... but from the wrong import

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (mut config, mut audits, imports) = files_full_audited(&metadata);

    // FOREIGN has the audits, but OTHER_FOREIGN has the mapping
    let mut network = Network::new_mock();
    network.mock_serve_toml(FOREIGN_URL, &audits);
    audits.audits.clear();
    network.mock_serve_toml(OTHER_FOREIGN_URL, &audits);

    config.imports.insert(
        OTHER_FOREIGN.to_owned(),
        crate::format::RemoteImport {
            url: vec![OTHER_FOREIGN_URL.to_owned()],
            criteria_map: [(
                DEFAULT_CRIT.to_owned().into(),
                vec![DEFAULT_CRIT.to_owned().into()],
            )]
            .into_iter()
            .collect(),
            ..Default::default()
        },
    );
    config.imports.insert(
        FOREIGN.to_owned(),
        crate::format::RemoteImport {
            url: vec![FOREIGN_URL.to_owned()],
            ..Default::default()
        },
    );

    let store = Store::mock_online(
        &mock_cfg(&metadata),
        config,
        audits,
        imports,
        &network,
        true,
    )
    .unwrap();

    assert_report_snapshot!(
        "mock_simple_foreign_audited_pun_wrong_mapped",
        metadata,
        store
    );
}

#[test]
fn builtin_simple_foreign_tag_team() {
    // (Pass) An audit is achieved by connecting a foreign builtin audit to a local one

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (mut config, mut audits, mut imports) = builtin_files_full_audited(&metadata);
    audits.audits.insert(
        "transitive-third-party1".to_owned(),
        vec![full_audit(ver(5), SAFE_TO_DEPLOY)],
    );
    imports.audits.insert(
        FOREIGN.to_owned(),
        AuditsFile {
            criteria: SortedMap::new(),
            wildcard_audits: SortedMap::new(),
            audits: [(
                "transitive-third-party1".to_owned(),
                vec![delta_audit(ver(5), ver(DEFAULT_VER), SAFE_TO_DEPLOY)],
            )]
            .into_iter()
            .collect(),
            trusted: SortedMap::new(),
        },
    );
    config.imports.insert(
        FOREIGN.to_owned(),
        crate::format::RemoteImport {
            url: vec![FOREIGN_URL.to_owned()],
            ..Default::default()
        },
    );

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin_simple_foreign_tag_team", metadata, store);
}

#[test]
fn builtin_simple_mega_foreign_tag_team() {
    // (Pass) An audit is achieved by connecting a two foreign imports together

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (mut config, mut audits, mut imports) = builtin_files_full_audited(&metadata);
    audits.audits.insert(
        "transitive-third-party1".to_owned(),
        vec![full_audit(ver(3), SAFE_TO_DEPLOY)],
    );
    imports.audits.insert(
        FOREIGN.to_owned(),
        AuditsFile {
            criteria: SortedMap::new(),
            wildcard_audits: SortedMap::new(),
            audits: [(
                "transitive-third-party1".to_owned(),
                vec![delta_audit(ver(3), ver(6), SAFE_TO_DEPLOY)],
            )]
            .into_iter()
            .collect(),
            trusted: SortedMap::new(),
        },
    );
    config.imports.insert(
        FOREIGN.to_owned(),
        crate::format::RemoteImport {
            url: vec![FOREIGN_URL.to_owned()],
            ..Default::default()
        },
    );
    imports.audits.insert(
        OTHER_FOREIGN.to_owned(),
        AuditsFile {
            criteria: SortedMap::new(),
            wildcard_audits: SortedMap::new(),
            audits: [(
                "transitive-third-party1".to_owned(),
                vec![delta_audit(ver(6), ver(DEFAULT_VER), SAFE_TO_DEPLOY)],
            )]
            .into_iter()
            .collect(),
            trusted: SortedMap::new(),
        },
    );
    config.imports.insert(
        OTHER_FOREIGN.to_owned(),
        crate::format::RemoteImport {
            url: vec![OTHER_FOREIGN_URL.to_owned()],
            ..Default::default()
        },
    );

    let store = Store::mock(config, audits, imports);

    assert_report_snapshot!("builtin_simple_mega_foreign_tag_team", metadata, store);
}

#[test]
fn builtin_simple_registry_suggestions() {
    // (Pass) After a failing audit, registry suggestions may be proposed if run
    // with network access.

    let _enter = TEST_RUNTIME.enter();
    let mock = MockMetadata::simple();

    let metadata = mock.metadata();
    let (config, audits, imports) = builtin_files_no_exemptions(&metadata);

    let mut network = Network::new_mock();
    network.mock_serve_toml(
        crate::storage::REGISTRY_URL,
        &RegistryFile {
            registry: [
                (
                    FOREIGN.to_owned(),
                    RegistryEntry {
                        url: vec![FOREIGN_URL.to_owned()],
                    },
                ),
                (
                    OTHER_FOREIGN.to_owned(),
                    RegistryEntry {
                        url: vec![OTHER_FOREIGN_URL.to_owned()],
                    },
                ),
            ]
            .into_iter()
            .collect(),
        },
    );
    network.mock_serve_toml(
        FOREIGN_URL,
        &AuditsFile {
            criteria: SortedMap::new(),
            wildcard_audits: SortedMap::new(),
            audits: [
                (
                    "third-party1".to_owned(),
                    vec![full_audit(ver(DEFAULT_VER), SAFE_TO_DEPLOY)],
                ),
                (
                    "third-party2".to_owned(),
                    vec![delta_audit(ver(1), ver(DEFAULT_VER), SAFE_TO_DEPLOY)],
                ),
            ]
            .into_iter()
            .collect(),
            trusted: SortedMap::new(),
        },
    );
    network.mock_serve_toml(
        OTHER_FOREIGN_URL,
        &AuditsFile {
            criteria: SortedMap::new(),
            wildcard_audits: SortedMap::new(),
            audits: [
                (
                    "transitive-third-party1".to_owned(),
                    vec![full_audit(ver(8), SAFE_TO_DEPLOY)],
                ),
                (
                    "third-party2".to_owned(),
                    vec![full_audit(ver(DEFAULT_VER), SAFE_TO_DEPLOY)],
                ),
            ]
            .into_iter()
            .collect(),
            trusted: SortedMap::new(),
        },
    );

    let store = Store::mock_online(
        &mock_cfg(&metadata),
        config,
        audits,
        imports,
        &network,
        true,
    )
    .unwrap();

    assert_report_snapshot!(
        "builtin_simple_registry_suggestions",
        metadata,
        store,
        Some(&network)
    );
}