Client Test

rev. b089fac03cba5061dd86d9628e74511b55f01c68

Files changed:

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

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

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

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

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

↥ Expand context

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

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

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

↥ Expand context

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

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

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

↥ Expand context

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

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

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

↥ Expand context

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

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

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

↥ Expand context

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

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

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

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

↥ Expand context

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

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

@@ -224,224 +284,286 @@

↥ Expand context

     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<XmlMapWithXmlNamespaceInput>()
             .ok_or("failed to downcast to XmlMapWithXmlNamespaceInput")?;
-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 xml_map_with_xml_namespace_test {
-245
     /// 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_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-258
         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");
-281
+    }
-282
     /// 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

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

↥ Expand context

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

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

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

↥ Expand context

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

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

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

↥ Expand context

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

 mod xml_namespaces_test {
-237
     /// Serializes XML namespaces
     /// Test ID: XmlNamespaces
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_namespaces_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-250
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .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");
-273
+    }
-274
     /// 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

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

↥ Expand context

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

 mod xml_timestamps_test {
-237
     /// 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_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-250
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .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");
-272
+    }
-273
     /// 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_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-286
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .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");
-308
+    }
-309
     /// 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_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-322
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .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");
-344
+    }
-345
     /// 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_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-358
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .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");
-380
+    }
-381
     /// 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_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-394
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .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");
-416
+    }
-417
     /// 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_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-430
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .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");
-452
+    }
-453
     /// 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_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-466
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .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");
-488
+    }
-489
     /// 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

@@ -214,214 +381,389 @@

↥ Expand context

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

 mod xml_unions_test {
-235
     /// 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_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-248
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .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");
-277
+    }
-278
     /// 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_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-291
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .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");
-313
+    }
-314
     /// 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_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-327
         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");
-347
+    }
-348
     /// 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_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-361
         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");
-381
+    }
-382
     /// 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/src/config.rs

@@ -350,350 +409,427 @@

↥ Expand context

     ///     fn resolve_auth_scheme<'a>(
     ///         &'a self,
     ///         _params: &'a rest_xml_extras::config::auth::Params,
     ///         _cfg: &'a ConfigBag,
     ///         _runtime_components: &'a RuntimeComponents,
     ///     ) -> AuthSchemeOptionsFuture<'a> {
     ///         // --snip--
     /// #      todo!()
     ///     }
     /// }
     ///
     /// let config = rest_xml_extras::Config::builder()
     ///     .auth_scheme_resolver(CustomAuthSchemeResolver)
     ///     // other configurations
     ///     .build();
     /// ```
     pub fn auth_scheme_resolver(mut self, auth_scheme_resolver: impl crate::config::auth::ResolveAuthScheme + 'static) -> Self {
         self.set_auth_scheme_resolver(auth_scheme_resolver);
         self
-369
+    }

-370
     /// Set the auth scheme resolver for the builder
     ///
     /// # Examples
     /// See an example for [`Self::auth_scheme_resolver`].
     pub fn set_auth_scheme_resolver(&mut self, auth_scheme_resolver: impl crate::config::auth::ResolveAuthScheme + 'static) -> &mut Self {
         self.runtime_components
             .set_auth_scheme_option_resolver(::std::option::Option::Some(auth_scheme_resolver.into_shared_resolver()));
         self
-379
+    }
-+
     /// Enable no authentication regardless of what authentication mechanisms operations support
     ///
     /// This adds [NoAuthScheme](aws_smithy_runtime::client::auth::no_auth::NoAuthScheme) as a fallback
     /// and the auth scheme resolver will use it when no other auth schemes are applicable.
     pub fn allow_no_auth(mut self) -> Self {
         self.set_allow_no_auth();
         self
-+
+    }
-+
     /// Enable no authentication regardless of what authentication mechanisms operations support
     ///
     /// This adds [NoAuthScheme](aws_smithy_runtime::client::auth::no_auth::NoAuthScheme) as a fallback
     /// and the auth scheme resolver will use it when no other auth schemes are applicable.
     pub fn set_allow_no_auth(&mut self) -> &mut Self {
         self.push_runtime_plugin(::aws_smithy_runtime::client::auth::no_auth::NoAuthRuntimePluginV2::new().into_shared());
         self
-+
+    }
     /// Set the auth scheme preference for an auth scheme resolver
     /// (typically the default auth scheme resolver).
     ///
     /// Each operation has a predefined order of auth schemes, as determined by the service,
     /// for auth scheme resolution. By using the auth scheme preference, customers
     /// can reorder the schemes resolved by the auth scheme resolver.
     ///
     /// The preference list is intended as a hint rather than a strict override.
     /// Any schemes not present in the originally resolved auth schemes will be ignored.
     ///

↧ Expand context

     /// # Examples
     ///
     /// ```no_run
     /// # use aws_smithy_runtime_api::client::auth::AuthSchemeId;
     /// let config = rest_xml_extras::Config::builder()
     ///     .auth_scheme_preference([AuthSchemeId::from("scheme1"), AuthSchemeId::from("scheme2")])
     ///     // ...
     ///     .build();
     /// let client = rest_xml_extras::Client::from_conf(config);
     /// ```
-418
     pub fn auth_scheme_preference(
         mut self,
         preference: impl ::std::convert::Into<::aws_smithy_runtime_api::client::auth::AuthSchemePreference>,
     ) -> Self {
         self.set_auth_scheme_preference(::std::option::Option::Some(preference.into()));
         self
-425
+    }
-426
     /// Set the auth scheme preference for an auth scheme resolver

@@ -1198,1216 +1258,1277 @@

↥ Expand context

-1216
+    }
-1217
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         ::std::borrow::Cow::Borrowed(&self.components)
-1223
+    }
-1224
+}
-1225
 pub use ::aws_smithy_runtime::client::identity::IdentityCache;
 pub use ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponents;
 pub use ::aws_smithy_types::config_bag::ConfigBag;
-1229
 pub use ::aws_smithy_async::rt::sleep::Sleep;
-1231
 pub(crate) fn base_client_runtime_plugins(mut config: crate::Config) -> ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins {
     let mut configured_plugins = ::std::vec::Vec::new();
     ::std::mem::swap(&mut config.runtime_plugins, &mut configured_plugins);
     #[cfg(feature = "behavior-version-latest")]

-1236
+    {
         if config.behavior_version.is_none() {
             config.behavior_version = Some(::aws_smithy_runtime_api::client::behavior_version::BehaviorVersion::latest());
-1239
+        }
-1240
+    }
-1241
     let default_retry_partition = "restxmlprotocol";
-1243
     let scope = "rest_xml_extras";
-1245
     let mut plugins = ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins::new()
     #[allow(deprecated)]
                     let mut plugins = ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins::new()
                         // defaults
                         .with_client_plugins(::aws_smithy_runtime::client::defaults::default_plugins(
                             ::aws_smithy_runtime::client::defaults::DefaultPluginParams::new()
                                 .with_retry_partition_name(default_retry_partition)
                                 .with_behavior_version(config.behavior_version.expect("Invalid client configuration: A behavior major version must be set when sending a request or constructing a client. You must set it during client construction or by enabling the `behavior-version-latest` cargo feature."))
                         ))
                         // user config
                         .with_client_plugin(
                             ::aws_smithy_runtime_api::client::runtime_plugin::StaticRuntimePlugin::new()
                                 .with_config(config.config.clone())

↧ Expand context

                                 .with_runtime_components(config.runtime_components.clone())
-1259
+                        )
                         // codegen config
                         .with_client_plugin(crate::config::ServiceRuntimePlugin::new(config.clone()))
                         .with_client_plugin(::aws_smithy_runtime::client::auth::no_auth::NoAuthRuntimePlugin::new())
                         .with_client_plugin(
                             ::aws_smithy_runtime::client::metrics::MetricsRuntimePlugin::builder()
                                 .with_scope(scope)
                                 .with_time_source(config.runtime_components.time_source().unwrap_or_default())
                                 .build()
                                 .expect("All required fields have been set")
                         );
-1270
     for plugin in configured_plugins {
         plugins = plugins.with_client_plugin(plugin);
-1273
+    }
     plugins
-1275
+}
-1276
 pub use ::aws_smithy_types::config_bag::FrozenLayer;

tmp-codegen-diff/codegen-client-test/rest_xml_extras/rust-client-codegen/src/config/auth.rs

@@ -73,73 +150,132 @@

↥ Expand context

         let operation_name = params.operation_name();
-74
         let modeled_auth_options = match self.operation_overrides.get(operation_name) {
             Some(overrides) => overrides,
             None => &self.service_defaults,
         };
-79
         let _fut = ::aws_smithy_runtime_api::client::auth::AuthSchemeOptionsFuture::ready(Ok(modeled_auth_options.clone()));
-81
         _fut
-83
+    }
-84
+}
-85
 /// Configuration parameters for resolving the correct auth scheme
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct Params {
     operation_name: ::std::borrow::Cow<'static, str>,
-90
+}
 impl Params {
     /// Create a builder for [`Params`]

     pub fn builder() -> crate::config::auth::ParamsBuilder {
         crate::config::auth::ParamsBuilder::default()
-95
+    }
-96
     /// Return the operation name for [`Params`]
     pub fn operation_name(&self) -> &str {
         self.operation_name.as_ref()
-100
+    }
-101
+}
-102
 #[cfg(test)]
 #[derive(Debug)]
 pub(crate) struct NoAuthSchemeResolver;
--
 #[cfg(test)]
 impl ResolveAuthScheme for NoAuthSchemeResolver {
     fn resolve_auth_scheme<'a>(
         &'a self,
         _params: &'a crate::config::auth::Params,
         _cfg: &'a ::aws_smithy_types::config_bag::ConfigBag,
         _runtime_components: &'a ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponents,
     ) -> ::aws_smithy_runtime_api::client::auth::AuthSchemeOptionsFuture<'a> {
         ::aws_smithy_runtime_api::client::auth::AuthSchemeOptionsFuture::ready(::std::result::Result::Ok(vec![
             ::aws_smithy_runtime_api::client::auth::AuthSchemeOption::from(::aws_smithy_runtime::client::auth::no_auth::NO_AUTH_SCHEME_ID),
         ]))
--
+    }
--
+}
--
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 /// Builder for [`Params`]
 pub struct ParamsBuilder {
     operation_name: ::std::option::Option<::std::borrow::Cow<'static, str>>,
-107
+}
 impl ParamsBuilder {
     /// Set the operation name for the builder
     pub fn operation_name(self, operation_name: impl Into<::std::borrow::Cow<'static, str>>) -> Self {
         self.set_operation_name(::std::option::Option::Some(operation_name.into()))
-112
+    }

↧ Expand context

-113
     /// Set the operation name for the builder
     pub fn set_operation_name(mut self, operation_name: ::std::option::Option<::std::borrow::Cow<'static, str>>) -> Self {
         self.operation_name = operation_name;
         self
-118
+    }
     /// Consume this builder, create [`Params`]."
     ///
     /// Return [`BuildError`] if any of the required fields are unset.
     ///
     pub fn build(self) -> ::std::result::Result<crate::config::auth::Params, crate::config::auth::BuildError> {
         ::std::result::Result::Ok(crate::config::auth::Params {
             operation_name: self.operation_name.ok_or_else(|| BuildError::missing("operation_name"))?,
         })
-127
+    }
-128
+}
-129
 /// An error that occurred while constructing `config::auth::Params`
 #[derive(Debug)]
 pub struct BuildError {

tmp-codegen-diff/codegen-client-test/rest_xml_extras/rust-client-codegen/src/operation/checksum_required.rs

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

↥ Expand context

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

 #[cfg(test)]
 mod checksum_required_test {
-243
     /// Test ID: ChecksumRequiredHeader
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn checksum_required_header_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-255
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .checksum_required()
             .set_field(::std::option::Option::Some("hello".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();

↧ Expand context

         let expected_headers = [("Content-Md5", "JAJAqYA61wMhATGeQqRcMQ==")];
         ::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,
             "<ChecksumRequiredInput><field>hello</field></ChecksumRequiredInput>",
             ::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(), "/ChecksumRequired", "path was incorrect");
-275
+    }
-276
+}
-277
 /// Error type for the `ChecksumRequiredError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum ChecksumRequiredError {
     /// 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 \

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