aws_sdk_sts/
rest_xml_wrapped_errors.rs

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