Client Test

Client Test

rev. d06a46cae0f385cdae37a9f8264db3469a090ab5 (ignoring whitespace)

Files changed:

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/protocol_serde/shape_media_type_header.rs

@@ -4,4 +48,48 @@
   24     24   
        output = output.set_json(
   25     25   
            crate::protocol_serde::shape_media_type_header_output::de_json_header(_response_headers)
   26     26   
                .map_err(|_| crate::operation::media_type_header::MediaTypeHeaderError::unhandled("Failed to parse json from header `X-Json"))?,
   27     27   
        );
   28     28   
        output.build()
   29     29   
    })
   30     30   
}
   31     31   
   32     32   
pub fn ser_media_type_header_headers(
   33     33   
    input: &crate::operation::media_type_header::MediaTypeHeaderInput,
   34         -
    mut builder: ::http::request::Builder,
   35         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          34  +
    mut builder: ::http_1x::request::Builder,
          35  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   36     36   
    if let ::std::option::Option::Some(inner_1) = &input.json {
   37     37   
        let formatted_2 = ::aws_smithy_types::base64::encode(inner_1);
   38     38   
        let header_value = formatted_2;
   39         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          39  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   40     40   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   41     41   
                "json",
   42     42   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   43     43   
            )
   44     44   
        })?;
   45     45   
        builder = builder.header("X-Json", header_value);
   46     46   
    }
   47     47   
    Ok(builder)
   48     48   
}

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/protocol_serde/shape_null_and_empty_headers_client.rs

@@ -23,23 +96,96 @@
   43     43   
            crate::protocol_serde::shape_null_and_empty_headers_client_output::de_c_header(_response_headers).map_err(|_| {
   44     44   
                crate::operation::null_and_empty_headers_client::NullAndEmptyHeadersClientError::unhandled("Failed to parse c from header `X-C")
   45     45   
            })?,
   46     46   
        );
   47     47   
        output.build()
   48     48   
    })
   49     49   
}
   50     50   
   51     51   
pub fn ser_null_and_empty_headers_client_headers(
   52     52   
    input: &crate::operation::null_and_empty_headers_client::NullAndEmptyHeadersClientInput,
   53         -
    mut builder: ::http::request::Builder,
   54         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          53  +
    mut builder: ::http_1x::request::Builder,
          54  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   55     55   
    if let ::std::option::Option::Some(inner_1) = &input.a {
   56     56   
        let formatted_2 = inner_1.as_str();
   57     57   
        let header_value = formatted_2;
   58         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          58  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   59     59   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   60     60   
                "a",
   61     61   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   62     62   
            )
   63     63   
        })?;
   64     64   
        builder = builder.header("X-A", header_value);
   65     65   
    }
   66     66   
    if let ::std::option::Option::Some(inner_3) = &input.b {
   67     67   
        let formatted_4 = inner_3.as_str();
   68     68   
        let header_value = formatted_4;
   69         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          69  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   70     70   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   71     71   
                "b",
   72     72   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   73     73   
            )
   74     74   
        })?;
   75     75   
        builder = builder.header("X-B", header_value);
   76     76   
    }
   77     77   
    if let ::std::option::Option::Some(inner_5) = &input.c {
   78     78   
        // Empty vec in header is serialized as an empty string
   79     79   
        if inner_5.is_empty() {
   80     80   
            builder = builder.header("X-C", "");
   81     81   
        } else {
   82     82   
            for inner_6 in inner_5 {
   83     83   
                let formatted_7 = ::aws_smithy_http::header::quote_header_value(inner_6.as_str());
   84     84   
                let header_value = formatted_7;
   85         -
                let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          85  +
                let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   86     86   
                    ::aws_smithy_types::error::operation::BuildError::invalid_field(
   87     87   
                        "c",
   88     88   
                        format!("`{}` cannot be used as a header value: {}", &header_value, err),
   89     89   
                    )
   90     90   
                })?;
   91     91   
                builder = builder.header("X-C", header_value);
   92     92   
            }
   93     93   
        }
   94     94   
    }
   95     95   
    Ok(builder)

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/protocol_serde/shape_null_and_empty_headers_server.rs

@@ -23,23 +96,96 @@
   43     43   
            crate::protocol_serde::shape_null_and_empty_headers_server_output::de_c_header(_response_headers).map_err(|_| {
   44     44   
                crate::operation::null_and_empty_headers_server::NullAndEmptyHeadersServerError::unhandled("Failed to parse c from header `X-C")
   45     45   
            })?,
   46     46   
        );
   47     47   
        output.build()
   48     48   
    })
   49     49   
}
   50     50   
   51     51   
pub fn ser_null_and_empty_headers_server_headers(
   52     52   
    input: &crate::operation::null_and_empty_headers_server::NullAndEmptyHeadersServerInput,
   53         -
    mut builder: ::http::request::Builder,
   54         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          53  +
    mut builder: ::http_1x::request::Builder,
          54  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   55     55   
    if let ::std::option::Option::Some(inner_1) = &input.a {
   56     56   
        let formatted_2 = inner_1.as_str();
   57     57   
        let header_value = formatted_2;
   58         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          58  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   59     59   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   60     60   
                "a",
   61     61   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   62     62   
            )
   63     63   
        })?;
   64     64   
        builder = builder.header("X-A", header_value);
   65     65   
    }
   66     66   
    if let ::std::option::Option::Some(inner_3) = &input.b {
   67     67   
        let formatted_4 = inner_3.as_str();
   68     68   
        let header_value = formatted_4;
   69         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          69  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   70     70   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   71     71   
                "b",
   72     72   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   73     73   
            )
   74     74   
        })?;
   75     75   
        builder = builder.header("X-B", header_value);
   76     76   
    }
   77     77   
    if let ::std::option::Option::Some(inner_5) = &input.c {
   78     78   
        // Empty vec in header is serialized as an empty string
   79     79   
        if inner_5.is_empty() {
   80     80   
            builder = builder.header("X-C", "");
   81     81   
        } else {
   82     82   
            for inner_6 in inner_5 {
   83     83   
                let formatted_7 = ::aws_smithy_http::header::quote_header_value(inner_6.as_str());
   84     84   
                let header_value = formatted_7;
   85         -
                let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          85  +
                let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   86     86   
                    ::aws_smithy_types::error::operation::BuildError::invalid_field(
   87     87   
                        "c",
   88     88   
                        format!("`{}` cannot be used as a header value: {}", &header_value, err),
   89     89   
                    )
   90     90   
                })?;
   91     91   
                builder = builder.header("X-C", header_value);
   92     92   
            }
   93     93   
        }
   94     94   
    }
   95     95   
    Ok(builder)

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/protocol_serde/shape_put_with_content_encoding.rs

@@ -6,6 +60,60 @@
   26     26   
> {
   27     27   
    Ok({
   28     28   
        #[allow(unused_mut)]
   29     29   
        let mut output = crate::operation::put_with_content_encoding::builders::PutWithContentEncodingOutputBuilder::default();
   30     30   
        output.build()
   31     31   
    })
   32     32   
}
   33     33   
   34     34   
pub fn ser_put_with_content_encoding_headers(
   35     35   
    input: &crate::operation::put_with_content_encoding::PutWithContentEncodingInput,
   36         -
    mut builder: ::http::request::Builder,
   37         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          36  +
    mut builder: ::http_1x::request::Builder,
          37  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   38     38   
    if let ::std::option::Option::Some(inner_1) = &input.encoding {
   39     39   
        let formatted_2 = inner_1.as_str();
   40     40   
        let header_value = formatted_2;
   41         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          41  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   42     42   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   43     43   
                "encoding",
   44     44   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   45     45   
            )
   46     46   
        })?;
   47     47   
        builder = builder.header("Content-Encoding", header_value);
   48     48   
    }
   49     49   
    Ok(builder)
   50     50   
}
   51     51

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/protocol_serde/shape_simple_scalar_properties.rs

@@ -13,13 +78,78 @@
   33     33   
            crate::protocol_serde::shape_simple_scalar_properties_output::de_foo_header(_response_headers).map_err(|_| {
   34     34   
                crate::operation::simple_scalar_properties::SimpleScalarPropertiesError::unhandled("Failed to parse foo from header `X-Foo")
   35     35   
            })?,
   36     36   
        );
   37     37   
        output.build()
   38     38   
    })
   39     39   
}
   40     40   
   41     41   
pub fn ser_simple_scalar_properties_headers(
   42     42   
    input: &crate::operation::simple_scalar_properties::SimpleScalarPropertiesInput,
   43         -
    mut builder: ::http::request::Builder,
   44         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          43  +
    mut builder: ::http_1x::request::Builder,
          44  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   45     45   
    if let ::std::option::Option::Some(inner_1) = &input.foo {
   46     46   
        let formatted_2 = inner_1.as_str();
   47     47   
        let header_value = formatted_2;
   48         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          48  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   49     49   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   50     50   
                "foo",
   51     51   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   52     52   
            )
   53     53   
        })?;
   54     54   
        builder = builder.header("X-Foo", header_value);
   55     55   
    }
   56     56   
    Ok(builder)
   57     57   
}
   58     58

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/protocol_serde/shape_streaming_traits.rs

@@ -11,11 +55,55 @@
   31     31   
) -> std::result::Result<crate::operation::streaming_traits::StreamingTraitsOutput, crate::operation::streaming_traits::StreamingTraitsError> {
   32     32   
    #[allow(unused_mut)]
   33     33   
    let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
   34     34   
        .map_err(crate::operation::streaming_traits::StreamingTraitsError::unhandled)?;
   35     35   
    let generic = generic_builder.build();
   36     36   
    Err(crate::operation::streaming_traits::StreamingTraitsError::generic(generic))
   37     37   
}
   38     38   
   39     39   
pub fn ser_streaming_traits_headers(
   40     40   
    input: &crate::operation::streaming_traits::StreamingTraitsInput,
   41         -
    mut builder: ::http::request::Builder,
   42         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          41  +
    mut builder: ::http_1x::request::Builder,
          42  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   43     43   
    if let ::std::option::Option::Some(inner_1) = &input.foo {
   44     44   
        let formatted_2 = inner_1.as_str();
   45     45   
        let header_value = formatted_2;
   46         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          46  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   47     47   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   48     48   
                "foo",
   49     49   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   50     50   
            )
   51     51   
        })?;
   52     52   
        builder = builder.header("X-Foo", header_value);
   53     53   
    }
   54     54   
    Ok(builder)
   55     55   
}

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/protocol_serde/shape_streaming_traits_require_length.rs

@@ -6,6 +50,50 @@
   26     26   
> {
   27     27   
    Ok({
   28     28   
        #[allow(unused_mut)]
   29     29   
        let mut output = crate::operation::streaming_traits_require_length::builders::StreamingTraitsRequireLengthOutputBuilder::default();
   30     30   
        output.build()
   31     31   
    })
   32     32   
}
   33     33   
   34     34   
pub fn ser_streaming_traits_require_length_headers(
   35     35   
    input: &crate::operation::streaming_traits_require_length::StreamingTraitsRequireLengthInput,
   36         -
    mut builder: ::http::request::Builder,
   37         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          36  +
    mut builder: ::http_1x::request::Builder,
          37  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   38     38   
    if let ::std::option::Option::Some(inner_1) = &input.foo {
   39     39   
        let formatted_2 = inner_1.as_str();
   40     40   
        let header_value = formatted_2;
   41         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          41  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   42     42   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   43     43   
                "foo",
   44     44   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   45     45   
            )
   46     46   
        })?;
   47     47   
        builder = builder.header("X-Foo", header_value);
   48     48   
    }
   49     49   
    Ok(builder)
   50     50   
}

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/protocol_serde/shape_streaming_traits_with_media_type.rs

@@ -20,20 +64,64 @@
   40     40   
> {
   41     41   
    #[allow(unused_mut)]
   42     42   
    let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
   43     43   
        .map_err(crate::operation::streaming_traits_with_media_type::StreamingTraitsWithMediaTypeError::unhandled)?;
   44     44   
    let generic = generic_builder.build();
   45     45   
    Err(crate::operation::streaming_traits_with_media_type::StreamingTraitsWithMediaTypeError::generic(generic))
   46     46   
}
   47     47   
   48     48   
pub fn ser_streaming_traits_with_media_type_headers(
   49     49   
    input: &crate::operation::streaming_traits_with_media_type::StreamingTraitsWithMediaTypeInput,
   50         -
    mut builder: ::http::request::Builder,
   51         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          50  +
    mut builder: ::http_1x::request::Builder,
          51  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   52     52   
    if let ::std::option::Option::Some(inner_1) = &input.foo {
   53     53   
        let formatted_2 = inner_1.as_str();
   54     54   
        let header_value = formatted_2;
   55         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          55  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   56     56   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   57     57   
                "foo",
   58     58   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   59     59   
            )
   60     60   
        })?;
   61     61   
        builder = builder.header("X-Foo", header_value);
   62     62   
    }
   63     63   
    Ok(builder)
   64     64   
}

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/protocol_serde/shape_test_body_structure.rs

@@ -9,9 +74,74 @@
   29     29   
            crate::protocol_serde::shape_test_body_structure_output::de_test_id_header(_response_headers).map_err(|_| {
   30     30   
                crate::operation::test_body_structure::TestBodyStructureError::unhandled("Failed to parse testId from header `x-amz-test-id")
   31     31   
            })?,
   32     32   
        );
   33     33   
        output.build()
   34     34   
    })
   35     35   
}
   36     36   
   37     37   
pub fn ser_test_body_structure_headers(
   38     38   
    input: &crate::operation::test_body_structure::TestBodyStructureInput,
   39         -
    mut builder: ::http::request::Builder,
   40         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          39  +
    mut builder: ::http_1x::request::Builder,
          40  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   41     41   
    if let ::std::option::Option::Some(inner_1) = &input.test_id {
   42     42   
        let formatted_2 = inner_1.as_str();
   43     43   
        let header_value = formatted_2;
   44         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          44  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   45     45   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   46     46   
                "test_id",
   47     47   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   48     48   
            )
   49     49   
        })?;
   50     50   
        builder = builder.header("x-amz-test-id", header_value);
   51     51   
    }
   52     52   
    Ok(builder)
   53     53   
}
   54     54

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/protocol_serde/shape_test_get_no_payload.rs

@@ -7,7 +51,51 @@
   27     27   
            crate::protocol_serde::shape_test_get_no_payload_output::de_test_id_header(_response_headers).map_err(|_| {
   28     28   
                crate::operation::test_get_no_payload::TestGetNoPayloadError::unhandled("Failed to parse testId from header `X-Amz-Test-Id")
   29     29   
            })?,
   30     30   
        );
   31     31   
        output.build()
   32     32   
    })
   33     33   
}
   34     34   
   35     35   
pub fn ser_test_get_no_payload_headers(
   36     36   
    input: &crate::operation::test_get_no_payload::TestGetNoPayloadInput,
   37         -
    mut builder: ::http::request::Builder,
   38         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          37  +
    mut builder: ::http_1x::request::Builder,
          38  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   39     39   
    if let ::std::option::Option::Some(inner_1) = &input.test_id {
   40     40   
        let formatted_2 = inner_1.as_str();
   41     41   
        let header_value = formatted_2;
   42         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          42  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   43     43   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   44     44   
                "test_id",
   45     45   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   46     46   
            )
   47     47   
        })?;
   48     48   
        builder = builder.header("X-Amz-Test-Id", header_value);
   49     49   
    }
   50     50   
    Ok(builder)
   51     51   
}

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/protocol_serde/shape_test_payload_blob.rs

@@ -6,6 +50,50 @@
   26     26   
                crate::operation::test_payload_blob::TestPayloadBlobError::unhandled("Failed to parse contentType from header `Content-Type")
   27     27   
            })?,
   28     28   
        );
   29     29   
        output = output.set_data(crate::protocol_serde::shape_test_payload_blob_output::de_data_payload(_response_body)?);
   30     30   
        output.build()
   31     31   
    })
   32     32   
}
   33     33   
   34     34   
pub fn ser_test_payload_blob_headers(
   35     35   
    input: &crate::operation::test_payload_blob::TestPayloadBlobInput,
   36         -
    mut builder: ::http::request::Builder,
   37         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          36  +
    mut builder: ::http_1x::request::Builder,
          37  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   38     38   
    if let ::std::option::Option::Some(inner_1) = &input.content_type {
   39     39   
        let formatted_2 = inner_1.as_str();
   40     40   
        let header_value = formatted_2;
   41         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          41  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   42     42   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   43     43   
                "content_type",
   44     44   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   45     45   
            )
   46     46   
        })?;
   47     47   
        builder = builder.header("Content-Type", header_value);
   48     48   
    }
   49     49   
    Ok(builder)
   50     50   
}

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/protocol_serde/shape_test_payload_structure.rs

@@ -14,14 +58,58 @@
   34     34   
            crate::protocol_serde::shape_test_payload_structure_output::de_test_id_header(_response_headers).map_err(|_| {
   35     35   
                crate::operation::test_payload_structure::TestPayloadStructureError::unhandled("Failed to parse testId from header `x-amz-test-id")
   36     36   
            })?,
   37     37   
        );
   38     38   
        output.build()
   39     39   
    })
   40     40   
}
   41     41   
   42     42   
pub fn ser_test_payload_structure_headers(
   43     43   
    input: &crate::operation::test_payload_structure::TestPayloadStructureInput,
   44         -
    mut builder: ::http::request::Builder,
   45         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          44  +
    mut builder: ::http_1x::request::Builder,
          45  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   46     46   
    if let ::std::option::Option::Some(inner_1) = &input.test_id {
   47     47   
        let formatted_2 = inner_1.as_str();
   48     48   
        let header_value = formatted_2;
   49         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          49  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   50     50   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   51     51   
                "test_id",
   52     52   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   53     53   
            )
   54     54   
        })?;
   55     55   
        builder = builder.header("x-amz-test-id", header_value);
   56     56   
    }
   57     57   
    Ok(builder)
   58     58   
}

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/protocol_serde/shape_test_post_no_payload.rs

@@ -11,11 +55,55 @@
   31     31   
            crate::protocol_serde::shape_test_post_no_payload_output::de_test_id_header(_response_headers).map_err(|_| {
   32     32   
                crate::operation::test_post_no_payload::TestPostNoPayloadError::unhandled("Failed to parse testId from header `X-Amz-Test-Id")
   33     33   
            })?,
   34     34   
        );
   35     35   
        output.build()
   36     36   
    })
   37     37   
}
   38     38   
   39     39   
pub fn ser_test_post_no_payload_headers(
   40     40   
    input: &crate::operation::test_post_no_payload::TestPostNoPayloadInput,
   41         -
    mut builder: ::http::request::Builder,
   42         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          41  +
    mut builder: ::http_1x::request::Builder,
          42  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   43     43   
    if let ::std::option::Option::Some(inner_1) = &input.test_id {
   44     44   
        let formatted_2 = inner_1.as_str();
   45     45   
        let header_value = formatted_2;
   46         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          46  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   47     47   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   48     48   
                "test_id",
   49     49   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   50     50   
            )
   51     51   
        })?;
   52     52   
        builder = builder.header("X-Amz-Test-Id", header_value);
   53     53   
    }
   54     54   
    Ok(builder)
   55     55   
}

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/protocol_serde/shape_timestamp_format_headers.rs

@@ -55,55 +165,165 @@
   75     75   
                    "Failed to parse targetHttpDate from header `X-targetHttpDate",
   76     76   
                )
   77     77   
            })?,
   78     78   
        );
   79     79   
        output.build()
   80     80   
    })
   81     81   
}
   82     82   
   83     83   
pub fn ser_timestamp_format_headers_headers(
   84     84   
    input: &crate::operation::timestamp_format_headers::TimestampFormatHeadersInput,
   85         -
    mut builder: ::http::request::Builder,
   86         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          85  +
    mut builder: ::http_1x::request::Builder,
          86  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   87     87   
    if let ::std::option::Option::Some(inner_1) = &input.member_epoch_seconds {
   88     88   
        let formatted_2 = inner_1.fmt(::aws_smithy_types::date_time::Format::EpochSeconds)?;
   89     89   
        let header_value = formatted_2;
   90         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          90  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   91     91   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   92     92   
                "member_epoch_seconds",
   93     93   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   94     94   
            )
   95     95   
        })?;
   96     96   
        builder = builder.header("X-memberEpochSeconds", header_value);
   97     97   
    }
   98     98   
    if let ::std::option::Option::Some(inner_3) = &input.member_http_date {
   99     99   
        let formatted_4 = inner_3.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
  100    100   
        let header_value = formatted_4;
  101         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         101  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  102    102   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  103    103   
                "member_http_date",
  104    104   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  105    105   
            )
  106    106   
        })?;
  107    107   
        builder = builder.header("X-memberHttpDate", header_value);
  108    108   
    }
  109    109   
    if let ::std::option::Option::Some(inner_5) = &input.member_date_time {
  110    110   
        let formatted_6 = inner_5.fmt(::aws_smithy_types::date_time::Format::DateTime)?;
  111    111   
        let header_value = formatted_6;
  112         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         112  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  113    113   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  114    114   
                "member_date_time",
  115    115   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  116    116   
            )
  117    117   
        })?;
  118    118   
        builder = builder.header("X-memberDateTime", header_value);
  119    119   
    }
  120    120   
    if let ::std::option::Option::Some(inner_7) = &input.default_format {
  121    121   
        let formatted_8 = inner_7.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
  122    122   
        let header_value = formatted_8;
  123         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         123  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  124    124   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  125    125   
                "default_format",
  126    126   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  127    127   
            )
  128    128   
        })?;
  129    129   
        builder = builder.header("X-defaultFormat", header_value);
  130    130   
    }
  131    131   
    if let ::std::option::Option::Some(inner_9) = &input.target_epoch_seconds {
  132    132   
        let formatted_10 = inner_9.fmt(::aws_smithy_types::date_time::Format::EpochSeconds)?;
  133    133   
        let header_value = formatted_10;
  134         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         134  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  135    135   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  136    136   
                "target_epoch_seconds",
  137    137   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  138    138   
            )
  139    139   
        })?;
  140    140   
        builder = builder.header("X-targetEpochSeconds", header_value);
  141    141   
    }
  142    142   
    if let ::std::option::Option::Some(inner_11) = &input.target_http_date {
  143    143   
        let formatted_12 = inner_11.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
  144    144   
        let header_value = formatted_12;
  145         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         145  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  146    146   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  147    147   
                "target_http_date",
  148    148   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  149    149   
            )
  150    150   
        })?;
  151    151   
        builder = builder.header("X-targetHttpDate", header_value);
  152    152   
    }
  153    153   
    if let ::std::option::Option::Some(inner_13) = &input.target_date_time {
  154    154   
        let formatted_14 = inner_13.fmt(::aws_smithy_types::date_time::Format::DateTime)?;
  155    155   
        let header_value = formatted_14;
  156         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         156  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  157    157   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  158    158   
                "target_date_time",
  159    159   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  160    160   
            )
  161    161   
        })?;
  162    162   
        builder = builder.header("X-targetDateTime", header_value);
  163    163   
    }
  164    164   
    Ok(builder)
  165    165   
}

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/serialization_settings.rs

@@ -1,1 +78,83 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/*
    3      3   
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
    4      4   
 * SPDX-License-Identifier: Apache-2.0
    5      5   
 */
    6      6   
    7      7   
#![allow(dead_code)]
    8      8   
    9      9   
use aws_smithy_http::header::set_request_header_if_absent;
   10     10   
use aws_smithy_types::config_bag::{Storable, StoreReplace};
   11         -
use http::header::{HeaderName, CONTENT_LENGTH, CONTENT_TYPE};
          11  +
use http_1x::header::{HeaderName, CONTENT_LENGTH, CONTENT_TYPE};
   12     12   
   13     13   
/// Configuration for how default protocol headers are serialized
   14     14   
#[derive(Clone, Debug, Default)]
   15     15   
pub(crate) struct HeaderSerializationSettings {
   16     16   
    omit_default_content_length: bool,
   17     17   
    omit_default_content_type: bool,
   18     18   
}
   19     19   
   20     20   
impl HeaderSerializationSettings {
   21     21   
    /// Creates new [`HeaderSerializationSettings`]
   22     22   
    pub(crate) fn new() -> Self {
   23     23   
        Default::default()
   24     24   
    }
   25     25   
   26     26   
    /// Omit the default `Content-Length` header during serialization
   27     27   
    pub(crate) fn omit_default_content_length(self) -> Self {
   28     28   
        Self {
   29     29   
            omit_default_content_length: true,
   30     30   
            ..self
   31     31   
        }
   32     32   
    }
   33     33   
   34     34   
    /// Omit the default `Content-Type` header during serialization
   35     35   
    pub(crate) fn omit_default_content_type(self) -> Self {
   36     36   
        Self {
   37     37   
            omit_default_content_type: true,
   38     38   
            ..self
   39     39   
        }
   40     40   
    }
   41     41   
   42     42   
    /// Returns true if the given default header name should be serialized
   43     43   
    fn include_header(&self, header: &HeaderName) -> bool {
   44     44   
        (!self.omit_default_content_length || header != CONTENT_LENGTH) && (!self.omit_default_content_type || header != CONTENT_TYPE)
   45     45   
    }
   46     46   
   47     47   
    /// Sets a default header on the given request builder if it should be serialized
   48         -
    pub(crate) fn set_default_header(&self, mut request: http::request::Builder, header_name: HeaderName, value: &str) -> http::request::Builder {
          48  +
    pub(crate) fn set_default_header(
          49  +
        &self,
          50  +
        mut request: http_1x::request::Builder,
          51  +
        header_name: HeaderName,
          52  +
        value: &str,
          53  +
    ) -> http_1x::request::Builder {
   49     54   
        if self.include_header(&header_name) {
   50     55   
            request = set_request_header_if_absent(request, header_name, value);
   51     56   
        }
   52     57   
        request
   53     58   
    }
   54     59   
}
   55     60   
   56     61   
impl Storable for HeaderSerializationSettings {
   57     62   
    type Storer = StoreReplace<Self>;
   58     63   
}

tmp-codegen-diff/codegen-client-test/rest_json_extras/rust-client-codegen/Cargo.toml

@@ -1,1 +56,60 @@
   13     13   
path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-async"
   14     14   
[dependencies.aws-smithy-http]
   15     15   
path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http"
   16     16   
[dependencies.aws-smithy-json]
   17     17   
path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-json"
   18     18   
[dependencies.aws-smithy-runtime]
   19     19   
path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime"
   20     20   
features = ["client"]
   21     21   
[dependencies.aws-smithy-runtime-api]
   22     22   
path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime-api"
   23         -
features = ["client", "http-02x"]
          23  +
features = ["client", "http-1x"]
   24     24   
[dependencies.aws-smithy-types]
   25     25   
path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-types"
          26  +
features = ["http-body-1-x"]
   26     27   
[dependencies.bytes]
   27     28   
version = "1.4.0"
   28     29   
[dependencies.fastrand]
   29     30   
version = "2.0.0"
   30     31   
[dependencies.http]
   31     32   
version = "0.2.9"
          33  +
[dependencies.http-1x]
          34  +
version = "1"
          35  +
package = "http"
   32     36   
[dependencies.tracing]
   33     37   
version = "0.1"
   34     38   
[dev-dependencies.aws-smithy-http-client]
   35     39   
path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http-client"
   36     40   
features = ["test-util"]
   37     41   
[dev-dependencies.aws-smithy-protocol-test]
   38     42   
path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-protocol-test"
   39     43   
[dev-dependencies.pretty_assertions]
   40     44   
version = "1.3.0"
   41     45   
[dev-dependencies.tokio]