Client Test

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

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

-197
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-199
+    }
-200
+}
 #[derive(Debug)]
 struct HttpEmptyPrefixHeadersEndpointParamsInterceptor;
-203
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for HttpEmptyPrefixHeadersEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "HttpEmptyPrefixHeadersEndpointParamsInterceptor"
-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::<HttpEmptyPrefixHeadersInput>()
             .ok_or("failed to downcast to HttpEmptyPrefixHeadersInput")?;
-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 http_empty_prefix_headers_test {

↧ Expand context

-241
     /// Serializes all request headers, using specific when present
     /// Test ID: RestJsonHttpEmptyPrefixHeadersRequestClient
     #[::tokio::test]
     #[::tracing_test::traced_test]
     #[should_panic]
     async fn rest_json_http_empty_prefix_headers_request_client_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
             .http_empty_prefix_headers()
             .set_prefix_headers(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x-foo".to_owned().to_ascii_lowercase(), "Foo".to_owned());
                 ret.insert("hello".to_owned().to_ascii_lowercase(), "Hello".to_owned());

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

↧ Expand context

-246
     /// Test ID: RestJsonEnumPayloadRequest
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_enum_payload_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
             .http_enum_payload()
             .set_payload(::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/rust-client-codegen/src/operation/http_payload_traits.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 HttpPayloadTraitsEndpointParamsInterceptor;
-208
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for HttpPayloadTraitsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "HttpPayloadTraitsEndpointParamsInterceptor"
-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::<HttpPayloadTraitsInput>()
             .ok_or("failed to downcast to HttpPayloadTraitsInput")?;
-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_payload_traits_test {

↧ Expand context

-246
     /// Serializes a blob in the HTTP payload
     /// Test ID: RestJsonHttpPayloadTraitsWithBlob
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_payload_traits_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");
-257
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .http_payload_traits()
             .set_foo(::std::option::Option::Some("Foo".to_owned()))
             .set_blob(::std::option::Option::Some(::aws_smithy_types::Blob::new("blobby blob blob")))
             .send()
             .await;
         let _ = dbg!(result);

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

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

↥ Expand context

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

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

↧ Expand context

-251
     /// Serializes a blob in the HTTP payload with a content-type
     /// Test ID: RestJsonHttpPayloadTraitsWithMediaTypeWithBlob
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_payload_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");
-262
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .http_payload_traits_with_media_type()
             .set_foo(::std::option::Option::Some("Foo".to_owned()))
             .set_blob(::std::option::Option::Some(::aws_smithy_types::Blob::new("blobby blob blob")))
             .send()
             .await;
         let _ = dbg!(result);

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

↧ Expand context

-246
     /// Serializes a structure in the payload
     /// Test ID: RestJsonHttpPayloadWithStructure
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_payload_with_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");
-257
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .http_payload_with_structure()
             .set_nested(::std::option::Option::Some(
                 crate::types::NestedPayload::builder()
                     .set_greeting(::std::option::Option::Some("hello".to_owned()))
                     .set_name(::std::option::Option::Some("Phreddy".to_owned()))
                     .build(),

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

↧ Expand context

-246
     /// Serializes a union in the payload.
     /// Test ID: RestJsonHttpPayloadWithUnion
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_payload_with_union_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_payload_with_union()
             .set_nested(::std::option::Option::Some(crate::types::UnionPayload::Greeting("hello".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/http_prefix_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 HttpPrefixHeadersEndpointParamsInterceptor;
-203
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for HttpPrefixHeadersEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "HttpPrefixHeadersEndpointParamsInterceptor"
-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::<HttpPrefixHeadersInput>()
             .ok_or("failed to downcast to HttpPrefixHeadersInput")?;
-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 http_prefix_headers_test {

↧ Expand context

-241
     /// Adds headers by prefix
     /// Test ID: RestJsonHttpPrefixHeadersArePresent
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_prefix_headers_are_present_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
             .http_prefix_headers()
             .set_foo(::std::option::Option::Some("Foo".to_owned()))
             .set_foo_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("abc".to_owned().to_ascii_lowercase(), "Abc value".to_owned());
                 ret.insert("def".to_owned().to_ascii_lowercase(), "Def value".to_owned());

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

↧ Expand context

-240
     /// (de)serializes all response headers
     /// Test ID: HttpPrefixHeadersResponse
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn http_prefix_headers_response_response() {
         let expected_output = crate::operation::http_prefix_headers_in_response::HttpPrefixHeadersInResponseOutput::builder()
             .set_prefix_headers(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x-foo".to_owned().to_ascii_lowercase(), "Foo".to_owned());
                 ret.insert("hello".to_owned().to_ascii_lowercase(), "Hello".to_owned());
                 ret
             }))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("hello", "Hello")
                 .header("x-foo", "Foo")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(vec![]))

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

@@ -220,220 +281,283 @@

↥ Expand context

-220
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-222
+    }
-223
+}
 #[derive(Debug)]
 struct HttpRequestWithFloatLabelsEndpointParamsInterceptor;
-226
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for HttpRequestWithFloatLabelsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "HttpRequestWithFloatLabelsEndpointParamsInterceptor"
-230
+    }
-231
     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::<HttpRequestWithFloatLabelsInput>()
             .ok_or("failed to downcast to HttpRequestWithFloatLabelsInput")?;
-246
         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(())
-255
+    }
-256
+}
-257
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-260
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_request_with_float_labels_test {

↧ Expand context

-264
     /// Supports handling NaN float label values.
     /// Test ID: RestJsonSupportsNaNFloatLabels
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_supports_na_n_float_labels_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");
-275
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .http_request_with_float_labels()
             .set_float(::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number"),
             ))
             .set_double(::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number"),

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

@@ -223,223 +284,286 @@

↥ Expand context

-223
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-225
+    }
-226
+}
 #[derive(Debug)]
 struct HttpRequestWithGreedyLabelInPathEndpointParamsInterceptor;
-229
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for HttpRequestWithGreedyLabelInPathEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "HttpRequestWithGreedyLabelInPathEndpointParamsInterceptor"
-233
+    }
-234
     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::<HttpRequestWithGreedyLabelInPathInput>()
             .ok_or("failed to downcast to HttpRequestWithGreedyLabelInPathInput")?;
-249
         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(())
-258
+    }
-259
+}
-260
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-263
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_request_with_greedy_label_in_path_test {

↧ Expand context

-267
     /// Serializes greedy labels and normal labels
     /// Test ID: RestJsonHttpRequestWithGreedyLabelInPath
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_request_with_greedy_label_in_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");
-278
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .http_request_with_greedy_label_in_path()
             .set_foo(::std::option::Option::Some("hello/escape".to_owned()))
             .set_baz(::std::option::Option::Some("there/guy".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);

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

@@ -302,302 +363,365 @@

↥ Expand context

-302
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-304
+    }
-305
+}
 #[derive(Debug)]
 struct HttpRequestWithLabelsEndpointParamsInterceptor;
-308
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for HttpRequestWithLabelsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "HttpRequestWithLabelsEndpointParamsInterceptor"
-312
+    }
-313
     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::<HttpRequestWithLabelsInput>()
             .ok_or("failed to downcast to HttpRequestWithLabelsInput")?;
-328
         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(())
-337
+    }
-338
+}
-339
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-342
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_request_with_labels_test {

↧ Expand context

-346
     /// Sends a GET request that uses URI label bindings
     /// Test ID: RestJsonInputWithHeadersAndAllParams
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_input_with_headers_and_all_params_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");
-357
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .http_request_with_labels()
             .set_string(::std::option::Option::Some("string".to_owned()))
             .set_short(::std::option::Option::Some(1))
             .set_integer(::std::option::Option::Some(2))
             .set_long(::std::option::Option::Some(3))
             .set_float(::std::option::Option::Some(4.1_f32))

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

@@ -277,277 +338,340 @@

↥ Expand context

-277
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-279
+    }
-280
+}
 #[derive(Debug)]
 struct HttpRequestWithLabelsAndTimestampFormatEndpointParamsInterceptor;
-283
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for HttpRequestWithLabelsAndTimestampFormatEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "HttpRequestWithLabelsAndTimestampFormatEndpointParamsInterceptor"
-287
+    }
-288
     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::<HttpRequestWithLabelsAndTimestampFormatInput>()
             .ok_or("failed to downcast to HttpRequestWithLabelsAndTimestampFormatInput")?;
-303
         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(())
-312
+    }
-313
+}
-314
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-317
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_request_with_labels_and_timestamp_format_test {

↧ Expand context

-321
     /// Serializes different timestamp formats in URI labels
     /// Test ID: RestJsonHttpRequestWithLabelsAndTimestampFormat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_request_with_labels_and_timestamp_format_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");
-332
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .http_request_with_labels_and_timestamp_format()
             .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/http_request_with_regex_literal.rs

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

↥ Expand context

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

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

↧ Expand context

-251
     /// Path matching is not broken by regex expressions in literal segments
     /// Test ID: RestJsonToleratesRegexCharsInSegments
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_tolerates_regex_chars_in_segments_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");
-262
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .http_request_with_regex_literal()
             .set_str(::std::option::Option::Some("abc".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/http_response_code.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 HttpResponseCodeEndpointParamsInterceptor;
-202
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for HttpResponseCodeEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "HttpResponseCodeEndpointParamsInterceptor"
-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::<HttpResponseCodeInput>()
             .ok_or("failed to downcast to HttpResponseCodeInput")?;
-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 http_response_code_test {

↧ Expand context

-240
     /// Binds the http response code to an output structure. Note that
     /// even though all members are bound outside of the payload, an
     /// empty JSON object is serialized in the response. However,
     /// clients should be able to handle an empty JSON object or an
     /// empty payload without failing to deserialize a response.
     /// Test ID: RestJsonHttpResponseCode
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_response_code_response() {
         let expected_output = crate::operation::http_response_code::HttpResponseCodeOutput::builder()
             .set_status(::std::option::Option::Some(201))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(201)
                 .body(::aws_smithy_types::body::SdkBody::from("{}"))
                 .unwrap(),
-259
+        )

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

↧ Expand context

-246
     /// Test ID: RestJsonStringPayloadRequest
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_string_payload_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
             .http_string_payload()
             .set_payload(::std::option::Option::Some("rawstring".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "text/plain")];

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

↧ Expand context

-240
     /// Query parameters must be ignored when serializing the output
     /// of an operation. As of January 2021, server implementations
     /// are expected to respond with a JSON object regardless of
     /// if the output parameters are empty.
     /// Test ID: RestJsonIgnoreQueryParamsInResponse
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_ignore_query_params_in_response_response() {
         let expected_output = crate::operation::ignore_query_params_in_response::IgnoreQueryParamsInResponseOutput::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("{}"))
                 .unwrap(),
-256
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;

Client Test

Files changed: