Client Test

rev. 26e0a1e8aaec58e3c7fd18a79449d71bcadaf391

Files changed:

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

@@ -350,350 +409,425 @@

     ///     fn resolve_auth_scheme<'a>(
     ///         &'a self,
     ///         _params: &'a naming_test_casing::config::auth::Params,
     ///         _cfg: &'a ConfigBag,
     ///         _runtime_components: &'a RuntimeComponents,
     ///     ) -> AuthSchemeOptionsFuture<'a> {
     ///         // --snip--
     /// #      todo!()
     ///     }
     /// }
     ///
     /// let config = naming_test_casing::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
-369
+    }

-370
     /// 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
-379
+    }
-+
     /// Add [NoAuthScheme](aws_smithy_runtime::client::auth::no_auth::NoAuthScheme) as a fallback for operations that don't require authentication
     ///
     /// The auth scheme resolver will use this when no other auth schemes are applicable.
     pub fn allow_no_auth(mut self) -> Self {
         self.set_allow_no_auth();
         self
-+
+    }
-+
     /// Add [NoAuthScheme](aws_smithy_runtime::client::auth::no_auth::NoAuthScheme) as a fallback for operations that don't require authentication
     ///
     /// The auth scheme resolver will use this 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 = naming_test_casing::Config::builder()
     ///     .auth_scheme_preference([AuthSchemeId::from("scheme1"), AuthSchemeId::from("scheme2")])
     ///     // ...
     ///     .build();
     /// let client = naming_test_casing::Client::from_conf(config);
     /// ```
-416
     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
-423
+    }
-424
     /// Set the auth scheme preference for an auth scheme resolver

@@ -1198,1214 +1258,1275 @@

↥ Expand context

-1214
+    }
-1215
     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)
-1221
+    }
-1222
+}
-1223
 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;
-1227
 pub use ::aws_smithy_async::rt::sleep::Sleep;
-1229
 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")]

-1234
+    {
         if config.behavior_version.is_none() {
             config.behavior_version = Some(::aws_smithy_runtime_api::client::behavior_version::BehaviorVersion::latest());
-1237
+        }
-1238
+    }
-1239
     let default_retry_partition = "acronyminside_service";
-1241
     let scope = "naming_test_casing";
-1243
     let mut plugins = ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins::new()
     #[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()
                                 .with_config(config.config.clone())

↧ Expand context

                                 .with_runtime_components(config.runtime_components.clone())
-1257
+                        )
                         // 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")
                         );
-1268
     for plugin in configured_plugins {
         plugins = plugins.with_client_plugin(plugin);
-1271
+    }
     plugins
-1273
+}
-1274
 pub use ::aws_smithy_types::config_bag::FrozenLayer;

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

@@ -350,350 +409,425 @@

↥ Expand context

     ///     fn resolve_auth_scheme<'a>(
     ///         &'a self,
     ///         _params: &'a naming_test_ops::config::auth::Params,
     ///         _cfg: &'a ConfigBag,
     ///         _runtime_components: &'a RuntimeComponents,
     ///     ) -> AuthSchemeOptionsFuture<'a> {
     ///         // --snip--
     /// #      todo!()
     ///     }
     /// }
     ///
     /// let config = naming_test_ops::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
-369
+    }

-370
     /// 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
-379
+    }
-+
     /// Add [NoAuthScheme](aws_smithy_runtime::client::auth::no_auth::NoAuthScheme) as a fallback for operations that don't require authentication
     ///
     /// The auth scheme resolver will use this when no other auth schemes are applicable.
     pub fn allow_no_auth(mut self) -> Self {
         self.set_allow_no_auth();
         self
-+
+    }
-+
     /// Add [NoAuthScheme](aws_smithy_runtime::client::auth::no_auth::NoAuthScheme) as a fallback for operations that don't require authentication
     ///
     /// The auth scheme resolver will use this 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 = naming_test_ops::Config::builder()
     ///     .auth_scheme_preference([AuthSchemeId::from("scheme1"), AuthSchemeId::from("scheme2")])
     ///     // ...
     ///     .build();
     /// let client = naming_test_ops::Client::from_conf(config);
     /// ```
-416
     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
-423
+    }
-424
     /// Set the auth scheme preference for an auth scheme resolver

@@ -1198,1214 +1258,1275 @@

↥ Expand context

-1214
+    }
-1215
     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)
-1221
+    }
-1222
+}
-1223
 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;
-1227
 pub use ::aws_smithy_async::rt::sleep::Sleep;
-1229
 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")]

-1234
+    {
         if config.behavior_version.is_none() {
             config.behavior_version = Some(::aws_smithy_runtime_api::client::behavior_version::BehaviorVersion::latest());
-1237
+        }
-1238
+    }
-1239
     let default_retry_partition = "config";
-1241
     let scope = "naming_test_ops";
-1243
     let mut plugins = ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins::new()
     #[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()
                                 .with_config(config.config.clone())

↧ Expand context

                                 .with_runtime_components(config.runtime_components.clone())
-1257
+                        )
                         // 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")
                         );
-1268
     for plugin in configured_plugins {
         plugins = plugins.with_client_plugin(plugin);
-1271
+    }
     plugins
-1273
+}
-1274
 pub use ::aws_smithy_types::config_bag::FrozenLayer;

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

@@ -73,73 +150,132 @@

↥ Expand context

         let operation_name = params.operation_name();
-74
         let modeled_auth_options = match self.operation_overrides.get(operation_name) {
             Some(overrides) => overrides,
             None => &self.service_defaults,
         };
-79
         let _fut = ::aws_smithy_runtime_api::client::auth::AuthSchemeOptionsFuture::ready(Ok(modeled_auth_options.clone()));
-81
         _fut
-83
+    }
-84
+}
-85
 /// 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>,
-90
+}
 impl Params {
     /// Create a builder for [`Params`]

     pub fn builder() -> crate::config::auth::ParamsBuilder {
         crate::config::auth::ParamsBuilder::default()
-95
+    }
-96
     /// Return the operation name for [`Params`]
     pub fn operation_name(&self) -> &str {
         self.operation_name.as_ref()
-100
+    }
-101
+}
-102
 #[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>>,
-107
+}
 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()))
-112
+    }

↧ Expand context

-113
     /// 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
-118
+    }
     /// 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"))?,
         })
-127
+    }
-128
+}
-129
 /// An error that occurred while constructing `config::auth::Params`
 #[derive(Debug)]
 pub struct BuildError {

tmp-codegen-diff/codegen-client-test/naming_test_ops/rust-client-codegen/src/operation/reserved_words_as_members.rs

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

↥ 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::<ReservedWordsAsMembersInput>()
             .ok_or("failed to downcast to ReservedWordsAsMembersInput")?;
-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 reserved_words_as_members_test {
-244
     /// Test ID: reserved_words
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn reserved_words_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
             .reserved_words_as_members()
             .set_as(::std::option::Option::Some(5))
             .set_async(::std::option::Option::Some(true))
             .send()
             .await;
         let _ = dbg!(result);

↧ Expand context

         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "Config.ReservedWordsAsMembers"),
         ];
         ::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,
             "{\"as\": 5, \"async\": true}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
         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(), "/", "path was incorrect");
-280
+    }
-281
+}
-282
 /// Error type for the `ReservedWordsAsMembersError` operation.
 #[non_exhaustive]

tmp-codegen-diff/codegen-client-test/naming_test_ops/rust-client-codegen/src/operation/structure_name_punning.rs

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

↥ 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::<StructureNamePunningInput>()
             .ok_or("failed to downcast to StructureNamePunningInput")?;
-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 structure_name_punning_test {
-244
     /// Test ID: structure_punning
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn structure_punning_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
             .structure_name_punning()
             .set_regular_string(::std::option::Option::Some("hello!".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();

↧ Expand context

         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "Config.StructureNamePunning"),
         ];
         ::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,
             "{\"regular_string\": \"hello!\"}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
         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(), "/", "path was incorrect");
-279
+    }
-280
+}
-281
 /// Error type for the `StructureNamePunningError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

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

@@ -350,350 +409,425 @@

↥ Expand context

     ///     fn resolve_auth_scheme<'a>(
     ///         &'a self,
     ///         _params: &'a naming_test_structs::config::auth::Params,
     ///         _cfg: &'a ConfigBag,
     ///         _runtime_components: &'a RuntimeComponents,
     ///     ) -> AuthSchemeOptionsFuture<'a> {
     ///         // --snip--
     /// #      todo!()
     ///     }
     /// }
     ///
     /// let config = naming_test_structs::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
-369
+    }

-370
     /// 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
-379
+    }
-+
     /// Add [NoAuthScheme](aws_smithy_runtime::client::auth::no_auth::NoAuthScheme) as a fallback for operations that don't require authentication
     ///
     /// The auth scheme resolver will use this when no other auth schemes are applicable.
     pub fn allow_no_auth(mut self) -> Self {
         self.set_allow_no_auth();
         self
-+
+    }
-+
     /// Add [NoAuthScheme](aws_smithy_runtime::client::auth::no_auth::NoAuthScheme) as a fallback for operations that don't require authentication
     ///
     /// The auth scheme resolver will use this 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 = naming_test_structs::Config::builder()
     ///     .auth_scheme_preference([AuthSchemeId::from("scheme1"), AuthSchemeId::from("scheme2")])
     ///     // ...
     ///     .build();
     /// let client = naming_test_structs::Client::from_conf(config);
     /// ```
-416
     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
-423
+    }
-424
     /// Set the auth scheme preference for an auth scheme resolver

@@ -1198,1214 +1258,1275 @@

↥ Expand context

-1214
+    }
-1215
     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)
-1221
+    }
-1222
+}
-1223
 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;
-1227
 pub use ::aws_smithy_async::rt::sleep::Sleep;
-1229
 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")]

-1234
+    {
         if config.behavior_version.is_none() {
             config.behavior_version = Some(::aws_smithy_runtime_api::client::behavior_version::BehaviorVersion::latest());
-1237
+        }
-1238
+    }
-1239
     let default_retry_partition = "namingobstaclecoursestructs";
-1241
     let scope = "naming_test_structs";
-1243
     let mut plugins = ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins::new()
     #[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()
                                 .with_config(config.config.clone())

↧ Expand context

                                 .with_runtime_components(config.runtime_components.clone())
-1257
+                        )
                         // 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")
                         );
-1268
     for plugin in configured_plugins {
         plugins = plugins.with_client_plugin(plugin);
-1271
+    }
     plugins
-1273
+}
-1274
 pub use ::aws_smithy_types::config_bag::FrozenLayer;

tmp-codegen-diff/codegen-client-test/pokemon-service-awsjson-client/rust-client-codegen/src/config.rs

@@ -350,350 +409,425 @@

↥ Expand context

     ///     fn resolve_auth_scheme<'a>(
     ///         &'a self,
     ///         _params: &'a pokemon_service_awsjson_client::config::auth::Params,
     ///         _cfg: &'a ConfigBag,
     ///         _runtime_components: &'a RuntimeComponents,
     ///     ) -> AuthSchemeOptionsFuture<'a> {
     ///         // --snip--
     /// #      todo!()
     ///     }
     /// }
     ///
     /// let config = pokemon_service_awsjson_client::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
-369
+    }

-370
     /// 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
-379
+    }
-+
     /// Add [NoAuthScheme](aws_smithy_runtime::client::auth::no_auth::NoAuthScheme) as a fallback for operations that don't require authentication
     ///
     /// The auth scheme resolver will use this when no other auth schemes are applicable.
     pub fn allow_no_auth(mut self) -> Self {
         self.set_allow_no_auth();
         self
-+
+    }
-+
     /// Add [NoAuthScheme](aws_smithy_runtime::client::auth::no_auth::NoAuthScheme) as a fallback for operations that don't require authentication
     ///
     /// The auth scheme resolver will use this 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 = pokemon_service_awsjson_client::Config::builder()
     ///     .auth_scheme_preference([AuthSchemeId::from("scheme1"), AuthSchemeId::from("scheme2")])
     ///     // ...
     ///     .build();
     /// let client = pokemon_service_awsjson_client::Client::from_conf(config);
     /// ```
-416
     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
-423
+    }
-424
     /// Set the auth scheme preference for an auth scheme resolver

@@ -1198,1214 +1258,1275 @@

↥ Expand context

-1214
+    }
-1215
     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)
-1221
+    }
-1222
+}
-1223
 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;
-1227
 pub use ::aws_smithy_async::rt::sleep::Sleep;
-1229
 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")]

-1234
+    {
         if config.behavior_version.is_none() {
             config.behavior_version = Some(::aws_smithy_runtime_api::client::behavior_version::BehaviorVersion::latest());
-1237
+        }
-1238
+    }
-1239
     let default_retry_partition = "pokemonservice";
-1241
     let scope = "pokemon-service-awsjson-client";
-1243
     let mut plugins = ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins::new()
     #[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()
                                 .with_config(config.config.clone())

↧ Expand context

                                 .with_runtime_components(config.runtime_components.clone())
-1257
+                        )
                         // 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")
                         );
-1268
     for plugin in configured_plugins {
         plugins = plugins.with_client_plugin(plugin);
-1271
+    }
     plugins
-1273
+}
-1274
 pub use ::aws_smithy_types::config_bag::FrozenLayer;

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

@@ -350,350 +409,425 @@

↥ Expand context

     ///     fn resolve_auth_scheme<'a>(
     ///         &'a self,
     ///         _params: &'a pokemon_service_client::config::auth::Params,
     ///         _cfg: &'a ConfigBag,
     ///         _runtime_components: &'a RuntimeComponents,
     ///     ) -> AuthSchemeOptionsFuture<'a> {
     ///         // --snip--
     /// #      todo!()
     ///     }
     /// }
     ///
     /// let config = pokemon_service_client::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
-369
+    }

-370
     /// 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
-379
+    }
-+
     /// Add [NoAuthScheme](aws_smithy_runtime::client::auth::no_auth::NoAuthScheme) as a fallback for operations that don't require authentication
     ///
     /// The auth scheme resolver will use this when no other auth schemes are applicable.
     pub fn allow_no_auth(mut self) -> Self {
         self.set_allow_no_auth();
         self
-+
+    }
-+
     /// Add [NoAuthScheme](aws_smithy_runtime::client::auth::no_auth::NoAuthScheme) as a fallback for operations that don't require authentication
     ///
     /// The auth scheme resolver will use this 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 = pokemon_service_client::Config::builder()
     ///     .auth_scheme_preference([AuthSchemeId::from("scheme1"), AuthSchemeId::from("scheme2")])
     ///     // ...
     ///     .build();
     /// let client = pokemon_service_client::Client::from_conf(config);
     /// ```
-416
     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
-423
+    }
-424
     /// Set the auth scheme preference for an auth scheme resolver

@@ -1198,1214 +1258,1275 @@

↥ Expand context

-1214
+    }
-1215
     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)
-1221
+    }
-1222
+}
-1223
 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;
-1227
 pub use ::aws_smithy_async::rt::sleep::Sleep;
-1229
 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")]

-1234
+    {
         if config.behavior_version.is_none() {
             config.behavior_version = Some(::aws_smithy_runtime_api::client::behavior_version::BehaviorVersion::latest());
-1237
+        }
-1238
+    }
-1239
     let default_retry_partition = "pokemonservice";
-1241
     let scope = "pokemon-service-client";
-1243
     let mut plugins = ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins::new()
     #[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()
                                 .with_config(config.config.clone())

↧ Expand context

                                 .with_runtime_components(config.runtime_components.clone())
-1257
+                        )
                         // 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")
                         );
-1268
     for plugin in configured_plugins {
         plugins = plugins.with_client_plugin(plugin);
-1271
+    }
     plugins
-1273
+}
-1274
 pub use ::aws_smithy_types::config_bag::FrozenLayer;

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

@@ -350,350 +409,425 @@

↥ Expand context

     ///     fn resolve_auth_scheme<'a>(
     ///         &'a self,
     ///         _params: &'a query_compat_test::config::auth::Params,
     ///         _cfg: &'a ConfigBag,
     ///         _runtime_components: &'a RuntimeComponents,
     ///     ) -> AuthSchemeOptionsFuture<'a> {
     ///         // --snip--
     /// #      todo!()
     ///     }
     /// }
     ///
     /// let config = query_compat_test::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
-369
+    }

-370
     /// 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
-379
+    }
-+
     /// Add [NoAuthScheme](aws_smithy_runtime::client::auth::no_auth::NoAuthScheme) as a fallback for operations that don't require authentication
     ///
     /// The auth scheme resolver will use this when no other auth schemes are applicable.
     pub fn allow_no_auth(mut self) -> Self {
         self.set_allow_no_auth();
         self
-+
+    }
-+
     /// Add [NoAuthScheme](aws_smithy_runtime::client::auth::no_auth::NoAuthScheme) as a fallback for operations that don't require authentication
     ///
     /// The auth scheme resolver will use this 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 = query_compat_test::Config::builder()
     ///     .auth_scheme_preference([AuthSchemeId::from("scheme1"), AuthSchemeId::from("scheme2")])
     ///     // ...
     ///     .build();
     /// let client = query_compat_test::Client::from_conf(config);
     /// ```
-416
     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
-423
+    }
-424
     /// Set the auth scheme preference for an auth scheme resolver

@@ -1198,1214 +1258,1275 @@

↥ Expand context

-1214
+    }
-1215
     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)
-1221
+    }
-1222
+}
-1223
 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;
-1227
 pub use ::aws_smithy_async::rt::sleep::Sleep;
-1229
 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")]

-1234
+    {
         if config.behavior_version.is_none() {
             config.behavior_version = Some(::aws_smithy_runtime_api::client::behavior_version::BehaviorVersion::latest());
-1237
+        }
-1238
+    }
-1239
     let default_retry_partition = "querycompatservice";
-1241
     let scope = "query-compat-test";
-1243
     let mut plugins = ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins::new()
     #[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()
                                 .with_config(config.config.clone())

↧ Expand context

                                 .with_runtime_components(config.runtime_components.clone())
-1257
+                        )
                         // 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")
                         );
-1268
     for plugin in configured_plugins {
         plugins = plugins.with_client_plugin(plugin);
-1271
+    }
     plugins
-1273
+}
-1274
 pub use ::aws_smithy_types::config_bag::FrozenLayer;

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

@@ -73,73 +150,132 @@

↥ Expand context

         let operation_name = params.operation_name();
-74
         let modeled_auth_options = match self.operation_overrides.get(operation_name) {
             Some(overrides) => overrides,
             None => &self.service_defaults,
         };
-79
         let _fut = ::aws_smithy_runtime_api::client::auth::AuthSchemeOptionsFuture::ready(Ok(modeled_auth_options.clone()));
-81
         _fut
-83
+    }
-84
+}
-85
 /// 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>,
-90
+}
 impl Params {
     /// Create a builder for [`Params`]

     pub fn builder() -> crate::config::auth::ParamsBuilder {
         crate::config::auth::ParamsBuilder::default()
-95
+    }
-96
     /// Return the operation name for [`Params`]
     pub fn operation_name(&self) -> &str {
         self.operation_name.as_ref()
-100
+    }
-101
+}
-102
 #[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>>,
-107
+}
 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()))
-112
+    }

↧ Expand context

-113
     /// 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
-118
+    }
     /// 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"))?,
         })
-127
+    }
-128
+}
-129
 /// An error that occurred while constructing `config::auth::Params`
 #[derive(Debug)]
 pub struct BuildError {

tmp-codegen-diff/codegen-client-test/query-compat-test/rust-client-codegen/src/operation/operation.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::<OperationInput>()
             .ok_or("failed to downcast to OperationInput")?;
-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 operation_test {
-239
     /// Test ID: BasicQueryCompatTest
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn basic_query_compat_test_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
             .operation()
             .set_message(::std::option::Option::Some("hello!".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();

↧ Expand context

         let expected_headers = [("x-amz-target", "QueryCompatService.Operation"), ("x-amzn-query-mode", "true")];
         ::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,
             "{\"message\":\"hello!\"}",
             ::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(), "/", "path was incorrect");
-271
+    }
-272
+}
-273
 /// Error type for the `OperationError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum OperationError {
     /// 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 \

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

@@ -366,366 +425,441 @@

↥ Expand context

     ///     fn resolve_auth_scheme<'a>(
     ///         &'a self,
     ///         _params: &'a rest_json::config::auth::Params,
     ///         _cfg: &'a ConfigBag,
     ///         _runtime_components: &'a RuntimeComponents,
     ///     ) -> AuthSchemeOptionsFuture<'a> {
     ///         // --snip--
     /// #      todo!()
     ///     }
     /// }
     ///
     /// let config = rest_json::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
+    }
-+
     /// Add [NoAuthScheme](aws_smithy_runtime::client::auth::no_auth::NoAuthScheme) as a fallback for operations that don't require authentication
     ///
     /// The auth scheme resolver will use this when no other auth schemes are applicable.
     pub fn allow_no_auth(mut self) -> Self {
         self.set_allow_no_auth();
         self
-+
+    }
-+
     /// Add [NoAuthScheme](aws_smithy_runtime::client::auth::no_auth::NoAuthScheme) as a fallback for operations that don't require authentication
     ///
     /// The auth scheme resolver will use this 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_json::Config::builder()
     ///     .auth_scheme_preference([AuthSchemeId::from("scheme1"), AuthSchemeId::from("scheme2")])
     ///     // ...
     ///     .build();
     /// let client = rest_json::Client::from_conf(config);
     /// ```
-432
     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
-439
+    }
-440
     /// Set the auth scheme preference for an auth scheme resolver

@@ -1214,1230 +1274,1291 @@

↥ Expand context

-1230
+    }
-1231
     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)
-1237
+    }
-1238
+}
-1239
 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;
-1243
 pub use ::aws_smithy_async::rt::sleep::Sleep;
-1245
 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")]

-1250
+    {
         if config.behavior_version.is_none() {
             config.behavior_version = Some(::aws_smithy_runtime_api::client::behavior_version::BehaviorVersion::latest());
-1253
+        }
-1254
+    }
-1255
     let default_retry_partition = "restjsonprotocol";
-1257
     let scope = "rest_json";
-1259
     let mut plugins = ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins::new()
     #[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()
                                 .with_config(config.config.clone())

↧ Expand context

                                 .with_runtime_components(config.runtime_components.clone())
-1273
+                        )
                         // 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")
                         );
-1284
     for plugin in configured_plugins {
         plugins = plugins.with_client_plugin(plugin);
-1287
+    }
     plugins
-1289
+}
-1290
 pub use ::aws_smithy_types::config_bag::FrozenLayer;

tmp-codegen-diff/codegen-client-test/rest_json/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_json/rust-client-codegen/src/operation/all_query_string_types.rs

@@ -383,383 +443,445 @@

↥ 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")?;
-388
         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(())
-395
+    }
-396
+}
-397
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-400
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]

 mod all_query_string_types_test {
-404
     /// Serializes query string parameters with all supported types
     /// Test ID: RestJsonAllQueryStringTypes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_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");
-417
         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"),

@@ -511,513 +759,773 @@

↥ Expand context

             "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",
             "IntegerEnumList=3",
         ];
         ::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");

-533
+    }
-534
     /// Handles query string maps
     /// Test ID: RestJsonQueryStringMap
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_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");
-547
         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_string_list(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("QueryParamsStringKeyA".to_owned(), vec!["Foo".to_owned()]);
                 ret.insert("QueryParamsStringKeyB".to_owned(), vec!["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");
-569
+    }
-570
     /// Handles escaping all required characters in the query string.
     /// Test ID: RestJsonQueryStringEscaping
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_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");
-583
         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()))
             .set_query_params_map_of_string_list(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("String".to_owned(), vec![" %:/?#[]@!$&'()*+,;=😹".to_owned()]);
                 ret
             }))
             .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");
-605
+    }
-606
     /// Supports handling NaN float query values.
     /// Test ID: RestJsonSupportsNaNFloatQueryValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_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");
-619
         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"),
             ))
             .set_query_params_map_of_string_list(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("Float".to_owned(), vec!["NaN".to_owned()]);
                 ret.insert("Double".to_owned(), vec!["NaN".to_owned()]);
                 ret
             }))
             .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");
-647
+    }
-648
     /// Supports handling Infinity float query values.
     /// Test ID: RestJsonSupportsInfinityFloatQueryValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_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");
-661
         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"),
             ))
             .set_query_params_map_of_string_list(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("Float".to_owned(), vec!["Infinity".to_owned()]);
                 ret.insert("Double".to_owned(), vec!["Infinity".to_owned()]);
                 ret
             }))
             .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");
-689
+    }
-690
     /// Supports handling -Infinity float query values.
     /// Test ID: RestJsonSupportsNegativeInfinityFloatQueryValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_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");
-703
         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"),
             ))
             .set_query_params_map_of_string_list(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("Float".to_owned(), vec!["-Infinity".to_owned()]);
                 ret.insert("Double".to_owned(), vec!["-Infinity".to_owned()]);
                 ret
             }))
             .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");
-731
+    }
-732
     /// Query values of 0 and false are serialized
     /// Test ID: RestJsonZeroAndFalseQueryValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_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");
-745
         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))
             .set_query_params_map_of_string_list(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("Integer".to_owned(), vec!["0".to_owned()]);

↧ Expand context

                 ret.insert("Boolean".to_owned(), vec!["false".to_owned()]);
                 ret
             }))
             .send()
             .await;
         let _ = dbg!(result);
         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");
-769
+    }
-770
+}
-771
 /// Error type for the `AllQueryStringTypesError` operation.
 #[non_exhaustive]

tmp-codegen-diff/codegen-client-test/rest_json/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: RestJsonConstantAndVariableQueryStringMissingOneValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_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: RestJsonConstantAndVariableQueryStringAllValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_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_json/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: RestJsonConstantQueryString
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_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 */ }`

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