Client Test

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

@@ -221,221 +282,284 @@

-221
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-223
+    }
-224
+}
 #[derive(Debug)]
 struct QueryParamsAsStringListMapEndpointParamsInterceptor;
-227
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for QueryParamsAsStringListMapEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "QueryParamsAsStringListMapEndpointParamsInterceptor"
-231
+    }
-232
     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::<QueryParamsAsStringListMapInput>()
             .ok_or("failed to downcast to QueryParamsAsStringListMapInput")?;
-247
         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(())
-256
+    }
-257
+}
-258
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-261
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod query_params_as_string_list_map_test {

↧ Expand context

-265
     /// Serialize query params from map of list strings
     /// Test ID: RestXmlQueryParamsStringListMap
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_xml_query_params_string_list_map_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-276
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .query_params_as_string_list_map()
             .set_qux(::std::option::Option::Some("named".to_owned()))
             .set_foo(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("baz".to_owned(), vec!["bar".to_owned(), "qux".to_owned()]);
                 ret

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

@@ -213,213 +274,276 @@

↥ Expand context

-213
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-215
+    }
-216
+}
 #[derive(Debug)]
 struct QueryPrecedenceEndpointParamsInterceptor;
-219
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for QueryPrecedenceEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "QueryPrecedenceEndpointParamsInterceptor"
-223
+    }
-224
     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::<QueryPrecedenceInput>()
             .ok_or("failed to downcast to QueryPrecedenceInput")?;
-239
         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(())
-248
+    }
-249
+}
-250
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-253
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod query_precedence_test {

↧ Expand context

-257
     /// Prefer named query parameters when serializing
     /// Test ID: RestXmlQueryPrecedence
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_xml_query_precedence_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-268
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .query_precedence()
             .set_foo(::std::option::Option::Some("named".to_owned()))
             .set_baz(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("bar".to_owned(), "fromMap".to_owned());
                 ret.insert("qux".to_owned(), "alsoFromMap".to_owned());

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

@@ -194,194 +255,257 @@

↥ Expand context

-194
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-196
+    }
-197
+}
 #[derive(Debug)]
 struct RecursiveShapesEndpointParamsInterceptor;
-200
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for RecursiveShapesEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "RecursiveShapesEndpointParamsInterceptor"
-204
+    }
-205
     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::<RecursiveShapesInput>()
             .ok_or("failed to downcast to RecursiveShapesInput")?;
-220
         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
+}
-231
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-234
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod recursive_shapes_test {

↧ Expand context

-238
     /// Serializes recursive structures
     /// Test ID: RecursiveShapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn recursive_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-249
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .recursive_shapes()
             .set_nested(::std::option::Option::Some(
                 crate::types::RecursiveShapesInputOutputNested1::builder()
                     .set_foo(::std::option::Option::Some("Foo1".to_owned()))
                     .set_nested(::std::option::Option::Some(::std::boxed::Box::new(
                         crate::types::RecursiveShapesInputOutputNested2::builder()

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

@@ -203,203 +264,266 @@

↥ Expand context

-203
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-205
+    }
-206
+}
 #[derive(Debug)]
 struct SimpleScalarPropertiesEndpointParamsInterceptor;
-209
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for SimpleScalarPropertiesEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "SimpleScalarPropertiesEndpointParamsInterceptor"
-213
+    }
-214
     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")?;
-229
         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(())
-238
+    }
-239
+}
-240
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-243
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod simple_scalar_properties_test {

↧ Expand context

     use ::aws_smithy_protocol_test::FloatEquals;
-248
     /// Serializes simple scalar properties
     /// Test ID: SimpleScalarProperties
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn simple_scalar_properties_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-259
         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))

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

@@ -197,197 +258,260 @@

↥ Expand context

-197
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-199
+    }
-200
+}
 #[derive(Debug)]
 struct TimestampFormatHeadersEndpointParamsInterceptor;
-203
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for TimestampFormatHeadersEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "TimestampFormatHeadersEndpointParamsInterceptor"
-207
+    }
-208
     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::<TimestampFormatHeadersInput>()
             .ok_or("failed to downcast to TimestampFormatHeadersInput")?;
-223
         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(())
-232
+    }
-233
+}
-234
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-237
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod timestamp_format_headers_test {

↧ Expand context

-241
     /// Tests how timestamp request headers are serialized
     /// Test ID: TimestampFormatHeaders
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn timestamp_format_headers_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-252
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .timestamp_format_headers()
             .set_member_epoch_seconds(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1576540098, 0_f64,
             )))
             .set_member_http_date(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1576540098, 0_f64,

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

@@ -194,194 +255,257 @@

↥ Expand context

-194
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-196
+    }
-197
+}
 #[derive(Debug)]
 struct XmlAttributesEndpointParamsInterceptor;
-200
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for XmlAttributesEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "XmlAttributesEndpointParamsInterceptor"
-204
+    }
-205
     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::<XmlAttributesInput>()
             .ok_or("failed to downcast to XmlAttributesInput")?;
-220
         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
+}
-231
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-234
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod xml_attributes_test {

↧ Expand context

-238
     /// Serializes XML attributes on the synthesized document
     /// Test ID: XmlAttributes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_attributes_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-249
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .xml_attributes()
             .set_foo(::std::option::Option::Some("hi".to_owned()))
             .set_attr(::std::option::Option::Some("test".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);

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

@@ -202,202 +263,265 @@

↥ Expand context

-202
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-204
+    }
-205
+}
 #[derive(Debug)]
 struct XmlAttributesOnPayloadEndpointParamsInterceptor;
-208
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for XmlAttributesOnPayloadEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "XmlAttributesOnPayloadEndpointParamsInterceptor"
-212
+    }
-213
     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::<XmlAttributesOnPayloadInput>()
             .ok_or("failed to downcast to XmlAttributesOnPayloadInput")?;
-228
         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(())
-237
+    }
-238
+}
-239
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-242
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod xml_attributes_on_payload_test {

↧ Expand context

-246
     /// Serializes XML attributes on the synthesized document
     /// Test ID: XmlAttributesOnPayload
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_attributes_on_payload_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-257
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .xml_attributes_on_payload()
             .set_payload(::std::option::Option::Some(
                 crate::types::XmlAttributesPayloadRequest::builder()
                     .set_foo(::std::option::Option::Some("hi".to_owned()))
                     .set_attr(::std::option::Option::Some("test".to_owned()))
                     .build(),

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

@@ -188,188 +249,251 @@

↥ Expand context

-188
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-190
+    }
-191
+}
 #[derive(Debug)]
 struct XmlBlobsEndpointParamsInterceptor;
-194
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for XmlBlobsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "XmlBlobsEndpointParamsInterceptor"
-198
+    }
-199
     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::<XmlBlobsInput>()
             .ok_or("failed to downcast to XmlBlobsInput")?;
-214
         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(())
-223
+    }
-224
+}
-225
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-228
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod xml_blobs_test {

↧ Expand context

-232
     /// Blobs are base64 encoded
     /// Test ID: XmlBlobs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_blobs_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-243
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .xml_blobs()
             .set_data(::std::option::Option::Some(::aws_smithy_types::Blob::new("value")))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();

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

@@ -194,194 +255,257 @@

↥ Expand context

-194
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-196
+    }
-197
+}
 #[derive(Debug)]
 struct XmlEmptyBlobsEndpointParamsInterceptor;
-200
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for XmlEmptyBlobsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "XmlEmptyBlobsEndpointParamsInterceptor"
-204
+    }
-205
     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::<XmlEmptyBlobsInput>()
             .ok_or("failed to downcast to XmlEmptyBlobsInput")?;
-220
         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
+}
-231
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-234
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod xml_empty_blobs_test {

↧ Expand context

-238
     /// Empty blobs are deserialized as empty string
     /// Test ID: XmlEmptyBlobs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_empty_blobs_response() {
         let expected_output = crate::operation::xml_empty_blobs::XmlEmptyBlobsOutput::builder()
             .set_data(::std::option::Option::Some(::aws_smithy_types::Blob::new("")))
             .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(
                     "<XmlEmptyBlobsResponse>\n    <data></data>\n</XmlEmptyBlobsResponse>\n",
                 ))
                 .unwrap(),
-255
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;

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

@@ -194,194 +255,257 @@

↥ Expand context

-194
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-196
+    }
-197
+}
 #[derive(Debug)]
 struct XmlEmptyListsEndpointParamsInterceptor;
-200
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for XmlEmptyListsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "XmlEmptyListsEndpointParamsInterceptor"
-204
+    }
-205
     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::<XmlEmptyListsInput>()
             .ok_or("failed to downcast to XmlEmptyListsInput")?;
-220
         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
+}
-231
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-234
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod xml_empty_lists_test {

↧ Expand context

-238
     /// Serializes Empty XML lists
     /// Test ID: XmlEmptyLists
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_empty_lists_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-249
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .xml_empty_lists()
             .set_string_list(::std::option::Option::Some(vec![]))
             .set_string_set(::std::option::Option::Some(vec![]))
             .send()
             .await;
         let _ = dbg!(result);

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

@@ -194,194 +255,257 @@

↥ Expand context

-194
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-196
+    }
-197
+}
 #[derive(Debug)]
 struct XmlEmptyMapsEndpointParamsInterceptor;
-200
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for XmlEmptyMapsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "XmlEmptyMapsEndpointParamsInterceptor"
-204
+    }
-205
     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::<XmlEmptyMapsInput>()
             .ok_or("failed to downcast to XmlEmptyMapsInput")?;
-220
         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
+}
-231
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-234
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod xml_empty_maps_test {

↧ Expand context

-238
     /// Serializes Empty XML maps
     /// Test ID: XmlEmptyMaps
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_empty_maps_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-249
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .xml_empty_maps()
             .set_my_map(::std::option::Option::Some(::std::collections::HashMap::new()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();

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

@@ -194,194 +255,257 @@

↥ Expand context

-194
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-196
+    }
-197
+}
 #[derive(Debug)]
 struct XmlEmptyStringsEndpointParamsInterceptor;
-200
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for XmlEmptyStringsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "XmlEmptyStringsEndpointParamsInterceptor"
-204
+    }
-205
     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::<XmlEmptyStringsInput>()
             .ok_or("failed to downcast to XmlEmptyStringsInput")?;
-220
         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
+}
-231
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-234
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod xml_empty_strings_test {

↧ Expand context

-238
     /// Serializes xml empty strings
     /// Test ID: XmlEmptyStrings
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_empty_strings_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-249
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .xml_empty_strings()
             .set_empty_string(::std::option::Option::Some("".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();

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

@@ -188,188 +249,251 @@

↥ Expand context

-188
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-190
+    }
-191
+}
 #[derive(Debug)]
 struct XmlEnumsEndpointParamsInterceptor;
-194
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for XmlEnumsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "XmlEnumsEndpointParamsInterceptor"
-198
+    }
-199
     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::<XmlEnumsInput>()
             .ok_or("failed to downcast to XmlEnumsInput")?;
-214
         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(())
-223
+    }
-224
+}
-225
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-228
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod xml_enums_test {

↧ Expand context

-232
     /// Serializes simple scalar properties
     /// Test ID: XmlEnums
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_enums_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-243
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .xml_enums()
             .set_foo_enum1(::std::option::Option::Some(
                 "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             ))
             .set_foo_enum2(::std::option::Option::Some(
                 "0".parse::<crate::types::FooEnum>().expect("static value validated to member"),

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

@@ -194,194 +255,257 @@

↥ Expand context

-194
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-196
+    }
-197
+}
 #[derive(Debug)]
 struct XmlIntEnumsEndpointParamsInterceptor;
-200
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for XmlIntEnumsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "XmlIntEnumsEndpointParamsInterceptor"
-204
+    }
-205
     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::<XmlIntEnumsInput>()
             .ok_or("failed to downcast to XmlIntEnumsInput")?;
-220
         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
+}
-231
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-234
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod xml_int_enums_test {

↧ Expand context

-238
     /// Serializes simple scalar properties
     /// Test ID: XmlIntEnums
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_int_enums_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-249
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .xml_int_enums()
             .set_int_enum1(::std::option::Option::Some(1))
             .set_int_enum2(::std::option::Option::Some(2))
             .set_int_enum3(::std::option::Option::Some(3))
             .set_int_enum_list(::std::option::Option::Some(vec![1, 2]))
             .set_int_enum_set(::std::option::Option::Some(vec![1, 2]))

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

@@ -188,188 +249,251 @@

↥ Expand context

-188
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-190
+    }
-191
+}
 #[derive(Debug)]
 struct XmlListsEndpointParamsInterceptor;
-194
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for XmlListsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "XmlListsEndpointParamsInterceptor"
-198
+    }
-199
     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::<XmlListsInput>()
             .ok_or("failed to downcast to XmlListsInput")?;
-214
         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(())
-223
+    }
-224
+}
-225
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-228
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod xml_lists_test {

↧ Expand context

-232
     /// Tests for XML list serialization
     /// Test ID: XmlLists
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_lists_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-243
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .xml_lists()
             .set_string_list(::std::option::Option::Some(vec!["foo".to_owned(), "bar".to_owned()]))
             .set_string_set(::std::option::Option::Some(vec!["foo".to_owned(), "bar".to_owned()]))
             .set_integer_list(::std::option::Option::Some(vec![1, 2]))
             .set_boolean_list(::std::option::Option::Some(vec![true, false]))
             .set_timestamp_list(::std::option::Option::Some(vec![

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

@@ -202,202 +263,265 @@

↥ Expand context

-202
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-204
+    }
-205
+}
 #[derive(Debug)]
 struct XmlMapWithXmlNamespaceEndpointParamsInterceptor;
-208
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for XmlMapWithXmlNamespaceEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "XmlMapWithXmlNamespaceEndpointParamsInterceptor"
-212
+    }
-213
     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::<XmlMapWithXmlNamespaceInput>()
             .ok_or("failed to downcast to XmlMapWithXmlNamespaceInput")?;
-228
         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(())
-237
+    }
-238
+}
-239
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-242
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod xml_map_with_xml_namespace_test {

↧ Expand context

-246
     /// Serializes XML maps in requests that have xmlNamespace and xmlName on members
     /// Test ID: RestXmlXmlMapWithXmlNamespace
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_xml_xml_map_with_xml_namespace_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-257
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .xml_map_with_xml_namespace()
             .set_my_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("a".to_owned(), "A".to_owned());
                 ret.insert("b".to_owned(), "B".to_owned());
                 ret

Client Test

Files changed: