Client Test

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

@@ -194,194 +255,257 @@

-194
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-196
+    }
-197
+}
 #[derive(Debug)]
 struct UpdateItemEndpointParamsInterceptor;
-200
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateItemEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "UpdateItemEndpointParamsInterceptor"
-204
+    }
-205
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,

         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<UpdateItemInput>()
             .ok_or("failed to downcast to UpdateItemInput")?;
-220
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-229
+    }
-230
+}
-231
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-234
 /// Error type for the `UpdateItemError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

↧ Expand context

 pub enum UpdateItemError {
     /// <p>A condition specified in the operation could not be evaluated.</p>
     ConditionalCheckFailedError(crate::types::error::ConditionalCheckFailedError),
     /// <p>An error occurred on the server side.</p>
     InternalServerError(crate::types::error::InternalServerError),
     #[allow(missing_docs)] // documentation missing in model
     InvalidEndpointError(crate::types::error::InvalidEndpointError),
     /// <p>An item collection is too large. This exception is only returned for tables that have one or more local secondary indexes.</p>
     ItemCollectionSizeLimitExceededError(crate::types::error::ItemCollectionSizeLimitExceededError),
     /// <p>Your request rate is too high. The AWS SDKs for DynamoDB automatically retry requests that receive this exception. Your request is eventually successful, unless your retry queue is too large to finish. Reduce the frequency of requests and use exponential backoff. For more information, go to <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.Errors.html#Programming.Errors.RetryAndBackoff">Error Retries and Exponential Backoff</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
     ProvisionedThroughputExceededError(crate::types::error::ProvisionedThroughputExceededError),
     /// <p>Throughput exceeds the current throughput quota for your account. Please contact AWS Support at <a href="https://aws.amazon.com/support">AWS Support</a> to request a quota increase.</p>
     RequestLimitExceeded(crate::types::error::RequestLimitExceeded),
     /// <p>The operation tried to access a nonexistent table or index. The resource might not be specified correctly, or its status might not be <code>ACTIVE</code>.</p>
     ResourceNotFoundError(crate::types::error::ResourceNotFoundError),
     /// <p>Operation was rejected because there is an ongoing transaction for the item.</p>
     TransactionConflictError(crate::types::error::TransactionConflictError),
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
     variable wildcard pattern and check `.code()`:

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

@@ -196,196 +257,259 @@

↥ Expand context

-196
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-198
+    }
-199
+}
 #[derive(Debug)]
 struct UpdateTableEndpointParamsInterceptor;
-202
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateTableEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "UpdateTableEndpointParamsInterceptor"
-206
+    }
-207
     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")?;
-222
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-231
+    }
-232
+}
-233
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-236
 /// Error type for the `UpdateTableError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

↧ Expand context

 pub enum UpdateTableError {
     /// <p>An error occurred on the server side.</p>
     InternalServerError(crate::types::error::InternalServerError),
     #[allow(missing_docs)] // documentation missing in model
     InvalidEndpointError(crate::types::error::InvalidEndpointError),
     /// <p>There is no limit to the number of daily on-demand backups that can be taken.</p>
     /// <p>Up to 50 simultaneous table operations are allowed per account. These operations include <code>CreateTable</code>, <code>UpdateTable</code>, <code>DeleteTable</code>,<code>UpdateTimeToLive</code>, <code>RestoreTableFromBackup</code>, and <code>RestoreTableToPointInTime</code>.</p>
     /// <p>The only exception is when you are creating a table with one or more secondary indexes. You can have up to 25 such requests running at a time; however, if the table or index specifications are complex, DynamoDB might temporarily reduce the number of concurrent operations.</p>
     /// <p>There is a soft account quota of 256 tables.</p>
     LimitExceededError(crate::types::error::LimitExceededError),
     /// <p>The operation conflicts with the resource's availability. For example, you attempted to recreate an existing table, or tried to delete a table currently in the <code>CREATING</code> state.</p>
     ResourceInUseError(crate::types::error::ResourceInUseError),
     /// <p>The operation tried to access a nonexistent table or index. The resource might not be specified correctly, or its status might not be <code>ACTIVE</code>.</p>
     ResourceNotFoundError(crate::types::error::ResourceNotFoundError),
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
     variable wildcard pattern and check `.code()`:
-257
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-259
+     \

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

@@ -207,207 +268,270 @@

↥ Expand context

-207
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-209
+    }
-210
+}
 #[derive(Debug)]
 struct UpdateTableReplicaAutoScalingEndpointParamsInterceptor;
-213
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateTableReplicaAutoScalingEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "UpdateTableReplicaAutoScalingEndpointParamsInterceptor"
-217
+    }
-218
     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")?;
-233
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-242
+    }
-243
+}
-244
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-247
 /// Error type for the `UpdateTableReplicaAutoScalingError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

↧ Expand context

 pub enum UpdateTableReplicaAutoScalingError {
     /// <p>An error occurred on the server side.</p>
     InternalServerError(crate::types::error::InternalServerError),
     /// <p>There is no limit to the number of daily on-demand backups that can be taken.</p>
     /// <p>Up to 50 simultaneous table operations are allowed per account. These operations include <code>CreateTable</code>, <code>UpdateTable</code>, <code>DeleteTable</code>,<code>UpdateTimeToLive</code>, <code>RestoreTableFromBackup</code>, and <code>RestoreTableToPointInTime</code>.</p>
     /// <p>The only exception is when you are creating a table with one or more secondary indexes. You can have up to 25 such requests running at a time; however, if the table or index specifications are complex, DynamoDB might temporarily reduce the number of concurrent operations.</p>
     /// <p>There is a soft account quota of 256 tables.</p>
     LimitExceededError(crate::types::error::LimitExceededError),
     /// <p>The operation conflicts with the resource's availability. For example, you attempted to recreate an existing table, or tried to delete a table currently in the <code>CREATING</code> state.</p>
     ResourceInUseError(crate::types::error::ResourceInUseError),
     /// <p>The operation tried to access a nonexistent table or index. The resource might not be specified correctly, or its status might not be <code>ACTIVE</code>.</p>
     ResourceNotFoundError(crate::types::error::ResourceNotFoundError),
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
     variable wildcard pattern and check `.code()`:
-266
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-268
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-UpdateTableReplicaAutoScalingError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),

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

@@ -199,199 +260,262 @@

↥ Expand context

-199
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-201
+    }
-202
+}
 #[derive(Debug)]
 struct UpdateTimeToLiveEndpointParamsInterceptor;
-205
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateTimeToLiveEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "UpdateTimeToLiveEndpointParamsInterceptor"
-209
+    }
-210
     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")?;
-225
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-234
+    }
-235
+}
-236
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-239
 /// Error type for the `UpdateTimeToLiveError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

↧ Expand context

 pub enum UpdateTimeToLiveError {
     /// <p>An error occurred on the server side.</p>
     InternalServerError(crate::types::error::InternalServerError),
     #[allow(missing_docs)] // documentation missing in model
     InvalidEndpointError(crate::types::error::InvalidEndpointError),
     /// <p>There is no limit to the number of daily on-demand backups that can be taken.</p>
     /// <p>Up to 50 simultaneous table operations are allowed per account. These operations include <code>CreateTable</code>, <code>UpdateTable</code>, <code>DeleteTable</code>,<code>UpdateTimeToLive</code>, <code>RestoreTableFromBackup</code>, and <code>RestoreTableToPointInTime</code>.</p>
     /// <p>The only exception is when you are creating a table with one or more secondary indexes. You can have up to 25 such requests running at a time; however, if the table or index specifications are complex, DynamoDB might temporarily reduce the number of concurrent operations.</p>
     /// <p>There is a soft account quota of 256 tables.</p>
     LimitExceededError(crate::types::error::LimitExceededError),
     /// <p>The operation conflicts with the resource's availability. For example, you attempted to recreate an existing table, or tried to delete a table currently in the <code>CREATING</code> state.</p>
     ResourceInUseError(crate::types::error::ResourceInUseError),
     /// <p>The operation tried to access a nonexistent table or index. The resource might not be specified correctly, or its status might not be <code>ACTIVE</code>.</p>
     ResourceNotFoundError(crate::types::error::ResourceNotFoundError),
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
     variable wildcard pattern and check `.code()`:
-260
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-262
+     \

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

@@ -199,199 +260,262 @@

↥ Expand context

-199
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-201
+    }
-202
+}
 #[derive(Debug)]
 struct CompleteSnapshotEndpointParamsInterceptor;
-205
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CompleteSnapshotEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "CompleteSnapshotEndpointParamsInterceptor"
-209
+    }
-210
     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")?;
-225
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-234
+    }
-235
+}
-236
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-239
 /// Error type for the `CompleteSnapshotError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

↧ Expand context

 pub enum CompleteSnapshotError {
     /// <p>You do not have sufficient access to perform this action.</p>
     AccessDeniedError(crate::types::error::AccessDeniedError),
     /// <p>An internal error has occurred.</p>
     InternalServerError(crate::types::error::InternalServerError),
     /// <p>The number of API requests has exceed the maximum allowed API request throttling limit.</p>
     RequestThrottledError(crate::types::error::RequestThrottledError),
     /// <p>The specified resource does not exist.</p>
     ResourceNotFoundError(crate::types::error::ResourceNotFoundError),
     /// <p>Your current service quotas do not allow you to perform this action.</p>
     ServiceQuotaExceededError(crate::types::error::ServiceQuotaExceededError),
     /// <p>The input fails to satisfy the constraints of the EBS direct APIs.</p>
     ValidationError(crate::types::error::ValidationError),
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
     variable wildcard pattern and check `.code()`:
-259
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-261
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-CompleteSnapshotError) for what information is available for the error.")]

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

@@ -247,247 +308,310 @@

↥ Expand context

-247
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-249
+    }
-250
+}
 #[derive(Debug)]
 struct GetSnapshotBlockEndpointParamsInterceptor;
-253
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetSnapshotBlockEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GetSnapshotBlockEndpointParamsInterceptor"
-257
+    }
-258
     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")?;
-273
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-282
+    }
-283
+}
-284
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-287
 /// Error type for the `GetSnapshotBlockError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

↧ Expand context

 pub enum GetSnapshotBlockError {
     /// <p>You do not have sufficient access to perform this action.</p>
     AccessDeniedError(crate::types::error::AccessDeniedError),
     /// <p>An internal error has occurred.</p>
     InternalServerError(crate::types::error::InternalServerError),
     /// <p>The number of API requests has exceed the maximum allowed API request throttling limit.</p>
     RequestThrottledError(crate::types::error::RequestThrottledError),
     /// <p>The specified resource does not exist.</p>
     ResourceNotFoundError(crate::types::error::ResourceNotFoundError),
     /// <p>Your current service quotas do not allow you to perform this action.</p>
     ServiceQuotaExceededError(crate::types::error::ServiceQuotaExceededError),
     /// <p>The input fails to satisfy the constraints of the EBS direct APIs.</p>
     ValidationError(crate::types::error::ValidationError),
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
     variable wildcard pattern and check `.code()`:
-307
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-309
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-GetSnapshotBlockError) for what information is available for the error.")]

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

@@ -232,232 +293,295 @@

↥ Expand context

-232
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-234
+    }
-235
+}
 #[derive(Debug)]
 struct ListChangedBlocksEndpointParamsInterceptor;
-238
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListChangedBlocksEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListChangedBlocksEndpointParamsInterceptor"
-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::<ListChangedBlocksInput>()
             .ok_or("failed to downcast to ListChangedBlocksInput")?;
-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)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-267
+    }
-268
+}
-269
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-272
 /// Error type for the `ListChangedBlocksError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

↧ Expand context

 pub enum ListChangedBlocksError {
     /// <p>You do not have sufficient access to perform this action.</p>
     AccessDeniedError(crate::types::error::AccessDeniedError),
     /// <p>An internal error has occurred.</p>
     InternalServerError(crate::types::error::InternalServerError),
     /// <p>The number of API requests has exceed the maximum allowed API request throttling limit.</p>
     RequestThrottledError(crate::types::error::RequestThrottledError),
     /// <p>The specified resource does not exist.</p>
     ResourceNotFoundError(crate::types::error::ResourceNotFoundError),
     /// <p>Your current service quotas do not allow you to perform this action.</p>
     ServiceQuotaExceededError(crate::types::error::ServiceQuotaExceededError),
     /// <p>The input fails to satisfy the constraints of the EBS direct APIs.</p>
     ValidationError(crate::types::error::ValidationError),
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
     variable wildcard pattern and check `.code()`:
-292
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-294
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-ListChangedBlocksError) for what information is available for the error.")]

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

@@ -222,222 +283,285 @@

↥ Expand context

-222
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-224
+    }
-225
+}
 #[derive(Debug)]
 struct ListSnapshotBlocksEndpointParamsInterceptor;
-228
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListSnapshotBlocksEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListSnapshotBlocksEndpointParamsInterceptor"
-232
+    }
-233
     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::<ListSnapshotBlocksInput>()
             .ok_or("failed to downcast to ListSnapshotBlocksInput")?;
-248
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-257
+    }
-258
+}
-259
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-262
 /// Error type for the `ListSnapshotBlocksError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

↧ Expand context

 pub enum ListSnapshotBlocksError {
     /// <p>You do not have sufficient access to perform this action.</p>
     AccessDeniedError(crate::types::error::AccessDeniedError),
     /// <p>An internal error has occurred.</p>
     InternalServerError(crate::types::error::InternalServerError),
     /// <p>The number of API requests has exceed the maximum allowed API request throttling limit.</p>
     RequestThrottledError(crate::types::error::RequestThrottledError),
     /// <p>The specified resource does not exist.</p>
     ResourceNotFoundError(crate::types::error::ResourceNotFoundError),
     /// <p>Your current service quotas do not allow you to perform this action.</p>
     ServiceQuotaExceededError(crate::types::error::ServiceQuotaExceededError),
     /// <p>The input fails to satisfy the constraints of the EBS direct APIs.</p>
     ValidationError(crate::types::error::ValidationError),
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
     variable wildcard pattern and check `.code()`:
-282
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-284
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-ListSnapshotBlocksError) for what information is available for the error.")]

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

@@ -221,221 +282,284 @@

↥ Expand context

-221
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-223
+    }
-224
+}
 #[derive(Debug)]
 struct PutSnapshotBlockEndpointParamsInterceptor;
-227
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutSnapshotBlockEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PutSnapshotBlockEndpointParamsInterceptor"
-231
+    }
-232
     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::<PutSnapshotBlockInput>()
             .ok_or("failed to downcast to PutSnapshotBlockInput")?;
-247
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-256
+    }
-257
+}
-258
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-261
 /// Error type for the `PutSnapshotBlockError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

↧ Expand context

 pub enum PutSnapshotBlockError {
     /// <p>You do not have sufficient access to perform this action.</p>
     AccessDeniedError(crate::types::error::AccessDeniedError),
     /// <p>An internal error has occurred.</p>
     InternalServerError(crate::types::error::InternalServerError),
     /// <p>The number of API requests has exceed the maximum allowed API request throttling limit.</p>
     RequestThrottledError(crate::types::error::RequestThrottledError),
     /// <p>The specified resource does not exist.</p>
     ResourceNotFoundError(crate::types::error::ResourceNotFoundError),
     /// <p>Your current service quotas do not allow you to perform this action.</p>
     ServiceQuotaExceededError(crate::types::error::ServiceQuotaExceededError),
     /// <p>The input fails to satisfy the constraints of the EBS direct APIs.</p>
     ValidationError(crate::types::error::ValidationError),
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
     variable wildcard pattern and check `.code()`:
-281
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-283
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-PutSnapshotBlockError) for what information is available for the error.")]

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

@@ -199,199 +260,262 @@

↥ Expand context

-199
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-201
+    }
-202
+}
 #[derive(Debug)]
 struct StartSnapshotEndpointParamsInterceptor;
-205
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for StartSnapshotEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "StartSnapshotEndpointParamsInterceptor"
-209
+    }
-210
     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::<StartSnapshotInput>()
             .ok_or("failed to downcast to StartSnapshotInput")?;
-225
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-234
+    }
-235
+}
-236
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-239
 /// Error type for the `StartSnapshotError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

↧ Expand context

 pub enum StartSnapshotError {
     /// <p>You do not have sufficient access to perform this action.</p>
     AccessDeniedError(crate::types::error::AccessDeniedError),
     /// <p>You have reached the limit for concurrent API requests. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-accessing-snapshot.html#ebsapi-performance">Optimizing performance of the EBS direct APIs</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p>
     ConcurrentLimitExceededError(crate::types::error::ConcurrentLimitExceededError),
     /// <p>The request uses the same client token as a previous, but non-identical request.</p>
     ConflictError(crate::types::error::ConflictError),
     /// <p>An internal error has occurred.</p>
     InternalServerError(crate::types::error::InternalServerError),
     /// <p>The number of API requests has exceed the maximum allowed API request throttling limit.</p>
     RequestThrottledError(crate::types::error::RequestThrottledError),
     /// <p>The specified resource does not exist.</p>
     ResourceNotFoundError(crate::types::error::ResourceNotFoundError),
     /// <p>Your current service quotas do not allow you to perform this action.</p>
     ServiceQuotaExceededError(crate::types::error::ServiceQuotaExceededError),
     /// <p>The input fails to satisfy the constraints of the EBS direct APIs.</p>
     ValidationError(crate::types::error::ValidationError),
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
     variable wildcard pattern and check `.code()`:

tmp-codegen-diff/codegen-client-test/ec2_query/rust-client-codegen/src/operation/datetime_offsets.rs

@@ -193,193 +254,256 @@

↥ Expand context

-193
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-195
+    }
-196
+}
 #[derive(Debug)]
 struct DatetimeOffsetsEndpointParamsInterceptor;
-199
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for DatetimeOffsetsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "DatetimeOffsetsEndpointParamsInterceptor"
-203
+    }
-204
     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::<DatetimeOffsetsInput>()
             .ok_or("failed to downcast to DatetimeOffsetsInput")?;
-219
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-228
+    }
-229
+}
-230
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-233
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod datetime_offsets_test {

↧ Expand context

-237
     /// Ensures that clients can correctly parse datetime (timestamps) with offsets
     /// Test ID: Ec2QueryDateTimeWithNegativeOffset
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn ec2_query_date_time_with_negative_offset_response() {
         let expected_output = crate::operation::datetime_offsets::DatetimeOffsetsOutput::builder()
             .set_datetime(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1576540098, 0_f64,
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "text/xml;charset=UTF-8")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<DatetimeOffsetsResponse xmlns=\"https://example.com/\">\n    <datetime>2019-12-16T22:48:18-01:00</datetime>\n    <requestId>requestid</requestId>\n</DatetimeOffsetsResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-256

tmp-codegen-diff/codegen-client-test/ec2_query/rust-client-codegen/src/operation/empty_input_and_empty_output.rs

@@ -199,199 +260,262 @@

↥ Expand context

-199
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-201
+    }
-202
+}
 #[derive(Debug)]
 struct EmptyInputAndEmptyOutputEndpointParamsInterceptor;
-205
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for EmptyInputAndEmptyOutputEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "EmptyInputAndEmptyOutputEndpointParamsInterceptor"
-209
+    }
-210
     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::<EmptyInputAndEmptyOutputInput>()
             .ok_or("failed to downcast to EmptyInputAndEmptyOutputInput")?;
-225
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-234
+    }
-235
+}
-236
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-239
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod empty_input_and_empty_output_test {

↧ Expand context

-243
     /// Empty input serializes no extra query params
     /// Test ID: Ec2QueryEmptyInputAndEmptyOutput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn ec2_query_empty_input_and_empty_output_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-254
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.empty_input_and_empty_output().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/x-www-form-urlencoded")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(

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

@@ -198,198 +259,261 @@

↥ Expand context

 struct EndpointOperationEndpointParamsInterceptor;
-199
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for EndpointOperationEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "EndpointOperationEndpointParamsInterceptor"
-203
+    }
-204
     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::<EndpointOperationInput>()

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

↧ Expand context

-242
     /// Operations can prepend to the given host if they define the
     /// endpoint trait.
     /// Test ID: Ec2QueryEndpointTrait
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn ec2_query_endpoint_trait_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-254
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.endpoint_operation().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/x-www-form-urlencoded")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");

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

@@ -219,219 +280,282 @@

↥ Expand context

             '_,
             ::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::<EndpointWithHostLabelOperationInput>()
             .ok_or("failed to downcast to EndpointWithHostLabelOperationInput")?;
-230
         let endpoint_prefix = {
             let label = _input.label.as_deref().unwrap_or_default();
             if label.is_empty() {
                 return Err(
                     ::aws_smithy_runtime_api::client::endpoint::error::InvalidEndpointError::failed_to_construct_uri(
                         "label was unset or empty but must be set as part of the endpoint prefix",
-237
+                    )
                     .into(),

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

↧ Expand context

-263
     /// Operations can prepend to the given host if they define the
     /// endpoint trait, and can use the host label trait to define
     /// further customization based on user input.
     /// Test ID: Ec2QueryEndpointTraitWithHostLabel
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn ec2_query_endpoint_trait_with_host_label_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-276
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .endpoint_with_host_label_operation()
             .set_label(::std::option::Option::Some("bar".to_owned()))
             .send()
             .await;

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

@@ -193,193 +254,256 @@

↥ Expand context

-193
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-195
+    }
-196
+}
 #[derive(Debug)]
 struct FractionalSecondsEndpointParamsInterceptor;
-199
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for FractionalSecondsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "FractionalSecondsEndpointParamsInterceptor"
-203
+    }
-204
     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::<FractionalSecondsInput>()
             .ok_or("failed to downcast to FractionalSecondsInput")?;
-219
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-228
+    }
-229
+}
-230
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-233
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod fractional_seconds_test {

↧ Expand context

-237
     /// Ensures that clients can correctly parse datetime timestamps with fractional seconds
     /// Test ID: Ec2QueryDateTimeWithFractionalSeconds
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn ec2_query_date_time_with_fractional_seconds_response() {
         let expected_output = crate::operation::fractional_seconds::FractionalSecondsOutput::builder()
             .set_datetime(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 946845296, 0.123_f64,
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "text/xml;charset=UTF-8")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<FractionalSecondsResponse xmlns=\"https://example.com/\">\n    <datetime>2000-01-02T20:34:56.123Z</datetime>\n    <requestId>requestid</requestId>\n</FractionalSecondsResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-256

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

@@ -193,193 +254,256 @@

↥ Expand context

-193
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-195
+    }
-196
+}
 #[derive(Debug)]
 struct GreetingWithErrorsEndpointParamsInterceptor;
-199
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GreetingWithErrorsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GreetingWithErrorsEndpointParamsInterceptor"
-203
+    }
-204
     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::<GreetingWithErrorsInput>()
             .ok_or("failed to downcast to GreetingWithErrorsInput")?;
-219
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-228
+    }
-229
+}
-230
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-233
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod greeting_with_errors_test {

↧ Expand context

-237
     /// Ensures that operations with errors successfully know how to deserialize the successful response
     /// Test ID: Ec2GreetingWithErrors
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn ec2_greeting_with_errors_response() {
         let expected_output = crate::operation::greeting_with_errors::GreetingWithErrorsOutput::builder()
             .set_greeting(::std::option::Option::Some("Hello".to_owned()))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "text/xml;charset=UTF-8")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<GreetingWithErrorsResponse xmlns=\"https://example.com/\">\n    <greeting>Hello</greeting>\n    <requestId>requestid</requestId>\n</GreetingWithErrorsResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-254
         let op = crate::operation::greeting_with_errors::GreetingWithErrors::new();
         let config = op.config().expect("the operation has config");

Client Test

Files changed: