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

#[cfg(test)]
mod tests {
    use gag::Gag;
    use std::fs::ReadDir;
    use std::path::PathBuf;
    use std::{fs, panic};
    use workspace_root::get_workspace_root;
    use xmlgenerator::XMLGenerator;
    use xmlgenerator::error::XMLGeneratorError;

    fn fetch_test_files(directory: &str) -> ReadDir {
        let root: PathBuf = get_workspace_root();

        let mut example_dir = root;
        example_dir.push("examples");
        example_dir.push(directory);

        fs::read_dir(example_dir).unwrap()
    }

    fn check_error(error: &XMLGeneratorError, expected_error: &String) {
        match error {
            XMLGeneratorError::InvalidPathError(e) => panic!("Invalid path error: {}", e),
            XMLGeneratorError::XSDValidatorError(e) => panic!("XSD validator error: {}", e),
            XMLGeneratorError::DataTypeInformationError(e) => {
                panic!("Data type information error: {}", e)
            }
            XMLGeneratorError::DataTypeNotFoundError(e) => panic!("Data type not found: {}", e),
            XMLGeneratorError::XSDParserError(e) => panic!("XSD parser error: {}", e),
            XMLGeneratorError::DataTypesFormatError(e) => panic!("DataTypes format error: {}", e),
            XMLGeneratorError::XMLBuilderError(e) => panic!("XML builder error: {}", e),
            XMLGeneratorError::InvalidXSDVersionError(e) => panic!("Invalid XSD version: {}", e),
            XMLGeneratorError::InfiniteRecursionError => {
                assert_eq!("Recursion detected", expected_error)
            }
            XMLGeneratorError::NoElementsError => panic!("No elements included in XSD"),
            XMLGeneratorError::InvalidXSDError(e) => panic!("Invalid XSD error: {}", e),
            XMLGeneratorError::NoIndependentElementsError => {}
            XMLGeneratorError::MultipleRootsError => {}
            XMLGeneratorError::TypeGenerationError(e) => panic!("Type generation error: {}", e),
            XMLGeneratorError::RegexError(e) => panic!("Regex error: {}", e),
            XMLGeneratorError::UnimplementedFeature(e) => panic!("Unimplemented feature: {}", e),
            XMLGeneratorError::InvalidXSDNameError(e) => panic!("Invalid XSD name: {}", e),
            XMLGeneratorError::LineEndingsError(e) => panic!("Line endings error: {}", e),
            XMLGeneratorError::RegexMismatchError(p1, p2) => {
                panic!("Incompatible patterns: {} and {}", p1, p2)
            }
            XMLGeneratorError::EncodingError => panic!("Encoding error"),
        }
    }

    fn test_xml(generator: &XMLGenerator, filepath: &PathBuf, expected: &String) {
        match generator.generate(filepath, Some(47)) {
            Ok(_) => panic!("No error thrown for invalid result"),
            Err(error) => check_error(&error, expected),
        }
    }

    fn test_error(generator: &XMLGenerator, filename: &str, error: &str) {
        let files = fetch_test_files("invalid");

        for file in files {
            let filepath = file.unwrap().path();
            if filepath.ends_with(filename) {
                test_xml(generator, &filepath, &error.to_string());
            }
        }
    }

    fn run_generator(
        generator: &XMLGenerator,
        filepath: &PathBuf,
    ) -> Result<String, XMLGeneratorError> {
        let _err_gag = Gag::stderr().unwrap();

        generator.generate(filepath, Some(42))
    }

    #[test]
    fn test_examples() {
        let generator = XMLGenerator::new();
        let files = fetch_test_files("working");

        for file in files {
            let filepath = file.unwrap().path();

            match run_generator(&generator, &filepath) {
                Ok(out) => println!("{}", out),
                Err(err) => {
                    panic!("XMLGenerator error: {:?}", err);
                }
            }
        }

        test_error(&generator, "recursive.xsd", "Recursion detected");
        test_error(
            &generator,
            "two_roots.xsd",
            "not implemented: Multiple independent (root) elements",
        );
    }
}