Client Test

tmp-codegen-diff/codegen-client-test/aws_query/rust-client-codegen/src/operation/query_idempotency_token_auto_fill.rs

@@ -210,210 +271,273 @@

-210
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-212
+    }
-213
+}
 #[derive(Debug)]
 struct QueryIdempotencyTokenAutoFillEndpointParamsInterceptor;
-216
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for QueryIdempotencyTokenAutoFillEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "QueryIdempotencyTokenAutoFillEndpointParamsInterceptor"
-220
+    }
-221
     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::<QueryIdempotencyTokenAutoFillInput>()
             .ok_or("failed to downcast to QueryIdempotencyTokenAutoFillInput")?;
-236
         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(())
-245
+    }
-246
+}
-247
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-250
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod query_idempotency_token_auto_fill_test {

↧ Expand context

-254
     /// Automatically adds idempotency token when not set
     /// Test ID: QueryProtocolIdempotencyTokenAutoFill
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn query_protocol_idempotency_token_auto_fill_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");
-265
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.query_idempotency_token_auto_fill().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/x-www-form-urlencoded")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let required_headers = &["Content-Length"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));

tmp-codegen-diff/codegen-client-test/aws_query/rust-client-codegen/src/operation/query_lists.rs

@@ -193,193 +254,256 @@

↥ Expand context

-193
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-195
+    }
-196
+}
 #[derive(Debug)]
 struct QueryListsEndpointParamsInterceptor;
-199
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for QueryListsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "QueryListsEndpointParamsInterceptor"
-203
+    }
-204
     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::<QueryListsInput>()
             .ok_or("failed to downcast to QueryListsInput")?;
-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(())
-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 query_lists_test {

↧ Expand context

-237
     /// Serializes query lists
     /// Test ID: QueryLists
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn query_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)
             .endpoint_url("https://example.com");
-248
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .query_lists()
             .set_list_arg(::std::option::Option::Some(vec!["foo".to_owned(), "bar".to_owned(), "baz".to_owned()]))
             .set_complex_list_arg(::std::option::Option::Some(vec![
                 crate::types::GreetingStruct::builder()
                     .set_hi(::std::option::Option::Some("hello".to_owned()))
                     .build(),

tmp-codegen-diff/codegen-client-test/aws_query/rust-client-codegen/src/operation/query_maps.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 QueryMapsEndpointParamsInterceptor;
-198
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for QueryMapsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "QueryMapsEndpointParamsInterceptor"
-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::<QueryMapsInput>()
             .ok_or("failed to downcast to QueryMapsInput")?;
-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 query_maps_test {

↧ Expand context

-236
     /// Serializes query maps
     /// Test ID: QuerySimpleQueryMaps
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn query_simple_query_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");
-247
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .query_maps()
             .set_map_arg(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("bar".to_owned(), "Bar".to_owned());
                 ret.insert("foo".to_owned(), "Foo".to_owned());
                 ret

tmp-codegen-diff/codegen-client-test/aws_query/rust-client-codegen/src/operation/query_timestamps.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 QueryTimestampsEndpointParamsInterceptor;
-202
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for QueryTimestampsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "QueryTimestampsEndpointParamsInterceptor"
-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::<QueryTimestampsInput>()
             .ok_or("failed to downcast to QueryTimestampsInput")?;
-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 query_timestamps_test {

↧ Expand context

-240
     /// Serializes timestamps
     /// Test ID: QueryTimestampsInput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn query_timestamps_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");
-251
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .query_timestamps()
             .set_normal_format(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1422172800, 0_f64,
             )))
             .set_epoch_member(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1422172800, 0_f64,

tmp-codegen-diff/codegen-client-test/aws_query/rust-client-codegen/src/operation/recursive_xml_shapes.rs

@@ -193,193 +254,256 @@

↥ Expand context

-193
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-195
+    }
-196
+}
 #[derive(Debug)]
 struct RecursiveXmlShapesEndpointParamsInterceptor;
-199
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for RecursiveXmlShapesEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "RecursiveXmlShapesEndpointParamsInterceptor"
-203
+    }
-204
     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::<RecursiveXmlShapesInput>()
             .ok_or("failed to downcast to RecursiveXmlShapesInput")?;
-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(())
-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 recursive_xml_shapes_test {

↧ Expand context

-237
     /// Serializes recursive structures
     /// Test ID: QueryRecursiveShapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn query_recursive_shapes_response() {
         let expected_output = crate::operation::recursive_xml_shapes::RecursiveXmlShapesOutput::builder()
             .set_nested(::std::option::Option::Some(
                 crate::types::RecursiveXmlShapesOutputNested1::builder()
                     .set_foo(::std::option::Option::Some("Foo1".to_owned()))
                     .set_nested(::std::option::Option::Some(::std::boxed::Box::new(
                         crate::types::RecursiveXmlShapesOutputNested2::builder()
                             .set_bar(::std::option::Option::Some("Bar1".to_owned()))
                             .set_recursive_member(::std::option::Option::Some(
                                 crate::types::RecursiveXmlShapesOutputNested1::builder()
                                     .set_foo(::std::option::Option::Some("Foo2".to_owned()))
                                     .set_nested(::std::option::Option::Some(::std::boxed::Box::new(
                                         crate::types::RecursiveXmlShapesOutputNested2::builder()
                                             .set_bar(::std::option::Option::Some("Bar2".to_owned()))
                                             .build(),

tmp-codegen-diff/codegen-client-test/aws_query/rust-client-codegen/src/operation/simple_input_params.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 SimpleInputParamsEndpointParamsInterceptor;
-202
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for SimpleInputParamsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "SimpleInputParamsEndpointParamsInterceptor"
-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::<SimpleInputParamsInput>()
             .ok_or("failed to downcast to SimpleInputParamsInput")?;
-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 simple_input_params_test {

↧ Expand context

-240
     /// Serializes strings
     /// Test ID: QuerySimpleInputParamsStrings
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn query_simple_input_params_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)
             .endpoint_url("https://example.com");
-251
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .simple_input_params()
             .set_foo(::std::option::Option::Some("val1".to_owned()))
             .set_bar(::std::option::Option::Some("val2".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);

tmp-codegen-diff/codegen-client-test/aws_query/rust-client-codegen/src/operation/simple_scalar_xml_properties.rs

@@ -199,199 +260,262 @@

↥ Expand context

-199
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-201
+    }
-202
+}
 #[derive(Debug)]
 struct SimpleScalarXmlPropertiesEndpointParamsInterceptor;
-205
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for SimpleScalarXmlPropertiesEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "SimpleScalarXmlPropertiesEndpointParamsInterceptor"
-209
+    }
-210
     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::<SimpleScalarXmlPropertiesInput>()
             .ok_or("failed to downcast to SimpleScalarXmlPropertiesInput")?;
-225
         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 simple_scalar_xml_properties_test {

↧ Expand context

     use ::aws_smithy_protocol_test::FloatEquals;
-244
     /// Serializes simple scalar properties
     /// Test ID: QuerySimpleScalarProperties
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn query_simple_scalar_properties_response() {
         let expected_output = crate::operation::simple_scalar_xml_properties::SimpleScalarXmlPropertiesOutput::builder()
             .set_string_value(::std::option::Option::Some("string".to_owned()))
             .set_empty_string_value(::std::option::Option::Some("".to_owned()))
             .set_true_boolean_value(::std::option::Option::Some(true))
             .set_false_boolean_value(::std::option::Option::Some(false))
             .set_byte_value(::std::option::Option::Some(1))
             .set_short_value(::std::option::Option::Some(2))
             .set_integer_value(::std::option::Option::Some(3))
             .set_long_value(::std::option::Option::Some(4))
             .set_float_value(::std::option::Option::Some(5.5_f32))
             .set_double_value(::std::option::Option::Some(6.5_f64))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()

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

@@ -185,185 +246,248 @@

↥ Expand context

-185
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-187
+    }
-188
+}
 #[derive(Debug)]
 struct XmlBlobsEndpointParamsInterceptor;
-191
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for XmlBlobsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "XmlBlobsEndpointParamsInterceptor"
-195
+    }
-196
     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::<XmlBlobsInput>()
             .ok_or("failed to downcast to XmlBlobsInput")?;
-211
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-220
+    }
-221
+}
-222
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-225
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod xml_blobs_test {

↧ Expand context

-229
     /// Blobs are base64 encoded
     /// Test ID: QueryXmlBlobs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn query_xml_blobs_response() {
         let expected_output = crate::operation::xml_blobs::XmlBlobsOutput::builder()
             .set_data(::std::option::Option::Some(::aws_smithy_types::Blob::new("value")))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "text/xml")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlBlobsResponse xmlns=\"https://example.com/\">\n    <XmlBlobsResult>\n        <data>dmFsdWU=</data>\n    </XmlBlobsResult>\n</XmlBlobsResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-246
         let op = crate::operation::xml_blobs::XmlBlobs::new();
         let config = op.config().expect("the operation has config");

tmp-codegen-diff/codegen-client-test/aws_query/rust-client-codegen/src/operation/xml_empty_blobs.rs

@@ -193,193 +254,256 @@

↥ Expand context

-193
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-195
+    }
-196
+}
 #[derive(Debug)]
 struct XmlEmptyBlobsEndpointParamsInterceptor;
-199
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for XmlEmptyBlobsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "XmlEmptyBlobsEndpointParamsInterceptor"
-203
+    }
-204
     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::<XmlEmptyBlobsInput>()
             .ok_or("failed to downcast to XmlEmptyBlobsInput")?;
-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(())
-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_blobs_test {

↧ Expand context

-237
     /// Empty blobs are deserialized as empty string
     /// Test ID: QueryXmlEmptyBlobs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn query_xml_empty_blobs_response() {
         let expected_output = crate::operation::xml_empty_blobs::XmlEmptyBlobsOutput::builder()
             .set_data(::std::option::Option::Some(::aws_smithy_types::Blob::new("")))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "text/xml")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlEmptyBlobsResponse xmlns=\"https://example.com/\">\n    <XmlEmptyBlobsResult>\n        <data></data>\n    </XmlEmptyBlobsResult>\n</XmlEmptyBlobsResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-254
         let op = crate::operation::xml_empty_blobs::XmlEmptyBlobs::new();
         let config = op.config().expect("the operation has config");

tmp-codegen-diff/codegen-client-test/aws_query/rust-client-codegen/src/operation/xml_empty_lists.rs

@@ -193,193 +254,256 @@

↥ Expand context

-193
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-195
+    }
-196
+}
 #[derive(Debug)]
 struct XmlEmptyListsEndpointParamsInterceptor;
-199
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for XmlEmptyListsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "XmlEmptyListsEndpointParamsInterceptor"
-203
+    }
-204
     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::<XmlEmptyListsInput>()
             .ok_or("failed to downcast to XmlEmptyListsInput")?;
-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(())
-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 {

↧ Expand context

-237
     /// Deserializes empty XML lists
     /// Test ID: QueryXmlEmptyLists
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn query_xml_empty_lists_response() {
         let expected_output = crate::operation::xml_empty_lists::XmlEmptyListsOutput::builder()
             .set_string_list(::std::option::Option::Some(vec![]))
             .set_string_set(::std::option::Option::Some(vec![]))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "text/xml")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlEmptyListsResponse xmlns=\"https://example.com/\">\n    <XmlEmptyListsResult>\n        <stringList/>\n        <stringSet></stringSet>\n    </XmlEmptyListsResult>\n</XmlEmptyListsResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-255
         let op = crate::operation::xml_empty_lists::XmlEmptyLists::new();

tmp-codegen-diff/codegen-client-test/aws_query/rust-client-codegen/src/operation/xml_empty_maps.rs

@@ -193,193 +254,256 @@

↥ Expand context

-193
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-195
+    }
-196
+}
 #[derive(Debug)]
 struct XmlEmptyMapsEndpointParamsInterceptor;
-199
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for XmlEmptyMapsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "XmlEmptyMapsEndpointParamsInterceptor"
-203
+    }
-204
     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::<XmlEmptyMapsInput>()
             .ok_or("failed to downcast to XmlEmptyMapsInput")?;
-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(())
-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 {

↧ Expand context

-237
     /// Deserializes Empty XML maps
     /// Test ID: QueryXmlEmptyMaps
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn query_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()))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "text/xml")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlEmptyMapsResponse xmlns=\"https://example.com/\">\n    <XmlEmptyMapsResult>\n        <myMap>\n        </myMap>\n    </XmlEmptyMapsResult>\n</XmlEmptyMapsResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-254
         let op = crate::operation::xml_empty_maps::XmlEmptyMaps::new();
         let config = op.config().expect("the operation has config");

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

@@ -185,185 +246,248 @@

↥ Expand context

-185
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-187
+    }
-188
+}
 #[derive(Debug)]
 struct XmlEnumsEndpointParamsInterceptor;
-191
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for XmlEnumsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "XmlEnumsEndpointParamsInterceptor"
-195
+    }
-196
     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::<XmlEnumsInput>()
             .ok_or("failed to downcast to XmlEnumsInput")?;
-211
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-220
+    }
-221
+}
-222
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-225
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod xml_enums_test {

↧ Expand context

-229
     /// Serializes simple scalar properties
     /// Test ID: QueryXmlEnums
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn query_xml_enums_response() {
         let expected_output = crate::operation::xml_enums::XmlEnumsOutput::builder()
             .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"),
             ))
             .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"),
             ]))

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

@@ -193,193 +254,256 @@

↥ Expand context

-193
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-195
+    }
-196
+}
 #[derive(Debug)]
 struct XmlIntEnumsEndpointParamsInterceptor;
-199
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for XmlIntEnumsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "XmlIntEnumsEndpointParamsInterceptor"
-203
+    }
-204
     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::<XmlIntEnumsInput>()
             .ok_or("failed to downcast to XmlIntEnumsInput")?;
-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(())
-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 {

↧ Expand context

-237
     /// Serializes simple scalar properties
     /// Test ID: QueryXmlIntEnums
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn query_xml_int_enums_response() {
         let expected_output = crate::operation::xml_int_enums::XmlIntEnumsOutput::builder()
             .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]))
             .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
             }))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()

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

@@ -185,185 +246,248 @@

↥ Expand context

-185
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-187
+    }
-188
+}
 #[derive(Debug)]
 struct XmlListsEndpointParamsInterceptor;
-191
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for XmlListsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "XmlListsEndpointParamsInterceptor"
-195
+    }
-196
     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::<XmlListsInput>()
             .ok_or("failed to downcast to XmlListsInput")?;
-211
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-220
+    }
-221
+}
-222
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-225
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod xml_lists_test {

↧ Expand context

-229
     /// Tests for XML list serialization
     /// Test ID: QueryXmlLists
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn query_xml_lists_response() {
         let expected_output = crate::operation::xml_lists::XmlListsOutput::builder()
             .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![
                 ::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]))

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

@@ -182,182 +243,245 @@

↥ Expand context

-182
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-184
+    }
-185
+}
 #[derive(Debug)]
 struct XmlMapsEndpointParamsInterceptor;
-188
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for XmlMapsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "XmlMapsEndpointParamsInterceptor"
-192
+    }
-193
     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")?;
-208
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-217
+    }
-218
+}
-219
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-222
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod xml_maps_test {

↧ Expand context

-226
     /// Tests for XML map serialization
     /// Test ID: QueryXmlMaps
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn query_xml_maps_response() {
         let expected_output = crate::operation::xml_maps::XmlMapsOutput::builder()
             .set_my_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "foo".to_owned(),
                     crate::types::GreetingStruct::builder()
                         .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(),

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

@@ -193,193 +254,256 @@

↥ Expand context

-193
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-195
+    }
-196
+}
 #[derive(Debug)]
 struct XmlMapsXmlNameEndpointParamsInterceptor;
-199
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for XmlMapsXmlNameEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "XmlMapsXmlNameEndpointParamsInterceptor"
-203
+    }
-204
     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")?;
-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(())
-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 {

↧ Expand context

-237
     /// Serializes XML lists
     /// Test ID: QueryQueryXmlMapsXmlName
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn query_query_xml_maps_xml_name_response() {
         let expected_output = crate::operation::xml_maps_xml_name::XmlMapsXmlNameOutput::builder()
             .set_my_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "foo".to_owned(),
                     crate::types::GreetingStruct::builder()
                         .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(),

Client Test

Files changed: