person_registration/
lib.rs

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
use rand::{thread_rng, Rng};

pub trait Gen {
    fn generate() -> String;
}

pub struct Person;

impl Gen for Person {
    fn generate() -> String {
        let mut out = String::from("###.###.###-##");
        while out.find("#") != None {
            let mut rng = thread_rng();
            let num: u32 = rng.gen_range(0..10);
            out = out.replacen("#", &num.to_string(), 1);
        }
        out.to_string()
    }
}

pub struct Juridic;

impl Gen for Juridic {
    fn generate() -> String {
        let mut out = String::from("##.###.###/####-##");
        while out.find("#") != None {
            let mut rng = thread_rng();
            let num: u32 = rng.gen_range(0..10);
            out = out.replacen("#", &num.to_string(), 1);
        }
        out.to_string()
    }
}

pub struct General;

impl Gen for General {
    fn generate() -> String {
        let mut out = String::from("##.###.###-#");
        while out.find("#") != None {
            let mut rng = thread_rng();
            let num: u32 = rng.gen_range(0..10);
            out = out.replacen("#", &num.to_string(), 1);
        }
        out.to_string()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    use regex::Regex;

    #[test]
    fn physical_person_registration() {
        let re = Regex::new(r"[0-9]{3}\.[0-9]{3}\.[0-9]{3}\-[0-9]{2}").unwrap();
        let mut expectations = vec![];
        for _i in 0..100 {
            let generated_value = Person::generate();
            if re.is_match(&generated_value) {
                expectations.push(generated_value);
            }
        }
        assert_eq!(expectations.len(), 100);
        let expect = expectations.binary_search(&Person::generate());
        assert!(match expect { Err(0..=100) => true, _ => false, });
    }

    #[test]
    fn juridic_person_registration() {
        let re = Regex::new(r"[0-9]{2}\.[0-9]{3}\.[0-9]{3}/[0-9]{4}\-[0-9]{2}").unwrap();
        let mut expectations = vec![];
        for _i in 0..100 {
            let generated_value = Juridic::generate();
            if re.is_match(&generated_value) {
                expectations.push(generated_value);
            }
        }
        assert_eq!(expectations.len(), 100);
        let expect = expectations.binary_search(&Juridic::generate());
        assert!(match expect { Err(0..=100) => true, _ => false, });
    }

    #[test]
    fn general_person_registration() {
        let re = Regex::new(r"[0-9]{2}\.[0-9]{3}\.[0-9]{3}\-[0-9]{1}").unwrap();
        let mut expectations = vec![];
        for _i in 0..100 {
            let generated_value = General::generate();
            if re.is_match(&generated_value) {
                expectations.push(generated_value);
            }
        }
        assert_eq!(expectations.len(), 100);
        let expect = expectations.binary_search(&General::generate());
        assert!(match expect { Err(0..=100) => true, _ => false, });
    }
}