fastxml 0.9.0

A fast, memory-efficient XML library with XPath and XSD validation support
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

//! Tests for the redesigned `Validator` entry point and its `Report`.

use std::io::BufReader;
use std::sync::Arc;

use fastxml::Parser;
use fastxml::schema::{Schema, Validator};

const XSD: &str = r#"<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="age" type="xs:int"/>
</xs:schema>"#;

const VALID: &str = r#"<?xml version="1.0"?><age>42</age>"#;
const INVALID: &str = r#"<?xml version="1.0"?><age>oops</age>"#;

fn schema() -> Arc<Schema> {
    Arc::new(Schema::from_xsd(XSD.as_bytes()).unwrap())
}

#[test]
fn streaming_explicit_schema_valid() {
    let report = Validator::from(VALID).schema(schema()).run().unwrap();
    assert!(report.is_valid(), "errors: {:?}", report.errors());
    assert!(report.is_clean());
}

#[test]
fn streaming_explicit_schema_invalid() {
    let report = Validator::from(INVALID).schema(schema()).run().unwrap();
    assert!(!report.is_valid());
    assert!(!report.errors().is_empty());
    assert!(report.error_count() >= 1);
}

#[test]
fn dom_explicit_schema_valid() {
    let doc = Parser::from(VALID).parse().unwrap();
    let report = Validator::from(&doc).schema(schema()).run().unwrap();
    assert!(report.is_valid(), "errors: {:?}", report.errors());
}

#[test]
fn dom_explicit_schema_invalid() {
    let doc = Parser::from(INVALID).parse().unwrap();
    let report = Validator::from(&doc).schema(schema()).run().unwrap();
    assert!(!report.is_valid());
}

#[test]
fn from_reader_valid() {
    let report = Validator::from_reader(BufReader::new(VALID.as_bytes()))
        .schema(schema())
        .run()
        .unwrap();
    assert!(report.is_valid(), "errors: {:?}", report.errors());
}

#[test]
fn from_bytes_input() {
    let report = Validator::from(VALID.as_bytes())
        .schema(schema())
        .run()
        .unwrap();
    assert!(report.is_valid());
}

#[test]
fn dom_and_streaming_agree() {
    let s = schema();
    for (xml, expected_valid) in [(VALID, true), (INVALID, false)] {
        let doc = Parser::from(xml).parse().unwrap();
        let dom = Validator::from(&doc).schema(Arc::clone(&s)).run().unwrap();
        let stream = Validator::from(xml).schema(Arc::clone(&s)).run().unwrap();
        assert_eq!(dom.is_valid(), expected_valid, "DOM disagreed for {xml}");
        assert_eq!(
            stream.is_valid(),
            expected_valid,
            "stream disagreed for {xml}"
        );
        assert_eq!(
            dom.is_valid(),
            stream.is_valid(),
            "DOM and streaming disagreed for {xml}"
        );
    }
}

#[test]
fn max_errors_caps_collection() {
    // Two bad children → cap at 1 should collect at most 1 error.
    let xsd = r#"<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="root">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="n" type="xs:int" maxOccurs="unbounded"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
</xs:schema>"#;
    let xml = r#"<?xml version="1.0"?><root><n>a</n><n>b</n><n>c</n></root>"#;
    let s = Arc::new(Schema::from_xsd(xsd.as_bytes()).unwrap());

    let capped = Validator::from(xml)
        .schema(Arc::clone(&s))
        .max_errors(1)
        .run()
        .unwrap();
    assert!(!capped.is_valid());
    assert!(
        capped.error_count() <= 1,
        "expected cap of 1, got {}",
        capped.error_count()
    );
}