Client Test

tmp-codegen-diff/codegen-client-test/query-compat-test/rust-client-codegen/src/operation/operation.rs

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

-196
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-198
+    }
-199
+}
 #[derive(Debug)]
 struct OperationEndpointParamsInterceptor;
-202
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for OperationEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "OperationEndpointParamsInterceptor"
-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::<OperationInput>()
             .ok_or("failed to downcast to OperationInput")?;
-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
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod operation_test {

↧ Expand context

-240
     /// Test ID: BasicQueryCompatTest
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn basic_query_compat_test_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");
-250
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .operation()
             .set_message(::std::option::Option::Some("hello!".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("x-amz-target", "QueryCompatService.Operation"), ("x-amzn-query-mode", "true")];

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/all_query_string_types.rs

@@ -361,361 +422,424 @@

↥ Expand context

-361
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-363
+    }
-364
+}
 #[derive(Debug)]
 struct AllQueryStringTypesEndpointParamsInterceptor;
-367
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for AllQueryStringTypesEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "AllQueryStringTypesEndpointParamsInterceptor"
-371
+    }
-372
     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::<AllQueryStringTypesInput>()
             .ok_or("failed to downcast to AllQueryStringTypesInput")?;
-387
         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(())
-396
+    }
-397
+}
-398
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-401
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod all_query_string_types_test {

↧ Expand context

-405
     /// Serializes query string parameters with all supported types
     /// Test ID: RestJsonAllQueryStringTypes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_all_query_string_types_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");
-416
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .all_query_string_types()
             .set_query_string(::std::option::Option::Some("Hello there".to_owned()))
             .set_query_string_list(::std::option::Option::Some(vec!["a".to_owned(), "b".to_owned(), "c".to_owned()]))
             .set_query_string_set(::std::option::Option::Some(vec!["a".to_owned(), "b".to_owned(), "c".to_owned()]))
             .set_query_byte(::std::option::Option::Some(1))
             .set_query_short(::std::option::Option::Some(2))

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/constant_and_variable_query_string.rs

@@ -217,217 +278,280 @@

↥ Expand context

-217
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-219
+    }
-220
+}
 #[derive(Debug)]
 struct ConstantAndVariableQueryStringEndpointParamsInterceptor;
-223
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ConstantAndVariableQueryStringEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ConstantAndVariableQueryStringEndpointParamsInterceptor"
-227
+    }
-228
     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::<ConstantAndVariableQueryStringInput>()
             .ok_or("failed to downcast to ConstantAndVariableQueryStringInput")?;
-243
         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(())
-252
+    }
-253
+}
-254
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-257
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod constant_and_variable_query_string_test {

↧ Expand context

-261
     /// Mixes constant and variable query string parameters
     /// Test ID: RestJsonConstantAndVariableQueryStringMissingOneValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_constant_and_variable_query_string_missing_one_value_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-272
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .constant_and_variable_query_string()
             .set_baz(::std::option::Option::Some("bam".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/constant_query_string.rs

@@ -217,217 +278,280 @@

↥ Expand context

-217
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-219
+    }
-220
+}
 #[derive(Debug)]
 struct ConstantQueryStringEndpointParamsInterceptor;
-223
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ConstantQueryStringEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ConstantQueryStringEndpointParamsInterceptor"
-227
+    }
-228
     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::<ConstantQueryStringInput>()
             .ok_or("failed to downcast to ConstantQueryStringInput")?;
-243
         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(())
-252
+    }
-253
+}
-254
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-257
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod constant_query_string_test {

↧ Expand context

-261
     /// Includes constant query string parameters
     /// Test ID: RestJsonConstantQueryString
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_constant_query_string_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");
-272
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .constant_query_string()
             .set_hello(::std::option::Option::Some("hi".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/content_type_parameters.rs

@@ -202,202 +263,265 @@

↥ Expand context

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

↧ Expand context

 pub enum ContentTypeParametersError {
     /// 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()`:
-250
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-252
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-ContentTypeParametersError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-255
+}
 impl ContentTypeParametersError {
     /// Creates the `ContentTypeParametersError::Unhandled` variant from any error type.
     pub fn unhandled(
         err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,
     ) -> Self {
         Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
             source: err.into(),
             meta: ::std::default::Default::default(),
         })
-265
+    }

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/datetime_offsets.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 DatetimeOffsetsEndpointParamsInterceptor;
-202
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for DatetimeOffsetsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "DatetimeOffsetsEndpointParamsInterceptor"
-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::<DatetimeOffsetsInput>()
             .ok_or("failed to downcast to DatetimeOffsetsInput")?;
-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
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod datetime_offsets_test {

↧ Expand context

-240
     /// Ensures that clients can correctly parse datetime (timestamps) with offsets
     /// Test ID: RestJsonDateTimeWithNegativeOffset
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_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()
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "      {\n          \"datetime\": \"2019-12-16T22:48:18-01:00\"\n      }\n",
                 ))
                 .unwrap(),
-258
+        )
         .unwrap();

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/document_type.rs

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

↥ Expand context

-194
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-196
+    }
-197
+}
 #[derive(Debug)]
 struct DocumentTypeEndpointParamsInterceptor;
-200
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for DocumentTypeEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "DocumentTypeEndpointParamsInterceptor"
-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::<DocumentTypeInput>()
             .ok_or("failed to downcast to DocumentTypeInput")?;
-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
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod document_type_test {

↧ Expand context

-238
     /// Serializes document types as part of the JSON request payload with no escaping.
     /// Test ID: DocumentTypeInputWithObject
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn document_type_input_with_object_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");
-249
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .document_type()
             .set_string_value(::std::option::Option::Some("string".to_owned()))
             .set_document_value(::std::option::Option::Some({
                 let json_bytes = br#"{
                         "foo": "bar"
                     }"#;

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/document_type_as_map_value.rs

@@ -202,202 +263,265 @@

↥ Expand context

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

↧ Expand context

-246
     /// Serializes a map that uses documents as the value.
     /// Test ID: DocumentTypeAsMapValueInput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn document_type_as_map_value_input_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-257
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .document_type_as_map_value()
             .set_doc_valued_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("foo".to_owned(), {
                     let json_bytes = br#"{
                                 "f": 1,

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/document_type_as_payload.rs

@@ -202,202 +263,265 @@

↥ Expand context

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

↧ Expand context

-246
     /// Serializes a document as the target of the httpPayload trait.
     /// Test ID: DocumentTypeAsPayloadInput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn document_type_as_payload_input_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-257
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .document_type_as_payload()
             .set_document_value(::std::option::Option::Some({
                 let json_bytes = br#"{
                         "foo": "bar"
                     }"#;
                 let mut tokens = ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/empty_input_and_empty_output.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 EmptyInputAndEmptyOutputEndpointParamsInterceptor;
-202
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for EmptyInputAndEmptyOutputEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "EmptyInputAndEmptyOutputEndpointParamsInterceptor"
-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::<EmptyInputAndEmptyOutputInput>()
             .ok_or("failed to downcast to EmptyInputAndEmptyOutputInput")?;
-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
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod empty_input_and_empty_output_test {

↧ Expand context

-240
     /// Clients should not serialize a JSON payload when no parameters
     /// are given that are sent in the body. A service will tolerate
     /// clients that omit a payload or that send a JSON object.
     /// Test ID: RestJsonEmptyInputAndEmptyOutput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_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");
-253
         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 body = http_request.body().bytes().expect("body should be strict");
         // No body.

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

@@ -201,201 +262,264 @@

↥ Expand context

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

             .ok_or("failed to downcast to EndpointOperationInput")?;
-222
         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);
-227
         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(())
-236
+    }
-237
+}
-238
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-241
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod endpoint_operation_test {

↧ Expand context

-245
     /// Operations can prepend to the given host if they define the
     /// endpoint trait.
     /// Test ID: RestJsonEndpointTrait
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_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");
-257
         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 body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &::bytes::Bytes::new());

tmp-codegen-diff/codegen-client-test/rest_json/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: RestJsonEndpointTraitWithHostLabel
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_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/rest_json/rust-client-codegen/src/operation/fractional_seconds.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 FractionalSecondsEndpointParamsInterceptor;
-202
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for FractionalSecondsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "FractionalSecondsEndpointParamsInterceptor"
-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::<FractionalSecondsInput>()
             .ok_or("failed to downcast to FractionalSecondsInput")?;
-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
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod fractional_seconds_test {

↧ Expand context

-240
     /// Ensures that clients can correctly parse datetime timestamps with fractional seconds
     /// Test ID: RestJsonDateTimeWithFractionalSeconds
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_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()
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "      {\n          \"datetime\": \"2000-01-02T20:34:56.123Z\"\n      }\n",
                 ))
                 .unwrap(),
-258
+        )
         .unwrap();

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/greeting_with_errors.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 GreetingWithErrorsEndpointParamsInterceptor;
-202
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GreetingWithErrorsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GreetingWithErrorsEndpointParamsInterceptor"
-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::<GreetingWithErrorsInput>()
             .ok_or("failed to downcast to GreetingWithErrorsInput")?;
-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
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod greeting_with_errors_test {

↧ Expand context

-240
     /// Ensures that operations with errors successfully know how
     /// to deserialize a successful response. As of January 2021,
     /// server implementations are expected to respond with a
     /// JSON object regardless of if the output parameters are
     /// empty.
     /// Test ID: RestJsonGreetingWithErrors
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_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("X-Greeting", "Hello")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("{}"))
                 .unwrap(),
-259
+        )

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/host_with_path_operation.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 HostWithPathOperationEndpointParamsInterceptor;
-202
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for HostWithPathOperationEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "HostWithPathOperationEndpointParamsInterceptor"
-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::<HostWithPathOperationInput>()
             .ok_or("failed to downcast to HostWithPathOperationInput")?;
-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
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod host_with_path_operation_test {

↧ Expand context

-240
     /// Custom endpoints supplied by users can have paths
     /// Test ID: RestJsonHostWithPath
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_host_with_path_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com/custom");
-251
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.host_with_path_operation().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &::bytes::Bytes::new());
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/http_checksum_required.rs

@@ -202,202 +263,265 @@

↥ Expand context

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

↧ Expand context

-246
     /// Adds Content-MD5 header
     /// Test ID: RestJsonHttpChecksumRequired
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_checksum_required_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");
-257
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .http_checksum_required()
             .set_foo(::std::option::Option::Some("base64 encoded md5 checksum".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();

Client Test

Files changed: