Client Test

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

@@ -215,215 +276,278 @@

-215
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-217
+    }
-218
+}
 #[derive(Debug)]
 struct StreamingTraitsWithMediaTypeEndpointParamsInterceptor;
-221
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for StreamingTraitsWithMediaTypeEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "StreamingTraitsWithMediaTypeEndpointParamsInterceptor"
-225
+    }
-226
     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::<StreamingTraitsWithMediaTypeInput>()
             .ok_or("failed to downcast to StreamingTraitsWithMediaTypeInput")?;
-241
         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(())
-250
+    }
-251
+}
-252
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-255
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod streaming_traits_with_media_type_test {

↧ Expand context

-259
     /// Serializes a blob in the HTTP payload with a content-type
     /// Test ID: RestJsonStreamingTraitsWithMediaTypeWithBlob
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_streaming_traits_with_media_type_with_blob_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");
-270
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .streaming_traits_with_media_type()
             .set_foo(::std::option::Option::Some("Foo".to_owned()))
             .set_blob(::std::option::Option::Some(::aws_smithy_types::byte_stream::ByteStream::from_static(
                 b"blobby blob blob",
             )))
             .send()

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

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

↥ Expand context

-201
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-203
+    }
-204
+}
 #[derive(Debug)]
 struct TestBodyStructureEndpointParamsInterceptor;
-207
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for TestBodyStructureEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "TestBodyStructureEndpointParamsInterceptor"
-211
+    }
-212
     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::<TestBodyStructureInput>()
             .ok_or("failed to downcast to TestBodyStructureInput")?;
-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 test_body_structure_test {

↧ Expand context

-245
     /// Serializes a structure
     /// Test ID: RestJsonTestBodyStructure
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_test_body_structure_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");
-256
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .test_body_structure()
             .set_test_config(::std::option::Option::Some(
                 crate::types::TestConfig::builder().set_timeout(::std::option::Option::Some(10)).build(),
             ))
             .send()
             .await;

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/test_get_no_input_no_payload.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 TestGetNoInputNoPayloadEndpointParamsInterceptor;
-202
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for TestGetNoInputNoPayloadEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "TestGetNoInputNoPayloadEndpointParamsInterceptor"
-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::<TestGetNoInputNoPayloadInput>()
             .ok_or("failed to downcast to TestGetNoInputNoPayloadInput")?;
-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 test_get_no_input_no_payload_test {

↧ Expand context

-240
     /// Serializes a GET request for an operation with no input, and therefore no modeled body
     /// Test ID: RestJsonHttpGetWithNoInput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_get_with_no_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");
-251
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.test_get_no_input_no_payload().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let forbidden_headers = &["Content-Type", "Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::forbid_headers(http_request.headers(), forbidden_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.

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

@@ -197,197 +258,260 @@

↥ Expand context

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

         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<TestGetNoPayloadInput>()
             .ok_or("failed to downcast to TestGetNoPayloadInput")?;
-223
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-232
+    }
-233
+}
-234
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-237
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod test_get_no_payload_test {

↧ Expand context

-241
     /// Serializes a GET request with no modeled body
     /// Test ID: RestJsonHttpGetWithNoModeledBody
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_get_with_no_modeled_body_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");
-252
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.test_get_no_payload().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let forbidden_headers = &["Content-Length", "Content-Type"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::forbid_headers(http_request.headers(), forbidden_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.

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

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

↥ Expand context

-201
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-203
+    }
-204
+}
 #[derive(Debug)]
 struct TestPayloadBlobEndpointParamsInterceptor;
-207
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for TestPayloadBlobEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "TestPayloadBlobEndpointParamsInterceptor"
-211
+    }
-212
     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::<TestPayloadBlobInput>()
             .ok_or("failed to downcast to TestPayloadBlobInput")?;
-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 test_payload_blob_test {

↧ Expand context

-245
     /// Serializes a payload targeting an empty blob
     /// Test ID: RestJsonHttpWithEmptyBlobPayload
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_with_empty_blob_payload_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");
-256
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.test_payload_blob().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/test_payload_structure.rs

@@ -203,203 +264,266 @@

↥ Expand context

-203
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-205
+    }
-206
+}
 #[derive(Debug)]
 struct TestPayloadStructureEndpointParamsInterceptor;
-209
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for TestPayloadStructureEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "TestPayloadStructureEndpointParamsInterceptor"
-213
+    }
-214
     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::<TestPayloadStructureInput>()
             .ok_or("failed to downcast to TestPayloadStructureInput")?;
-229
         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(())
-238
+    }
-239
+}
-240
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-243
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod test_payload_structure_test {

↧ Expand context

-247
     /// Serializes a payload targeting an empty structure
     /// Test ID: RestJsonHttpWithEmptyStructurePayload
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_with_empty_structure_payload_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");
-258
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .test_payload_structure()
             .set_payload_config(::std::option::Option::Some(crate::types::PayloadConfig::builder().build()))
             .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/test_post_no_input_no_payload.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 TestPostNoInputNoPayloadEndpointParamsInterceptor;
-202
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for TestPostNoInputNoPayloadEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "TestPostNoInputNoPayloadEndpointParamsInterceptor"
-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::<TestPostNoInputNoPayloadInput>()
             .ok_or("failed to downcast to TestPostNoInputNoPayloadInput")?;
-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 test_post_no_input_no_payload_test {

↧ Expand context

-240
     /// Serializes a POST request for an operation with no input, and therefore no modeled body
     /// Test ID: RestJsonHttpPostWithNoInput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_post_with_no_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");
-251
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.test_post_no_input_no_payload().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let forbidden_headers = &["Content-Type"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::forbid_headers(http_request.headers(), forbidden_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.

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

@@ -197,197 +258,260 @@

↥ Expand context

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

         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<TestPostNoPayloadInput>()
             .ok_or("failed to downcast to TestPostNoPayloadInput")?;
-223
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-232
+    }
-233
+}
-234
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-237
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod test_post_no_payload_test {

↧ Expand context

-241
     /// Serializes a POST request with no modeled body
     /// Test ID: RestJsonHttpPostWithNoModeledBody
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_post_with_no_modeled_body_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");
-252
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.test_post_no_payload().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let forbidden_headers = &["Content-Type"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::forbid_headers(http_request.headers(), forbidden_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.

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

@@ -197,197 +258,260 @@

↥ Expand context

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

         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<TimestampFormatHeadersInput>()
             .ok_or("failed to downcast to TimestampFormatHeadersInput")?;
-223
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-232
+    }
-233
+}
-234
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-237
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod timestamp_format_headers_test {

↧ Expand context

-241
     /// Tests how timestamp request headers are serialized
     /// Test ID: RestJsonTimestampFormatHeaders
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_timestamp_format_headers_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");
-252
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .timestamp_format_headers()
             .set_member_epoch_seconds(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1576540098, 0_f64,
             )))
             .set_member_http_date(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1576540098, 0_f64,

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/unit_input_and_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 UnitInputAndOutputEndpointParamsInterceptor;
-202
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UnitInputAndOutputEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "UnitInputAndOutputEndpointParamsInterceptor"
-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::<UnitInputAndOutputInput>()
             .ok_or("failed to downcast to UnitInputAndOutputInput")?;
-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 unit_input_and_output_test {

↧ Expand context

-240
     /// A unit type input serializes no payload. When clients do not
     /// need to serialize any data in the payload, they should omit
     /// a payload altogether.
     /// Test ID: RestJsonUnitInputAndOutput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_unit_input_and_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.unit_input_and_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_extras/rust-client-codegen/src/operation/case_insensitive_error_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 CaseInsensitiveErrorOperationEndpointParamsInterceptor;
-202
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CaseInsensitiveErrorOperationEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "CaseInsensitiveErrorOperationEndpointParamsInterceptor"
-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::<CaseInsensitiveErrorOperationInput>()
             .ok_or("failed to downcast to CaseInsensitiveErrorOperationInput")?;
-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 case_insensitive_error_operation_test {

↧ Expand context

-240
     /// Upper case error modeled lower case. See: https://github.com/smithy-lang/smithy-rs/blob/6c21fb0eb377c7120a8179f4537ba99a4b50ba96/rust-runtime/inlineable/src/json_errors.rs#L51-L51
     /// Test ID: UpperErrorModeledLower
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn upper_error_modeled_lower_response() {
         let expected_output = crate::types::error::CaseInsensitiveError::builder()
             .set_message(::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-Amzn-Errortype", "CaseInsensitiveError")
                 .status(500)
                 .body(::aws_smithy_types::body::SdkBody::from("{\"Message\": \"hello\"}"))
                 .unwrap(),
-255
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-259

tmp-codegen-diff/codegen-client-test/rest_json_extras/rust-client-codegen/src/operation/empty_struct_with_content_on_wire_op.rs

@@ -200,200 +261,263 @@

↥ Expand context

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

         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<EmptyStructWithContentOnWireOpInput>()
             .ok_or("failed to downcast to EmptyStructWithContentOnWireOpInput")?;
-226
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-235
+    }
-236
+}
-237
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-240
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod empty_struct_with_content_on_wire_op_test {

↧ Expand context

-244
     /// Test ID: EmptyStructWithContentOnWire
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn empty_struct_with_content_on_wire_response() {
         let expected_output = crate::operation::empty_struct_with_content_on_wire_op::EmptyStructWithContentOnWireOpOutput::builder()
             .set_empty(::std::option::Option::Some(crate::types::EmptyStruct::builder().build()))
             .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("{\"empty\": {\"value\":\"not actually empty\"}}"))
                 .unwrap(),
-257
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-261
         let op = crate::operation::empty_struct_with_content_on_wire_op::EmptyStructWithContentOnWireOp::new();
         let config = op.config().expect("the operation has config");

tmp-codegen-diff/codegen-client-test/rest_json_extras/rust-client-codegen/src/operation/enum_query.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 EnumQueryEndpointParamsInterceptor;
-205
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for EnumQueryEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "EnumQueryEndpointParamsInterceptor"
-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::<EnumQueryInput>()
             .ok_or("failed to downcast to EnumQueryInput")?;
-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 enum_query_test {

↧ Expand context

-243
     /// Test ID: EnumQueryRequest
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn enum_query_request_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
             .enum_query()
             .set_enum(::std::option::Option::Some(
                 "enumvalue".parse::<crate::types::StringEnum>().expect("static value validated to member"),
             ))
             .send()
             .await;
         let _ = dbg!(result);

tmp-codegen-diff/codegen-client-test/rest_json_extras/rust-client-codegen/src/operation/escaped_string_values.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 EscapedStringValuesEndpointParamsInterceptor;
-208
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for EscapedStringValuesEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "EscapedStringValuesEndpointParamsInterceptor"
-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::<EscapedStringValuesInput>()
             .ok_or("failed to downcast to EscapedStringValuesInput")?;
-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 escaped_string_values_test {

↧ Expand context

-246
     /// Test ID: EscapedStringValuesRequest
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn escaped_string_values_request_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");
-256
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .escaped_string_values()
             .set_enum(::std::option::Option::Some(
                 "has\"quotes"
                     .parse::<crate::types::EnumWithEscapedChars>()
                     .expect("static value validated to member"),
             ))
             .set_some_string(::std::option::Option::Some("test".to_owned()))

tmp-codegen-diff/codegen-client-test/rest_json_extras/rust-client-codegen/src/operation/map_with_enum_key_op.rs

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

↥ Expand context

-201
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-203
+    }
-204
+}
 #[derive(Debug)]
 struct MapWithEnumKeyOpEndpointParamsInterceptor;
-207
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MapWithEnumKeyOpEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MapWithEnumKeyOpEndpointParamsInterceptor"
-211
+    }
-212
     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::<MapWithEnumKeyOpInput>()
             .ok_or("failed to downcast to MapWithEnumKeyOpInput")?;
-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 map_with_enum_key_op_test {

↧ Expand context

-245
     /// Test ID: MapWithEnumKeyRequest
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn map_with_enum_key_request_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");
-255
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .map_with_enum_key_op()
             .set_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "enumvalue".parse::<crate::types::StringEnum>().expect("static value validated to member"),
                     "something".to_owned(),
                 );

tmp-codegen-diff/codegen-client-test/rest_json_extras/rust-client-codegen/src/operation/null_in_non_sparse.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 NullInNonSparseEndpointParamsInterceptor;
-202
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for NullInNonSparseEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "NullInNonSparseEndpointParamsInterceptor"
-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::<NullInNonSparseInput>()
             .ok_or("failed to downcast to NullInNonSparseInput")?;
-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 null_in_non_sparse_test {

↧ Expand context

-240
     /// Test ID: NullInNonSparse
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn null_in_non_sparse_response() {
         let expected_output = crate::operation::null_in_non_sparse::NullInNonSparseOutput::builder()
             .set_list(::std::option::Option::Some(vec!["one".to_owned(), "two".to_owned()]))
             .set_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("one".to_owned(), "1".to_owned());
                 ret
             }))
             .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(
                     "{\"list\":[null,\"one\",null,\"two\",null],\"map\":{\"zero\":null,\"one\":\"1\"}}",
                 ))
                 .unwrap(),

Client Test

Files changed: