spawnflake 0.2.9

Generate pattern based random data for mysql
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

use crate::configuration::config_model::GenericConfiguration;

/// macro that generates a random number regardless the type
#[macro_export]
macro_rules! random_number {
    ($calc:ty) => {{
        use rand::Rng;
        pub fn rnd(a: $calc, b: $calc) -> $calc {
            let rng = rand::thread_rng().gen_range(a..b);

            rng
        }
        rnd
    }};
}

/// generates a random number (int) based on configuration rules
pub fn generate_int_number(config: &GenericConfiguration, name: &str) -> i32 {
    let pattern = config
        .clone()
        .types
        .integer
        .into_iter()
        .find(|x| x.name == name)
        .unwrap();

    random_number!(i32)(pattern.rules[0], pattern.rules[1])
}

/// Checks if a integer generator exists
pub fn int_generator_exists(config: &GenericConfiguration, name: &str) -> bool {
    let name_generator = &config.types.integer.iter().find(|x| x.name == name);

    name_generator.is_some()
}

/// generates a random number (float) based on configuration rules
pub fn generate_float_number(config: &GenericConfiguration, name: &str) -> f32 {
    let pattern = config
        .clone()
        .types
        .float
        .into_iter()
        .find(|x| x.name == name)
        .unwrap();

    random_number!(f32)(pattern.rules[0], pattern.rules[1])
}

/// Checks if a float generator exists
pub fn float_point_generator_exists(config: &GenericConfiguration, name: &str) -> bool {
    let name_generator = &config.types.float.iter().find(|x| x.name == name);

    name_generator.is_some()
}

#[cfg(test)]
mod tests {
    #[test]
    fn get_random_i32_between_two_values() {
        assert_eq!(random_number!(i32)(1, 5) >= 1, true);
    }

    #[test]
    fn get_random_i64_between_two_values() {
        assert_eq!(
            random_number!(i64)(100000000000, 5100000000000) >= 100000000000,
            true
        );
    }

    #[test]
    fn get_random_f32_between_two_values() {
        assert_eq!(random_number!(f32)(1.1, 5.3) >= 1.1, true);
    }

    #[test]
    fn get_random_f64_between_two_values() {
        assert_eq!(
            random_number!(f64)(
                1000000000000000000000000000000000000000.1,
                5000000000000000000000000000000000000000.3
            ) >= 1000000000000000000000000000000000000000.1,
            true
        );
    }
}