Client Test

rev. 3d2cf9bfcccf2cb5e5660fe2685c9174956bfcad (ignoring whitespace)

Files changed:

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

@@ -221,221 +281,281 @@

             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<QueryPrecedenceInput>()
             .ok_or("failed to downcast to QueryPrecedenceInput")?;
-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 query_precedence_test {
-245
     /// Prefer named query parameters when serializing
     /// Test ID: RestJsonQueryPrecedence
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_query_precedence_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-253
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .query_precedence()
             .set_foo(::std::option::Option::Some("named".to_owned()))
             .set_baz(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("bar".to_owned(), "fromMap".to_owned());
                 ret.insert("qux".to_owned(), "alsoFromMap".to_owned());

↧ Expand context

                 ret
             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_query_params = &["bar=named", "qux=alsoFromMap"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_query_string(&http_request, expected_query_params));
         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(), "/Precedence", "path was incorrect");
-276
+    }
-277
+}
-278
 /// Error type for the `QueryPrecedenceError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

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

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

↥ Expand context

             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<RecursiveShapesInput>()
             .ok_or("failed to downcast to RecursiveShapesInput")?;
-210
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-217
+    }
-218
+}
-219
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.

-222
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod recursive_shapes_test {
-226
     /// Serializes recursive structures
     /// Test ID: RestJsonRecursiveShapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_recursive_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-234
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .recursive_shapes()
             .set_nested(::std::option::Option::Some(
                 crate::types::RecursiveShapesInputOutputNested1::builder()
                     .set_foo(::std::option::Option::Some("Foo1".to_owned()))
                     .set_nested(::std::option::Option::Some(::std::boxed::Box::new(
                         crate::types::RecursiveShapesInputOutputNested2::builder()

↧ Expand context

                             .set_bar(::std::option::Option::Some("Bar1".to_owned()))
                             .set_recursive_member(::std::option::Option::Some(
                                 crate::types::RecursiveShapesInputOutputNested1::builder()
                                     .set_foo(::std::option::Option::Some("Foo2".to_owned()))
                                     .set_nested(::std::option::Option::Some(::std::boxed::Box::new(
                                         crate::types::RecursiveShapesInputOutputNested2::builder()
                                             .set_bar(::std::option::Option::Some("Bar2".to_owned()))
                                             .build(),
                                     )))
                                     .build(),
                             ))
                             .build(),
                     )))
                     .build(),
             ))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/json")];

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

@@ -212,212 +405,405 @@

↥ 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::<SimpleScalarPropertiesInput>()
             .ok_or("failed to downcast to SimpleScalarPropertiesInput")?;
-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 simple_scalar_properties_test {
     use ::aws_smithy_protocol_test::FloatEquals;
-236
     /// Serializes simple scalar properties
     /// Test ID: RestJsonSimpleScalarProperties
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_simple_scalar_properties_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-244
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .simple_scalar_properties()
             .set_foo(::std::option::Option::Some("Foo".to_owned()))
             .set_string_value(::std::option::Option::Some("string".to_owned()))
             .set_true_boolean_value(::std::option::Option::Some(true))
             .set_false_boolean_value(::std::option::Option::Some(false))
             .set_byte_value(::std::option::Option::Some(1))
             .set_short_value(::std::option::Option::Some(2))
             .set_integer_value(::std::option::Option::Some(3))
             .set_long_value(::std::option::Option::Some(4))
             .set_float_value(::std::option::Option::Some(5.5_f32))
             .set_double_value(::std::option::Option::Some(6.5_f64))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/json"), ("X-Foo", "Foo")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(
         ::aws_smithy_protocol_test::validate_body(body, "{\n    \"stringValue\": \"string\",\n    \"trueBooleanValue\": true,\n    \"falseBooleanValue\": false,\n    \"byteValue\": 1,\n    \"shortValue\": 2,\n    \"integerValue\": 3,\n    \"longValue\": 4,\n    \"floatValue\": 5.5,\n    \"DoubleDribble\": 6.5\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(), "/SimpleScalarProperties", "path was incorrect");
-271
+    }
-272
     /// Rest Json should not serialize null structure values
     /// Test ID: RestJsonDoesntSerializeNullStructureValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_doesnt_serialize_null_structure_values_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-280
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .simple_scalar_properties()
             .set_string_value(::std::option::Option::None)
             .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,
             "{}",
             ::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(), "/SimpleScalarProperties", "path was incorrect");
-300
+    }
-301
     /// Supports handling NaN float values.
     /// Test ID: RestJsonSupportsNaNFloatInputs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_supports_na_n_float_inputs_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-309
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .simple_scalar_properties()
             .set_float_value(::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number"),
             ))
             .set_double_value(::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 = [("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    \"floatValue\": \"NaN\",\n    \"DoubleDribble\": \"NaN\"\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(), "/SimpleScalarProperties", "path was incorrect");
-334
+    }
-335
     /// Supports handling Infinity float values.
     /// Test ID: RestJsonSupportsInfinityFloatInputs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_supports_infinity_float_inputs_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-343
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .simple_scalar_properties()
             .set_float_value(::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number"),
             ))
             .set_double_value(::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 = [("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    \"floatValue\": \"Infinity\",\n    \"DoubleDribble\": \"Infinity\"\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(), "/SimpleScalarProperties", "path was incorrect");
-368
+    }
-369
     /// Supports handling -Infinity float values.
     /// Test ID: RestJsonSupportsNegativeInfinityFloatInputs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_supports_negative_infinity_float_inputs_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-377
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .simple_scalar_properties()
             .set_float_value(::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number"),
             ))
             .set_double_value(::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 = [("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    \"floatValue\": \"-Infinity\",\n    \"DoubleDribble\": \"-Infinity\"\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(), "/SimpleScalarProperties", "path was incorrect");
-402
+    }
-403
     /// Serializes simple scalar properties
     /// Test ID: RestJsonSimpleScalarProperties

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

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

↥ Expand context

             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<SparseJsonListsInput>()
             .ok_or("failed to downcast to SparseJsonListsInput")?;
-210
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-217
+    }
-218
+}
-219
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.

-222
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod sparse_json_lists_test {
-226
     /// Serializes null values in sparse lists
     /// Test ID: RestJsonSparseListsSerializeNull
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_sparse_lists_serialize_null_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-234
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .sparse_json_lists()
             .set_sparse_string_list(::std::option::Option::Some(vec![
                 ::std::option::Option::None,
                 ::std::option::Option::Some("hi".to_owned()),
             ]))
             .set_sparse_short_list(::std::option::Option::Some(vec![

↧ Expand context

                 ::std::option::Option::None,
                 ::std::option::Option::Some(2),
             ]))
             .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    \"sparseStringList\": [\n        null,\n        \"hi\"\n    ],\n    \"sparseShortList\": [\n        null,\n        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(), "/SparseJsonLists", "path was incorrect");
-261
+    }
-262

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

@@ -202,202 +426,426 @@

↥ Expand context

             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<SparseJsonMapsInput>()
             .ok_or("failed to downcast to SparseJsonMapsInput")?;
-210
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-217
+    }
-218
+}
-219
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.

-222
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod sparse_json_maps_test {
-226
     /// Serializes JSON maps
     /// Test ID: RestJsonSparseJsonMaps
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_sparse_json_maps_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-234
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .sparse_json_maps()
             .set_sparse_struct_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "foo".to_owned(),
                     ::std::option::Option::Some(
                         crate::types::GreetingStruct::builder()
                             .set_hi(::std::option::Option::Some("there".to_owned()))
                             .build(),
                     ),
                 );
                 ret.insert(
                     "baz".to_owned(),
                     ::std::option::Option::Some(
                         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    \"sparseStructMap\": {\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(), "/SparseJsonMaps", "path was incorrect");
-271
+    }
-272
     /// Serializes JSON map values in sparse maps
     /// Test ID: RestJsonSerializesSparseNullMapValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_serializes_sparse_null_map_values_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-280
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .sparse_json_maps()
             .set_sparse_boolean_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), ::std::option::Option::None);
                 ret
             }))
             .set_sparse_number_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), ::std::option::Option::None);
                 ret
             }))
             .set_sparse_string_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), ::std::option::Option::None);
                 ret
             }))
             .set_sparse_struct_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), ::std::option::Option::None);
                 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    \"sparseBooleanMap\": {\n        \"x\": null\n    },\n    \"sparseNumberMap\": {\n        \"x\": null\n    },\n    \"sparseStringMap\": {\n        \"x\": null\n    },\n    \"sparseStructMap\": {\n        \"x\": null\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(), "/SparseJsonMaps", "path was incorrect");
-317
+    }
-318
     /// Ensure that 0 and false are sent over the wire in all maps and lists
     /// Test ID: RestJsonSerializesZeroValuesInSparseMaps
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_serializes_zero_values_in_sparse_maps_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-326
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .sparse_json_maps()
             .set_sparse_number_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), ::std::option::Option::Some(0));
                 ret
             }))
             .set_sparse_boolean_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), ::std::option::Option::Some(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    \"sparseNumberMap\": {\n        \"x\": 0\n    },\n    \"sparseBooleanMap\": {\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(), "/SparseJsonMaps", "path was incorrect");
-355
+    }
-356
     /// A request that contains a sparse map of sets
     /// Test ID: RestJsonSerializesSparseSetMap
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_serializes_sparse_set_map_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-364
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .sparse_json_maps()
             .set_sparse_set_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), ::std::option::Option::Some(vec![]));
                 ret.insert("y".to_owned(), ::std::option::Option::Some(vec!["a".to_owned(), "b".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    \"sparseSetMap\": {\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(), "/SparseJsonMaps", "path was incorrect");
-389
+    }
-390
     /// A request that contains a sparse map of sets.
     /// Test ID: RestJsonSerializesSparseSetMapAndRetainsNull
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_serializes_sparse_set_map_and_retains_null_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-398
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .sparse_json_maps()
             .set_sparse_set_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), ::std::option::Option::Some(vec![]));
                 ret.insert("y".to_owned(), ::std::option::Option::Some(vec!["a".to_owned(), "b".to_owned()]));
                 ret.insert("z".to_owned(), ::std::option::Option::None);

↧ Expand context

                 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    \"sparseSetMap\": {\n        \"x\": [],\n        \"y\": [\"a\", \"b\"],\n        \"z\": null\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(), "/SparseJsonMaps", "path was incorrect");
-424
+    }
-425
     /// Deserializes JSON maps

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

@@ -214,214 +306,306 @@

↥ Expand context

             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<StreamingTraitsInput>()
             .ok_or("failed to downcast to StreamingTraitsInput")?;
-222
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-229
+    }
-230
+}
-231
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.

-234
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod streaming_traits_test {
-238
     /// Serializes a blob in the HTTP payload
     /// Test ID: RestJsonStreamingTraitsWithBlob
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_streaming_traits_with_blob_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-246
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .streaming_traits()
             .set_foo(::std::option::Option::Some("Foo".to_owned()))
             .set_blob(::std::option::Option::Some(::aws_smithy_types::byte_stream::ByteStream::from_static(
                 b"blobby blob blob",
             )))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/octet-stream"), ("X-Foo", "Foo")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "blobby blob blob",
             ::aws_smithy_protocol_test::MediaType::from("application/octet-stream"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/StreamingTraits", "path was incorrect");
-269
+    }
-270
     /// Serializes an empty blob in the HTTP payload
     /// Test ID: RestJsonStreamingTraitsWithNoBlobBody
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_streaming_traits_with_no_blob_body_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-278
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .streaming_traits()
             .set_foo(::std::option::Option::Some("Foo".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();

↧ Expand context

         let expected_headers = [("X-Foo", "Foo")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &bytes::Bytes::new());
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/StreamingTraits", "path was incorrect");
-295
+    }
-296
     /// Serializes a blob in the HTTP payload
     /// Test ID: RestJsonStreamingTraitsWithBlob
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_streaming_traits_with_blob_response() {
         let expected_output = crate::operation::streaming_traits::StreamingTraitsOutput::builder()
             .set_foo(::std::option::Option::Some("Foo".to_owned()))
             .set_blob(::std::option::Option::Some(::aws_smithy_types::byte_stream::ByteStream::from_static(
                 b"blobby blob blob",
             )))

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

@@ -210,210 +304,304 @@

↥ Expand context

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

-230
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod streaming_traits_require_length_test {
-234
     /// Serializes a blob in the HTTP payload with a required length
     /// Test ID: RestJsonStreamingTraitsRequireLengthWithBlob
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_streaming_traits_require_length_with_blob_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-242
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .streaming_traits_require_length()
             .set_foo(::std::option::Option::Some("Foo".to_owned()))
             .set_blob(::std::option::Option::Some(::aws_smithy_types::byte_stream::ByteStream::from_static(
                 b"blobby blob blob",
             )))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/octet-stream"), ("X-Foo", "Foo")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "blobby blob blob",
             ::aws_smithy_protocol_test::MediaType::from("application/octet-stream"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/StreamingTraitsRequireLength", "path was incorrect");
-267
+    }
-268
     /// Serializes an empty blob in the HTTP payload
     /// Test ID: RestJsonStreamingTraitsRequireLengthWithNoBlobBody
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_streaming_traits_require_length_with_no_blob_body_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-276
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .streaming_traits_require_length()
             .set_foo(::std::option::Option::Some("Foo".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();

↧ Expand context

         let expected_headers = [("X-Foo", "Foo")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &bytes::Bytes::new());
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/StreamingTraitsRequireLength", "path was incorrect");
-293
+    }
-294
+}
-295
 /// Error type for the `StreamingTraitsRequireLengthError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum StreamingTraitsRequireLengthError {
     /// 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()`:
-303
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`

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

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

↥ Expand context

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

-243
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod streaming_traits_with_media_type_test {
-247
     /// Serializes a blob in the HTTP payload with a content-type
     /// Test ID: RestJsonStreamingTraitsWithMediaTypeWithBlob
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_streaming_traits_with_media_type_with_blob_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-255
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .streaming_traits_with_media_type()
             .set_foo(::std::option::Option::Some("Foo".to_owned()))
             .set_blob(::std::option::Option::Some(::aws_smithy_types::byte_stream::ByteStream::from_static(
                 b"blobby blob blob",
             )))
             .send()

↧ Expand context

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

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

@@ -209,209 +302,302 @@

↥ Expand context

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

-229
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod test_body_structure_test {
-233
     /// Serializes a structure
     /// Test ID: RestJsonTestBodyStructure
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_test_body_structure_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-241
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .test_body_structure()
             .set_test_config(::std::option::Option::Some(
                 crate::types::TestConfig::builder().set_timeout(::std::option::Option::Some(10)).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 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,
             "{\"testConfig\":\n    {\"timeout\": 10}\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(), "/body", "path was incorrect");
-265
+    }
-266
     /// Serializes an empty structure in the body
     /// Test ID: RestJsonHttpWithEmptyBody
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_with_empty_body_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-274
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.test_body_structure().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/json")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));

↧ Expand context

         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "{}",
             ::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(), "/body", "path was incorrect");
-292
+    }
-293
+}
-294
 /// Error type for the `TestBodyStructureError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum TestBodyStructureError {
     /// 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()`:
-302
+     \

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

@@ -204,204 +264,264 @@

↥ Expand context

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

-224
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod test_get_no_input_no_payload_test {
-228
     /// Serializes a GET request for an operation with no input, and therefore no modeled body
     /// Test ID: RestJsonHttpGetWithNoInput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_get_with_no_input_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-236
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.test_get_no_input_no_payload().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let forbidden_headers = &["Content-Type", "Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::forbid_headers(http_request.headers(), forbidden_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.

↧ Expand context

         ::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(), "/no_input_no_payload", "path was incorrect");
-249
+    }
-250
+}
-251
 /// Error type for the `TestGetNoInputNoPayloadError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum TestGetNoInputNoPayloadError {
     /// 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()`:
-259
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-261
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-TestGetNoInputNoPayloadError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-264
+}

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

@@ -199,199 +281,281 @@

↥ Expand context

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

-219
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod test_get_no_payload_test {
-223
     /// Serializes a GET request with no modeled body
     /// Test ID: RestJsonHttpGetWithNoModeledBody
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_get_with_no_modeled_body_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-231
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.test_get_no_payload().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let forbidden_headers = &["Content-Length", "Content-Type"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::forbid_headers(http_request.headers(), forbidden_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::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(), "/no_payload", "path was incorrect");
-244
+    }
-245
     /// Serializes a GET request with header member but no modeled body
     /// Test ID: RestJsonHttpGetWithHeaderMemberNoModeledBody
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_get_with_header_member_no_modeled_body_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-253
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .test_get_no_payload()
             .set_test_id(::std::option::Option::Some("t-12345".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();

↧ Expand context

         let expected_headers = [("X-Amz-Test-Id", "t-12345")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let forbidden_headers = &["Content-Length", "Content-Type"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::forbid_headers(http_request.headers(), forbidden_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::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(), "/no_payload", "path was incorrect");
-272
+    }
-273
+}
-274
 /// Error type for the `TestGetNoPayloadError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum TestGetNoPayloadError {
     /// 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()`:

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

@@ -203,203 +283,283 @@

↥ Expand context

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

-223
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod test_payload_blob_test {
-227
     /// Serializes a payload targeting an empty blob
     /// Test ID: RestJsonHttpWithEmptyBlobPayload
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_with_empty_blob_payload_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-235
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.test_payload_blob().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &bytes::Bytes::new());
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/blob_payload", "path was incorrect");
-246
+    }
-247
     /// Serializes a payload targeting a blob
     /// Test ID: RestJsonTestPayloadBlob
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_test_payload_blob_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-255
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .test_payload_blob()
             .set_content_type(::std::option::Option::Some("image/jpg".to_owned()))
             .set_data(::std::option::Option::Some(::aws_smithy_types::Blob::new("1234")))
             .send()
             .await;
         let _ = dbg!(result);

↧ Expand context

         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "image/jpg")];
         ::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,
             "1234",
             ::aws_smithy_protocol_test::MediaType::from("image/jpg"),
         ));
         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(), "/blob_payload", "path was incorrect");
-278
+    }
-279
+}
-280
 /// Error type for the `TestPayloadBlobError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

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

@@ -211,211 +335,335 @@

↥ Expand context

             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<TestPayloadStructureInput>()
             .ok_or("failed to downcast to TestPayloadStructureInput")?;
-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 test_payload_structure_test {
-235
     /// Serializes a payload targeting an empty structure
     /// Test ID: RestJsonHttpWithEmptyStructurePayload
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_with_empty_structure_payload_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-243
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .test_payload_structure()
             .set_payload_config(::std::option::Option::Some(crate::types::PayloadConfig::builder().build()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/json")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "{}",
             ::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(), "/payload", "path was incorrect");
-265
+    }
-266
     /// Serializes a payload targeting a structure
     /// Test ID: RestJsonTestPayloadStructure
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_test_payload_structure_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-274
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .test_payload_structure()
             .set_payload_config(::std::option::Option::Some(
                 crate::types::PayloadConfig::builder().set_data(::std::option::Option::Some(25)).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 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,
             "{\"data\": 25\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(), "/payload", "path was incorrect");
-298
+    }
-299
     /// Serializes an request with header members but no payload
     /// Test ID: RestJsonHttpWithHeadersButNoPayload
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_with_headers_but_no_payload_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-307
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .test_payload_structure()
             .set_test_id(::std::option::Option::Some("t-12345".to_owned()))
             .set_payload_config(::std::option::Option::Some(crate::types::PayloadConfig::builder().build()))
             .send()
             .await;
         let _ = dbg!(result);

↧ Expand context

         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/json"), ("X-Amz-Test-Id", "t-12345")];
         ::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,
             "{}",
             ::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(), "/payload", "path was incorrect");
-330
+    }
-331
+}
-332
 /// Error type for the `TestPayloadStructureError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

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

@@ -204,204 +264,264 @@

↥ Expand context

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

-224
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod test_post_no_input_no_payload_test {
-228
     /// Serializes a POST request for an operation with no input, and therefore no modeled body
     /// Test ID: RestJsonHttpPostWithNoInput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_post_with_no_input_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-236
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.test_post_no_input_no_payload().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let forbidden_headers = &["Content-Type"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::forbid_headers(http_request.headers(), forbidden_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.

↧ Expand context

         ::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(), "/no_input_no_payload", "path was incorrect");
-249
+    }
-250
+}
-251
 /// Error type for the `TestPostNoInputNoPayloadError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum TestPostNoInputNoPayloadError {
     /// 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()`:
-259
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-261
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-TestPostNoInputNoPayloadError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-264
+}

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

@@ -205,205 +287,287 @@

↥ Expand context

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

-225
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod test_post_no_payload_test {
-229
     /// Serializes a POST request with no modeled body
     /// Test ID: RestJsonHttpPostWithNoModeledBody
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_post_with_no_modeled_body_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-237
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.test_post_no_payload().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let forbidden_headers = &["Content-Type"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::forbid_headers(http_request.headers(), forbidden_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::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(), "/no_payload", "path was incorrect");
-250
+    }
-251
     /// Serializes a POST request with header member but no modeled body
     /// Test ID: RestJsonHttpWithPostHeaderMemberNoModeledBody
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_with_post_header_member_no_modeled_body_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-259
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .test_post_no_payload()
             .set_test_id(::std::option::Option::Some("t-12345".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();

↧ Expand context

         let expected_headers = [("X-Amz-Test-Id", "t-12345")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let forbidden_headers = &["Content-Type"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::forbid_headers(http_request.headers(), forbidden_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::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(), "/no_payload", "path was incorrect");
-278
+    }
-279
+}
-280
 /// Error type for the `TestPostNoPayloadError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum TestPostNoPayloadError {
     /// 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()`:

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

@@ -205,205 +265,265 @@

↥ Expand context

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

-225
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod timestamp_format_headers_test {
-229
     /// Tests how timestamp request headers are serialized
     /// Test ID: RestJsonTimestampFormatHeaders
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_timestamp_format_headers_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-237
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .timestamp_format_headers()
             .set_member_epoch_seconds(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1576540098, 0_f64,
             )))
             .set_member_http_date(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1576540098, 0_f64,

↧ 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();

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