Client Test

rev. 1fb202108840af7ccb1069c5b8afebf43a5e5aec

Files changed:

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

@@ -202,202 +292,292 @@

             ::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::<XmlAttributesInput>()
             .ok_or("failed to downcast to XmlAttributesInput")?;
-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 xml_attributes_test {
-226
     /// Serializes XML attributes on the synthesized document
     /// Test ID: XmlAttributes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_attributes_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
             .xml_attributes()
             .set_foo(::std::option::Option::Some("hi".to_owned()))
             .set_attr(::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/xml")];
         ::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,
             "<XmlAttributesRequest test=\"test\">\n    <foo>hi</foo>\n</XmlAttributesRequest>\n",
             ::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(), "/XmlAttributes", "path was incorrect");
-255
+    }
-256
     /// Serializes XML attributes with escaped characters on the synthesized document
     /// Test ID: XmlAttributesWithEscaping
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_attributes_with_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");
-264
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .xml_attributes()
             .set_foo(::std::option::Option::Some("hi".to_owned()))
             .set_attr(::std::option::Option::Some("<test&mock>".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);

↧ Expand context

         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 body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "<XmlAttributesRequest test=\"&lt;test&amp;mock&gt;\">\n    <foo>hi</foo>\n</XmlAttributesRequest>\n",
             ::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(), "/XmlAttributes", "path was incorrect");
-285
+    }
-286
     /// Serializes simple scalar properties
     /// Test ID: XmlAttributes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_attributes_response() {
         let expected_output = crate::operation::xml_attributes::XmlAttributesOutput::builder()

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

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

↥ Expand context

             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<XmlAttributesOnPayloadInput>()
             .ok_or("failed to downcast to XmlAttributesOnPayloadInput")?;
-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 xml_attributes_on_payload_test {
-234
     /// Serializes XML attributes on the synthesized document
     /// Test ID: XmlAttributesOnPayload
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_attributes_on_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");
-242
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .xml_attributes_on_payload()
             .set_payload(::std::option::Option::Some(
                 crate::types::XmlAttributesPayloadRequest::builder()
                     .set_foo(::std::option::Option::Some("hi".to_owned()))
                     .set_attr(::std::option::Option::Some("test".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 body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "<XmlAttributesPayloadRequest test=\"test\">\n    <foo>hi</foo>\n</XmlAttributesPayloadRequest>\n",
             ::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(), "/XmlAttributesOnPayload", "path was incorrect");
-267
+    }
-268
     /// Serializes simple scalar properties
     /// Test ID: XmlAttributesOnPayload

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

@@ -195,195 +255,255 @@

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

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

↧ Expand context

         let expected_headers = [("Content-Type", "application/xml")];
         ::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,
             "<XmlBlobsRequest>\n    <data>dmFsdWU=</data>\n</XmlBlobsRequest>\n",
             ::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(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/XmlBlobs", "path was incorrect");
-247
+    }
-248
     /// Blobs are base64 encoded
     /// Test ID: XmlBlobs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_blobs_response() {
         let expected_output = crate::operation::xml_blobs::XmlBlobsOutput::builder()
             .set_data(::std::option::Option::Some(::aws_smithy_types::Blob::new("value")))

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/xml_empty_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::<XmlEmptyListsInput>()
             .ok_or("failed to downcast to XmlEmptyListsInput")?;
-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 xml_empty_lists_test {
-226
     /// Serializes Empty XML lists
     /// Test ID: XmlEmptyLists
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_empty_lists_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-234
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .xml_empty_lists()
             .set_string_list(::std::option::Option::Some(vec![]))
             .set_string_set(::std::option::Option::Some(vec![]))
             .send()
             .await;
         let _ = dbg!(result);

↧ Expand context

         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 body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "<XmlEmptyListsRequest>\n        <stringList></stringList>\n        <stringSet></stringSet>\n</XmlEmptyListsRequest>\n",
             ::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(), "/XmlEmptyLists", "path was incorrect");
-255
+    }
-256
     /// Deserializes Empty XML lists
     /// Test ID: XmlEmptyLists
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_empty_lists_response() {
         let expected_output = crate::operation::xml_empty_lists::XmlEmptyListsOutput::builder()

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/xml_empty_maps.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::<XmlEmptyMapsInput>()
             .ok_or("failed to downcast to XmlEmptyMapsInput")?;
-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 xml_empty_maps_test {
-226
     /// Serializes Empty XML maps
     /// Test ID: XmlEmptyMaps
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_empty_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
             .xml_empty_maps()
             .set_my_map(::std::option::Option::Some(::std::collections::HashMap::new()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();

↧ Expand context

         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 body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "<XmlEmptyMapsRequest>\n    <myMap></myMap>\n</XmlEmptyMapsRequest>\n",
             ::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(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/XmlEmptyMaps", "path was incorrect");
-254
+    }
-255
     /// Deserializes Empty XML maps
     /// Test ID: XmlEmptyMaps
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_empty_maps_response() {
         let expected_output = crate::operation::xml_empty_maps::XmlEmptyMapsOutput::builder()
             .set_my_map(::std::option::Option::Some(::std::collections::HashMap::new()))

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/xml_empty_strings.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::<XmlEmptyStringsInput>()
             .ok_or("failed to downcast to XmlEmptyStringsInput")?;
-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 xml_empty_strings_test {
-226
     /// Serializes xml empty strings
     /// Test ID: XmlEmptyStrings
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_empty_strings_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
             .xml_empty_strings()
             .set_empty_string(::std::option::Option::Some("".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();

↧ Expand context

         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 body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "<XmlEmptyStringsRequest>\n    <emptyString></emptyString>\n</XmlEmptyStringsRequest>\n",
             ::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(), "/XmlEmptyStrings", "path was incorrect");
-254
+    }
-255
     /// Deserializes xml empty strings
     /// Test ID: XmlEmptyStrings
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_empty_strings_response() {
         let expected_output = crate::operation::xml_empty_strings::XmlEmptyStringsOutput::builder()
             .set_empty_string(::std::option::Option::Some("".to_owned()))

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

@@ -195,195 +255,255 @@

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

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

↧ Expand context

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

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

@@ -201,201 +261,261 @@

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

-221
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod xml_int_enums_test {
-225
     /// Serializes simple scalar properties
     /// Test ID: XmlIntEnums
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_int_enums_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-233
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .xml_int_enums()
             .set_int_enum1(::std::option::Option::Some(1))
             .set_int_enum2(::std::option::Option::Some(2))
             .set_int_enum3(::std::option::Option::Some(3))
             .set_int_enum_list(::std::option::Option::Some(vec![1, 2]))
             .set_int_enum_set(::std::option::Option::Some(vec![1, 2]))

↧ Expand context

             .set_int_enum_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("a".to_owned(), 1);
                 ret.insert("b".to_owned(), 2);
                 ret
             }))
             .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 body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(
         ::aws_smithy_protocol_test::validate_body(body, "<XmlIntEnumsRequest>\n    <intEnum1>1</intEnum1>\n    <intEnum2>2</intEnum2>\n    <intEnum3>3</intEnum3>\n    <intEnumList>\n        <member>1</member>\n        <member>2</member>\n    </intEnumList>\n    <intEnumSet>\n        <member>1</member>\n        <member>2</member>\n    </intEnumSet>\n    <intEnumMap>\n        <entry>\n            <key>a</key>\n            <value>1</value>\n        </entry>\n        <entry>\n            <key>b</key>\n            <value>2</value>\n        </entry>\n    </intEnumMap>\n</XmlIntEnumsRequest>\n", ::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(), "/XmlIntEnums", "path was incorrect");
-261
+    }

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

@@ -195,195 +255,255 @@

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

-215
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod xml_lists_test {
-219
     /// Tests for XML list serialization
     /// Test ID: XmlLists
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_lists_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-227
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .xml_lists()
             .set_string_list(::std::option::Option::Some(vec!["foo".to_owned(), "bar".to_owned()]))
             .set_string_set(::std::option::Option::Some(vec!["foo".to_owned(), "bar".to_owned()]))
             .set_integer_list(::std::option::Option::Some(vec![1, 2]))
             .set_boolean_list(::std::option::Option::Some(vec![true, false]))
             .set_timestamp_list(::std::option::Option::Some(vec![

↧ Expand context

                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
             ]))
             .set_enum_list(::std::option::Option::Some(vec![
                 "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
                 "0".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             ]))
             .set_int_enum_list(::std::option::Option::Some(vec![1, 2]))
             .set_nested_string_list(::std::option::Option::Some(vec![
                 vec!["foo".to_owned(), "bar".to_owned()],
                 vec!["baz".to_owned(), "qux".to_owned()],
             ]))
             .set_renamed_list_members(::std::option::Option::Some(vec!["foo".to_owned(), "bar".to_owned()]))
             .set_flattened_list(::std::option::Option::Some(vec!["hi".to_owned(), "bye".to_owned()]))
             .set_flattened_list2(::std::option::Option::Some(vec!["yep".to_owned(), "nope".to_owned()]))
             .set_structure_list(::std::option::Option::Some(vec![
                 crate::types::StructureListMember::builder()
                     .set_a(::std::option::Option::Some("1".to_owned()))
                     .set_b(::std::option::Option::Some("2".to_owned()))
                     .build(),

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

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

↥ Expand context

             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<XmlMapWithXmlNamespaceInput>()
             .ok_or("failed to downcast to XmlMapWithXmlNamespaceInput")?;
-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 xml_map_with_xml_namespace_test {
-234
     /// Serializes XML maps in requests that have xmlNamespace and xmlName on members
     /// Test ID: RestXmlXmlMapWithXmlNamespace
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_xml_xml_map_with_xml_namespace_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
             .xml_map_with_xml_namespace()
             .set_my_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("a".to_owned(), "A".to_owned());
                 ret.insert("b".to_owned(), "B".to_owned());
                 ret

↧ Expand context

             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/xml")];
         ::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, "<XmlMapWithXmlNamespaceRequest>\n    <KVP xmlns=\"https://the-member.example.com\">\n        <entry>\n            <K xmlns=\"https://the-key.example.com\">a</K>\n            <V xmlns=\"https://the-value.example.com\">A</V>\n        </entry>\n        <entry>\n            <K xmlns=\"https://the-key.example.com\">b</K>\n            <V xmlns=\"https://the-value.example.com\">B</V>\n        </entry>\n    </KVP>\n</XmlMapWithXmlNamespaceRequest>", ::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(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/XmlMapWithXmlNamespace", "path was incorrect");
-265
+    }
-266
     /// Serializes XML maps in responses that have xmlNamespace and xmlName on members
     /// Test ID: RestXmlXmlMapWithXmlNamespace
     #[::tokio::test]
     #[::tracing_test::traced_test]

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

@@ -195,195 +255,255 @@

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

-215
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod xml_maps_test {
-219
     /// Tests for XML map serialization
     /// Test ID: XmlMaps
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_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");
-227
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .xml_maps()
             .set_my_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "foo".to_owned(),
                     crate::types::GreetingStruct::builder()

↧ Expand context

                         .set_hi(::std::option::Option::Some("there".to_owned()))
                         .build(),
                 );
                 ret.insert(
                     "baz".to_owned(),
                     crate::types::GreetingStruct::builder()
                         .set_hi(::std::option::Option::Some("bye".to_owned()))
                         .build(),
                 );
                 ret
             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/xml")];
         ::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, "<XmlMapsRequest>\n    <myMap>\n        <entry>\n            <key>foo</key>\n            <value>\n                <hi>there</hi>\n            </value>\n        </entry>\n        <entry>\n            <key>baz</key>\n            <value>\n                <hi>bye</hi>\n            </value>\n        </entry>\n    </myMap>\n</XmlMapsRequest>\n", ::aws_smithy_protocol_test::MediaType::from("application/xml"))

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/xml_maps_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::<XmlMapsXmlNameInput>()
             .ok_or("failed to downcast to XmlMapsXmlNameInput")?;
-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 xml_maps_xml_name_test {
-226
     /// Serializes XML maps that have xmlName on members
     /// Test ID: XmlMapsXmlName
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_maps_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
             .xml_maps_xml_name()
             .set_my_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "foo".to_owned(),
                     crate::types::GreetingStruct::builder()

↧ Expand context

                         .set_hi(::std::option::Option::Some("there".to_owned()))
                         .build(),
                 );
                 ret.insert(
                     "baz".to_owned(),
                     crate::types::GreetingStruct::builder()
                         .set_hi(::std::option::Option::Some("bye".to_owned()))
                         .build(),
                 );
                 ret
             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/xml")];
         ::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, "<XmlMapsXmlNameRequest>\n    <myMap>\n        <entry>\n            <Attribute>foo</Attribute>\n            <Setting>\n                <hi>there</hi>\n            </Setting>\n        </entry>\n        <entry>\n            <Attribute>baz</Attribute>\n            <Setting>\n                <hi>bye</hi>\n            </Setting>\n        </entry>\n    </myMap>\n</XmlMapsXmlNameRequest>\n", ::aws_smithy_protocol_test::MediaType::from("application/xml"))

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/xml_namespaces.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::<XmlNamespacesInput>()
             .ok_or("failed to downcast to XmlNamespacesInput")?;
-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 xml_namespaces_test {
-226
     /// Serializes XML namespaces
     /// Test ID: XmlNamespaces
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_namespaces_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
             .xml_namespaces()
             .set_nested(::std::option::Option::Some(
                 crate::types::XmlNamespaceNested::builder()
                     .set_foo(::std::option::Option::Some("Foo".to_owned()))
                     .set_values(::std::option::Option::Some(vec!["Bar".to_owned(), "Baz".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 body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(
         ::aws_smithy_protocol_test::validate_body(body, "<XmlNamespacesRequest xmlns=\"http://foo.com\">\n    <nested>\n        <foo xmlns:baz=\"http://baz.com\">Foo</foo>\n        <values xmlns=\"http://qux.com\">\n            <member xmlns=\"http://bux.com\">Bar</member>\n            <member xmlns=\"http://bux.com\">Baz</member>\n        </values>\n    </nested>\n</XmlNamespacesRequest>\n", ::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(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/XmlNamespaces", "path was incorrect");
-257
+    }
-258
     /// Serializes XML namespaces
     /// Test ID: XmlNamespaces
     #[::tokio::test]
     #[::tracing_test::traced_test]

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

@@ -202,202 +448,448 @@

↥ 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::<XmlTimestampsInput>()
             .ok_or("failed to downcast to XmlTimestampsInput")?;
-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 xml_timestamps_test {
-226
     /// Tests how normal timestamps are serialized
     /// Test ID: XmlTimestamps
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_timestamps_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
             .xml_timestamps()
             .set_normal(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/xml")];
         ::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,
             "<XmlTimestampsRequest>\n    <normal>2014-04-29T18:30:38Z</normal>\n</XmlTimestampsRequest>\n",
             ::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(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/XmlTimestamps", "path was incorrect");
-256
+    }
-257
     /// Ensures that the timestampFormat of date-time works like normal timestamps
     /// Test ID: XmlTimestampsWithDateTimeFormat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_timestamps_with_date_time_format_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-265
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .xml_timestamps()
             .set_date_time(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/xml")];
         ::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,
             "<XmlTimestampsRequest>\n    <dateTime>2014-04-29T18:30:38Z</dateTime>\n</XmlTimestampsRequest>\n",
             ::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(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/XmlTimestamps", "path was incorrect");
-287
+    }
-288
     /// Ensures that the timestampFormat of date-time on the target shape works like normal timestamps
     /// Test ID: XmlTimestampsWithDateTimeOnTargetFormat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_timestamps_with_date_time_on_target_format_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-296
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .xml_timestamps()
             .set_date_time_on_target(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/xml")];
         ::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,
             "<XmlTimestampsRequest>\n    <dateTimeOnTarget>2014-04-29T18:30:38Z</dateTimeOnTarget>\n</XmlTimestampsRequest>\n",
             ::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(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/XmlTimestamps", "path was incorrect");
-318
+    }
-319
     /// Ensures that the timestampFormat of epoch-seconds works
     /// Test ID: XmlTimestampsWithEpochSecondsFormat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_timestamps_with_epoch_seconds_format_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-327
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .xml_timestamps()
             .set_epoch_seconds(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/xml")];
         ::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,
             "<XmlTimestampsRequest>\n    <epochSeconds>1398796238</epochSeconds>\n</XmlTimestampsRequest>\n",
             ::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(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/XmlTimestamps", "path was incorrect");
-349
+    }
-350
     /// Ensures that the timestampFormat of epoch-seconds on the target shape works
     /// Test ID: XmlTimestampsWithEpochSecondsOnTargetFormat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_timestamps_with_epoch_seconds_on_target_format_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-358
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .xml_timestamps()
             .set_epoch_seconds_on_target(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/xml")];
         ::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,
             "<XmlTimestampsRequest>\n    <epochSecondsOnTarget>1398796238</epochSecondsOnTarget>\n</XmlTimestampsRequest>\n",
             ::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(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/XmlTimestamps", "path was incorrect");
-380
+    }
-381
     /// Ensures that the timestampFormat of http-date works
     /// Test ID: XmlTimestampsWithHttpDateFormat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_timestamps_with_http_date_format_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-389
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .xml_timestamps()
             .set_http_date(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/xml")];
         ::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,
             "<XmlTimestampsRequest>\n    <httpDate>Tue, 29 Apr 2014 18:30:38 GMT</httpDate>\n</XmlTimestampsRequest>\n",
             ::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(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/XmlTimestamps", "path was incorrect");
-411
+    }
-412
     /// Ensures that the timestampFormat of http-date on the target shape works
     /// Test ID: XmlTimestampsWithHttpDateOnTargetFormat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_timestamps_with_http_date_on_target_format_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-420
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .xml_timestamps()
             .set_http_date_on_target(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .send()
             .await;

↧ Expand context

         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/xml")];
         ::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,
             "<XmlTimestampsRequest>\n    <httpDateOnTarget>Tue, 29 Apr 2014 18:30:38 GMT</httpDateOnTarget>\n</XmlTimestampsRequest>\n",
             ::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(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/XmlTimestamps", "path was incorrect");
-442
+    }
-443
     /// Tests how normal timestamps are serialized
     /// Test ID: XmlTimestamps
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_timestamps_response() {

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

@@ -199,199 +357,357 @@

↥ 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::<XmlUnionsInput>()
             .ok_or("failed to downcast to XmlUnionsInput")?;
-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 xml_unions_test {
-223
     /// Serializes union struct member
     /// Test ID: XmlUnionsWithStructMember
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_unions_with_struct_member_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
             .xml_unions()
             .set_union_value(::std::option::Option::Some(crate::types::XmlUnionShape::StructValue(
                 crate::types::XmlNestedUnionStruct::builder()
                     .set_string_value(::std::option::Option::Some("string".to_owned()))
                     .set_boolean_value(::std::option::Option::Some(true))
                     .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))
                     .build(),
             )))
             .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 body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(
         ::aws_smithy_protocol_test::validate_body(body, "<XmlUnionsRequest>\n    <unionValue>\n       <structValue>\n          <stringValue>string</stringValue>\n          <booleanValue>true</booleanValue>\n          <byteValue>1</byteValue>\n          <shortValue>2</shortValue>\n          <integerValue>3</integerValue>\n          <longValue>4</longValue>\n          <floatValue>5.5</floatValue>\n          <doubleValue>6.5</doubleValue>\n       </structValue>\n    </unionValue>\n</XmlUnionsRequest>\n", ::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(), "/XmlUnions", "path was incorrect");
-260
+    }
-261
     /// serialize union string member
     /// Test ID: XmlUnionsWithStringMember
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_unions_with_string_member_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-269
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .xml_unions()
             .set_union_value(::std::option::Option::Some(crate::types::XmlUnionShape::StringValue(
                 "some string".to_owned(),
             )))
             .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 body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "<XmlUnionsRequest>\n   <unionValue>\n      <stringValue>some string</stringValue>\n   </unionValue>\n</XmlUnionsRequest>\n",
             ::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(), "/XmlUnions", "path was incorrect");
-291
+    }
-292
     /// Serializes union boolean member
     /// Test ID: XmlUnionsWithBooleanMember
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_unions_with_boolean_member_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");
-300
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .xml_unions()
             .set_union_value(::std::option::Option::Some(crate::types::XmlUnionShape::BooleanValue(true)))
             .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 body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "<XmlUnionsRequest>\n   <unionValue>\n      <booleanValue>true</booleanValue>\n   </unionValue>\n</XmlUnionsRequest>\n",
             ::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(), "/XmlUnions", "path was incorrect");
-320
+    }
-321
     /// Serializes union member
     /// Test ID: XmlUnionsWithUnionMember
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_unions_with_union_member_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");
-329
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .xml_unions()
             .set_union_value(::std::option::Option::Some(crate::types::XmlUnionShape::UnionValue(
                 ::std::boxed::Box::new(crate::types::XmlUnionShape::BooleanValue(true)),
             )))
             .send()
             .await;

↧ Expand context

         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 body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(
         ::aws_smithy_protocol_test::validate_body(body, "<XmlUnionsRequest>\n   <unionValue>\n      <unionValue>\n         <booleanValue>true</booleanValue>\n      </unionValue>\n   </unionValue>\n</XmlUnionsRequest>\n", ::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(), "/XmlUnions", "path was incorrect");
-349
+    }
-350
     /// Serializes union struct member
     /// Test ID: XmlUnionsWithStructMember
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_unions_with_struct_member_response() {
         let expected_output = crate::operation::xml_unions::XmlUnionsOutput::builder()
             .set_union_value(::std::option::Option::Some(crate::types::XmlUnionShape::StructValue(

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

@@ -1,1 +54,55 @@

↥ Expand context

 # Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 [package]
 name = "rest_xml_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-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.aws-smithy-xml]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-xml"
 [dependencies.http]
 version = "0.2.9"
 [dependencies.md-5]
 version = "0.10.0"
 [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.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]
 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"]
-54
-55

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