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
88
89
90
91
92

use super::chain::Chain;
use crate::configuration::config_model::GenericConfiguration;
use core::panic;

/// Looks up chain generators (usually for names and addresses)
/// panics if a generator does not exist
pub fn loader(config: &GenericConfiguration, name: &str) -> Vec<Chain> {
    let mut chains: Vec<Chain> = vec![];
    let name_generator = &config.types.string.iter().find(|x| x.name == name);
    match name_generator {
        Some(data) => {
            for rule in &data.rules {
                let chain = Chain::new(rule.to_vec());
                chains.push(chain);
            }
        }
        None => panic!("no such name for a generator exists"),
    }

    chains
}

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

    name_generator.is_some()
}

#[cfg(test)]
mod tests {
    use crate::{
        configuration::config_model::{
            GenericConfiguration, Patterns, RelationalDatabaseConfiguration, ValueTypes,
        },
        name_generator::loader::name_generator_exists,
    };

    #[test]
    fn generator_exists() {
        let exists = name_generator_exists(
            &GenericConfiguration {
                types: ValueTypes {
                    string: vec![Patterns::<Vec<String>> {
                        name: "test".to_string(),
                        rules: vec![],
                    }],
                    integer: vec![],
                    float: vec![],
                    datetime: vec![],
                },
                mysql_configuration: Some(RelationalDatabaseConfiguration {
                    address: "".to_string(),
                    port: 123,
                    user: "".to_string(),
                    password: "".to_string(),
                    schema: "".to_string(),
                }),
            },
            "test",
        );

        assert_eq!(exists, true);
    }

    #[test]
    fn generator_doesnot_exists() {
        let exists = name_generator_exists(
            &GenericConfiguration {
                types: ValueTypes {
                    string: vec![Patterns::<Vec<String>> {
                        name: "random".to_string(),
                        rules: vec![],
                    }],
                    integer: vec![],
                    float: vec![],
                    datetime: vec![],
                },
                mysql_configuration: Some(RelationalDatabaseConfiguration {
                    address: "".to_string(),
                    port: 123,
                    user: "".to_string(),
                    password: "".to_string(),
                    schema: "".to_string(),
                }),
            },
            "test",
        );

        assert_eq!(exists, false);
    }
}