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
use aws_smithy_xml::decode::{try_data, Document, ScopedDecoder, XmlError};
use std::convert::TryFrom;
#[allow(unused)]
pub fn body_is_error(body: &[u8]) -> Result<bool, XmlError> {
let mut doc = Document::try_from(body)?;
let scoped = doc.root_element()?;
Ok(scoped.start_el().matches("ErrorResponse"))
}
pub fn parse_generic_error(body: &[u8]) -> Result<aws_smithy_types::Error, XmlError> {
let mut doc = Document::try_from(body)?;
let mut root = doc.root_element()?;
let mut err_builder = aws_smithy_types::Error::builder();
while let Some(mut tag) = root.next_tag() {
match tag.start_el().local() {
"Error" => {
while let Some(mut error_field) = tag.next_tag() {
match error_field.start_el().local() {
"Code" => {
err_builder.code(try_data(&mut error_field)?);
}
"Message" => {
err_builder.message(try_data(&mut error_field)?);
}
_ => {}
}
}
}
"RequestId" => {
err_builder.request_id(try_data(&mut tag)?);
}
_ => {}
}
}
Ok(err_builder.build())
}
#[allow(unused)]
pub fn error_scope<'a, 'b>(doc: &'a mut Document<'b>) -> Result<ScopedDecoder<'b, 'a>, XmlError> {
let root = doc
.next_start_element()
.ok_or_else(|| XmlError::custom("no root found searching for an Error"))?;
if !root.matches("ErrorResponse") {
return Err(XmlError::custom("expected ErrorResponse as root"));
}
while let Some(el) = doc.next_start_element() {
if el.matches("Error") && el.depth() == 1 {
return Ok(doc.scoped_to(el));
}
}
Err(XmlError::custom("No Error found inside of ErrorResponse"))
}
#[cfg(test)]
mod test {
use super::{body_is_error, parse_generic_error};
use crate::rest_xml_wrapped_errors::error_scope;
use aws_smithy_xml::decode::Document;
use std::convert::TryFrom;
#[test]
fn parse_wrapped_error() {
let xml = br#"<ErrorResponse>
<Error>
<Type>Sender</Type>
<Code>InvalidGreeting</Code>
<Message>Hi</Message>
<AnotherSetting>setting</AnotherSetting>
<Ignore><This/></Ignore>
</Error>
<RequestId>foo-id</RequestId>
</ErrorResponse>"#;
assert!(body_is_error(xml).unwrap());
let parsed = parse_generic_error(xml).expect("valid xml");
assert_eq!(parsed.request_id(), Some("foo-id"));
assert_eq!(parsed.message(), Some("Hi"));
assert_eq!(parsed.code(), Some("InvalidGreeting"));
}
#[test]
fn test_error_scope() {
let xml: &[u8] = br#"<ErrorResponse>
<RequestId>foo-id</RequestId>
<MorePreamble>foo-id</RequestId>
<Sneaky><Error>These are not the errors you are looking for</Error></Sneaky>
<Error>
<Type>Sender</Type>
<Code>InvalidGreeting</Code>
<Message>Hi</Message>
<AnotherSetting>setting</AnotherSetting>
<Ignore><This/></Ignore>
</Error>
<RequestId>foo-id</RequestId>
</ErrorResponse>"#;
let mut doc = Document::try_from(xml).expect("valid");
let mut error = error_scope(&mut doc).expect("contains error");
let mut keys = vec![];
while let Some(tag) = error.next_tag() {
keys.push(tag.start_el().local().to_owned());
}
assert_eq!(
keys,
vec!["Type", "Code", "Message", "AnotherSetting", "Ignore",]
)
}
}