aws_sdk_sts/
rest_xml_wrapped_errors.rs
1use aws_smithy_types::error::metadata::{Builder as ErrorMetadataBuilder, ErrorMetadata};
8use aws_smithy_xml::decode::{try_data, Document, ScopedDecoder, XmlDecodeError};
9
10#[allow(unused)]
11pub fn body_is_error(body: &[u8]) -> Result<bool, XmlDecodeError> {
12 let mut doc = Document::try_from(body)?;
13 let scoped = doc.root_element()?;
14 Ok(scoped.start_el().matches("ErrorResponse"))
15}
16
17#[allow(dead_code)]
18pub fn parse_error_metadata(body: &[u8]) -> Result<ErrorMetadataBuilder, XmlDecodeError> {
19 let mut doc = Document::try_from(body)?;
20 let mut root = doc.root_element()?;
21 let mut err_builder = ErrorMetadata::builder();
22 while let Some(mut tag) = root.next_tag() {
23 if tag.start_el().local() == "Error" {
24 while let Some(mut error_field) = tag.next_tag() {
25 match error_field.start_el().local() {
26 "Code" => {
27 err_builder = err_builder.code(try_data(&mut error_field)?);
28 }
29 "Message" => {
30 err_builder = err_builder.message(try_data(&mut error_field)?);
31 }
32 _ => {}
33 }
34 }
35 }
36 }
37 Ok(err_builder)
38}
39
40#[allow(unused)]
41pub fn error_scope<'a, 'b>(doc: &'a mut Document<'b>) -> Result<ScopedDecoder<'b, 'a>, XmlDecodeError> {
42 let root = doc
43 .next_start_element()
44 .ok_or_else(|| XmlDecodeError::custom("no root found searching for an Error"))?;
45 if !root.matches("ErrorResponse") {
46 return Err(XmlDecodeError::custom("expected ErrorResponse as root"));
47 }
48
49 while let Some(el) = doc.next_start_element() {
50 if el.matches("Error") && el.depth() == 1 {
51 return Ok(doc.scoped_to(el));
52 }
53 }
55 Err(XmlDecodeError::custom("no error found inside of ErrorResponse"))
56}
57
58#[cfg(test)]
59mod test {
60 use super::{body_is_error, parse_error_metadata};
61 use crate::rest_xml_wrapped_errors::error_scope;
62 use aws_smithy_xml::decode::Document;
63
64 #[test]
65 fn parse_wrapped_error() {
66 let xml = br#"<ErrorResponse>
67 <Error>
68 <Type>Sender</Type>
69 <Code>InvalidGreeting</Code>
70 <Message>Hi</Message>
71 <AnotherSetting>setting</AnotherSetting>
72 <Ignore><This/></Ignore>
73 </Error>
74 <RequestId>foo-id</RequestId>
75</ErrorResponse>"#;
76 assert!(body_is_error(xml).unwrap());
77 let parsed = parse_error_metadata(xml).expect("valid xml").build();
78 assert_eq!(parsed.message(), Some("Hi"));
79 assert_eq!(parsed.code(), Some("InvalidGreeting"));
80 }
81
82 #[test]
83 fn test_error_scope() {
84 let xml: &[u8] = br#"<ErrorResponse>
85 <RequestId>foo-id</RequestId>
86 <MorePreamble>foo-id</RequestId>
87 <Sneaky><Error>These are not the errors you are looking for</Error></Sneaky>
88 <Error>
89 <Type>Sender</Type>
90 <Code>InvalidGreeting</Code>
91 <Message>Hi</Message>
92 <AnotherSetting>setting</AnotherSetting>
93 <Ignore><This/></Ignore>
94 </Error>
95 <RequestId>foo-id</RequestId>
96</ErrorResponse>"#;
97 let mut doc = Document::try_from(xml).expect("valid");
98 let mut error = error_scope(&mut doc).expect("contains error");
99 let mut keys = vec![];
100 while let Some(tag) = error.next_tag() {
101 keys.push(tag.start_el().local().to_owned());
102 }
104 assert_eq!(keys, vec!["Type", "Code", "Message", "AnotherSetting", "Ignore",])
105 }
106}