Client Test

rev. ce76c569583a3fdee1e9d39e082a8d5efd7b13b7 (ignoring whitespace)

Files changed:

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/xml_unions.rs

@@ -188,188 +501,502 @@

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for XmlUnionsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "XmlUnionsEndpointParamsInterceptor"
-191
+    }
-192
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<XmlUnionsInput>()
             .ok_or("failed to downcast to XmlUnionsInput")?;
-207

         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-214
+    }
-215
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod xml_unions_request_test {
 mod xml_unions_test {
-+
     /// Serializes union struct member
     /// Test ID: XmlUnionsWithStructMember
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn xml_unions_with_struct_member_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-227
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .xml_unions()
             .set_union_value(::std::option::Option::Some(crate::types::XmlUnionShape::StructValue(
                 crate::types::XmlNestedUnionStruct::builder()
                     .set_string_value(::std::option::Option::Some("string".to_owned()))
                     .set_boolean_value(::std::option::Option::Some(true))
                     .set_byte_value(::std::option::Option::Some(1))
                     .set_short_value(::std::option::Option::Some(2))
                     .set_integer_value(::std::option::Option::Some(3))
                     .set_long_value(::std::option::Option::Some(4))
                     .set_float_value(::std::option::Option::Some(5.5_f32))
                     .set_double_value(::std::option::Option::Some(6.5_f64))
                     .build(),
             )))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/xml")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(
         ::aws_smithy_protocol_test::validate_body(body, "<XmlUnionsRequest>\n    <unionValue>\n       <structValue>\n          <stringValue>string</stringValue>\n          <booleanValue>true</booleanValue>\n          <byteValue>1</byteValue>\n          <shortValue>2</shortValue>\n          <integerValue>3</integerValue>\n          <longValue>4</longValue>\n          <floatValue>5.5</floatValue>\n          <doubleValue>6.5</doubleValue>\n       </structValue>\n    </unionValue>\n</XmlUnionsRequest>\n", ::aws_smithy_protocol_test::MediaType::from("application/xml"))
         );
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/XmlUnions", "path was incorrect");
-256
+    }
     /// serialize union string member
     /// Test ID: XmlUnionsWithStringMember
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn xml_unions_with_string_member_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-264
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .xml_unions()
             .set_union_value(::std::option::Option::Some(crate::types::XmlUnionShape::StringValue(
                 "some string".to_owned(),
             )))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/xml")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "<XmlUnionsRequest>\n   <unionValue>\n      <stringValue>some string</stringValue>\n   </unionValue>\n</XmlUnionsRequest>\n",
             ::aws_smithy_protocol_test::MediaType::from("application/xml"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/XmlUnions", "path was incorrect");
-286
+    }
     /// Serializes union boolean member
     /// Test ID: XmlUnionsWithBooleanMember
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn xml_unions_with_boolean_member_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-294
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .xml_unions()
             .set_union_value(::std::option::Option::Some(crate::types::XmlUnionShape::BooleanValue(true)))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/xml")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "<XmlUnionsRequest>\n   <unionValue>\n      <booleanValue>true</booleanValue>\n   </unionValue>\n</XmlUnionsRequest>\n",
             ::aws_smithy_protocol_test::MediaType::from("application/xml"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/XmlUnions", "path was incorrect");
-314
+    }
     /// Serializes union member
     /// Test ID: XmlUnionsWithUnionMember
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn xml_unions_with_union_member_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-322
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .xml_unions()
             .set_union_value(::std::option::Option::Some(crate::types::XmlUnionShape::UnionValue(
                 ::std::boxed::Box::new(crate::types::XmlUnionShape::BooleanValue(true)),
             )))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/xml")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(
         ::aws_smithy_protocol_test::validate_body(body, "<XmlUnionsRequest>\n   <unionValue>\n      <unionValue>\n         <booleanValue>true</booleanValue>\n      </unionValue>\n   </unionValue>\n</XmlUnionsRequest>\n", ::aws_smithy_protocol_test::MediaType::from("application/xml"))
         );
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/XmlUnions", "path was incorrect");
-342
+    }
     /// Serializes union struct member
     /// Test ID: XmlUnionsWithStructMember
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn xml_unions_with_struct_member_response() {
         let expected_output = crate::operation::xml_unions::XmlUnionsOutput::builder()
             .set_union_value(::std::option::Option::Some(crate::types::XmlUnionShape::StructValue(
                 crate::types::XmlNestedUnionStruct::builder()
                     .set_string_value(::std::option::Option::Some("string".to_owned()))
                     .set_boolean_value(::std::option::Option::Some(true))
                     .set_byte_value(::std::option::Option::Some(1))
                     .set_short_value(::std::option::Option::Some(2))
                     .set_integer_value(::std::option::Option::Some(3))
                     .set_long_value(::std::option::Option::Some(4))
                     .set_float_value(::std::option::Option::Some(5.5_f32))
                     .set_double_value(::std::option::Option::Some(6.5_f64))
                     .build(),
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "application/xml")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlUnionsResponse>\n    <unionValue>\n       <structValue>\n          <stringValue>string</stringValue>\n          <booleanValue>true</booleanValue>\n          <byteValue>1</byteValue>\n          <shortValue>2</shortValue>\n          <integerValue>3</integerValue>\n          <longValue>4</longValue>\n          <floatValue>5.5</floatValue>\n          <doubleValue>6.5</doubleValue>\n       </structValue>\n    </unionValue>\n</XmlUnionsResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-370
         let op = crate::operation::xml_unions::XmlUnions::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-376
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::xml_unions::XmlUnionsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.union_value, expected_output.union_value, "Unexpected value for `union_value`");
-388
+    }
     /// Serializes union string member
     /// Test ID: XmlUnionsWithStringMember
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn xml_unions_with_string_member_response() {
         let expected_output = crate::operation::xml_unions::XmlUnionsOutput::builder()
             .set_union_value(::std::option::Option::Some(crate::types::XmlUnionShape::StringValue(
                 "some string".to_owned(),
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("Content-Type", "application/xml")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "<XmlUnionsResponse>\n   <unionValue>\n      <stringValue>some string</stringValue>\n   </unionValue>\n</XmlUnionsResponse>\n",
                 ))
                 .unwrap(),
-407
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-411
         let op = crate::operation::xml_unions::XmlUnions::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-417
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::xml_unions::XmlUnionsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.union_value, expected_output.union_value, "Unexpected value for `union_value`");
-429
+    }
     /// Serializes union boolean member
     /// Test ID: XmlUnionsWithBooleanMember
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn xml_unions_with_boolean_member_response() {
         let expected_output = crate::operation::xml_unions::XmlUnionsOutput::builder()
             .set_union_value(::std::option::Option::Some(crate::types::XmlUnionShape::BooleanValue(true)))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("Content-Type", "application/xml")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "<XmlUnionsResponse>\n   <unionValue>\n      <booleanValue>true</booleanValue>\n   </unionValue>\n</XmlUnionsResponse>\n",
                 ))
                 .unwrap(),
-446
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-450
         let op = crate::operation::xml_unions::XmlUnions::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-456
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::xml_unions::XmlUnionsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.union_value, expected_output.union_value, "Unexpected value for `union_value`");
-468
+    }
     /// Serializes union member
     /// Test ID: XmlUnionsWithUnionMember
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn xml_unions_with_union_member_response() {
         let expected_output = crate::operation::xml_unions::XmlUnionsOutput::builder()
             .set_union_value(::std::option::Option::Some(crate::types::XmlUnionShape::UnionValue(
                 ::std::boxed::Box::new(crate::types::XmlUnionShape::BooleanValue(true)),
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "application/xml")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlUnionsResponse>\n   <unionValue>\n      <unionValue>\n         <booleanValue>true</booleanValue>\n      </unionValue>\n   </unionValue>\n</XmlUnionsResponse>\n"))

↧ Expand context

                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-487
         let op = crate::operation::xml_unions::XmlUnions::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-493
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::xml_unions::XmlUnionsOutput>()

tmp-codegen-diff/codegen-client-test/rest_xml_extras/rust-client-codegen/Cargo.toml

@@ -11,11 +48,53 @@

↥ Expand context

 [dependencies.aws-smithy-async]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-async"
 [dependencies.aws-smithy-http]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http"
 [dependencies.aws-smithy-runtime]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime"
 features = ["client"]
 [dependencies.aws-smithy-runtime-api]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime-api"
 features = ["client", "http-02x"]
 [dependencies.aws-smithy-types]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-types"
 [dependencies.aws-smithy-xml]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-xml"
 [dependencies.http]
 version = "0.2.9"
 [dependencies.md-5]
 version = "0.10.0"
 [dev-dependencies.aws-smithy-protocol-test]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-protocol-test"

 [dev-dependencies.aws-smithy-runtime]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime"
 features = ["client", "test-util"]
 [dev-dependencies.bytes]
 version = "1.4.0"
 [dev-dependencies.pretty_assertions]
 version = "1.3.0"
 [dev-dependencies.tokio]
 version = "1.23.1"
 features = ["macros", "test-util", "rt-multi-thread"]
 [dev-dependencies.tracing]
 version = "0.1"
 [dev-dependencies.tracing-test]
 version = "0.2.5"
 features = ["no-env-filter"]
 [features]
 test-util = ["aws-smithy-runtime/test-util"]
 rt-tokio = ["aws-smithy-async/rt-tokio", "aws-smithy-types/rt-tokio"]
 behavior-version-latest = []
 rustls = ["aws-smithy-runtime/tls-rustls"]
 default = ["rt-tokio", "rustls"]
-52
-53

tmp-codegen-diff/codegen-client-test/rest_xml_extras/rust-client-codegen/src/operation/attribute_party.rs

@@ -187,187 +250,251 @@

↥ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for AttributePartyEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "AttributePartyEndpointParamsInterceptor"
-190
+    }
-191
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<AttributePartyInput>()
             .ok_or("failed to downcast to AttributePartyInput")?;
-206

         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-213
+    }
-214
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod attribute_party_request_test {
 mod attribute_party_test {
-+
     /// Test ID: DeserAttributes
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn deser_attributes_response() {
         let expected_output = crate::operation::attribute_party::AttributePartyOutput::builder()
             .set_enum(::std::option::Option::Some(
                 "enumvalue".parse::<crate::types::StringEnum>().expect("static value validated to member"),
             ))
             .set_number(::std::option::Option::Some(5))
             .set_ts(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 482196050, 0_f64,
             )))
             .set_bool(::std::option::Option::Some(true))

↧ Expand context

             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "<AttributePartyInputOutput enum=\"enumvalue\" prefix:anumber=\"5\" ts=\"1985-04-12T23:20:50.00Z\" bool=\"true\"/>",
                 ))
                 .unwrap(),
-240
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-244
         let op = crate::operation::attribute_party::AttributeParty::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-250
         let parsed = de.deserialize_streaming(&mut http_response);

tmp-codegen-diff/codegen-client-test/rest_xml_extras/rust-client-codegen/src/operation/checksum_required.rs

@@ -193,193 +256,257 @@

↥ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ChecksumRequiredEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ChecksumRequiredEndpointParamsInterceptor"
-196
+    }
-197
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<ChecksumRequiredInput>()
             .ok_or("failed to downcast to ChecksumRequiredInput")?;
-212

         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-219
+    }
-220
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod checksum_required_request_test {
 mod checksum_required_test {
-+
     /// Test ID: ChecksumRequiredHeader
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn checksum_required_header_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-231
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .checksum_required()
             .set_field(::std::option::Option::Some("hello".to_owned()))
             .send()
             .await;

↧ Expand context

         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Md5", "JAJAqYA61wMhATGeQqRcMQ==")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "<ChecksumRequiredInput><field>hello</field></ChecksumRequiredInput>",
             ::aws_smithy_protocol_test::MediaType::from("application/xml"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/ChecksumRequired", "path was incorrect");
-251
+    }
-252
+}
-253
 /// Error type for the `ChecksumRequiredError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum ChecksumRequiredError {

tmp-codegen-diff/codegen-client-test/rest_xml_extras/rust-client-codegen/src/operation/enum_keys.rs

@@ -184,184 +279,280 @@

↥ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for EnumKeysEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "EnumKeysEndpointParamsInterceptor"
-187
+    }
-188
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<EnumKeysInput>()
             .ok_or("failed to downcast to EnumKeysInput")?;
-203

         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-210
+    }
-211
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod enum_keys_request_test {
 mod enum_keys_test {
-+
     /// Test ID: SerEnumMap
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn ser_enum_map_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-222
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .enum_keys()
             .set_data(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "enumvalue".parse::<crate::types::StringEnum>().expect("static value validated to member"),
                     "hello".to_owned(),
                 );
                 ret
             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "<XmlMapEnumKeys><data><entry><key>enumvalue</key><value>hello</value></entry></data></XmlMapEnumKeys>",
             ::aws_smithy_protocol_test::MediaType::from("application/xml"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/enumkeys", "path was incorrect");
-247
+    }
     /// Test ID: DeserEnumMap
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn deser_enum_map_response() {
         let expected_output = crate::operation::enum_keys::EnumKeysOutput::builder()
             .set_data(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "enumvalue".parse::<crate::types::StringEnum>().expect("static value validated to member"),
                     "hello".to_owned(),
                 );
                 ret
             }))

↧ Expand context

             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "<XmlMapEnumKeys><data><entry><key>enumvalue</key><value>hello</value></entry></data></XmlMapEnumKeys>",
                 ))
                 .unwrap(),
-269
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-273
         let op = crate::operation::enum_keys::EnumKeys::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-279
         let parsed = de.deserialize_streaming(&mut http_response);

tmp-codegen-diff/codegen-client-test/rest_xml_extras/rust-client-codegen/src/operation/primitive_int_op_xml.rs

@@ -193,193 +279,280 @@

↥ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PrimitiveIntOpXmlEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PrimitiveIntOpXmlEndpointParamsInterceptor"
-196
+    }
-197
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<PrimitiveIntOpXmlInput>()
             .ok_or("failed to downcast to PrimitiveIntOpXmlInput")?;
-212

         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-219
+    }
-220
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod primitive_int_op_xml_request_test {
 mod primitive_int_op_xml_test {
-+
     /// Primitive ints should not be serialized when they are unset
     /// Test ID: RestXmlSerPrimitiveIntUnset
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_xml_ser_primitive_int_unset_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-232
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.primitive_int_op_xml().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "    <PrimitiveIntDocument>\n    </PrimitiveIntDocument>\n",
             ::aws_smithy_protocol_test::MediaType::from("application/xml"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/primitive-document", "path was incorrect");
-246
+    }
     /// Primitive ints should not be serialized when they are unset
     /// Test ID: RestXmlSerPrimitiveIntSetToDefault
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_xml_ser_primitive_int_set_to_default_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-254
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.primitive_int_op_xml().set_value(::std::option::Option::Some(1)).send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(

↧ Expand context

             body,
             "<PrimitiveIntDocument>\n     <value>1</value>\n</PrimitiveIntDocument>\n",
             ::aws_smithy_protocol_test::MediaType::from("application/xml"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/primitive-document", "path was incorrect");
-268
+    }
-269
+}
-270
 /// Error type for the `PrimitiveIntOpXmlError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum PrimitiveIntOpXmlError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
     variable wildcard pattern and check `.code()`:
-278
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-280
+     \

tmp-codegen-diff/codegen-client-test/rest_xml_extras/rust-client-codegen/src/operation/string_header.rs

@@ -187,187 +254,255 @@

↥ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for StringHeaderEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "StringHeaderEndpointParamsInterceptor"
-190
+    }
-191
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<StringHeaderInput>()
             .ok_or("failed to downcast to StringHeaderInput")?;
-206

         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-213
+    }
-214
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod string_header_request_test {
 mod string_header_test {
-+
     /// Regression test for https://github.com/awslabs/aws-sdk-rust/issues/122
     /// where `,` was eagerly used to split fields in cases where the input was not
     /// a list.
     ///
     /// Test ID: DeserHeaderStringCommas
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn deser_header_string_commas_response() {
         let expected_output = crate::operation::string_header::StringHeaderOutput::builder()
             .set_field(::std::option::Option::Some("a,b,c".to_owned()))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("x-field", "a,b,c")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(""))
                 .unwrap(),

↧ Expand context

-236
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-240
         let op = crate::operation::string_header::StringHeader::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-246
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::string_header::StringHeaderOutput>()

tmp-codegen-diff/codegen-client-test/rest_xml_extras/rust-client-codegen/src/operation/xml_maps_flattened_nested_xml_namespace.rs

@@ -203,203 +266,267 @@

↥ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for XmlMapsFlattenedNestedXmlNamespaceEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "XmlMapsFlattenedNestedXmlNamespaceEndpointParamsInterceptor"
-206
+    }
-207
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<XmlMapsFlattenedNestedXmlNamespaceInput>()
             .ok_or("failed to downcast to XmlMapsFlattenedNestedXmlNamespaceInput")?;
-222

         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-229
+    }
-230
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod xml_maps_flattened_nested_xml_namespace_request_test {
 mod xml_maps_flattened_nested_xml_namespace_test {
-+
     /// Test ID: DeserFlatNamespaceMaps
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn deser_flat_namespace_maps_response() {
         let expected_output = crate::operation::xml_maps_flattened_nested_xml_namespace::XmlMapsFlattenedNestedXmlNamespaceOutput::builder()
             .set_my_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("map2".to_owned(), {
                     let mut ret = ::std::collections::HashMap::new();
                     ret.insert("fourth".to_owned(), "onegai".to_owned());
                     ret.insert("third".to_owned(), "plz".to_owned());
                     ret
                 });

↧ Expand context

                 ret.insert("map1".to_owned(), {
                     let mut ret = ::std::collections::HashMap::new();
                     ret.insert("second".to_owned(), "konnichiwa".to_owned());
                     ret.insert("first".to_owned(), "hi".to_owned());
                     ret
                 });
                 ret
             }))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlMapsFlattenedNestedXmlNamespaceInputOutput xmlns=\"http://aoo.com\"><myMap><yek xmlns=\"http://doo.com\">map2</yek><eulav xmlns=\"http://eoo.com\"><entry><K xmlns=\"http://goo.com\">third</K><V xmlns=\"http://hoo.com\">plz</V></entry><entry><K xmlns=\"http://goo.com\">fourth</K><V xmlns=\"http://hoo.com\">onegai</V></entry></eulav></myMap><myMap><yek xmlns=\"http://doo.com\">map1</yek><eulav xmlns=\"http://eoo.com\"><entry><K xmlns=\"http://goo.com\">second</K><V xmlns=\"http://hoo.com\">konnichiwa</V></entry><entry><K xmlns=\"http://goo.com\">first</K><V xmlns=\"http://hoo.com\">hi</V></entry></eulav></myMap></XmlMapsFlattenedNestedXmlNamespaceInput>"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-264
         let op = crate::operation::xml_maps_flattened_nested_xml_namespace::XmlMapsFlattenedNestedXmlNamespace::new();
         let config = op.config().expect("the operation has config");
         let de = config

tmp-codegen-diff/codegen-client-test/rest_xml_extras_unwrapped/rust-client-codegen/Cargo.toml

@@ -4,4 +41,46 @@

↥ Expand context

 version = "0.0.1"
 authors = ["protocoltest@example.com"]
 description = "test"
 edition = "2021"
-8
 [package.metadata.smithy]
 codegen-version = "ci"
 [dependencies.aws-smithy-async]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-async"
 [dependencies.aws-smithy-http]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http"
 [dependencies.aws-smithy-runtime]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime"
 features = ["client"]
 [dependencies.aws-smithy-runtime-api]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime-api"
 features = ["client", "http-02x"]
 [dependencies.aws-smithy-types]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-types"
 [dependencies.aws-smithy-xml]

 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-xml"
 [dependencies.http]
 version = "0.2.9"
 [dev-dependencies.bytes]
 version = "1.4.0"
 [dev-dependencies.pretty_assertions]
 version = "1.3.0"
 [dev-dependencies.tokio]
 version = "1.23.1"
 features = ["macros", "test-util", "rt-multi-thread"]
 [dev-dependencies.tracing]
 version = "0.1"
 [dev-dependencies.tracing-test]
 version = "0.2.5"
 features = ["no-env-filter"]
 [features]
 test-util = ["aws-smithy-runtime/test-util"]
 rt-tokio = ["aws-smithy-async/rt-tokio", "aws-smithy-types/rt-tokio"]
 behavior-version-latest = []
 rustls = ["aws-smithy-runtime/tls-rustls"]
 default = ["rt-tokio", "rustls"]
-45
-46

tmp-codegen-diff/codegen-client-test/rest_xml_extras_unwrapped/rust-client-codegen/src/operation/greeting_with_unwrapped_errors.rs

@@ -193,193 +331,332 @@

↥ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GreetingWithUnwrappedErrorsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GreetingWithUnwrappedErrorsEndpointParamsInterceptor"
-196
+    }
-197
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<GreetingWithUnwrappedErrorsInput>()
             .ok_or("failed to downcast to GreetingWithUnwrappedErrorsInput")?;
-212

         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-219
+    }
-220
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod greeting_with_unwrapped_errors_request_test {
 mod greeting_with_unwrapped_errors_test {
-+
     /// Ensures that operations with errors successfully know how to deserialize the successful response
     /// Test ID: GreetingWithErrorsUnwrapped
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn greeting_with_errors_unwrapped_response() {
         let expected_output = crate::operation::greeting_with_unwrapped_errors::GreetingWithUnwrappedErrorsOutput::builder()
             .set_greeting(::std::option::Option::Some("Hello".to_owned()))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("X-Greeting", "Hello")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(""))
                 .unwrap(),
-239
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-243
         let op = crate::operation::greeting_with_unwrapped_errors::GreetingWithUnwrappedErrors::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-249
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::greeting_with_unwrapped_errors::GreetingWithUnwrappedErrorsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.greeting, expected_output.greeting, "Unexpected value for `greeting`");
-261
+    }
     /// Parses simple XML errors
     /// Test ID: InvalidGreetingErrorUnwrapped
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn invalid_greeting_error_unwrapped_response() {
         let expected_output = crate::types::error::InvalidGreetingUnwrapped::builder()
             .set_message(::std::option::Option::Some("Hi".to_owned()))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "application/xml")
         .status(400)
                     .body(::aws_smithy_types::body::SdkBody::from("   <Error>\n      <Type>Sender</Type>\n      <Code>InvalidGreetingUnwrapped</Code>\n      <Message>Hi</Message>\n      <AnotherSetting>setting</AnotherSetting>\n      <RequestId>foo-id</RequestId>\n   </Error>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-278
         let op = crate::operation::greeting_with_unwrapped_errors::GreetingWithUnwrappedErrors::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-284
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed.expect_err("should be error response");
         let parsed: &crate::operation::greeting_with_unwrapped_errors::GreetingWithUnwrappedErrorsError =
             parsed.as_operation_error().expect("operation error").downcast_ref().unwrap();
         if let crate::operation::greeting_with_unwrapped_errors::GreetingWithUnwrappedErrorsError::InvalidGreetingUnwrapped(parsed) = parsed {
             ::pretty_assertions::assert_eq!(parsed.message, expected_output.message, "Unexpected value for `message`");
         } else {
             panic!("wrong variant: Got: {:?}. Expected: {:?}", parsed, expected_output);
-298
+        }
-299
+    }
     /// Test ID: ComplexErrorUnwrapped
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn complex_error_unwrapped_response() {
         let expected_output = crate::types::error::ComplexErrorUnwrapped::builder()
             .set_header(::std::option::Option::Some("Header".to_owned()))
             .set_top_level(::std::option::Option::Some("Top level".to_owned()))
             .set_nested(::std::option::Option::Some(
                 crate::types::ComplexNestedErrorData::builder()
                     .set_foo(::std::option::Option::Some("bar".to_owned()))
                     .build(),
             ))
             .build();

↧ Expand context

         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "application/xml")
         .header("X-Header", "Header")
         .status(400)
                     .body(::aws_smithy_types::body::SdkBody::from("   <Error>\n      <Type>Sender</Type>\n      <Code>ComplexErrorUnwrapped</Code>\n      <Message>Hi</Message>\n      <TopLevel>Top level</TopLevel>\n      <Nested>\n          <Foo>bar</Foo>\n      </Nested>\n   <RequestId>foo-id</RequestId>\n   </Error>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-322
         let op = crate::operation::greeting_with_unwrapped_errors::GreetingWithUnwrappedErrors::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-328
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));

tmp-codegen-diff/codegen-client-test/rest_xml_namespace/rust-client-codegen/Cargo.toml

@@ -9,9 +46,51 @@

↥ Expand context

 [package.metadata.smithy]
 codegen-version = "ci"
 [dependencies.aws-smithy-async]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-async"
 [dependencies.aws-smithy-http]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http"
 [dependencies.aws-smithy-runtime]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime"
 features = ["client"]
 [dependencies.aws-smithy-runtime-api]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime-api"
 features = ["client", "http-02x"]
 [dependencies.aws-smithy-types]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-types"
 [dependencies.aws-smithy-xml]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-xml"
 [dependencies.http]
 version = "0.2.9"
 [dev-dependencies.aws-smithy-protocol-test]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-protocol-test"

 [dev-dependencies.aws-smithy-runtime]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime"
 features = ["client", "test-util"]
 [dev-dependencies.bytes]
 version = "1.4.0"
 [dev-dependencies.pretty_assertions]
 version = "1.3.0"
 [dev-dependencies.tokio]
 version = "1.23.1"
 features = ["macros", "test-util", "rt-multi-thread"]
 [dev-dependencies.tracing]
 version = "0.1"
 [dev-dependencies.tracing-test]
 version = "0.2.5"
 features = ["no-env-filter"]
 [features]
 test-util = ["aws-smithy-runtime/test-util"]
 rt-tokio = ["aws-smithy-async/rt-tokio", "aws-smithy-types/rt-tokio"]
 behavior-version-latest = []
 rustls = ["aws-smithy-runtime/tls-rustls"]
 default = ["rt-tokio", "rustls"]
-50
-51

tmp-codegen-diff/codegen-client-test/rest_xml_namespace/rust-client-codegen/src/operation/simple_scalar_properties.rs

@@ -200,200 +305,306 @@

↥ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for SimpleScalarPropertiesEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "SimpleScalarPropertiesEndpointParamsInterceptor"
-203
+    }
-204
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<SimpleScalarPropertiesInput>()
             .ok_or("failed to downcast to SimpleScalarPropertiesInput")?;
-219

         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-226
+    }
-227
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod simple_scalar_properties_request_test {
 mod simple_scalar_properties_test {
     use ::aws_smithy_protocol_test::FloatEquals;
-+
     /// Serializes simple scalar properties
     /// Test ID: XmlNamespaceSimpleScalarProperties
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn xml_namespace_simple_scalar_properties_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-240
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .simple_scalar_properties()
             .set_foo(::std::option::Option::Some("Foo".to_owned()))
             .set_string_value(::std::option::Option::Some("string".to_owned()))
             .set_true_boolean_value(::std::option::Option::Some(true))
             .set_false_boolean_value(::std::option::Option::Some(false))
             .set_byte_value(::std::option::Option::Some(1))
             .set_short_value(::std::option::Option::Some(2))
             .set_integer_value(::std::option::Option::Some(3))
             .set_long_value(::std::option::Option::Some(4))
             .set_float_value(::std::option::Option::Some(5.5_f32))
             .set_double_value(::std::option::Option::Some(6.5_f64))
             .set_nested(::std::option::Option::Some(
                 crate::types::NestedWithNamespace::builder()
                     .set_attr_field(::std::option::Option::Some("nestedAttrValue".to_owned()))
                     .build(),
             ))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/xml"), ("X-Foo", "Foo")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(
         ::aws_smithy_protocol_test::validate_body(body, "<SimpleScalarPropertiesInputOutput xmlns=\"https://example.com\">\n    <stringValue>string</stringValue>\n    <trueBooleanValue>true</trueBooleanValue>\n    <falseBooleanValue>false</falseBooleanValue>\n    <byteValue>1</byteValue>\n    <shortValue>2</shortValue>\n    <integerValue>3</integerValue>\n    <longValue>4</longValue>\n    <floatValue>5.5</floatValue>\n    <DoubleDribble>6.5</DoubleDribble>\n    <Nested xmlns:xsi=\"https://example.com\" xsi:someName=\"nestedAttrValue\"></Nested>\n</SimpleScalarPropertiesInputOutput>\n", ::aws_smithy_protocol_test::MediaType::from("application/xml"))
         );
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/SimpleScalarProperties", "path was incorrect");
-272
+    }
     /// Serializes simple scalar properties
     /// Test ID: XmlNamespaceSimpleScalarProperties
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn xml_namespace_simple_scalar_properties_response() {
         let expected_output = crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput::builder()
             .set_foo(::std::option::Option::Some("Foo".to_owned()))
             .set_string_value(::std::option::Option::Some("string".to_owned()))
             .set_true_boolean_value(::std::option::Option::Some(true))
             .set_false_boolean_value(::std::option::Option::Some(false))
             .set_byte_value(::std::option::Option::Some(1))
             .set_short_value(::std::option::Option::Some(2))
             .set_integer_value(::std::option::Option::Some(3))
             .set_long_value(::std::option::Option::Some(4))

↧ Expand context

             .set_float_value(::std::option::Option::Some(5.5_f32))
             .set_double_value(::std::option::Option::Some(6.5_f64))
             .set_nested(::std::option::Option::Some(
                 crate::types::NestedWithNamespace::builder()
                     .set_attr_field(::std::option::Option::Some("nestedAttrValue".to_owned()))
                     .build(),
             ))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "application/xml")
         .header("X-Foo", "Foo")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<SimpleScalarPropertiesInputOutput xmlns=\"https://example.com\">\n    <stringValue>string</stringValue>\n    <trueBooleanValue>true</trueBooleanValue>\n    <falseBooleanValue>false</falseBooleanValue>\n    <byteValue>1</byteValue>\n    <shortValue>2</shortValue>\n    <integerValue>3</integerValue>\n    <longValue>4</longValue>\n    <floatValue>5.5</floatValue>\n    <DoubleDribble>6.5</DoubleDribble>\n    <Nested xmlns:xsi=\"https://example.com\" xsi:someName=\"nestedAttrValue\"></Nested>\n</SimpleScalarPropertiesInputOutput>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-304
         let op = crate::operation::simple_scalar_properties::SimpleScalarProperties::new();
         let config = op.config().expect("the operation has config");

Pages: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16