Client Test

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/operation/transact_write_items.rs

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

-158
+}
 #[derive(Debug)]
 struct TransactWriteItemsRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for TransactWriteItemsRequestSerializer {
     #[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::transact_write_items::TransactWriteItemsInput>()
             .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::transact_write_items::TransactWriteItemsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-184
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::transact_write_items::TransactWriteItemsInput,
                 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::CONTENT_TYPE, "application/x-amz-json-1.0");
             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/x-amz-json-1.0");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http::header::HeaderName::from_static("x-amz-target"),
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "DynamoDB_20120810.TransactWriteItems",
             );
             builder
         };
         let body =
             ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_transact_write_items::ser_transact_write_items_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);
-208
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-210
+    }
-211
+}
 #[derive(Debug)]
 struct TransactWriteItemsEndpointParamsInterceptor;
-214
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for TransactWriteItemsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "TransactWriteItemsEndpointParamsInterceptor"

↧ 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::<TransactWriteItemsInput>()
             .ok_or("failed to downcast to TransactWriteItemsInput")?;
-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/dynamo/rust-client-codegen/src/operation/untag_resource.rs

@@ -148,148 +226,226 @@

↥ Expand context

-148
+}
 #[derive(Debug)]
 struct UntagResourceRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for UntagResourceRequestSerializer {
     #[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::untag_resource::UntagResourceInput>()
             .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::untag_resource::UntagResourceInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-174
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::untag_resource::UntagResourceInput,
                 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))
-183
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-amz-json-1.0");
             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/x-amz-json-1.0");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http::header::HeaderName::from_static("x-amz-target"),
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "DynamoDB_20120810.UntagResource",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_untag_resource::ser_untag_resource_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);
-197
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-199
+    }
-200
+}
 #[derive(Debug)]
 struct UntagResourceEndpointParamsInterceptor;
-203
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UntagResourceEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "UntagResourceEndpointParamsInterceptor"

↧ Expand context

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

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/operation/update_continuous_backups.rs

@@ -151,151 +231,231 @@

↥ Expand context

-151
+}
 #[derive(Debug)]
 struct UpdateContinuousBackupsRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for UpdateContinuousBackupsRequestSerializer {
     #[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::update_continuous_backups::UpdateContinuousBackupsInput>()
             .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::update_continuous_backups::UpdateContinuousBackupsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-177
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::update_continuous_backups::UpdateContinuousBackupsInput,
                 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))
-186
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-amz-json-1.0");
             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/x-amz-json-1.0");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http::header::HeaderName::from_static("x-amz-target"),
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "DynamoDB_20120810.UpdateContinuousBackups",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_update_continuous_backups::ser_update_continuous_backups_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);
-202
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-204
+    }
-205
+}
 #[derive(Debug)]
 struct UpdateContinuousBackupsEndpointParamsInterceptor;
-208
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateContinuousBackupsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "UpdateContinuousBackupsEndpointParamsInterceptor"

↧ Expand context

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

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/operation/update_contributor_insights.rs

@@ -157,157 +237,237 @@

↥ Expand context

-157
+}
 #[derive(Debug)]
 struct UpdateContributorInsightsRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for UpdateContributorInsightsRequestSerializer {
     #[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::update_contributor_insights::UpdateContributorInsightsInput>()
             .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::update_contributor_insights::UpdateContributorInsightsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-183
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::update_contributor_insights::UpdateContributorInsightsInput,
                 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/x-amz-json-1.0");
             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/x-amz-json-1.0");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http::header::HeaderName::from_static("x-amz-target"),
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "DynamoDB_20120810.UpdateContributorInsights",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_update_contributor_insights::ser_update_contributor_insights_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);
-208
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-210
+    }
-211
+}
 #[derive(Debug)]
 struct UpdateContributorInsightsEndpointParamsInterceptor;
-214
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateContributorInsightsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "UpdateContributorInsightsEndpointParamsInterceptor"

↧ 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::<UpdateContributorInsightsInput>()
             .ok_or("failed to downcast to UpdateContributorInsightsInput")?;
-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/dynamo/rust-client-codegen/src/operation/update_global_table.rs

@@ -151,151 +229,229 @@

↥ Expand context

-151
+}
 #[derive(Debug)]
 struct UpdateGlobalTableRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for UpdateGlobalTableRequestSerializer {
     #[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::update_global_table::UpdateGlobalTableInput>()
             .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::update_global_table::UpdateGlobalTableInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-177
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::update_global_table::UpdateGlobalTableInput,
                 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))
-186
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-amz-json-1.0");
             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/x-amz-json-1.0");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http::header::HeaderName::from_static("x-amz-target"),
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "DynamoDB_20120810.UpdateGlobalTable",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_update_global_table::ser_update_global_table_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);
-200
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-202
+    }
-203
+}
 #[derive(Debug)]
 struct UpdateGlobalTableEndpointParamsInterceptor;
-206
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateGlobalTableEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "UpdateGlobalTableEndpointParamsInterceptor"

↧ Expand context

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

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/operation/update_global_table_settings.rs

@@ -157,157 +237,237 @@

↥ Expand context

-157
+}
 #[derive(Debug)]
 struct UpdateGlobalTableSettingsRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for UpdateGlobalTableSettingsRequestSerializer {
     #[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::update_global_table_settings::UpdateGlobalTableSettingsInput>()
             .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::update_global_table_settings::UpdateGlobalTableSettingsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-183
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::update_global_table_settings::UpdateGlobalTableSettingsInput,
                 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/x-amz-json-1.0");
             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/x-amz-json-1.0");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http::header::HeaderName::from_static("x-amz-target"),
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "DynamoDB_20120810.UpdateGlobalTableSettings",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_update_global_table_settings::ser_update_global_table_settings_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);
-208
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-210
+    }
-211
+}
 #[derive(Debug)]
 struct UpdateGlobalTableSettingsEndpointParamsInterceptor;
-214
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateGlobalTableSettingsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "UpdateGlobalTableSettingsEndpointParamsInterceptor"

↧ 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::<UpdateGlobalTableSettingsInput>()
             .ok_or("failed to downcast to UpdateGlobalTableSettingsInput")?;
-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/dynamo/rust-client-codegen/src/operation/update_item.rs

@@ -146,146 +224,224 @@

↥ Expand context

         crate::protocol_serde::type_erase_result(parse_result)
-147
+    }
-148
+}
 #[derive(Debug)]
 struct UpdateItemRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for UpdateItemRequestSerializer {
     #[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::update_item::UpdateItemInput>().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::update_item::UpdateItemInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-172
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::update_item::UpdateItemInput,
                 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))
-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/x-amz-json-1.0");
             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/x-amz-json-1.0");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http::header::HeaderName::from_static("x-amz-target"),
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "DynamoDB_20120810.UpdateItem",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_update_item::ser_update_item_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);
-195
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-197
+    }
-198
+}
 #[derive(Debug)]
 struct UpdateItemEndpointParamsInterceptor;
-201
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateItemEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "UpdateItemEndpointParamsInterceptor"

↧ Expand context

-205
+    }
-206
     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::<UpdateItemInput>()
             .ok_or("failed to downcast to UpdateItemInput")?;
-221
         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/dynamo/rust-client-codegen/src/operation/update_table.rs

@@ -148,148 +226,226 @@

↥ Expand context

-148
+}
 #[derive(Debug)]
 struct UpdateTableRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for UpdateTableRequestSerializer {
     #[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::update_table::UpdateTableInput>()
             .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::update_table::UpdateTableInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-174
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::update_table::UpdateTableInput,
                 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))
-183
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-amz-json-1.0");
             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/x-amz-json-1.0");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http::header::HeaderName::from_static("x-amz-target"),
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "DynamoDB_20120810.UpdateTable",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_update_table::ser_update_table_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);
-197
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-199
+    }
-200
+}
 #[derive(Debug)]
 struct UpdateTableEndpointParamsInterceptor;
-203
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateTableEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "UpdateTableEndpointParamsInterceptor"

↧ Expand context

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

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/operation/update_table_replica_auto_scaling.rs

@@ -157,157 +237,237 @@

↥ Expand context

-157
+}
 #[derive(Debug)]
 struct UpdateTableReplicaAutoScalingRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for UpdateTableReplicaAutoScalingRequestSerializer {
     #[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::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingInput>()
             .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::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-183
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingInput,
                 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/x-amz-json-1.0");
             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/x-amz-json-1.0");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http::header::HeaderName::from_static("x-amz-target"),
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "DynamoDB_20120810.UpdateTableReplicaAutoScaling",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_update_table_replica_auto_scaling::ser_update_table_replica_auto_scaling_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);
-208
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-210
+    }
-211
+}
 #[derive(Debug)]
 struct UpdateTableReplicaAutoScalingEndpointParamsInterceptor;
-214
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateTableReplicaAutoScalingEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "UpdateTableReplicaAutoScalingEndpointParamsInterceptor"

↧ 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::<UpdateTableReplicaAutoScalingInput>()
             .ok_or("failed to downcast to UpdateTableReplicaAutoScalingInput")?;
-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/dynamo/rust-client-codegen/src/operation/update_time_to_live.rs

@@ -151,151 +229,229 @@

↥ Expand context

-151
+}
 #[derive(Debug)]
 struct UpdateTimeToLiveRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for UpdateTimeToLiveRequestSerializer {
     #[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::update_time_to_live::UpdateTimeToLiveInput>()
             .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::update_time_to_live::UpdateTimeToLiveInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-177
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::update_time_to_live::UpdateTimeToLiveInput,
                 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))
-186
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-amz-json-1.0");
             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/x-amz-json-1.0");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http::header::HeaderName::from_static("x-amz-target"),
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "DynamoDB_20120810.UpdateTimeToLive",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_update_time_to_live::ser_update_time_to_live_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);
-200
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-202
+    }
-203
+}
 #[derive(Debug)]
 struct UpdateTimeToLiveEndpointParamsInterceptor;
-206
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateTimeToLiveEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "UpdateTimeToLiveEndpointParamsInterceptor"

↧ Expand context

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

tmp-codegen-diff/codegen-client-test/dynamo/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/ebs/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 = "ebs"
 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]
 test-util = ["aws-smithy-runtime/test-util"]
 rt-tokio = ["aws-smithy-async/rt-tokio", "aws-smithy-types/rt-tokio"]
 rt-tokio = ["aws-smithy-async/rt-tokio", "aws-smithy-types/http-body-1-x", "aws-smithy-types/rt-tokio"]
 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"]
-46
-47

tmp-codegen-diff/codegen-client-test/ebs/rust-client-codegen/src/json_errors.rs

@@ -1,1 +45,45 @@

↥ Expand context

 // 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
 use aws_smithy_json::deserialize::token::skip_value;
 use aws_smithy_json::deserialize::{error::DeserializeError, json_token_iter, Token};
 use aws_smithy_runtime_api::http::Headers;
 use aws_smithy_types::error::metadata::{Builder as ErrorMetadataBuilder, ErrorMetadata};
 use std::borrow::Cow;
-12
 // currently only used by AwsJson
 #[allow(unused)]
 pub fn is_error<B>(response: &http::Response<B>) -> bool {
 pub fn is_error<B>(response: &http_1x::Response<B>) -> bool {
     !response.status().is_success()
-17
+}
-18
 fn sanitize_error_code(error_code: &str) -> &str {
     // Trim a trailing URL from the error code, which is done by removing the longest suffix
     // beginning with a `:`
     let error_code = match error_code.find(':') {
         Some(idx) => &error_code[..idx],
         None => error_code,
     };

↧ Expand context

-26
     // Trim a prefixing namespace from the error code, beginning with a `#`
     match error_code.find('#') {
         Some(idx) => &error_code[idx + 1..],
         None => error_code,
-31
+    }
-32
+}
-33
 struct ErrorBody<'a> {
     code: Option<Cow<'a, str>>,
     message: Option<Cow<'a, str>>,
-37
+}
-38
 fn parse_error_body(bytes: &[u8]) -> Result<ErrorBody<'_>, DeserializeError> {
     let mut tokens = json_token_iter(bytes).peekable();
     let (mut typ, mut code, mut message) = (None, None, None);
     if let Some(Token::StartObject { .. }) = tokens.next().transpose()? {
         loop {
             match tokens.next().transpose()? {
                 Some(Token::EndObject { .. }) => break,

@@ -60,60 +120,120 @@

↥ Expand context

         if tokens.next().is_some() {
             return Err(DeserializeError::custom("found more JSON tokens after completing parsing"));
-62
+        }
-63
+    }
     Ok(ErrorBody { code: code.or(typ), message })
-65
+}
-66
 pub fn parse_error_metadata(payload: &[u8], headers: &Headers) -> Result<ErrorMetadataBuilder, DeserializeError> {
     let ErrorBody { code, message } = parse_error_body(payload)?;
-69
     let mut err_builder = ErrorMetadata::builder();
     if let Some(code) = headers.get("x-amzn-errortype").or(code.as_deref()).map(sanitize_error_code) {
         err_builder = err_builder.code(code);
-73
+    }
     if let Some(message) = message {
         err_builder = err_builder.message(message);
-76
+    }
     Ok(err_builder)
-78
+}
-79

 #[cfg(test)]
 mod test {
     use crate::json_errors::{parse_error_body, parse_error_metadata, sanitize_error_code};
     use aws_smithy_runtime_api::client::orchestrator::HttpResponse;
     use aws_smithy_types::{body::SdkBody, error::ErrorMetadata};
     use std::borrow::Cow;
-86
     #[test]
     fn error_metadata() {
         let response = HttpResponse::try_from(
             http::Response::builder()
             http_1x::Response::builder()
                 .body(SdkBody::from(r#"{ "__type": "FooError", "message": "Go to foo" }"#))
                 .unwrap(),
-93
+        )
         .unwrap();
         assert_eq!(
             parse_error_metadata(response.body().bytes().unwrap(), response.headers())
                 .unwrap()
                 .build(),
             ErrorMetadata::builder().code("FooError").message("Go to foo").build()
-100
+        )

↧ Expand context

-101
+    }
-102
     #[test]
     fn error_type() {
         assert_eq!(
             Some(Cow::Borrowed("FooError")),
             parse_error_body(br#"{ "__type": "FooError" }"#).unwrap().code
         );
-109
+    }
-110
     #[test]
     fn code_takes_priority() {
         assert_eq!(
             Some(Cow::Borrowed("BarError")),
             parse_error_body(br#"{ "code": "BarError", "__type": "FooError" }"#).unwrap().code
         );
-117
+    }
-118
     #[test]
     fn ignore_unrecognized_fields() {

@@ -129,129 +180,180 @@

↥ Expand context

     #[test]
     fn sanitize_namespace_and_url() {
         assert_eq!(
             sanitize_error_code("aws.protocoltests.restjson#FooError:http://internal.amazon.com/coral/com.amazon.coral.validate/"),
             "FooError"
         );
-135
+    }
-136
     #[test]
     fn sanitize_noop() {
         assert_eq!(sanitize_error_code("FooError"), "FooError");
-140
+    }
-141
     #[test]
     fn sanitize_url() {
         assert_eq!(
             sanitize_error_code("FooError:http://internal.amazon.com/coral/com.amazon.coral.validate/"),
             "FooError"
         );
-148
+    }

-149
     #[test]
     fn sanitize_namespace() {
         assert_eq!(sanitize_error_code("aws.protocoltests.restjson#FooError"), "FooError");
-153
+    }
-154
     // services like lambda use an alternate `Message` instead of `message`
     #[test]
     fn alternative_error_message_names() {
         let response = HttpResponse::try_from(
             http::Response::builder()
             http_1x::Response::builder()
                 .header("x-amzn-errortype", "ResourceNotFoundException")
                 .body(SdkBody::from(
                     r#"{
                     "Type": "User",
                     "Message": "Functions from 'us-west-2' are not reachable from us-east-1"
                 }"#,
                 ))
                 .unwrap(),
-168
+        )
         .unwrap();

↧ Expand context

         assert_eq!(
             parse_error_metadata(response.body().bytes().unwrap(), response.headers())
                 .unwrap()
                 .build(),
             ErrorMetadata::builder()
                 .code("ResourceNotFoundException")
                 .message("Functions from 'us-west-2' are not reachable from us-east-1")
                 .build()
         );
-179
+    }
-180
+}

tmp-codegen-diff/codegen-client-test/ebs/rust-client-codegen/src/operation/complete_snapshot.rs

@@ -159,159 +226,226 @@

↥ Expand context

             .downcast::<crate::operation::complete_snapshot::CompleteSnapshotInput>()
             .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::complete_snapshot::CompleteSnapshotInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.snapshot_id;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("snapshot_id", "cannot be empty or unset"))?;
                 let snapshot_id = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if snapshot_id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(

                         "snapshot_id",
                         "cannot be empty or unset",
                     ));
-182
+                }
                 ::std::write!(output, "/snapshots/completion/{SnapshotId}", SnapshotId = snapshot_id).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-185
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::complete_snapshot::CompleteSnapshotInput,
                 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)?;
                 let builder = crate::protocol_serde::shape_complete_snapshot::ser_complete_snapshot_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-195
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-200
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-202
+    }
-203
+}
 #[derive(Debug)]
 struct CompleteSnapshotEndpointParamsInterceptor;
-206

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CompleteSnapshotEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "CompleteSnapshotEndpointParamsInterceptor"
-210
+    }
-211
     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::<CompleteSnapshotInput>()
             .ok_or("failed to downcast to CompleteSnapshotInput")?;
-226

tmp-codegen-diff/codegen-client-test/ebs/rust-client-codegen/src/operation/get_snapshot_block.rs

@@ -207,207 +274,274 @@

↥ Expand context

                 ::std::write!(
                     output,
                     "/snapshots/{SnapshotId}/blocks/{BlockIndex}",
                     SnapshotId = snapshot_id,
                     BlockIndex = block_index
-212
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-215
+            }
             fn uri_query(
                 _input: &crate::operation::get_snapshot_block::GetSnapshotBlockInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 let inner_3 = &_input.block_token;
                 let inner_3 = inner_3
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("block_token", "cannot be empty or unset"))?;
                 if inner_3.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(

                         "block_token",
                         "cannot be empty or unset",
                     ));
-230
+                }
                 query.push_kv("blockToken", &::aws_smithy_http::query::fmt_string(inner_3));
                 ::std::result::Result::Ok(())
-233
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_snapshot_block::GetSnapshotBlockInput,
                 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)?;
                 uri_query(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-243
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-248
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-250
+    }
-251
+}
 #[derive(Debug)]
 struct GetSnapshotBlockEndpointParamsInterceptor;
-254

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetSnapshotBlockEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GetSnapshotBlockEndpointParamsInterceptor"
-258
+    }
-259
     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::<GetSnapshotBlockInput>()
             .ok_or("failed to downcast to GetSnapshotBlockInput")?;
-274

tmp-codegen-diff/codegen-client-test/ebs/rust-client-codegen/src/operation/list_changed_blocks.rs

@@ -192,192 +259,259 @@

↥ Expand context

             fn uri_query(
                 _input: &crate::operation::list_changed_blocks::ListChangedBlocksInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 if let ::std::option::Option::Some(inner_2) = &_input.first_snapshot_id {
-198
+                    {
                         query.push_kv("firstSnapshotId", &::aws_smithy_http::query::fmt_string(inner_2));
-200
+                    }
-201
+                }
                 if let ::std::option::Option::Some(inner_3) = &_input.next_token {
-203
+                    {
                         query.push_kv("pageToken", &::aws_smithy_http::query::fmt_string(inner_3));
-205
+                    }
-206
+                }
                 if let ::std::option::Option::Some(inner_4) = &_input.max_results {
-208
+                    {
                         query.push_kv("maxResults", ::aws_smithy_types::primitive::Encoder::from(*inner_4).encode());
-210
+                    }
-211
+                }

                 if let ::std::option::Option::Some(inner_5) = &_input.starting_block_index {
-213
+                    {
                         query.push_kv("startingBlockIndex", ::aws_smithy_types::primitive::Encoder::from(*inner_5).encode());
-215
+                    }
-216
+                }
                 ::std::result::Result::Ok(())
-218
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_changed_blocks::ListChangedBlocksInput,
                 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)?;
                 uri_query(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-228
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-233
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-235
+    }
-236
+}
 #[derive(Debug)]
 struct ListChangedBlocksEndpointParamsInterceptor;
-239

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListChangedBlocksEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListChangedBlocksEndpointParamsInterceptor"
-243
+    }
-244
     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::<ListChangedBlocksInput>()
             .ok_or("failed to downcast to ListChangedBlocksInput")?;
-259

Client Test

Files changed: