Client Test

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

@@ -157,157 +236,239 @@

-157
+}
 #[derive(Debug)]
 struct RecursiveUnionOperationRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for RecursiveUnionOperationRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &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::recursive_union_operation::RecursiveUnionOperationInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(

                 _input: &crate::operation::recursive_union_operation::RecursiveUnionOperationInput,
                 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/RecursiveUnionOperation").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-183
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::recursive_union_operation::RecursiveUnionOperationInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::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))
-192
+            }
             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");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/cbor");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::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");
                 _header_serialization_settings.set_default_header(builder, ::http_1x::header::HeaderName::from_static("accept"), "application/cbor");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_recursive_union_operation::ser_recursive_union_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);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-210
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-212
+    }
-213
+}
 #[derive(Debug)]
 struct RecursiveUnionOperationEndpointParamsInterceptor;
-216
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for RecursiveUnionOperationEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "RecursiveUnionOperationEndpointParamsInterceptor"

↧ Expand context

-220
+    }
-221
     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()
             .downcast_ref::<RecursiveUnionOperationInput>()
             .ok_or("failed to downcast to RecursiveUnionOperationInput")?;
-236
         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)
         })?;

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

@@ -157,157 +236,239 @@

↥ Expand context

-157
+}
 #[derive(Debug)]
 struct SimpleStructOperationRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for SimpleStructOperationRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &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::simple_struct_operation::SimpleStructOperationInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(

                 _input: &crate::operation::simple_struct_operation::SimpleStructOperationInput,
                 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/SimpleStructOperation").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-183
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::simple_struct_operation::SimpleStructOperationInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::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))
-192
+            }
             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");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/cbor");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::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");
                 _header_serialization_settings.set_default_header(builder, ::http_1x::header::HeaderName::from_static("accept"), "application/cbor");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_simple_struct_operation::ser_simple_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);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-210
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-212
+    }
-213
+}
 #[derive(Debug)]
 struct SimpleStructOperationEndpointParamsInterceptor;
-216
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for SimpleStructOperationEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "SimpleStructOperationEndpointParamsInterceptor"

↧ Expand context

-220
+    }
-221
     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()
             .downcast_ref::<SimpleStructOperationInput>()
             .ok_or("failed to downcast to SimpleStructOperationInput")?;
-236
         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)
         })?;

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

@@ -157,157 +236,239 @@

↥ Expand context

-157
+}
 #[derive(Debug)]
 struct SingleMemberStructOperationRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for SingleMemberStructOperationRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &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::single_member_struct_operation::SingleMemberStructOperationInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(

                 _input: &crate::operation::single_member_struct_operation::SingleMemberStructOperationInput,
                 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/SingleMemberStructOperation").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-183
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::single_member_struct_operation::SingleMemberStructOperationInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::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))
-192
+            }
             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");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/cbor");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::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");
                 _header_serialization_settings.set_default_header(builder, ::http_1x::header::HeaderName::from_static("accept"), "application/cbor");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_single_member_struct_operation::ser_single_member_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);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-210
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-212
+    }
-213
+}
 #[derive(Debug)]
 struct SingleMemberStructOperationEndpointParamsInterceptor;
-216
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for SingleMemberStructOperationEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "SingleMemberStructOperationEndpointParamsInterceptor"

↧ Expand context

-220
+    }
-221
     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()
             .downcast_ref::<SingleMemberStructOperationInput>()
             .ok_or("failed to downcast to SingleMemberStructOperationInput")?;
-236
         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)
         })?;

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

@@ -167,167 +257,261 @@

↥ Expand context

-167
+}
 #[derive(Debug)]
 struct StreamingOperationRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for StreamingOperationRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &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::streaming_operation::StreamingOperationInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(

                 _input: &crate::operation::streaming_operation::StreamingOperationInput,
                 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/StreamingOperation").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-193
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::streaming_operation::StreamingOperationInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::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))
-202
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/vnd.amazon.eventstream");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http::header::HeaderName::from_static("smithy-protocol"), "rpc-v2-cbor");
                 _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/vnd.amazon.eventstream");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http::header::HeaderName::from_static("accept"),
                 ::http_1x::header::HeaderName::from_static("smithy-protocol"),
                 "rpc-v2-cbor",
             );
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("accept"),
                 "application/vnd.amazon.eventstream, application/cbor",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from({
             let error_marshaller = crate::event_stream_serde::EventsErrorMarshaller::new();
             let marshaller = crate::event_stream_serde::EventsMarshaller::new();
             let (signer, signer_sender) = ::aws_smithy_eventstream::frame::DeferredSigner::new();
             _cfg.interceptor_state().store_put(signer_sender);
             ::aws_smithy_types::body::SdkBody::from_body_0_4(::hyper::Body::wrap_stream(input.events.into_body_stream(
                 marshaller,
                 error_marshaller,
                 signer,
             )))
         });
         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);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-232
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-234
+    }
-235
+}
 #[derive(Debug)]
 struct StreamingOperationEndpointParamsInterceptor;
-238
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for StreamingOperationEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "StreamingOperationEndpointParamsInterceptor"

↧ Expand context

-242
+    }
-243
     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()
             .downcast_ref::<StreamingOperationInput>()
             .ok_or("failed to downcast to StreamingOperationInput")?;
-258
         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)
         })?;

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

@@ -169,169 +265,269 @@

↥ Expand context

-169
+}
 #[derive(Debug)]
 struct StreamingOperationWithInitialDataRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for StreamingOperationWithInitialDataRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &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::streaming_operation_with_initial_data::StreamingOperationWithInitialDataInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(

                 _input: &crate::operation::streaming_operation_with_initial_data::StreamingOperationWithInitialDataInput,
                 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/StreamingOperationWithInitialData").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-195
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::streaming_operation_with_initial_data::StreamingOperationWithInitialDataInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::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))
-204
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/vnd.amazon.eventstream");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http::header::HeaderName::from_static("smithy-protocol"), "rpc-v2-cbor");
                 _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/vnd.amazon.eventstream");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http::header::HeaderName::from_static("accept"),
                 ::http_1x::header::HeaderName::from_static("smithy-protocol"),
                 "rpc-v2-cbor",
             );
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("accept"),
                 "application/vnd.amazon.eventstream, application/cbor",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from({
             let error_marshaller = crate::event_stream_serde::EventsErrorMarshaller::new();
             let marshaller = crate::event_stream_serde::EventsMarshaller::new();
             let (signer, signer_sender) = ::aws_smithy_eventstream::frame::DeferredSigner::new();
             _cfg.interceptor_state().store_put(signer_sender);
             ::aws_smithy_types::body::SdkBody::from_body_0_4(::hyper::Body::wrap_stream({
                 use ::futures_util::StreamExt;
                 let body =
                     crate::protocol_serde::shape_streaming_operation_with_initial_data::ser_streaming_operation_with_initial_data_input(&input)?;
                 let initial_message = crate::event_stream_serde::initial_message_from_body(body);
                 let mut buffer = ::std::vec::Vec::new();
                 ::aws_smithy_eventstream::frame::write_message_to(&initial_message, &mut buffer)?;
                 let initial_message_stream = futures_util::stream::iter(vec![Ok(buffer.into())]);
                 let adapter = input.events.into_body_stream(marshaller, error_marshaller, signer);
                 initial_message_stream.chain(adapter)
             }))
         });
         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);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-240
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-242
+    }
-243
+}
 #[derive(Debug)]
 struct StreamingOperationWithInitialDataEndpointParamsInterceptor;
-246
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for StreamingOperationWithInitialDataEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "StreamingOperationWithInitialDataEndpointParamsInterceptor"

↧ Expand context

-250
+    }
-251
     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()
             .downcast_ref::<StreamingOperationWithInitialDataInput>()
             .ok_or("failed to downcast to StreamingOperationWithInitialDataInput")?;
-266
         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)
         })?;

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

@@ -172,172 +262,266 @@

↥ Expand context

 #[derive(Debug)]
 struct StreamingOperationWithInitialResponseRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for StreamingOperationWithInitialResponseRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &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::streaming_operation_with_initial_response::StreamingOperationWithInitialResponseInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::streaming_operation_with_initial_response::StreamingOperationWithInitialResponseInput,

                 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/StreamingOperationWithInitialResponse")
                     .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-198
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::streaming_operation_with_initial_response::StreamingOperationWithInitialResponseInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::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))
-207
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/vnd.amazon.eventstream");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http::header::HeaderName::from_static("smithy-protocol"), "rpc-v2-cbor");
                 _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/vnd.amazon.eventstream");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http::header::HeaderName::from_static("accept"),
                 ::http_1x::header::HeaderName::from_static("smithy-protocol"),
                 "rpc-v2-cbor",
             );
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("accept"),
                 "application/vnd.amazon.eventstream, application/cbor",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from({
             let error_marshaller = crate::event_stream_serde::EventsErrorMarshaller::new();
             let marshaller = crate::event_stream_serde::EventsMarshaller::new();
             let (signer, signer_sender) = ::aws_smithy_eventstream::frame::DeferredSigner::new();
             _cfg.interceptor_state().store_put(signer_sender);
             ::aws_smithy_types::body::SdkBody::from_body_0_4(::hyper::Body::wrap_stream(input.events.into_body_stream(
                 marshaller,
                 error_marshaller,
                 signer,
             )))
         });
         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);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-237
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-239
+    }
-240
+}
 #[derive(Debug)]
 struct StreamingOperationWithInitialResponseEndpointParamsInterceptor;
-243
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for StreamingOperationWithInitialResponseEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "StreamingOperationWithInitialResponseEndpointParamsInterceptor"

↧ Expand context

-247
+    }
-248
     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()
             .downcast_ref::<StreamingOperationWithInitialResponseInput>()
             .ok_or("failed to downcast to StreamingOperationWithInitialResponseInput")?;
-263
         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)
         })?;

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

@@ -169,169 +265,269 @@

↥ Expand context

-169
+}
 #[derive(Debug)]
 struct StreamingOperationWithOptionalDataRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for StreamingOperationWithOptionalDataRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &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::streaming_operation_with_optional_data::StreamingOperationWithOptionalDataInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(

                 _input: &crate::operation::streaming_operation_with_optional_data::StreamingOperationWithOptionalDataInput,
                 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/StreamingOperationWithOptionalData").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-195
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::streaming_operation_with_optional_data::StreamingOperationWithOptionalDataInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::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))
-204
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/vnd.amazon.eventstream");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http::header::HeaderName::from_static("smithy-protocol"), "rpc-v2-cbor");
                 _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/vnd.amazon.eventstream");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http::header::HeaderName::from_static("accept"),
                 ::http_1x::header::HeaderName::from_static("smithy-protocol"),
                 "rpc-v2-cbor",
             );
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("accept"),
                 "application/vnd.amazon.eventstream, application/cbor",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from({
             let error_marshaller = crate::event_stream_serde::EventsErrorMarshaller::new();
             let marshaller = crate::event_stream_serde::EventsMarshaller::new();
             let (signer, signer_sender) = ::aws_smithy_eventstream::frame::DeferredSigner::new();
             _cfg.interceptor_state().store_put(signer_sender);
             ::aws_smithy_types::body::SdkBody::from_body_0_4(::hyper::Body::wrap_stream({
                 use ::futures_util::StreamExt;
                 let body =
                     crate::protocol_serde::shape_streaming_operation_with_optional_data::ser_streaming_operation_with_optional_data_input(&input)?;
                 let initial_message = crate::event_stream_serde::initial_message_from_body(body);
                 let mut buffer = ::std::vec::Vec::new();
                 ::aws_smithy_eventstream::frame::write_message_to(&initial_message, &mut buffer)?;
                 let initial_message_stream = futures_util::stream::iter(vec![Ok(buffer.into())]);
                 let adapter = input.events.into_body_stream(marshaller, error_marshaller, signer);
                 initial_message_stream.chain(adapter)
             }))
         });
         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);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-240
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-242
+    }
-243
+}
 #[derive(Debug)]
 struct StreamingOperationWithOptionalDataEndpointParamsInterceptor;
-246
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for StreamingOperationWithOptionalDataEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "StreamingOperationWithOptionalDataEndpointParamsInterceptor"

↧ Expand context

-250
+    }
-251
     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()
             .downcast_ref::<StreamingOperationWithOptionalDataInput>()
             .ok_or("failed to downcast to StreamingOperationWithOptionalDataInput")?;
-266
         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)
         })?;

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

@@ -1,1 +78,83 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-6
 #![allow(dead_code)]
-8
 use aws_smithy_http::header::set_request_header_if_absent;
 use aws_smithy_types::config_bag::{Storable, StoreReplace};
 use http::header::{HeaderName, CONTENT_LENGTH, CONTENT_TYPE};
 use http_1x::header::{HeaderName, CONTENT_LENGTH, CONTENT_TYPE};
-12
 /// Configuration for how default protocol headers are serialized
 #[derive(Clone, Debug, Default)]
 pub(crate) struct HeaderSerializationSettings {
     omit_default_content_length: bool,
     omit_default_content_type: bool,
-18
+}
-19
 impl HeaderSerializationSettings {
     /// Creates new [`HeaderSerializationSettings`]
     pub(crate) fn new() -> Self {
         Default::default()
-24
+    }
-25
     /// Omit the default `Content-Length` header during serialization
     pub(crate) fn omit_default_content_length(self) -> Self {
         Self {
             omit_default_content_length: true,
             ..self
-31
+        }
-32
+    }
-33
     /// Omit the default `Content-Type` header during serialization
     pub(crate) fn omit_default_content_type(self) -> Self {
         Self {
             omit_default_content_type: true,
             ..self
-39
+        }
-40
+    }
-41
     /// Returns true if the given default header name should be serialized
     fn include_header(&self, header: &HeaderName) -> bool {
         (!self.omit_default_content_length || header != CONTENT_LENGTH) && (!self.omit_default_content_type || header != CONTENT_TYPE)
-45
+    }
-46
     /// Sets a default header on the given request builder if it should be serialized
     pub(crate) fn set_default_header(&self, mut request: http::request::Builder, header_name: HeaderName, value: &str) -> http::request::Builder {
     pub(crate) fn set_default_header(
         &self,
         mut request: http_1x::request::Builder,
         header_name: HeaderName,
         value: &str,
     ) -> http_1x::request::Builder {
         if self.include_header(&header_name) {
             request = set_request_header_if_absent(request, header_name, value);
-56
+        }
         request
-58
+    }
-59
+}
-60
 impl Storable for HeaderSerializationSettings {
     type Storer = StoreReplace<Self>;
-63
+}

↧ Expand context

-64
 #[cfg(test)]
 mod tests {
     use super::*;
-68
     #[test]
     fn test_include_header() {
         let settings = HeaderSerializationSettings::default();
         assert!(settings.include_header(&CONTENT_LENGTH));
         assert!(settings.include_header(&CONTENT_TYPE));
-74
         let settings = HeaderSerializationSettings::default().omit_default_content_length();
         assert!(!settings.include_header(&CONTENT_LENGTH));
         assert!(settings.include_header(&CONTENT_TYPE));
-78
         let settings = HeaderSerializationSettings::default().omit_default_content_type();
         assert!(settings.include_header(&CONTENT_LENGTH));
         assert!(!settings.include_header(&CONTENT_TYPE));
-82
         let settings = HeaderSerializationSettings::default()

tmp-codegen-diff/codegen-client-test/rpcv2cbor_non_query_compatible/rust-client-codegen/Cargo.toml

@@ -1,1 +56,60 @@

↥ Expand context

 # Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 [package]
 name = "rpcv2cbor_non_query_compatible"
 version = "0.0.1"
 authors = ["protocoltest@example.com"]
 description = "test"
 edition = "2021"
-8
 [package.metadata.smithy]
 codegen-version = "ci"
 protocol = "smithy.protocols#rpcv2Cbor"
 [dependencies.aws-smithy-async]

 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-async"
 [dependencies.aws-smithy-cbor]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-cbor"
 [dependencies.aws-smithy-http]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http"
 [dependencies.aws-smithy-runtime]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime"
 features = ["client"]
 [dependencies.aws-smithy-runtime-api]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime-api"
 features = ["client", "http-02x"]
 features = ["client", "http-1x"]
 [dependencies.aws-smithy-types]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-types"
 features = ["http-body-1-x"]
 [dependencies.fastrand]
 version = "2.0.0"
 [dependencies.http]
 version = "0.2.9"
 [dependencies.http-1x]
 version = "1"
 package = "http"
 [dependencies.tracing]
 version = "0.1"
 [dev-dependencies.aws-smithy-http-client]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http-client"
 features = ["test-util"]
 [dev-dependencies.aws-smithy-protocol-test]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-protocol-test"
 [dev-dependencies.bytes]
 version = "1.4.0"
 [dev-dependencies.pretty_assertions]

↧ Expand context

 version = "1.3.0"
 [dev-dependencies.tokio]
 version = "1.23.1"
 features = ["macros", "test-util", "rt-multi-thread"]
 [dev-dependencies.tracing-test]
 version = "0.2.5"
 features = ["no-env-filter"]
 [features]
 rt-tokio = ["aws-smithy-async/rt-tokio", "aws-smithy-types/rt-tokio"]
 test-util = ["aws-smithy-runtime/test-util"]
 behavior-version-latest = []
 rustls = ["aws-smithy-runtime/tls-rustls"]
 default-https-client = ["aws-smithy-runtime/default-https-client"]
 gated-tests = []
 default = ["rt-tokio", "rustls", "default-https-client"]
-59
-60

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

@@ -158,158 +234,237 @@

↥ Expand context

 #[derive(Debug)]
 struct NonQueryCompatibleOperationRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for NonQueryCompatibleOperationRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &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::non_query_compatible_operation::NonQueryCompatibleOperationInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::non_query_compatible_operation::NonQueryCompatibleOperationInput,

                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/service/NonQueryCompatibleRpcV2Protocol/operation/NonQueryCompatibleOperation")
                     .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-184
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::non_query_compatible_operation::NonQueryCompatibleOperationInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::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))
-193
+            }
             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");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::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");
                 _header_serialization_settings.set_default_header(builder, ::http_1x::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);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-208
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-210
+    }
-211
+}
 #[derive(Debug)]
 struct NonQueryCompatibleOperationEndpointParamsInterceptor;
-214
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for NonQueryCompatibleOperationEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "NonQueryCompatibleOperationEndpointParamsInterceptor"

↧ Expand context

-218
+    }
-219
     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()
             .downcast_ref::<NonQueryCompatibleOperationInput>()
             .ok_or("failed to downcast to NonQueryCompatibleOperationInput")?;
-234
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;

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

@@ -1,1 +78,83 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-6
 #![allow(dead_code)]
-8
 use aws_smithy_http::header::set_request_header_if_absent;
 use aws_smithy_types::config_bag::{Storable, StoreReplace};
 use http::header::{HeaderName, CONTENT_LENGTH, CONTENT_TYPE};
 use http_1x::header::{HeaderName, CONTENT_LENGTH, CONTENT_TYPE};
-12
 /// Configuration for how default protocol headers are serialized
 #[derive(Clone, Debug, Default)]
 pub(crate) struct HeaderSerializationSettings {
     omit_default_content_length: bool,
     omit_default_content_type: bool,
-18
+}
-19
 impl HeaderSerializationSettings {
     /// Creates new [`HeaderSerializationSettings`]
     pub(crate) fn new() -> Self {
         Default::default()
-24
+    }
-25
     /// Omit the default `Content-Length` header during serialization
     pub(crate) fn omit_default_content_length(self) -> Self {
         Self {
             omit_default_content_length: true,
             ..self
-31
+        }
-32
+    }
-33
     /// Omit the default `Content-Type` header during serialization
     pub(crate) fn omit_default_content_type(self) -> Self {
         Self {
             omit_default_content_type: true,
             ..self
-39
+        }
-40
+    }
-41
     /// Returns true if the given default header name should be serialized
     fn include_header(&self, header: &HeaderName) -> bool {
         (!self.omit_default_content_length || header != CONTENT_LENGTH) && (!self.omit_default_content_type || header != CONTENT_TYPE)
-45
+    }
-46
     /// Sets a default header on the given request builder if it should be serialized
     pub(crate) fn set_default_header(&self, mut request: http::request::Builder, header_name: HeaderName, value: &str) -> http::request::Builder {
     pub(crate) fn set_default_header(
         &self,
         mut request: http_1x::request::Builder,
         header_name: HeaderName,
         value: &str,
     ) -> http_1x::request::Builder {
         if self.include_header(&header_name) {
             request = set_request_header_if_absent(request, header_name, value);
-56
+        }
         request
-58
+    }
-59
+}
-60
 impl Storable for HeaderSerializationSettings {
     type Storer = StoreReplace<Self>;
-63
+}

↧ Expand context

-64
 #[cfg(test)]
 mod tests {
     use super::*;
-68
     #[test]
     fn test_include_header() {
         let settings = HeaderSerializationSettings::default();
         assert!(settings.include_header(&CONTENT_LENGTH));
         assert!(settings.include_header(&CONTENT_TYPE));
-74
         let settings = HeaderSerializationSettings::default().omit_default_content_length();
         assert!(!settings.include_header(&CONTENT_LENGTH));
         assert!(settings.include_header(&CONTENT_TYPE));
-78
         let settings = HeaderSerializationSettings::default().omit_default_content_type();
         assert!(settings.include_header(&CONTENT_LENGTH));
         assert!(!settings.include_header(&CONTENT_TYPE));
-82
         let settings = HeaderSerializationSettings::default()

tmp-codegen-diff/codegen-client-test/rpcv2cbor_query_compatible/rust-client-codegen/Cargo.toml

@@ -1,1 +58,62 @@

↥ Expand context

 # Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 [package]
 name = "rpcv2cbor_query_compatible"
 version = "0.0.1"
 authors = ["protocoltest@example.com"]
 description = "test"
 edition = "2021"
-8
 [package.metadata.smithy]
 codegen-version = "ci"
 protocol = "smithy.protocols#rpcv2Cbor"
 [dependencies.aws-smithy-async]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-async"
 [dependencies.aws-smithy-cbor]

 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-cbor"
 [dependencies.aws-smithy-http]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http"
 [dependencies.aws-smithy-json]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-json"
 [dependencies.aws-smithy-runtime]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime"
 features = ["client"]
 [dependencies.aws-smithy-runtime-api]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime-api"
 features = ["client", "http-02x"]
 features = ["client", "http-1x"]
 [dependencies.aws-smithy-types]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-types"
 features = ["http-body-1-x"]
 [dependencies.fastrand]
 version = "2.0.0"
 [dependencies.http]
 version = "0.2.9"
 [dependencies.http-1x]
 version = "1"
 package = "http"
 [dependencies.tracing]
 version = "0.1"
 [dev-dependencies.aws-smithy-http-client]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http-client"
 features = ["test-util"]
 [dev-dependencies.aws-smithy-protocol-test]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-protocol-test"
 [dev-dependencies.bytes]
 version = "1.4.0"
 [dev-dependencies.pretty_assertions]

↧ Expand context

 version = "1.3.0"
 [dev-dependencies.tokio]
 version = "1.23.1"
 features = ["macros", "test-util", "rt-multi-thread"]
 [dev-dependencies.tracing-test]
 version = "0.2.5"
 features = ["no-env-filter"]
 [features]
 rt-tokio = ["aws-smithy-async/rt-tokio", "aws-smithy-types/rt-tokio"]
 test-util = ["aws-smithy-runtime/test-util"]
 behavior-version-latest = []
 rustls = ["aws-smithy-runtime/tls-rustls"]
 default-https-client = ["aws-smithy-runtime/default-https-client"]
 gated-tests = []
 default = ["rt-tokio", "rustls", "default-https-client"]
-61
-62

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

@@ -3,3 +71,72 @@

↥ Expand context

  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-6
 use aws_smithy_runtime_api::http::Headers;
-8
 const X_AMZN_QUERY_ERROR: &str = "x-amzn-query-error";
 const QUERY_COMPATIBLE_ERRORCODE_DELIMITER: char = ';';
-11
 /// Obtains custom error code and error type from the given `headers`.
 ///
 /// Looks up a value for the `X_AMZN_QUERY_ERROR` header and if found, the value should be in the
 /// form of `<error code>;<error type>`. The function then splits it into two parts and returns
 /// a (error code, error type) as a tuple.
 ///
 /// Any execution path besides the above happy path will yield a `None`.
 pub fn parse_aws_query_compatible_error(headers: &Headers) -> Option<(&str, &str)> {
     let header_value = headers.get(X_AMZN_QUERY_ERROR)?;
     header_value
         .find(QUERY_COMPATIBLE_ERRORCODE_DELIMITER)

         .map(|idx| (&header_value[..idx], &header_value[idx + 1..]))
-24
+}
-25
 #[cfg(test)]
 mod test {
     use crate::aws_query_compatible_errors::{parse_aws_query_compatible_error, X_AMZN_QUERY_ERROR};
     use aws_smithy_runtime_api::http::Response;
-30
     #[test]
     fn parse_aws_query_compatible_error_should_parse_code_and_type_fields() {
         let mut response: http::Response<()> = http::Response::default();
         let mut response: http_1x::Response<()> = http_1x::Response::default();
         response.headers_mut().insert(
             X_AMZN_QUERY_ERROR,
             http::HeaderValue::from_static("AWS.SimpleQueueService.NonExistentQueue;Sender"),
             http_1x::HeaderValue::from_static("AWS.SimpleQueueService.NonExistentQueue;Sender"),
         );
         let response = Response::try_from(response).unwrap();
-39
         let actual = parse_aws_query_compatible_error(response.headers());
-41
         assert_eq!(Some(("AWS.SimpleQueueService.NonExistentQueue", "Sender")), actual,);
-43
+    }
-44
     #[test]
     fn parse_aws_query_compatible_error_should_return_none_when_header_value_has_no_delimiter() {
         let mut response: http::Response<()> = http::Response::default();
         let mut response: http_1x::Response<()> = http_1x::Response::default();
         response.headers_mut().insert(
             X_AMZN_QUERY_ERROR,
             http::HeaderValue::from_static("AWS.SimpleQueueService.NonExistentQueue"),
             http_1x::HeaderValue::from_static("AWS.SimpleQueueService.NonExistentQueue"),
         );
         let response = Response::try_from(response).unwrap();
-53
         let actual = parse_aws_query_compatible_error(response.headers());
-55
         assert_eq!(None, actual);
-57
+    }
-58
     #[test]
     fn parse_aws_query_compatible_error_should_return_none_when_there_is_no_target_header() {
         let mut response: http::Response<()> = http::Response::default();
         response
             .headers_mut()
             .insert("x-amzn-requestid", http::HeaderValue::from_static("a918fbf2-457a-4fe1-99ba-5685ce220fc1"));
         let mut response: http_1x::Response<()> = http_1x::Response::default();
         response.headers_mut().insert(
             "x-amzn-requestid",
             http_1x::HeaderValue::from_static("a918fbf2-457a-4fe1-99ba-5685ce220fc1"),
         );
         let response = Response::try_from(response).unwrap();
-67
         let actual = parse_aws_query_compatible_error(response.headers());
-69
         assert_eq!(None, actual);
-71
+    }
-72
+}

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

@@ -157,157 +229,232 @@

↥ Expand context

-157
+}
 #[derive(Debug)]
 struct QueryCompatibleOperationRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for QueryCompatibleOperationRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &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::query_compatible_operation::QueryCompatibleOperationInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(

                 _input: &crate::operation::query_compatible_operation::QueryCompatibleOperationInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/service/QueryCompatibleRpcV2Protocol/operation/QueryCompatibleOperation").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-183
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::query_compatible_operation::QueryCompatibleOperationInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::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))
-192
+            }
             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");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::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");
                 _header_serialization_settings.set_default_header(builder, ::http_1x::header::HeaderName::from_static("accept"), "application/cbor");
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http::header::HeaderName::from_static("x-amzn-query-mode"), "true");
                 _header_serialization_settings.set_default_header(builder, ::http_1x::header::HeaderName::from_static("x-amzn-query-mode"), "true");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-206
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-208
+    }
-209
+}
 #[derive(Debug)]
 struct QueryCompatibleOperationEndpointParamsInterceptor;
-212

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for QueryCompatibleOperationEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "QueryCompatibleOperationEndpointParamsInterceptor"
-216
+    }
-217
     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()
             .downcast_ref::<QueryCompatibleOperationInput>()
             .ok_or("failed to downcast to QueryCompatibleOperationInput")?;
-232

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

@@ -1,1 +78,83 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-6
 #![allow(dead_code)]
-8
 use aws_smithy_http::header::set_request_header_if_absent;
 use aws_smithy_types::config_bag::{Storable, StoreReplace};
 use http::header::{HeaderName, CONTENT_LENGTH, CONTENT_TYPE};
 use http_1x::header::{HeaderName, CONTENT_LENGTH, CONTENT_TYPE};
-12
 /// Configuration for how default protocol headers are serialized
 #[derive(Clone, Debug, Default)]
 pub(crate) struct HeaderSerializationSettings {
     omit_default_content_length: bool,
     omit_default_content_type: bool,
-18
+}
-19
 impl HeaderSerializationSettings {
     /// Creates new [`HeaderSerializationSettings`]
     pub(crate) fn new() -> Self {
         Default::default()
-24
+    }
-25
     /// Omit the default `Content-Length` header during serialization
     pub(crate) fn omit_default_content_length(self) -> Self {
         Self {
             omit_default_content_length: true,
             ..self
-31
+        }
-32
+    }
-33
     /// Omit the default `Content-Type` header during serialization
     pub(crate) fn omit_default_content_type(self) -> Self {
         Self {
             omit_default_content_type: true,
             ..self
-39
+        }
-40
+    }
-41
     /// Returns true if the given default header name should be serialized
     fn include_header(&self, header: &HeaderName) -> bool {
         (!self.omit_default_content_length || header != CONTENT_LENGTH) && (!self.omit_default_content_type || header != CONTENT_TYPE)
-45
+    }
-46
     /// Sets a default header on the given request builder if it should be serialized
     pub(crate) fn set_default_header(&self, mut request: http::request::Builder, header_name: HeaderName, value: &str) -> http::request::Builder {
     pub(crate) fn set_default_header(
         &self,
         mut request: http_1x::request::Builder,
         header_name: HeaderName,
         value: &str,
     ) -> http_1x::request::Builder {
         if self.include_header(&header_name) {
             request = set_request_header_if_absent(request, header_name, value);
-56
+        }
         request
-58
+    }
-59
+}
-60
 impl Storable for HeaderSerializationSettings {
     type Storer = StoreReplace<Self>;
-63
+}

↧ Expand context

-64
 #[cfg(test)]
 mod tests {
     use super::*;
-68
     #[test]
     fn test_include_header() {
         let settings = HeaderSerializationSettings::default();
         assert!(settings.include_header(&CONTENT_LENGTH));
         assert!(settings.include_header(&CONTENT_TYPE));
-74
         let settings = HeaderSerializationSettings::default().omit_default_content_length();
         assert!(!settings.include_header(&CONTENT_LENGTH));
         assert!(settings.include_header(&CONTENT_TYPE));
-78
         let settings = HeaderSerializationSettings::default().omit_default_content_type();
         assert!(settings.include_header(&CONTENT_LENGTH));
         assert!(!settings.include_header(&CONTENT_TYPE));
-82
         let settings = HeaderSerializationSettings::default()

tmp-codegen-diff/codegen-client-test/simple/rust-client-codegen/Cargo.toml

@@ -1,1 +43,47 @@

↥ Expand context

 # Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 [package]
 name = "simple"
 version = "0.0.1"
 authors = ["protocoltest@example.com"]
 description = "test"
 edition = "2021"
-8
 [package.metadata.smithy]
 codegen-version = "ci"
 protocol = "aws.protocols#restJson1"
 [dependencies.aws-smithy-async]

 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-async"
 [dependencies.aws-smithy-http]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http"
 [dependencies.aws-smithy-json]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-json"
 [dependencies.aws-smithy-runtime]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime"
 features = ["client"]
 [dependencies.aws-smithy-runtime-api]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime-api"
 features = ["client", "http-02x"]
 features = ["client", "http-1x"]
 [dependencies.aws-smithy-types]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-types"
 features = ["http-body-1-x"]
 [dependencies.bytes]
 version = "1.4.0"
 [dependencies.fastrand]
 version = "2.0.0"
 [dependencies.http]
 version = "0.2.9"
 [dependencies.http-1x]
 version = "1"
 package = "http"
 [dependencies.tracing]
 version = "0.1"
 [features]
 rt-tokio = ["aws-smithy-async/rt-tokio", "aws-smithy-types/rt-tokio"]
 test-util = ["aws-smithy-runtime/test-util"]
 behavior-version-latest = []
 rustls = ["aws-smithy-runtime/tls-rustls"]
 default-https-client = ["aws-smithy-runtime/default-https-client"]
 gated-tests = []
 default = ["rt-tokio", "rustls", "default-https-client"]

↧ Expand context

Client Test

Files changed: