passay-rs 0.1.0

A password validation library inspired by the Java Passay library.
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use crate::rule::allowed_character::MatchBehavior;
use crate::rule::allowed_character::MatchBehavior::Contains;
use crate::rule::rule_result::RuleResult;
use crate::rule::{PasswordData, Rule};
use std::collections::HashMap;
use std::ops::Range;

pub const ERROR_CODE: &str = "ILLEGAL_NUMBER_RANGE";

/// Rule for determining if a password contains any number within a defined range.
/// # Example
///
/// ```
///  use passay_rs::rule::Rule;
///  use passay_rs::rule::number_range::NumberRangeRule;
///  use passay_rs::rule::PasswordData;
///  let rule = NumberRangeRule::from(101..199);
///  let password = PasswordData::with_password("150Rcv8#n65".to_string());
///  let result = rule.validate(&password);
///  assert!(!result.valid());
/// ```
pub struct NumberRangeRule {
    range: Range<isize>,
    match_behavior: MatchBehavior,
    report_all: bool,
}

impl NumberRangeRule {
    pub fn new(range: Range<isize>, match_behavior: MatchBehavior, report_all: bool) -> Self {
        NumberRangeRule {
            range,
            match_behavior,
            report_all,
        }
    }
    fn create_rule_result_detail_parameters(&self, number: isize) -> HashMap<String, String> {
        let mut map = HashMap::with_capacity(1);
        map.insert("number".to_string(), number.to_string());
        map.insert("matchBehavior".to_string(), self.match_behavior.to_string());
        map
    }
}

impl From<Range<isize>> for NumberRangeRule {
    fn from(value: Range<isize>) -> Self {
        NumberRangeRule::new(value, Contains, true)
    }
}

impl Rule for NumberRangeRule {
    fn validate(&self, password_data: &PasswordData) -> RuleResult {
        let mut result = RuleResult::default();
        let text = password_data.password();
        for i in self.range.clone() {
            if self.match_behavior.match_str(text, &i.to_string()) {
                result.add_error(
                    ERROR_CODE,
                    Some(self.create_rule_result_detail_parameters(i)),
                );
                if !self.report_all {
                    break;
                }
            }
        }
        result
    }
}

#[cfg(test)]
mod tests {
    use crate::rule::PasswordData;
    use crate::rule::allowed_character::MatchBehavior::{Contains, EndsWith, StartsWith};
    use crate::rule::number_range::{ERROR_CODE, NumberRangeRule};
    use crate::test::{RulePasswordTestItem, check_messages, check_passwords};

    #[test]
    fn test_passwords() {
        let test_cases: Vec<RulePasswordTestItem> = vec![
            RulePasswordTestItem(
                Box::new(NumberRangeRule::from(101..199)),
                PasswordData::with_password("p4zRcv8#n65".to_string()),
                vec![],
            ),
            RulePasswordTestItem(
                Box::new(NumberRangeRule::new(101..199, StartsWith, true)),
                PasswordData::with_password("150Rcv8#n65".to_string()),
                vec![ERROR_CODE],
            ),
            RulePasswordTestItem(
                Box::new(NumberRangeRule::new(101..199, StartsWith, true)),
                PasswordData::with_password("p4zRcv101#n6F".to_string()),
                vec![],
            ),
            RulePasswordTestItem(
                Box::new(NumberRangeRule::new(101..199, EndsWith, true)),
                PasswordData::with_password("p4zRcv8#n198".to_string()),
                vec![ERROR_CODE],
            ),
            RulePasswordTestItem(
                Box::new(NumberRangeRule::new(101..199, EndsWith, true)),
                PasswordData::with_password("p4zRcv101#n6F".to_string()),
                vec![],
            ),
            RulePasswordTestItem(
                Box::new(NumberRangeRule::from(101..199)),
                PasswordData::with_password("p4zRcv99#n65".to_string()),
                vec![],
            ),
            RulePasswordTestItem(
                Box::new(NumberRangeRule::from(101..199)),
                PasswordData::with_password("p4zRcv100#n65".to_string()),
                vec![],
            ),
            RulePasswordTestItem(
                Box::new(NumberRangeRule::from(101..199)),
                PasswordData::with_password("p4zRcv199#n65".to_string()),
                vec![],
            ),
        ];
        check_passwords(test_cases);
    }

    #[test]
    fn test_messages() {
        let test_cases: Vec<RulePasswordTestItem> = vec![
            RulePasswordTestItem(
                Box::new(NumberRangeRule::new(101..199, StartsWith, true)),
                PasswordData::with_password("133Rcv8#n65".to_string()),
                vec!["ILLEGAL_NUMBER_RANGE,starts with,133"],
            ),
            RulePasswordTestItem(
                Box::new(NumberRangeRule::new(101..199, Contains, true)),
                PasswordData::with_password("p4zRcv168#n65".to_string()),
                vec!["ILLEGAL_NUMBER_RANGE,contains,168"],
            ),
            RulePasswordTestItem(
                Box::new(NumberRangeRule::new(101..199, EndsWith, true)),
                PasswordData::with_password("p4zRcv8#n188".to_string()),
                vec!["ILLEGAL_NUMBER_RANGE,ends with,188"],
            ),
        ];
        check_messages(test_cases);
    }
}