Client Test

rev. 26e0a1e8aaec58e3c7fd18a79449d71bcadaf391

Files changed:

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

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

         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/json_rpc11/rust-client-codegen/src/operation/empty_operation.rs

@@ -218,218 +333,339 @@

↥ Expand context

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

 mod empty_operation_test {
-239
     /// Sends requests to /
     /// Test ID: sends_requests_to_slash
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn sends_requests_to_slash_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-252
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.empty_operation().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.EmptyOperation"),
         ];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         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");
-265
+    }
-266
     /// Includes X-Amz-Target header and Content-Type
     /// Test ID: includes_x_amz_target_and_content_type
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn includes_x_amz_target_and_content_type_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");
-279
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.empty_operation().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.EmptyOperation"),
         ];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         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");
-292
+    }
-293
     /// Clients must always send an empty JSON object payload for
     /// operations with no input (that is, `{}`). While AWS service
     /// implementations support requests with no payload or requests
     /// that send `{}`, always sending `{}` from the client is
     /// preferred for forward compatibility in case input is ever
     /// added to an operation.
     /// Test ID: json_1_1_client_sends_empty_payload_for_no_input_shape
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn json_1_1_client_sends_empty_payload_for_no_input_shape_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");
-311
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.empty_operation().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.EmptyOperation"),
         ];

↧ Expand context

         ::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,
             "{}",
             ::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");
-330
+    }
-331
     /// When no output is defined, the service is expected to return
     /// an empty payload, however, client must ignore a JSON payload
     /// if one is returned. This ensures that if output is added later,
     /// then it will not break the client.
     /// Test ID: handles_empty_output_shape
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn handles_empty_output_shape_response() {

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

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

↥ Expand context

         let endpoint_prefix = ::aws_smithy_runtime_api::client::endpoint::EndpointPrefix::new("foo.").map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint prefix could not be built", err)
         })?;
         cfg.interceptor_state().store_put(endpoint_prefix);
-228
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-235
+    }
-236
+}
-237
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-240
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod endpoint_operation_test {

-244
     /// Operations can prepend to the given host if they define the
     /// endpoint trait.
     /// Test ID: AwsJson11EndpointTrait
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_endpoint_trait_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-258
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.endpoint_operation().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.EndpointOperation"),
         ];

↧ Expand context

         ::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,
             "{}",
             ::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");
         ::pretty_assertions::assert_eq!(uri.host().expect("host should be set"), "foo.example.com");
-278
+    }
-279
+}
-280
 /// Error type for the `EndpointOperationError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum EndpointOperationError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \

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

@@ -249,249 +309,311 @@

↥ Expand context

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

     /// Operations can prepend to the given host if they define the
     /// endpoint trait, and can use the host label trait to define
     /// further customization based on user input.
     /// Test ID: AwsJson11EndpointTraitWithHostLabel
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_endpoint_trait_with_host_label_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-283
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .endpoint_with_host_label_operation()
             .set_label(::std::option::Option::Some("bar".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();

↧ Expand context

         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.EndpointWithHostLabelOperation"),
         ];
         ::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,
             "{\"label\": \"bar\"}",
             ::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");
         ::pretty_assertions::assert_eq!(uri.host().expect("host should be set"), "foo.bar.example.com");
-307
+    }
-308
+}
-309
 /// Error type for the `EndpointWithHostLabelOperationError` operation.
 #[non_exhaustive]

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/operation/host_with_path_operation.rs

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

↥ Expand context

     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<HostWithPathOperationInput>()
             .ok_or("failed to downcast to HostWithPathOperationInput")?;
-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 host_with_path_operation_test {
-247
     /// Custom endpoints supplied by users can have paths
     /// Test ID: AwsJson11HostWithPath
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_host_with_path_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/custom");
-260
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.host_with_path_operation().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.HostWithPathOperation"),
         ];

↧ Expand context

         ::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,
             "{}",
             ::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(), "/custom/", "path was incorrect");
-279
+    }
-280
+}
-281
 /// Error type for the `HostWithPathOperationError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum HostWithPathOperationError {
     /// 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/json_rpc11/rust-client-codegen/src/operation/json_enums.rs

@@ -219,219 +337,341 @@

↥ Expand context

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

 mod json_enums_test {
-240
     /// Serializes simple scalar properties
     /// Test ID: AwsJson11Enums
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_enums_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // 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");
-253
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_enums()
             .set_foo_enum1(::std::option::Option::Some(
                 "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             ))
             .set_foo_enum2(::std::option::Option::Some(
                 "0".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             ))
             .set_foo_enum3(::std::option::Option::Some(
                 "1".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             ))
             .set_foo_enum_list(::std::option::Option::Some(vec![
                 "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
                 "0".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             ]))
             .set_foo_enum_set(::std::option::Option::Some(vec![
                 "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
                 "0".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             ]))
             .set_foo_enum_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "hi".to_owned(),
                     "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
                 );
                 ret.insert(
                     "zero".to_owned(),
                     "0".parse::<crate::types::FooEnum>().expect("static value validated to member"),
                 );
                 ret
             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/x-amz-json-1.1"), ("X-Amz-Target", "JsonProtocol.JsonEnums")];
         ::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, "{\n    \"fooEnum1\": \"Foo\",\n    \"fooEnum2\": \"0\",\n    \"fooEnum3\": \"1\",\n    \"fooEnumList\": [\n        \"Foo\",\n        \"0\"\n    ],\n    \"fooEnumSet\": [\n        \"Foo\",\n        \"0\"\n    ],\n    \"fooEnumMap\": {\n        \"hi\": \"Foo\",\n        \"zero\": \"0\"\n    }\n}", ::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");
-299
+    }
-300
     /// Serializes simple scalar properties
     /// Test ID: AwsJson11EnumsBasic
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_enums_basic_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");
-313
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_enums()
             .set_foo_enum1(::std::option::Option::Some(
                 "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             ))
             .set_foo_enum2(::std::option::Option::Some(
                 "0".parse::<crate::types::FooEnum>().expect("static value validated to member"),

↧ Expand context

             ))
             .set_foo_enum3(::std::option::Option::Some(
                 "1".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             ))
             .set_foo_enum_list(::std::option::Option::Some(vec![
                 "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
                 "0".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             ]))
             .set_foo_enum_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "hi".to_owned(),
                     "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
                 );
                 ret.insert(
                     "zero".to_owned(),
                     "0".parse::<crate::types::FooEnum>().expect("static value validated to member"),
                 );
                 ret
             }))

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/operation/json_int_enums.rs

@@ -221,221 +281,283 @@

↥ Expand context

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

 mod json_int_enums_test {
-242
     /// Serializes simple scalar properties
     /// Test ID: AwsJson11IntEnums
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_int_enums_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // 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");
-255
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_int_enums()
             .set_int_enum1(::std::option::Option::Some(1))
             .set_int_enum2(::std::option::Option::Some(2))
             .set_int_enum3(::std::option::Option::Some(3))
             .set_int_enum_list(::std::option::Option::Some(vec![1, 2]))
             .set_int_enum_set(::std::option::Option::Some(vec![1, 2]))

↧ Expand context

             .set_int_enum_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("a".to_owned(), 1);
                 ret.insert("b".to_owned(), 2);
                 ret
             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.JsonIntEnums"),
         ];
         ::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, "{\n    \"intEnum1\": 1,\n    \"intEnum2\": 2,\n    \"intEnum3\": 3,\n    \"intEnumList\": [\n        1,\n        2\n    ],\n    \"intEnumSet\": [\n        1,\n        2\n    ],\n    \"intEnumMap\": {\n        \"a\": 1,\n        \"b\": 2\n    }\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         );
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/operation/json_unions.rs

@@ -219,219 +573,591 @@

↥ Expand context

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

 mod json_unions_test {
-240
     /// Serializes a string union value
     /// Test ID: AwsJson11SerializeStringUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_serialize_string_union_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");
-253
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_unions()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::StringValue("foo".to_owned())))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.JsonUnions"),
         ];
         ::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,
             "{\n    \"contents\": {\n        \"stringValue\": \"foo\"\n    }\n}",
             ::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");
-276
+    }
-277
     /// Serializes a boolean union value
     /// Test ID: AwsJson11SerializeBooleanUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_serialize_boolean_union_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");
-290
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_unions()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::BooleanValue(true)))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.JsonUnions"),
         ];
         ::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,
             "{\n    \"contents\": {\n        \"booleanValue\": true\n    }\n}",
             ::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");
-313
+    }
-314
     /// Serializes a number union value
     /// Test ID: AwsJson11SerializeNumberUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_serialize_number_union_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");
-327
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_unions()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::NumberValue(1)))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.JsonUnions"),
         ];
         ::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,
             "{\n    \"contents\": {\n        \"numberValue\": 1\n    }\n}",
             ::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");
-350
+    }
-351
     /// Serializes a blob union value
     /// Test ID: AwsJson11SerializeBlobUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_serialize_blob_union_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");
-364
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_unions()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::BlobValue(
                 ::aws_smithy_types::Blob::new("foo"),
             )))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.JsonUnions"),
         ];
         ::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,
             "{\n    \"contents\": {\n        \"blobValue\": \"Zm9v\"\n    }\n}",
             ::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");
-389
+    }
-390
     /// Serializes a timestamp union value
     /// Test ID: AwsJson11SerializeTimestampUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_serialize_timestamp_union_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");
-403
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_unions()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::TimestampValue(
                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
             )))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.JsonUnions"),
         ];
         ::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,
             "{\n    \"contents\": {\n        \"timestampValue\": 1398796238\n    }\n}",
             ::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");
-428
+    }
-429
     /// Serializes an enum union value
     /// Test ID: AwsJson11SerializeEnumUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_serialize_enum_union_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");
-442
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_unions()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::EnumValue(
                 "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             )))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.JsonUnions"),
         ];
         ::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,
             "{\n    \"contents\": {\n        \"enumValue\": \"Foo\"\n    }\n}",
             ::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");
-467
+    }
-468
     /// Serializes a list union value
     /// Test ID: AwsJson11SerializeListUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_serialize_list_union_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");
-481
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_unions()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::ListValue(vec![
                 "foo".to_owned(),
                 "bar".to_owned(),
             ])))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.JsonUnions"),
         ];
         ::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,
             "{\n    \"contents\": {\n        \"listValue\": [\"foo\", \"bar\"]\n    }\n}",
             ::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");
-507
+    }
-508
     /// Serializes a map union value
     /// Test ID: AwsJson11SerializeMapUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_serialize_map_union_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");
-521
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_unions()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::MapValue({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("foo".to_owned(), "bar".to_owned());
                 ret.insert("spam".to_owned(), "eggs".to_owned());
                 ret
             })))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.JsonUnions"),
         ];
         ::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,
             "{\n    \"contents\": {\n        \"mapValue\": {\n            \"foo\": \"bar\",\n            \"spam\": \"eggs\"\n        }\n    }\n}",
             ::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");
-549
+    }
-550
     /// Serializes a structure union value
     /// Test ID: AwsJson11SerializeStructureUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_serialize_structure_union_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");
-563
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_unions()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::StructureValue(
                 crate::types::GreetingStruct::builder()
                     .set_hi(::std::option::Option::Some("hello".to_owned()))
                     .build(),
             )))

↧ Expand context

             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.JsonUnions"),
         ];
         ::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,
             "{\n    \"contents\": {\n        \"structureValue\": {\n            \"hi\": \"hello\"\n        }\n    }\n}",
             ::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");
-590
+    }
-591

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/operation/kitchen_sink_operation.rs

@@ -230,230 +1169,1215 @@

↥ Expand context

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

     use ::aws_smithy_protocol_test::FloatEquals;
-251
     /// Serializes string shapes
     /// Test ID: serializes_string_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_string_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // 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");
-264
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_string(::std::option::Option::Some("abc xyz".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"String\":\"abc xyz\"}",
             ::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");
-289
+    }
-290
     /// Serializes string shapes with jsonvalue trait
     /// Test ID: serializes_string_shapes_with_jsonvalue_trait
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_string_shapes_with_jsonvalue_trait_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-303
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.kitchen_sink_operation()
         .set_json_value(
             ::std::option::Option::Some(
                 "{\"string\":\"value\",\"number\":1234.5,\"boolTrue\":true,\"boolFalse\":false,\"array\":[1,2,3,4],\"object\":{\"key\":\"value\"},\"null\":null}".to_owned()
-309
+            )
-310
+        )
         .send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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, "{\"JsonValue\":\"{\\\"string\\\":\\\"value\\\",\\\"number\\\":1234.5,\\\"boolTrue\\\":true,\\\"boolFalse\\\":false,\\\"array\\\":[1,2,3,4],\\\"object\\\":{\\\"key\\\":\\\"value\\\"},\\\"null\\\":null}\"}", ::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");
-328
+    }
-329
     /// Serializes integer shapes
     /// Test ID: serializes_integer_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_integer_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // 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");
-342
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_integer(::std::option::Option::Some(1234))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"Integer\":1234}",
             ::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");
-367
+    }
-368
     /// Serializes long shapes
     /// Test ID: serializes_long_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_long_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // 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");
-381
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_long(::std::option::Option::Some(999999999999))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"Long\":999999999999}",
             ::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");
-406
+    }
-407
     /// Serializes float shapes
     /// Test ID: serializes_float_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_float_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // 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");
-420
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_float(::std::option::Option::Some(1234.5_f32))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"Float\":1234.5}",
             ::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");
-445
+    }
-446
     /// Serializes double shapes
     /// Test ID: serializes_double_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_double_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // 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");
-459
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_double(::std::option::Option::Some(1234.5_f64))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"Double\":1234.5}",
             ::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");
-484
+    }
-485
     /// Serializes blob shapes
     /// Test ID: serializes_blob_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_blob_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // 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");
-498
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_blob(::std::option::Option::Some(::aws_smithy_types::Blob::new("binary-value")))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"Blob\":\"YmluYXJ5LXZhbHVl\"}",
             ::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");
-523
+    }
-524
     /// Serializes boolean shapes (true)
     /// Test ID: serializes_boolean_shapes_true
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_boolean_shapes_true_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");
-537
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_boolean(::std::option::Option::Some(true))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"Boolean\":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");
-562
+    }
-563
     /// Serializes boolean shapes (false)
     /// Test ID: serializes_boolean_shapes_false
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_boolean_shapes_false_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");
-576
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_boolean(::std::option::Option::Some(false))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"Boolean\":false}",
             ::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");
-601
+    }
-602
     /// Serializes timestamp shapes
     /// Test ID: serializes_timestamp_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_timestamp_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // 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");
-615
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_timestamp(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 946845296, 0_f64,
             )))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"Timestamp\":946845296}",
             ::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");
-642
+    }
-643
     /// Serializes timestamp shapes with iso8601 timestampFormat
     /// Test ID: serializes_timestamp_shapes_with_iso8601_timestampformat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_timestamp_shapes_with_iso8601_timestampformat_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");
-656
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_iso8601_timestamp(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 946845296, 0_f64,
             )))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"Iso8601Timestamp\":\"2000-01-02T20:34:56Z\"}",
             ::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");
-683
+    }
-684
     /// Serializes timestamp shapes with httpdate timestampFormat
     /// Test ID: serializes_timestamp_shapes_with_httpdate_timestampformat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_timestamp_shapes_with_httpdate_timestampformat_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");
-697
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_httpdate_timestamp(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 946845296, 0_f64,
             )))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"HttpdateTimestamp\":\"Sun, 02 Jan 2000 20:34:56 GMT\"}",
             ::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");
-724
+    }
-725
     /// Serializes timestamp shapes with unixTimestamp timestampFormat
     /// Test ID: serializes_timestamp_shapes_with_unixtimestamp_timestampformat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_timestamp_shapes_with_unixtimestamp_timestampformat_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");
-738
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_unix_timestamp(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 946845296, 0_f64,
             )))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"UnixTimestamp\":946845296}",
             ::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");
-765
+    }
-766
     /// Serializes list shapes
     /// Test ID: serializes_list_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_list_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // 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");
-779
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_list_of_strings(::std::option::Option::Some(vec!["abc".to_owned(), "mno".to_owned(), "xyz".to_owned()]))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"ListOfStrings\":[\"abc\",\"mno\",\"xyz\"]}",
             ::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");
-804
+    }
-805
     /// Serializes empty list shapes
     /// Test ID: serializes_empty_list_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_empty_list_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // 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");
-818
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_list_of_strings(::std::option::Option::Some(vec![]))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"ListOfStrings\":[]}",
             ::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");
-843
+    }
-844
     /// Serializes list of map shapes
     /// Test ID: serializes_list_of_map_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_list_of_map_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // 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");
-857
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_list_of_maps_of_strings(::std::option::Option::Some(vec![
-862
+                {
                     let mut ret = ::std::collections::HashMap::new();
                     ret.insert("foo".to_owned(), "bar".to_owned());
                     ret
                 },
-867
+                {
                     let mut ret = ::std::collections::HashMap::new();
                     ret.insert("abc".to_owned(), "xyz".to_owned());
                     ret
                 },
-872
+                {
                     let mut ret = ::std::collections::HashMap::new();
                     ret.insert("red".to_owned(), "blue".to_owned());
                     ret
                 },
             ]))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"ListOfMapsOfStrings\":[{\"foo\":\"bar\"},{\"abc\":\"xyz\"},{\"red\":\"blue\"}]}",
             ::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");
-898
+    }
-899
     /// Serializes list of structure shapes
     /// Test ID: serializes_list_of_structure_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_list_of_structure_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // 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");
-912
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_list_of_structs(::std::option::Option::Some(vec![
                 crate::types::SimpleStruct::builder()
                     .set_value(::std::option::Option::Some("abc".to_owned()))
                     .build(),
                 crate::types::SimpleStruct::builder()
                     .set_value(::std::option::Option::Some("mno".to_owned()))
                     .build(),
                 crate::types::SimpleStruct::builder()
                     .set_value(::std::option::Option::Some("xyz".to_owned()))
                     .build(),
             ]))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"ListOfStructs\":[{\"Value\":\"abc\"},{\"Value\":\"mno\"},{\"Value\":\"xyz\"}]}",
             ::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");
-947
+    }
-948
     /// Serializes list of recursive structure shapes
     /// Test ID: serializes_list_of_recursive_structure_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_list_of_recursive_structure_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // 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");
-961
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_recursive_list(::std::option::Option::Some(vec![crate::types::KitchenSink::builder()
                 .set_recursive_list(::std::option::Option::Some(vec![crate::types::KitchenSink::builder()
                     .set_recursive_list(::std::option::Option::Some(vec![crate::types::KitchenSink::builder()
                         .set_integer(::std::option::Option::Some(123))
                         .build()]))
                     .build()]))
                 .build()]))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"RecursiveList\":[{\"RecursiveList\":[{\"RecursiveList\":[{\"Integer\":123}]}]}]}",
             ::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");
-992
+    }
-993
     /// Serializes map shapes
     /// Test ID: serializes_map_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_map_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // 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");
-1006
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_map_of_strings(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("abc".to_owned(), "xyz".to_owned());
                 ret.insert("mno".to_owned(), "hjk".to_owned());
                 ret
             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"MapOfStrings\":{\"abc\":\"xyz\",\"mno\":\"hjk\"}}",
             ::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");
-1036
+    }
-1037
     /// Serializes empty map shapes
     /// Test ID: serializes_empty_map_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_empty_map_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // 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");
-1050
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_map_of_strings(::std::option::Option::Some(::std::collections::HashMap::new()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"MapOfStrings\":{}}",
             ::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");
-1075
+    }
-1076
     /// Serializes map of list shapes
     /// Test ID: serializes_map_of_list_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_map_of_list_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // 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");
-1089
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_map_of_lists_of_strings(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("abc".to_owned(), vec!["abc".to_owned(), "xyz".to_owned()]);
                 ret.insert("mno".to_owned(), vec!["xyz".to_owned(), "abc".to_owned()]);
                 ret
             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"MapOfListsOfStrings\":{\"abc\":[\"abc\",\"xyz\"],\"mno\":[\"xyz\",\"abc\"]}}",
             ::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");
-1119
+    }
-1120
     /// Serializes map of structure shapes
     /// Test ID: serializes_map_of_structure_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_map_of_structure_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // 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");
-1133
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_map_of_structs(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "key1".to_owned(),
                     crate::types::SimpleStruct::builder()
                         .set_value(::std::option::Option::Some("value-1".to_owned()))
                         .build(),
                 );
                 ret.insert(
                     "key2".to_owned(),
                     crate::types::SimpleStruct::builder()
                         .set_value(::std::option::Option::Some("value-2".to_owned()))
                         .build(),
                 );
                 ret
             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"MapOfStructs\":{\"key1\":{\"Value\":\"value-1\"},\"key2\":{\"Value\":\"value-2\"}}}",
             ::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");
-1173
+    }
-1174
     /// Serializes map of recursive structure shapes
     /// Test ID: serializes_map_of_recursive_structure_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_map_of_recursive_structure_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // 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");
-1187
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_recursive_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "key1".to_owned(),
                     crate::types::KitchenSink::builder()

↧ Expand context

                         .set_recursive_map(::std::option::Option::Some({
                             let mut ret = ::std::collections::HashMap::new();
                             ret.insert(
                                 "key2".to_owned(),
                                 crate::types::KitchenSink::builder()
                                     .set_recursive_map(::std::option::Option::Some({
                                         let mut ret = ::std::collections::HashMap::new();
                                         ret.insert(
                                             "key3".to_owned(),
                                             crate::types::KitchenSink::builder()
                                                 .set_boolean(::std::option::Option::Some(false))
                                                 .build(),
                                         );
                                         ret
                                     }))
                                     .build(),
                             );
                             ret
                         }))
                         .build(),

@@ -1173,1219 +1389,1445 @@

↥ Expand context

             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"RecursiveMap\":{\"key1\":{\"RecursiveMap\":{\"key2\":{\"RecursiveMap\":{\"key3\":{\"Boolean\":false}}}}}}}",
             ::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");

-1239
+    }
-1240
     /// Serializes structure shapes
     /// Test ID: serializes_structure_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_structure_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // 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");
-1253
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_simple_struct(::std::option::Option::Some(
                 crate::types::SimpleStruct::builder()
                     .set_value(::std::option::Option::Some("abc".to_owned()))
                     .build(),
             ))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"SimpleStruct\":{\"Value\":\"abc\"}}",
             ::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");
-1282
+    }
-1283
     /// Serializes structure members with locationName traits
     /// Test ID: serializes_structure_members_with_locationname_traits
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_structure_members_with_locationname_traits_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");
-1296
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_struct_with_json_name(::std::option::Option::Some(
                 crate::types::StructWithJsonName::builder()
                     .set_value(::std::option::Option::Some("some-value".to_owned()))
                     .build(),
             ))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"StructWithJsonName\":{\"Value\":\"some-value\"}}",
             ::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");
-1325
+    }
-1326
     /// Serializes empty structure shapes
     /// Test ID: serializes_empty_structure_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_empty_structure_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // 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");
-1339
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_simple_struct(::std::option::Option::Some(crate::types::SimpleStruct::builder().build()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"SimpleStruct\":{}}",
             ::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");
-1364
+    }
-1365
     /// Serializes structure which have no members
     /// Test ID: serializes_structure_which_have_no_members
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_structure_which_have_no_members_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");
-1378
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_empty_struct(::std::option::Option::Some(crate::types::EmptyStruct::builder().build()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"EmptyStruct\":{}}",
             ::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");
-1403
+    }
-1404
     /// Serializes recursive structure shapes
     /// Test ID: serializes_recursive_structure_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_recursive_structure_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // 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");
-1417
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_string(::std::option::Option::Some("top-value".to_owned()))
             .set_boolean(::std::option::Option::Some(false))
             .set_recursive_struct(::std::option::Option::Some(::std::boxed::Box::new(
                 crate::types::KitchenSink::builder()
                     .set_string(::std::option::Option::Some("nested-value".to_owned()))

↧ Expand context

                     .set_boolean(::std::option::Option::Some(true))
                     .set_recursive_list(::std::option::Option::Some(vec![
                         crate::types::KitchenSink::builder()
                             .set_string(::std::option::Option::Some("string-only".to_owned()))
                             .build(),
                         crate::types::KitchenSink::builder()
                             .set_recursive_struct(::std::option::Option::Some(::std::boxed::Box::new(
                                 crate::types::KitchenSink::builder()
                                     .set_map_of_strings(::std::option::Option::Some({
                                         let mut ret = ::std::collections::HashMap::new();
                                         ret.insert("color".to_owned(), "red".to_owned());
                                         ret.insert("size".to_owned(), "large".to_owned());
                                         ret
                                     }))
                                     .build(),
                             )))
                             .build(),
                     ]))
                     .build(),
             )))

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/operation/null_operation.rs

@@ -221,221 +281,283 @@

↥ Expand context

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

 mod null_operation_test {
-242
     /// Null structure values are dropped
     /// Test ID: AwsJson11StructuresDontSerializeNullValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_structures_dont_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");
-255
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.null_operation().set_string(::std::option::Option::None).send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.NullOperation"),
         ];

↧ Expand context

         ::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,
             "{}",
             ::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");
-274
+    }
-275
     /// Null structure values are dropped
     /// Test ID: AwsJson11StructuresDontDeserializeNullValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_structures_dont_deserialize_null_values_response() {
         let expected_output = crate::operation::null_operation::NullOperationOutput::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/operation/operation_with_optional_input_output.rs

@@ -233,233 +324,328 @@

↥ Expand context

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

 mod operation_with_optional_input_output_test {
-254
     /// Can call operations with no input or output
     /// Test ID: can_call_operation_with_no_input_or_output
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn can_call_operation_with_no_input_or_output_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-267
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.operation_with_optional_input_output().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.OperationWithOptionalInputOutput"),
         ];
         ::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,
             "{}",
             ::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");
-286
+    }
-287
     /// Can invoke operations with optional input
     /// Test ID: can_call_operation_with_optional_input
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn can_call_operation_with_optional_input_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");
-300
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .operation_with_optional_input_output()
             .set_value(::std::option::Option::Some("Hi".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", "JsonProtocol.OperationWithOptionalInputOutput"),
         ];
         ::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,
             "{\"Value\":\"Hi\"}",
             ::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");
-323
+    }
-324
+}
-325
 /// Error type for the `OperationWithOptionalInputOutputError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/operation/put_and_get_inline_documents.rs

@@ -229,229 +289,291 @@

↥ Expand context

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

 mod put_and_get_inline_documents_test {
-250
     /// Serializes inline documents in a JSON request.
     /// Test ID: PutAndGetInlineDocumentsInput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn put_and_get_inline_documents_input_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
             .put_and_get_inline_documents()
             .set_inline_document(::std::option::Option::Some({
                 let json_bytes = br#"{
                         "foo": "bar"
                     }"#;
                 let mut tokens = ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();

↧ Expand context

                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens).expect("well formed json")
             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.PutAndGetInlineDocuments"),
         ];
         ::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,
             "{\n    \"inlineDocument\": {\"foo\": \"bar\"}\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/operation/put_with_content_encoding.rs

@@ -229,229 +320,324 @@

↥ Expand context

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

 mod put_with_content_encoding_test {
-250
     /// Compression algorithm encoding is appended to the Content-Encoding header.
     /// Test ID: SDKAppliedContentEncoding_awsJson1_1
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn sdk_applied_content_encoding_aws_json1_1_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.put_with_content_encoding()
         .set_data(
             ::std::option::Option::Some(
                 "RjCEL3kBwqPivZUXGiyA5JCujtWgJAkKRlnTEsNYfBRGOS0f7LT6R3bCSOXeJ4auSHzQ4BEZZTklUyj5\n1HEojihShQC2jkQJrNdGOZNSW49yRO0XbnGmeczUHbZqZRelLFKW4xjru9uTuB8lFCtwoGgciFsgqTF8\n5HYcoqINTRxuAwGuRUMoNO473QT0BtCQoKUkAyVaypG0hBZdGNoJhunBfW0d3HWTYlzz9pXElyZhq3C1\n2PDB17GEoOYXmTxDecysmPOdo5z6T0HFhujfeJFIQQ8dirmXcG4F3v0bZdf6AZ3jsiVh6RnEXIPxPbOi\ngIXDWTMUr4Pg3f2LdYCM01eAb2qTdgsEN0MUDhEIfn68I2tnWvcozyUFpg1ez6pyWP8ssWVfFrckREIM\nMb0cTUVqSVSM8bnFiF9SoXM6ZoGMKfX1mT708OYk7SqZ1JlCTkecDJDoR5ED2q2MWKUGR6jjnEV0GtD8\nWJO6AcF0DptY9Hk16Bav3z6c5FeBvrGDrxTFVgRUk8SychzjrcqJ4qskwN8rL3zslC0oqobQRnLFOvwJ\nprSzBIwdH2yAuxokXAdVRa1u9NGNRvfWJfKkwbbVz8yV76RUF9KNhAUmwyYDrLnxNj8ROl8B7dv8Gans\n7Bit52wcdiJyjBW1pAodB7zqqVwtBx5RaSpF7kEMXexYXp9N0J1jlXzdeg5Wgg4pO7TJNr2joiPVAiFf\nefwMMCNBkYx2z7cRxVxCJZMXXzxSKMGgdTN24bJ5UgE0TxyV52RC0wGWG49S1x5jGrvmxKCIgYPs0w3Z\n0I3XcdB0WEj4x4xRztB9Cx2Mc4qFYQdzS9kOioAgNBti1rBySZ8lFZM2zqxvBsJTTJsmcKPr1crqiXjM\noVWdM4ObOO6QA7Pu4c1hT68CrTmbcecjFcxHkgsqdixnFtN6keMGL9Z2YMjZOjYYzbUEwLJqUVWalkIB\nBkgBRqZpzxx5nB5t0qDH35KjsfKM5cinQaFoRq9y9Z82xdCoKZOsUbxZkk1kVmy1jPDCBhkhixkc5PKS\nFoSKTbeK7kuCEZCtR9OfF2k2MqbygGFsFu2sgb1Zn2YdDbaRwRGeaLhswta09UNSMUo8aTixgoYVHxwy\nvraLB6olPSPegeLOnmBeWyKmEfPdbpdGm4ev4vA2AUFuLIeFz0LkCSN0NgQMrr8ALEm1UNpJLReg1ZAX\nzZh7gtQTZUaBVdMJokaJpLk6FPxSA6zkwB5TegSqhrFIsmvpY3VNWmTUq7H0iADdh3dRQ8Is97bTsbwu\nvAEOjh4FQ9wPSFzEtcSJeYQft5GfWYPisDImjjvHVFshFFkNy2nN18pJmhVPoJc456tgbdfEIdGhIADC\n6UPcSSzE1FxlPpILqZrp3i4NvvKoiOa4a8tnALd2XRHHmsvALn2Wmfu07b86gZlu4yOyuUFNoWI6tFvd\nbHnqSJYNQlFESv13gJw609DBzNnrIgBGYBAcDRrIGAnflRKwVDUnDFrUQmE8xNG6jRlyb1p2Y2RrfBtG\ncKqhuGNiT2DfxpY89ektZ98waPhJrFEPJToNH8EADzBorh3T0h4YP1IeLmaI7SOxeuVrk1kjRqMK0rUB\nlUJgJNtCE35jCyoHMwPQlyi78ZaVv8COVQ24zcGpw0MTy6JUsDzAC3jLNY6xCb40SZV9XzG7nWvXA5Ej\nYC1gTXxF4AtFexIdDZ4RJbtYMyXt8LsEJerwwpkfqvDwsiFuqYC6vIn9RoZO5kI0F35XtUITDQYKZ4eq\nWBV0itxTyyR5Rp6g30pZEmEqOusDaIh96CEmHpOBYAQZ7u1QTfzRdysIGMpzbx5gj9Dxm2PO1glWzY7P\nlVqQiBlXSGDOkBkrB6SkiAxknt9zsPdTTsf3r3nid4hdiPrZmGWNgjOO1khSxZSzBdltrCESNnQmlnP5\nZOHA0eSYXwy8j4od5ZmjA3IpFOEPW2MutMbxIbJpg5dIx2x7WxespftenRLgl3CxcpPDcnb9w8LCHBg7\nSEjrEer6Y8wVLFWsQiv6nTdCPZz9cGqwgtCaiHRy8lTWFgdfWd397vw9rduGld3uUFeFRGjYrphqEmHi\nhiG0GhE6wRFVUsGJtvOCYkVREvbEdxPFeJvlAvOcs9HKbtptlTusvYB86vR2bNcIY4f5JZu2X6sGa354\n7LRk0ps2zqYjat3hMR7XDC8KiKceBteFsXoDjfVxTYKelpedTxqWAafrKhaoAVuNM98PSnkuIWGzjSUC\nNsDJTt6vt1D1afBVPWVmnQ7ZQdtEtLIEwAWYjemAztreELIr1E9fPEILm1Ke4KctP9I0I72Dh4eylNZD\n0DEr2Hg7cWFckuZ0Av5d0IPRARXikEGDHl8uh12TXL9v2Uh0ZVSJMEYvxGSbZvkWz8TjWSk3hKA2a7GL\nJm3Ho7e1C34gE1XRGcEthxvURxt4OKBqN3ZNaMIuDTWinoQAutMcUqtm4MoL7RGPiCHUrvTwQPSirsmA\nQmOEu8nOpnP77Fivh9jLGx5ta7nL6jrsWUsBqiN1lzpdPYLRR4mUIAj6sNWiDEk4pkbHSMEcqbWw6Zl7\npsEyPDHalCNhWMA3RSK3skURzQDZ0oBV5W7vjVIZ4d3uCKsk6zrzEI9u5mx7p9RdNKodXfzqYt0ULdtc\n3RW0hIfw2KvrO3BD2QrtgAkfrFBGVvlJSUoh0MvLz8DeXxfuiuq9Ttu7wvsqVI4Piah6WNEXtHHGPJO3\nGhc75Bnv2To4VS2v8rmyKAPIIVTuYBHZN6sZ4FhFzbrslCIdk0eadaU60naqiNWU3CsxplIYGyeThmJ7\n9u4h6Y2OmiPZjFPS2bAzwgAozYTVefII9aEaWZ0hxHZeu1FW7r79dkdO73ZqRfas9u8Z7LLBPCw5pV0F\n5I0pHDgNb6MogoxF4NZJfVtIX1vCHhhVLrXjrYNJU2fD9Fw8kT8Ie2HDBJnqAvYKmryQ1r9ulo3Me3rH\nq9s2Y5uCDxu9iQNhnpwIm57WYGFeqd2fnQeY2IziD3Jgx0KSrmOH0jgi0RwJyfGXaORPq3bQQqljuACo\nkO6io9t5VI8PbNxSHTRbtYiPciUslbT0g7SpCLrRPOBRJ4DDk56pjghpeoUagJ5xJ4wjBzBuXnAGkNnP\nTfpiuz2r3oSBAi8sB9wiYK2z9sp4gZyQsqdVNzAEgKatOxBRBmJCBYpjO98ZQrF83XApPpfFg0ujB2PW\n1iYF9NkgwIKB5oB6KVTOmSKJk11mVermPgeugHbzdd2zUP6fP8fWbhseqk2t8ahGvqjs2CDHFIWXl5jc\nfCknbykE3ANt7lnAfJQ2ddduLGiqrX4HWx6jcWw08Es6BkleO0IDbaWrb95d5isvFlzJsf0TyDIXF4uq\nbBDCi0XPWqtRJ2iqmnJa2GbBe9GmAOWMkBFSilMyC4sR395WSDpD56fx0NGoU6cHrRu9xF2Bgh7RGSfl\nch2GXEeE02fDpSHFNvJBlOEqqfkIX6oCa6KY9NThqeIjYsT184XR2ZI7akXRaw1gMOGpk4FmUxk6WIuX\n4ei1SLQgSdl7OEdRtJklZ76eFrMbkJQ2TDhu8f7mVuiy53GUMIvCrP9xYGZGmCIDm2e4U2BDi3F7C5xK\n3bDZXwlQp6z4BSqTy2OVEWxXUJfjPMOL5Mc7AvDeKtxAS73pVIv0HgHIa4NBAdC7uLG0zXuu1FF6z2XY\nyUhk03fMZhYe7vVxsul3WE7U01fuN8z2y0eKwBW1RFBE1eKIaR9Y01sIWQWbSrfHfDrdZiElhmhHehfs\n0EfrR4sLYdQshJuvhTeKGJDaEhtPQwwJ9mUYGtuCL9RozWx1XI4bHNlzBTW0BVokYiJGlPe7wdxNzJD7\nJgS7Lwv6jGKngVf86imGZyzqwiteWFPdNUoWdTvUPSMO5xIUK9mo5QpwbBOAmyYzVq42o3Qs90N9khEV\nU36LB99fw8PtGHH5wsCHshfauwnNPj0blGXzke0kQ4JNCVH7Jtn0Y0aeejkSxFtwtxoYs6zHl1Lxxpsd\nsw5vBy49CEtoltDW367lVAwDjWdx20msGB7qJCkEDrzu7EXSO22782QX9NBRcN9ppX0C25I0FMA4Wnhz\n9zIpiXRrsTH35jzM8Cjt4EVLGNU3O0HuEvAer3cENnMJtngdrT86ox3fihMQbiuy4Bh4DEcP5in2VjbT\n3qbnoCNvOi8Fmmf7KlGlWAOceL5OHVE5lljjQEMzEQOCEgrk5mDKgwSBJQBNauIDSC1a5iEQjB8Xxp4C\nqeKyyWY9IOntNrtU5ny4lNprHJd36dKFeBLKcGCOvgHBXdOZloMF0YTRExw7hreEO9IoTGVHJ4teWsNr\nHdtagUHjkeZkdMMfnUGNv5aBNtFMqhcZH6EitEa9lGPkKBbJpoom3u8D8EHSIF1H5EZqqx9TLY5hWAIG\nPwJ4qwkpCGw5rCLVrjw7ARKukIFzNULANqjHUMcJ002TlUosJM4xJ4aAgckpLVGOGuPDhGAAexEcQmbg\nUsZdmqQrtuVUyyLteLbLbqtR6CTlcAIwY3xyMCmPgyefE0FEUODBoxQtRUuYTL9RC5o1sYb2PvcxUQfb\niJFi2CAl99pAzcckU2qVCxniARslIxM5pmMRGsQX9ZzYAfZrbg6ce6S74I8UMlgRQ2QVyvUjKKOE6IrJ\nLng370emHfe5m6LZULD5YiZutkD5ipjL2Bz77DvTE5kNPUhuoKBcTJcUgytfXAKUTWOcRKNlq0GImrxM\nJfr7AWbLFFNKGLeTrVDBwpcokJCv0zcOKWe8fd2xkeXkZTdmM66IgM27cyYmtQ6YF26Kd0qrWJeVZJV9\n3fyLYYvKN5csbRY2BHoYE5ERARRW65IrpkXMf48OrCXMtDIP0Z7wxI9DiTeKKeH4uuguhCJnwzR3WxLA\nVU6eBJEd7ZjS6JA83w7decq8uDI7LGKjcz1FySp3B7fE9DkHRGXxbsL7Fjar6vW2mAv8CuvI20B6jctp\n2yLDs24sPfB3sSxrrlhbuT1m6DZqiN0dl6umKx7NGZhmOTVGr20jfcxhqPQwTJfd7kel4rvxip4BqkvT\n7STy8knJ2BXGyJeNgwo1PXUZRDVy0LCTsSF1RFuRZe8cktHl9lgw8ntdPn1pVFL0MwJkJfdXBNUp5gNv\n50FTkrpo1t6wq4CVbcfj2XOrOzvBUzNH26sXGABI1gGxCdp2jEZrHgqQaWIaTJVTuguZhxqDvdYsrwFW\nYN58uuNcKHIrGdRSigyZInwQDYk0pjcqdSeU0WVU3Y9htzZBR7XRaCJr5YTZvq7fwermb5tuwb37lPLq\nB2IGg0iftkVbXaSyfCwVaRbfLBb88so0QqpmJGirFu8FcDiXOV1zTr8yW9XLdYQuUjh43xrXLdgsuYff\nCagInUk1eU1aLjVZoJRsNmStmOEpAqlYMwTvx7w6j2f421Cxr5cNZBIVlAxlXN2QiDqJ9v3sHhHkTanc\nlQuH8ptUyX8qncpBuXXBn7cSez9N0EoxCBl1GHUagbjstgJo4gzLvTmVIY6MiWYOBitzNUHfyqKwtKUr\nVoSCdZcGeA9lHUPA7PUprRRaT3m1hGKPyshtVS2ikG48w3oVerln1N1qGdtz46gZCrndw3LZ1B362RfW\nzDPuXbpsyLsRMTt1Rz1oKHRXp3iE41hkhQH6pxlvyCW2INnHt5XU8zRamOB3oW0udOhMpQFDjRkOcy06\nb4t0QTHvoRqmBna3WXzIMZyeK3GChF5eF8oDXRbjhk7BB6YKCgqwWUzEJ5K47HMSlhFkBUjaPRjdGM0z\nzOMwhW6b1NvSwP7XM1P5yi1oPvOspts1vr29SXqrMMrBhVogeodWyd69NqrO4jkyBxKmlXifoTowpfiY\n2cUCE0XMZqxUN39LCP09JqZifaEcBEo3mgtm1tWu5QR2GNq7UyQf4RIPSDOpDCAtwoPhRgdT1lJdcj4U\nlnH0wrJ8Uwu7c08L7ErnIrDATqCrOjpSbzGP1xHENABYONC4TknFPrJ8pe40A8fzGT0qBw9mAM1SKcHO\nfoiLcMC9AjHTqJzDG3xplSLPG9or2rMeq7Fzp9r0y7uJRMxgg51EbjfvYlH466A3ggvL2WQlDXjJqPW3\nBJGWAWDNN9LK8f46bADKPxakpkx23S9O47rGSXfDhVSIZsDympxWX1UOzWwMZRHkofVeKqizgbKkGgUT\nWykE9gRoRAOd9wfHZDYKa9i0LaPDiaUMvnU1gdBIqIoiVsdJ9swX47oxvMtOxtcS0zlD6llDkBuIiU5g\nPwRCYmtkkb25c8iRJXwGFPjI1wJ34I1z1ENicPdosPiUe9ZC2jnXIKzEdv01x2ER7DNDF3yxOwOhxNxI\nGqsmC92j25UQQFu9ZstOZ28AoCkuOYs0Uycm5u8jR1T39dMBwrko09rC65ENLnsxM8oebmyFCPiGJ1ED\n5Xqc9qZ237f1OnETAoEOwqUSvrdPTv56U7hV91EMTyC812MLQpr2710E3VVpsUCUMNhIxdt7UXZ1UNFb\njgzpZLXnf4DHrv6B7kq6UI50KMxcw1HZE2GpODfUTzNFLaqdrvzxKe5eUWdcojBaRbD4fFdVYJTElYDH\nNNVh6ofkoeWcs9CWGFmSBe0T4K8phFeygQg0prKMELNEy6qENzVtG9ZDcqj3a7L6ZLtvq50anWp7fAVu\nfwz55g4iM2Z2fA0pnwHDL7tt67zTxGITvsnJsZSpeq1EQsZcwtkBV9liu7Rl7jiVT1IIRtchB8TsTiaA\nwVHIQQ9RIOTiPQdKNqi1kC9iGlUqWK93gblNWlBw1eYB9Wk8FQogutwTf0caNMx8D4nPbANcmOOlskIy\nzALh15OlTrWnhP95rf08AN2J026zDE2DUF9k0eCevYBQIDjqKNW4XCZnjbHoIcKzbY5VzPbMs3ZyMz8K\nSucBmgPg6wrSK5ykbkapS5vuqvXc9GbjQJ8bPNzoxoWGyjbZvDs2OBrIqBmcQb2DLJ8v38McQ4mC4UsS\njf4PyfSCtpk274QZjvLCZbLiCBxQegk7jUU0NmTFJAcYCxd9xMWdlFkiszcltT2YzwuFFz7iA6aa4n5L\nHpBNfUA01GcAi1aCMYhmooS4zSlYcSOZkovMz36U3Fd9WtqIEOJLi7HMgHQDgNMdK6DTzAdHQtxerxVF\nHJnPrfNVG7270r3bp0bPnLNYLhObbAn6zqSAUeLtI2Y4KJDjBKCAh2vvYGbu0e2REYJWRj7MkGevsSSy\nb1kCXLt6tKGWAb7lt5c0xyJgUIJW7pdtnwgT0ZCa24BecCAwNnG5U2EwQbcjZGsFxqNGfaemd3oFEhES\nBaE0Fxms9UKTnMafu8wvZ2xymMrUduuRzOjDeX7oD5YsLC88V8CGMLxbbxIpt94KGykbr6e7L0R4oZl1\ntKMgFwQ2p9Txdbp0Y293LcsJymKizqI0F2xEp7y4SmWOJqHZtsbz80wVV9nv41CvtfxuSoGZJ5cNB7pI\nBgzNcQCeH3Jt0RaGGwboxxpuFbzilmkMFXxJm87tD4WNgu01nHfGCKeQcySEBZpVfJgi6sDFJ8uWnvKm\n9mPLHurtWzEfKqUEa1iC71bXjw5wrvhv9BYW8JSUELHmDquftQyKdq0DZXhULMHGQLf4e95WIaoA14LL\nbThz77kuhKULPTu2MNrBUKGorurhGugo5gs4ZUezSsUOe3KxYdrFMdGgny1GgTxMSMTp2RAZytKjv4kQ\nVx7XgzvpQLIbDjUPAkJv6lScwIRq1W3Ne0Rh0V6Bmn6U5uIuWnJjULmbaQiSODj3z0mAZvak0mSWIGwT\nTX83HztcC4W7e1f6a1thmcc5K61Icehla2hBELWPpixTkyC4eEVmk9Rq0m0ZXtx0JX2ZQXqXDEyePyMe\nJ70sdSzXk72zusqhY4yuOMGgbYNHqxOToK6NxujR7e4dV3Wk5JnSUthym8scjcPeCiKDNY4cHfTMnDXJ\n9zLVy01LtNKYpJ1s8FxVxigmxQNKEbIamxhx6yqwGC4aiISVOOUEjvNOdaUfXfUsE6jEwtwxyGxjlRK1\ncLyxXttq4QWN6PehgHv7jXykzPjInbEysebFvvPOOMdunmJvcCNMSvjUda8fL6xfGo0FDrLg8XZipd6S\noPVdYtyIM1Dg40KbBA3JuumPYtXuJaHrZnjZmdnM5OVo4ZNxktfCVT0c6bnD4bAeyn4bYt1ZPaX6hQHh\nJtvNYfpD0ONYlmqKuToQAMlz52Fh6bj45EbX89L5eLlSpWeyBlGotzriB0EPlclrGi5l2B5oPb1aB1ag\nyyYuu44l0F1oOVYnBIZsxIsHVITxi9lEuVPFkWASOUNuVQXfM4n5hxWR9qtuKnIcPsvbJsv1U10XlKh3\nKisqPhHU15xrCLr5gwFxPUKiNTLUBrkzgBOHXPVsHcLCiSD0YU56TRGfvEom43TWUKPPfl9Z54tgVQuT\njCRlaljAzeniQIcbbHZnn3f0HxbDG3DFYqWSxNrXabHhRsIOhhUHSPENyhGSTVO5t0XX5CdMspJPCd02\n3Oqv32ccbUK4O3YH6LEvp0WO3kSl5n50odVkI9B0i0iq4UPFGMkM8bEQJbgJoOH71P10vtdevJFQE4g2\nyhimiM53ZJRWgSZveHtENZc0Gjo0F9eioak9BnPpY1QxAFPC817svuhEstcU69bLCA4D1rO5R8AuIIBq\nyQJcifFLvbpAEYTLKJqysZrU8EEl3TSdC13A9hZvk4NC8VGEDAxcNrKw313dZp17kZPO5HSd1y6sljAW\nA9M1d6FMYV5SlBWf3WZNCUPS7qKNlda2YBsC6IUVB363f5RLGQOQHwbaijBSRCkrVoRxBHtc0Bd5J9V9\nP5uMTXkpZOxRcCQvImGgcmGuxxLb5zTqfS2xu7v3Sf3IIesSt9tVzcEcdbEvLGVJkLk4mb3G30DbIbri\nPZ09JkweDvMaQ3bxT2nfkz3Ilihkw9jqikkCCCz7E8h6z6KbhQErEW9VzJZzMCgJsyPjFam6iNwpe07S\nhyOvNVw2t9wpzL5xM11DvVzQwDaWEytNRHzDBs4KwEtpI2IpjUyVZHSwA0UGqqkzoCgrJFlNOvPlXqcS\nIcREouUIBmuttkrhPWJtSxOOgpsdvBR3kTOzAXNzSKxoaBAb0c5SDMUc6FIyGA8x5wg5DkUgjFUUodEt\nOYaB2VHVePW9mxHeBTdKWLzJow4ZZvjnoBuVigXljKCNh137ckV2y3Yg3Xi4UzJEI2V5Rw9AfnMs7xUw\nVHOFCg189maD3bmZAe7b4eaGZhyy4HVKjqCXmIH7vsEjRvbnfB0SQxxpuqBDJbHNCtW4vM643ZQQBVPP\na7oXSQIq9w2dHp0A7dtkocCZdQp9FKR9XdJAFIbVSHzIF1ZogeZlc0pXuNE0tagvD57xwDRFkAuoQyMu\nYDdZasXrpSmEE5UjHVkyYsISn8QsfXurzDybX468aoRoks654jjmRY5zi1oB8TcMdC2c3sicNaqfeuhd\nH1nPX7l4RpdqWMR7gGx9slXtG8S3KxpOi4qCD7yg3saD66nun4dzksQURoTUdXyrJR5UpHsfIlTF1aJa\nMdXyQtQnrkl00TeghQd00rRFZsCnhi0qrCSKiBfB2EVrd9RPpbgwJGZHuIQecdBmNetc2ylSEClqVBPR\nGOPPIxrnswEZjmnS0jxKW9VSM1QVxSPJnPFswCqT95SoKD6CP4xdX28WIUGiNaIKodXXJHEIsXBCxLsr\nPwWPCtoplC6hhpKmW5dQo92iCTyY2KioKzO8XR6FKm6qonMKVEwQNtlYE9c97KMtEnp25VOdMP46SQXS\nYsSVp7vm8LP87VYI8SOKcW3s2oedYFtt45rvDzoTF0GmS6wELQ9uo98HhjQAI1Dt91cgjJOwygNmLoZE\nX5K2zQiNA163uMCl5xzaBqY4YTL0wgALg3IFdYSp0RFYLWdt6IxoGI1tnoxcjlUEPo5eGIc3mS3SmaLn\nOdumfUQQ4Jgmgaa5anUVQsfBDrlAN5oaX7O0JO71SSPSWiHBsT9WIPy2J1Cace9ZZLRxblFPSXcvsuHh\nhvnhWQltEDAe7MgvkFQ8lGVFa8jhzijoF9kLmMhMILSzYnfXnZPNP7TlAAwlLHK1RqlpHskJqb6CPpGP\nQvOAhEMsM3zJ2KejZx0esxkjxA0ZufVvGAMN3vTUMplQaF4RiQkp9fzBXf3CMk01dWjOMMIEXTeKzIQe\nEcffzjixWU9FpAyGp2rVl4ETRgqljOGw4UgK31r0ZIEGnH0xGz1FtbW1OcQM008JVujRqulCucEMmntr\n".to_owned()
-269
+            )
-270
+        )
         .send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Encoding", "gzip")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         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
     /// Compression algorithm encoding is appended to the Content-Encoding header, and the
     /// user-provided content-encoding is NOT in the Content-Encoding header since HTTP binding
     /// traits are ignored in the awsJson1_1 protocol.
     ///
     /// Test ID: SDKAppendsGzipAndIgnoresHttpProvidedEncoding_awsJson1_1
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn sdk_appends_gzip_and_ignores_http_provided_encoding_aws_json1_1_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");
-296
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.put_with_content_encoding()
         .set_encoding(
             ::std::option::Option::Some(
                 "custom".to_owned()
-302
+            )
-303
+        )
         .set_data(

↧ Expand context

             ::std::option::Option::Some(
                 "RjCEL3kBwqPivZUXGiyA5JCujtWgJAkKRlnTEsNYfBRGOS0f7LT6R3bCSOXeJ4auSHzQ4BEZZTklUyj5\n1HEojihShQC2jkQJrNdGOZNSW49yRO0XbnGmeczUHbZqZRelLFKW4xjru9uTuB8lFCtwoGgciFsgqTF8\n5HYcoqINTRxuAwGuRUMoNO473QT0BtCQoKUkAyVaypG0hBZdGNoJhunBfW0d3HWTYlzz9pXElyZhq3C1\n2PDB17GEoOYXmTxDecysmPOdo5z6T0HFhujfeJFIQQ8dirmXcG4F3v0bZdf6AZ3jsiVh6RnEXIPxPbOi\ngIXDWTMUr4Pg3f2LdYCM01eAb2qTdgsEN0MUDhEIfn68I2tnWvcozyUFpg1ez6pyWP8ssWVfFrckREIM\nMb0cTUVqSVSM8bnFiF9SoXM6ZoGMKfX1mT708OYk7SqZ1JlCTkecDJDoR5ED2q2MWKUGR6jjnEV0GtD8\nWJO6AcF0DptY9Hk16Bav3z6c5FeBvrGDrxTFVgRUk8SychzjrcqJ4qskwN8rL3zslC0oqobQRnLFOvwJ\nprSzBIwdH2yAuxokXAdVRa1u9NGNRvfWJfKkwbbVz8yV76RUF9KNhAUmwyYDrLnxNj8ROl8B7dv8Gans\n7Bit52wcdiJyjBW1pAodB7zqqVwtBx5RaSpF7kEMXexYXp9N0J1jlXzdeg5Wgg4pO7TJNr2joiPVAiFf\nefwMMCNBkYx2z7cRxVxCJZMXXzxSKMGgdTN24bJ5UgE0TxyV52RC0wGWG49S1x5jGrvmxKCIgYPs0w3Z\n0I3XcdB0WEj4x4xRztB9Cx2Mc4qFYQdzS9kOioAgNBti1rBySZ8lFZM2zqxvBsJTTJsmcKPr1crqiXjM\noVWdM4ObOO6QA7Pu4c1hT68CrTmbcecjFcxHkgsqdixnFtN6keMGL9Z2YMjZOjYYzbUEwLJqUVWalkIB\nBkgBRqZpzxx5nB5t0qDH35KjsfKM5cinQaFoRq9y9Z82xdCoKZOsUbxZkk1kVmy1jPDCBhkhixkc5PKS\nFoSKTbeK7kuCEZCtR9OfF2k2MqbygGFsFu2sgb1Zn2YdDbaRwRGeaLhswta09UNSMUo8aTixgoYVHxwy\nvraLB6olPSPegeLOnmBeWyKmEfPdbpdGm4ev4vA2AUFuLIeFz0LkCSN0NgQMrr8ALEm1UNpJLReg1ZAX\nzZh7gtQTZUaBVdMJokaJpLk6FPxSA6zkwB5TegSqhrFIsmvpY3VNWmTUq7H0iADdh3dRQ8Is97bTsbwu\nvAEOjh4FQ9wPSFzEtcSJeYQft5GfWYPisDImjjvHVFshFFkNy2nN18pJmhVPoJc456tgbdfEIdGhIADC\n6UPcSSzE1FxlPpILqZrp3i4NvvKoiOa4a8tnALd2XRHHmsvALn2Wmfu07b86gZlu4yOyuUFNoWI6tFvd\nbHnqSJYNQlFESv13gJw609DBzNnrIgBGYBAcDRrIGAnflRKwVDUnDFrUQmE8xNG6jRlyb1p2Y2RrfBtG\ncKqhuGNiT2DfxpY89ektZ98waPhJrFEPJToNH8EADzBorh3T0h4YP1IeLmaI7SOxeuVrk1kjRqMK0rUB\nlUJgJNtCE35jCyoHMwPQlyi78ZaVv8COVQ24zcGpw0MTy6JUsDzAC3jLNY6xCb40SZV9XzG7nWvXA5Ej\nYC1gTXxF4AtFexIdDZ4RJbtYMyXt8LsEJerwwpkfqvDwsiFuqYC6vIn9RoZO5kI0F35XtUITDQYKZ4eq\nWBV0itxTyyR5Rp6g30pZEmEqOusDaIh96CEmHpOBYAQZ7u1QTfzRdysIGMpzbx5gj9Dxm2PO1glWzY7P\nlVqQiBlXSGDOkBkrB6SkiAxknt9zsPdTTsf3r3nid4hdiPrZmGWNgjOO1khSxZSzBdltrCESNnQmlnP5\nZOHA0eSYXwy8j4od5ZmjA3IpFOEPW2MutMbxIbJpg5dIx2x7WxespftenRLgl3CxcpPDcnb9w8LCHBg7\nSEjrEer6Y8wVLFWsQiv6nTdCPZz9cGqwgtCaiHRy8lTWFgdfWd397vw9rduGld3uUFeFRGjYrphqEmHi\nhiG0GhE6wRFVUsGJtvOCYkVREvbEdxPFeJvlAvOcs9HKbtptlTusvYB86vR2bNcIY4f5JZu2X6sGa354\n7LRk0ps2zqYjat3hMR7XDC8KiKceBteFsXoDjfVxTYKelpedTxqWAafrKhaoAVuNM98PSnkuIWGzjSUC\nNsDJTt6vt1D1afBVPWVmnQ7ZQdtEtLIEwAWYjemAztreELIr1E9fPEILm1Ke4KctP9I0I72Dh4eylNZD\n0DEr2Hg7cWFckuZ0Av5d0IPRARXikEGDHl8uh12TXL9v2Uh0ZVSJMEYvxGSbZvkWz8TjWSk3hKA2a7GL\nJm3Ho7e1C34gE1XRGcEthxvURxt4OKBqN3ZNaMIuDTWinoQAutMcUqtm4MoL7RGPiCHUrvTwQPSirsmA\nQmOEu8nOpnP77Fivh9jLGx5ta7nL6jrsWUsBqiN1lzpdPYLRR4mUIAj6sNWiDEk4pkbHSMEcqbWw6Zl7\npsEyPDHalCNhWMA3RSK3skURzQDZ0oBV5W7vjVIZ4d3uCKsk6zrzEI9u5mx7p9RdNKodXfzqYt0ULdtc\n3RW0hIfw2KvrO3BD2QrtgAkfrFBGVvlJSUoh0MvLz8DeXxfuiuq9Ttu7wvsqVI4Piah6WNEXtHHGPJO3\nGhc75Bnv2To4VS2v8rmyKAPIIVTuYBHZN6sZ4FhFzbrslCIdk0eadaU60naqiNWU3CsxplIYGyeThmJ7\n9u4h6Y2OmiPZjFPS2bAzwgAozYTVefII9aEaWZ0hxHZeu1FW7r79dkdO73ZqRfas9u8Z7LLBPCw5pV0F\n5I0pHDgNb6MogoxF4NZJfVtIX1vCHhhVLrXjrYNJU2fD9Fw8kT8Ie2HDBJnqAvYKmryQ1r9ulo3Me3rH\nq9s2Y5uCDxu9iQNhnpwIm57WYGFeqd2fnQeY2IziD3Jgx0KSrmOH0jgi0RwJyfGXaORPq3bQQqljuACo\nkO6io9t5VI8PbNxSHTRbtYiPciUslbT0g7SpCLrRPOBRJ4DDk56pjghpeoUagJ5xJ4wjBzBuXnAGkNnP\nTfpiuz2r3oSBAi8sB9wiYK2z9sp4gZyQsqdVNzAEgKatOxBRBmJCBYpjO98ZQrF83XApPpfFg0ujB2PW\n1iYF9NkgwIKB5oB6KVTOmSKJk11mVermPgeugHbzdd2zUP6fP8fWbhseqk2t8ahGvqjs2CDHFIWXl5jc\nfCknbykE3ANt7lnAfJQ2ddduLGiqrX4HWx6jcWw08Es6BkleO0IDbaWrb95d5isvFlzJsf0TyDIXF4uq\nbBDCi0XPWqtRJ2iqmnJa2GbBe9GmAOWMkBFSilMyC4sR395WSDpD56fx0NGoU6cHrRu9xF2Bgh7RGSfl\nch2GXEeE02fDpSHFNvJBlOEqqfkIX6oCa6KY9NThqeIjYsT184XR2ZI7akXRaw1gMOGpk4FmUxk6WIuX\n4ei1SLQgSdl7OEdRtJklZ76eFrMbkJQ2TDhu8f7mVuiy53GUMIvCrP9xYGZGmCIDm2e4U2BDi3F7C5xK\n3bDZXwlQp6z4BSqTy2OVEWxXUJfjPMOL5Mc7AvDeKtxAS73pVIv0HgHIa4NBAdC7uLG0zXuu1FF6z2XY\nyUhk03fMZhYe7vVxsul3WE7U01fuN8z2y0eKwBW1RFBE1eKIaR9Y01sIWQWbSrfHfDrdZiElhmhHehfs\n0EfrR4sLYdQshJuvhTeKGJDaEhtPQwwJ9mUYGtuCL9RozWx1XI4bHNlzBTW0BVokYiJGlPe7wdxNzJD7\nJgS7Lwv6jGKngVf86imGZyzqwiteWFPdNUoWdTvUPSMO5xIUK9mo5QpwbBOAmyYzVq42o3Qs90N9khEV\nU36LB99fw8PtGHH5wsCHshfauwnNPj0blGXzke0kQ4JNCVH7Jtn0Y0aeejkSxFtwtxoYs6zHl1Lxxpsd\nsw5vBy49CEtoltDW367lVAwDjWdx20msGB7qJCkEDrzu7EXSO22782QX9NBRcN9ppX0C25I0FMA4Wnhz\n9zIpiXRrsTH35jzM8Cjt4EVLGNU3O0HuEvAer3cENnMJtngdrT86ox3fihMQbiuy4Bh4DEcP5in2VjbT\n3qbnoCNvOi8Fmmf7KlGlWAOceL5OHVE5lljjQEMzEQOCEgrk5mDKgwSBJQBNauIDSC1a5iEQjB8Xxp4C\nqeKyyWY9IOntNrtU5ny4lNprHJd36dKFeBLKcGCOvgHBXdOZloMF0YTRExw7hreEO9IoTGVHJ4teWsNr\nHdtagUHjkeZkdMMfnUGNv5aBNtFMqhcZH6EitEa9lGPkKBbJpoom3u8D8EHSIF1H5EZqqx9TLY5hWAIG\nPwJ4qwkpCGw5rCLVrjw7ARKukIFzNULANqjHUMcJ002TlUosJM4xJ4aAgckpLVGOGuPDhGAAexEcQmbg\nUsZdmqQrtuVUyyLteLbLbqtR6CTlcAIwY3xyMCmPgyefE0FEUODBoxQtRUuYTL9RC5o1sYb2PvcxUQfb\niJFi2CAl99pAzcckU2qVCxniARslIxM5pmMRGsQX9ZzYAfZrbg6ce6S74I8UMlgRQ2QVyvUjKKOE6IrJ\nLng370emHfe5m6LZULD5YiZutkD5ipjL2Bz77DvTE5kNPUhuoKBcTJcUgytfXAKUTWOcRKNlq0GImrxM\nJfr7AWbLFFNKGLeTrVDBwpcokJCv0zcOKWe8fd2xkeXkZTdmM66IgM27cyYmtQ6YF26Kd0qrWJeVZJV9\n3fyLYYvKN5csbRY2BHoYE5ERARRW65IrpkXMf48OrCXMtDIP0Z7wxI9DiTeKKeH4uuguhCJnwzR3WxLA\nVU6eBJEd7ZjS6JA83w7decq8uDI7LGKjcz1FySp3B7fE9DkHRGXxbsL7Fjar6vW2mAv8CuvI20B6jctp\n2yLDs24sPfB3sSxrrlhbuT1m6DZqiN0dl6umKx7NGZhmOTVGr20jfcxhqPQwTJfd7kel4rvxip4BqkvT\n7STy8knJ2BXGyJeNgwo1PXUZRDVy0LCTsSF1RFuRZe8cktHl9lgw8ntdPn1pVFL0MwJkJfdXBNUp5gNv\n50FTkrpo1t6wq4CVbcfj2XOrOzvBUzNH26sXGABI1gGxCdp2jEZrHgqQaWIaTJVTuguZhxqDvdYsrwFW\nYN58uuNcKHIrGdRSigyZInwQDYk0pjcqdSeU0WVU3Y9htzZBR7XRaCJr5YTZvq7fwermb5tuwb37lPLq\nB2IGg0iftkVbXaSyfCwVaRbfLBb88so0QqpmJGirFu8FcDiXOV1zTr8yW9XLdYQuUjh43xrXLdgsuYff\nCagInUk1eU1aLjVZoJRsNmStmOEpAqlYMwTvx7w6j2f421Cxr5cNZBIVlAxlXN2QiDqJ9v3sHhHkTanc\nlQuH8ptUyX8qncpBuXXBn7cSez9N0EoxCBl1GHUagbjstgJo4gzLvTmVIY6MiWYOBitzNUHfyqKwtKUr\nVoSCdZcGeA9lHUPA7PUprRRaT3m1hGKPyshtVS2ikG48w3oVerln1N1qGdtz46gZCrndw3LZ1B362RfW\nzDPuXbpsyLsRMTt1Rz1oKHRXp3iE41hkhQH6pxlvyCW2INnHt5XU8zRamOB3oW0udOhMpQFDjRkOcy06\nb4t0QTHvoRqmBna3WXzIMZyeK3GChF5eF8oDXRbjhk7BB6YKCgqwWUzEJ5K47HMSlhFkBUjaPRjdGM0z\nzOMwhW6b1NvSwP7XM1P5yi1oPvOspts1vr29SXqrMMrBhVogeodWyd69NqrO4jkyBxKmlXifoTowpfiY\n2cUCE0XMZqxUN39LCP09JqZifaEcBEo3mgtm1tWu5QR2GNq7UyQf4RIPSDOpDCAtwoPhRgdT1lJdcj4U\nlnH0wrJ8Uwu7c08L7ErnIrDATqCrOjpSbzGP1xHENABYONC4TknFPrJ8pe40A8fzGT0qBw9mAM1SKcHO\nfoiLcMC9AjHTqJzDG3xplSLPG9or2rMeq7Fzp9r0y7uJRMxgg51EbjfvYlH466A3ggvL2WQlDXjJqPW3\nBJGWAWDNN9LK8f46bADKPxakpkx23S9O47rGSXfDhVSIZsDympxWX1UOzWwMZRHkofVeKqizgbKkGgUT\nWykE9gRoRAOd9wfHZDYKa9i0LaPDiaUMvnU1gdBIqIoiVsdJ9swX47oxvMtOxtcS0zlD6llDkBuIiU5g\nPwRCYmtkkb25c8iRJXwGFPjI1wJ34I1z1ENicPdosPiUe9ZC2jnXIKzEdv01x2ER7DNDF3yxOwOhxNxI\nGqsmC92j25UQQFu9ZstOZ28AoCkuOYs0Uycm5u8jR1T39dMBwrko09rC65ENLnsxM8oebmyFCPiGJ1ED\n5Xqc9qZ237f1OnETAoEOwqUSvrdPTv56U7hV91EMTyC812MLQpr2710E3VVpsUCUMNhIxdt7UXZ1UNFb\njgzpZLXnf4DHrv6B7kq6UI50KMxcw1HZE2GpODfUTzNFLaqdrvzxKe5eUWdcojBaRbD4fFdVYJTElYDH\nNNVh6ofkoeWcs9CWGFmSBe0T4K8phFeygQg0prKMELNEy6qENzVtG9ZDcqj3a7L6ZLtvq50anWp7fAVu\nfwz55g4iM2Z2fA0pnwHDL7tt67zTxGITvsnJsZSpeq1EQsZcwtkBV9liu7Rl7jiVT1IIRtchB8TsTiaA\nwVHIQQ9RIOTiPQdKNqi1kC9iGlUqWK93gblNWlBw1eYB9Wk8FQogutwTf0caNMx8D4nPbANcmOOlskIy\nzALh15OlTrWnhP95rf08AN2J026zDE2DUF9k0eCevYBQIDjqKNW4XCZnjbHoIcKzbY5VzPbMs3ZyMz8K\nSucBmgPg6wrSK5ykbkapS5vuqvXc9GbjQJ8bPNzoxoWGyjbZvDs2OBrIqBmcQb2DLJ8v38McQ4mC4UsS\njf4PyfSCtpk274QZjvLCZbLiCBxQegk7jUU0NmTFJAcYCxd9xMWdlFkiszcltT2YzwuFFz7iA6aa4n5L\nHpBNfUA01GcAi1aCMYhmooS4zSlYcSOZkovMz36U3Fd9WtqIEOJLi7HMgHQDgNMdK6DTzAdHQtxerxVF\nHJnPrfNVG7270r3bp0bPnLNYLhObbAn6zqSAUeLtI2Y4KJDjBKCAh2vvYGbu0e2REYJWRj7MkGevsSSy\nb1kCXLt6tKGWAb7lt5c0xyJgUIJW7pdtnwgT0ZCa24BecCAwNnG5U2EwQbcjZGsFxqNGfaemd3oFEhES\nBaE0Fxms9UKTnMafu8wvZ2xymMrUduuRzOjDeX7oD5YsLC88V8CGMLxbbxIpt94KGykbr6e7L0R4oZl1\ntKMgFwQ2p9Txdbp0Y293LcsJymKizqI0F2xEp7y4SmWOJqHZtsbz80wVV9nv41CvtfxuSoGZJ5cNB7pI\nBgzNcQCeH3Jt0RaGGwboxxpuFbzilmkMFXxJm87tD4WNgu01nHfGCKeQcySEBZpVfJgi6sDFJ8uWnvKm\n9mPLHurtWzEfKqUEa1iC71bXjw5wrvhv9BYW8JSUELHmDquftQyKdq0DZXhULMHGQLf4e95WIaoA14LL\nbThz77kuhKULPTu2MNrBUKGorurhGugo5gs4ZUezSsUOe3KxYdrFMdGgny1GgTxMSMTp2RAZytKjv4kQ\nVx7XgzvpQLIbDjUPAkJv6lScwIRq1W3Ne0Rh0V6Bmn6U5uIuWnJjULmbaQiSODj3z0mAZvak0mSWIGwT\nTX83HztcC4W7e1f6a1thmcc5K61Icehla2hBELWPpixTkyC4eEVmk9Rq0m0ZXtx0JX2ZQXqXDEyePyMe\nJ70sdSzXk72zusqhY4yuOMGgbYNHqxOToK6NxujR7e4dV3Wk5JnSUthym8scjcPeCiKDNY4cHfTMnDXJ\n9zLVy01LtNKYpJ1s8FxVxigmxQNKEbIamxhx6yqwGC4aiISVOOUEjvNOdaUfXfUsE6jEwtwxyGxjlRK1\ncLyxXttq4QWN6PehgHv7jXykzPjInbEysebFvvPOOMdunmJvcCNMSvjUda8fL6xfGo0FDrLg8XZipd6S\noPVdYtyIM1Dg40KbBA3JuumPYtXuJaHrZnjZmdnM5OVo4ZNxktfCVT0c6bnD4bAeyn4bYt1ZPaX6hQHh\nJtvNYfpD0ONYlmqKuToQAMlz52Fh6bj45EbX89L5eLlSpWeyBlGotzriB0EPlclrGi5l2B5oPb1aB1ag\nyyYuu44l0F1oOVYnBIZsxIsHVITxi9lEuVPFkWASOUNuVQXfM4n5hxWR9qtuKnIcPsvbJsv1U10XlKh3\nKisqPhHU15xrCLr5gwFxPUKiNTLUBrkzgBOHXPVsHcLCiSD0YU56TRGfvEom43TWUKPPfl9Z54tgVQuT\njCRlaljAzeniQIcbbHZnn3f0HxbDG3DFYqWSxNrXabHhRsIOhhUHSPENyhGSTVO5t0XX5CdMspJPCd02\n3Oqv32ccbUK4O3YH6LEvp0WO3kSl5n50odVkI9B0i0iq4UPFGMkM8bEQJbgJoOH71P10vtdevJFQE4g2\nyhimiM53ZJRWgSZveHtENZc0Gjo0F9eioak9BnPpY1QxAFPC817svuhEstcU69bLCA4D1rO5R8AuIIBq\nyQJcifFLvbpAEYTLKJqysZrU8EEl3TSdC13A9hZvk4NC8VGEDAxcNrKw313dZp17kZPO5HSd1y6sljAW\nA9M1d6FMYV5SlBWf3WZNCUPS7qKNlda2YBsC6IUVB363f5RLGQOQHwbaijBSRCkrVoRxBHtc0Bd5J9V9\nP5uMTXkpZOxRcCQvImGgcmGuxxLb5zTqfS2xu7v3Sf3IIesSt9tVzcEcdbEvLGVJkLk4mb3G30DbIbri\nPZ09JkweDvMaQ3bxT2nfkz3Ilihkw9jqikkCCCz7E8h6z6KbhQErEW9VzJZzMCgJsyPjFam6iNwpe07S\nhyOvNVw2t9wpzL5xM11DvVzQwDaWEytNRHzDBs4KwEtpI2IpjUyVZHSwA0UGqqkzoCgrJFlNOvPlXqcS\nIcREouUIBmuttkrhPWJtSxOOgpsdvBR3kTOzAXNzSKxoaBAb0c5SDMUc6FIyGA8x5wg5DkUgjFUUodEt\nOYaB2VHVePW9mxHeBTdKWLzJow4ZZvjnoBuVigXljKCNh137ckV2y3Yg3Xi4UzJEI2V5Rw9AfnMs7xUw\nVHOFCg189maD3bmZAe7b4eaGZhyy4HVKjqCXmIH7vsEjRvbnfB0SQxxpuqBDJbHNCtW4vM643ZQQBVPP\na7oXSQIq9w2dHp0A7dtkocCZdQp9FKR9XdJAFIbVSHzIF1ZogeZlc0pXuNE0tagvD57xwDRFkAuoQyMu\nYDdZasXrpSmEE5UjHVkyYsISn8QsfXurzDybX468aoRoks654jjmRY5zi1oB8TcMdC2c3sicNaqfeuhd\nH1nPX7l4RpdqWMR7gGx9slXtG8S3KxpOi4qCD7yg3saD66nun4dzksQURoTUdXyrJR5UpHsfIlTF1aJa\nMdXyQtQnrkl00TeghQd00rRFZsCnhi0qrCSKiBfB2EVrd9RPpbgwJGZHuIQecdBmNetc2ylSEClqVBPR\nGOPPIxrnswEZjmnS0jxKW9VSM1QVxSPJnPFswCqT95SoKD6CP4xdX28WIUGiNaIKodXXJHEIsXBCxLsr\nPwWPCtoplC6hhpKmW5dQo92iCTyY2KioKzO8XR6FKm6qonMKVEwQNtlYE9c97KMtEnp25VOdMP46SQXS\nYsSVp7vm8LP87VYI8SOKcW3s2oedYFtt45rvDzoTF0GmS6wELQ9uo98HhjQAI1Dt91cgjJOwygNmLoZE\nX5K2zQiNA163uMCl5xzaBqY4YTL0wgALg3IFdYSp0RFYLWdt6IxoGI1tnoxcjlUEPo5eGIc3mS3SmaLn\nOdumfUQQ4Jgmgaa5anUVQsfBDrlAN5oaX7O0JO71SSPSWiHBsT9WIPy2J1Cace9ZZLRxblFPSXcvsuHh\nhvnhWQltEDAe7MgvkFQ8lGVFa8jhzijoF9kLmMhMILSzYnfXnZPNP7TlAAwlLHK1RqlpHskJqb6CPpGP\nQvOAhEMsM3zJ2KejZx0esxkjxA0ZufVvGAMN3vTUMplQaF4RiQkp9fzBXf3CMk01dWjOMMIEXTeKzIQe\nEcffzjixWU9FpAyGp2rVl4ETRgqljOGw4UgK31r0ZIEGnH0xGz1FtbW1OcQM008JVujRqulCucEMmntr\n".to_owned()
-307
+            )
-308
+        )
         .send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Encoding", "gzip")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         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");
-317
+    }
-318
+}
-319
 /// Error type for the `PutWithContentEncodingError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum PutWithContentEncodingError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).

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

@@ -230,230 +370,376 @@

↥ Expand context

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

     use ::aws_smithy_protocol_test::FloatEquals;
-251
     /// Supports handling NaN float values.
     /// Test ID: AwsJson11SupportsNaNFloatInputs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_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");
-264
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .simple_scalar_properties()
             .set_float_value(::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number"),
             ))
             .set_double_value(::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number"),
             ))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.SimpleScalarProperties"),
         ];
         ::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,
             "{\n    \"floatValue\": \"NaN\",\n    \"doubleValue\": \"NaN\"\n}",
             ::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");
-292
+    }
-293
     /// Supports handling Infinity float values.
     /// Test ID: AwsJson11SupportsInfinityFloatInputs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_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");
-306
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .simple_scalar_properties()
             .set_float_value(::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number"),
             ))
             .set_double_value(::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number"),
             ))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.SimpleScalarProperties"),
         ];
         ::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,
             "{\n    \"floatValue\": \"Infinity\",\n    \"doubleValue\": \"Infinity\"\n}",
             ::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");
-334
+    }
-335
     /// Supports handling -Infinity float values.
     /// Test ID: AwsJson11SupportsNegativeInfinityFloatInputs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_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");
-348
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .simple_scalar_properties()
             .set_float_value(::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number"),
             ))
             .set_double_value(::std::option::Option::Some(
                 <f64 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 = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.SimpleScalarProperties"),
         ];
         ::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,
             "{\n    \"floatValue\": \"-Infinity\",\n    \"doubleValue\": \"-Infinity\"\n}",
             ::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");
-376
+    }

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

@@ -229,229 +328,332 @@

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

 mod sparse_nulls_operation_test {
-250
     /// Serializes null values in maps
     /// Test ID: AwsJson11SparseMapsSerializeNullValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_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");
-263
         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 = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.SparseNullsOperation"),
         ];
         ::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,
             "{\n    \"sparseStringMap\": {\n        \"foo\": null\n    }\n}",
             ::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");
-290
+    }
-291
     /// Serializes null values in lists
     /// Test ID: AwsJson11SparseListsSerializeNull
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_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");
-304
         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 = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.SparseNullsOperation"),
         ];
         ::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,
             "{\n    \"sparseStringList\": [\n        null\n    ]\n}",
             ::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");
-327
+    }
-328
     /// Deserializes null values in maps
     /// Test ID: AwsJson11SparseMapsDeserializeNullValues
     #[::tokio::test]
     #[::tracing_test::traced_test]

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

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

↥ Expand context

     ///     fn resolve_auth_scheme<'a>(
     ///         &'a self,
     ///         _params: &'a misc::config::auth::Params,
     ///         _cfg: &'a ConfigBag,
     ///         _runtime_components: &'a RuntimeComponents,
     ///     ) -> AuthSchemeOptionsFuture<'a> {
     ///         // --snip--
     /// #      todo!()
     ///     }
     /// }
     ///
     /// let config = misc::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 = misc::Config::builder()
     ///     .auth_scheme_preference([AuthSchemeId::from("scheme1"), AuthSchemeId::from("scheme2")])
     ///     // ...
     ///     .build();
     /// let client = misc::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

@@ -1196,1212 +1256,1273 @@

↥ Expand context

-1212
+    }
-1213
     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)
-1219
+    }
-1220
+}
-1221
 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;
-1225
 pub use ::aws_smithy_async::rt::sleep::Sleep;
-1227
 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")]

-1232
+    {
         if config.behavior_version.is_none() {
             config.behavior_version = Some(::aws_smithy_runtime_api::client::behavior_version::BehaviorVersion::latest());
-1235
+        }
-1236
+    }
-1237
     let default_retry_partition = "miscservice";
-1239
     let scope = "misc";
-1241
     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())
-1255
+                        )
                         // 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")
                         );
-1266
     for plugin in configured_plugins {
         plugins = plugins.with_client_plugin(plugin);
-1269
+    }
     plugins
-1271
+}
-1272
 pub use ::aws_smithy_types::config_bag::FrozenLayer;

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