Client Test

rev. b089fac03cba5061dd86d9628e74511b55f01c68 (ignoring whitespace)

Files changed:

tmp-codegen-diff/codegen-client-test/rest_json_extras/rust-client-codegen/src/operation/map_with_enum_key_op.rs

@@ -222,222 +282,284 @@

         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<MapWithEnumKeyOpInput>()
             .ok_or("failed to downcast to MapWithEnumKeyOpInput")?;
-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(())
-235
+    }
-236
+}
-237
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-240
 #[allow(unreachable_code, unused_variables)]

 #[cfg(test)]
 mod map_with_enum_key_op_test {
-244
     /// Test ID: MapWithEnumKeyRequest
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn map_with_enum_key_request_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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-256
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .map_with_enum_key_op()
             .set_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "enumvalue".parse::<crate::types::StringEnum>().expect("static value validated to member"),
                     "something".to_owned(),

↧ Expand context

                 );
                 ret
             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/json")];
         ::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,
             "{\"map\":{\"enumvalue\":\"something\"}}",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
         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(), "/map-with-enum-key", "path was incorrect");
-283
+    }
     /// Test ID: MapWithEnumKeyResponse

tmp-codegen-diff/codegen-client-test/rest_json_extras/rust-client-codegen/src/operation/primitive_int_op.rs

@@ -216,216 +276,278 @@

↥ Expand context

     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<PrimitiveIntOpInput>()
             .ok_or("failed to downcast to PrimitiveIntOpInput")?;
-221
         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(())
-228
+    }
-229
+}
-230
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-233
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]

 mod primitive_int_op_test {
-237
     /// Primitive ints should not be serialized when they are unset
     /// Test ID: SerPrimitiveInt
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn ser_primitive_int_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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-250
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.primitive_int_op().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/json")];
         ::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(

↧ Expand context

             body,
             "{}",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
         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");
-266
+    }
-267
     /// Upper case error modeled lower case
     /// Test ID: ServiceLevelErrorClient
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn service_level_error_client_response() {
         let expected_output = crate::types::error::ExtraError::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("X-Amzn-Errortype", "ExtraError")
                 .status(500)
                 .body(::aws_smithy_types::body::SdkBody::from(""))

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

@@ -241,241 +377,383 @@

↥ Expand context

     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<QueryPrecedenceInput>()
             .ok_or("failed to downcast to QueryPrecedenceInput")?;
-246
         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(())
-253
+    }
-254
+}
-255
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-258
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]

 mod query_precedence_test {
-262
     /// Keys and values must be url encoded
     /// Test ID: UrlParamsKeyEncoding
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn url_params_key_encoding_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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-275
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .query_precedence()
             .set_foo(::std::option::Option::Some("&🐱".to_owned()))
             .set_baz(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("hello there".to_owned(), "how's your encoding?".to_owned());
                 ret.insert("a & b & c".to_owned(), "better encode = this".to_owned());
                 ret
             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_query_params = &[
             "bar=%26%F0%9F%90%B1",
             "hello%20there=how%27s%20your%20encoding%3F",
             "a%20%26%20b%20%26%20c=better%20encode%20%3D%20this",
         ];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_query_string(&http_request, expected_query_params));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &::bytes::Bytes::new());
         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(), "/Precedence", "path was incorrect");
-302
+    }
-303
     /// Prefer named query parameters when serializing
     /// Test ID: RestJsonQueryPrecedenceForbid
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_query_precedence_forbid_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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-316
         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());
                 ret
             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_query_params = &["bar=named", "qux=alsoFromMap"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_query_string(&http_request, expected_query_params));
         let forbid_params = &["bar=fromMap"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::forbid_query_params(&http_request, forbid_params));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &::bytes::Bytes::new());
         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(), "/Precedence", "path was incorrect");
-341
+    }
-342
     /// Prefer named query parameters when serializing
     /// Test ID: RestJsonQueryPrecedence
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-355
         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());

↧ Expand context

                 ret
             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_query_params = &["bar=named", "qux=alsoFromMap"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_query_string(&http_request, expected_query_params));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &::bytes::Bytes::new());
         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(), "/Precedence", "path was incorrect");
-378
+    }
-379
     /// Upper case error modeled lower case
     /// Test ID: ServiceLevelErrorClient
     #[::tokio::test]
     #[::tracing_test::traced_test]

tmp-codegen-diff/codegen-client-test/rest_json_extras/rust-client-codegen/src/operation/string_payload.rs

@@ -217,217 +277,279 @@

↥ Expand context

         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<StringPayloadInput>()
             .ok_or("failed to downcast to StringPayloadInput")?;
-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(())
-230
+    }
-231
+}
-232
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-235
 #[allow(unreachable_code, unused_variables)]

 #[cfg(test)]
 mod string_payload_test {
-239
     /// Test ID: StringPayload
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn string_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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-251
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .string_payload()
             .set_payload(::std::option::Option::Some("rawstring".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();

↧ Expand context

         let expected_headers = [("Content-Type", "text/plain")];
         ::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,
             "rawstring",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
         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(), "/StringPayload", "path was incorrect");
-271
+    }
-272
     /// Upper case error modeled lower case
     /// Test ID: ServiceLevelErrorClient
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn service_level_error_client_response() {
         let expected_output = crate::types::error::ExtraError::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(

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

@@ -366,366 +425,443 @@

↥ Expand context

     ///     fn resolve_auth_scheme<'a>(
     ///         &'a self,
     ///         _params: &'a rest_xml::config::auth::Params,
     ///         _cfg: &'a ConfigBag,
     ///         _runtime_components: &'a RuntimeComponents,
     ///     ) -> AuthSchemeOptionsFuture<'a> {
     ///         // --snip--
     /// #      todo!()
     ///     }
     /// }
     ///
     /// let config = rest_xml::Config::builder()
     ///     .auth_scheme_resolver(CustomAuthSchemeResolver)
     ///     // other configurations
     ///     .build();
     /// ```
     pub fn auth_scheme_resolver(mut self, auth_scheme_resolver: impl crate::config::auth::ResolveAuthScheme + 'static) -> Self {
         self.set_auth_scheme_resolver(auth_scheme_resolver);
         self
-385
+    }

-386
     /// Set the auth scheme resolver for the builder
     ///
     /// # Examples
     /// See an example for [`Self::auth_scheme_resolver`].
     pub fn set_auth_scheme_resolver(&mut self, auth_scheme_resolver: impl crate::config::auth::ResolveAuthScheme + 'static) -> &mut Self {
         self.runtime_components
             .set_auth_scheme_option_resolver(::std::option::Option::Some(auth_scheme_resolver.into_shared_resolver()));
         self
-395
+    }
-+
     /// Enable no authentication regardless of what authentication mechanisms operations support
     ///
     /// This adds [NoAuthScheme](aws_smithy_runtime::client::auth::no_auth::NoAuthScheme) as a fallback
     /// and the auth scheme resolver will use it when no other auth schemes are applicable.
     pub fn allow_no_auth(mut self) -> Self {
         self.set_allow_no_auth();
         self
-+
+    }
-+
     /// Enable no authentication regardless of what authentication mechanisms operations support
     ///
     /// This adds [NoAuthScheme](aws_smithy_runtime::client::auth::no_auth::NoAuthScheme) as a fallback
     /// and the auth scheme resolver will use it when no other auth schemes are applicable.
     pub fn set_allow_no_auth(&mut self) -> &mut Self {
         self.push_runtime_plugin(::aws_smithy_runtime::client::auth::no_auth::NoAuthRuntimePluginV2::new().into_shared());
         self
-+
+    }
     /// Set the auth scheme preference for an auth scheme resolver
     /// (typically the default auth scheme resolver).
     ///
     /// Each operation has a predefined order of auth schemes, as determined by the service,
     /// for auth scheme resolution. By using the auth scheme preference, customers
     /// can reorder the schemes resolved by the auth scheme resolver.
     ///
     /// The preference list is intended as a hint rather than a strict override.
     /// Any schemes not present in the originally resolved auth schemes will be ignored.
     ///

↧ Expand context

     /// # Examples
     ///
     /// ```no_run
     /// # use aws_smithy_runtime_api::client::auth::AuthSchemeId;
     /// let config = rest_xml::Config::builder()
     ///     .auth_scheme_preference([AuthSchemeId::from("scheme1"), AuthSchemeId::from("scheme2")])
     ///     // ...
     ///     .build();
     /// let client = rest_xml::Client::from_conf(config);
     /// ```
-434
     pub fn auth_scheme_preference(
         mut self,
         preference: impl ::std::convert::Into<::aws_smithy_runtime_api::client::auth::AuthSchemePreference>,
     ) -> Self {
         self.set_auth_scheme_preference(::std::option::Option::Some(preference.into()));
         self
-441
+    }
-442
     /// Set the auth scheme preference for an auth scheme resolver

@@ -1214,1232 +1273,1292 @@

↥ Expand context

-1232
+    }
-1233
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         ::std::borrow::Cow::Borrowed(&self.components)
-1239
+    }
-1240
+}
-1241
 pub use ::aws_smithy_runtime::client::identity::IdentityCache;
 pub use ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponents;
 pub use ::aws_smithy_types::config_bag::ConfigBag;
-1245
 pub use ::aws_smithy_async::rt::sleep::Sleep;
-1247
 pub(crate) fn base_client_runtime_plugins(mut config: crate::Config) -> ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins {
     let mut configured_plugins = ::std::vec::Vec::new();
     ::std::mem::swap(&mut config.runtime_plugins, &mut configured_plugins);
     #[cfg(feature = "behavior-version-latest")]

-1252
+    {
         if config.behavior_version.is_none() {
             config.behavior_version = Some(::aws_smithy_runtime_api::client::behavior_version::BehaviorVersion::latest());
-1255
+        }
-1256
+    }
-1257
     let default_retry_partition = "restxmlprotocol";
-1259
     let scope = "rest_xml";
-1261
     #[allow(deprecated)]
                     let mut plugins = ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins::new()
                         // defaults
                         .with_client_plugins(::aws_smithy_runtime::client::defaults::default_plugins(
                             ::aws_smithy_runtime::client::defaults::DefaultPluginParams::new()
                                 .with_retry_partition_name(default_retry_partition)
                                 .with_behavior_version(config.behavior_version.expect("Invalid client configuration: A behavior major version must be set when sending a request or constructing a client. You must set it during client construction or by enabling the `behavior-version-latest` cargo feature."))
                         ))
                         // user config
                         .with_client_plugin(
                             ::aws_smithy_runtime_api::client::runtime_plugin::StaticRuntimePlugin::new()

↧ Expand context

                                 .with_config(config.config.clone())
                                 .with_runtime_components(config.runtime_components.clone())
-1275
+                        )
                         // codegen config
                         .with_client_plugin(crate::config::ServiceRuntimePlugin::new(config.clone()))
                         .with_client_plugin(::aws_smithy_runtime::client::auth::no_auth::NoAuthRuntimePlugin::new())
                         .with_client_plugin(
                             ::aws_smithy_runtime::client::metrics::MetricsRuntimePlugin::builder()
                                 .with_scope(scope)
                                 .with_time_source(config.runtime_components.time_source().unwrap_or_default())
                                 .build()
                                 .expect("All required fields have been set")
                         );
-1286
     for plugin in configured_plugins {
         plugins = plugins.with_client_plugin(plugin);
-1289
+    }
     plugins
-1291
+}
-1292

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/config/auth.rs

@@ -71,71 +148,130 @@

↥ Expand context

         let operation_name = params.operation_name();
-72
         let modeled_auth_options = match self.operation_overrides.get(operation_name) {
             Some(overrides) => overrides,
             None => &self.service_defaults,
         };
-77
         let _fut = ::aws_smithy_runtime_api::client::auth::AuthSchemeOptionsFuture::ready(Ok(modeled_auth_options.clone()));
-79
         _fut
-81
+    }
-82
+}
-83
 /// Configuration parameters for resolving the correct auth scheme
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct Params {
     operation_name: ::std::borrow::Cow<'static, str>,
-88
+}
 impl Params {
     /// Create a builder for [`Params`]

     pub fn builder() -> crate::config::auth::ParamsBuilder {
         crate::config::auth::ParamsBuilder::default()
-93
+    }
-94
     /// Return the operation name for [`Params`]
     pub fn operation_name(&self) -> &str {
         self.operation_name.as_ref()
-98
+    }
-99
+}
-100
 #[cfg(test)]
 #[derive(Debug)]
 pub(crate) struct NoAuthSchemeResolver;
--
 #[cfg(test)]
 impl ResolveAuthScheme for NoAuthSchemeResolver {
     fn resolve_auth_scheme<'a>(
         &'a self,
         _params: &'a crate::config::auth::Params,
         _cfg: &'a ::aws_smithy_types::config_bag::ConfigBag,
         _runtime_components: &'a ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponents,
     ) -> ::aws_smithy_runtime_api::client::auth::AuthSchemeOptionsFuture<'a> {
         ::aws_smithy_runtime_api::client::auth::AuthSchemeOptionsFuture::ready(::std::result::Result::Ok(vec![
             ::aws_smithy_runtime_api::client::auth::AuthSchemeOption::from(::aws_smithy_runtime::client::auth::no_auth::NO_AUTH_SCHEME_ID),
         ]))
--
+    }
--
+}
--
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 /// Builder for [`Params`]
 pub struct ParamsBuilder {
     operation_name: ::std::option::Option<::std::borrow::Cow<'static, str>>,
-105
+}
 impl ParamsBuilder {
     /// Set the operation name for the builder
     pub fn operation_name(self, operation_name: impl Into<::std::borrow::Cow<'static, str>>) -> Self {
         self.set_operation_name(::std::option::Option::Some(operation_name.into()))
-110
+    }

↧ Expand context

-111
     /// Set the operation name for the builder
     pub fn set_operation_name(mut self, operation_name: ::std::option::Option<::std::borrow::Cow<'static, str>>) -> Self {
         self.operation_name = operation_name;
         self
-116
+    }
     /// Consume this builder, create [`Params`]."
     ///
     /// Return [`BuildError`] if any of the required fields are unset.
     ///
     pub fn build(self) -> ::std::result::Result<crate::config::auth::Params, crate::config::auth::BuildError> {
         ::std::result::Result::Ok(crate::config::auth::Params {
             operation_name: self.operation_name.ok_or_else(|| BuildError::missing("operation_name"))?,
         })
-125
+    }
-126
+}
-127
 /// An error that occurred while constructing `config::auth::Params`
 #[derive(Debug)]
 pub struct BuildError {

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

@@ -381,381 +441,443 @@

↥ Expand context

     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<AllQueryStringTypesInput>()
             .ok_or("failed to downcast to AllQueryStringTypesInput")?;
-386
         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(())
-393
+    }
-394
+}
-395
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-398
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]

 mod all_query_string_types_test {
-402
     /// Serializes query string parameters with all supported types
     /// Test ID: AllQueryStringTypes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn all_query_string_types_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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-415
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .all_query_string_types()
             .set_query_string(::std::option::Option::Some("Hello there".to_owned()))
             .set_query_string_list(::std::option::Option::Some(vec!["a".to_owned(), "b".to_owned(), "c".to_owned()]))
             .set_query_string_set(::std::option::Option::Some(vec!["a".to_owned(), "b".to_owned(), "c".to_owned()]))
             .set_query_byte(::std::option::Option::Some(1))
             .set_query_short(::std::option::Option::Some(2))

↧ Expand context

             .set_query_integer(::std::option::Option::Some(3))
             .set_query_integer_list(::std::option::Option::Some(vec![1, 2, 3]))
             .set_query_integer_set(::std::option::Option::Some(vec![1, 2, 3]))
             .set_query_long(::std::option::Option::Some(4))
             .set_query_float(::std::option::Option::Some(1.1_f32))
             .set_query_double(::std::option::Option::Some(1.1_f64))
             .set_query_double_list(::std::option::Option::Some(vec![1.1_f64, 2.1_f64, 3.1_f64]))
             .set_query_boolean(::std::option::Option::Some(true))
             .set_query_boolean_list(::std::option::Option::Some(vec![true, false, true]))
             .set_query_timestamp(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(1, 0_f64)))
             .set_query_timestamp_list(::std::option::Option::Some(vec![
                 ::aws_smithy_types::DateTime::from_fractional_secs(1, 0_f64),
                 ::aws_smithy_types::DateTime::from_fractional_secs(2, 0_f64),
                 ::aws_smithy_types::DateTime::from_fractional_secs(3, 0_f64),
             ]))
             .set_query_enum(::std::option::Option::Some(
                 "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             ))
             .set_query_enum_list(::std::option::Option::Some(vec![
                 "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),

@@ -477,479 +702,716 @@

↥ Expand context

             "BooleanList=true",
             "Timestamp=1970-01-01T00%3A00%3A01Z",
             "TimestampList=1970-01-01T00%3A00%3A01Z",
             "TimestampList=1970-01-01T00%3A00%3A02Z",
             "TimestampList=1970-01-01T00%3A00%3A03Z",
             "Enum=Foo",
             "EnumList=Foo",
             "EnumList=Baz",
             "EnumList=Bar",
             "IntegerEnum=1",
             "IntegerEnumList=1",
             "IntegerEnumList=2",
         ];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_query_string(&http_request, expected_query_params));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &::bytes::Bytes::new());
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/AllQueryStringTypesInput", "path was incorrect");

-499
+    }
-500
     /// Handles query string maps
     /// Test ID: RestXmlQueryStringMap
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_xml_query_string_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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-513
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .all_query_string_types()
             .set_query_params_map_of_strings(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("QueryParamsStringKeyA".to_owned(), "Foo".to_owned());
                 ret.insert("QueryParamsStringKeyB".to_owned(), "Bar".to_owned());
                 ret
             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_query_params = &["QueryParamsStringKeyA=Foo", "QueryParamsStringKeyB=Bar"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_query_string(&http_request, expected_query_params));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &::bytes::Bytes::new());
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/AllQueryStringTypesInput", "path was incorrect");
-535
+    }
-536
     /// Handles escaping all required characters in the query string.
     /// Test ID: RestXmlQueryStringEscaping
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_xml_query_string_escaping_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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-549
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .all_query_string_types()
             .set_query_string(::std::option::Option::Some(" %:/?#[]@!$&'()*+,;=😹".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_query_params = &["String=%20%25%3A%2F%3F%23%5B%5D%40%21%24%26%27%28%29%2A%2B%2C%3B%3D%F0%9F%98%B9"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_query_string(&http_request, expected_query_params));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &::bytes::Bytes::new());
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/AllQueryStringTypesInput", "path was incorrect");
-566
+    }
-567
     /// Supports handling NaN float query values.
     /// Test ID: RestXmlSupportsNaNFloatQueryValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_xml_supports_na_n_float_query_values_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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-580
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .all_query_string_types()
             .set_query_float(::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number"),
             ))
             .set_query_double(::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number"),
             ))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_query_params = &["Float=NaN", "Double=NaN"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_query_string(&http_request, expected_query_params));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &::bytes::Bytes::new());
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/AllQueryStringTypesInput", "path was incorrect");
-602
+    }
-603
     /// Supports handling Infinity float query values.
     /// Test ID: RestXmlSupportsInfinityFloatQueryValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_xml_supports_infinity_float_query_values_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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-616
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .all_query_string_types()
             .set_query_float(::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number"),
             ))
             .set_query_double(::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number"),
             ))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_query_params = &["Float=Infinity", "Double=Infinity"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_query_string(&http_request, expected_query_params));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &::bytes::Bytes::new());
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/AllQueryStringTypesInput", "path was incorrect");
-638
+    }
-639
     /// Supports handling -Infinity float query values.
     /// Test ID: RestXmlSupportsNegativeInfinityFloatQueryValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_xml_supports_negative_infinity_float_query_values_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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-652
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .all_query_string_types()
             .set_query_float(::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number"),
             ))
             .set_query_double(::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number"),
             ))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_query_params = &["Float=-Infinity", "Double=-Infinity"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_query_string(&http_request, expected_query_params));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &::bytes::Bytes::new());
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/AllQueryStringTypesInput", "path was incorrect");
-674
+    }
-675
     /// Query values of 0 and false are serialized
     /// Test ID: RestXmlZeroAndFalseQueryValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_xml_zero_and_false_query_values_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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-688
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .all_query_string_types()
             .set_query_integer(::std::option::Option::Some(0))
             .set_query_boolean(::std::option::Option::Some(false))
             .send()
             .await;
         let _ = dbg!(result);

↧ Expand context

         let http_request = request_receiver.expect_request();
         let expected_query_params = &["Integer=0", "Boolean=false"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_query_string(&http_request, expected_query_params));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &::bytes::Bytes::new());
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/AllQueryStringTypesInput", "path was incorrect");
-706
+    }
-707
+}
-708
 /// Error type for the `AllQueryStringTypesError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum AllQueryStringTypesError {
     /// 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()`:
-716
+     \

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

@@ -216,216 +276,278 @@

↥ Expand context

     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<BodyWithXmlNameInput>()
             .ok_or("failed to downcast to BodyWithXmlNameInput")?;
-221
         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(())
-228
+    }
-229
+}
-230
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-233
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]

 mod body_with_xml_name_test {
-237
     /// Serializes a payload using a wrapper name based on the xmlName
     /// Test ID: BodyWithXmlName
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn body_with_xml_name_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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-250
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .body_with_xml_name()
             .set_nested(::std::option::Option::Some(
                 crate::types::PayloadWithXmlName::builder()
                     .set_name(::std::option::Option::Some("Phreddy".to_owned()))
                     .build(),
             ))

↧ Expand context

             .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 required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_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,
             "<Ahoy><nested><name>Phreddy</name></nested></Ahoy>",
             ::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(), "/BodyWithXmlName", "path was incorrect");
-276
+    }
-277
     /// Serializes a payload using a wrapper name based on the xmlName

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

@@ -239,239 +330,334 @@

↥ Expand context

     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<ConstantAndVariableQueryStringInput>()
             .ok_or("failed to downcast to ConstantAndVariableQueryStringInput")?;
-244
         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(())
-251
+    }
-252
+}
-253
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-256
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]

 mod constant_and_variable_query_string_test {
-260
     /// Mixes constant and variable query string parameters
     /// Test ID: ConstantAndVariableQueryStringMissingOneValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn constant_and_variable_query_string_missing_one_value_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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-273
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .constant_and_variable_query_string()
             .set_baz(::std::option::Option::Some("bam".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_query_params = &["foo=bar", "baz=bam"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_query_string(&http_request, expected_query_params));
         let forbid_params = &["maybeSet"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::forbid_query_params(&http_request, forbid_params));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &::bytes::Bytes::new());
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/ConstantAndVariableQueryString", "path was incorrect");
-292
+    }
-293
     /// Mixes constant and variable query string parameters
     /// Test ID: ConstantAndVariableQueryStringAllValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn constant_and_variable_query_string_all_values_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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-306
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .constant_and_variable_query_string()
             .set_baz(::std::option::Option::Some("bam".to_owned()))
             .set_maybe_set(::std::option::Option::Some("yes".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);

↧ Expand context

         let http_request = request_receiver.expect_request();
         let expected_query_params = &["foo=bar", "baz=bam", "maybeSet=yes"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_query_string(&http_request, expected_query_params));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &::bytes::Bytes::new());
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/ConstantAndVariableQueryString", "path was incorrect");
-324
+    }
-325
+}
-326
 /// Error type for the `ConstantAndVariableQueryStringError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum ConstantAndVariableQueryStringError {
     /// 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()`:
-334
+     \

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

@@ -239,239 +299,301 @@

↥ Expand context

     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<ConstantQueryStringInput>()
             .ok_or("failed to downcast to ConstantQueryStringInput")?;
-244
         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(())
-251
+    }
-252
+}
-253
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-256
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]

 mod constant_query_string_test {
-260
     /// Includes constant query string parameters
     /// Test ID: ConstantQueryString
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn constant_query_string_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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-273
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .constant_query_string()
             .set_hello(::std::option::Option::Some("hi".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();

↧ Expand context

         let expected_query_params = &["foo=bar", "hello"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_query_string(&http_request, expected_query_params));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &::bytes::Bytes::new());
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/ConstantQueryString/hi", "path was incorrect");
-290
+    }
-291
+}
-292
 /// Error type for the `ConstantQueryStringError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum ConstantQueryStringError {
     /// 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()`:
-300
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`

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

@@ -218,218 +278,280 @@

↥ Expand context

     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<EmptyInputAndEmptyOutputInput>()
             .ok_or("failed to downcast to EmptyInputAndEmptyOutputInput")?;
-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(())
-230
+    }
-231
+}
-232
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-235
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]

 mod empty_input_and_empty_output_test {
-239
     /// Empty input serializes no payload
     /// Test ID: EmptyInputAndEmptyOutput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn empty_input_and_empty_output_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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-252
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.empty_input_and_empty_output().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &::bytes::Bytes::new());
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

↧ Expand context

         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/EmptyInputAndEmptyOutput", "path was incorrect");
-263
+    }
-264
     /// Empty output serializes no payload
     /// Test ID: EmptyInputAndEmptyOutput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn empty_input_and_empty_output_response() {
         let expected_output = crate::operation::empty_input_and_empty_output::EmptyInputAndEmptyOutputOutput::builder().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(""))
                 .unwrap(),
-276
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-280

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

@@ -224,224 +284,286 @@

↥ Expand context

         let endpoint_prefix = ::aws_smithy_runtime_api::client::endpoint::EndpointPrefix::new("foo.").map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint prefix could not be built", err)
         })?;
         cfg.interceptor_state().store_put(endpoint_prefix);
-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(())
-235
+    }
-236
+}
-237
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-240
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod endpoint_operation_test {

-244
     /// Operations can prepend to the given host if they define the
     /// endpoint trait.
     /// Test ID: RestXmlEndpointTrait
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_xml_endpoint_trait_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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-258
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.endpoint_operation().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &::bytes::Bytes::new());
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

↧ Expand context

         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/EndpointOperation", "path was incorrect");
         ::pretty_assertions::assert_eq!(uri.host().expect("host should be set"), "foo.example.com");
-270
+    }
-271
+}
-272
 /// Error type for the `EndpointOperationError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum EndpointOperationError {
     /// 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()`:
-280
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-282
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-EndpointOperationError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-285
+}
 impl EndpointOperationError {

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

@@ -246,246 +306,308 @@

↥ Expand context

         cfg.interceptor_state().store_put(endpoint_prefix);
-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(())
-254
+    }
-255
+}
-256
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-259
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod endpoint_with_host_label_header_operation_test {
-263
     /// Operations can prepend to the given host if they define the
     /// endpoint trait, and can use the host label trait to define

     /// further customization based on user input. The label must also
     /// be serialized in into any other location it is bound to, such
     /// as the body or in this case an http header.
     /// Test ID: RestXmlEndpointTraitWithHostLabelAndHttpBinding
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_xml_endpoint_trait_with_host_label_and_http_binding_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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-280
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .endpoint_with_host_label_header_operation()
             .set_account_id(::std::option::Option::Some("bar".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();

↧ Expand context

         let expected_headers = [("X-Amz-Account-Id", "bar")];
         ::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");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &::bytes::Bytes::new());
         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(), "/EndpointWithHostLabelHeaderOperation", "path was incorrect");
         ::pretty_assertions::assert_eq!(uri.host().expect("host should be set"), "bar.example.com");
-298
+    }
-299
+}
-300
 /// Error type for the `EndpointWithHostLabelHeaderOperationError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum EndpointWithHostLabelHeaderOperationError {
     /// 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()`:
-308
+     \

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

@@ -244,244 +304,306 @@

↥ Expand context

-244
+        }
         .map_err(|err| ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint prefix could not be built", err))?;
         cfg.interceptor_state().store_put(endpoint_prefix);
-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(())
-254
+    }
-255
+}
-256
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-259
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod endpoint_with_host_label_operation_test {
-263

     /// Operations can prepend to the given host if they define the
     /// endpoint trait, and can use the host label trait to define
     /// further customization based on user input.
     /// Test ID: RestXmlEndpointTraitWithHostLabel
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_xml_endpoint_trait_with_host_label_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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-278
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .endpoint_with_host_label_operation()
             .set_label(::std::option::Option::Some("bar".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();

↧ Expand context

         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "<EndpointWithHostLabelOperationRequest>\n    <label>bar</label>\n</EndpointWithHostLabelOperationRequest>\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(), "/EndpointWithHostLabelOperation", "path was incorrect");
         ::pretty_assertions::assert_eq!(uri.host().expect("host should be set"), "foo.bar.example.com");
-297
+    }
-298
+}
-299
 /// Error type for the `EndpointWithHostLabelOperationError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum EndpointWithHostLabelOperationError {
     /// 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()`:

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

@@ -216,216 +276,278 @@

↥ Expand context

     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<FlattenedXmlMapInput>()
             .ok_or("failed to downcast to FlattenedXmlMapInput")?;
-221
         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(())
-228
+    }
-229
+}
-230
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-233
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]

 mod flattened_xml_map_test {
-237
     /// Serializes flattened XML maps in requests
     /// Test ID: FlattenedXmlMap
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn flattened_xml_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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-250
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .flattened_xml_map()
             .set_my_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "foo".to_owned(),
                     "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),

↧ Expand context

                 );
                 ret.insert(
                     "baz".to_owned(),
                     "Baz".parse::<crate::types::FooEnum>().expect("static value validated to member"),
                 );
                 ret
             }))
             .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, "<FlattenedXmlMapRequest>\n    <myMap>\n        <key>foo</key>\n        <value>Foo</value>\n    </myMap>\n    <myMap>\n        <key>baz</key>\n        <value>Baz</value>\n    </myMap>\n</FlattenedXmlMapRequest>", ::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(), "/FlattenedXmlMap", "path was incorrect");

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

@@ -224,224 +284,286 @@

↥ Expand context

     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<FlattenedXmlMapWithXmlNameInput>()
             .ok_or("failed to downcast to FlattenedXmlMapWithXmlNameInput")?;
-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(())
-236
+    }
-237
+}
-238
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-241
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]

 mod flattened_xml_map_with_xml_name_test {
-245
     /// Serializes flattened XML maps in requests that have xmlName on members
     /// Test ID: FlattenedXmlMapWithXmlName
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn flattened_xml_map_with_xml_name_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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-258
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .flattened_xml_map_with_xml_name()
             .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

↧ Expand context

             }))
             .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, "<FlattenedXmlMapWithXmlNameRequest>\n    <KVP>\n        <K>a</K>\n        <V>A</V>\n    </KVP>\n    <KVP>\n        <K>b</K>\n        <V>B</V>\n    </KVP>\n</FlattenedXmlMapWithXmlNameRequest>", ::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(), "/FlattenedXmlMapWithXmlName", "path was incorrect");
-281
+    }
-282
     /// Serializes flattened XML maps in responses that have xmlName on members
     /// Test ID: FlattenedXmlMapWithXmlName
     #[::tokio::test]
     #[::tracing_test::traced_test]

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