fn targets_iter_and_map_test()

in tough/src/schema/mod.rs [1174:1270]

• 89 lines of code
• 1 McCabe index (conditional complexity)

fn targets_iter_and_map_test() {
    use maplit::hashmap;

    // Create a dummy Target object.
    let nothing = Target {
        length: 0,
        hashes: Hashes {
            sha256: [0u8].to_vec().into(),
            _extra: Default::default(),
        },
        custom: Default::default(),
        _extra: Default::default(),
    };

    // Create a hierarchy of targets/delegations: a -> b -> c
    let c_role = DelegatedRole {
        name: "c-role".to_string(),
        keyids: vec![],
        threshold: NonZeroU64::new(1).unwrap(),
        paths: PathSet::Paths(vec![PathPattern::new("*").unwrap()]),
        terminating: false,
        targets: Some(Signed {
            signed: Targets {
                spec_version: "".to_string(),
                version: NonZeroU64::new(1).unwrap(),
                expires: Utc::now(),
                targets: hashmap! {
                    TargetName::new("c.txt").unwrap() => nothing.clone(),
                },
                delegations: None,
                _extra: Default::default(),
            },
            signatures: vec![],
        }),
    };
    let b_delegations = Delegations {
        keys: Default::default(),
        roles: vec![c_role],
    };
    let b_role = DelegatedRole {
        name: "b-role".to_string(),
        keyids: vec![],
        threshold: NonZeroU64::new(1).unwrap(),
        paths: PathSet::Paths(vec![PathPattern::new("*").unwrap()]),
        terminating: false,
        targets: Some(Signed {
            signed: Targets {
                spec_version: "".to_string(),
                version: NonZeroU64::new(1).unwrap(),
                expires: Utc::now(),
                targets: hashmap! {
                    TargetName::new("b.txt").unwrap() => nothing.clone(),
                },
                delegations: Some(b_delegations),
                _extra: Default::default(),
            },
            signatures: vec![],
        }),
    };
    let a_delegations = Delegations {
        keys: Default::default(),
        roles: vec![b_role],
    };
    let a = Targets {
        spec_version: "".to_string(),
        version: NonZeroU64::new(1).unwrap(),
        expires: Utc::now(),
        targets: hashmap! {
            TargetName::new("a.txt").unwrap() => nothing.clone(),
        },
        delegations: Some(a_delegations),
        _extra: Default::default(),
    };

    // Assert that targets_iter is recursive and thus has a.txt, b.txt and c.txt
    assert!(a
        .targets_iter()
        .map(|(key, _)| key)
        .find(|&item| item.raw() == "a.txt")
        .is_some());
    assert!(a
        .targets_iter()
        .map(|(key, _)| key)
        .find(|&item| item.raw() == "b.txt")
        .is_some());
    assert!(a
        .targets_iter()
        .map(|(key, _)| key)
        .find(|&item| item.raw() == "c.txt")
        .is_some());

    // Assert that targets_map is also recursive
    let map = a.targets_map();
    assert!(map.contains_key(&TargetName::new("a.txt").unwrap()));
    assert!(map.contains_key(&TargetName::new("b.txt").unwrap()));
    assert!(map.contains_key(&TargetName::new("c.txt").unwrap()));
}