Server Test

[dependencies.bytes]

version = "1.4.0"

#[cfg(test)]

#[allow(unreachable_code, unused_variables)]

mod server_case_insensitive_error_operation_test {

    /// Upper case error modeled lower case.

    /// Test ID: ServiceLevelErrorServer

    #[::tokio::test]

    async fn service_level_error_server_response() {

        let output = crate::error::ExtraError {};

        let output = crate::error::CaseInsensitiveErrorOperationError::ExtraError(output);

        use ::aws_smithy_http_server::response::IntoResponse;

        let http_response = output.into_response();

        ::pretty_assertions::assert_eq!(

            http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),

            http_response.status()

        );

        let expected_headers = [("X-Amzn-Errortype", "ExtraError")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(

            http_response.headers(),

            expected_headers,

        ));

        let body = ::hyper::body::to_bytes(http_response.into_body())

            .await

            .expect("unable to extract body to bytes");

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

            &body,

            "{}",

            ::aws_smithy_protocol_test::MediaType::from("unknown"),

        ));

    }

}

#[cfg(test)]

#[allow(unreachable_code, unused_variables)]

mod server_empty_struct_with_content_on_wire_op_test {

    /// Upper case error modeled lower case.

    /// Test ID: ServiceLevelErrorServer

    #[::tokio::test]

    async fn service_level_error_server_response() {

        let output = crate::error::ExtraError {};

        let output = crate::error::EmptyStructWithContentOnWireOpError::ExtraError(output);

        use ::aws_smithy_http_server::response::IntoResponse;

        let http_response = output.into_response();

        ::pretty_assertions::assert_eq!(

            http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),

            http_response.status()

        );

        let expected_headers = [("X-Amzn-Errortype", "ExtraError")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(

            http_response.headers(),

            expected_headers,

        ));

        let body = ::hyper::body::to_bytes(http_response.into_body())

            .await

            .expect("unable to extract body to bytes");

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

            &body,

            "{}",

            ::aws_smithy_protocol_test::MediaType::from("unknown"),

        ));

#[cfg(test)]

#[allow(unreachable_code, unused_variables)]

mod server_enum_query_test {

    /// Test ID: EnumQueryRequest

    #[::tokio::test]

    async fn enum_query_request_request() {

        #[allow(unused_mut)]

        let mut http_request = http::Request::builder()

            .uri("/foo/enumvalue")

            .method("GET")

            .body(::aws_smithy_http_server::body::Body::empty())

            .unwrap();

        #[allow(unused_mut)]

        let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);

        let config = crate::service::RestJsonExtrasConfig::builder().build();

        let service =

            crate::service::RestJsonExtras::builder::<::hyper::body::Body, _, _, _>(config)

                .enum_query(move |input: crate::input::EnumQueryInput| {

                    let sender = sender.clone();

                    async move {

                        let result = {

                            let expected = crate::input::EnumQueryInput {

                                r#enum: "enumvalue"

                                    .parse::<crate::model::StringEnum>()

                                    .expect("static value validated to member"),

                            };

                            ::pretty_assertions::assert_eq!(input, expected);

                            let response = crate::output::EnumQueryOutput {};

                            Ok(response)

                        };

                        sender.send(()).await.expect("receiver dropped early");

                        result

                    }

                })

                .build_unchecked();

        let http_response = ::tower::ServiceExt::oneshot(service, http_request)

            .await

            .expect("unable to make an HTTP request");

        assert!(receiver.recv().await.is_some());

    }

    /// Upper case error modeled lower case.

    /// Test ID: ServiceLevelErrorServer

    #[::tokio::test]

    async fn service_level_error_server_response() {

        let output = crate::error::ExtraError {};

        let output = crate::error::EnumQueryError::ExtraError(output);

        use ::aws_smithy_http_server::response::IntoResponse;

        let http_response = output.into_response();

        ::pretty_assertions::assert_eq!(

            http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),

            http_response.status()

        );

        let expected_headers = [("X-Amzn-Errortype", "ExtraError")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(

            http_response.headers(),

            expected_headers,

        ));

        let body = ::hyper::body::to_bytes(http_response.into_body())

            .await

            .expect("unable to extract body to bytes");

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

            &body,

            "{}",

            ::aws_smithy_protocol_test::MediaType::from("unknown"),

        ));

#[cfg(test)]

#[allow(unreachable_code, unused_variables)]

mod server_escaped_string_values_test {

    /// Test ID: EscapedStringValuesRequest

    #[::tokio::test]

    async fn escaped_string_values_request_request() {

        #[allow(unused_mut)]

        let mut http_request = http::Request::builder()

            .uri("/escaped-string-values")

            .method("POST")

            .header("Content-Type", "application/json")

            .body(::aws_smithy_http_server::body::Body::from(

                ::bytes::Bytes::from_static(

                    "{\"enum\":\"has\\\"quotes\",\"also\\\"has\\\"quotes\":\"test\"}".as_bytes(),

                ),

            ))

            .unwrap();

        #[allow(unused_mut)]

        let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);

        let config = crate::service::RestJsonExtrasConfig::builder().build();

        let service =

            crate::service::RestJsonExtras::builder::<::hyper::body::Body, _, _, _>(config)

                .escaped_string_values(move |input: crate::input::EscapedStringValuesInput| {

                    let sender = sender.clone();

                    async move {

                        let result = {

                            let expected = crate::input::EscapedStringValuesInput {

                                r#enum: ::std::option::Option::Some(

                                    "has\"quotes"

                                        .parse::<crate::model::EnumWithEscapedChars>()

                                        .expect("static value validated to member"),

                                ),

                                some_string: ::std::option::Option::Some("test".to_owned()),

                            };

                            ::pretty_assertions::assert_eq!(input, expected);

                            let response = crate::output::EscapedStringValuesOutput {

                                r#enum: ::std::option::Option::None,

                                some_string: ::std::option::Option::None,

                            };

                            Ok(response)

                        };

                        sender.send(()).await.expect("receiver dropped early");

                        result

                })

                .build_unchecked();

        let http_response = ::tower::ServiceExt::oneshot(service, http_request)

            .expect("unable to make an HTTP request");

        assert!(receiver.recv().await.is_some());

    }

    /// Test ID: EscapedStringValuesResponse

    #[::tokio::test]

    async fn escaped_string_values_response_response() {

        let output = crate::output::EscapedStringValuesOutput {

            r#enum: ::std::option::Option::Some(

                "has\"quotes"

                    .parse::<crate::model::EnumWithEscapedChars>()

                    .expect("static value validated to member"),

            ),

            some_string: ::std::option::Option::Some("test".to_owned()),

        use ::aws_smithy_http_server::response::IntoResponse;

        let http_response = output.into_response();

        ::pretty_assertions::assert_eq!(

            http::StatusCode::from_u16(200).expect("invalid expected HTTP status code"),

            http_response.status()

        );

        let body = ::hyper::body::to_bytes(http_response.into_body())

            .await

            .expect("unable to extract body to bytes");

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

            &body,

            "{\"enum\":\"has\\\"quotes\",\"also\\\"has\\\"quotes\":\"test\"}",

            ::aws_smithy_protocol_test::MediaType::from("unknown"),

        ));

    }

    /// Upper case error modeled lower case.

    /// Test ID: ServiceLevelErrorServer

    #[::tokio::test]

    async fn service_level_error_server_response() {

        let output = crate::error::ExtraError {};

        let output = crate::error::EscapedStringValuesError::ExtraError(output);

        use ::aws_smithy_http_server::response::IntoResponse;

        let http_response = output.into_response();

        ::pretty_assertions::assert_eq!(

            http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),

            http_response.status()

        );

        let expected_headers = [("X-Amzn-Errortype", "ExtraError")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(

            http_response.headers(),

            expected_headers,

        ));

        let body = ::hyper::body::to_bytes(http_response.into_body())

            .await

            .expect("unable to extract body to bytes");

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

            &body,

            "{}",

            ::aws_smithy_protocol_test::MediaType::from("unknown"),

        ));

    }

}

#[cfg(test)]

#[allow(unreachable_code, unused_variables)]

mod server_http_enum_payload2_test {

    /// Test ID: RestJsonEnumPayloadRequest2

    #[::tokio::test]

    async fn rest_json_enum_payload_request2_request() {

        #[allow(unused_mut)]

        let mut http_request = http::Request::builder()

            .uri("/EnumPayload2")

            .method("POST")

            .header("Content-Type", "text/plain")

            .body(::aws_smithy_http_server::body::Body::from(

                ::bytes::Bytes::from_static("enumvalue".as_bytes()),

            ))

            .unwrap();

        #[allow(unused_mut)]

        let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);

        let config = crate::service::RestJsonExtrasConfig::builder().build();

        let service =

            crate::service::RestJsonExtras::builder::<::hyper::body::Body, _, _, _>(config)

                .http_enum_payload2(move |input: crate::input::HttpEnumPayload2Input| {

                    let sender = sender.clone();

                    async move {

                        let result = {

                            let expected = crate::input::HttpEnumPayload2Input {

                                payload: ::std::option::Option::Some(

                                    "enumvalue"

                                        .parse::<crate::model::StringEnum>()

                                        .expect("static value validated to member"),

                                ),

                            };

                            ::pretty_assertions::assert_eq!(input, expected);

                            let response = crate::output::HttpEnumPayload2Output {

                                payload: ::std::option::Option::None,

                            };

                            Ok(response)

                        };

                        sender.send(()).await.expect("receiver dropped early");

                        result

                    }

                })

                .build_unchecked();

        let http_response = ::tower::ServiceExt::oneshot(service, http_request)

            .await

            .expect("unable to make an HTTP request");

        assert!(receiver.recv().await.is_some());

    }

    /// Test ID: RestJsonEnumPayloadResponse2

    #[::tokio::test]

    async fn rest_json_enum_payload_response2_response() {

        let output = crate::output::HttpEnumPayload2Output {

            payload: ::std::option::Option::Some(

                "enumvalue"

                    .parse::<crate::model::StringEnum>()

                    .expect("static value validated to member"),

            ),

        };

        use ::aws_smithy_http_server::response::IntoResponse;

        let http_response = output.into_response();

        ::pretty_assertions::assert_eq!(

            http::StatusCode::from_u16(200).expect("invalid expected HTTP status code"),

            http_response.status()

        );

        let expected_headers = [("Content-Type", "text/plain")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(

            http_response.headers(),

            expected_headers,

        ));

        let body = ::hyper::body::to_bytes(http_response.into_body())

            .await

            .expect("unable to extract body to bytes");

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

            &body,

            "enumvalue",

            ::aws_smithy_protocol_test::MediaType::from("unknown"),

        ));

    }

    /// Upper case error modeled lower case.

    /// Test ID: ServiceLevelErrorServer

    #[::tokio::test]

    async fn service_level_error_server_response() {

        let output = crate::error::ExtraError {};

        let output = crate::error::HttpEnumPayload2Error::ExtraError(output);

        use ::aws_smithy_http_server::response::IntoResponse;

        let http_response = output.into_response();

        ::pretty_assertions::assert_eq!(

            http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),

            http_response.status()

        );

        let expected_headers = [("X-Amzn-Errortype", "ExtraError")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(

            http_response.headers(),

            expected_headers,

        ));

        let body = ::hyper::body::to_bytes(http_response.into_body())

            .await

            .expect("unable to extract body to bytes");

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

            &body,

            "{}",

            ::aws_smithy_protocol_test::MediaType::from("unknown"),

        ));

    }

}

#[cfg(test)]

#[allow(unreachable_code, unused_variables)]

mod server_http_payload_traits2_test {

    /// Servers must accept no content type for blob inputs

    /// without the media type trait.

    /// Test ID: RestJsonHttpPayloadTraitsWithBlobAcceptsNoContentType

    #[::tokio::test]

    async fn rest_json_http_payload_traits_with_blob_accepts_no_content_type_request() {

        #[allow(unused_mut)]

        let mut http_request = http::Request::builder()

            .uri("/HttpPayloadTraits")

            .method("POST")

            .header("X-Foo", "Foo")

            .body(::aws_smithy_http_server::body::Body::from(

                ::bytes::Bytes::from_static("This is definitely a jpeg".as_bytes()),

            ))

            .unwrap();

        #[allow(unused_mut)]

        let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);

        let config = crate::service::RestJsonExtrasConfig::builder().build();

        let service =

            crate::service::RestJsonExtras::builder::<::hyper::body::Body, _, _, _>(config)

                .http_payload_traits2(move |input: crate::input::HttpPayloadTraits2Input| {

                    let sender = sender.clone();

                    async move {

                        let result = {

                            let expected = crate::input::HttpPayloadTraits2Input {

                                foo: ::std::option::Option::Some("Foo".to_owned()),

                                blob: ::std::option::Option::Some(::aws_smithy_types::Blob::new(

                                    "This is definitely a jpeg",

                                )),

                            };

                            ::pretty_assertions::assert_eq!(input, expected);

                            let response = crate::output::HttpPayloadTraits2Output {

                                foo: ::std::option::Option::None,

                                blob: ::std::option::Option::None,

                            };

                            Ok(response)

                        };

                        sender.send(()).await.expect("receiver dropped early");

                        result

                    }

                })

                .build_unchecked();

        let http_response = ::tower::ServiceExt::oneshot(service, http_request)

            .await

            .expect("unable to make an HTTP request");

        assert!(receiver.recv().await.is_some());

    }

    /// Upper case error modeled lower case.

    /// Test ID: ServiceLevelErrorServer

    #[::tokio::test]

    async fn service_level_error_server_response() {

        let output = crate::error::ExtraError {};

        let output = crate::error::HttpPayloadTraits2Error::ExtraError(output);

        use ::aws_smithy_http_server::response::IntoResponse;

        let http_response = output.into_response();

        ::pretty_assertions::assert_eq!(

            http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),

            http_response.status()

        );

        let expected_headers = [("X-Amzn-Errortype", "ExtraError")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(

            http_response.headers(),

            expected_headers,

        ));

        let body = ::hyper::body::to_bytes(http_response.into_body())

            .await

            .expect("unable to extract body to bytes");

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

            &body,

            "{}",

            ::aws_smithy_protocol_test::MediaType::from("unknown"),

        ));

    }

}

#[cfg(test)]

#[allow(unreachable_code, unused_variables)]

mod server_http_string_payload2_test {

    /// Test ID: RestJsonStringPayloadRequest2

    #[::tokio::test]

    async fn rest_json_string_payload_request2_request() {

        #[allow(unused_mut)]

        let mut http_request = http::Request::builder()

            .uri("/StringPayload2")

            .method("POST")

            .header("Content-Type", "text/plain")

            .body(::aws_smithy_http_server::body::Body::from(

                ::bytes::Bytes::from_static("rawstring".as_bytes()),

            ))

            .unwrap();

        #[allow(unused_mut)]

        let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);

        let config = crate::service::RestJsonExtrasConfig::builder().build();

        let service =

            crate::service::RestJsonExtras::builder::<::hyper::body::Body, _, _, _>(config)

                .http_string_payload2(move |input: crate::input::HttpStringPayload2Input| {

                    let sender = sender.clone();

                    async move {

                        let result = {

                            let expected = crate::input::HttpStringPayload2Input {

                                payload: ::std::option::Option::Some("rawstring".to_owned()),

                            };

                            ::pretty_assertions::assert_eq!(input, expected);

                            let response = crate::output::HttpStringPayload2Output {

                                payload: ::std::option::Option::None,

                            };

                            Ok(response)

                        };

                        sender.send(()).await.expect("receiver dropped early");

                        result

                    }

                })

                .build_unchecked();

        let http_response = ::tower::ServiceExt::oneshot(service, http_request)

            .await

            .expect("unable to make an HTTP request");

        assert!(receiver.recv().await.is_some());

    }

    /// Test ID: RestJsonStringPayloadResponse2

    #[::tokio::test]

    async fn rest_json_string_payload_response2_response() {

        let output = crate::output::HttpStringPayload2Output {

            payload: ::std::option::Option::Some("rawstring".to_owned()),

        };

        use ::aws_smithy_http_server::response::IntoResponse;

        let http_response = output.into_response();

        ::pretty_assertions::assert_eq!(

            http::StatusCode::from_u16(200).expect("invalid expected HTTP status code"),

            http_response.status()

        );

        let expected_headers = [("Content-Type", "text/plain")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(

            http_response.headers(),

            expected_headers,

        ));

        let body = ::hyper::body::to_bytes(http_response.into_body())

            .await

            .expect("unable to extract body to bytes");

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

            &body,

            "rawstring",

            ::aws_smithy_protocol_test::MediaType::from("text/plain"),

        ));

    }

    /// Upper case error modeled lower case.

    /// Test ID: ServiceLevelErrorServer

    #[::tokio::test]

    async fn service_level_error_server_response() {

        let output = crate::error::ExtraError {};

        let output = crate::error::HttpStringPayload2Error::ExtraError(output);

        use ::aws_smithy_http_server::response::IntoResponse;

        let http_response = output.into_response();

        ::pretty_assertions::assert_eq!(

            http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),

            http_response.status()

        );

        let expected_headers = [("X-Amzn-Errortype", "ExtraError")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(

            http_response.headers(),

            expected_headers,

        ));

        let body = ::hyper::body::to_bytes(http_response.into_body())

            .await

            .expect("unable to extract body to bytes");

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

            &body,

            "{}",

            ::aws_smithy_protocol_test::MediaType::from("unknown"),

        ));

    }

    /// Serializes a string in the HTTP payload without a content-type header

    /// Test ID: RestJsonStringPayloadNoContentType2

    #[::tokio::test]

    async fn rest_json_string_payload_no_content_type2_malformed_request() {

        {

            #[allow(unused_mut)]

            let mut http_request = http::Request::builder()

                .uri("/StringPayload2")

                .method("POST")

                .body(::aws_smithy_http_server::body::Body::from(

                    ::bytes::Bytes::from_static("rawstring".as_bytes()),

                ))

                .unwrap();

            #[allow(unused_mut)]

            let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);

            let config = crate::service::RestJsonExtrasConfig::builder().build();

            let service = crate::service::RestJsonExtras::builder::<::hyper::body::Body, _, _, _>(config)

                            .http_string_payload2(move |input: crate::input::HttpStringPayload2Input| {

                                let sender = sender.clone();

                                async move {

                                    let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::HttpStringPayload2Output, crate::error::HttpStringPayload2Error> };

                                    sender.send(()).await.expect("receiver dropped early");

                                    result

                                }

                            })

                            .build_unchecked();

            let http_response = ::tower::ServiceExt::oneshot(service, http_request)

                .await

                .expect("unable to make an HTTP request");

            ::pretty_assertions::assert_eq!(

                http::StatusCode::from_u16(415).expect("invalid expected HTTP status code"),

                http_response.status()

            );

            let expected_headers = [("x-amzn-errortype", "UnsupportedMediaTypeException")];

            ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(

                http_response.headers(),

                expected_headers,

            ));

        }

    }

    /// Serializes a string in the HTTP payload without the expected content-type header

    /// Test ID: RestJsonStringPayloadWrongContentType2

    #[::tokio::test]

    async fn rest_json_string_payload_wrong_content_type2_malformed_request() {

        {

            #[allow(unused_mut)]

            let mut http_request = http::Request::builder()

                .uri("/StringPayload2")

                .method("POST")

                .header("Content-Type", "application/json")

                .body(::aws_smithy_http_server::body::Body::from(

                    ::bytes::Bytes::from_static("rawstring".as_bytes()),

                ))

                .unwrap();

            #[allow(unused_mut)]

            let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);

            let config = crate::service::RestJsonExtrasConfig::builder().build();

            let service = crate::service::RestJsonExtras::builder::<::hyper::body::Body, _, _, _>(config)

                            .http_string_payload2(move |input: crate::input::HttpStringPayload2Input| {

                                let sender = sender.clone();

                                async move {

                                    let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::HttpStringPayload2Output, crate::error::HttpStringPayload2Error> };

                                    sender.send(()).await.expect("receiver dropped early");

                                    result

                                }

                            })

                            .build_unchecked();

            let http_response = ::tower::ServiceExt::oneshot(service, http_request)

                .await

                .expect("unable to make an HTTP request");

            ::pretty_assertions::assert_eq!(

                http::StatusCode::from_u16(415).expect("invalid expected HTTP status code"),

                http_response.status()

            );

            let expected_headers = [("x-amzn-errortype", "UnsupportedMediaTypeException")];

            ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(

                http_response.headers(),

                expected_headers,

            ));

        }

    }

    /// Serializes a string in the HTTP payload with an unstatisfiable accept header

    /// Test ID: RestJsonStringPayloadUnsatisfiableAccept2

    #[::tokio::test]

    async fn rest_json_string_payload_unsatisfiable_accept2_malformed_request() {

        {

            #[allow(unused_mut)]

            let mut http_request = http::Request::builder()

                .uri("/StringPayload2")

                .method("POST")

                .header("Accept", "application/json")

                .header("Content-Type", "text/plain")

                .body(::aws_smithy_http_server::body::Body::from(

                    ::bytes::Bytes::from_static("rawstring".as_bytes()),

                ))

                .unwrap();

            #[allow(unused_mut)]

            let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);

            let config = crate::service::RestJsonExtrasConfig::builder().build();

            let service = crate::service::RestJsonExtras::builder::<::hyper::body::Body, _, _, _>(config)

                            .http_string_payload2(move |input: crate::input::HttpStringPayload2Input| {

                                let sender = sender.clone();

                                async move {

                                    let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::HttpStringPayload2Output, crate::error::HttpStringPayload2Error> };

                                    sender.send(()).await.expect("receiver dropped early");

                                    result

                                }

                            })

                            .build_unchecked();

            let http_response = ::tower::ServiceExt::oneshot(service, http_request)

                .await

                .expect("unable to make an HTTP request");

            ::pretty_assertions::assert_eq!(

                http::StatusCode::from_u16(406).expect("invalid expected HTTP status code"),

                http_response.status()

            );

            let expected_headers = [("x-amzn-errortype", "NotAcceptableException")];

            ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(

                http_response.headers(),

                expected_headers,

            ));

        }

    }

}

#[cfg(test)]

#[allow(unreachable_code, unused_variables)]

mod server_malformed_content_type_with_body2_test {

    /// Upper case error modeled lower case.

    /// Test ID: ServiceLevelErrorServer

    #[::tokio::test]

    async fn service_level_error_server_response() {

        let output = crate::error::ExtraError {};

        let output = crate::error::MalformedContentTypeWithBody2Error::ExtraError(output);

        use ::aws_smithy_http_server::response::IntoResponse;

        let http_response = output.into_response();

        ::pretty_assertions::assert_eq!(

            http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),

            http_response.status()

        );

        let expected_headers = [("X-Amzn-Errortype", "ExtraError")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(

            http_response.headers(),

            expected_headers,

        ));

        let body = ::hyper::body::to_bytes(http_response.into_body())

            .await

            .expect("unable to extract body to bytes");

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

            &body,

            "{}",

            ::aws_smithy_protocol_test::MediaType::from("unknown"),

        ));

    }

    /// When there is modeled input, the content type must be application/json

    /// Test ID: RestJsonWithBodyExpectsApplicationJsonContentTypeNoHeaders

    #[::tokio::test]

    async fn rest_json_with_body_expects_application_json_content_type_no_headers_malformed_request(

    ) {

        {

            #[allow(unused_mut)]

            let mut http_request = http::Request::builder()

                .uri("/MalformedContentTypeWithBody")

                .method("POST")

                .body(::aws_smithy_http_server::body::Body::from(

                    ::bytes::Bytes::from_static("{}".as_bytes()),

                ))

                .unwrap();

            #[allow(unused_mut)]

            let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);

            let config = crate::service::RestJsonExtrasConfig::builder().build();

            let service = crate::service::RestJsonExtras::builder::<::hyper::body::Body, _, _, _>(config)

                            .malformed_content_type_with_body2(move |input: crate::input::MalformedContentTypeWithBody2Input| {

                                let sender = sender.clone();

                                async move {

                                    let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedContentTypeWithBody2Output, crate::error::MalformedContentTypeWithBody2Error> };

                                    sender.send(()).await.expect("receiver dropped early");

                                    result

                                }

                            })

                            .build_unchecked();

            let http_response = ::tower::ServiceExt::oneshot(service, http_request)

                .await

                .expect("unable to make an HTTP request");

            ::pretty_assertions::assert_eq!(

                http::StatusCode::from_u16(415).expect("invalid expected HTTP status code"),

                http_response.status()

            );

            let expected_headers = [("x-amzn-errortype", "UnsupportedMediaTypeException")];

            ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(

                http_response.headers(),

                expected_headers,

            ));

        }

    }

}

#[cfg(test)]

#[allow(unreachable_code, unused_variables)]

mod server_map_with_enum_key_op_test {

    /// Test ID: MapWithEnumKeyRequest

    #[::tokio::test]

    async fn map_with_enum_key_request_request() {

        #[allow(unused_mut)]

        let mut http_request = http::Request::builder()

            .uri("/map-with-enum-key")

            .method("POST")

            .header("Content-Type", "application/json")

            .body(::aws_smithy_http_server::body::Body::from(

                ::bytes::Bytes::from_static("{\"map\":{\"enumvalue\":\"something\"}}".as_bytes()),

            ))

            .unwrap();

        #[allow(unused_mut)]

        let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);

        let config = crate::service::RestJsonExtrasConfig::builder().build();

        let service =

            crate::service::RestJsonExtras::builder::<::hyper::body::Body, _, _, _>(config)

                .map_with_enum_key_op(move |input: crate::input::MapWithEnumKeyOpInput| {

                    let sender = sender.clone();

                    async move {

                        let result = {

                            let expected = crate::input::MapWithEnumKeyOpInput {

                                map: ::std::option::Option::Some({

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

                                    ret.insert(

                                        "enumvalue"

                                            .parse::<crate::model::StringEnum>()

                                            .expect("static value validated to member"),

                                        "something".to_owned(),

                                    );

                                    ret

                                }),

                            };

                            ::pretty_assertions::assert_eq!(input, expected);

                            let response = crate::output::MapWithEnumKeyOpOutput {

                                map: ::std::option::Option::None,

                            };

                            Ok(response)

                        };

                        sender.send(()).await.expect("receiver dropped early");

                        result

                    }

                })

                .build_unchecked();

        let http_response = ::tower::ServiceExt::oneshot(service, http_request)

            .await

            .expect("unable to make an HTTP request");

        assert!(receiver.recv().await.is_some());

    }

    /// Test ID: MapWithEnumKeyResponse

    #[::tokio::test]

    async fn map_with_enum_key_response_response() {

        let output = crate::output::MapWithEnumKeyOpOutput {

            map: ::std::option::Option::Some({

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

                ret.insert(

                    "enumvalue"

                        .parse::<crate::model::StringEnum>()

                        .expect("static value validated to member"),

                    "something".to_owned(),

                );

                ret

            }),

        };

        use ::aws_smithy_http_server::response::IntoResponse;

        let http_response = output.into_response();

        ::pretty_assertions::assert_eq!(

            http::StatusCode::from_u16(200).expect("invalid expected HTTP status code"),

            http_response.status()

        );

        let body = ::hyper::body::to_bytes(http_response.into_body())

            .await

            .expect("unable to extract body to bytes");

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

            &body,

            "{\"map\":{\"enumvalue\":\"something\"}}",

            ::aws_smithy_protocol_test::MediaType::from("unknown"),

        ));

    }

    /// Upper case error modeled lower case.

    /// Test ID: ServiceLevelErrorServer

    #[::tokio::test]

    async fn service_level_error_server_response() {

        let output = crate::error::ExtraError {};

        let output = crate::error::MapWithEnumKeyOpError::ExtraError(output);

        use ::aws_smithy_http_server::response::IntoResponse;

        let http_response = output.into_response();

        ::pretty_assertions::assert_eq!(

            http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),

            http_response.status()

        );

        let expected_headers = [("X-Amzn-Errortype", "ExtraError")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(

            http_response.headers(),

            expected_headers,

        ));

        let body = ::hyper::body::to_bytes(http_response.into_body())

            .await

            .expect("unable to extract body to bytes");

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

            &body,

            "{}",

            ::aws_smithy_protocol_test::MediaType::from("unknown"),

        ));

    }

}

#[cfg(test)]

#[allow(unreachable_code, unused_variables)]

mod server_null_in_non_sparse_test {

    /// Upper case error modeled lower case.

    /// Test ID: ServiceLevelErrorServer

    #[::tokio::test]

    async fn service_level_error_server_response() {

        let output = crate::error::ExtraError {};

        let output = crate::error::NullInNonSparseError::ExtraError(output);

        use ::aws_smithy_http_server::response::IntoResponse;

        let http_response = output.into_response();

        ::pretty_assertions::assert_eq!(

            http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),

            http_response.status()

        );

        let expected_headers = [("X-Amzn-Errortype", "ExtraError")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(

            http_response.headers(),

            expected_headers,

        ));

        let body = ::hyper::body::to_bytes(http_response.into_body())

            .await

            .expect("unable to extract body to bytes");

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

            &body,

            "{}",

            ::aws_smithy_protocol_test::MediaType::from("unknown"),

        ));

    }

}

#[cfg(test)]

#[allow(unreachable_code, unused_variables)]

mod server_primitive_int_header_test {

    /// Test ID: DeserPrimitiveHeader

    #[::tokio::test]

    async fn deser_primitive_header_response() {

        let output = crate::output::PrimitiveIntHeaderOutput { field: 123 };

        use ::aws_smithy_http_server::response::IntoResponse;

        let http_response = output.into_response();

        ::pretty_assertions::assert_eq!(

            http::StatusCode::from_u16(200).expect("invalid expected HTTP status code"),

            http_response.status()

        );

        let expected_headers = [("x-field", "123")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(

            http_response.headers(),

            expected_headers,

        ));

    }

    /// Test ID: DeserPrimitiveHeaderMissing

    #[::tokio::test]

    async fn deser_primitive_header_missing_response() {

        let output = crate::output::PrimitiveIntHeaderOutput { field: 0 };

        use ::aws_smithy_http_server::response::IntoResponse;

        let http_response = output.into_response();

        ::pretty_assertions::assert_eq!(

            http::StatusCode::from_u16(200).expect("invalid expected HTTP status code"),

            http_response.status()

        );

    }

    /// Upper case error modeled lower case.

    /// Test ID: ServiceLevelErrorServer

    #[::tokio::test]

    async fn service_level_error_server_response() {

        let output = crate::error::ExtraError {};

        let output = crate::error::PrimitiveIntHeaderError::ExtraError(output);

        use ::aws_smithy_http_server::response::IntoResponse;

        let http_response = output.into_response();

        ::pretty_assertions::assert_eq!(

            http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),

            http_response.status()

        );

        let expected_headers = [("X-Amzn-Errortype", "ExtraError")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(

            http_response.headers(),

            expected_headers,

        ));

        let body = ::hyper::body::to_bytes(http_response.into_body())

            .await

            .expect("unable to extract body to bytes");

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

            &body,

            "{}",

            ::aws_smithy_protocol_test::MediaType::from("unknown"),

        ));

#[cfg(test)]

#[allow(unreachable_code, unused_variables)]

mod server_primitive_int_op_test {

    /// Upper case error modeled lower case.

    /// Test ID: ServiceLevelErrorServer

    #[::tokio::test]

    async fn service_level_error_server_response() {

        let output = crate::error::ExtraError {};

        let output = crate::error::PrimitiveIntOpError::ExtraError(output);

        use ::aws_smithy_http_server::response::IntoResponse;

        let http_response = output.into_response();

        ::pretty_assertions::assert_eq!(

            http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),

            http_response.status()

        let expected_headers = [("X-Amzn-Errortype", "ExtraError")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(

            http_response.headers(),

            expected_headers,

        ));

        let body = ::hyper::body::to_bytes(http_response.into_body())

            .await

            .expect("unable to extract body to bytes");

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

            &body,

            "{}",

            ::aws_smithy_protocol_test::MediaType::from("unknown"),

        ));

#[cfg(test)]

mod server_query_precedence_test {

    /// Servers put all query params in map

    /// Test ID: RestJsonServersPutAllQueryParamsInMap

    async fn rest_json_servers_put_all_query_params_in_map_request() {

            .uri("/Precedence")

                ::bytes::Bytes::from_static("".as_bytes()),

        *http_request.uri_mut() = "/Precedence?bar=named&qux=fromMap".parse().unwrap();

                .query_precedence(move |input: crate::input::QueryPrecedenceInput| {

                            let expected = crate::input::QueryPrecedenceInput {

                                foo: ::std::option::Option::Some("named".to_owned()),

                                baz: ::std::option::Option::Some({

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

                                    ret.insert("bar".to_owned(), "named".to_owned());

                                    ret.insert("qux".to_owned(), "fromMap".to_owned());

                                    ret

                                }),

                            let response = crate::output::QueryPrecedenceOutput {};

        assert!(receiver.recv().await.is_some());

    /// Upper case error modeled lower case.

    /// Test ID: ServiceLevelErrorServer

    async fn service_level_error_server_response() {

        let output = crate::error::ExtraError {};

        let output = crate::error::QueryPrecedenceError::ExtraError(output);

            http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),

        let expected_headers = [("X-Amzn-Errortype", "ExtraError")];

            "{}",

            ::aws_smithy_protocol_test::MediaType::from("unknown"),

}

#[cfg(test)]

#[allow(unreachable_code, unused_variables)]

mod server_status_response_test {

        let output = crate::error::StatusResponseError::ExtraError(output);

}

#[cfg(test)]

#[allow(unreachable_code, unused_variables)]

mod server_string_payload_test {

    /// Test ID: StringPayload

    async fn string_payload_request() {

            .uri("/StringPayload")

            .header("Content-Type", "text/plain")

        let service =

            crate::service::RestJsonExtras::builder::<::hyper::body::Body, _, _, _>(config)

                .string_payload(move |input: crate::input::StringPayloadInput| {

                    let sender = sender.clone();

                    async move {

                        let result = {

                            let expected = crate::input::StringPayloadInput {

                                payload: ::std::option::Option::Some("rawstring".to_owned()),

                            };

                            ::pretty_assertions::assert_eq!(input, expected);

                            let response = crate::output::StringPayloadOutput {

                                payload: ::std::option::Option::None,

                            };

                            Ok(response)

                        };

                        sender.send(()).await.expect("receiver dropped early");

                        result

                    }

                })

                .build_unchecked();

        let http_response = ::tower::ServiceExt::oneshot(service, http_request)

            .await

            .expect("unable to make an HTTP request");

        assert!(receiver.recv().await.is_some());

    }

    /// Upper case error modeled lower case.

    /// Test ID: ServiceLevelErrorServer

    #[::tokio::test]

    async fn service_level_error_server_response() {

        let output = crate::error::ExtraError {};

        let output = crate::error::StringPayloadError::ExtraError(output);

        use ::aws_smithy_http_server::response::IntoResponse;

        let http_response = output.into_response();

        ::pretty_assertions::assert_eq!(

            http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),

            http_response.status()

        );

        let expected_headers = [("X-Amzn-Errortype", "ExtraError")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(

            http_response.headers(),

            expected_headers,

        ));

        let body = ::hyper::body::to_bytes(http_response.into_body())

            .await

            .expect("unable to extract body to bytes");

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

            &body,

            "{}",

            ::aws_smithy_protocol_test::MediaType::from("unknown"),

        ));

    }

}

static CONTENT_TYPE_HTTPSTRINGPAYLOAD2: ::once_cell::sync::Lazy<::mime::Mime> =

    ::once_cell::sync::Lazy::new(|| {

        "text/plain"

            .parse::<::mime::Mime>()

            .expect("BUG: MIME parsing failed, content_type is not valid")

    });

::pin_project_lite::pin_project! {

    /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the

    /// [`HttpStringPayload2Input`](crate::input::HttpStringPayload2Input) using modelled bindings.

    pub struct HttpStringPayload2InputFuture {

        inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpStringPayload2Input, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>

    }

}

impl std::future::Future for HttpStringPayload2InputFuture {

    type Output = Result<