Client Test

rev. c4f9295a7b4566dca79c361e3a2aa9e63cdf82e7 (ignoring whitespace)

Files changed:

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

@@ -206,206 +266,266 @@

         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<UnitInputAndOutputInput>()
             .ok_or("failed to downcast to UnitInputAndOutputInput")?;
-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 unit_input_and_output_test {
-228
     /// A unit type input serializes no payload. When clients do not
     /// need to serialize any data in the payload, they should omit
     /// a payload altogether.
     /// Test ID: RestJsonUnitInputAndOutput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_unit_input_and_output_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-238
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.unit_input_and_output().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::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(), "/UnitInputAndOutput", "path was incorrect");
-249
+    }
-250
     /// When an operation defines Unit output, the service will respond
     /// with an empty payload, and may optionally include the content-type
     /// header.
     /// Test ID: RestJsonUnitInputAndOutputNoOutput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_unit_input_and_output_no_output_response() {
         let expected_output = crate::operation::unit_input_and_output::UnitInputAndOutputOutput::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(),
-264
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;

tmp-codegen-diff/codegen-client-test/rest_json_extras/rust-client-codegen/Cargo.toml

@@ -1,1 +52,53 @@

↥ Expand context

 # Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 [package]
 name = "rest_json_extras"
 version = "0.0.1"
 authors = ["protocoltest@example.com"]
 description = "test"
 edition = "2021"
-8
 [package.metadata.smithy]
 codegen-version = "ci"
 [dependencies.aws-smithy-async]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-async"
 [dependencies.aws-smithy-http]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http"
 [dependencies.aws-smithy-json]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-json"
 [dependencies.aws-smithy-runtime]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime"

 features = ["client"]
 [dependencies.aws-smithy-runtime-api]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime-api"
 features = ["client", "http-02x"]
 [dependencies.aws-smithy-types]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-types"
 [dependencies.bytes]
 version = "1.4.0"
 [dependencies.http]
 version = "0.2.9"
 [dev-dependencies.aws-smithy-http-client]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http-client"
 features = ["test-util"]
 [dev-dependencies.aws-smithy-protocol-test]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-protocol-test"
 [dev-dependencies.aws-smithy-runtime]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime"
 features = ["client", "test-util"]
 [dev-dependencies.pretty_assertions]
 version = "1.3.0"
 [dev-dependencies.tokio]
 version = "1.23.1"
 features = ["macros", "test-util", "rt-multi-thread"]
 [dev-dependencies.tracing]
 version = "0.1"
 [dev-dependencies.tracing-test]
 version = "0.2.5"
 features = ["no-env-filter"]
 [features]
 test-util = ["aws-smithy-runtime/test-util"]
 rt-tokio = ["aws-smithy-async/rt-tokio", "aws-smithy-types/rt-tokio"]
 behavior-version-latest = []
 rustls = ["aws-smithy-runtime/tls-rustls"]
 default-https-client = ["aws-smithy-runtime/default-https-client"]
 gated-tests = []
 default = ["rt-tokio", "rustls"]
 default = ["rt-tokio", "rustls", "default-https-client"]
-52
-53

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

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

↥ Expand context

             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<EnumQueryInput>()
             .ok_or("failed to downcast to EnumQueryInput")?;
-214
         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(())
-221
+    }
-222
+}
-223
 // The get_* functions below are generated from JMESPath expressions in the

 // operationContextParams trait. They target the operation's input shape.
-226
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod enum_query_test {
-230
     /// Test ID: EnumQueryRequest
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn enum_query_request_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-237
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .enum_query()
             .set_enum(::std::option::Option::Some(
                 "enumvalue".parse::<crate::types::StringEnum>().expect("static value validated to member"),
             ))
             .send()
             .await;

↧ Expand context

         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         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(), "/foo/enumvalue", "path was incorrect");
-251
+    }
-252
     /// Upper case error modeled lower case
     /// Test ID: ServiceLevelErrorClient
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn service_level_error_client_response() {
         let expected_output = crate::types::error::ExtraError::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("X-Amzn-Errortype", "ExtraError")
                 .status(500)
                 .body(::aws_smithy_types::body::SdkBody::from(""))
                 .unwrap(),
-265
+        )

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

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

↥ Expand context

             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<EscapedStringValuesInput>()
             .ok_or("failed to downcast to EscapedStringValuesInput")?;
-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 escaped_string_values_test {
-234
     /// Test ID: EscapedStringValuesRequest
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn escaped_string_values_request_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-241
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .escaped_string_values()
             .set_enum(::std::option::Option::Some(
                 "has\"quotes"
                     .parse::<crate::types::EnumWithEscapedChars>()
                     .expect("static value validated to member"),
             ))

↧ Expand context

             .set_some_string(::std::option::Option::Some("test".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,
             "{\"enum\":\"has\\\"quotes\",\"also\\\"has\\\"quotes\":\"test\"}",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
         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(), "/escaped-string-values", "path was incorrect");
-266
+    }
     /// Test ID: EscapedStringValuesResponse
     #[::tokio::test]
     #[::tracing_test::traced_test]

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

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

↥ Expand context

             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<MapWithEnumKeyOpInput>()
             .ok_or("failed to downcast to MapWithEnumKeyOpInput")?;
-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 map_with_enum_key_op_test {
-227
     /// Test ID: MapWithEnumKeyRequest
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn map_with_enum_key_request_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-234
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .map_with_enum_key_op()
             .set_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "enumvalue".parse::<crate::types::StringEnum>().expect("static value validated to member"),
                     "something".to_owned(),

↧ 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,
             "{\"map\":{\"enumvalue\":\"something\"}}",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
         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(), "/map-with-enum-key", "path was incorrect");
-261
+    }
     /// Test ID: MapWithEnumKeyResponse

tmp-codegen-diff/codegen-client-test/rest_json_extras/rust-client-codegen/src/operation/primitive_int_op.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::<PrimitiveIntOpInput>()
             .ok_or("failed to downcast to PrimitiveIntOpInput")?;
-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 primitive_int_op_test {
-226
     /// Primitive ints should not be serialized when they are unset
     /// Test ID: SerPrimitiveInt
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn ser_primitive_int_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.primitive_int_op().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,
             "{}",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
         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(), "/primitive-document", "path was incorrect");
-250
+    }
-251
     /// Upper case error modeled lower case
     /// Test ID: ServiceLevelErrorClient
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn service_level_error_client_response() {
         let expected_output = crate::types::error::ExtraError::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("X-Amzn-Errortype", "ExtraError")
                 .status(500)
                 .body(::aws_smithy_types::body::SdkBody::from(""))

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

@@ -221,221 +351,351 @@

↥ 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::<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
     /// Keys and values must be url encoded
     /// Test ID: UrlParamsKeyEncoding
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn url_params_key_encoding_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("&🐱".to_owned()))
             .set_baz(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("hello there".to_owned(), "how's your encoding?".to_owned());
                 ret.insert("a & b & c".to_owned(), "better encode = this".to_owned());
                 ret
             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_query_params = &[
             "bar=%26%F0%9F%90%B1",
             "hello%20there=how%27s%20your%20encoding%3F",
             "a%20%26%20b%20%26%20c=better%20encode%20%3D%20this",
         ];
         ::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");
-280
+    }
-281
     /// Prefer named query parameters when serializing
     /// Test ID: RestJsonQueryPrecedenceForbid
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_query_precedence_forbid_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-289
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .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());
                 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 forbid_params = &["bar=fromMap"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::forbid_query_params(&http_request, forbid_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");
-314
+    }
-315
     /// 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");
-323
         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");
-346
+    }
-347
     /// Upper case error modeled lower case
     /// Test ID: ServiceLevelErrorClient
     #[::tokio::test]
     #[::tracing_test::traced_test]

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

@@ -203,203 +263,263 @@

↥ Expand context

             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<StringPayloadInput>()
             .ok_or("failed to downcast to StringPayloadInput")?;
-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 string_payload_test {
-228
     /// Test ID: StringPayload
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn string_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
             .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 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("unknown"),
         ));
         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");
-255
+    }
-256
     /// Upper case error modeled lower case
     /// Test ID: ServiceLevelErrorClient
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn service_level_error_client_response() {
         let expected_output = crate::types::error::ExtraError::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/Cargo.toml

@@ -9,9 +64,65 @@

↥ Expand context

 [package.metadata.smithy]
 codegen-version = "ci"
 [dependencies.aws-smithy-async]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-async"
 [dependencies.aws-smithy-compression]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-compression"
 features = ["http-body-0-4-x"]
 [dependencies.aws-smithy-http]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http"
 [dependencies.aws-smithy-runtime]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime"
 features = ["client"]
 [dependencies.aws-smithy-runtime-api]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime-api"
 features = ["client", "http-02x"]
 [dependencies.aws-smithy-types]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-types"
 features = ["http-body-0-4-x"]
 [dependencies.aws-smithy-xml]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-xml"

 [dependencies.fastrand]
 version = "2.0.0"
 [dependencies.flate2]
 version = "1.0.30"
 [dependencies.http]
 version = "0.2.9"
 [dependencies.http-body]
 version = "0.4.4"
 [dependencies.tracing]
 version = "0.1"
 [dev-dependencies.aws-smithy-http-client]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http-client"
 features = ["test-util"]
 [dev-dependencies.aws-smithy-protocol-test]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-protocol-test"
 [dev-dependencies.aws-smithy-runtime]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime"
 features = ["client", "test-util"]
 [dev-dependencies.aws-smithy-types]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-types"
 [dev-dependencies.bytes]
 version = "1.4.0"
 [dev-dependencies.pretty_assertions]
 version = "1.3.0"
 [dev-dependencies.tokio]
 version = "1.23.1"
 features = ["macros", "test-util", "rt-multi-thread"]
 [dev-dependencies.tracing-test]
 version = "0.2.5"
 features = ["no-env-filter"]
 [features]
 test-util = ["aws-smithy-runtime/test-util"]
 rt-tokio = ["aws-smithy-async/rt-tokio", "aws-smithy-types/rt-tokio"]
 behavior-version-latest = []
 rustls = ["aws-smithy-runtime/tls-rustls"]
 default-https-client = ["aws-smithy-runtime/default-https-client"]
 gated-tests = []
 default = ["rt-tokio", "rustls"]
 default = ["rt-tokio", "rustls", "default-https-client"]
-64
-65

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/all_query_string_types.rs

@@ -367,367 +427,427 @@

↥ 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::<AllQueryStringTypesInput>()
             .ok_or("failed to downcast to AllQueryStringTypesInput")?;
-375
         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(())
-382
+    }
-383
+}
-384
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.

-387
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod all_query_string_types_test {
-391
     /// Serializes query string parameters with all supported types
     /// Test ID: AllQueryStringTypes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn all_query_string_types_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");
-399
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .all_query_string_types()
             .set_query_string(::std::option::Option::Some("Hello there".to_owned()))
             .set_query_string_list(::std::option::Option::Some(vec!["a".to_owned(), "b".to_owned(), "c".to_owned()]))
             .set_query_string_set(::std::option::Option::Some(vec!["a".to_owned(), "b".to_owned(), "c".to_owned()]))
             .set_query_byte(::std::option::Option::Some(1))
             .set_query_short(::std::option::Option::Some(2))

↧ Expand context

             .set_query_integer(::std::option::Option::Some(3))
             .set_query_integer_list(::std::option::Option::Some(vec![1, 2, 3]))
             .set_query_integer_set(::std::option::Option::Some(vec![1, 2, 3]))
             .set_query_long(::std::option::Option::Some(4))
             .set_query_float(::std::option::Option::Some(1.1_f32))
             .set_query_double(::std::option::Option::Some(1.1_f64))
             .set_query_double_list(::std::option::Option::Some(vec![1.1_f64, 2.1_f64, 3.1_f64]))
             .set_query_boolean(::std::option::Option::Some(true))
             .set_query_boolean_list(::std::option::Option::Some(vec![true, false, true]))
             .set_query_timestamp(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(1, 0_f64)))
             .set_query_timestamp_list(::std::option::Option::Some(vec![
                 ::aws_smithy_types::DateTime::from_fractional_secs(1, 0_f64),
                 ::aws_smithy_types::DateTime::from_fractional_secs(2, 0_f64),
                 ::aws_smithy_types::DateTime::from_fractional_secs(3, 0_f64),
             ]))
             .set_query_enum(::std::option::Option::Some(
                 "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             ))
             .set_query_enum_list(::std::option::Option::Some(vec![
                 "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),

@@ -460,460 +670,670 @@

↥ Expand context

             "Boolean=true",
             "BooleanList=true",
             "BooleanList=false",
             "BooleanList=true",
             "Timestamp=1970-01-01T00%3A00%3A01Z",
             "TimestampList=1970-01-01T00%3A00%3A01Z",
             "TimestampList=1970-01-01T00%3A00%3A02Z",
             "TimestampList=1970-01-01T00%3A00%3A03Z",
             "Enum=Foo",
             "EnumList=Foo",
             "EnumList=Baz",
             "EnumList=Bar",
             "IntegerEnum=1",
             "IntegerEnumList=1",
             "IntegerEnumList=2",
         ];
         ::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(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/AllQueryStringTypesInput", "path was incorrect");
-483
+    }
-484
     /// Handles query string maps
     /// Test ID: RestXmlQueryStringMap
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_xml_query_string_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");
-492
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .all_query_string_types()
             .set_query_params_map_of_strings(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("QueryParamsStringKeyA".to_owned(), "Foo".to_owned());
                 ret.insert("QueryParamsStringKeyB".to_owned(), "Bar".to_owned());
                 ret
             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_query_params = &["QueryParamsStringKeyA=Foo", "QueryParamsStringKeyB=Bar"];
         ::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(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/AllQueryStringTypesInput", "path was incorrect");
-514
+    }
-515
     /// Handles escaping all required characters in the query string.
     /// Test ID: RestXmlQueryStringEscaping
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_xml_query_string_escaping_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-523
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .all_query_string_types()
             .set_query_string(::std::option::Option::Some(" %:/?#[]@!$&'()*+,;=😹".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_query_params = &["String=%20%25%3A%2F%3F%23%5B%5D%40%21%24%26%27%28%29%2A%2B%2C%3B%3D%F0%9F%98%B9"];
         ::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(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/AllQueryStringTypesInput", "path was incorrect");
-540
+    }
-541
     /// Supports handling NaN float query values.
     /// Test ID: RestXmlSupportsNaNFloatQueryValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_xml_supports_na_n_float_query_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");
-549
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .all_query_string_types()
             .set_query_float(::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number"),
             ))
             .set_query_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_query_params = &["Float=NaN", "Double=NaN"];
         ::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(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/AllQueryStringTypesInput", "path was incorrect");
-571
+    }
-572
     /// Supports handling Infinity float query values.
     /// Test ID: RestXmlSupportsInfinityFloatQueryValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_xml_supports_infinity_float_query_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");
-580
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .all_query_string_types()
             .set_query_float(::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number"),
             ))
             .set_query_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_query_params = &["Float=Infinity", "Double=Infinity"];
         ::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(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/AllQueryStringTypesInput", "path was incorrect");
-602
+    }
-603
     /// Supports handling -Infinity float query values.
     /// Test ID: RestXmlSupportsNegativeInfinityFloatQueryValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_xml_supports_negative_infinity_float_query_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");
-611
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .all_query_string_types()
             .set_query_float(::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number"),
             ))
             .set_query_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_query_params = &["Float=-Infinity", "Double=-Infinity"];
         ::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(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/AllQueryStringTypesInput", "path was incorrect");
-633
+    }
-634
     /// Query values of 0 and false are serialized
     /// Test ID: RestXmlZeroAndFalseQueryValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_xml_zero_and_false_query_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");
-642
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .all_query_string_types()
             .set_query_integer(::std::option::Option::Some(0))
             .set_query_boolean(::std::option::Option::Some(false))
             .send()
             .await;
         let _ = dbg!(result);

↧ Expand context

         let http_request = request_receiver.expect_request();
         let expected_query_params = &["Integer=0", "Boolean=false"];
         ::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(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/AllQueryStringTypesInput", "path was incorrect");
-660
+    }
-661
+}
-662
 /// Error type for the `AllQueryStringTypesError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum AllQueryStringTypesError {
     /// 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()`:
-670
+     \

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/body_with_xml_name.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::<BodyWithXmlNameInput>()
             .ok_or("failed to downcast to BodyWithXmlNameInput")?;
-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 body_with_xml_name_test {
-226
     /// Serializes a payload using a wrapper name based on the xmlName
     /// Test ID: BodyWithXmlName
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn body_with_xml_name_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
             .body_with_xml_name()
             .set_nested(::std::option::Option::Some(
                 crate::types::PayloadWithXmlName::builder()
                     .set_name(::std::option::Option::Some("Phreddy".to_owned()))
                     .build(),
             ))

↧ Expand context

             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/xml")];
         ::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,
             "<Ahoy><nested><name>Phreddy</name></nested></Ahoy>",
             ::aws_smithy_protocol_test::MediaType::from("application/xml"),
         ));
         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(), "/BodyWithXmlName", "path was incorrect");
-260
+    }
-261
     /// Serializes a payload using a wrapper name based on the xmlName

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/constant_and_variable_query_string.rs

@@ -225,225 +313,313 @@

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

-245
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod constant_and_variable_query_string_test {
-249
     /// Mixes constant and variable query string parameters
     /// Test ID: ConstantAndVariableQueryStringMissingOneValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn constant_and_variable_query_string_missing_one_value_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");
-257
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .constant_and_variable_query_string()
             .set_baz(::std::option::Option::Some("bam".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_query_params = &["foo=bar", "baz=bam"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_query_string(&http_request, expected_query_params));
         let forbid_params = &["maybeSet"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::forbid_query_params(&http_request, forbid_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(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/ConstantAndVariableQueryString", "path was incorrect");
-276
+    }
-277
     /// Mixes constant and variable query string parameters
     /// Test ID: ConstantAndVariableQueryStringAllValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn constant_and_variable_query_string_all_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");
-285
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .constant_and_variable_query_string()
             .set_baz(::std::option::Option::Some("bam".to_owned()))
             .set_maybe_set(::std::option::Option::Some("yes".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);

↧ Expand context

         let http_request = request_receiver.expect_request();
         let expected_query_params = &["foo=bar", "baz=bam", "maybeSet=yes"];
         ::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(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/ConstantAndVariableQueryString", "path was incorrect");
-303
+    }
-304
+}
-305
 /// Error type for the `ConstantAndVariableQueryStringError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum ConstantAndVariableQueryStringError {
     /// 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()`:
-313
+     \

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/constant_query_string.rs

@@ -225,225 +285,285 @@

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

-245
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod constant_query_string_test {
-249
     /// Includes constant query string parameters
     /// Test ID: ConstantQueryString
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn constant_query_string_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");
-257
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .constant_query_string()
             .set_hello(::std::option::Option::Some("hi".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();

↧ Expand context

         let expected_query_params = &["foo=bar", "hello"];
         ::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(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/ConstantQueryString/hi", "path was incorrect");
-274
+    }
-275
+}
-276
 /// Error type for the `ConstantQueryStringError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum ConstantQueryStringError {
     /// 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()`:
-284
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/empty_input_and_empty_output.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::<EmptyInputAndEmptyOutputInput>()
             .ok_or("failed to downcast to EmptyInputAndEmptyOutputInput")?;
-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 empty_input_and_empty_output_test {
-228
     /// Empty input serializes no payload
     /// Test ID: EmptyInputAndEmptyOutput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn empty_input_and_empty_output_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.empty_input_and_empty_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(), "/EmptyInputAndEmptyOutput", "path was incorrect");
-247
+    }
-248
     /// Empty output serializes no payload
     /// Test ID: EmptyInputAndEmptyOutput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn empty_input_and_empty_output_response() {
         let expected_output = crate::operation::empty_input_and_empty_output::EmptyInputAndEmptyOutputOutput::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(),
-260
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-264

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/endpoint_operation.rs

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

↥ Expand context

             .downcast_ref::<EndpointOperationInput>()
             .ok_or("failed to downcast to EndpointOperationInput")?;
-206
         let endpoint_prefix = ::aws_smithy_runtime_api::client::endpoint::EndpointPrefix::new("foo.").map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint prefix could not be built", err)
         })?;
         cfg.interceptor_state().store_put(endpoint_prefix);
-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 endpoint_operation_test {
-227
     /// Operations can prepend to the given host if they define the
     /// endpoint trait.
     /// Test ID: RestXmlEndpointTrait
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_xml_endpoint_trait_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.endpoint_operation().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(), "/EndpointOperation", "path was incorrect");
         ::pretty_assertions::assert_eq!(uri.host().expect("host should be set"), "foo.example.com");
-248
+    }
-249
+}
-250
 /// Error type for the `EndpointOperationError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum EndpointOperationError {
     /// 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()`:
-258
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-260
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-EndpointOperationError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-263
+}
 impl EndpointOperationError {

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/endpoint_with_host_label_header_operation.rs

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

↥ Expand context

             ::aws_smithy_runtime_api::client::endpoint::EndpointPrefix::new(format!("{accountId}.", accountId = account_id))
-232
+        }
         .map_err(|err| ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint prefix could not be built", err))?;
         cfg.interceptor_state().store_put(endpoint_prefix);
-235
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-242
+    }
-243
+}
-244
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-247
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod endpoint_with_host_label_header_operation_test {

-251
     /// Operations can prepend to the given host if they define the
     /// endpoint trait, and can use the host label trait to define
     /// further customization based on user input. The label must also
     /// be serialized in into any other location it is bound to, such
     /// as the body or in this case an http header.
     /// Test ID: RestXmlEndpointTraitWithHostLabelAndHttpBinding
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_xml_endpoint_trait_with_host_label_and_http_binding_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-263
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .endpoint_with_host_label_header_operation()
             .set_account_id(::std::option::Option::Some("bar".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();

↧ Expand context

         let expected_headers = [("X-Amz-Account-Id", "bar")];
         ::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(), "/EndpointWithHostLabelHeaderOperation", "path was incorrect");
         ::pretty_assertions::assert_eq!(uri.host().expect("host should be set"), "bar.example.com");
-281
+    }
-282
+}
-283
 /// Error type for the `EndpointWithHostLabelHeaderOperationError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum EndpointWithHostLabelHeaderOperationError {
     /// 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()`:
-291
+     \

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