Client Test

rev. b089fac03cba5061dd86d9628e74511b55f01c68

Files changed:

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

@@ -245,245 +305,307 @@

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

 mod http_request_with_greedy_label_in_path_test {
-266
     /// 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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-279
         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"
         );
-299
+    }
-300
+}
-301
 /// 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

@@ -324,324 +424,428 @@

↥ Expand context

     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<HttpRequestWithLabelsInput>()
             .ok_or("failed to downcast to HttpRequestWithLabelsInput")?;
-329
         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(())
-336
+    }
-337
+}
-338
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-341
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]

 mod http_request_with_labels_test {
-345
     /// 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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-358
         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"
         );
-386
+    }
-387
     /// 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_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-400
         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");
-424
+    }
-425
+}
-426
 /// 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

@@ -299,299 +359,361 @@

↥ Expand context

     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<HttpRequestWithLabelsAndTimestampFormatInput>()
             .ok_or("failed to downcast to HttpRequestWithLabelsAndTimestampFormatInput")?;
-304
         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(())
-311
+    }
-312
+}
-313
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-316
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]

 mod http_request_with_labels_and_timestamp_format_test {
-320
     /// 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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-333
         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

@@ -229,229 +289,291 @@

↥ Expand context

     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<HttpRequestWithRegexLiteralInput>()
             .ok_or("failed to downcast to HttpRequestWithRegexLiteralInput")?;
-234
         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(())
-241
+    }
-242
+}
-243
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-246
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]

 mod http_request_with_regex_literal_test {
-250
     /// 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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .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_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");
-278
+    }
-279
+}
-280
 /// 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()`:
-288
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-290
+     \
     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

@@ -223,223 +283,285 @@

↥ 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::<HttpStringPayloadInput>()
             .ok_or("failed to downcast to HttpStringPayloadInput")?;
-229
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-236
+    }
-237
+}
-238
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-241
 #[allow(unreachable_code, unused_variables)]

 #[cfg(test)]
 mod http_string_payload_test {
-245
     /// 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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-257
         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");
-279
+    }
     /// 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

@@ -220,220 +580,600 @@

↥ Expand context

         let _input = context
             .input()
             .downcast_ref::<InputAndOutputWithHeadersInput>()
             .ok_or("failed to downcast to InputAndOutputWithHeadersInput")?;
-224
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-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 input_and_output_with_headers_test {

     use ::aws_smithy_protocol_test::FloatEquals;
-241
     /// 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_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-254
         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");
-273
+    }
-274
     /// 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_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-287
         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");
-304
+    }
-305
     /// 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_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-318
         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");
-349
+    }
-350
     /// 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_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-363
         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");
-382
+    }
-383
     /// 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_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-396
         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");
-416
+    }
-417
     /// 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_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-430
         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");
-454
+    }
-455
     /// 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_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-468
         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");
-486
+    }
-487
     /// 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_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-500
         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");
-522
+    }
-523
     /// 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_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-536
         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");
-558
+    }
-559
     /// 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_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-572
         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");
-594
+    }
-595
     /// 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

@@ -214,214 +274,276 @@

↥ Expand context

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

 mod json_blobs_test {
-235
     /// 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_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-248
         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");
-268
+    }
-269
     /// 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

@@ -214,214 +274,276 @@

↥ Expand context

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

 mod json_enums_test {
-235
     /// 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_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-248
         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

@@ -216,216 +276,278 @@

↥ Expand context

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

 mod json_int_enums_test {
-237
     /// 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_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-250
         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");
-278
+    }

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

@@ -214,214 +330,334 @@

↥ Expand context

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

 mod json_lists_test {
-235
     /// 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_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-248
         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");
-292
+    }
-293
     /// 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_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-306
         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");
-322
+    }
-323
     /// 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![

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

@@ -210,210 +356,362 @@

↥ Expand context

     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<JsonMapsInput>()
             .ok_or("failed to downcast to JsonMapsInput")?;
-215
         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(())
-222
+    }
-223
+}
-224
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-227
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]

 mod json_maps_test {
-231
     /// Serializes JSON maps
     /// Test ID: RestJsonJsonMaps
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_json_maps_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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-244
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_maps()
             .set_dense_struct_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "foo".to_owned(),
                     crate::types::GreetingStruct::builder()
                         .set_hi(::std::option::Option::Some("there".to_owned()))
                         .build(),
                 );
                 ret.insert(
                     "baz".to_owned(),
                     crate::types::GreetingStruct::builder()
                         .set_hi(::std::option::Option::Some("bye".to_owned()))
                         .build(),
                 );
                 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    \"denseStructMap\": {\n        \"foo\": {\n            \"hi\": \"there\"\n        },\n        \"baz\": {\n            \"hi\": \"bye\"\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(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/JsonMaps", "path was incorrect");
-277
+    }
-278
     /// Ensure that 0 and false are sent over the wire in all maps and lists
     /// Test ID: RestJsonSerializesZeroValuesInMaps
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_serializes_zero_values_in_maps_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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-291
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_maps()
             .set_dense_number_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), 0);
                 ret
             }))
             .set_dense_boolean_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), false);
                 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    \"denseNumberMap\": {\n        \"x\": 0\n    },\n    \"denseBooleanMap\": {\n        \"x\": false\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(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/JsonMaps", "path was incorrect");
-320
+    }
-321
     /// A request that contains a dense map of sets.
     /// Test ID: RestJsonSerializesDenseSetMap
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_serializes_dense_set_map_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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-334
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_maps()
             .set_dense_set_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), vec![]);
                 ret.insert("y".to_owned(), vec!["a".to_owned(), "b".to_owned()]);
                 ret

↧ 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 body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "{\n    \"denseSetMap\": {\n        \"x\": [],\n        \"y\": [\"a\", \"b\"]\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(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/JsonMaps", "path was incorrect");
-359
+    }
-360
     /// Deserializes JSON maps
     /// Test ID: RestJsonJsonMaps

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

@@ -216,216 +480,494 @@

↥ Expand context

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

 mod json_timestamps_test {
-237
     /// Tests how normal timestamps are serialized
     /// Test ID: RestJsonJsonTimestamps
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_json_timestamps_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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-250
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_timestamps()
             .set_normal(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .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    \"normal\": 1398796238\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(), "/JsonTimestamps", "path was incorrect");
-272
+    }
-273
     /// Ensures that the timestampFormat of date-time works like normal timestamps
     /// Test ID: RestJsonJsonTimestampsWithDateTimeFormat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_json_timestamps_with_date_time_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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-286
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_timestamps()
             .set_date_time(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .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    \"dateTime\": \"2014-04-29T18:30:38Z\"\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(), "/JsonTimestamps", "path was incorrect");
-308
+    }
-309
     /// Ensures that the timestampFormat of date-time on the target shape works like normal timestamps
     /// Test ID: RestJsonJsonTimestampsWithDateTimeOnTargetFormat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_json_timestamps_with_date_time_on_target_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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-322
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_timestamps()
             .set_date_time_on_target(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .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    \"dateTimeOnTarget\": \"2014-04-29T18:30:38Z\"\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(), "/JsonTimestamps", "path was incorrect");
-344
+    }
-345
     /// Ensures that the timestampFormat of epoch-seconds works
     /// Test ID: RestJsonJsonTimestampsWithEpochSecondsFormat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_json_timestamps_with_epoch_seconds_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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-358
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_timestamps()
             .set_epoch_seconds(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .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    \"epochSeconds\": 1398796238\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(), "/JsonTimestamps", "path was incorrect");
-380
+    }
-381
     /// Ensures that the timestampFormat of epoch-seconds on the target shape works
     /// Test ID: RestJsonJsonTimestampsWithEpochSecondsOnTargetFormat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_json_timestamps_with_epoch_seconds_on_target_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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-394
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_timestamps()
             .set_epoch_seconds_on_target(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .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    \"epochSecondsOnTarget\": 1398796238\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(), "/JsonTimestamps", "path was incorrect");
-416
+    }
-417
     /// Ensures that the timestampFormat of http-date works
     /// Test ID: RestJsonJsonTimestampsWithHttpDateFormat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_json_timestamps_with_http_date_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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-430
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_timestamps()
             .set_http_date(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .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    \"httpDate\": \"Tue, 29 Apr 2014 18:30:38 GMT\"\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(), "/JsonTimestamps", "path was incorrect");
-452
+    }
-453
     /// Ensures that the timestampFormat of http-date on the target shape works
     /// Test ID: RestJsonJsonTimestampsWithHttpDateOnTargetFormat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_json_timestamps_with_http_date_on_target_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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-466
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_timestamps()
             .set_http_date_on_target(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .send()
             .await;

↧ Expand context

         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    \"httpDateOnTarget\": \"Tue, 29 Apr 2014 18:30:38 GMT\"\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(), "/JsonTimestamps", "path was incorrect");
-488
+    }
-489
     /// Tests how normal timestamps are serialized
     /// Test ID: RestJsonJsonTimestamps
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_json_timestamps_response() {

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

@@ -214,214 +580,600 @@

↥ Expand context

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

 mod json_unions_test {
-235
     /// Serializes a string union value
     /// Test ID: RestJsonSerializeStringUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_serialize_string_union_value_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-248
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_unions()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::StringValue("foo".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 body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "{\n    \"contents\": {\n        \"stringValue\": \"foo\"\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(), "/JsonUnions", "path was incorrect");
-268
+    }
-269
     /// Serializes a boolean union value
     /// Test ID: RestJsonSerializeBooleanUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_serialize_boolean_union_value_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-282
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_unions()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::BooleanValue(true)))
             .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    \"contents\": {\n        \"booleanValue\": true\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(), "/JsonUnions", "path was incorrect");
-302
+    }
-303
     /// Serializes a number union value
     /// Test ID: RestJsonSerializeNumberUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_serialize_number_union_value_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-316
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_unions()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::NumberValue(1)))
             .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    \"contents\": {\n        \"numberValue\": 1\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(), "/JsonUnions", "path was incorrect");
-336
+    }
-337
     /// Serializes a blob union value
     /// Test ID: RestJsonSerializeBlobUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_serialize_blob_union_value_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-350
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_unions()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::BlobValue(
                 ::aws_smithy_types::Blob::new("foo"),
             )))
             .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    \"contents\": {\n        \"blobValue\": \"Zm9v\"\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(), "/JsonUnions", "path was incorrect");
-372
+    }
-373
     /// Serializes a timestamp union value
     /// Test ID: RestJsonSerializeTimestampUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_serialize_timestamp_union_value_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-386
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_unions()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::TimestampValue(
                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
             )))
             .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    \"contents\": {\n        \"timestampValue\": 1398796238\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(), "/JsonUnions", "path was incorrect");
-408
+    }
-409
     /// Serializes an enum union value
     /// Test ID: RestJsonSerializeEnumUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_serialize_enum_union_value_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-422
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_unions()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::EnumValue(
                 "Foo".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 = [("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    \"contents\": {\n        \"enumValue\": \"Foo\"\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(), "/JsonUnions", "path was incorrect");
-444
+    }
-445
     /// Serializes a list union value
     /// Test ID: RestJsonSerializeListUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_serialize_list_union_value_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-458
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_unions()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::ListValue(vec![
                 "foo".to_owned(),
                 "bar".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 body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "{\n    \"contents\": {\n        \"listValue\": [\"foo\", \"bar\"]\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(), "/JsonUnions", "path was incorrect");
-481
+    }
-482
     /// Serializes a map union value
     /// Test ID: RestJsonSerializeMapUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_serialize_map_union_value_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-495
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_unions()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::MapValue({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("foo".to_owned(), "bar".to_owned());
                 ret.insert("spam".to_owned(), "eggs".to_owned());
                 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    \"contents\": {\n        \"mapValue\": {\n            \"foo\": \"bar\",\n            \"spam\": \"eggs\"\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(), "/JsonUnions", "path was incorrect");
-520
+    }
-521
     /// Serializes a structure union value
     /// Test ID: RestJsonSerializeStructureUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_serialize_structure_union_value_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-534
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_unions()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::StructureValue(
                 crate::types::GreetingStruct::builder()
                     .set_hi(::std::option::Option::Some("hello".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    \"contents\": {\n        \"structureValue\": {\n            \"hi\": \"hello\"\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(), "/JsonUnions", "path was incorrect");
-558
+    }
-559
     /// Serializes a renamed structure union value
     /// Test ID: RestJsonSerializeRenamedStructureUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_serialize_renamed_structure_union_value_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-572
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_unions()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::RenamedStructureValue(
                 crate::types::RenamedGreeting::builder()
                     .set_salutation(::std::option::Option::Some("hello!".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 body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "{\n    \"contents\": {\n        \"renamedStructureValue\": {\n            \"salutation\": \"hello!\"\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(), "/JsonUnions", "path was incorrect");
-596
+    }
-597
     /// Deserializes a string union value
     /// Test ID: RestJsonDeserializeStringUnionValue
     #[::tokio::test]

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

@@ -219,219 +279,281 @@

↥ Expand context

     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<MediaTypeHeaderInput>()
             .ok_or("failed to downcast to MediaTypeHeaderInput")?;
-224
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-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 media_type_header_test {
-240
     /// Headers that target strings with a mediaType are base64 encoded
     /// Test ID: MediaTypeHeaderInputBase64
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn media_type_header_input_base64_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)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-253
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .media_type_header()
             .set_json(::std::option::Option::Some("true".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();

↧ Expand context

         let expected_headers = [("X-Json", "dHJ1ZQ==")];
         ::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(), "/MediaTypeHeader", "path was incorrect");
-270
+    }
-271
     /// Headers that target strings with a mediaType are base64 encoded
     /// Test ID: MediaTypeHeaderOutputBase64
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn media_type_header_output_base64_response() {
         let expected_output = crate::operation::media_type_header::MediaTypeHeaderOutput::builder()
             .set_json(::std::option::Option::Some("true".to_owned()))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()

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

@@ -220,220 +280,282 @@

↥ Expand context

             .input()
             .downcast_ref::<NoInputAndNoOutputInput>()
             .ok_or("failed to downcast to NoInputAndNoOutputInput")?;
-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 no_input_and_no_output_test {
-239

     /// No input serializes no payload. When clients do not need to
     /// serialize any data in the payload, they should omit a payload
     /// altogether.
     /// Test ID: RestJsonNoInputAndNoOutput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_no_input_and_no_output_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-254
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.no_input_and_no_output().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::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(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/NoInputAndNoOutput", "path was incorrect");
-265
+    }
-266
     /// When an operation does not define output, the service will respond
     /// with an empty payload, and may optionally include the content-type
     /// header.
     /// Test ID: RestJsonNoInputAndNoOutput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_no_input_and_no_output_response() {
         let expected_output = crate::operation::no_input_and_no_output::NoInputAndNoOutputOutput::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(""))
                 .unwrap(),
-280
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;

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

@@ -220,220 +280,282 @@

↥ Expand context

             .input()
             .downcast_ref::<NoInputAndOutputInput>()
             .ok_or("failed to downcast to NoInputAndOutputInput")?;
-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 no_input_and_output_test {
-239

     /// No input serializes no payload. When clients do not need to
     /// serialize any data in the payload, they should omit a payload
     /// altogether.
     /// Test ID: RestJsonNoInputAndOutput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_no_input_and_output_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-254
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.no_input_and_output().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::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(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/NoInputAndOutputOutput", "path was incorrect");
-265
+    }
-266
     /// Operations that define output and do not bind anything to
     /// the payload return a JSON object in the response.
     /// Test ID: RestJsonNoInputAndOutputWithJson
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_no_input_and_output_with_json_response() {
         let expected_output = crate::operation::no_input_and_output::NoInputAndOutputOutput::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(),
-280
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;

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