Client Test

rev. a7fb2e3446d314cfbe48069306e4e0a389b39aeb

Files changed:

tmp-codegen-diff/codegen-client-test/rest_xml_namespace/rust-client-codegen/src/protocol_serde/shape_simple_scalar_properties.rs

@@ -17,17 +84,86 @@

-17
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_simple_scalar_properties_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput,
     crate::operation::simple_scalar_properties::SimpleScalarPropertiesError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::simple_scalar_properties::builders::SimpleScalarPropertiesOutputBuilder::default();
         output = crate::protocol_serde::shape_simple_scalar_properties::de_simple_scalar_properties(_response_body, output)
             .map_err(crate::operation::simple_scalar_properties::SimpleScalarPropertiesError::unhandled)?;
         output = output.set_foo(
             crate::protocol_serde::shape_simple_scalar_properties_output::de_foo_header(_response_headers).map_err(|_| {
                 crate::operation::simple_scalar_properties::SimpleScalarPropertiesError::unhandled("Failed to parse foo from header `X-Foo")
             })?,
         );

         output.build()
     })
-39
+}
-40
 pub fn ser_simple_scalar_properties_headers(
     input: &crate::operation::simple_scalar_properties::SimpleScalarPropertiesInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.foo {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "foo",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("X-Foo", header_value);
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "foo",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("X-Foo", header_value);
-+
+        }
-57
+    }
     Ok(builder)
-59
+}
-60
 pub fn ser_simple_scalar_properties_op_input(
     input: &crate::operation::simple_scalar_properties::SimpleScalarPropertiesInput,
 ) -> Result<::aws_smithy_types::body::SdkBody, ::aws_smithy_types::error::operation::SerializationError> {
     let mut out = String::new();
-65
+    {
         let mut writer = ::aws_smithy_xml::encode::XmlWriter::new(&mut out);

↧ Expand context

         #[allow(unused_mut)]
         let mut root = writer.start_el("SimpleScalarPropertiesInputOutput").write_ns("https://example.com", None);
         crate::protocol_serde::shape_simple_scalar_properties_input::ser_simple_scalar_properties_input_input_input(input, root)?
-70
+    }
     Ok(::aws_smithy_types::body::SdkBody::from(out))
-72
+}
-73
 #[allow(unused_mut)]
 pub fn de_simple_scalar_properties(
     inp: &[u8],
     mut builder: crate::operation::simple_scalar_properties::builders::SimpleScalarPropertiesOutputBuilder,
 ) -> Result<crate::operation::simple_scalar_properties::builders::SimpleScalarPropertiesOutputBuilder, ::aws_smithy_xml::decode::XmlDecodeError> {
     let mut doc = ::aws_smithy_xml::decode::Document::try_from(inp)?;
-80
     #[allow(unused_mut)]
     let mut decoder = doc.root_element()?;
     #[allow(unused_variables)]
     let start_el = decoder.start_el();
     if !start_el.matches("SimpleScalarPropertiesInputOutput") {
         return Err(::aws_smithy_xml::decode::XmlDecodeError::custom(format!(

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

@@ -150,150 +211,209 @@

↥ Expand context

     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::empty_input_output::EmptyInputOutputInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             fn uri_base(
                 _input: &crate::operation::empty_input_output::EmptyInputOutputInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/service/RpcV2Protocol/operation/EmptyInputOutput").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-166
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::empty_input_output::EmptyInputOutputInput,

                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-175
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/cbor");
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http::header::HeaderName::from_static("smithy-protocol"), "rpc-v2-cbor");
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http::header::HeaderName::from_static("accept"), "application/cbor");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_empty_input_output::ser_empty_input_output_input(&input)?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
-186
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-188
+    }
-189
+}

↧ Expand context

 #[derive(Debug)]
 struct EmptyInputOutputEndpointParamsInterceptor;
-192
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for EmptyInputOutputEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "EmptyInputOutputEndpointParamsInterceptor"
-196
+    }
-197
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()

@@ -213,211 +277,271 @@

↥ Expand context

             .ok_or("failed to downcast to EmptyInputOutputInput")?;
-212
         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(())
-219
+    }
-220
+}
-221
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-224
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod empty_input_output_test {
-228
     /// When Input structure is empty we write CBOR equivalent of {}
     /// Test ID: empty_input

     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn empty_input_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-236
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.empty_input_output().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Accept", "application/cbor"),
             ("Content-Type", "application/cbor"),
             ("smithy-protocol", "rpc-v2-cbor"),
         ];
         let expected_headers = [("Content-Type", "application/cbor"), ("smithy-protocol", "rpc-v2-cbor")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let forbidden_headers = &["X-Amz-Target"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::forbid_headers(http_request.headers(), forbidden_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "v/8=",
             ::aws_smithy_protocol_test::MediaType::from("application/cbor"),

↧ Expand context

         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/service/RpcV2Protocol/operation/EmptyInputOutput", "path was incorrect");
-256
+    }
-257
     /// When output structure is empty we write CBOR equivalent of {}
     /// Test ID: empty_output
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn empty_output_response() {
         let expected_output = crate::operation::empty_input_output::EmptyInputOutputOutput::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("Content-Type", "application/cbor")
                 .header("smithy-protocol", "rpc-v2-cbor")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("v/8="))
                 .unwrap(),
-271
+        )

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

@@ -139,139 +200,198 @@

↥ Expand context

         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input.downcast::<crate::operation::float16::Float16Input>().expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             fn uri_base(
                 _input: &crate::operation::float16::Float16Input,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/service/RpcV2Protocol/operation/Float16").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-156
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(

                 input: &crate::operation::float16::Float16Input,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-165
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http::header::HeaderName::from_static("smithy-protocol"), "rpc-v2-cbor");
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http::header::HeaderName::from_static("accept"), "application/cbor");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
-175
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-177
+    }
-178
+}

↧ Expand context

 #[derive(Debug)]
 struct Float16EndpointParamsInterceptor;
-181
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for Float16EndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "Float16EndpointParamsInterceptor"
-185
+    }
-186
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()

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

@@ -149,149 +210,208 @@

↥ Expand context

         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::fractional_seconds::FractionalSecondsInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             fn uri_base(
                 _input: &crate::operation::fractional_seconds::FractionalSecondsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/service/RpcV2Protocol/operation/FractionalSeconds").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-166
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(

                 input: &crate::operation::fractional_seconds::FractionalSecondsInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-175
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http::header::HeaderName::from_static("smithy-protocol"), "rpc-v2-cbor");
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http::header::HeaderName::from_static("accept"), "application/cbor");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
-185
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-187
+    }
-188
+}

↧ Expand context

 #[derive(Debug)]
 struct FractionalSecondsEndpointParamsInterceptor;
-191
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for FractionalSecondsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "FractionalSecondsEndpointParamsInterceptor"
-195
+    }
-196
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()

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

@@ -149,149 +210,208 @@

↥ Expand context

         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::greeting_with_errors::GreetingWithErrorsInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             fn uri_base(
                 _input: &crate::operation::greeting_with_errors::GreetingWithErrorsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/service/RpcV2Protocol/operation/GreetingWithErrors").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-166
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(

                 input: &crate::operation::greeting_with_errors::GreetingWithErrorsInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-175
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http::header::HeaderName::from_static("smithy-protocol"), "rpc-v2-cbor");
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http::header::HeaderName::from_static("accept"), "application/cbor");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
-185
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-187
+    }
-188
+}

↧ Expand context

 #[derive(Debug)]
 struct GreetingWithErrorsEndpointParamsInterceptor;
-191
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GreetingWithErrorsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GreetingWithErrorsEndpointParamsInterceptor"
-195
+    }
-196
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()

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

@@ -148,148 +209,207 @@

↥ Expand context

         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::no_input_output::NoInputOutputInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             fn uri_base(
                 _input: &crate::operation::no_input_output::NoInputOutputInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/service/RpcV2Protocol/operation/NoInputOutput").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-165
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(

                 input: &crate::operation::no_input_output::NoInputOutputInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-174
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http::header::HeaderName::from_static("smithy-protocol"), "rpc-v2-cbor");
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http::header::HeaderName::from_static("accept"), "application/cbor");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
-184
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-186
+    }
-187
+}

↧ Expand context

 #[derive(Debug)]
 struct NoInputOutputEndpointParamsInterceptor;
-190
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for NoInputOutputEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "NoInputOutputEndpointParamsInterceptor"
-194
+    }
-195
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()

@@ -211,209 +271,269 @@

↥ Expand context

             .ok_or("failed to downcast to NoInputOutputInput")?;
-210
         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(())
-217
+    }
-218
+}
-219
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-222
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod no_input_output_test {
-226
     /// Body is empty and no Content-Type header if no input
     /// Test ID: no_input

     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn no_input_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-234
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.no_input_output().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Accept", "application/cbor"), ("smithy-protocol", "rpc-v2-cbor")];
         let expected_headers = [("smithy-protocol", "rpc-v2-cbor")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let forbidden_headers = &["Content-Type", "X-Amz-Target"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::forbid_headers(http_request.headers(), forbidden_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &bytes::Bytes::new());
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/service/RpcV2Protocol/operation/NoInputOutput", "path was incorrect");
-249
+    }

↧ Expand context

-250
     /// A `Content-Type` header should not be set if the response body is empty.
     /// Test ID: no_output
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn no_output_response() {
         let expected_output = crate::operation::no_input_output::NoInputOutputOutput::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("smithy-protocol", "rpc-v2-cbor")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(""))
                 .unwrap(),
-263
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-267
         let op = crate::operation::no_input_output::NoInputOutput::new();
         let config = op.config().expect("the operation has config");

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

@@ -156,156 +217,215 @@

↥ Expand context

     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::operation_with_defaults::OperationWithDefaultsInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             fn uri_base(
                 _input: &crate::operation::operation_with_defaults::OperationWithDefaultsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/service/RpcV2Protocol/operation/OperationWithDefaults").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-172
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::operation_with_defaults::OperationWithDefaultsInput,

                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-181
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/cbor");
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http::header::HeaderName::from_static("smithy-protocol"), "rpc-v2-cbor");
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http::header::HeaderName::from_static("accept"), "application/cbor");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_operation_with_defaults::ser_operation_with_defaults_input(
             &input,
         )?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
-194
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())

↧ Expand context

-196
+    }
-197
+}
 #[derive(Debug)]
 struct OperationWithDefaultsEndpointParamsInterceptor;
-200
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for OperationWithDefaultsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "OperationWithDefaultsEndpointParamsInterceptor"
-204
+    }
-205
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {

@@ -227,225 +320,310 @@

↥ Expand context

             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-227
+    }
-228
+}
-229
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-232
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod operation_with_defaults_test {
     use ::aws_smithy_protocol_test::FloatEquals;
-237
     /// Client populates default values in input.
     /// Test ID: RpcV2CborClientPopulatesDefaultValuesInInput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     #[should_panic]
     async fn rpc_v2_cbor_client_populates_default_values_in_input_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);

         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-246
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .operation_with_defaults()
             .set_defaults(::std::option::Option::Some(crate::types::Defaults::builder().build()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Accept", "application/cbor"),
             ("Content-Type", "application/cbor"),
             ("smithy-protocol", "rpc-v2-cbor"),
         ];
         let expected_headers = [("Content-Type", "application/cbor"), ("smithy-protocol", "rpc-v2-cbor")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(
         ::aws_smithy_protocol_test::validate_body(body, "v2hkZWZhdWx0c79tZGVmYXVsdFN0cmluZ2JoaW5kZWZhdWx0Qm9vbGVhbvVrZGVmYXVsdExpc3Sf/3BkZWZhdWx0VGltZXN0YW1wwQBrZGVmYXVsdEJsb2JjYWJja2RlZmF1bHRCeXRlAWxkZWZhdWx0U2hvcnQBbmRlZmF1bHRJbnRlZ2VyCmtkZWZhdWx0TG9uZxhkbGRlZmF1bHRGbG9hdPo/gAAAbWRlZmF1bHREb3VibGX6P4AAAGpkZWZhdWx0TWFwv/9rZGVmYXVsdEVudW1jRk9PbmRlZmF1bHRJbnRFbnVtAWtlbXB0eVN0cmluZ2BsZmFsc2VCb29sZWFu9GllbXB0eUJsb2JgaHplcm9CeXRlAGl6ZXJvU2hvcnQAa3plcm9JbnRlZ2VyAGh6ZXJvTG9uZwBpemVyb0Zsb2F0+gAAAABqemVyb0RvdWJsZfoAAAAA//8=", ::aws_smithy_protocol_test::MediaType::from("application/cbor"))
         );
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/service/RpcV2Protocol/operation/OperationWithDefaults", "path was incorrect");
-266
+    }
-267
     /// Client skips top level default values in input.
     /// Test ID: RpcV2CborClientSkipsTopLevelDefaultValuesInInput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_client_skips_top_level_default_values_in_input_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-275
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.operation_with_defaults().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Accept", "application/cbor"),
             ("Content-Type", "application/cbor"),
             ("smithy-protocol", "rpc-v2-cbor"),
         ];
         let expected_headers = [("Content-Type", "application/cbor"), ("smithy-protocol", "rpc-v2-cbor")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "v/8=",
             ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

↧ Expand context

         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/service/RpcV2Protocol/operation/OperationWithDefaults", "path was incorrect");
-293
+    }
-294
     /// Client uses explicitly provided member values over defaults
     /// Test ID: RpcV2CborClientUsesExplicitlyProvidedMemberValuesOverDefaults
     #[::tokio::test]
     #[::tracing_test::traced_test]
     #[should_panic]
     async fn rpc_v2_cbor_client_uses_explicitly_provided_member_values_over_defaults_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-303
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .operation_with_defaults()
             .set_defaults(::std::option::Option::Some(
                 crate::types::Defaults::builder()
                     .set_default_string(::std::option::Option::Some("bye".to_owned()))
                     .set_default_boolean(::std::option::Option::Some(true))

@@ -324,314 +457,435 @@

↥ Expand context

                     .set_default_byte(::std::option::Option::Some(2))
                     .set_default_short(::std::option::Option::Some(2))
                     .set_default_integer(::std::option::Option::Some(20))
                     .set_default_long(::std::option::Option::Some(200))
                     .set_default_float(::std::option::Option::Some(2.0_f32))
                     .set_default_double(::std::option::Option::Some(2.0_f64))
                     .set_default_map(::std::option::Option::Some({
                         let mut ret = ::std::collections::HashMap::new();
                         ret.insert("name".to_owned(), "Jack".to_owned());
                         ret
                     }))
                     .set_default_enum(::std::option::Option::Some(
                         "BAR".parse::<crate::types::TestEnum>().expect("static value validated to member"),
                     ))
                     .set_default_int_enum(::std::option::Option::Some(2))
                     .set_empty_string(::std::option::Option::Some("foo".to_owned()))
                     .set_false_boolean(::std::option::Option::Some(true))
                     .set_empty_blob(::std::option::Option::Some(::aws_smithy_types::Blob::new("hi")))
                     .set_zero_byte(::std::option::Option::Some(1))
                     .set_zero_short(::std::option::Option::Some(1))

                     .set_zero_integer(::std::option::Option::Some(1))
                     .set_zero_long(::std::option::Option::Some(1))
                     .set_zero_float(::std::option::Option::Some(1.0_f32))
                     .set_zero_double(::std::option::Option::Some(1.0_f64))
                     .build(),
             ))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Accept", "application/cbor"),
             ("Content-Type", "application/cbor"),
             ("smithy-protocol", "rpc-v2-cbor"),
         ];
         let expected_headers = [("Content-Type", "application/cbor"), ("smithy-protocol", "rpc-v2-cbor")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(
         ::aws_smithy_protocol_test::validate_body(body, "v2hkZWZhdWx0c7dtZGVmYXVsdFN0cmluZ2NieWVuZGVmYXVsdEJvb2xlYW71a2RlZmF1bHRMaXN0gWFhcGRlZmF1bHRUaW1lc3RhbXDB+z/wAAAAAAAAa2RlZmF1bHRCbG9iQmhpa2RlZmF1bHRCeXRlAmxkZWZhdWx0U2hvcnQCbmRlZmF1bHRJbnRlZ2VyFGtkZWZhdWx0TG9uZxjIbGRlZmF1bHRGbG9hdPpAAAAAbWRlZmF1bHREb3VibGX7QAAAAAAAAABqZGVmYXVsdE1hcKFkbmFtZWRKYWNra2RlZmF1bHRFbnVtY0JBUm5kZWZhdWx0SW50RW51bQJrZW1wdHlTdHJpbmdjZm9vbGZhbHNlQm9vbGVhbvVpZW1wdHlCbG9iQmhpaHplcm9CeXRlAWl6ZXJvU2hvcnQBa3plcm9JbnRlZ2VyAWh6ZXJvTG9uZwFpemVyb0Zsb2F0+j+AAABqemVyb0RvdWJsZfs/8AAAAAAAAP8=", ::aws_smithy_protocol_test::MediaType::from("application/cbor"))
         );
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/service/RpcV2Protocol/operation/OperationWithDefaults", "path was incorrect");
-355
+    }
-356
     /// Any time a value is provided for a member in the top level of input, it is used, regardless of if its the default.
     /// Test ID: RpcV2CborClientUsesExplicitlyProvidedValuesInTopLevel
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_client_uses_explicitly_provided_values_in_top_level_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-364
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .operation_with_defaults()
             .set_top_level_default(::std::option::Option::Some("hi".to_owned()))
             .set_other_top_level_default(::std::option::Option::Some(0))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Accept", "application/cbor"),
             ("Content-Type", "application/cbor"),
             ("smithy-protocol", "rpc-v2-cbor"),
         ];
         let expected_headers = [("Content-Type", "application/cbor"), ("smithy-protocol", "rpc-v2-cbor")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "v290b3BMZXZlbERlZmF1bHRiaGl0b3RoZXJUb3BMZXZlbERlZmF1bHQA/w==",
             ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/service/RpcV2Protocol/operation/OperationWithDefaults", "path was incorrect");
-387
+    }
-388
     /// Typically, non top-level members would have defaults filled in, but if they have the clientOptional trait, the defaults should be ignored.
     /// Test ID: RpcV2CborClientIgnoresNonTopLevelDefaultsOnMembersWithClientOptional
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_client_ignores_non_top_level_defaults_on_members_with_client_optional_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-396
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .operation_with_defaults()
             .set_client_optional_defaults(::std::option::Option::Some(crate::types::ClientOptionalDefaults::builder().build()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Accept", "application/cbor"),
             ("Content-Type", "application/cbor"),
             ("smithy-protocol", "rpc-v2-cbor"),
         ];
         let expected_headers = [("Content-Type", "application/cbor"), ("smithy-protocol", "rpc-v2-cbor")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "v3ZjbGllbnRPcHRpb25hbERlZmF1bHRzoP8=",
             ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

↧ Expand context

         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/service/RpcV2Protocol/operation/OperationWithDefaults", "path was incorrect");
-418
+    }
-419
     /// Client populates default values when missing in response.
     /// Test ID: RpcV2CborClientPopulatesDefaultsValuesWhenMissingInResponse
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_client_populates_defaults_values_when_missing_in_response_response() {
         let expected_output = crate::operation::operation_with_defaults::OperationWithDefaultsOutput::builder()
             .set_default_string(::std::option::Option::Some("hi".to_owned()))
             .set_default_boolean(::std::option::Option::Some(true))
             .set_default_list(::std::option::Option::Some(vec![]))
             .set_default_timestamp(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(0, 0_f64)))
             .set_default_blob(::std::option::Option::Some(::aws_smithy_types::Blob::new("abc")))
             .set_default_byte(::std::option::Option::Some(1))
             .set_default_short(::std::option::Option::Some(1))
             .set_default_integer(::std::option::Option::Some(10))
             .set_default_long(::std::option::Option::Some(100))
             .set_default_float(::std::option::Option::Some(1.0_f32))

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

@@ -150,150 +211,209 @@

↥ Expand context

     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::optional_input_output::OptionalInputOutputInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             fn uri_base(
                 _input: &crate::operation::optional_input_output::OptionalInputOutputInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/service/RpcV2Protocol/operation/OptionalInputOutput").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-166
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::optional_input_output::OptionalInputOutputInput,

                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-175
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/cbor");
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http::header::HeaderName::from_static("smithy-protocol"), "rpc-v2-cbor");
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http::header::HeaderName::from_static("accept"), "application/cbor");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_optional_input_output::ser_optional_input_output_input(
             &input,
         )?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
-188
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())

↧ Expand context

-190
+    }
-191
+}
 #[derive(Debug)]
 struct OptionalInputOutputEndpointParamsInterceptor;
-194
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for OptionalInputOutputEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "OptionalInputOutputEndpointParamsInterceptor"
-198
+    }
-199
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {

@@ -215,213 +279,273 @@

↥ Expand context

             .ok_or("failed to downcast to OptionalInputOutputInput")?;
-214
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-221
+    }
-222
+}
-223
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-226
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod optional_input_output_test {
-230
     /// When input is empty we write CBOR equivalent of {}
     /// Test ID: optional_input

     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn optional_input_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-238
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.optional_input_output().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Accept", "application/cbor"),
             ("Content-Type", "application/cbor"),
             ("smithy-protocol", "rpc-v2-cbor"),
         ];
         let expected_headers = [("Content-Type", "application/cbor"), ("smithy-protocol", "rpc-v2-cbor")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let forbidden_headers = &["X-Amz-Target"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::forbid_headers(http_request.headers(), forbidden_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "v/8=",
             ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

↧ Expand context

         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/service/RpcV2Protocol/operation/OptionalInputOutput", "path was incorrect");
-256
+    }
-257
     /// When output is empty we write CBOR equivalent of {}
     /// Test ID: optional_output
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn optional_output_response() {
         let expected_output = crate::operation::optional_input_output::OptionalInputOutputOutput::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("Content-Type", "application/cbor")
                 .header("smithy-protocol", "rpc-v2-cbor")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("v/8="))
                 .unwrap(),
-271
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;

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

@@ -150,150 +211,209 @@

↥ Expand context

     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::recursive_shapes::RecursiveShapesInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             fn uri_base(
                 _input: &crate::operation::recursive_shapes::RecursiveShapesInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/service/RpcV2Protocol/operation/RecursiveShapes").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-166
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::recursive_shapes::RecursiveShapesInput,

                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-175
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/cbor");
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http::header::HeaderName::from_static("smithy-protocol"), "rpc-v2-cbor");
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http::header::HeaderName::from_static("accept"), "application/cbor");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_recursive_shapes::ser_recursive_shapes_input(&input)?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
-186
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-188
+    }
-189
+}

↧ Expand context

 #[derive(Debug)]
 struct RecursiveShapesEndpointParamsInterceptor;
-192
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for RecursiveShapesEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "RecursiveShapesEndpointParamsInterceptor"
-196
+    }
-197
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()

@@ -236,234 +300,294 @@

↥ Expand context

         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-236
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .recursive_shapes()
             .set_nested(::std::option::Option::Some(
                 crate::types::RecursiveShapesInputOutputNested1::builder()
                     .set_foo(::std::option::Option::Some("Foo1".to_owned()))
                     .set_nested(::std::option::Option::Some(::std::boxed::Box::new(
                         crate::types::RecursiveShapesInputOutputNested2::builder()
                             .set_bar(::std::option::Option::Some("Bar1".to_owned()))
                             .set_recursive_member(::std::option::Option::Some(
                                 crate::types::RecursiveShapesInputOutputNested1::builder()
                                     .set_foo(::std::option::Option::Some("Foo2".to_owned()))
                                     .set_nested(::std::option::Option::Some(::std::boxed::Box::new(
                                         crate::types::RecursiveShapesInputOutputNested2::builder()
                                             .set_bar(::std::option::Option::Some("Bar2".to_owned()))
                                             .build(),
                                     )))

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

↧ Expand context

         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/service/RpcV2Protocol/operation/RecursiveShapes", "path was incorrect");
-277
+    }
-278
     /// Serializes recursive structures
     /// Test ID: RpcV2CborRecursiveShapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_recursive_shapes_response() {
         let expected_output = crate::operation::recursive_shapes::RecursiveShapesOutput::builder()
             .set_nested(::std::option::Option::Some(
                 crate::types::RecursiveShapesInputOutputNested1::builder()
                     .set_foo(::std::option::Option::Some("Foo1".to_owned()))
                     .set_nested(::std::option::Option::Some(::std::boxed::Box::new(
                         crate::types::RecursiveShapesInputOutputNested2::builder()
                             .set_bar(::std::option::Option::Some("Bar1".to_owned()))
                             .set_recursive_member(::std::option::Option::Some(
                                 crate::types::RecursiveShapesInputOutputNested1::builder()
                                     .set_foo(::std::option::Option::Some("Foo2".to_owned()))
                                     .set_nested(::std::option::Option::Some(::std::boxed::Box::new(

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

@@ -150,150 +211,209 @@

↥ Expand context

     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::rpc_v2_cbor_dense_maps::RpcV2CborDenseMapsInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             fn uri_base(
                 _input: &crate::operation::rpc_v2_cbor_dense_maps::RpcV2CborDenseMapsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/service/RpcV2Protocol/operation/RpcV2CborDenseMaps").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-166
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::rpc_v2_cbor_dense_maps::RpcV2CborDenseMapsInput,

                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-175
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/cbor");
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http::header::HeaderName::from_static("smithy-protocol"), "rpc-v2-cbor");
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http::header::HeaderName::from_static("accept"), "application/cbor");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_rpc_v2_cbor_dense_maps::ser_rpc_v2_cbor_dense_maps_input(
             &input,
         )?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
-188
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())

↧ Expand context

-190
+    }
-191
+}
 #[derive(Debug)]
 struct RpcV2CborDenseMapsEndpointParamsInterceptor;
-194
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for RpcV2CborDenseMapsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "RpcV2CborDenseMapsEndpointParamsInterceptor"
-198
+    }
-199
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {

@@ -234,232 +382,368 @@

↥ Expand context

     /// Test ID: RpcV2CborMaps
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_maps_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-238
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .rpc_v2_cbor_dense_maps()
             .set_dense_struct_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "foo".to_owned(),
                     crate::types::GreetingStruct::builder()
                         .set_hi(::std::option::Option::Some("there".to_owned()))
                         .build(),
                 );
                 ret.insert(
                     "baz".to_owned(),

                     crate::types::GreetingStruct::builder()
                         .set_hi(::std::option::Option::Some("bye".to_owned()))
                         .build(),
                 );
                 ret
             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Accept", "application/cbor"),
             ("Content-Type", "application/cbor"),
             ("smithy-protocol", "rpc-v2-cbor"),
         ];
         let expected_headers = [("Content-Type", "application/cbor"), ("smithy-protocol", "rpc-v2-cbor")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "oW5kZW5zZVN0cnVjdE1hcKJjZm9voWJoaWV0aGVyZWNiYXqhYmhpY2J5ZQ==",
             ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/service/RpcV2Protocol/operation/RpcV2CborDenseMaps", "path was incorrect");
-275
+    }
-276
     /// Ensure that 0 and false are sent over the wire in all maps and lists
     /// Test ID: RpcV2CborSerializesZeroValuesInMaps
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_serializes_zero_values_in_maps_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-284
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .rpc_v2_cbor_dense_maps()
             .set_dense_number_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), 0);
                 ret
             }))
             .set_dense_boolean_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), false);
                 ret
             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Accept", "application/cbor"),
             ("Content-Type", "application/cbor"),
             ("smithy-protocol", "rpc-v2-cbor"),
         ];
         let expected_headers = [("Content-Type", "application/cbor"), ("smithy-protocol", "rpc-v2-cbor")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "om5kZW5zZU51bWJlck1hcKFheABvZGVuc2VCb29sZWFuTWFwoWF49A==",
             ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/service/RpcV2Protocol/operation/RpcV2CborDenseMaps", "path was incorrect");
-315
+    }
-316
     /// A request that contains a dense map of sets.
     /// Test ID: RpcV2CborSerializesDenseSetMap
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_serializes_dense_set_map_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-324
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .rpc_v2_cbor_dense_maps()
             .set_dense_set_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), vec![]);
                 ret.insert("y".to_owned(), vec!["a".to_owned(), "b".to_owned()]);
                 ret
             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Accept", "application/cbor"),
             ("Content-Type", "application/cbor"),
             ("smithy-protocol", "rpc-v2-cbor"),
         ];
         let expected_headers = [("Content-Type", "application/cbor"), ("smithy-protocol", "rpc-v2-cbor")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "oWtkZW5zZVNldE1hcKJheIBheYJhYWFi",
             ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

↧ Expand context

         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/service/RpcV2Protocol/operation/RpcV2CborDenseMaps", "path was incorrect");
-351
+    }
-352
     /// Deserializes maps
     /// Test ID: RpcV2CborMaps
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_maps_response() {
         let expected_output = crate::operation::rpc_v2_cbor_dense_maps::RpcV2CborDenseMapsOutput::builder()
             .set_dense_struct_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "foo".to_owned(),
                     crate::types::GreetingStruct::builder()
                         .set_hi(::std::option::Option::Some("there".to_owned()))
                         .build(),
                 );
                 ret.insert(
                     "baz".to_owned(),

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

@@ -150,150 +211,209 @@

↥ Expand context

     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::rpc_v2_cbor_lists::RpcV2CborListsInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             fn uri_base(
                 _input: &crate::operation::rpc_v2_cbor_lists::RpcV2CborListsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/service/RpcV2Protocol/operation/RpcV2CborLists").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-166
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::rpc_v2_cbor_lists::RpcV2CborListsInput,

                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-175
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/cbor");
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http::header::HeaderName::from_static("smithy-protocol"), "rpc-v2-cbor");
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http::header::HeaderName::from_static("accept"), "application/cbor");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_rpc_v2_cbor_lists::ser_rpc_v2_cbor_lists_input(&input)?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
-186
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-188
+    }
-189
+}

↧ Expand context

 #[derive(Debug)]
 struct RpcV2CborListsEndpointParamsInterceptor;
-192
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for RpcV2CborListsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "RpcV2CborListsEndpointParamsInterceptor"
-196
+    }
-197
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()

@@ -247,245 +379,365 @@

↥ Expand context

                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
             ]))
             .set_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_int_enum_list(::std::option::Option::Some(vec![1, 2]))
             .set_nested_string_list(::std::option::Option::Some(vec![
                 vec!["foo".to_owned(), "bar".to_owned()],
                 vec!["baz".to_owned(), "qux".to_owned()],
             ]))
             .set_structure_list(::std::option::Option::Some(vec![
                 crate::types::StructureListMember::builder()
                     .set_a(::std::option::Option::Some("1".to_owned()))
                     .set_b(::std::option::Option::Some("2".to_owned()))
                     .build(),
                 crate::types::StructureListMember::builder()
                     .set_a(::std::option::Option::Some("3".to_owned()))
                     .set_b(::std::option::Option::Some("4".to_owned()))

                     .build(),
             ]))
             .set_blob_list(::std::option::Option::Some(vec![
                 ::aws_smithy_types::Blob::new("foo"),
                 ::aws_smithy_types::Blob::new("bar"),
             ]))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Accept", "application/cbor"),
             ("Content-Type", "application/cbor"),
             ("smithy-protocol", "rpc-v2-cbor"),
         ];
         let expected_headers = [("Content-Type", "application/cbor"), ("smithy-protocol", "rpc-v2-cbor")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(
         ::aws_smithy_protocol_test::validate_body(body, "v2pzdHJpbmdMaXN0gmNmb29jYmFyaXN0cmluZ1NldIJjZm9vY2JhcmtpbnRlZ2VyTGlzdIIBAmtib29sZWFuTGlzdIL19G10aW1lc3RhbXBMaXN0gsH7QdTX+/OAAADB+0HU1/vzgAAAaGVudW1MaXN0gmNGb29hMGtpbnRFbnVtTGlzdIIBAnBuZXN0ZWRTdHJpbmdMaXN0goJjZm9vY2JhcoJjYmF6Y3F1eG1zdHJ1Y3R1cmVMaXN0gqJhYWExYWJhMqJhYWEzYWJhNGhibG9iTGlzdIJDZm9vQ2Jhcv8=", ::aws_smithy_protocol_test::MediaType::from("application/cbor"))
         );
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/service/RpcV2Protocol/operation/RpcV2CborLists", "path was incorrect");
-286
+    }
-287
     /// Serializes empty JSON lists
     /// Test ID: RpcV2CborListsEmpty
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_lists_empty_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-295
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .rpc_v2_cbor_lists()
             .set_string_list(::std::option::Option::Some(vec![]))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Accept", "application/cbor"),
             ("Content-Type", "application/cbor"),
             ("smithy-protocol", "rpc-v2-cbor"),
         ];
         let expected_headers = [("Content-Type", "application/cbor"), ("smithy-protocol", "rpc-v2-cbor")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "v2pzdHJpbmdMaXN0n///",
             ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/service/RpcV2Protocol/operation/RpcV2CborLists", "path was incorrect");
-317
+    }
-318
     /// Serializes empty JSON definite length lists
     /// Test ID: RpcV2CborListsEmptyUsingDefiniteLength
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_lists_empty_using_definite_length_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-326
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .rpc_v2_cbor_lists()
             .set_string_list(::std::option::Option::Some(vec![]))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Accept", "application/cbor"),
             ("Content-Type", "application/cbor"),
             ("smithy-protocol", "rpc-v2-cbor"),
         ];
         let expected_headers = [("Content-Type", "application/cbor"), ("smithy-protocol", "rpc-v2-cbor")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "oWpzdHJpbmdMaXN0gA==",
             ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

↧ Expand context

         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/service/RpcV2Protocol/operation/RpcV2CborLists", "path was incorrect");
-348
+    }
-349
     /// Serializes RpcV2 Cbor lists
     /// Test ID: RpcV2CborLists
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_lists_response() {
         let expected_output = crate::operation::rpc_v2_cbor_lists::RpcV2CborListsOutput::builder()
             .set_string_list(::std::option::Option::Some(vec!["foo".to_owned(), "bar".to_owned()]))
             .set_string_set(::std::option::Option::Some(vec!["foo".to_owned(), "bar".to_owned()]))
             .set_integer_list(::std::option::Option::Some(vec![1, 2]))
             .set_boolean_list(::std::option::Option::Some(vec![true, false]))
             .set_timestamp_list(::std::option::Option::Some(vec![
                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
             ]))
             .set_enum_list(::std::option::Option::Some(vec![
                 "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),

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

@@ -150,150 +211,209 @@

↥ Expand context

     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             fn uri_base(
                 _input: &crate::operation::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/service/RpcV2Protocol/operation/RpcV2CborSparseMaps").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-166
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsInput,

                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-175
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/cbor");
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http::header::HeaderName::from_static("smithy-protocol"), "rpc-v2-cbor");
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http::header::HeaderName::from_static("accept"), "application/cbor");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_rpc_v2_cbor_sparse_maps::ser_rpc_v2_cbor_sparse_maps_input(
             &input,
         )?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
-188
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())

↧ Expand context

-190
+    }
-191
+}
 #[derive(Debug)]
 struct RpcV2CborSparseMapsEndpointParamsInterceptor;
-194
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for RpcV2CborSparseMapsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "RpcV2CborSparseMapsEndpointParamsInterceptor"
-198
+    }
-199
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {

@@ -238,236 +481,459 @@

↥ Expand context

         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-238
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .rpc_v2_cbor_sparse_maps()
             .set_sparse_struct_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "foo".to_owned(),
                     ::std::option::Option::Some(
                         crate::types::GreetingStruct::builder()
                             .set_hi(::std::option::Option::Some("there".to_owned()))
                             .build(),
                     ),
                 );
                 ret.insert(
                     "baz".to_owned(),
                     ::std::option::Option::Some(
                         crate::types::GreetingStruct::builder()

                             .set_hi(::std::option::Option::Some("bye".to_owned()))
                             .build(),
                     ),
                 );
                 ret
             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Accept", "application/cbor"),
             ("Content-Type", "application/cbor"),
             ("smithy-protocol", "rpc-v2-cbor"),
         ];
         let expected_headers = [("Content-Type", "application/cbor"), ("smithy-protocol", "rpc-v2-cbor")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "v29zcGFyc2VTdHJ1Y3RNYXC/Y2Zvb79iaGlldGhlcmX/Y2Jher9iaGljYnll////",
             ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/service/RpcV2Protocol/operation/RpcV2CborSparseMaps", "path was incorrect");
-279
+    }
-280
     /// Serializes null map values in sparse maps
     /// Test ID: RpcV2CborSerializesNullMapValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_serializes_null_map_values_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-288
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .rpc_v2_cbor_sparse_maps()
             .set_sparse_boolean_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), ::std::option::Option::None);
                 ret
             }))
             .set_sparse_number_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), ::std::option::Option::None);
                 ret
             }))
             .set_sparse_string_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), ::std::option::Option::None);
                 ret
             }))
             .set_sparse_struct_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), ::std::option::Option::None);
                 ret
             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Accept", "application/cbor"),
             ("Content-Type", "application/cbor"),
             ("smithy-protocol", "rpc-v2-cbor"),
         ];
         let expected_headers = [("Content-Type", "application/cbor"), ("smithy-protocol", "rpc-v2-cbor")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "v3BzcGFyc2VCb29sZWFuTWFwv2F49v9vc3BhcnNlTnVtYmVyTWFwv2F49v9vc3BhcnNlU3RyaW5nTWFwv2F49v9vc3BhcnNlU3RydWN0TWFwv2F49v//",
             ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/service/RpcV2Protocol/operation/RpcV2CborSparseMaps", "path was incorrect");
-329
+    }
-330
     /// A request that contains a sparse map of sets
     /// Test ID: RpcV2CborSerializesSparseSetMap
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_serializes_sparse_set_map_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-338
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .rpc_v2_cbor_sparse_maps()
             .set_sparse_set_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), ::std::option::Option::Some(vec![]));
                 ret.insert("y".to_owned(), ::std::option::Option::Some(vec!["a".to_owned(), "b".to_owned()]));
                 ret
             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Accept", "application/cbor"),
             ("Content-Type", "application/cbor"),
             ("smithy-protocol", "rpc-v2-cbor"),
         ];
         let expected_headers = [("Content-Type", "application/cbor"), ("smithy-protocol", "rpc-v2-cbor")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "v2xzcGFyc2VTZXRNYXC/YXif/2F5n2FhYWL///8=",
             ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/service/RpcV2Protocol/operation/RpcV2CborSparseMaps", "path was incorrect");
-365
+    }
-366
     /// A request that contains a sparse map of sets.
     /// Test ID: RpcV2CborSerializesSparseSetMapAndRetainsNull
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_serializes_sparse_set_map_and_retains_null_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-374
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .rpc_v2_cbor_sparse_maps()
             .set_sparse_set_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), ::std::option::Option::Some(vec![]));
                 ret.insert("y".to_owned(), ::std::option::Option::Some(vec!["a".to_owned(), "b".to_owned()]));
                 ret.insert("z".to_owned(), ::std::option::Option::None);
                 ret
             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Accept", "application/cbor"),
             ("Content-Type", "application/cbor"),
             ("smithy-protocol", "rpc-v2-cbor"),
         ];
         let expected_headers = [("Content-Type", "application/cbor"), ("smithy-protocol", "rpc-v2-cbor")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "v2xzcGFyc2VTZXRNYXC/YXif/2F5n2FhYWL/YXr2//8=",
             ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/service/RpcV2Protocol/operation/RpcV2CborSparseMaps", "path was incorrect");
-402
+    }
-403
     /// Ensure that 0 and false are sent over the wire in all maps and lists
     /// Test ID: RpcV2CborSerializesZeroValuesInSparseMaps
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_serializes_zero_values_in_sparse_maps_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-411
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .rpc_v2_cbor_sparse_maps()
             .set_sparse_number_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), ::std::option::Option::Some(0));
                 ret
             }))
             .set_sparse_boolean_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), ::std::option::Option::Some(false));
                 ret
             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Accept", "application/cbor"),
             ("Content-Type", "application/cbor"),
             ("smithy-protocol", "rpc-v2-cbor"),
         ];
         let expected_headers = [("Content-Type", "application/cbor"), ("smithy-protocol", "rpc-v2-cbor")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "v29zcGFyc2VOdW1iZXJNYXC/YXgA/3BzcGFyc2VCb29sZWFuTWFwv2F49P//",
             ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

↧ Expand context

         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/service/RpcV2Protocol/operation/RpcV2CborSparseMaps", "path was incorrect");
-442
+    }
-443
     /// Deserializes sparse maps
     /// Test ID: RpcV2CborSparseJsonMaps
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_sparse_json_maps_response() {
         let expected_output = crate::operation::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsOutput::builder()
             .set_sparse_struct_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "foo".to_owned(),
                     ::std::option::Option::Some(
                         crate::types::GreetingStruct::builder()
                             .set_hi(::std::option::Option::Some("there".to_owned()))
                             .build(),
                     ),
                 );

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

@@ -156,156 +217,215 @@

↥ Expand context

     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::simple_scalar_properties::SimpleScalarPropertiesInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             fn uri_base(
                 _input: &crate::operation::simple_scalar_properties::SimpleScalarPropertiesInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/service/RpcV2Protocol/operation/SimpleScalarProperties").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-172
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::simple_scalar_properties::SimpleScalarPropertiesInput,

                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-181
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/cbor");
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http::header::HeaderName::from_static("smithy-protocol"), "rpc-v2-cbor");
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http::header::HeaderName::from_static("accept"), "application/cbor");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_simple_scalar_properties::ser_simple_scalar_properties_input(&input)?,
         );
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
-194
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())

↧ Expand context

-196
+    }
-197
+}
 #[derive(Debug)]
 struct SimpleScalarPropertiesEndpointParamsInterceptor;
-200
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for SimpleScalarPropertiesEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "SimpleScalarPropertiesEndpointParamsInterceptor"
-204
+    }
-205
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {

@@ -235,233 +468,446 @@

↥ Expand context

 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod simple_scalar_properties_test {
     use ::aws_smithy_protocol_test::FloatEquals;
-237
     /// Serializes simple scalar properties
     /// Test ID: RpcV2CborSimpleScalarProperties
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_simple_scalar_properties_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-245
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .simple_scalar_properties()
             .set_byte_value(::std::option::Option::Some(5))
             .set_double_value(::std::option::Option::Some(1.889_f64))
             .set_false_boolean_value(::std::option::Option::Some(false))
             .set_float_value(::std::option::Option::Some(7.625_f32))

             .set_integer_value(::std::option::Option::Some(256))
             .set_long_value(::std::option::Option::Some(9873))
             .set_short_value(::std::option::Option::Some(9898))
             .set_string_value(::std::option::Option::Some("simple".to_owned()))
             .set_true_boolean_value(::std::option::Option::Some(true))
             .set_blob_value(::std::option::Option::Some(::aws_smithy_types::Blob::new("foo")))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Accept", "application/cbor"),
             ("Content-Type", "application/cbor"),
             ("smithy-protocol", "rpc-v2-cbor"),
         ];
         let expected_headers = [("Content-Type", "application/cbor"), ("smithy-protocol", "rpc-v2-cbor")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(
         ::aws_smithy_protocol_test::validate_body(body, "v2lieXRlVmFsdWUFa2RvdWJsZVZhbHVl+z/+OVgQYk3TcWZhbHNlQm9vbGVhblZhbHVl9GpmbG9hdFZhbHVl+kD0AABsaW50ZWdlclZhbHVlGQEAaWxvbmdWYWx1ZRkmkWpzaG9ydFZhbHVlGSaqa3N0cmluZ1ZhbHVlZnNpbXBsZXB0cnVlQm9vbGVhblZhbHVl9WlibG9iVmFsdWVDZm9v/w==", ::aws_smithy_protocol_test::MediaType::from("application/cbor"))
         );
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(
             uri.path(),
             "/service/RpcV2Protocol/operation/SimpleScalarProperties",
             "path was incorrect"
         );
-278
+    }
-279
     /// RpcV2 Cbor should not serialize null structure values
     /// Test ID: RpcV2CborClientDoesntSerializeNullStructureValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_client_doesnt_serialize_null_structure_values_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-287
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .simple_scalar_properties()
             .set_string_value(::std::option::Option::None)
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Accept", "application/cbor"),
             ("Content-Type", "application/cbor"),
             ("smithy-protocol", "rpc-v2-cbor"),
         ];
         let expected_headers = [("Content-Type", "application/cbor"), ("smithy-protocol", "rpc-v2-cbor")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "v/8=",
             ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(
             uri.path(),
             "/service/RpcV2Protocol/operation/SimpleScalarProperties",
             "path was incorrect"
         );
-313
+    }
-314
     /// Supports handling NaN float values.
     /// Test ID: RpcV2CborSupportsNaNFloatInputs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_supports_na_n_float_inputs_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-322
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .simple_scalar_properties()
             .set_double_value(::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number"),
             ))
             .set_float_value(::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number"),
             ))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Accept", "application/cbor"),
             ("Content-Type", "application/cbor"),
             ("smithy-protocol", "rpc-v2-cbor"),
         ];
         let expected_headers = [("Content-Type", "application/cbor"), ("smithy-protocol", "rpc-v2-cbor")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "v2tkb3VibGVWYWx1Zft/+AAAAAAAAGpmbG9hdFZhbHVl+n/AAAD/",
             ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(
             uri.path(),
             "/service/RpcV2Protocol/operation/SimpleScalarProperties",
             "path was incorrect"
         );
-353
+    }
-354
     /// Supports handling Infinity float values.
     /// Test ID: RpcV2CborSupportsInfinityFloatInputs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_supports_infinity_float_inputs_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-362
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .simple_scalar_properties()
             .set_double_value(::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number"),
             ))
             .set_float_value(::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number"),
             ))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Accept", "application/cbor"),
             ("Content-Type", "application/cbor"),
             ("smithy-protocol", "rpc-v2-cbor"),
         ];
         let expected_headers = [("Content-Type", "application/cbor"), ("smithy-protocol", "rpc-v2-cbor")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "v2tkb3VibGVWYWx1Zft/8AAAAAAAAGpmbG9hdFZhbHVl+n+AAAD/",
             ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(
             uri.path(),
             "/service/RpcV2Protocol/operation/SimpleScalarProperties",
             "path was incorrect"
         );
-393
+    }
-394
     /// Supports handling Infinity float values.
     /// Test ID: RpcV2CborSupportsNegativeInfinityFloatInputs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_supports_negative_infinity_float_inputs_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-402
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .simple_scalar_properties()
             .set_double_value(::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number"),
             ))
             .set_float_value(::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number"),
             ))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Accept", "application/cbor"),
             ("Content-Type", "application/cbor"),
             ("smithy-protocol", "rpc-v2-cbor"),
         ];
         let expected_headers = [("Content-Type", "application/cbor"), ("smithy-protocol", "rpc-v2-cbor")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "v2tkb3VibGVWYWx1Zfv/8AAAAAAAAGpmbG9hdFZhbHVl+v+AAAD/",
             ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

↧ Expand context

         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(
             uri.path(),
             "/service/RpcV2Protocol/operation/SimpleScalarProperties",
             "path was incorrect"
         );
-433
+    }
-434
     /// Serializes simple scalar properties
     /// Test ID: RpcV2CborSimpleScalarProperties
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_simple_scalar_properties_response() {
         let expected_output = crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput::builder()
             .set_true_boolean_value(::std::option::Option::Some(true))
             .set_false_boolean_value(::std::option::Option::Some(false))
             .set_byte_value(::std::option::Option::Some(5))
             .set_double_value(::std::option::Option::Some(1.889_f64))
             .set_float_value(::std::option::Option::Some(7.625_f32))
             .set_integer_value(::std::option::Option::Some(256))

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

@@ -156,156 +217,215 @@

↥ Expand context

     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::sparse_nulls_operation::SparseNullsOperationInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             fn uri_base(
                 _input: &crate::operation::sparse_nulls_operation::SparseNullsOperationInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/service/RpcV2Protocol/operation/SparseNullsOperation").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-172
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::sparse_nulls_operation::SparseNullsOperationInput,

                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-181
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/cbor");
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http::header::HeaderName::from_static("smithy-protocol"), "rpc-v2-cbor");
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http::header::HeaderName::from_static("accept"), "application/cbor");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_sparse_nulls_operation::ser_sparse_nulls_operation_input(
             &input,
         )?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
-194
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())

↧ Expand context

-196
+    }
-197
+}
 #[derive(Debug)]
 struct SparseNullsOperationEndpointParamsInterceptor;
-200
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for SparseNullsOperationEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "SparseNullsOperationEndpointParamsInterceptor"
-204
+    }
-205
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {

@@ -229,227 +328,318 @@

↥ Expand context

-227
+    }
-228
+}
-229
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-232
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod sparse_nulls_operation_test {
-236
     /// Serializes null values in maps
     /// Test ID: RpcV2CborSparseMapsSerializeNullValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_sparse_maps_serialize_null_values_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-244
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client

             .sparse_nulls_operation()
             .set_sparse_string_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("foo".to_owned(), ::std::option::Option::None);
                 ret
             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Accept", "application/cbor"),
             ("Content-Type", "application/cbor"),
             ("smithy-protocol", "rpc-v2-cbor"),
         ];
         let expected_headers = [("Content-Type", "application/cbor"), ("smithy-protocol", "rpc-v2-cbor")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "v29zcGFyc2VTdHJpbmdNYXC/Y2Zvb/b//w==",
             ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/service/RpcV2Protocol/operation/SparseNullsOperation", "path was incorrect");
-270
+    }
-271
     /// Serializes null values in lists
     /// Test ID: RpcV2CborSparseListsSerializeNull
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_sparse_lists_serialize_null_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-279
         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();
         let expected_headers = [
             ("Accept", "application/cbor"),
             ("Content-Type", "application/cbor"),
             ("smithy-protocol", "rpc-v2-cbor"),
         ];
         let expected_headers = [("Content-Type", "application/cbor"), ("smithy-protocol", "rpc-v2-cbor")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "v3BzcGFyc2VTdHJpbmdMaXN0n/b//w==",
             ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

↧ Expand context

         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/service/RpcV2Protocol/operation/SparseNullsOperation", "path was incorrect");
-301
+    }
-302
     /// Deserializes null values in maps
     /// Test ID: RpcV2CborSparseMapsDeserializeNullValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_sparse_maps_deserialize_null_values_response() {
         let expected_output = crate::operation::sparse_nulls_operation::SparseNullsOperationOutput::builder()
             .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
             }))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("Content-Type", "application/cbor")
                 .header("smithy-protocol", "rpc-v2-cbor")

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

@@ -156,156 +217,215 @@

↥ Expand context

     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::complex_struct_operation::ComplexStructOperationInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             fn uri_base(
                 _input: &crate::operation::complex_struct_operation::ComplexStructOperationInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/service/RpcV2CborService/operation/ComplexStructOperation").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-172
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::complex_struct_operation::ComplexStructOperationInput,

                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-181
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/cbor");
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http::header::HeaderName::from_static("smithy-protocol"), "rpc-v2-cbor");
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http::header::HeaderName::from_static("accept"), "application/cbor");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_complex_struct_operation::ser_complex_struct_operation_input(&input)?,
         );
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
-194
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())

↧ Expand context

-196
+    }
-197
+}
 #[derive(Debug)]
 struct ComplexStructOperationEndpointParamsInterceptor;
-200
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ComplexStructOperationEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ComplexStructOperationEndpointParamsInterceptor"
-204
+    }
-205
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {

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

@@ -156,156 +217,215 @@

↥ Expand context

     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::empty_struct_operation::EmptyStructOperationInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             fn uri_base(
                 _input: &crate::operation::empty_struct_operation::EmptyStructOperationInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/service/RpcV2CborService/operation/EmptyStructOperation").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-172
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::empty_struct_operation::EmptyStructOperationInput,

                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-181
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/cbor");
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http::header::HeaderName::from_static("smithy-protocol"), "rpc-v2-cbor");
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http::header::HeaderName::from_static("accept"), "application/cbor");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_empty_struct_operation::ser_empty_struct_operation_input(
             &input,
         )?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
-194
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())

↧ Expand context

-196
+    }
-197
+}
 #[derive(Debug)]
 struct EmptyStructOperationEndpointParamsInterceptor;
-200
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for EmptyStructOperationEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "EmptyStructOperationEndpointParamsInterceptor"
-204
+    }
-205
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {

Pages: 1 2 3 4 5 6