Client Test

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

@@ -188,188 +249,251 @@

-188
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-190
+    }
-191
+}
 #[derive(Debug)]
 struct XmlMapsEndpointParamsInterceptor;
-194
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for XmlMapsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "XmlMapsEndpointParamsInterceptor"
-198
+    }
-199
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,

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

↧ Expand context

-232
     /// 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)
             .endpoint_url("https://example.com");
-243
         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()

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

@@ -194,194 +255,257 @@

↥ Expand context

-194
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-196
+    }
-197
+}
 #[derive(Debug)]
 struct XmlMapsXmlNameEndpointParamsInterceptor;
-200
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for XmlMapsXmlNameEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "XmlMapsXmlNameEndpointParamsInterceptor"
-204
+    }
-205
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,

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

↧ Expand context

-238
     /// 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)
             .endpoint_url("https://example.com");
-249
         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()

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

@@ -194,194 +255,257 @@

↥ Expand context

-194
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-196
+    }
-197
+}
 #[derive(Debug)]
 struct XmlNamespacesEndpointParamsInterceptor;
-200
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for XmlNamespacesEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "XmlNamespacesEndpointParamsInterceptor"
-204
+    }
-205
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,

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

↧ Expand context

-238
     /// 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)
             .endpoint_url("https://example.com");
-249
         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(),

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

@@ -194,194 +255,257 @@

↥ Expand context

-194
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-196
+    }
-197
+}
 #[derive(Debug)]
 struct XmlTimestampsEndpointParamsInterceptor;
-200
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for XmlTimestampsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "XmlTimestampsEndpointParamsInterceptor"
-204
+    }
-205
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,

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

↧ Expand context

-238
     /// 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)
             .endpoint_url("https://example.com");
-249
         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;

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

@@ -192,192 +253,255 @@

↥ Expand context

-192
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-194
+    }
-195
+}
 #[derive(Debug)]
 struct XmlUnionsEndpointParamsInterceptor;
-198
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for XmlUnionsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "XmlUnionsEndpointParamsInterceptor"
-202
+    }
-203
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,

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

↧ Expand context

-236
     /// 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)
             .endpoint_url("https://example.com");
-247
         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))

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

@@ -190,190 +251,253 @@

↥ Expand context

-190
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-192
+    }
-193
+}
 #[derive(Debug)]
 struct AttributePartyEndpointParamsInterceptor;
-196
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for AttributePartyEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "AttributePartyEndpointParamsInterceptor"
-200
+    }
-201
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,

         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<AttributePartyInput>()
             .ok_or("failed to downcast to AttributePartyInput")?;
-216
         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 attribute_party_test {

↧ Expand context

-234
     /// Test ID: DeserAttributes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn deser_attributes_response() {
         let expected_output = crate::operation::attribute_party::AttributePartyOutput::builder()
             .set_enum(::std::option::Option::Some(
                 "enumvalue".parse::<crate::types::StringEnum>().expect("static value validated to member"),
             ))
             .set_number(::std::option::Option::Some(5))
             .set_ts(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 482196050, 0_f64,
             )))
             .set_bool(::std::option::Option::Some(true))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "<AttributePartyInputOutput enum=\"enumvalue\" prefix:anumber=\"5\" ts=\"1985-04-12T23:20:50.00Z\" bool=\"true\"/>",

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

@@ -200,200 +261,263 @@

↥ Expand context

-200
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-202
+    }
-203
+}
 #[derive(Debug)]
 struct ChecksumRequiredEndpointParamsInterceptor;
-206
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ChecksumRequiredEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ChecksumRequiredEndpointParamsInterceptor"
-210
+    }
-211
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,

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

↧ Expand context

-244
     /// 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)
             .endpoint_url("https://example.com");
-254
         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();
         let expected_headers = [("Content-Md5", "JAJAqYA61wMhATGeQqRcMQ==")];

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

@@ -192,192 +253,255 @@

↥ Expand context

-192
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-194
+    }
-195
+}
 #[derive(Debug)]
 struct CreateFooEndpointParamsInterceptor;
-198
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CreateFooEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "CreateFooEndpointParamsInterceptor"
-202
+    }
-203
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,

         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<CreateFooInput>()
             .ok_or("failed to downcast to CreateFooInput")?;
-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(())
-227
+    }
-228
+}
-229
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-232
 /// Error type for the `CreateFooError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

↧ Expand context

 pub enum CreateFooError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
     variable wildcard pattern and check `.code()`:
-240
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-242
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-CreateFooError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-245
+}
 impl CreateFooError {
     /// Creates the `CreateFooError::Unhandled` variant from any error type.
     pub fn unhandled(
         err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,
     ) -> Self {
         Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
             source: err.into(),
             meta: ::std::default::Default::default(),
         })
-255
+    }

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

@@ -188,188 +249,251 @@

↥ Expand context

-188
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-190
+    }
-191
+}
 #[derive(Debug)]
 struct EnumKeysEndpointParamsInterceptor;
-194
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for EnumKeysEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "EnumKeysEndpointParamsInterceptor"
-198
+    }
-199
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,

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

↧ Expand context

-232
     /// Test ID: SerEnumMap
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn ser_enum_map_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-242
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .enum_keys()
             .set_data(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "enumvalue".parse::<crate::types::StringEnum>().expect("static value validated to member"),
                     "hello".to_owned(),
                 );

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

@@ -202,202 +263,265 @@

↥ Expand context

-202
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-204
+    }
-205
+}
 #[derive(Debug)]
 struct PrimitiveIntOpXmlEndpointParamsInterceptor;
-208
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PrimitiveIntOpXmlEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PrimitiveIntOpXmlEndpointParamsInterceptor"
-212
+    }
-213
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,

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

↧ Expand context

-246
     /// Primitive ints should not be serialized when they are unset
     /// Test ID: RestXmlSerPrimitiveIntUnset
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_xml_ser_primitive_int_unset_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)
             .endpoint_url("https://example.com");
-257
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.primitive_int_op_xml().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "    <PrimitiveIntDocument>\n    </PrimitiveIntDocument>\n",

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

@@ -194,194 +255,257 @@

↥ Expand context

-194
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-196
+    }
-197
+}
 #[derive(Debug)]
 struct RequiredMemberEndpointParamsInterceptor;
-200
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for RequiredMemberEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "RequiredMemberEndpointParamsInterceptor"
-204
+    }
-205
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,

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

↧ Expand context

 pub enum RequiredMemberError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
     variable wildcard pattern and check `.code()`:
-242
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-244
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-RequiredMemberError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-247
+}
 impl RequiredMemberError {
     /// Creates the `RequiredMemberError::Unhandled` variant from any error type.
     pub fn unhandled(
         err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,
     ) -> Self {
         Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
             source: err.into(),
             meta: ::std::default::Default::default(),
         })
-257
+    }

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

@@ -190,190 +251,253 @@

↥ Expand context

-190
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-192
+    }
-193
+}
 #[derive(Debug)]
 struct StringHeaderEndpointParamsInterceptor;
-196
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for StringHeaderEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "StringHeaderEndpointParamsInterceptor"
-200
+    }
-201
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,

         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<StringHeaderInput>()
             .ok_or("failed to downcast to StringHeaderInput")?;
-216
         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 string_header_test {

↧ Expand context

-234
     /// Regression test for https://github.com/awslabs/aws-sdk-rust/issues/122
     /// where `,` was eagerly used to split fields in cases where the input was not
     /// a list.
     ///
     /// Test ID: DeserHeaderStringCommas
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn deser_header_string_commas_response() {
         let expected_output = crate::operation::string_header::StringHeaderOutput::builder()
             .set_field(::std::option::Option::Some("a,b,c".to_owned()))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("x-field", "a,b,c")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(""))
                 .unwrap(),
-252
+        )
         .unwrap();

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

@@ -206,206 +267,269 @@

↥ Expand context

-206
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-208
+    }
-209
+}
 #[derive(Debug)]
 struct XmlMapsFlattenedNestedXmlNamespaceEndpointParamsInterceptor;
-212
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for XmlMapsFlattenedNestedXmlNamespaceEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "XmlMapsFlattenedNestedXmlNamespaceEndpointParamsInterceptor"
-216
+    }
-217
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,

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

↧ Expand context

-250
     /// Test ID: DeserFlatNamespaceMaps
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn deser_flat_namespace_maps_response() {
         let expected_output = crate::operation::xml_maps_flattened_nested_xml_namespace::XmlMapsFlattenedNestedXmlNamespaceOutput::builder()
             .set_my_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("map2".to_owned(), {
                     let mut ret = ::std::collections::HashMap::new();
                     ret.insert("fourth".to_owned(), "onegai".to_owned());
                     ret.insert("third".to_owned(), "plz".to_owned());
                     ret
                 });
                 ret.insert("map1".to_owned(), {
                     let mut ret = ::std::collections::HashMap::new();
                     ret.insert("second".to_owned(), "konnichiwa".to_owned());
                     ret.insert("first".to_owned(), "hi".to_owned());
                     ret
                 });

tmp-codegen-diff/codegen-client-test/rest_xml_extras_unwrapped/rust-client-codegen/src/operation/greeting_with_unwrapped_errors.rs

@@ -196,196 +257,259 @@

↥ Expand context

-196
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-198
+    }
-199
+}
 #[derive(Debug)]
 struct GreetingWithUnwrappedErrorsEndpointParamsInterceptor;
-202
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GreetingWithUnwrappedErrorsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GreetingWithUnwrappedErrorsEndpointParamsInterceptor"
-206
+    }
-207
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,

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

↧ Expand context

-240
     /// Ensures that operations with errors successfully know how to deserialize the successful response
     /// Test ID: GreetingWithErrorsUnwrapped
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn greeting_with_errors_unwrapped_response() {
         let expected_output = crate::operation::greeting_with_unwrapped_errors::GreetingWithUnwrappedErrorsOutput::builder()
             .set_greeting(::std::option::Option::Some("Hello".to_owned()))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("X-Greeting", "Hello")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(""))
                 .unwrap(),
-255
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-259

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

@@ -203,203 +264,266 @@

↥ Expand context

-203
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-205
+    }
-206
+}
 #[derive(Debug)]
 struct SimpleScalarPropertiesEndpointParamsInterceptor;
-209
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for SimpleScalarPropertiesEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "SimpleScalarPropertiesEndpointParamsInterceptor"
-213
+    }
-214
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,

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

↧ Expand context

     use ::aws_smithy_protocol_test::FloatEquals;
-248
     /// Serializes simple scalar properties
     /// Test ID: XmlNamespaceSimpleScalarProperties
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn xml_namespace_simple_scalar_properties_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)
             .endpoint_url("https://example.com");
-259
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .simple_scalar_properties()
             .set_foo(::std::option::Option::Some("Foo".to_owned()))
             .set_string_value(::std::option::Option::Some("string".to_owned()))
             .set_true_boolean_value(::std::option::Option::Some(true))
             .set_false_boolean_value(::std::option::Option::Some(false))

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/empty_input_output.rs

@@ -198,198 +259,261 @@

↥ Expand context

-198
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-200
+    }
-201
+}
 #[derive(Debug)]
 struct EmptyInputOutputEndpointParamsInterceptor;
-204
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for EmptyInputOutputEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "EmptyInputOutputEndpointParamsInterceptor"
-208
+    }
-209
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,

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

↧ Expand context

-242
     /// When Input structure is empty we write CBOR equivalent of {}
     /// Test ID: empty_input
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn empty_input_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)
             .endpoint_url("https://example.com");
-253
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.empty_input_output().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Accept", "application/cbor"),
             ("Content-Type", "application/cbor"),
             ("smithy-protocol", "rpc-v2-cbor"),

Client Test

Files changed: