tokidator 0.2.1

Token based authentication framework
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

use std::hash::Hash;

use num_traits::{FromPrimitive, ToPrimitive};

use crate::policy::{PolicyCount, PolicySet};

pub enum PolicyCondition<P>
    where P: Hash + Eq + FromPrimitive + ToPrimitive + PolicyCount {
    NoCheck,
    Contains(P),
    OneOf(PolicySet<P>),
    AllOf(PolicySet<P>),
}

impl<P> PolicyCondition<P>
    where P: Hash + Eq + FromPrimitive + ToPrimitive + PolicyCount {
    pub fn satisfy(&self, policies: &PolicySet<P>) -> bool {
        use PolicyCondition::*;
        match self {
            NoCheck => true,
            Contains(policy) => policies.contains(policy),
            OneOf(set) =>
                set.iter().any(|p| policies.contains(p)),
            AllOf(set) => {
                !set.is_empty() && set.iter().all(|p| policies.contains(p))
            }
        }
    }
}

impl<P> From<P> for PolicyCondition<P>
    where P: Hash + Eq + FromPrimitive + ToPrimitive + PolicyCount {
    fn from(p: P) -> Self {
        PolicyCondition::Contains(p)
    }
}

impl<P> From<Vec<P>> for PolicyCondition<P>
    where P: Hash + Eq + FromPrimitive + ToPrimitive + PolicyCount {
    fn from(vec: Vec<P>) -> Self {
        PolicyCondition::AllOf(vec.into_iter().collect())
    }
}

#[cfg(test)]
mod tests {
    use crate::policy::PolicyCondition::*;
    use crate::policy::tests::TestPolicy::{self, *};

    use super::*;

    #[test]
    fn no_check_should_satisfy() {
        assert!(NoCheck.satisfy(&PolicySet::<TestPolicy>::new()));
        assert!(NoCheck.satisfy(&vec![Policy1].into()));
        assert!(NoCheck.satisfy(&vec![Policy1, Policy2].into()));
    }

    #[test]
    fn contains_should_satisfy() {
        assert!(Contains(Policy1).satisfy(&vec![Policy1].into()));
        assert!(Contains(Policy1).satisfy(&vec![Policy1, Policy2].into()));
    }

    #[test]
    fn contains_should_not_satisfy() {
        assert!(!Contains(Policy1).satisfy(&vec![].into()));
        assert!(!Contains(Policy1).satisfy(&vec![Policy2].into()));
    }

    #[test]
    fn one_of_should_satisfy() {
        let check_ps: PolicySet<_> = vec![Policy1, Policy2].into();
        assert!(OneOf(vec![Policy1].into()).satisfy(&check_ps));
        assert!(OneOf(vec![Policy2].into()).satisfy(&check_ps));
        assert!(OneOf(vec![Policy1, Policy2].into()).satisfy(&check_ps));
        assert!(OneOf(vec![Policy1, Policy2, Policy3].into()).satisfy(&check_ps));
    }

    #[test]
    fn one_of_should_not_satisfy() {
        assert!(!OneOf(Vec::<TestPolicy>::new().into()).satisfy(&vec![].into()));
        assert!(!OneOf(vec![].into()).satisfy(&vec![Policy1].into()));
        assert!(!OneOf(vec![].into()).satisfy(&vec![Policy1, Policy2].into()));

        // should not satisfy by empty set
        assert!(!OneOf(vec![Policy1].into()).satisfy(&vec![].into()));
        assert!(!OneOf(vec![Policy1, Policy2].into()).satisfy(&vec![].into()));

        assert!(!OneOf(vec![Policy1].into()).satisfy(&vec![Policy2].into()));
        assert!(!OneOf(vec![Policy1].into()).satisfy(&vec![Policy2, Policy3].into()));
    }

    #[test]
    fn all_of_should_satisfy() {
        assert!(AllOf(vec![Policy1].into()).satisfy(&vec![Policy1].into()));
        assert!(AllOf(vec![Policy1, Policy2].into()).satisfy(&vec![Policy1, Policy2].into()));
        assert!(AllOf(vec![Policy1, Policy2].into()).satisfy(&vec![Policy1, Policy2, Policy3].into()));
    }

    #[test]
    fn all_of_should_not_satisfy() {
        assert!(!AllOf(Vec::<TestPolicy>::new().into()).satisfy(&vec![].into()));
        assert!(!AllOf(vec![].into()).satisfy(&vec![Policy1].into()));
        assert!(!AllOf(vec![].into()).satisfy(&vec![Policy1, Policy2].into()));

        // should not satisfy by empty set
        assert!(!AllOf(vec![Policy1].into()).satisfy(&vec![].into()));
        assert!(!AllOf(vec![Policy1, Policy2].into()).satisfy(&vec![].into()));

        assert!(!AllOf(vec![Policy1, Policy2].into()).satisfy(&vec![Policy1].into()));
        assert!(!AllOf(vec![Policy1, Policy2].into()).satisfy(&vec![Policy2].into()));
        assert!(!AllOf(vec![Policy1, Policy2].into()).satisfy(&vec![Policy2, Policy3].into()));
    }
}