Client Test

[dependencies.hyper]

version = "0.14.26"

features = ["stream"]

[dependencies.tracing]

version = "0.1"

[features]

test-util = ["aws-smithy-runtime/test-util"]

rt-tokio = ["aws-smithy-async/rt-tokio", "aws-smithy-types/rt-tokio"]

behavior-version-latest = []

rustls = ["aws-smithy-runtime/tls-rustls"]

gated-tests = []

features = ["client"]

[dependencies.aws-smithy-runtime-api]

path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime-api"

features = ["client", "http-02x"]

[dependencies.aws-smithy-types]

path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-types"

[dependencies.bytes]

version = "1.4.0"

[dependencies.http]

version = "0.2.9"

[dev-dependencies.aws-smithy-protocol-test]

path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-protocol-test"

[dev-dependencies.pretty_assertions]

version = "1.3.0"

[dev-dependencies.tokio]

version = "1.23.1"

features = ["macros", "test-util", "rt-multi-thread"]

[dev-dependencies.tracing]

version = "0.1"

[dev-dependencies.tracing-test]

version = "0.2.5"

features = ["no-env-filter"]

[features]

test-util = ["aws-smithy-runtime/test-util"]

rt-tokio = ["aws-smithy-async/rt-tokio", "aws-smithy-types/rt-tokio"]

behavior-version-latest = []

rustls = ["aws-smithy-runtime/tls-rustls"]

gated-tests = []

// operationContextParams trait. They target the operation's input shape.

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

mod operation_test {

    /// Test ID: BasicQueryCompatTest

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn basic_query_compat_test_request() {

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());

        let result = client

            .operation()

            .set_message(::std::option::Option::Some("hello!".to_owned()))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

[dependencies.flate2]

version = "1.0.30"

[dependencies.http]

version = "0.2.9"

[dependencies.http-body]

version = "0.4.4"

[dependencies.md-5]

version = "0.10.0"

[dependencies.tracing]

version = "0.1"

[dev-dependencies.aws-smithy-protocol-test]

path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-protocol-test"

[dev-dependencies.aws-smithy-types]

path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-types"

[dev-dependencies.pretty_assertions]

version = "1.3.0"

[dev-dependencies.tokio]

version = "1.23.1"

features = ["macros", "test-util", "rt-multi-thread"]

[dev-dependencies.tracing-test]

version = "0.2.5"

features = ["no-env-filter"]

[features]

test-util = ["aws-smithy-runtime/test-util"]

rt-tokio = ["aws-smithy-async/rt-tokio", "aws-smithy-types/rt-tokio"]

behavior-version-latest = []

rustls = ["aws-smithy-runtime/tls-rustls"]

gated-tests = []

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

mod all_query_string_types_test {

    /// Serializes query string parameters with all supported types

    /// Test ID: RestJsonAllQueryStringTypes

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn rest_json_all_query_string_types_request() {

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());

        let result = client

            .all_query_string_types()

            .set_query_string(::std::option::Option::Some("Hello there".to_owned()))

            .set_query_string_list(::std::option::Option::Some(vec!["a".to_owned(), "b".to_owned(), "c".to_owned()]))

            .set_query_string_set(::std::option::Option::Some(vec!["a".to_owned(), "b".to_owned(), "c".to_owned()]))

            .set_query_byte(::std::option::Option::Some(1))

            .set_query_short(::std::option::Option::Some(2))

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/AllQueryStringTypesInput", "path was incorrect");

    }

    /// Handles query string maps

    /// Test ID: RestJsonQueryStringMap

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn rest_json_query_string_map_request() {

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());

        let result = client

            .all_query_string_types()

            .set_query_params_map_of_string_list(::std::option::Option::Some({

                let mut ret = ::std::collections::HashMap::new();

                ret.insert("QueryParamsStringKeyA".to_owned(), vec!["Foo".to_owned()]);

                ret.insert("QueryParamsStringKeyB".to_owned(), vec!["Bar".to_owned()]);

                ret

            }))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_query_params = &["QueryParamsStringKeyA=Foo", "QueryParamsStringKeyB=Bar"];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_query_string(&http_request, expected_query_params));

        let body = http_request.body().bytes().expect("body should be strict");

        // No body.

        ::pretty_assertions::assert_eq!(&body, &bytes::Bytes::new());

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/AllQueryStringTypesInput", "path was incorrect");

    }

    /// Handles escaping all required characters in the query string.

    /// Test ID: RestJsonQueryStringEscaping

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn rest_json_query_string_escaping_request() {

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());

        let result = client

            .all_query_string_types()

            .set_query_string(::std::option::Option::Some(" %:/?#[]@!$&'()*+,;=😹".to_owned()))

            .set_query_params_map_of_string_list(::std::option::Option::Some({

                let mut ret = ::std::collections::HashMap::new();

                ret.insert("String".to_owned(), vec![" %:/?#[]@!$&'()*+,;=😹".to_owned()]);

                ret

            }))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_query_params = &["String=%20%25%3A%2F%3F%23%5B%5D%40%21%24%26%27%28%29%2A%2B%2C%3B%3D%F0%9F%98%B9"];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_query_string(&http_request, expected_query_params));

        let body = http_request.body().bytes().expect("body should be strict");

        // No body.

        ::pretty_assertions::assert_eq!(&body, &bytes::Bytes::new());

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/AllQueryStringTypesInput", "path was incorrect");

    }

    /// Supports handling NaN float query values.

    /// Test ID: RestJsonSupportsNaNFloatQueryValues

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn rest_json_supports_na_n_float_query_values_request() {

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());

        let result = client

            .all_query_string_types()

            .set_query_float(::std::option::Option::Some(

                <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number"),

            ))

            .set_query_double(::std::option::Option::Some(

                <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number"),

            ))

            .set_query_params_map_of_string_list(::std::option::Option::Some({

                let mut ret = ::std::collections::HashMap::new();

                ret.insert("Float".to_owned(), vec!["NaN".to_owned()]);

                ret.insert("Double".to_owned(), vec!["NaN".to_owned()]);

                ret

            }))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_query_params = &["Float=NaN", "Double=NaN"];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_query_string(&http_request, expected_query_params));

        let body = http_request.body().bytes().expect("body should be strict");

        // No body.

        ::pretty_assertions::assert_eq!(&body, &bytes::Bytes::new());

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/AllQueryStringTypesInput", "path was incorrect");

    }

    /// Supports handling Infinity float query values.

    /// Test ID: RestJsonSupportsInfinityFloatQueryValues

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn rest_json_supports_infinity_float_query_values_request() {

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());

        let result = client

            .all_query_string_types()

            .set_query_float(::std::option::Option::Some(

                <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number"),

            ))

            .set_query_double(::std::option::Option::Some(

                <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number"),

            ))

            .set_query_params_map_of_string_list(::std::option::Option::Some({

                let mut ret = ::std::collections::HashMap::new();

                ret.insert("Float".to_owned(), vec!["Infinity".to_owned()]);

                ret.insert("Double".to_owned(), vec!["Infinity".to_owned()]);

                ret

            }))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_query_params = &["Float=Infinity", "Double=Infinity"];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_query_string(&http_request, expected_query_params));

        let body = http_request.body().bytes().expect("body should be strict");

        // No body.

        ::pretty_assertions::assert_eq!(&body, &bytes::Bytes::new());

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/AllQueryStringTypesInput", "path was incorrect");

    }

    /// Supports handling -Infinity float query values.

    /// Test ID: RestJsonSupportsNegativeInfinityFloatQueryValues

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn rest_json_supports_negative_infinity_float_query_values_request() {

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());

        let result = client

            .all_query_string_types()

            .set_query_float(::std::option::Option::Some(

                <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number"),

            ))

            .set_query_double(::std::option::Option::Some(

                <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number"),

            ))

            .set_query_params_map_of_string_list(::std::option::Option::Some({

                let mut ret = ::std::collections::HashMap::new();

                ret.insert("Float".to_owned(), vec!["-Infinity".to_owned()]);

                ret.insert("Double".to_owned(), vec!["-Infinity".to_owned()]);

                ret

            }))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_query_params = &["Float=-Infinity", "Double=-Infinity"];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_query_string(&http_request, expected_query_params));

        let body = http_request.body().bytes().expect("body should be strict");

        // No body.

        ::pretty_assertions::assert_eq!(&body, &bytes::Bytes::new());

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/AllQueryStringTypesInput", "path was incorrect");

    }

    /// Query values of 0 and false are serialized

    /// Test ID: RestJsonZeroAndFalseQueryValues

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn rest_json_zero_and_false_query_values_request() {

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());

        let result = client

            .all_query_string_types()

            .set_query_integer(::std::option::Option::Some(0))

            .set_query_boolean(::std::option::Option::Some(false))

            .set_query_params_map_of_string_list(::std::option::Option::Some({

                let mut ret = ::std::collections::HashMap::new();

                ret.insert("Integer".to_owned(), vec!["0".to_owned()]);

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

mod constant_and_variable_query_string_test {

    /// Mixes constant and variable query string parameters

    /// Test ID: RestJsonConstantAndVariableQueryStringMissingOneValue

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn rest_json_constant_and_variable_query_string_missing_one_value_request() {

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());

        let result = client

            .constant_and_variable_query_string()

            .set_baz(::std::option::Option::Some("bam".to_owned()))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_query_params = &["foo=bar", "baz=bam"];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_query_string(&http_request, expected_query_params));

        let forbid_params = &["maybeSet"];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::forbid_query_params(&http_request, forbid_params));

        let body = http_request.body().bytes().expect("body should be strict");

        // No body.

        ::pretty_assertions::assert_eq!(&body, &bytes::Bytes::new());

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/ConstantAndVariableQueryString", "path was incorrect");

    }

    /// Mixes constant and variable query string parameters

    /// Test ID: RestJsonConstantAndVariableQueryStringAllValues

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn rest_json_constant_and_variable_query_string_all_values_request() {

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());

        let result = client

            .constant_and_variable_query_string()

            .set_baz(::std::option::Option::Some("bam".to_owned()))

            .set_maybe_set(::std::option::Option::Some("yes".to_owned()))

            .send()

            .await;

        let _ = dbg!(result);

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

mod constant_query_string_test {

    /// Includes constant query string parameters

    /// Test ID: RestJsonConstantQueryString

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn rest_json_constant_query_string_request() {

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());

        let result = client

            .constant_query_string()

            .set_hello(::std::option::Option::Some("hi".to_owned()))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

mod document_type_test {

    /// Serializes document types as part of the JSON request payload with no escaping.

    /// Test ID: DocumentTypeInputWithObject

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn document_type_input_with_object_request() {

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());

        let result = client

            .document_type()

            .set_string_value(::std::option::Option::Some("string".to_owned()))

            .set_document_value(::std::option::Option::Some({

                let json_bytes = br#"{

                        "foo": "bar"

                    }"#;

                let mut tokens = ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();

                ::aws_smithy_json::deserialize::token::expect_document(&mut tokens).expect("well formed json")

            }))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/json")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));

        let body = http_request.body().bytes().expect("body should be strict");

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(

            body,

            "{\n    \"stringValue\": \"string\",\n    \"documentValue\": {\n        \"foo\": \"bar\"\n    }\n}",

            ::aws_smithy_protocol_test::MediaType::from("application/json"),

        ));

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/DocumentType", "path was incorrect");

    }

    /// Serializes document types using a string.

    /// Test ID: DocumentInputWithString

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn document_input_with_string_request() {

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());

        let result = client

            .document_type()

            .set_string_value(::std::option::Option::Some("string".to_owned()))

            .set_document_value(::std::option::Option::Some({

                let json_bytes = br#""hello""#;

                let mut tokens = ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();

                ::aws_smithy_json::deserialize::token::expect_document(&mut tokens).expect("well formed json")

            }))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/json")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));

        let body = http_request.body().bytes().expect("body should be strict");

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(

            body,

            "{\n    \"stringValue\": \"string\",\n    \"documentValue\": \"hello\"\n}",

            ::aws_smithy_protocol_test::MediaType::from("application/json"),

        ));

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/DocumentType", "path was incorrect");

    }

    /// Serializes document types using a number.

    /// Test ID: DocumentInputWithNumber

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn document_input_with_number_request() {

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());

        let result = client

            .document_type()

            .set_string_value(::std::option::Option::Some("string".to_owned()))

            .set_document_value(::std::option::Option::Some({

                let json_bytes = br#"10"#;

                let mut tokens = ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();

                ::aws_smithy_json::deserialize::token::expect_document(&mut tokens).expect("well formed json")

            }))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/json")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));

        let body = http_request.body().bytes().expect("body should be strict");

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(

            body,

            "{\n    \"stringValue\": \"string\",\n    \"documentValue\": 10\n}",

            ::aws_smithy_protocol_test::MediaType::from("application/json"),

        ));

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/DocumentType", "path was incorrect");

    }

    /// Serializes document types using a boolean.

    /// Test ID: DocumentInputWithBoolean

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn document_input_with_boolean_request() {

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());

        let result = client

            .document_type()

            .set_string_value(::std::option::Option::Some("string".to_owned()))

            .set_document_value(::std::option::Option::Some({

                let json_bytes = br#"true"#;

                let mut tokens = ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();

                ::aws_smithy_json::deserialize::token::expect_document(&mut tokens).expect("well formed json")

            }))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/json")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));

        let body = http_request.body().bytes().expect("body should be strict");

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(

            body,

            "{\n    \"stringValue\": \"string\",\n    \"documentValue\": true\n}",

            ::aws_smithy_protocol_test::MediaType::from("application/json"),

        ));

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/DocumentType", "path was incorrect");

    }

    /// Serializes document types using a list.

    /// Test ID: DocumentInputWithList

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn document_input_with_list_request() {

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());

        let result = client

            .document_type()

            .set_string_value(::std::option::Option::Some("string".to_owned()))

            .set_document_value(::std::option::Option::Some({

                let json_bytes = br#"[

                        true,

                        "hi",

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

mod document_type_as_map_value_test {

    /// Serializes a map that uses documents as the value.

    /// Test ID: DocumentTypeAsMapValueInput

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn document_type_as_map_value_input_request() {

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());

        let result = client

            .document_type_as_map_value()

            .set_doc_valued_map(::std::option::Option::Some({

                let mut ret = ::std::collections::HashMap::new();

                ret.insert("foo".to_owned(), {

                    let json_bytes = br#"{

                                "f": 1,

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

mod document_type_as_payload_test {

    /// Serializes a document as the target of the httpPayload trait.

    /// Test ID: DocumentTypeAsPayloadInput

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn document_type_as_payload_input_request() {

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());

        let result = client

            .document_type_as_payload()

            .set_document_value(::std::option::Option::Some({

                let json_bytes = br#"{

                        "foo": "bar"

                    }"#;

                let mut tokens = ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();

                ::aws_smithy_json::deserialize::token::expect_document(&mut tokens).expect("well formed json")

            }))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/json")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));

        let body = http_request.body().bytes().expect("body should be strict");

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(

            body,

            "{\n    \"foo\": \"bar\"\n}",

            ::aws_smithy_protocol_test::MediaType::from("application/json"),

        ));

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/DocumentTypeAsPayload", "path was incorrect");

    }

    /// Serializes a document as the target of the httpPayload trait using a string.

    /// Test ID: DocumentTypeAsPayloadInputString

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn document_type_as_payload_input_string_request() {

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());

        let result = client

            .document_type_as_payload()

            .set_document_value(::std::option::Option::Some({

                let json_bytes = br#""hello""#;

                let mut tokens = ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();

                ::aws_smithy_json::deserialize::token::expect_document(&mut tokens).expect("well formed json")

            }))

#[cfg(test)]

mod empty_input_and_empty_output_test {

    /// Clients should not serialize a JSON payload when no parameters

    /// are given that are sent in the body. A service will tolerate

    /// clients that omit a payload or that send a JSON object.

    /// Test ID: RestJsonEmptyInputAndEmptyOutput

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn rest_json_empty_input_and_empty_output_request() {

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());

        let result = client.empty_input_and_empty_output().send().await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let body = http_request.body().bytes().expect("body should be strict");

        // No body.

        ::pretty_assertions::assert_eq!(&body, &bytes::Bytes::new());

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

mod endpoint_operation_test {

    /// Operations can prepend to the given host if they define the

    /// endpoint trait.

    /// Test ID: RestJsonEndpointTrait

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn rest_json_endpoint_trait_request() {

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());

        let result = client.endpoint_operation().send().await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let body = http_request.body().bytes().expect("body should be strict");

        // No body.

        ::pretty_assertions::assert_eq!(&body, &bytes::Bytes::new());

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

#[cfg(test)]

mod endpoint_with_host_label_operation_test {

    /// Operations can prepend to the given host if they define the

    /// endpoint trait, and can use the host label trait to define

    /// further customization based on user input.

    /// Test ID: RestJsonEndpointTraitWithHostLabel

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn rest_json_endpoint_trait_with_host_label_request() {

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());

        let result = client

            .endpoint_with_host_label_operation()

            .set_label(::std::option::Option::Some("bar".to_owned()))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();