Server Test

tmp-codegen-diff/codegen-server-test/unique_items-http0x/rust-server-codegen/src/unconstrained.rs

@@ -0,1 +0,44 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-+
 pub(crate) mod complex_set_unconstrained {
-+
     #[derive(Debug, Clone)]
     pub(crate) struct ComplexSetUnconstrained(
         pub(crate) std::vec::Vec<crate::model::ComplexSetStruct>,
     );
-+
     impl From<ComplexSetUnconstrained>
         for crate::constrained::MaybeConstrained<crate::model::ComplexSet>
-+
+    {
         fn from(value: ComplexSetUnconstrained) -> Self {
             Self::Unconstrained(value)
-+
+        }
-+
+    }
     impl std::convert::TryFrom<ComplexSetUnconstrained> for crate::model::ComplexSet {
         type Error = crate::model::complex_set::ConstraintViolation;
         fn try_from(value: ComplexSetUnconstrained) -> std::result::Result<Self, Self::Error> {
             let inner = value.0;
             Self::try_from(inner)
-+
+        }
-+
+    }
-+
+}
 pub(crate) mod simple_set_unconstrained {
-+
     #[derive(Debug, Clone)]
     pub(crate) struct SimpleSetUnconstrained(pub(crate) std::vec::Vec<::std::string::String>);
-+
     impl From<SimpleSetUnconstrained>
         for crate::constrained::MaybeConstrained<crate::model::SimpleSet>
-+
+    {
         fn from(value: SimpleSetUnconstrained) -> Self {
             Self::Unconstrained(value)
-+
+        }
-+
+    }
     impl std::convert::TryFrom<SimpleSetUnconstrained> for crate::model::SimpleSet {
         type Error = crate::model::simple_set::ConstraintViolation;
         fn try_from(value: SimpleSetUnconstrained) -> std::result::Result<Self, Self::Error> {
             let inner = value.0;
             Self::try_from(inner)
-+
+        }
-+
+    }
-+
+}

tmp-codegen-diff/codegen-server-test/unique_items/rust-server-codegen/Cargo.toml

@@ -1,1 +56,60 @@

↥ Expand context

 # Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 [package]
 name = "unique_items"
 version = "0.0.1"
 authors = ["protocoltest@example.com"]
 description = "test"
 edition = "2021"
-8
 [package.metadata.smithy]

 codegen-version = "ci"
 protocol = "aws.protocols#restJson1"
 [dependencies.aws-smithy-http]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http"
 [dependencies.aws-smithy-http-server]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http-server"
 [dependencies.aws-smithy-json]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-json"
 [dependencies.aws-smithy-runtime-api]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime-api"
 features = ["http-1x"]
 [dependencies.aws-smithy-types]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-types"
 features = ["http-body-1-x"]
 [dependencies.futures-util]
 version = "0.3"
 [dependencies.http]
 version = "0.2.9"
 [dependencies.hyper]
 version = "0.14.26"
 [dependencies.http-1x]
 version = "1"
 package = "http"
 [dependencies.http-body-util]
 version = "0.1.3"
 [dependencies.mime]
 version = "0.3"
 [dependencies.pin-project-lite]
 version = "0.2"
 [dependencies.tower]
 version = "0.4"
 [dependencies.tracing]
 version = "0.1"
 [dev-dependencies.aws-smithy-protocol-test]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-protocol-test"
 features = ["http-1x"]
 [dev-dependencies.bytes]
 version = "1.4.0"
 [dev-dependencies.hyper]
 version = "0.14.12"
 version = "1"
 [dev-dependencies.pretty_assertions]
 version = "1.3.0"
 [dev-dependencies.tokio]
 version = "1.23.1"
 features = ["macros", "test-util", "rt-multi-thread"]
 [dev-dependencies.tracing-test]
 version = "0.2.5"
 features = ["no-env-filter"]
 [features]
 rt-tokio = ["aws-smithy-types/rt-tokio"]

↧ Expand context

 aws-lambda = ["aws-smithy-http-server/aws-lambda"]
 request-id = ["aws-smithy-http-server/request-id"]
 default = ["rt-tokio", "request-id"]
-59
-60

tmp-codegen-diff/codegen-server-test/unique_items/rust-server-codegen/src/lib.rs

@@ -19,19 +128,131 @@

↥ Expand context

 #![allow(rustdoc::invalid_html_tags)]
 #![forbid(unsafe_code)]
 #![cfg_attr(docsrs, feature(doc_cfg))]
 //! unique_items
-23
 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 //! A fast and customizable Rust implementation of the UniqueItemsService Smithy service.
 //!
 //! # Using UniqueItemsService
 //!
 //! The primary entrypoint is [`UniqueItemsService`]: it satisfies the [`Service<http::Request, Response = http::Response>`](::tower::Service)
 //! trait and therefore can be handed to a [`hyper` server](https://github.com/hyperium/hyper) via [`UniqueItemsService::into_make_service`]
 //! or used in AWS Lambda
 #![cfg_attr(
     feature = "aws-lambda",
     doc = " via [`LambdaHandler`](crate::server::routing::LambdaHandler)."
 )]
 #![cfg_attr(
     not(feature = "aws-lambda"),
     doc = " by enabling the `aws-lambda` feature flag and utilizing the `LambdaHandler`."

 )]
 //! The [`crate::input`], [`crate::output`], and [`crate::error`]
 //! modules provide the types used in each operation.
 //!
 //! ### Running on Hyper
 //!
 //! ```rust,no_run
 //! # use std::net::SocketAddr;
 //! # async fn dummy() {
 //! use unique_items::{UniqueItemsService, UniqueItemsServiceConfig};
 //! use unique_items::serve;
 //! use ::tokio::net::TcpListener;
 //!
 //! # let app = UniqueItemsService::builder(
 //! #     UniqueItemsServiceConfig::builder()
 //! #         .build()
 //! # ).build_unchecked();
 //! let server = app.into_make_service();
 //! let bind: SocketAddr = "127.0.0.1:6969".parse()
 //!     .expect("unable to parse the server bind address and port");
 //! ::hyper::Server::bind(&bind).serve(server).await.unwrap();
 //! let listener = TcpListener::bind(bind).await
 //!     .expect("failed to bind TCP listener");
 //! serve(listener, app.into_make_service()).await.unwrap();
 //! # }
 //! ```
 //!
 //! ### Running on Lambda
 //!
 //! ```rust,ignore
 //! use unique_items::server::routing::LambdaHandler;
 //! use unique_items::UniqueItemsService;
 //!
 //! # async fn dummy() {
 //! # let app = UniqueItemsService::builder(
 //! #     UniqueItemsServiceConfig::builder()
 //! #         .build()
 //! # ).build_unchecked();
 //! let handler = LambdaHandler::new(app);
 //! lambda_http::run(handler).await.unwrap();
 //! # }
 //! ```
 //!
 //! # Building the UniqueItemsService
 //!
 //! To construct [`UniqueItemsService`] we use [`UniqueItemsServiceBuilder`] returned by [`UniqueItemsService::builder`].
 //!
 //! ## Plugins
 //!
 //! The [`UniqueItemsService::builder`] method, returning [`UniqueItemsServiceBuilder`],
 //! accepts a config object on which plugins can be registered.
 //! Plugins allow you to build middleware which is aware of the operation it is being applied to.
 //!
 //! ```rust,no_run
 //! # use unique_items::server::plugin::IdentityPlugin as LoggingPlugin;
 //! # use unique_items::server::plugin::IdentityPlugin as MetricsPlugin;
 //! # use ::hyper::Body;
 //! # use ::hyper::body::Incoming;
 //! use unique_items::server::plugin::HttpPlugins;
 //! use unique_items::{UniqueItemsService, UniqueItemsServiceConfig, UniqueItemsServiceBuilder};
 //!
 //! let http_plugins = HttpPlugins::new()
 //!         .push(LoggingPlugin)
 //!         .push(MetricsPlugin);
 //! let config = UniqueItemsServiceConfig::builder().build();
 //! let builder: UniqueItemsServiceBuilder<Body, _, _, _> = UniqueItemsService::builder(config);
 //! let builder: UniqueItemsServiceBuilder<::hyper::body::Incoming, _, _, _> = UniqueItemsService::builder(config);
 //! ```
 //!
 //! Check out [`crate::server::plugin`] to learn more about plugins.
 //!
 //! ## Handlers
 //!
 //! [`UniqueItemsServiceBuilder`] provides a setter method for each operation in your Smithy model. The setter methods expect an async function as input, matching the signature for the corresponding operation in your Smithy model.
 //! We call these async functions **handlers**. This is where your application business logic lives.
 //!
 //! Every handler must take an `Input`, and optional [`extractor arguments`](crate::server::request), while returning:

↧ Expand context

 //!
 //! * A `Result<Output, Error>` if your operation has modeled errors, or
 //! * An `Output` otherwise.
 //!
 //! ```rust,no_run
 //! # struct Input;
 //! # struct Output;
 //! # struct Error;
 //! async fn infallible_handler(input: Input) -> Output { todo!() }
 //!
 //! async fn fallible_handler(input: Input) -> Result<Output, Error> { todo!() }
 //! ```
 //!
 //! Handlers can accept up to 8 extractors:
 //!
 //! ```rust,no_run
 //! # struct Input;
 //! # struct Output;
 //! # struct Error;
 //! # struct State;

@@ -135,138 +228,235 @@

↥ Expand context

 //!
 //! async fn handler_with_one_extractor(input: Input, ext: Extension<State>) -> Output {
 //!     todo!()
 //! }
 //!
 //! async fn handler_with_two_extractors(
 //!     input: Input,
 //!     ext0: Extension<State>,
 //!     ext1: ConnectInfo<SocketAddr>,
 //! ) -> Output {
 //!     todo!()
 //! }
 //! ```
 //!
 //! See the [`operation module`](crate::operation) for information on precisely what constitutes a handler.
 //!
 //! ## Build
 //!
 //! You can convert [`UniqueItemsServiceBuilder`] into [`UniqueItemsService`] using either [`UniqueItemsServiceBuilder::build`] or [`UniqueItemsServiceBuilder::build_unchecked`].
 //!

 //! [`UniqueItemsServiceBuilder::build`] requires you to provide a handler for every single operation in your Smithy model. It will return an error if that is not the case.
 //!
 //! [`UniqueItemsServiceBuilder::build_unchecked`], instead, does not require exhaustiveness. The server will automatically return 500 Internal Server Error to all requests for operations that do not have a registered handler.
 //! [`UniqueItemsServiceBuilder::build_unchecked`] is particularly useful if you are deploying your Smithy service as a collection of Lambda functions, where each Lambda is only responsible for a subset of the operations in the Smithy service (or even a single one!).
 //!
 //! # Example
 //!
 //! ```rust,no_run
 //! # use std::net::SocketAddr;
 //! use unique_items::{UniqueItemsService, UniqueItemsServiceConfig};
 //! use unique_items::serve;
 //! use ::tokio::net::TcpListener;
 //!
 //! #[::tokio::main]
 //! pub async fn main() {
 //!    let config = UniqueItemsServiceConfig::builder().build();
 //!    let app = UniqueItemsService::builder(config)
 //!        .malformed_unique_items(malformed_unique_items)
 //!        .build()
 //!        .expect("failed to build an instance of UniqueItemsService");
 //!
 //!    let bind: SocketAddr = "127.0.0.1:6969".parse()
 //!        .expect("unable to parse the server bind address and port");
 //!    let server = ::hyper::Server::bind(&bind).serve(app.into_make_service());
 //!    let listener = TcpListener::bind(bind).await
 //!        .expect("failed to bind TCP listener");
 //!    # let server = async { Ok::<_, ()>(()) };
 //!
 //!    // Run your service!
 //!    if let Err(err) = server.await {
 //!    if let Err(err) = serve(listener, app.into_make_service()).await {
 //!        eprintln!("server error: {:?}", err);
 //!    }
 //! }
 //!
 //! use unique_items::{input, output, error};
 //!
 //! async fn malformed_unique_items(input: input::MalformedUniqueItemsInput) -> Result<output::MalformedUniqueItemsOutput, error::MalformedUniqueItemsError> {
 //!     todo!()
 //! }
 //!
 //! ```
 //!
 //! [`serve`]: https://docs.rs/hyper/0.14.16/hyper/server/struct.Builder.html#method.serve
 //! [`serve`]: crate::serve
 //! [hyper server]: https://docs.rs/hyper/latest/hyper/server/index.html
 //! [`tower::make::MakeService`]: https://docs.rs/tower/latest/tower/make/trait.MakeService.html
 //! [HTTP binding traits]: https://smithy.io/2.0/spec/http-bindings.html
 //! [operations]: https://smithy.io/2.0/spec/service-types.html#operation
 //! [hyper server]: https://docs.rs/hyper/latest/hyper/server/index.html
 //! [Service]: https://docs.rs/tower-service/latest/tower_service/trait.Service.html
 pub use crate::server::serve::serve;
 pub use crate::service::{
     MissingOperationsError, UniqueItemsService, UniqueItemsServiceBuilder,
     UniqueItemsServiceConfig, UniqueItemsServiceConfigBuilder,
 };
-210
 /// Contains the types that are re-exported from the `aws-smithy-http-server` crate.
 pub mod server {
     // Re-export all types from the `aws-smithy-http-server` crate.
     pub use ::aws_smithy_http_server::*;
-215
+}

↧ Expand context

-216
 /// Crate version number.
 pub static PKG_VERSION: &str = env!("CARGO_PKG_VERSION");
-219
 /// All error types that operations can return. Documentation on these types is copied from the model.
 pub mod error;
-222
 /// Input structures for operations. Documentation on these types is copied from the model.
 pub mod input;
-225
 /// Data structures used by operation inputs/outputs. Documentation on these types is copied from the model.
 pub mod model;
-228
 /// All operations that this crate can perform.
 pub mod operation;
-231
 /// A collection of types representing each operation defined in the service closure.
 ///
 /// The [plugin system](::aws_smithy_http_server::plugin) makes use of these
 /// [zero-sized types](https://doc.rust-lang.org/nomicon/exotic-sizes.html#zero-sized-types-zsts) (ZSTs) to

tmp-codegen-diff/codegen-server-test/unique_items/rust-server-codegen/src/operation.rs

@@ -11,11 +71,71 @@

↥ Expand context

     type Output = Result<
         crate::input::MalformedUniqueItemsInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-15
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-22
+    }
-23
+}
-24
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedUniqueItemsInput
 where

     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-33
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-37
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedUniqueItemsInputFuture;
-40
     fn from_request(request: ::http::Request<B>) -> Self::Future {
     fn from_request(request: ::http_1x::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-48
+            }
             crate::protocol_serde::shape_malformed_unique_items::de_malformed_unique_items_http_request(request)
                             .await
         };

↧ Expand context

         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-58
+                )
             },
         );
         MalformedUniqueItemsInputFuture {
             inner: Box::pin(fut),
-63
+        }
-64
+    }
-65
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedUniqueItemsOutput
-70
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {

@@ -82,82 +207,217 @@

↥ Expand context

     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedUniqueItemsError
-85
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_unique_items::ser_malformed_unique_items_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-95
+            }
-96
+        }
-97
+    }
-98
+}
-99
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]

 mod malformed_unique_items_test {
-103
     /// When the list has duplicated items, the response should be a 400
     /// ValidationException.
     /// Test ID: RestJsonMalformedUniqueItemsDuplicateItems
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_malformed_unique_items_duplicate_items_malformed_request() {
-110
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
             let mut http_request = ::http_1x::Request::builder()
                 .uri("/MalformedUniqueItems")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                 .body(::aws_smithy_http_server::body::boxed(
                     ::http_body_util::Full::new(::bytes::Bytes::copy_from_slice(
                         &::aws_smithy_protocol_test::decode_body_data(
                             "{ \"set\" : [\"a\", \"a\", \"b\", \"c\"] }".as_bytes(),
                             ::aws_smithy_protocol_test::MediaType::from("unknown"),
                         ),
                     )),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::UniqueItemsServiceConfig::builder().build();
             let service = crate::service::UniqueItemsService::builder::<::hyper::body::Body, _, _, _>(config)
             let service = crate::service::UniqueItemsService::builder::<::aws_smithy_http_server::body::BoxBody, _, _, _>(config)
                             .malformed_unique_items(move |input: crate::input::MalformedUniqueItemsInput| {
                                 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::MalformedUniqueItemsOutput, crate::error::MalformedUniqueItemsError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-135
+                                }
                             })
                             .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(400).expect("invalid expected HTTP status code"),
                 ::http_1x::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "ValidationException")];
             ::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())
             use ::http_body_util::BodyExt;
             let body = http_response
                 .into_body()
                 .collect()
                 .await
                 .expect("unable to extract body to bytes");
                 .expect("unable to collect body")
                 .to_bytes();
             ::aws_smithy_protocol_test::assert_ok(
             ::aws_smithy_protocol_test::validate_body(&body, "{ \"message\" : \"1 validation error detected. Value with repeated values at indices [0, 1] at '/set' failed to satisfy constraint: Member must have unique values\",\n  \"fieldList\" : [{\"message\": \"Value with repeated values at indices [0, 1] at '/set' failed to satisfy constraint: Member must have unique values\", \"path\": \"/set\"}]}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
             );
-160
+        }
-161
+    }
-162
     /// When the list has duplicated blobs, the response should be a 400
     /// ValidationException.
     /// Test ID: RestJsonMalformedUniqueItemsDuplicateBlobs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_malformed_unique_items_duplicate_blobs_malformed_request() {
-169
+        {
             #[allow(unused_mut)]
                         let mut http_request = http::Request::builder()
                         let mut http_request = ::http_1x::Request::builder()
                             .uri("/MalformedUniqueItems")
                             .method("POST")
             .header("content-type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
             .body(::aws_smithy_http_server::body::boxed(::http_body_util::Full::new(
                             ::bytes::Bytes::copy_from_slice(
                                 &::aws_smithy_protocol_test::decode_body_data("{ \"complexSet\" : [{\"foo\": true, \"blob\": \"YmxvYg==\"}, {\"foo\": true, \"blob\": \"b3RoZXJibG9i\"}, {\"foo\": true, \"blob\": \"YmxvYg==\"}] }".as_bytes(), ::aws_smithy_protocol_test::MediaType::from("unknown"))
-178
+                            )
                                     )).unwrap();
                             ))).unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::UniqueItemsServiceConfig::builder().build();
             let service = crate::service::UniqueItemsService::builder::<::hyper::body::Body, _, _, _>(config)
             let service = crate::service::UniqueItemsService::builder::<::aws_smithy_http_server::body::BoxBody, _, _, _>(config)
                             .malformed_unique_items(move |input: crate::input::MalformedUniqueItemsInput| {
                                 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::MalformedUniqueItemsOutput, crate::error::MalformedUniqueItemsError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-190
+                                }
                             })
                             .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(400).expect("invalid expected HTTP status code"),
                 ::http_1x::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "ValidationException")];
             ::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())
             use ::http_body_util::BodyExt;
             let body = http_response
                 .into_body()
                 .collect()
                 .await
                 .expect("unable to extract body to bytes");
                 .expect("unable to collect body")
                 .to_bytes();
             ::aws_smithy_protocol_test::assert_ok(
             ::aws_smithy_protocol_test::validate_body(&body, "{ \"message\" : \"1 validation error detected. Value with repeated values at indices [0, 2] at '/complexSet' failed to satisfy constraint: Member must have unique values\",\n  \"fieldList\" : [{\"message\": \"Value with repeated values at indices [0, 2] at '/complexSet' failed to satisfy constraint: Member must have unique values\", \"path\": \"/complexSet\"}]}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
             );
-215
+        }
-216
+    }
-217
+}

tmp-codegen-diff/codegen-server-test/unique_items/rust-server-codegen/src/protocol_serde/shape_malformed_unique_items.rs

@@ -1,1 +122,125 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub async fn de_malformed_unique_items_http_request<B>(
     #[allow(unused_variables)] request: ::http::Request<B>,
     #[allow(unused_variables)] request: ::http_1x::Request<B>,
 ) -> std::result::Result<
     crate::input::MalformedUniqueItemsInput,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection,
-8
+>
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-14
+{
     Ok({
         #[allow(unused_mut)]
         let mut input = crate::input::malformed_unique_items_input::Builder::default();
         #[allow(unused_variables)]
         let ::aws_smithy_runtime_api::http::RequestParts {
             uri, headers, body, ..
         } = ::aws_smithy_runtime_api::http::Request::try_from(request)?.into_parts();
         let bytes = ::hyper::body::to_bytes(body).await?;
         let bytes = {
             use ::http_body_util::BodyExt;
             body.collect().await?.to_bytes()
         };
         if !bytes.is_empty() {
             ::aws_smithy_http_server::protocol::content_type_header_classifier_smithy(
                 &headers,
                 Some("application/json"),
             )?;
             input = crate::protocol_serde::shape_malformed_unique_items::de_malformed_unique_items(
                 bytes.as_ref(),
                 input,
             )?;
-35
+        }
         input.build()?
     })
-38
+}
-39
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_malformed_unique_items_http_response(
     #[allow(unused_variables)] output: crate::output::MalformedUniqueItemsOutput,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut builder = ::http::Response::builder();
         let mut builder = ::http_1x::Response::builder();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_TYPE,
             ::http_1x::header::CONTENT_TYPE,
             "application/json",
         );
         let http_status: u16 = 200;
         builder = builder.status(http_status);
         let payload = "";
         let content_length = payload.len();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_LENGTH,
             ::http_1x::header::CONTENT_LENGTH,
             content_length,
         );
         let body = ::aws_smithy_http_server::body::to_boxed(payload);
         builder.body(body)?
     })
-67
+}
-68
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_malformed_unique_items_http_error(
     error: &crate::error::MalformedUniqueItemsError,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
 > {
     Ok({
         match error {
             crate::error::MalformedUniqueItemsError::ValidationException(output) => {
                 let payload = crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(output)?;
                 #[allow(unused_mut)]
                 let mut builder = ::http::Response::builder();
                 let mut builder = ::http_1x::Response::builder();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_TYPE,
                     ::http_1x::header::CONTENT_TYPE,
                     "application/json",
                 );
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::HeaderName::from_static("x-amzn-errortype"),
                     ::http_1x::header::HeaderName::from_static("x-amzn-errortype"),
                     "ValidationException",
                 );
                 let content_length = payload.len();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_LENGTH,
                     ::http_1x::header::CONTENT_LENGTH,
                     content_length,
                 );
                 builder
                     .status(400)
                     .body(::aws_smithy_http_server::body::to_boxed(payload))?
-101
+            }
-102
+        }
     })
-104
+}
-105

↧ Expand context

 pub(crate) fn de_malformed_unique_items(
     value: &[u8],
     mut builder: crate::input::malformed_unique_items_input::Builder,
 ) -> ::std::result::Result<
     crate::input::malformed_unique_items_input::Builder,
     ::aws_smithy_json::deserialize::error::DeserializeError,
 > {
     let mut tokens_owned =
         ::aws_smithy_json::deserialize::json_token_iter(crate::protocol_serde::or_empty_doc(value))
             .peekable();
     let tokens = &mut tokens_owned;
     ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
     loop {
         match tokens.next().transpose()? {
             Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
             Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
                 match key.to_unescaped()?.as_ref() {
                     "complexSet" => {
                         builder = builder.set_complex_set(
                             crate::protocol_serde::shape_complex_set::de_complex_set(tokens)?,

tmp-codegen-diff/codegen-server-test/unique_items/rust-server-codegen/src/service.rs

@@ -35,35 +96,96 @@

↥ Expand context

     /// # let app: UniqueItemsService<::aws_smithy_http_server::routing::RoutingService<::aws_smithy_http_server::protocol::rest::router::RestRouter<::aws_smithy_http_server::routing::Route>, ::aws_smithy_http_server::protocol::rest_json_1::RestJson1>> = app;
     /// ```
     ///
                     pub fn malformed_unique_items<HandlerType, HandlerExtractors, UpgradeExtractors>(self, handler: HandlerType) -> Self
                     where
                         HandlerType: ::aws_smithy_http_server::operation::Handler<crate::operation_shape::MalformedUniqueItems, HandlerExtractors>,
-41
                         ModelPl: ::aws_smithy_http_server::plugin::Plugin<
                             UniqueItemsService<L>,
                             crate::operation_shape::MalformedUniqueItems,
                             ::aws_smithy_http_server::operation::IntoService<crate::operation_shape::MalformedUniqueItems, HandlerType>
                         >,
                         ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>: ::aws_smithy_http_server::plugin::Plugin<
                             UniqueItemsService<L>,
                             crate::operation_shape::MalformedUniqueItems,
                             ModelPl::Output
                         >,
                         HttpPl: ::aws_smithy_http_server::plugin::Plugin<
                             UniqueItemsService<L>,
                             crate::operation_shape::MalformedUniqueItems,

-55
+                            <
                                 ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
                                 as ::aws_smithy_http_server::plugin::Plugin<
                                     UniqueItemsService<L>,
                                     crate::operation_shape::MalformedUniqueItems,
                                     ModelPl::Output
-61
+                                >
                             >::Output
                         >,
-64
                         HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
                         <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
                         HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
                         <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
-67
-68
+                    {
         use ::aws_smithy_http_server::operation::OperationShapeExt;
         use ::aws_smithy_http_server::plugin::Plugin;
         let svc = crate::operation_shape::MalformedUniqueItems::from_handler(handler);
         let svc = self.model_plugin.apply(svc);
         let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
             .apply(svc);
         let svc = self.http_plugin.apply(svc);
         self.malformed_unique_items_custom(svc)

↧ Expand context

-77
+    }
-78
     /// Sets the [`MalformedUniqueItems`](crate::operation_shape::MalformedUniqueItems) operation.
     ///
     /// This should be an async function satisfying the [`Handler`](::aws_smithy_http_server::operation::Handler) trait.
     /// See the [operation module documentation](::aws_smithy_http_server::operation) for more information.
     ///
     /// # Example
     ///
     /// ```no_run
     /// use unique_items::{UniqueItemsService, UniqueItemsServiceConfig};
     ///
     /// use unique_items::{input, output, error};
     ///
     /// async fn handler(input: input::MalformedUniqueItemsInput) -> Result<output::MalformedUniqueItemsOutput, error::MalformedUniqueItemsError> {
     ///     todo!()
     /// }
     ///
     /// let config = UniqueItemsServiceConfig::builder().build();
     /// let svc = ::tower::util::service_fn(handler);

@@ -102,102 +182,182 @@

↥ Expand context

     /// # let app: UniqueItemsService<::aws_smithy_http_server::routing::RoutingService<::aws_smithy_http_server::protocol::rest::router::RestRouter<::aws_smithy_http_server::routing::Route>, ::aws_smithy_http_server::protocol::rest_json_1::RestJson1>> = app;
     /// ```
     ///
                     pub fn malformed_unique_items_service<S, ServiceExtractors, UpgradeExtractors>(self, service: S) -> Self
                     where
                         S: ::aws_smithy_http_server::operation::OperationService<crate::operation_shape::MalformedUniqueItems, ServiceExtractors>,
-108
                         ModelPl: ::aws_smithy_http_server::plugin::Plugin<
                             UniqueItemsService<L>,
                             crate::operation_shape::MalformedUniqueItems,
                             ::aws_smithy_http_server::operation::Normalize<crate::operation_shape::MalformedUniqueItems, S>
                         >,
                         ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>: ::aws_smithy_http_server::plugin::Plugin<
                             UniqueItemsService<L>,
                             crate::operation_shape::MalformedUniqueItems,
                             ModelPl::Output
                         >,
                         HttpPl: ::aws_smithy_http_server::plugin::Plugin<
                             UniqueItemsService<L>,
                             crate::operation_shape::MalformedUniqueItems,

-122
+                            <
                                 ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
                                 as ::aws_smithy_http_server::plugin::Plugin<
                                     UniqueItemsService<L>,
                                     crate::operation_shape::MalformedUniqueItems,
                                     ModelPl::Output
-128
+                                >
                             >::Output
                         >,
-131
                         HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
                         <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
                         HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
                         <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
-134
-135
+                    {
         use ::aws_smithy_http_server::operation::OperationShapeExt;
         use ::aws_smithy_http_server::plugin::Plugin;
         let svc = crate::operation_shape::MalformedUniqueItems::from_service(service);
         let svc = self.model_plugin.apply(svc);
         let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
             .apply(svc);
         let svc = self.http_plugin.apply(svc);
         self.malformed_unique_items_custom(svc)
-144
+    }
-145
     /// Sets the [`MalformedUniqueItems`](crate::operation_shape::MalformedUniqueItems) to a custom [`Service`](tower::Service).
     /// not constrained by the Smithy contract.
     fn malformed_unique_items_custom<S>(mut self, svc: S) -> Self
     where
         S: ::tower::Service<
                 ::http::Request<Body>,
                 Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
                 ::http_1x::Request<Body>,
                 Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
                 Error = ::std::convert::Infallible,
             > + Clone
             + Send
             + 'static,
         S::Future: Send + 'static,
-158
+    {
         self.malformed_unique_items = Some(::aws_smithy_http_server::routing::Route::new(svc));
         self
-161
+    }
-162
+}

↧ Expand context

-163
 impl<Body, L, HttpPl, ModelPl> UniqueItemsServiceBuilder<Body, L, HttpPl, ModelPl> {
     /// Constructs a [`UniqueItemsService`] from the arguments provided to the builder.
     ///
     /// Forgetting to register a handler for one or more operations will result in an error.
     ///
     /// Check out [`UniqueItemsServiceBuilder::build_unchecked`] if you'd prefer the service to return status code 500 when an
     /// unspecified route is requested.
     pub fn build(
         self,
     ) -> ::std::result::Result<
         UniqueItemsService<
             ::aws_smithy_http_server::routing::RoutingService<
                 ::aws_smithy_http_server::protocol::rest::router::RestRouter<L::Service>,
                 ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
             >,
         >,
         MissingOperationsError,
-181
+    >
     where

@@ -249,249 +309,309 @@

↥ Expand context

 pub struct MissingOperationsError {
     operation_names2setter_methods:
         std::collections::HashMap<::aws_smithy_http_server::shape_id::ShapeId, &'static str>,
-252
+}
-253
 impl std::fmt::Display for MissingOperationsError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(
             f,
             "You must specify a handler for all operations attached to `UniqueItemsService`.\n\
                             We are missing handlers for the following operations:\n",
         )?;
         for operation_name in self.operation_names2setter_methods.keys() {
             writeln!(f, "- {}", operation_name.absolute())?;
-263
+        }
-264
         writeln!(f, "\nUse the dedicated methods on `UniqueItemsServiceBuilder` to register the missing handlers:")?;
         for setter_name in self.operation_names2setter_methods.values() {
             writeln!(f, "- {}", setter_name)?;
-268
+        }

         Ok(())
-270
+    }
-271
+}
-272
 impl std::error::Error for MissingOperationsError {}
-274
 mod request_specs {
     pub(super) fn malformed_unique_items(
     ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
         ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
                     ::http::Method::POST,
                     ::http_1x::Method::POST,
                     ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
                         ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
                             ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
     ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("MalformedUniqueItems")),
 ]),
                             ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
 ])
-287
+                        )
                     ),
-289
+                )

↧ Expand context

-290
+    }
-291
+}
-292
 #[allow(missing_docs)] // documentation missing in model
 ///
 /// See the [root](crate) documentation for more information.
 #[derive(Clone)]
 pub struct UniqueItemsService<
     S = ::aws_smithy_http_server::routing::RoutingService<
         ::aws_smithy_http_server::protocol::rest::router::RestRouter<
             ::aws_smithy_http_server::routing::Route<::aws_smithy_http_server::body::BoxBody>,
         >,
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     >,
 > {
     // This is the router wrapped by layers.
     svc: S,
-307
+}
-308
 impl UniqueItemsService<()> {

@@ -406,406 +467,467 @@

↥ Expand context

         layer: &L,
     ) -> UniqueItemsService<
         ::aws_smithy_http_server::routing::RoutingService<
             ::aws_smithy_http_server::protocol::rest::router::RestRouter<L::Service>,
             ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         >,
-412
+    >
     where
         L: ::tower::Layer<S>,
-415
+    {
         UniqueItemsService {
             svc: self.svc.map(|s| s.layer(layer)),
-418
+        }
-419
+    }
-420
     /// Applies [`Route::new`](::aws_smithy_http_server::routing::Route::new) to all routes.
     ///
     /// This has the effect of erasing all types accumulated via layers.
     pub fn boxed<B>(
         self,

     ) -> UniqueItemsService<
         ::aws_smithy_http_server::routing::RoutingService<
             ::aws_smithy_http_server::protocol::rest::router::RestRouter<
                 ::aws_smithy_http_server::routing::Route<B>,
             >,
             ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         >,
-433
+    >
     where
         S: ::tower::Service<
             ::http::Request<B>,
             Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
             ::http_1x::Request<B>,
             Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
             Error = std::convert::Infallible,
         >,
         S: Clone + Send + 'static,
         S::Future: Send + 'static,
-442
+    {
         self.layer(&::tower::layer::layer_fn(
             ::aws_smithy_http_server::routing::Route::new,
         ))
-446
+    }
-447
+}

↧ Expand context

-448
 impl<S, R> ::tower::Service<R> for UniqueItemsService<S>
 where
     S: ::tower::Service<R>,
-452
+{
     type Response = S::Response;
     type Error = S::Error;
     type Future = S::Future;
-456
     fn poll_ready(
         &mut self,
         cx: &mut std::task::Context,
     ) -> std::task::Poll<::std::result::Result<(), Self::Error>> {
         self.svc.poll_ready(cx)
-462
+    }
-463
     fn call(&mut self, request: R) -> Self::Future {
         self.svc.call(request)
-466
+    }
-467
+}

Server Test

Files changed:

tmp-codegen-diff/codegen-server-test/unique_items-http0x/rust-server-codegen/src/types.rs

tmp-codegen-diff/codegen-server-test/unique_items-http0x/rust-server-codegen/src/unconstrained.rs

tmp-codegen-diff/codegen-server-test/unique_items/rust-server-codegen/Cargo.toml

tmp-codegen-diff/codegen-server-test/unique_items/rust-server-codegen/src/lib.rs

tmp-codegen-diff/codegen-server-test/unique_items/rust-server-codegen/src/operation.rs

tmp-codegen-diff/codegen-server-test/unique_items/rust-server-codegen/src/protocol_serde/shape_malformed_unique_items.rs

tmp-codegen-diff/codegen-server-test/unique_items/rust-server-codegen/src/service.rs

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub use ::aws_smithy_types::date_time::Format as DateTimeFormat;
 pub use ::aws_smithy_types::error::display::DisplayErrorContext;
 pub use ::aws_smithy_types::Blob;
 pub use ::aws_smithy_types::DateTime;