Client Test

rev. b089fac03cba5061dd86d9628e74511b55f01c68

Files changed:

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

@@ -229,229 +474,484 @@

         let _input = context
             .input()
             .downcast_ref::<SimpleScalarPropertiesInput>()
             .ok_or("failed to downcast to SimpleScalarPropertiesInput")?;
-233
         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(())
-240
+    }
-241
+}
-242
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-245
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod simple_scalar_properties_test {

     use ::aws_smithy_protocol_test::FloatEquals;
-250
     /// Serializes simple scalar properties
     /// Test ID: RpcV2CborSimpleScalarProperties
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_simple_scalar_properties_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // 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");
-263
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .simple_scalar_properties()
             .set_byte_value(::std::option::Option::Some(5))
             .set_double_value(::std::option::Option::Some(1.889_f64))
             .set_false_boolean_value(::std::option::Option::Some(false))
             .set_float_value(::std::option::Option::Some(7.625_f32))
             .set_integer_value(::std::option::Option::Some(256))
             .set_long_value(::std::option::Option::Some(9873))
             .set_short_value(::std::option::Option::Some(9898))
             .set_string_value(::std::option::Option::Some("simple".to_owned()))
             .set_true_boolean_value(::std::option::Option::Some(true))
             .set_blob_value(::std::option::Option::Some(::aws_smithy_types::Blob::new("foo")))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Accept", "application/cbor"),
             ("Content-Type", "application/cbor"),
             ("smithy-protocol", "rpc-v2-cbor"),
         ];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(
         ::aws_smithy_protocol_test::validate_body(body, "v2lieXRlVmFsdWUFa2RvdWJsZVZhbHVl+z/+OVgQYk3TcWZhbHNlQm9vbGVhblZhbHVl9GpmbG9hdFZhbHVl+kD0AABsaW50ZWdlclZhbHVlGQEAaWxvbmdWYWx1ZRkmkWpzaG9ydFZhbHVlGSaqa3N0cmluZ1ZhbHVlZnNpbXBsZXB0cnVlQm9vbGVhblZhbHVl9WlibG9iVmFsdWVDZm9v/w==", ::aws_smithy_protocol_test::MediaType::from("application/cbor"))
         );
         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(),
             "/service/RpcV2Protocol/operation/SimpleScalarProperties",
             "path was incorrect"
         );
-300
+    }
-301
     /// RpcV2 Cbor should not serialize null structure values
     /// Test ID: RpcV2CborClientDoesntSerializeNullStructureValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_client_doesnt_serialize_null_structure_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");
-314
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .simple_scalar_properties()
             .set_string_value(::std::option::Option::None)
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Accept", "application/cbor"),
             ("Content-Type", "application/cbor"),
             ("smithy-protocol", "rpc-v2-cbor"),
         ];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "v/8=",
             ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
         ));
         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(),
             "/service/RpcV2Protocol/operation/SimpleScalarProperties",
             "path was incorrect"
         );
-344
+    }
-345
     /// Supports handling NaN float values.
     /// Test ID: RpcV2CborSupportsNaNFloatInputs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_supports_na_n_float_inputs_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");
-358
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .simple_scalar_properties()
             .set_double_value(::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number"),
             ))
             .set_float_value(::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number"),
             ))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Accept", "application/cbor"),
             ("Content-Type", "application/cbor"),
             ("smithy-protocol", "rpc-v2-cbor"),
         ];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "v2tkb3VibGVWYWx1Zft/+AAAAAAAAGpmbG9hdFZhbHVl+n/AAAD/",
             ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
         ));
         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(),
             "/service/RpcV2Protocol/operation/SimpleScalarProperties",
             "path was incorrect"
         );
-393
+    }
-394
     /// Supports handling Infinity float values.
     /// Test ID: RpcV2CborSupportsInfinityFloatInputs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_supports_infinity_float_inputs_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");
-407
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .simple_scalar_properties()
             .set_double_value(::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number"),
             ))
             .set_float_value(::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number"),
             ))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Accept", "application/cbor"),
             ("Content-Type", "application/cbor"),
             ("smithy-protocol", "rpc-v2-cbor"),
         ];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "v2tkb3VibGVWYWx1Zft/8AAAAAAAAGpmbG9hdFZhbHVl+n+AAAD/",
             ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
         ));
         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(),
             "/service/RpcV2Protocol/operation/SimpleScalarProperties",
             "path was incorrect"
         );
-442
+    }
-443
     /// Supports handling Infinity float values.
     /// Test ID: RpcV2CborSupportsNegativeInfinityFloatInputs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_supports_negative_infinity_float_inputs_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");
-456
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .simple_scalar_properties()
             .set_double_value(::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number"),
             ))
             .set_float_value(::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number"),

↧ Expand context

             ))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Accept", "application/cbor"),
             ("Content-Type", "application/cbor"),
             ("smithy-protocol", "rpc-v2-cbor"),
         ];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "v2tkb3VibGVWYWx1Zfv/8AAAAAAAAGpmbG9hdFZhbHVl+v+AAAD/",
             ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/sparse_nulls_operation.rs

@@ -228,228 +330,334 @@

↥ Expand context

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

 mod sparse_nulls_operation_test {
-249
     /// Serializes null values in maps
     /// Test ID: RpcV2CborSparseMapsSerializeNullValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_sparse_maps_serialize_null_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");
-262
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .sparse_nulls_operation()
             .set_sparse_string_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("foo".to_owned(), ::std::option::Option::None);
                 ret
             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Accept", "application/cbor"),
             ("Content-Type", "application/cbor"),
             ("smithy-protocol", "rpc-v2-cbor"),
         ];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "v29zcGFyc2VTdHJpbmdNYXC/Y2Zvb/b//w==",
             ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
         ));
         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(), "/service/RpcV2Protocol/operation/SparseNullsOperation", "path was incorrect");
-292
+    }
-293
     /// Serializes null values in lists
     /// Test ID: RpcV2CborSparseListsSerializeNull
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_sparse_lists_serialize_null_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
             .sparse_nulls_operation()
             .set_sparse_string_list(::std::option::Option::Some(vec![::std::option::Option::None]))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();

↧ Expand context

         let expected_headers = [
             ("Accept", "application/cbor"),
             ("Content-Type", "application/cbor"),
             ("smithy-protocol", "rpc-v2-cbor"),
         ];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "v3BzcGFyc2VTdHJpbmdMaXN0n/b//w==",
             ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
         ));
         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(), "/service/RpcV2Protocol/operation/SparseNullsOperation", "path was incorrect");
-332
+    }
-333
     /// Deserializes null values in maps

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

@@ -350,350 +409,427 @@

↥ Expand context

     ///     fn resolve_auth_scheme<'a>(
     ///         &'a self,
     ///         _params: &'a rpcv2cbor_extras::config::auth::Params,
     ///         _cfg: &'a ConfigBag,
     ///         _runtime_components: &'a RuntimeComponents,
     ///     ) -> AuthSchemeOptionsFuture<'a> {
     ///         // --snip--
     /// #      todo!()
     ///     }
     /// }
     ///
     /// let config = rpcv2cbor_extras::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
+    }
-+
     /// Enable no authentication regardless of what authentication mechanisms operations support
     ///
     /// This adds [NoAuthScheme](aws_smithy_runtime::client::auth::no_auth::NoAuthScheme) as a fallback
     /// and the auth scheme resolver will use it when no other auth schemes are applicable.
     pub fn allow_no_auth(mut self) -> Self {
         self.set_allow_no_auth();
         self
-+
+    }
-+
     /// Enable no authentication regardless of what authentication mechanisms operations support
     ///
     /// This adds [NoAuthScheme](aws_smithy_runtime::client::auth::no_auth::NoAuthScheme) as a fallback
     /// and the auth scheme resolver will use it when no other auth schemes are applicable.
     pub fn set_allow_no_auth(&mut self) -> &mut Self {
         self.push_runtime_plugin(::aws_smithy_runtime::client::auth::no_auth::NoAuthRuntimePluginV2::new().into_shared());
         self
-+
+    }
     /// Set the auth scheme preference for an auth scheme resolver
     /// (typically the default auth scheme resolver).
     ///
     /// Each operation has a predefined order of auth schemes, as determined by the service,
     /// for auth scheme resolution. By using the auth scheme preference, customers
     /// can reorder the schemes resolved by the auth scheme resolver.
     ///
     /// The preference list is intended as a hint rather than a strict override.
     /// Any schemes not present in the originally resolved auth schemes will be ignored.
     ///

↧ Expand context

     /// # Examples
     ///
     /// ```no_run
     /// # use aws_smithy_runtime_api::client::auth::AuthSchemeId;
     /// let config = rpcv2cbor_extras::Config::builder()
     ///     .auth_scheme_preference([AuthSchemeId::from("scheme1"), AuthSchemeId::from("scheme2")])
     ///     // ...
     ///     .build();
     /// let client = rpcv2cbor_extras::Client::from_conf(config);
     /// ```
-418
     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
-425
+    }
-426
     /// Set the auth scheme preference for an auth scheme resolver

@@ -1199,1217 +1259,1278 @@

↥ Expand context

-1217
+    }
-1218
     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)
-1224
+    }
-1225
+}
-1226
 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;
-1230
 pub use ::aws_smithy_async::rt::sleep::Sleep;
-1232
 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")]

-1237
+    {
         if config.behavior_version.is_none() {
             config.behavior_version = Some(::aws_smithy_runtime_api::client::behavior_version::BehaviorVersion::latest());
-1240
+        }
-1241
+    }
-1242
     let default_retry_partition = "rpcv2cborservice";
-1244
     let scope = "rpcv2cbor_extras";
-1246
     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())
-1260
+                        )
                         // 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")
                         );
-1271
     for plugin in configured_plugins {
         plugins = plugins.with_client_plugin(plugin);
-1274
+    }
     plugins
-1276
+}
-1277
 pub use ::aws_smithy_types::config_bag::FrozenLayer;

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

@@ -350,350 +409,427 @@

↥ Expand context

     ///     fn resolve_auth_scheme<'a>(
     ///         &'a self,
     ///         _params: &'a rpcv2cbor_non_query_compatible::config::auth::Params,
     ///         _cfg: &'a ConfigBag,
     ///         _runtime_components: &'a RuntimeComponents,
     ///     ) -> AuthSchemeOptionsFuture<'a> {
     ///         // --snip--
     /// #      todo!()
     ///     }
     /// }
     ///
     /// let config = rpcv2cbor_non_query_compatible::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
+    }
-+
     /// Enable no authentication regardless of what authentication mechanisms operations support
     ///
     /// This adds [NoAuthScheme](aws_smithy_runtime::client::auth::no_auth::NoAuthScheme) as a fallback
     /// and the auth scheme resolver will use it when no other auth schemes are applicable.
     pub fn allow_no_auth(mut self) -> Self {
         self.set_allow_no_auth();
         self
-+
+    }
-+
     /// Enable no authentication regardless of what authentication mechanisms operations support
     ///
     /// This adds [NoAuthScheme](aws_smithy_runtime::client::auth::no_auth::NoAuthScheme) as a fallback
     /// and the auth scheme resolver will use it when no other auth schemes are applicable.
     pub fn set_allow_no_auth(&mut self) -> &mut Self {
         self.push_runtime_plugin(::aws_smithy_runtime::client::auth::no_auth::NoAuthRuntimePluginV2::new().into_shared());
         self
-+
+    }
     /// Set the auth scheme preference for an auth scheme resolver
     /// (typically the default auth scheme resolver).
     ///
     /// Each operation has a predefined order of auth schemes, as determined by the service,
     /// for auth scheme resolution. By using the auth scheme preference, customers
     /// can reorder the schemes resolved by the auth scheme resolver.
     ///
     /// The preference list is intended as a hint rather than a strict override.
     /// Any schemes not present in the originally resolved auth schemes will be ignored.
     ///

↧ Expand context

     /// # Examples
     ///
     /// ```no_run
     /// # use aws_smithy_runtime_api::client::auth::AuthSchemeId;
     /// let config = rpcv2cbor_non_query_compatible::Config::builder()
     ///     .auth_scheme_preference([AuthSchemeId::from("scheme1"), AuthSchemeId::from("scheme2")])
     ///     // ...
     ///     .build();
     /// let client = rpcv2cbor_non_query_compatible::Client::from_conf(config);
     /// ```
-418
     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
-425
+    }
-426
     /// Set the auth scheme preference for an auth scheme resolver

@@ -1199,1217 +1259,1278 @@

↥ Expand context

-1217
+    }
-1218
     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)
-1224
+    }
-1225
+}
-1226
 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;
-1230
 pub use ::aws_smithy_async::rt::sleep::Sleep;
-1232
 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")]

-1237
+    {
         if config.behavior_version.is_none() {
             config.behavior_version = Some(::aws_smithy_runtime_api::client::behavior_version::BehaviorVersion::latest());
-1240
+        }
-1241
+    }
-1242
     let default_retry_partition = "nonquerycompatiblerpcv2protocol";
-1244
     let scope = "rpcv2cbor_non_query_compatible";
-1246
     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())
-1260
+                        )
                         // 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")
                         );
-1271
     for plugin in configured_plugins {
         plugins = plugins.with_client_plugin(plugin);
-1274
+    }
     plugins
-1276
+}
-1277
 pub use ::aws_smithy_types::config_bag::FrozenLayer;

tmp-codegen-diff/codegen-client-test/rpcv2cbor_non_query_compatible/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/rpcv2cbor_non_query_compatible/rust-client-codegen/src/operation/non_query_compatible_operation.rs

@@ -226,226 +286,288 @@

↥ Expand context

     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<NonQueryCompatibleOperationInput>()
             .ok_or("failed to downcast to NonQueryCompatibleOperationInput")?;
-231
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-238
+    }
-239
+}
-240
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-243
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]

 mod non_query_compatible_operation_test {
-247
     /// The query mode header MUST NOT be set on non-query-compatible services.
     /// Test ID: NonQueryCompatibleRpcV2CborForbidsQueryModeHeader
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn non_query_compatible_rpc_v2_cbor_forbids_query_mode_header_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");
-260
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.non_query_compatible_operation().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Accept", "application/cbor"), ("smithy-protocol", "rpc-v2-cbor")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let forbidden_headers = &["x-amzn-query-mode"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::forbid_headers(http_request.headers(), forbidden_headers));

↧ Expand context

         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &::bytes::Bytes::new());
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(
             uri.path(),
             "/service/NonQueryCompatibleRpcV2Protocol/operation/NonQueryCompatibleOperation",
             "path was incorrect"
         );
-279
+    }
-280
+}
-281
 /// Error type for the `NonQueryCompatibleOperationError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum NonQueryCompatibleOperationError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
     variable wildcard pattern and check `.code()`:

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

@@ -350,350 +409,427 @@

↥ Expand context

     ///     fn resolve_auth_scheme<'a>(
     ///         &'a self,
     ///         _params: &'a rpcv2cbor_query_compatible::config::auth::Params,
     ///         _cfg: &'a ConfigBag,
     ///         _runtime_components: &'a RuntimeComponents,
     ///     ) -> AuthSchemeOptionsFuture<'a> {
     ///         // --snip--
     /// #      todo!()
     ///     }
     /// }
     ///
     /// let config = rpcv2cbor_query_compatible::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
+    }
-+
     /// Enable no authentication regardless of what authentication mechanisms operations support
     ///
     /// This adds [NoAuthScheme](aws_smithy_runtime::client::auth::no_auth::NoAuthScheme) as a fallback
     /// and the auth scheme resolver will use it when no other auth schemes are applicable.
     pub fn allow_no_auth(mut self) -> Self {
         self.set_allow_no_auth();
         self
-+
+    }
-+
     /// Enable no authentication regardless of what authentication mechanisms operations support
     ///
     /// This adds [NoAuthScheme](aws_smithy_runtime::client::auth::no_auth::NoAuthScheme) as a fallback
     /// and the auth scheme resolver will use it when no other auth schemes are applicable.
     pub fn set_allow_no_auth(&mut self) -> &mut Self {
         self.push_runtime_plugin(::aws_smithy_runtime::client::auth::no_auth::NoAuthRuntimePluginV2::new().into_shared());
         self
-+
+    }
     /// Set the auth scheme preference for an auth scheme resolver
     /// (typically the default auth scheme resolver).
     ///
     /// Each operation has a predefined order of auth schemes, as determined by the service,
     /// for auth scheme resolution. By using the auth scheme preference, customers
     /// can reorder the schemes resolved by the auth scheme resolver.
     ///
     /// The preference list is intended as a hint rather than a strict override.
     /// Any schemes not present in the originally resolved auth schemes will be ignored.
     ///

↧ Expand context

     /// # Examples
     ///
     /// ```no_run
     /// # use aws_smithy_runtime_api::client::auth::AuthSchemeId;
     /// let config = rpcv2cbor_query_compatible::Config::builder()
     ///     .auth_scheme_preference([AuthSchemeId::from("scheme1"), AuthSchemeId::from("scheme2")])
     ///     // ...
     ///     .build();
     /// let client = rpcv2cbor_query_compatible::Client::from_conf(config);
     /// ```
-418
     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
-425
+    }
-426
     /// Set the auth scheme preference for an auth scheme resolver

@@ -1199,1217 +1259,1278 @@

↥ Expand context

-1217
+    }
-1218
     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)
-1224
+    }
-1225
+}
-1226
 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;
-1230
 pub use ::aws_smithy_async::rt::sleep::Sleep;
-1232
 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")]

-1237
+    {
         if config.behavior_version.is_none() {
             config.behavior_version = Some(::aws_smithy_runtime_api::client::behavior_version::BehaviorVersion::latest());
-1240
+        }
-1241
+    }
-1242
     let default_retry_partition = "querycompatiblerpcv2protocol";
-1244
     let scope = "rpcv2cbor_query_compatible";
-1246
     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())
-1260
+                        )
                         // 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")
                         );
-1271
     for plugin in configured_plugins {
         plugins = plugins.with_client_plugin(plugin);
-1274
+    }
     plugins
-1276
+}
-1277
 pub use ::aws_smithy_types::config_bag::FrozenLayer;

tmp-codegen-diff/codegen-client-test/rpcv2cbor_query_compatible/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/rpcv2cbor_query_compatible/rust-client-codegen/src/operation/query_compatible_operation.rs

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

↥ Expand context

     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<QueryCompatibleOperationInput>()
             .ok_or("failed to downcast to QueryCompatibleOperationInput")?;
-229
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-236
+    }
-237
+}
-238
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-241
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]

 mod query_compatible_operation_test {
-245
     /// Clients for query-compatible services MUST send the x-amzn-query-mode header.
     /// Test ID: QueryCompatibleRpcV2CborSendsQueryModeHeader
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn query_compatible_rpc_v2_cbor_sends_query_mode_header_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-258
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.query_compatible_operation().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Accept", "application/cbor"),
             ("smithy-protocol", "rpc-v2-cbor"),
             ("x-amzn-query-mode", "true"),

↧ Expand context

         ];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let forbidden_headers = &["Content-Type", "X-Amz-Target"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::forbid_headers(http_request.headers(), forbidden_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &::bytes::Bytes::new());
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(
             uri.path(),
             "/service/QueryCompatibleRpcV2Protocol/operation/QueryCompatibleOperation",
             "path was incorrect"
         );
-281
+    }
-282
     /// Parses simple RpcV2 CBOR errors with no query error code
     /// Test ID: QueryCompatibleRpcV2CborNoCustomCodeError
     #[::tokio::test]
     #[::tracing_test::traced_test]

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

@@ -350,350 +409,427 @@

↥ Expand context

     ///     fn resolve_auth_scheme<'a>(
     ///         &'a self,
     ///         _params: &'a simple::config::auth::Params,
     ///         _cfg: &'a ConfigBag,
     ///         _runtime_components: &'a RuntimeComponents,
     ///     ) -> AuthSchemeOptionsFuture<'a> {
     ///         // --snip--
     /// #      todo!()
     ///     }
     /// }
     ///
     /// let config = simple::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
+    }
-+
     /// Enable no authentication regardless of what authentication mechanisms operations support
     ///
     /// This adds [NoAuthScheme](aws_smithy_runtime::client::auth::no_auth::NoAuthScheme) as a fallback
     /// and the auth scheme resolver will use it when no other auth schemes are applicable.
     pub fn allow_no_auth(mut self) -> Self {
         self.set_allow_no_auth();
         self
-+
+    }
-+
     /// Enable no authentication regardless of what authentication mechanisms operations support
     ///
     /// This adds [NoAuthScheme](aws_smithy_runtime::client::auth::no_auth::NoAuthScheme) as a fallback
     /// and the auth scheme resolver will use it when no other auth schemes are applicable.
     pub fn set_allow_no_auth(&mut self) -> &mut Self {
         self.push_runtime_plugin(::aws_smithy_runtime::client::auth::no_auth::NoAuthRuntimePluginV2::new().into_shared());
         self
-+
+    }
     /// Set the auth scheme preference for an auth scheme resolver
     /// (typically the default auth scheme resolver).
     ///
     /// Each operation has a predefined order of auth schemes, as determined by the service,
     /// for auth scheme resolution. By using the auth scheme preference, customers
     /// can reorder the schemes resolved by the auth scheme resolver.
     ///
     /// The preference list is intended as a hint rather than a strict override.
     /// Any schemes not present in the originally resolved auth schemes will be ignored.
     ///

↧ Expand context

     /// # Examples
     ///
     /// ```no_run
     /// # use aws_smithy_runtime_api::client::auth::AuthSchemeId;
     /// let config = simple::Config::builder()
     ///     .auth_scheme_preference([AuthSchemeId::from("scheme1"), AuthSchemeId::from("scheme2")])
     ///     // ...
     ///     .build();
     /// let client = simple::Client::from_conf(config);
     /// ```
-418
     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
-425
+    }
-426
     /// Set the auth scheme preference for an auth scheme resolver

@@ -1196,1214 +1256,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 = "simpleservice";
-1241
     let scope = "simple";
-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;

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