Client Test

rev. c4f9295a7b4566dca79c361e3a2aa9e63cdf82e7

Files changed:

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

@@ -210,210 +302,302 @@

             ::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")?;
-218
         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(())
-225
+    }
-226
+}
-227
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.

-230
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_payload_traits_test {
-234
     /// 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_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-242
         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);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/octet-stream"), ("X-Foo", "Foo")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "blobby blob blob",
             ::aws_smithy_protocol_test::MediaType::from("application/octet-stream"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/HttpPayloadTraits", "path was incorrect");
-265
+    }
-266
     /// Serializes an empty blob in the HTTP payload
     /// Test ID: RestJsonHttpPayloadTraitsWithNoBlobBody
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_payload_traits_with_no_blob_body_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-274
         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()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();

↧ Expand context

         let expected_headers = [("X-Foo", "Foo")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &bytes::Bytes::new());
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/HttpPayloadTraits", "path was incorrect");
-291
+    }
-292
     /// 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_response() {
         let expected_output = crate::operation::http_payload_traits::HttpPayloadTraitsOutput::builder()
             .set_foo(::std::option::Option::Some("Foo".to_owned()))
             .set_blob(::std::option::Option::Some(::aws_smithy_types::Blob::new("blobby blob blob")))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(

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

@@ -215,215 +275,275 @@

↥ Expand context

             ::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")?;
-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(())
-230
+    }
-231
+}
-232
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.

-235
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_payload_traits_with_media_type_test {
-239
     /// 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_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-247
         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);

↧ Expand context

         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "text/plain"), ("X-Foo", "Foo")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "blobby blob blob",
             ::aws_smithy_protocol_test::MediaType::from("application/octet-stream"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/HttpPayloadTraitsWithMediaType", "path was incorrect");
-270
+    }
-271
     /// Serializes a blob in the HTTP payload with a content-type
     /// Test ID: RestJsonHttpPayloadTraitsWithMediaTypeWithBlob
     #[::tokio::test]
     #[::tracing_test::traced_test]

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

@@ -210,210 +270,270 @@

↥ Expand context

             ::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")?;
-218
         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(())
-225
+    }
-226
+}
-227
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.

-230
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_payload_with_structure_test {
-234
     /// 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_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-242
         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(),

↧ Expand context

             ))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/json")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "{\n    \"greeting\": \"hello\",\n    \"name\": \"Phreddy\"\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/HttpPayloadWithStructure", "path was incorrect");
-269
+    }
-270

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

@@ -210,210 +301,301 @@

↥ Expand context

             ::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")?;
-218
         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(())
-225
+    }
-226
+}
-227
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.

-230
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_payload_with_union_test {
-234
     /// 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_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-242
         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();
         let expected_headers = [("Content-Type", "application/json")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "{\n    \"greeting\": \"hello\"\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/HttpPayloadWithUnion", "path was incorrect");
-264
+    }
-265
     /// No payload is sent if the union has no value.
     /// Test ID: RestJsonHttpPayloadWithUnsetUnion
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_payload_with_unset_union_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-273
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.http_payload_with_union().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");

↧ Expand context

         ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/HttpPayloadWithUnion", "path was incorrect");
-284
+    }
-285
     /// Serializes a union in the payload.
     /// Test ID: RestJsonHttpPayloadWithUnion
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_payload_with_union_response() {
         let expected_output = crate::operation::http_payload_with_union::HttpPayloadWithUnionOutput::builder()
             .set_nested(::std::option::Option::Some(crate::types::UnionPayload::Greeting("hello".to_owned())))
             .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("{\n    \"greeting\": \"hello\"\n}"))
                 .unwrap(),
-300
+        )
         .unwrap();

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

@@ -205,205 +324,324 @@

↥ Expand context

             ::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")?;
-213
         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(())
-220
+    }
-221
+}
-222
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.

-225
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_prefix_headers_test {
-229
     /// 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_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-237
         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());
                 ret
             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("X-Foo", "Foo"), ("X-Foo-Abc", "Abc value"), ("X-Foo-Def", "Def value")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &bytes::Bytes::new());
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/HttpPrefixHeaders", "path was incorrect");
-260
+    }
-261
     /// No prefix headers are serialized because the value is not present
     /// Test ID: RestJsonHttpPrefixHeadersAreNotPresent
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_prefix_headers_are_not_present_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-269
         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(::std::collections::HashMap::new()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("X-Foo", "Foo")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &bytes::Bytes::new());
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/HttpPrefixHeaders", "path was incorrect");
-287
+    }
-288
     /// Serialize prefix headers were the value is present but empty
     /// Test ID: RestJsonHttpPrefixEmptyHeaders
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_prefix_empty_headers_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-296
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .http_prefix_headers()
             .set_foo_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("Abc".to_owned().to_ascii_lowercase(), "".to_owned());
                 ret
             }))

↧ Expand context

             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("X-Foo-Abc", "")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &bytes::Bytes::new());
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/HttpPrefixHeaders", "path was incorrect");
-317
+    }
-318
     /// Adds headers by prefix
     /// Test ID: RestJsonHttpPrefixHeadersArePresent
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_prefix_headers_are_present_response() {
         let expected_output = crate::operation::http_prefix_headers::HttpPrefixHeadersOutput::builder()

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

@@ -228,228 +346,346 @@

↥ Expand context

             ::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")?;
-236
         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(())
-243
+    }
-244
+}
-245
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.

-248
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_request_with_float_labels_test {
-252
     /// 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_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-260
         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"),
             ))
             .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");
         ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/FloatHttpLabels/NaN/NaN", "path was incorrect");
-280
+    }
-281
     /// Supports handling Infinity float label values.
     /// Test ID: RestJsonSupportsInfinityFloatLabels
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_supports_infinity_float_labels_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-289
         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("Infinity").expect("invalid string for number"),
             ))
             .set_double(::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number"),
             ))
             .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");
         ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/FloatHttpLabels/Infinity/Infinity", "path was incorrect");
-309
+    }
-310
     /// Supports handling -Infinity float label values.
     /// Test ID: RestJsonSupportsNegativeInfinityFloatLabels
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_supports_negative_infinity_float_labels_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-318
         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("-Infinity").expect("invalid string for number"),
             ))
             .set_double(::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number"),

↧ Expand context

             ))
             .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");
         ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/FloatHttpLabels/-Infinity/-Infinity", "path was incorrect");
-338
+    }
-339
+}
-340
 /// Error type for the `HttpRequestWithFloatLabelsError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum HttpRequestWithFloatLabelsError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \

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

@@ -231,231 +291,291 @@

↥ Expand context

             ::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")?;
-239
         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(())
-246
+    }
-247
+}
-248
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.

-251
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_request_with_greedy_label_in_path_test {
-255
     /// 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_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-263
         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);

↧ Expand context

         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");
         ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(
             uri.path(),
             "/HttpRequestWithGreedyLabelInPath/foo/hello%2Fescape/baz/there/guy",
             "path was incorrect"
         );
-283
+    }
-284
+}
-285
 /// Error type for the `HttpRequestWithGreedyLabelInPathError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum HttpRequestWithGreedyLabelInPathError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \

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

@@ -310,310 +407,407 @@

↥ Expand context

             ::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")?;
-318
         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(())
-325
+    }
-326
+}
-327
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.

-330
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_request_with_labels_test {
-334
     /// 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_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-342
         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))
             .set_double(::std::option::Option::Some(5.1_f64))
             .set_boolean(::std::option::Option::Some(true))
             .set_timestamp(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1576540098, 0_f64,
             )))
             .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");
         ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(
             uri.path(),
             "/HttpRequestWithLabels/string/1/2/3/4.1/5.1/true/2019-12-16T23%3A48%3A18Z",
             "path was incorrect"
         );
-370
+    }
-371
     /// Sends a GET request that uses URI label bindings
     /// Test ID: RestJsonHttpRequestLabelEscaping
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_request_label_escaping_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-379
         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(" %:/?#[]@!$&'()*+,;=😹".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))

↧ Expand context

             .set_double(::std::option::Option::Some(5.1_f64))
             .set_boolean(::std::option::Option::Some(true))
             .set_timestamp(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1576540098, 0_f64,
             )))
             .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");
         ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/HttpRequestWithLabels/%20%25%3A%2F%3F%23%5B%5D%40%21%24%26%27%28%29%2A%2B%2C%3B%3D%F0%9F%98%B9/1/2/3/4.1/5.1/true/2019-12-16T23%3A48%3A18Z", "path was incorrect");
-403
+    }
-404
+}
-405
 /// Error type for the `HttpRequestWithLabelsError` operation.
 #[non_exhaustive]

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

@@ -285,285 +345,345 @@

↥ Expand context

             ::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")?;
-293
         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(())
-300
+    }
-301
+}
-302
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.

-305
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_request_with_labels_and_timestamp_format_test {
-309
     /// 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_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-317
         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,

↧ Expand context

             )))
             .set_member_date_time(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1576540098, 0_f64,
             )))
             .set_default_format(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1576540098, 0_f64,
             )))
             .set_target_epoch_seconds(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1576540098, 0_f64,
             )))
             .set_target_http_date(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1576540098, 0_f64,
             )))
             .set_target_date_time(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1576540098, 0_f64,
             )))
             .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_request_with_regex_literal.rs

@@ -215,215 +275,275 @@

↥ Expand context

             ::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")?;
-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(())
-230
+    }
-231
+}
-232
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.

-235
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_request_with_regex_literal_test {
-239
     /// 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_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-247
         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();

↧ Expand context

         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");
         ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/ReDosLiteral/abc/(a+)+", "path was incorrect");
-262
+    }
-263
+}
-264
 /// Error type for the `HttpRequestWithRegexLiteralError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum HttpRequestWithRegexLiteralError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
     variable wildcard pattern and check `.code()`:
-272
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-274
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-HttpRequestWithRegexLiteralError) for what information is available for the error.")]

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

@@ -209,209 +269,269 @@

↥ Expand context

             ::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")?;
-218
         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(())
-225
+    }
-226
+}
-227
 // The get_* functions below are generated from JMESPath expressions in the

 // operationContextParams trait. They target the operation's input shape.
-230
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_string_payload_test {
-234
     /// Test ID: RestJsonStringPayloadRequest
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_string_payload_request_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-241
         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();

↧ Expand context

         let expected_headers = [("Content-Type", "text/plain")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "rawstring",
             ::aws_smithy_protocol_test::MediaType::from("text/plain"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/StringPayload", "path was incorrect");
-263
+    }
     /// Test ID: RestJsonStringPayloadResponse
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_string_payload_response_response() {
         let expected_output = crate::operation::http_string_payload::HttpStringPayloadOutput::builder()
             .set_payload(::std::option::Option::Some("rawstring".to_owned()))

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

@@ -206,206 +539,539 @@

↥ Expand context

         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<InputAndOutputWithHeadersInput>()
             .ok_or("failed to downcast to InputAndOutputWithHeadersInput")?;
-213
         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(())
-220
+    }
-221
+}
-222
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-225

 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod input_and_output_with_headers_test {
     use ::aws_smithy_protocol_test::FloatEquals;
-230
     /// Tests requests with string header bindings
     /// Test ID: RestJsonInputAndOutputWithStringHeaders
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_input_and_output_with_string_headers_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-238
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .input_and_output_with_headers()
             .set_header_string(::std::option::Option::Some("Hello".to_owned()))
             .set_header_string_list(::std::option::Option::Some(vec!["a".to_owned(), "b".to_owned(), "c".to_owned()]))
             .set_header_string_set(::std::option::Option::Some(vec!["a".to_owned(), "b".to_owned(), "c".to_owned()]))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("X-String", "Hello"), ("X-StringList", "a, b, c"), ("X-StringSet", "a, b, c")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &bytes::Bytes::new());
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/InputAndOutputWithHeaders", "path was incorrect");
-257
+    }
-258
     /// Tests requests with string list header bindings that require quoting
     /// Test ID: RestJsonInputAndOutputWithQuotedStringHeaders
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_input_and_output_with_quoted_string_headers_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-266
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .input_and_output_with_headers()
             .set_header_string_list(::std::option::Option::Some(vec!["b,c".to_owned(), "\"def\"".to_owned(), "a".to_owned()]))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("X-StringList", "\"b,c\", \"\\\"def\\\"\", a")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &bytes::Bytes::new());
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/InputAndOutputWithHeaders", "path was incorrect");
-283
+    }
-284
     /// Tests requests with numeric header bindings
     /// Test ID: RestJsonInputAndOutputWithNumericHeaders
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_input_and_output_with_numeric_headers_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-292
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .input_and_output_with_headers()
             .set_header_byte(::std::option::Option::Some(1))
             .set_header_short(::std::option::Option::Some(123))
             .set_header_integer(::std::option::Option::Some(123))
             .set_header_long(::std::option::Option::Some(123))
             .set_header_float(::std::option::Option::Some(1.1_f32))
             .set_header_double(::std::option::Option::Some(1.1_f64))
             .set_header_integer_list(::std::option::Option::Some(vec![1, 2, 3]))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("X-Byte", "1"),
             ("X-Double", "1.1"),
             ("X-Float", "1.1"),
             ("X-Integer", "123"),
             ("X-IntegerList", "1, 2, 3"),
             ("X-Long", "123"),
             ("X-Short", "123"),
         ];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &bytes::Bytes::new());
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/InputAndOutputWithHeaders", "path was incorrect");
-323
+    }
-324
     /// Tests requests with boolean header bindings
     /// Test ID: RestJsonInputAndOutputWithBooleanHeaders
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_input_and_output_with_boolean_headers_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-332
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .input_and_output_with_headers()
             .set_header_true_bool(::std::option::Option::Some(true))
             .set_header_false_bool(::std::option::Option::Some(false))
             .set_header_boolean_list(::std::option::Option::Some(vec![true, false, true]))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("X-Boolean1", "true"), ("X-Boolean2", "false"), ("X-BooleanList", "true, false, true")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &bytes::Bytes::new());
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/InputAndOutputWithHeaders", "path was incorrect");
-351
+    }
-352
     /// Tests requests with timestamp header bindings
     /// Test ID: RestJsonInputAndOutputWithTimestampHeaders
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_input_and_output_with_timestamp_headers_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-360
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .input_and_output_with_headers()
             .set_header_timestamp_list(::std::option::Option::Some(vec![
                 ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64),
                 ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64),
             ]))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("X-TimestampList", "Mon, 16 Dec 2019 23:48:18 GMT, Mon, 16 Dec 2019 23:48:18 GMT")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &bytes::Bytes::new());
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/InputAndOutputWithHeaders", "path was incorrect");
-380
+    }
-381
     /// Tests requests with enum header bindings
     /// Test ID: RestJsonInputAndOutputWithEnumHeaders
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_input_and_output_with_enum_headers_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-389
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .input_and_output_with_headers()
             .set_header_enum(::std::option::Option::Some(
                 "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             ))
             .set_header_enum_list(::std::option::Option::Some(vec![
                 "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
                 "Bar".parse::<crate::types::FooEnum>().expect("static value validated to member"),
                 "Baz".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             ]))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("X-Enum", "Foo"), ("X-EnumList", "Foo, Bar, Baz")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &bytes::Bytes::new());
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/InputAndOutputWithHeaders", "path was incorrect");
-413
+    }
-414
     /// Tests requests with intEnum header bindings
     /// Test ID: RestJsonInputAndOutputWithIntEnumHeaders
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_input_and_output_with_int_enum_headers_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-422
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .input_and_output_with_headers()
             .set_header_integer_enum(::std::option::Option::Some(1))
             .set_header_integer_enum_list(::std::option::Option::Some(vec![1, 2, 3]))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("X-IntegerEnum", "1"), ("X-IntegerEnumList", "1, 2, 3")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &bytes::Bytes::new());
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/InputAndOutputWithHeaders", "path was incorrect");
-440
+    }
-441
     /// Supports handling NaN float header values.
     /// Test ID: RestJsonSupportsNaNFloatHeaderInputs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_supports_na_n_float_header_inputs_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-449
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .input_and_output_with_headers()
             .set_header_float(::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number"),
             ))
             .set_header_double(::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number"),
             ))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("X-Double", "NaN"), ("X-Float", "NaN")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &bytes::Bytes::new());
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/InputAndOutputWithHeaders", "path was incorrect");
-471
+    }
-472
     /// Supports handling Infinity float header values.
     /// Test ID: RestJsonSupportsInfinityFloatHeaderInputs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_supports_infinity_float_header_inputs_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-480
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .input_and_output_with_headers()
             .set_header_float(::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number"),
             ))
             .set_header_double(::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number"),
             ))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("X-Double", "Infinity"), ("X-Float", "Infinity")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &bytes::Bytes::new());
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/InputAndOutputWithHeaders", "path was incorrect");
-502
+    }
-503
     /// Supports handling -Infinity float header values.
     /// Test ID: RestJsonSupportsNegativeInfinityFloatHeaderInputs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_supports_negative_infinity_float_header_inputs_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-511
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .input_and_output_with_headers()
             .set_header_float(::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number"),
             ))
             .set_header_double(::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number"),

↧ Expand context

             ))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("X-Double", "-Infinity"), ("X-Float", "-Infinity")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &bytes::Bytes::new());
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/InputAndOutputWithHeaders", "path was incorrect");
-533
+    }
-534
     /// Tests responses with string header bindings
     /// Test ID: RestJsonInputAndOutputWithStringHeaders
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_input_and_output_with_string_headers_response() {

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

@@ -199,199 +259,259 @@

↥ Expand context

             ::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::<JsonBlobsInput>()
             .ok_or("failed to downcast to JsonBlobsInput")?;
-207
         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(())
-214
+    }
-215
+}
-216
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.

-219
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod json_blobs_test {
-223
     /// Blobs are base64 encoded
     /// Test ID: RestJsonJsonBlobs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_json_blobs_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-231
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_blobs()
             .set_data(::std::option::Option::Some(::aws_smithy_types::Blob::new("value")))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();

↧ Expand context

         let expected_headers = [("Content-Type", "application/json")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "{\n    \"data\": \"dmFsdWU=\"\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/JsonBlobs", "path was incorrect");
-251
+    }
-252
     /// Blobs are base64 encoded
     /// Test ID: RestJsonJsonBlobs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_json_blobs_response() {
         let expected_output = crate::operation::json_blobs::JsonBlobsOutput::builder()
             .set_data(::std::option::Option::Some(::aws_smithy_types::Blob::new("value")))

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

@@ -199,199 +259,259 @@

↥ Expand context

             ::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::<JsonEnumsInput>()
             .ok_or("failed to downcast to JsonEnumsInput")?;
-207
         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(())
-214
+    }
-215
+}
-216
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.

-219
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod json_enums_test {
-223
     /// Serializes simple scalar properties
     /// Test ID: RestJsonJsonEnums
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_json_enums_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-231
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_enums()
             .set_foo_enum1(::std::option::Option::Some(
                 "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             ))
             .set_foo_enum2(::std::option::Option::Some(
                 "0".parse::<crate::types::FooEnum>().expect("static value validated to member"),

↧ Expand context

             ))
             .set_foo_enum3(::std::option::Option::Some(
                 "1".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             ))
             .set_foo_enum_list(::std::option::Option::Some(vec![
                 "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
                 "0".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             ]))
             .set_foo_enum_set(::std::option::Option::Some(vec![
                 "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
                 "0".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             ]))
             .set_foo_enum_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "hi".to_owned(),
                     "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
                 );
                 ret.insert(
                     "zero".to_owned(),

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

@@ -202,202 +262,262 @@

↥ Expand context

             ::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::<JsonIntEnumsInput>()
             .ok_or("failed to downcast to JsonIntEnumsInput")?;
-210
         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(())
-217
+    }
-218
+}
-219
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.

-222
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod json_int_enums_test {
-226
     /// Serializes intEnums as integers
     /// Test ID: RestJsonJsonIntEnums
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_json_int_enums_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-234
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_int_enums()
             .set_integer_enum1(::std::option::Option::Some(1))
             .set_integer_enum2(::std::option::Option::Some(2))
             .set_integer_enum3(::std::option::Option::Some(3))
             .set_integer_enum_list(::std::option::Option::Some(vec![1, 2, 3]))
             .set_integer_enum_set(::std::option::Option::Some(vec![1, 2]))

↧ Expand context

             .set_integer_enum_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("abc".to_owned(), 1);
                 ret.insert("def".to_owned(), 2);
                 ret
             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/json")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(
         ::aws_smithy_protocol_test::validate_body(body, "{\n    \"integerEnum1\": 1,\n    \"integerEnum2\": 2,\n    \"integerEnum3\": 3,\n    \"integerEnumList\": [\n        1,\n        2,\n        3\n    ],\n    \"integerEnumSet\": [\n        1,\n        2\n    ],\n    \"integerEnumMap\": {\n        \"abc\": 1,\n        \"def\": 2\n    }\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         );
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/JsonIntEnums", "path was incorrect");
-262
+    }

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

@@ -199,199 +312,312 @@

↥ Expand context

             ::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::<JsonListsInput>()
             .ok_or("failed to downcast to JsonListsInput")?;
-207
         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(())
-214
+    }
-215
+}
-216
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.

-219
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod json_lists_test {
-223
     /// Serializes JSON lists
     /// Test ID: RestJsonLists
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_lists_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-231
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_lists()
             .set_string_list(::std::option::Option::Some(vec!["foo".to_owned(), "bar".to_owned()]))
             .set_string_set(::std::option::Option::Some(vec!["foo".to_owned(), "bar".to_owned()]))
             .set_integer_list(::std::option::Option::Some(vec![1, 2]))
             .set_boolean_list(::std::option::Option::Some(vec![true, false]))
             .set_timestamp_list(::std::option::Option::Some(vec![
                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
             ]))
             .set_enum_list(::std::option::Option::Some(vec![
                 "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
                 "0".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             ]))
             .set_int_enum_list(::std::option::Option::Some(vec![1, 2]))
             .set_nested_string_list(::std::option::Option::Some(vec![
                 vec!["foo".to_owned(), "bar".to_owned()],
                 vec!["baz".to_owned(), "qux".to_owned()],
             ]))
             .set_structure_list(::std::option::Option::Some(vec![
                 crate::types::StructureListMember::builder()
                     .set_a(::std::option::Option::Some("1".to_owned()))
                     .set_b(::std::option::Option::Some("2".to_owned()))
                     .build(),
                 crate::types::StructureListMember::builder()
                     .set_a(::std::option::Option::Some("3".to_owned()))
                     .set_b(::std::option::Option::Some("4".to_owned()))
                     .build(),
             ]))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/json")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(
         ::aws_smithy_protocol_test::validate_body(body, "{\n    \"stringList\": [\n        \"foo\",\n        \"bar\"\n    ],\n    \"stringSet\": [\n        \"foo\",\n        \"bar\"\n    ],\n    \"integerList\": [\n        1,\n        2\n    ],\n    \"booleanList\": [\n        true,\n        false\n    ],\n    \"timestampList\": [\n        1398796238,\n        1398796238\n    ],\n    \"enumList\": [\n        \"Foo\",\n        \"0\"\n    ],\n    \"intEnumList\": [\n        1,\n        2\n    ],\n    \"nestedStringList\": [\n        [\n            \"foo\",\n            \"bar\"\n        ],\n        [\n            \"baz\",\n            \"qux\"\n        ]\n    ],\n    \"myStructureList\": [\n        {\n            \"value\": \"1\",\n            \"other\": \"2\"\n        },\n        {\n            \"value\": \"3\",\n            \"other\": \"4\"\n        }\n    ]\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         );
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/JsonLists", "path was incorrect");
-275
+    }
-276
     /// Serializes empty JSON lists
     /// Test ID: RestJsonListsEmpty
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_lists_empty_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-284
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.json_lists().set_string_list(::std::option::Option::Some(vec![])).send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/json")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(

↧ Expand context

             body,
             "{\n    \"stringList\": []\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/JsonLists", "path was incorrect");
-300
+    }
-301
     /// Serializes JSON lists
     /// Test ID: RestJsonLists
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_lists_response() {
         let expected_output = crate::operation::json_lists::JsonListsOutput::builder()
             .set_string_list(::std::option::Option::Some(vec!["foo".to_owned(), "bar".to_owned()]))
             .set_string_set(::std::option::Option::Some(vec!["foo".to_owned(), "bar".to_owned()]))
             .set_integer_list(::std::option::Option::Some(vec![1, 2]))
             .set_boolean_list(::std::option::Option::Some(vec![true, false]))
             .set_timestamp_list(::std::option::Option::Some(vec![

Pages: 1 2 3 4 5 6 7 8 9 10 11 12 13 14