xmlgenerator 0.2.4

Generate XML instances from an XML Schema (XSD)
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

#[cfg(test)]
mod tests {
    use std::collections::HashSet;
    use std::path::PathBuf;
    use workspace_root::get_workspace_root;

    use rstest::*;
    use std::panic;
    use xmlgenerator::{XMLGenerator, XMLGeneratorError};
    use xsdtestdata::XSDTestData;

    fn check_error(error: &XMLGeneratorError) -> String {
        match error {
            XMLGeneratorError::InvalidPathError(e) => panic!("Invalid path: {}", e),
            XMLGeneratorError::XSDValidatorError(e) => panic!("XSD validator error: {}", e),
            XMLGeneratorError::DataTypeInformationError(e) => {
                panic!("Data type information error: {}", e)
            }
            XMLGeneratorError::DataTypeNotFoundError(e) => panic!("DataType not found: {}", e),
            XMLGeneratorError::XSDParserError(e) => {
                format!("XSD Parser Error: {}", e)
            }
            XMLGeneratorError::DataTypesFormatError(e) => {
                format!("Data Types Format Error: {}", e)
            }
            XMLGeneratorError::XMLBuilderError(e) => panic!("XML builder error: {}", e),
            XMLGeneratorError::InvalidXSDVersionError(e) => {
                format!("Invalid XSD Version: {}", e)
            }
            XMLGeneratorError::InfiniteRecursionError => "Infinite Recursion detected".to_string(),
            XMLGeneratorError::NoElementsError => "No Elements in XSD".to_string(),
            XMLGeneratorError::InvalidXSDError(e) => panic!("Invalid XSD error: {}", e),
            XMLGeneratorError::InvalidXSDNameError(e) => {
                format!("Invalid XSD element name: {}", e)
            }
            XMLGeneratorError::NoIndependentElementsError => {
                "No Independent Elements found in XSD".to_string()
            }
            XMLGeneratorError::MultipleRootsError => "Multiple Roots found in XSD".to_string(),
            XMLGeneratorError::TypeGenerationError(e) => panic!("Type generation error: {}", e),
            XMLGeneratorError::RegexError(e) => panic!("Regex error: {}", e),
            XMLGeneratorError::RegexMismatchError(p1, p2) => {
                format!("Regex mismatch error: {} <-> {}", p1, p2)
            }
            XMLGeneratorError::EncodingError => "Encoding error".to_string(),
            XMLGeneratorError::LineEndingsError(e) => {
                format!("Invalid line ending error: {}", e)
            }
            XMLGeneratorError::UnimplementedFeature(e) => {
                format!("Unimplemented feature: {}", e)
            }
        }
    }

    fn check_result_str(str: &str) -> String {
        if str.is_empty() {
            panic!("Empty string is not allowed");
        }

        str.to_string()
    }

    fn test_file(generator: &XMLGenerator, test_data: &XSDTestData, key: &str) -> String {
        let file = match test_data.get(key) {
            Some(data) => data,
            None => {
                return "".to_string();
            }
        };

        let path = file.get_path();
        match generator.generate(path, Some(57)) {
            Ok(out) => check_result_str(&out),
            Err(err) => check_error(&err),
        }
    }

    fn validate_file(generator: &XMLGenerator, filepath: &PathBuf, valid: bool) -> bool {
        if !valid {
            return false;
        }

        generator.validate(filepath).is_ok()
    }

    fn get_valid_files<'a>(
        generator: &XMLGenerator,
        test_data: &'a XSDTestData,
    ) -> HashSet<&'a str> {
        let mut valid_files = HashSet::new();

        test_data.iter().for_each(|data| {
            let valid = data.is_valid();
            if valid && validate_file(generator, data.get_path(), valid) {
                valid_files.insert(data.get_key());
            }
        });

        valid_files
    }

    #[fixture]
    #[once]
    fn generator() -> XMLGenerator {
        XMLGenerator::new()
    }

    #[fixture]
    #[once]
    fn test_data() -> XSDTestData {
        let root = get_workspace_root();
        let db_root = root.join("xsdtests-master");
        let archive = root.join("xsdtests.zip");

        XSDTestData::new(&db_root, &archive)
    }

    #[rstest]
    fn test_xsd_database(
        generator: &XMLGenerator,
        test_data: &XSDTestData,
    ) {
        // TODO Split into cases
        get_valid_files(generator, test_data).into_iter().for_each(|k| {
            test_file(generator, test_data, k);
        });
    }

    // #[rstest]
    // fn test_single_file(generator: &XMLGenerator, test_data: &XSDTestData) {
    //     let file = "saxonData/XmlVersions/xv008.xsd";
    //     println!("{}", file);
    //
    //     let output = test_file(generator, test_data, file);
    //     println!("{}", output);
    // }
}