Server Test

tmp-codegen-diff/codegen-server-test/custom-validation-exception-example-http0x/rust-server-codegen/src/lib.rs

@@ -0,1 +0,248 @@

 #![allow(deprecated)]
 #![allow(unknown_lints)]
 #![allow(clippy::module_inception)]
 #![allow(clippy::upper_case_acronyms)]
 #![allow(clippy::large_enum_variant)]
 #![allow(clippy::wrong_self_convention)]
 #![allow(clippy::should_implement_trait)]
 #![allow(clippy::disallowed_names)]
 #![allow(clippy::vec_init_then_push)]
 #![allow(clippy::type_complexity)]
 #![allow(clippy::needless_return)]
 #![allow(clippy::derive_partial_eq_without_eq)]
 #![allow(clippy::result_large_err)]
 #![allow(clippy::unnecessary_map_on_constructor)]
 #![allow(clippy::deprecated_semver)]
 #![allow(clippy::uninlined_format_args)]
 #![allow(rustdoc::bare_urls)]
 #![allow(rustdoc::redundant_explicit_links)]
 #![allow(rustdoc::invalid_html_tags)]
 #![forbid(unsafe_code)]
 #![cfg_attr(docsrs, feature(doc_cfg))]
 //! custom-validation-exception-example-http0x
-+
 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 //! A fast and customizable Rust implementation of the CustomValidationExample Smithy service.
 //!
 //! # Using CustomValidationExample
 //!
 //! The primary entrypoint is [`CustomValidationExample`]: 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 [`CustomValidationExample::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 custom_validation_exception_example_http0x::{CustomValidationExample, CustomValidationExampleConfig};
 //!
 //! # let app = CustomValidationExample::builder(
 //! #     CustomValidationExampleConfig::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();
 //! # }
 //!
 //! ```
 //!
 //! ### Running on Lambda
 //!
 //! ```rust,ignore
 //! use custom_validation_exception_example_http0x::server::routing::LambdaHandler;
 //! use custom_validation_exception_example_http0x::CustomValidationExample;
 //!
 //! # async fn dummy() {
 //! # let app = CustomValidationExample::builder(
 //! #     CustomValidationExampleConfig::builder()
 //! #         .build()
 //! # ).build_unchecked();
 //! let handler = LambdaHandler::new(app);
 //! lambda_http::run(handler).await.unwrap();
 //! # }
 //! ```
 //!
 //! # Building the CustomValidationExample
 //!
 //! To construct [`CustomValidationExample`] we use [`CustomValidationExampleBuilder`] returned by [`CustomValidationExample::builder`].
 //!
 //! ## Plugins
 //!
 //! The [`CustomValidationExample::builder`] method, returning [`CustomValidationExampleBuilder`],
 //! 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 custom_validation_exception_example_http0x::server::plugin::IdentityPlugin as LoggingPlugin;
 //! # use custom_validation_exception_example_http0x::server::plugin::IdentityPlugin as MetricsPlugin;
 //! # use ::hyper::Body;
 //! use custom_validation_exception_example_http0x::server::plugin::HttpPlugins;
 //! use custom_validation_exception_example_http0x::{CustomValidationExample, CustomValidationExampleConfig, CustomValidationExampleBuilder};
 //!
 //! let http_plugins = HttpPlugins::new()
 //!         .push(LoggingPlugin)
 //!         .push(MetricsPlugin);
 //! let config = CustomValidationExampleConfig::builder().build();
 //! let builder: CustomValidationExampleBuilder<::hyper::Body, _, _, _> = CustomValidationExample::builder(config);
 //! ```
 //!
 //! Check out [`crate::server::plugin`] to learn more about plugins.
 //!
 //! ## Handlers
 //!
 //! [`CustomValidationExampleBuilder`] 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:
 //!
 //! * 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;
 //! # use std::net::SocketAddr;
 //! use custom_validation_exception_example_http0x::server::request::{extension::Extension, connect_info::ConnectInfo};
 //!
 //! async fn handler_with_no_extensions(input: Input) -> Output {
 //!     todo!()
 //! }
 //!
 //! 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 [`CustomValidationExampleBuilder`] into [`CustomValidationExample`] using either [`CustomValidationExampleBuilder::build`] or [`CustomValidationExampleBuilder::build_unchecked`].
 //!
 //! [`CustomValidationExampleBuilder::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.
 //!
 //! [`CustomValidationExampleBuilder::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.
 //! [`CustomValidationExampleBuilder::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 custom_validation_exception_example_http0x::{CustomValidationExample, CustomValidationExampleConfig};
 //!
 //! #[::tokio::main]
 //! pub async fn main() {
 //!    let config = CustomValidationExampleConfig::builder().build();
 //!    let app = CustomValidationExample::builder(config)
 //!        .test_operation(test_operation)
 //!        .build()
 //!        .expect("failed to build an instance of CustomValidationExample");
 //!
 //!    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 server = async { Ok::<_, ()>(()) };
 //!
 //!    // Run your service!
 //!    if let Err(err) = server.await {
 //!        eprintln!("server error: {:?}", err);
 //!    }
 //! }
 //!
 //! use custom_validation_exception_example_http0x::{input, output, error};
 //!
 //! async fn test_operation(input: input::TestOperationInput) -> Result<output::TestOperationOutput, error::TestOperationError> {
 //!     todo!()
 //! }
 //!
 //! ```
 //!
 //! [`serve`]: https://docs.rs/hyper/0.14.16/hyper/server/struct.Builder.html#method.serve
 //! [hyper server]: https://docs.rs/hyper/0.14.26/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
 //! [Service]: https://docs.rs/tower-service/latest/tower_service/trait.Service.html
 pub use crate::service::{
     CustomValidationExample, CustomValidationExampleBuilder, CustomValidationExampleConfig,
     CustomValidationExampleConfigBuilder, MissingOperationsError,
 };
-+
 /// 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_legacy_http_server::*;
-+
+}
-+
 /// Crate version number.
 pub static PKG_VERSION: &str = env!("CARGO_PKG_VERSION");
-+
 /// All error types that operations can return. Documentation on these types is copied from the model.
 pub mod error;
-+
 /// Input structures for operations. Documentation on these types is copied from the model.
 pub mod input;
-+
 /// Data structures used by operation inputs/outputs. Documentation on these types is copied from the model.
 pub mod model;
-+
 /// All operations that this crate can perform.
 pub mod operation;
-+
 /// A collection of types representing each operation defined in the service closure.
 ///
 /// The [plugin system](::aws_smithy_legacy_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
 /// parameterize [`Plugin`](::aws_smithy_legacy_http_server::plugin::Plugin) implementations. Their traits, such as
 /// [`OperationShape`](::aws_smithy_legacy_http_server::operation::OperationShape), can be used to provide
 /// operation specific information to the [`Layer`](::tower::Layer) being applied.
 pub mod operation_shape;
-+
 /// Output structures for operations. Documentation on these types is copied from the model.
 pub mod output;
-+
 mod service;
-+
 /// Data primitives referenced by other data types.
 pub mod types;
-+
 /// Constrained types for constrained shapes.
 mod constrained;
-+
 mod mimes;
-+
 pub(crate) mod protocol_serde;

tmp-codegen-diff/codegen-server-test/custom-validation-exception-example-http0x/rust-server-codegen/src/mimes.rs

@@ -0,1 +0,7 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub(crate) static CONTENT_TYPE_APPLICATION_JSON: std::sync::LazyLock<::mime::Mime> =
     std::sync::LazyLock::new(|| {
         "application/json"
             .parse::<::mime::Mime>()
             .expect("BUG: MIME parsing failed, content_type is not valid")
     });

tmp-codegen-diff/codegen-server-test/custom-validation-exception-example-http0x/rust-server-codegen/src/model.rs

@@ -0,1 +0,186 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(missing_docs)] // documentation missing in model
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct CustomValidationField {
     #[allow(missing_docs)] // documentation missing in model
     pub custom_field_name: ::std::string::String,
     #[allow(missing_docs)] // documentation missing in model
     pub custom_field_message: ::std::string::String,
-+
+}
 impl CustomValidationField {
     #[allow(missing_docs)] // documentation missing in model
     pub fn custom_field_name(&self) -> &str {
         use std::ops::Deref;
         self.custom_field_name.deref()
-+
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn custom_field_message(&self) -> &str {
         use std::ops::Deref;
         self.custom_field_message.deref()
-+
+    }
-+
+}
 impl CustomValidationField {
     /// Creates a new builder-style object to manufacture [`CustomValidationField`](crate::model::CustomValidationField).
     pub fn builder() -> crate::model::custom_validation_field::Builder {
         crate::model::custom_validation_field::Builder::default()
-+
+    }
-+
+}
-+
 #[allow(missing_docs)] // documentation missing in model
 #[derive(
     ::std::clone::Clone,
     ::std::cmp::Eq,
     ::std::cmp::Ord,
     ::std::cmp::PartialEq,
     ::std::cmp::PartialOrd,
     ::std::fmt::Debug,
     ::std::hash::Hash,
 )]
 pub enum ValidationExceptionReason {
     #[allow(missing_docs)] // documentation missing in model
     TestReason0,
     #[allow(missing_docs)] // documentation missing in model
     TestReason1,
-+
+}
 /// See [`ValidationExceptionReason`](crate::model::ValidationExceptionReason).
 pub mod validation_exception_reason {
     #[derive(Debug, PartialEq)]
     pub struct ConstraintViolation(pub(crate) ::std::string::String);
-+
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             write!(
                 f,
                 r#"Value provided for 'com.aws.example#ValidationExceptionReason' failed to satisfy constraint: Member must satisfy enum value set: [testReason0, testReason1]"#
-+
+            )
-+
+        }
-+
+    }
-+
     impl ::std::error::Error for ConstraintViolation {}
-+
+}
 impl ::std::convert::TryFrom<&str> for ValidationExceptionReason {
     type Error = crate::model::validation_exception_reason::ConstraintViolation;
     fn try_from(
         s: &str,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<&str>>::Error> {
         match s {
             "testReason0" => Ok(ValidationExceptionReason::TestReason0),
             "testReason1" => Ok(ValidationExceptionReason::TestReason1),
             _ => Err(crate::model::validation_exception_reason::ConstraintViolation(s.to_owned())),
-+
+        }
-+
+    }
-+
+}
 impl ::std::convert::TryFrom<::std::string::String> for ValidationExceptionReason {
     type Error = crate::model::validation_exception_reason::ConstraintViolation;
     fn try_from(
         s: ::std::string::String,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<::std::string::String>>::Error>
-+
+    {
         s.as_str().try_into()
-+
+    }
-+
+}
 impl std::str::FromStr for ValidationExceptionReason {
     type Err = crate::model::validation_exception_reason::ConstraintViolation;
     fn from_str(s: &str) -> std::result::Result<Self, <Self as std::str::FromStr>::Err> {
         Self::try_from(s)
-+
+    }
-+
+}
 impl ValidationExceptionReason {
     /// Returns the `&str` value of the enum member.
     pub fn as_str(&self) -> &str {
         match self {
             ValidationExceptionReason::TestReason0 => "testReason0",
             ValidationExceptionReason::TestReason1 => "testReason1",
-+
+        }
-+
+    }
     /// Returns all the `&str` representations of the enum members.
     pub const fn values() -> &'static [&'static str] {
         &["testReason0", "testReason1"]
-+
+    }
-+
+}
 impl ::std::convert::AsRef<str> for ValidationExceptionReason {
     fn as_ref(&self) -> &str {
         self.as_str()
-+
+    }
-+
+}
 impl crate::constrained::Constrained for ValidationExceptionReason {
     type Unconstrained = ::std::string::String;
-+
+}
-+
 impl ::std::convert::From<::std::string::String>
     for crate::constrained::MaybeConstrained<crate::model::ValidationExceptionReason>
-+
+{
     fn from(value: ::std::string::String) -> Self {
         Self::Unconstrained(value)
-+
+    }
-+
+}
 /// See [`CustomValidationField`](crate::model::CustomValidationField).
 pub mod custom_validation_field {
-+
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
     #[non_exhaustive]
     #[allow(clippy::enum_variant_names)]
     pub enum ConstraintViolation {
         /// `custom_field_name` was not provided but it is required when building `CustomValidationField`.
         MissingCustomFieldName,
         /// `custom_field_message` was not provided but it is required when building `CustomValidationField`.
         MissingCustomFieldMessage,
-+
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingCustomFieldName => write!(f, "`custom_field_name` was not provided but it is required when building `CustomValidationField`"),
                 ConstraintViolation::MissingCustomFieldMessage => write!(f, "`custom_field_message` was not provided but it is required when building `CustomValidationField`"),
-+
+            }
-+
+        }
-+
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ::std::convert::TryFrom<Builder> for crate::model::CustomValidationField {
         type Error = ConstraintViolation;
-+
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-+
+        }
-+
+    }
     /// A builder for [`CustomValidationField`](crate::model::CustomValidationField).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) custom_field_name: ::std::option::Option<::std::string::String>,
         pub(crate) custom_field_message: ::std::option::Option<::std::string::String>,
-+
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn custom_field_name(mut self, input: ::std::string::String) -> Self {
             self.custom_field_name = Some(input);
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn custom_field_message(mut self, input: ::std::string::String) -> Self {
             self.custom_field_message = Some(input);
             self
-+
+        }
         /// Consumes the builder and constructs a [`CustomValidationField`](crate::model::CustomValidationField).
         ///
         /// The builder fails to construct a [`CustomValidationField`](crate::model::CustomValidationField) if a [`ConstraintViolation`] occurs.
         ///
         /// If the builder fails, it will return the _first_ encountered [`ConstraintViolation`].
         pub fn build(self) -> Result<crate::model::CustomValidationField, ConstraintViolation> {
             self.build_enforcing_all_constraints()
-+
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> Result<crate::model::CustomValidationField, ConstraintViolation> {
             Ok(crate::model::CustomValidationField {
                 custom_field_name: self
                     .custom_field_name
                     .ok_or(ConstraintViolation::MissingCustomFieldName)?,
                 custom_field_message: self
                     .custom_field_message
                     .ok_or(ConstraintViolation::MissingCustomFieldMessage)?,
             })
-+
+        }
-+
+    }
-+
+}

tmp-codegen-diff/codegen-server-test/custom-validation-exception-example-http0x/rust-server-codegen/src/operation.rs

@@ -0,1 +0,99 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`TestOperationInput`](crate::input::TestOperationInput) using modelled bindings.
     pub struct TestOperationInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::TestOperationInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for TestOperationInputFuture {
     type Output = Result<
         crate::input::TestOperationInput,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-+
     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)
-+
+    }
-+
+}
-+
 impl<B>
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::TestOperationInput
 where
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = TestOperationInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_test_operation::de_test_operation_http_request(request)
                 .await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         TestOperationInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::TestOperationOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_test_operation::ser_test_operation_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::TestOperationError
-+
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_test_operation::ser_test_operation_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-+
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}

tmp-codegen-diff/codegen-server-test/custom-validation-exception-example-http0x/rust-server-codegen/src/operation_shape.rs

@@ -0,1 +0,38 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(missing_docs)] // documentation missing in model
 pub struct TestOperation;
-+
 impl ::aws_smithy_legacy_http_server::operation::OperationShape for TestOperation {
     const ID: ::aws_smithy_legacy_http_server::shape_id::ShapeId =
         ::aws_smithy_legacy_http_server::shape_id::ShapeId::new(
             "com.aws.example#TestOperation",
             "com.aws.example",
             "TestOperation",
         );
-+
     type Input = crate::input::TestOperationInput;
     type Output = crate::output::TestOperationOutput;
     type Error = crate::error::TestOperationError;
-+
+}
-+
 impl ::aws_smithy_legacy_http_server::instrumentation::sensitivity::Sensitivity for TestOperation {
     type RequestFmt = ::aws_smithy_legacy_http_server::instrumentation::sensitivity::RequestFmt<
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::uri::MakeUri<
             ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
             ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         >,
     >;
     type ResponseFmt = ::aws_smithy_legacy_http_server::instrumentation::sensitivity::ResponseFmt<
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
     >;
-+
     fn request_fmt() -> Self::RequestFmt {
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::RequestFmt::new()
-+
+    }
-+
     fn response_fmt() -> Self::ResponseFmt {
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::ResponseFmt::new()
-+
+    }
-+
+}

tmp-codegen-diff/codegen-server-test/custom-validation-exception-example-http0x/rust-server-codegen/src/output.rs

@@ -0,1 +0,33 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(missing_docs)] // documentation missing in model
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct TestOperationOutput {}
 impl TestOperationOutput {
     /// Creates a new builder-style object to manufacture [`TestOperationOutput`](crate::output::TestOperationOutput).
     pub fn builder() -> crate::output::test_operation_output::Builder {
         crate::output::test_operation_output::Builder::default()
-+
+    }
-+
+}
 /// See [`TestOperationOutput`](crate::output::TestOperationOutput).
 pub mod test_operation_output {
-+
     impl ::std::convert::From<Builder> for crate::output::TestOperationOutput {
         fn from(builder: Builder) -> Self {
             builder.build()
-+
+        }
-+
+    }
     /// A builder for [`TestOperationOutput`](crate::output::TestOperationOutput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {}
     impl Builder {
         /// Consumes the builder and constructs a [`TestOperationOutput`](crate::output::TestOperationOutput).
         pub fn build(self) -> crate::output::TestOperationOutput {
             self.build_enforcing_all_constraints()
-+
+        }
         fn build_enforcing_all_constraints(self) -> crate::output::TestOperationOutput {
             crate::output::TestOperationOutput {}
-+
+        }
-+
+    }
-+
+}

tmp-codegen-diff/codegen-server-test/custom-validation-exception-example-http0x/rust-server-codegen/src/protocol_serde.rs

@@ -0,1 +0,14 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub(crate) mod shape_test_operation;
-+
 pub(crate) mod shape_my_custom_validation_exception;
-+
 pub(crate) fn or_empty_doc(data: &[u8]) -> &[u8] {
     if data.is_empty() {
         b"{}"
     } else {
         data
-+
+    }
-+
+}
-+
 pub(crate) mod shape_custom_validation_field;

tmp-codegen-diff/codegen-server-test/custom-validation-exception-example-http0x/rust-server-codegen/src/protocol_serde/shape_custom_validation_field.rs

@@ -0,1 +0,17 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub fn ser_custom_validation_field(
     object: &mut ::aws_smithy_json::serialize::JsonObjectWriter,
     input: &crate::model::CustomValidationField,
 ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {
-+
+    {
         object
             .key("customFieldName")
             .string(input.custom_field_name.as_str());
-+
+    }
-+
+    {
         object
             .key("customFieldMessage")
             .string(input.custom_field_message.as_str());
-+
+    }
     Ok(())
-+
+}

tmp-codegen-diff/codegen-server-test/custom-validation-exception-example-http0x/rust-server-codegen/src/protocol_serde/shape_my_custom_validation_exception.rs

@@ -0,1 +0,40 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub fn ser_my_custom_validation_exception_error(
     value: &crate::error::MyCustomValidationException,
 ) -> ::std::result::Result<String, ::aws_smithy_types::error::operation::SerializationError> {
     let mut out = ::std::string::String::new();
     let mut object = ::aws_smithy_json::serialize::JsonObjectWriter::new(&mut out);
     crate::protocol_serde::shape_my_custom_validation_exception::ser_my_custom_validation_exception(&mut object, value)?;
     object.finish();
     Ok(out)
-+
+}
-+
 pub fn ser_my_custom_validation_exception(
     object: &mut ::aws_smithy_json::serialize::JsonObjectWriter,
     input: &crate::error::MyCustomValidationException,
 ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {
     if let Some(var_1) = &input.custom_field_list {
         let mut array_2 = object.key("customFieldList").start_array();
         for item_3 in var_1 {
-+
+            {
                 #[allow(unused_mut)]
                 let mut object_4 = array_2.value().start_object();
                 crate::protocol_serde::shape_custom_validation_field::ser_custom_validation_field(
                     &mut object_4,
                     item_3,
                 )?;
                 object_4.finish();
-+
+            }
-+
+        }
         array_2.finish();
-+
+    }
-+
+    {
         object
             .key("customMessage")
             .string(input.custom_message.as_str());
-+
+    }
-+
+    {
         object.key("reason").string(input.reason.as_str());
-+
+    }
     Ok(())
-+
+}

tmp-codegen-diff/codegen-server-test/custom-validation-exception-example-http0x/rust-server-codegen/src/protocol_serde/shape_test_operation.rs

@@ -0,1 +0,160 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub async fn de_test_operation_http_request<B>(
     #[allow(unused_variables)] request: ::http::Request<B>,
 ) -> std::result::Result<
     crate::input::TestOperationInput,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection,
-+
+>
 where
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B::Data: Send,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-+
+{
     Ok({
         #[allow(unused_mut)]
         let mut input = crate::input::test_operation_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?;
         if !bytes.is_empty() {
             ::aws_smithy_legacy_http_server::protocol::content_type_header_classifier_smithy(
                 &headers,
                 Some("application/json"),
             )?;
             input = crate::protocol_serde::shape_test_operation::de_test_operation(
                 bytes.as_ref(),
                 input,
             )?;
-+
+        }
         input.build()?
     })
-+
+}
-+
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_test_operation_http_response(
     #[allow(unused_variables)] output: crate::output::TestOperationOutput,
 ) -> std::result::Result<
     ::aws_smithy_legacy_http_server::response::Response,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut builder = ::http::Response::builder();
         builder = ::aws_smithy_legacy_http::header::set_response_header_if_absent(
             builder,
             ::http::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_legacy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_LENGTH,
             content_length,
         );
         let body = ::aws_smithy_legacy_http_server::body::to_boxed(payload);
         builder.body(body)?
     })
-+
+}
-+
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_test_operation_http_error(
     error: &crate::error::TestOperationError,
 ) -> std::result::Result<
     ::aws_smithy_legacy_http_server::response::Response,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
 > {
     Ok({
         match error {
             crate::error::TestOperationError::MyCustomValidationException(output) => {
                 let payload = crate::protocol_serde::shape_my_custom_validation_exception::ser_my_custom_validation_exception_error(output)?;
                 #[allow(unused_mut)]
                 let mut builder = ::http::Response::builder();
                 builder = ::aws_smithy_legacy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_TYPE,
                     "application/json",
                 );
                 builder = ::aws_smithy_legacy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::HeaderName::from_static("x-amzn-errortype"),
                     "MyCustomValidationException",
                 );
                 let content_length = payload.len();
                 builder = ::aws_smithy_legacy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_LENGTH,
                     content_length,
                 );
                 builder
                     .status(400)
                     .body(::aws_smithy_legacy_http_server::body::to_boxed(payload))?
-+
+            }
-+
+        }
     })
-+
+}
-+
 pub(crate) fn de_test_operation(
     value: &[u8],
     mut builder: crate::input::test_operation_input::Builder,
 ) -> ::std::result::Result<
     crate::input::test_operation_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() {
                     "age" => {
                         builder = builder.set_age(
                             ::aws_smithy_json::deserialize::token::expect_number_or_null(
                                 tokens.next(),
                             )?
                             .map(i32::try_from)
                             .transpose()?,
                         );
-+
+                    }
                     "name" => {
                         if let Some(v) =
                             ::aws_smithy_json::deserialize::token::expect_string_or_null(
                                 tokens.next(),
                             )?
                             .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                             .transpose()?
-+
+                        {
                             builder = builder.set_name(v);
-+
+                        }
-+
+                    }
                     _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
-+
+                }
-+
+            }
             other => {
                 return Err(
                     ::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
                         "expected object key or end object, found: {other:?}"
                     )),
-+
+                )
-+
+            }
-+
+        }
-+
+    }
     if tokens.next().is_some() {
         return Err(
             ::aws_smithy_json::deserialize::error::DeserializeError::custom(
                 "found more JSON tokens after completing parsing",
             ),
         );
-+
+    }
     Ok(builder)
-+
+}

tmp-codegen-diff/codegen-server-test/custom-validation-exception-example-http0x/rust-server-codegen/src/service.rs

@@ -0,1 +0,731 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// The service builder for [`CustomValidationExample`].
 ///
 /// Constructed via [`CustomValidationExample::builder`].
 pub struct CustomValidationExampleBuilder<Body, L, HttpPl, ModelPl> {
     test_operation: Option<::aws_smithy_legacy_http_server::routing::Route<Body>>,
     layer: L,
     http_plugin: HttpPl,
     model_plugin: ModelPl,
-+
+}
-+
 impl<Body, L, HttpPl, ModelPl> CustomValidationExampleBuilder<Body, L, HttpPl, ModelPl> {
     /// Sets the [`TestOperation`](crate::operation_shape::TestOperation) operation.
     ///
     /// This should be an async function satisfying the [`Handler`](::aws_smithy_legacy_http_server::operation::Handler) trait.
     /// See the [operation module documentation](::aws_smithy_legacy_http_server::operation) for more information.
     ///
     /// # Example
     ///
     /// ```no_run
     /// use custom_validation_exception_example_http0x::{CustomValidationExample, CustomValidationExampleConfig};
     ///
     /// use custom_validation_exception_example_http0x::{input, output, error};
     ///
     /// async fn handler(input: input::TestOperationInput) -> Result<output::TestOperationOutput, error::TestOperationError> {
     ///     todo!()
     /// }
     ///
     /// let config = CustomValidationExampleConfig::builder().build();
     /// let app = CustomValidationExample::builder(config)
     ///     .test_operation(handler)
     ///     /* Set other handlers */
     ///     .build()
     ///     .unwrap();
     /// # let app: CustomValidationExample<::aws_smithy_legacy_http_server::routing::RoutingService<::aws_smithy_legacy_http_server::protocol::rest::router::RestRouter<::aws_smithy_legacy_http_server::routing::Route>, ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>> = app;
     /// ```
     ///
                     pub fn test_operation<HandlerType, HandlerExtractors, UpgradeExtractors>(self, handler: HandlerType) -> Self
                     where
                         HandlerType: ::aws_smithy_legacy_http_server::operation::Handler<crate::operation_shape::TestOperation, HandlerExtractors>,
-+
                         ModelPl: ::aws_smithy_legacy_http_server::plugin::Plugin<
                             CustomValidationExample<L>,
                             crate::operation_shape::TestOperation,
                             ::aws_smithy_legacy_http_server::operation::IntoService<crate::operation_shape::TestOperation, HandlerType>
                         >,
                         ::aws_smithy_legacy_http_server::operation::UpgradePlugin::<UpgradeExtractors>: ::aws_smithy_legacy_http_server::plugin::Plugin<
                             CustomValidationExample<L>,
                             crate::operation_shape::TestOperation,
                             ModelPl::Output
                         >,
                         HttpPl: ::aws_smithy_legacy_http_server::plugin::Plugin<
                             CustomValidationExample<L>,
                             crate::operation_shape::TestOperation,
-+
+                            <
                                 ::aws_smithy_legacy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
                                 as ::aws_smithy_legacy_http_server::plugin::Plugin<
                                     CustomValidationExample<L>,
                                     crate::operation_shape::TestOperation,
                                     ModelPl::Output
-+
+                                >
                             >::Output
                         >,
-+
                         HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_legacy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
                         <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
-+
-+
+                    {
         use ::aws_smithy_legacy_http_server::operation::OperationShapeExt;
         use ::aws_smithy_legacy_http_server::plugin::Plugin;
         let svc = crate::operation_shape::TestOperation::from_handler(handler);
         let svc = self.model_plugin.apply(svc);
         let svc =
             ::aws_smithy_legacy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
                 .apply(svc);
         let svc = self.http_plugin.apply(svc);
         self.test_operation_custom(svc)
-+
+    }
-+
     /// Sets the [`TestOperation`](crate::operation_shape::TestOperation) operation.
     ///
     /// This should be an async function satisfying the [`Handler`](::aws_smithy_legacy_http_server::operation::Handler) trait.
     /// See the [operation module documentation](::aws_smithy_legacy_http_server::operation) for more information.
     ///
     /// # Example
     ///
     /// ```no_run
     /// use custom_validation_exception_example_http0x::{CustomValidationExample, CustomValidationExampleConfig};
     ///
     /// use custom_validation_exception_example_http0x::{input, output, error};
     ///
     /// async fn handler(input: input::TestOperationInput) -> Result<output::TestOperationOutput, error::TestOperationError> {
     ///     todo!()
     /// }
     ///
     /// let config = CustomValidationExampleConfig::builder().build();
     /// let svc = ::tower::util::service_fn(handler);
     /// let app = CustomValidationExample::builder(config)
     ///     .test_operation_service(svc)
     ///     /* Set other handlers */
     ///     .build()
     ///     .unwrap();
     /// # let app: CustomValidationExample<::aws_smithy_legacy_http_server::routing::RoutingService<::aws_smithy_legacy_http_server::protocol::rest::router::RestRouter<::aws_smithy_legacy_http_server::routing::Route>, ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>> = app;
     /// ```
     ///
                     pub fn test_operation_service<S, ServiceExtractors, UpgradeExtractors>(self, service: S) -> Self
                     where
                         S: ::aws_smithy_legacy_http_server::operation::OperationService<crate::operation_shape::TestOperation, ServiceExtractors>,
-+
                         ModelPl: ::aws_smithy_legacy_http_server::plugin::Plugin<
                             CustomValidationExample<L>,
                             crate::operation_shape::TestOperation,
                             ::aws_smithy_legacy_http_server::operation::Normalize<crate::operation_shape::TestOperation, S>
                         >,
                         ::aws_smithy_legacy_http_server::operation::UpgradePlugin::<UpgradeExtractors>: ::aws_smithy_legacy_http_server::plugin::Plugin<
                             CustomValidationExample<L>,
                             crate::operation_shape::TestOperation,
                             ModelPl::Output
                         >,
                         HttpPl: ::aws_smithy_legacy_http_server::plugin::Plugin<
                             CustomValidationExample<L>,
                             crate::operation_shape::TestOperation,
-+
+                            <
                                 ::aws_smithy_legacy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
                                 as ::aws_smithy_legacy_http_server::plugin::Plugin<
                                     CustomValidationExample<L>,
                                     crate::operation_shape::TestOperation,
                                     ModelPl::Output
-+
+                                >
                             >::Output
                         >,
-+
                         HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_legacy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
                         <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
-+
-+
+                    {
         use ::aws_smithy_legacy_http_server::operation::OperationShapeExt;
         use ::aws_smithy_legacy_http_server::plugin::Plugin;
         let svc = crate::operation_shape::TestOperation::from_service(service);
         let svc = self.model_plugin.apply(svc);
         let svc =
             ::aws_smithy_legacy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
                 .apply(svc);
         let svc = self.http_plugin.apply(svc);
         self.test_operation_custom(svc)
-+
+    }
-+
     /// Sets the [`TestOperation`](crate::operation_shape::TestOperation) to a custom [`Service`](tower::Service).
     /// not constrained by the Smithy contract.
     fn test_operation_custom<S>(mut self, svc: S) -> Self
     where
         S: ::tower::Service<
                 ::http::Request<Body>,
                 Response = ::http::Response<::aws_smithy_legacy_http_server::body::BoxBody>,
                 Error = ::std::convert::Infallible,
             > + Clone
             + Send
             + 'static,
         S::Future: Send + 'static,
-+
+    {
         self.test_operation = Some(::aws_smithy_legacy_http_server::routing::Route::new(svc));
         self
-+
+    }
-+
+}
-+
 impl<Body, L, HttpPl, ModelPl> CustomValidationExampleBuilder<Body, L, HttpPl, ModelPl> {
     /// Constructs a [`CustomValidationExample`] from the arguments provided to the builder.
     ///
     /// Forgetting to register a handler for one or more operations will result in an error.
     ///
     /// Check out [`CustomValidationExampleBuilder::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<
         CustomValidationExample<
             ::aws_smithy_legacy_http_server::routing::RoutingService<
                 ::aws_smithy_legacy_http_server::protocol::rest::router::RestRouter<L::Service>,
                 ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
             >,
         >,
         MissingOperationsError,
-+
+    >
     where
         L: ::tower::Layer<::aws_smithy_legacy_http_server::routing::Route<Body>>,
-+
+    {
         let router = {
             use ::aws_smithy_legacy_http_server::operation::OperationShape;
             let mut missing_operation_names = std::collections::HashMap::new();
             if self.test_operation.is_none() {
                 missing_operation_names.insert(
                     crate::operation_shape::TestOperation::ID,
                     ".test_operation()",
                 );
-+
+            }
             if !missing_operation_names.is_empty() {
                 return Err(MissingOperationsError {
                     operation_names2setter_methods: missing_operation_names,
                 });
-+
+            }
             let unexpected_error_msg = "this should never panic since we are supposed to check beforehand that a handler has been registered for this operation; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues";
-+
             ::aws_smithy_legacy_http_server::protocol::rest::router::RestRouter::from_iter([(
                 request_specs::test_operation(),
                 self.test_operation.expect(unexpected_error_msg),
             )])
         };
         let svc = ::aws_smithy_legacy_http_server::routing::RoutingService::new(router);
         let svc = svc.map(|s| s.layer(self.layer));
         Ok(CustomValidationExample { svc })
-+
+    }
-+
     /// Constructs a [`CustomValidationExample`] from the arguments provided to the builder.
     /// Operations without a handler default to returning 500 Internal Server Error to the caller.
     ///
     /// Check out [`CustomValidationExampleBuilder::build`] if you'd prefer the builder to fail if one or more operations do
     /// not have a registered handler.
     pub fn build_unchecked(self) -> CustomValidationExample<L::Service>
     where
         Body: Send + 'static,
         L: ::tower::Layer<
             ::aws_smithy_legacy_http_server::routing::RoutingService<
                 ::aws_smithy_legacy_http_server::protocol::rest::router::RestRouter<
                     ::aws_smithy_legacy_http_server::routing::Route<Body>,
                 >,
                 ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
             >,
         >,
-+
+    {
         let router =
             ::aws_smithy_legacy_http_server::protocol::rest::router::RestRouter::from_iter([(
                 request_specs::test_operation(),
                 self.test_operation.unwrap_or_else(|| {
                     let svc = ::aws_smithy_legacy_http_server::operation::MissingFailure::<
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
                     >::default();
                     ::aws_smithy_legacy_http_server::routing::Route::new(svc)
                 }),
             )]);
         let svc = self
             .layer
             .layer(::aws_smithy_legacy_http_server::routing::RoutingService::new(router));
         CustomValidationExample { svc }
-+
+    }
-+
+}
-+
 /// The error encountered when calling the [`CustomValidationExampleBuilder::build`] method if one or more operation handlers are not
 /// specified.
 #[derive(Debug)]
 pub struct MissingOperationsError {
     operation_names2setter_methods:
         std::collections::HashMap<::aws_smithy_legacy_http_server::shape_id::ShapeId, &'static str>,
-+
+}
-+
 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 `CustomValidationExample`.\n\
                             We are missing handlers for the following operations:\n",
                         )?;
         for operation_name in self.operation_names2setter_methods.keys() {
             writeln!(f, "- {}", operation_name.absolute())?;
-+
+        }
-+
         writeln!(f, "\nUse the dedicated methods on `CustomValidationExampleBuilder` to register the missing handlers:")?;
         for setter_name in self.operation_names2setter_methods.values() {
             writeln!(f, "- {}", setter_name)?;
-+
+        }
         Ok(())
-+
+    }
-+
+}
-+
 impl std::error::Error for MissingOperationsError {}
-+
 mod request_specs {
     pub(super) fn test_operation(
     ) -> ::aws_smithy_legacy_http_server::routing::request_spec::RequestSpec {
         ::aws_smithy_legacy_http_server::routing::request_spec::RequestSpec::new(
                     ::http::Method::POST,
                     ::aws_smithy_legacy_http_server::routing::request_spec::UriSpec::new(
                         ::aws_smithy_legacy_http_server::routing::request_spec::PathAndQuerySpec::new(
                             ::aws_smithy_legacy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
     ::aws_smithy_legacy_http_server::routing::request_spec::PathSegment::Literal(String::from("test")),
 ]),
                             ::aws_smithy_legacy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
 ])
-+
+                        )
                     ),
-+
+                )
-+
+    }
-+
+}
-+
 #[allow(missing_docs)] // documentation missing in model
 ///
 /// See the [root](crate) documentation for more information.
 #[derive(Clone)]
 pub struct CustomValidationExample<
     S = ::aws_smithy_legacy_http_server::routing::RoutingService<
         ::aws_smithy_legacy_http_server::protocol::rest::router::RestRouter<
             ::aws_smithy_legacy_http_server::routing::Route<
                 ::aws_smithy_legacy_http_server::body::BoxBody,
             >,
         >,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     >,
 > {
     // This is the router wrapped by layers.
     svc: S,
-+
+}
-+
 impl CustomValidationExample<()> {
     /// Constructs a builder for [`CustomValidationExample`].
     /// You must specify a configuration object holding any plugins and layers that should be applied
     /// to the operations in this service.
     pub fn builder<
         Body,
         L,
         HttpPl: ::aws_smithy_legacy_http_server::plugin::HttpMarker,
         ModelPl: ::aws_smithy_legacy_http_server::plugin::ModelMarker,
     >(
         config: CustomValidationExampleConfig<L, HttpPl, ModelPl>,
     ) -> CustomValidationExampleBuilder<Body, L, HttpPl, ModelPl> {
         CustomValidationExampleBuilder {
             test_operation: None,
             layer: config.layers,
             http_plugin: config.http_plugins,
             model_plugin: config.model_plugins,
-+
+        }
-+
+    }
-+
     /// Constructs a builder for [`CustomValidationExample`].
     /// You must specify what plugins should be applied to the operations in this service.
     ///
     /// Use [`CustomValidationExample::builder_without_plugins`] if you don't need to apply plugins.
     ///
     /// Check out [`HttpPlugins`](::aws_smithy_legacy_http_server::plugin::HttpPlugins) and
     /// [`ModelPlugins`](::aws_smithy_legacy_http_server::plugin::ModelPlugins) if you need to apply
     /// multiple plugins.
     #[deprecated(
         since = "0.57.0",
         note = "please use the `builder` constructor and register plugins on the `CustomValidationExampleConfig` object instead; see https://github.com/smithy-lang/smithy-rs/discussions/3096"
     )]
     pub fn builder_with_plugins<
         Body,
         HttpPl: ::aws_smithy_legacy_http_server::plugin::HttpMarker,
         ModelPl: ::aws_smithy_legacy_http_server::plugin::ModelMarker,
     >(
         http_plugin: HttpPl,
         model_plugin: ModelPl,
     ) -> CustomValidationExampleBuilder<Body, ::tower::layer::util::Identity, HttpPl, ModelPl> {
         CustomValidationExampleBuilder {
             test_operation: None,
             layer: ::tower::layer::util::Identity::new(),
             http_plugin,
             model_plugin,
-+
+        }
-+
+    }
-+
     /// Constructs a builder for [`CustomValidationExample`].
     ///
     /// Use [`CustomValidationExample::builder_with_plugins`] if you need to specify plugins.
     #[deprecated(
         since = "0.57.0",
         note = "please use the `builder` constructor instead; see https://github.com/smithy-lang/smithy-rs/discussions/3096"
     )]
     pub fn builder_without_plugins<Body>() -> CustomValidationExampleBuilder<
         Body,
         ::tower::layer::util::Identity,
         ::aws_smithy_legacy_http_server::plugin::IdentityPlugin,
         ::aws_smithy_legacy_http_server::plugin::IdentityPlugin,
     > {
         Self::builder_with_plugins(
             ::aws_smithy_legacy_http_server::plugin::IdentityPlugin,
             ::aws_smithy_legacy_http_server::plugin::IdentityPlugin,
-+
+        )
-+
+    }
-+
+}
-+
 impl<S> CustomValidationExample<S> {
     /// Converts [`CustomValidationExample`] into a [`MakeService`](tower::make::MakeService).
     pub fn into_make_service(
         self,
     ) -> ::aws_smithy_legacy_http_server::routing::IntoMakeService<Self> {
         ::aws_smithy_legacy_http_server::routing::IntoMakeService::new(self)
-+
+    }
-+
     /// Converts [`CustomValidationExample`] into a [`MakeService`](tower::make::MakeService) with [`ConnectInfo`](::aws_smithy_legacy_http_server::request::connect_info::ConnectInfo).
     pub fn into_make_service_with_connect_info<C>(
         self,
     ) -> ::aws_smithy_legacy_http_server::routing::IntoMakeServiceWithConnectInfo<Self, C> {
         ::aws_smithy_legacy_http_server::routing::IntoMakeServiceWithConnectInfo::new(self)
-+
+    }
-+
+}
-+
 impl<S>
     CustomValidationExample<
         ::aws_smithy_legacy_http_server::routing::RoutingService<
             ::aws_smithy_legacy_http_server::protocol::rest::router::RestRouter<S>,
             ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         >,
-+
+    >
-+
+{
     /// Applies a [`Layer`](::tower::Layer) uniformly to all routes.
     #[deprecated(
         since = "0.57.0",
         note = "please add layers to the `CustomValidationExampleConfig` object instead; see https://github.com/smithy-lang/smithy-rs/discussions/3096"
     )]
     pub fn layer<L>(
         self,
         layer: &L,
     ) -> CustomValidationExample<
         ::aws_smithy_legacy_http_server::routing::RoutingService<
             ::aws_smithy_legacy_http_server::protocol::rest::router::RestRouter<L::Service>,
             ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         >,
-+
+    >
     where
         L: ::tower::Layer<S>,
-+
+    {
         CustomValidationExample {
             svc: self.svc.map(|s| s.layer(layer)),
-+
+        }
-+
+    }
-+
     /// Applies [`Route::new`](::aws_smithy_legacy_http_server::routing::Route::new) to all routes.
     ///
     /// This has the effect of erasing all types accumulated via layers.
     pub fn boxed<B>(
         self,
     ) -> CustomValidationExample<
         ::aws_smithy_legacy_http_server::routing::RoutingService<
             ::aws_smithy_legacy_http_server::protocol::rest::router::RestRouter<
                 ::aws_smithy_legacy_http_server::routing::Route<B>,
             >,
             ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         >,
-+
+    >
     where
         S: ::tower::Service<
             ::http::Request<B>,
             Response = ::http::Response<::aws_smithy_legacy_http_server::body::BoxBody>,
             Error = std::convert::Infallible,
         >,
         S: Clone + Send + 'static,
         S::Future: Send + 'static,
-+
+    {
         self.layer(&::tower::layer::layer_fn(
             ::aws_smithy_legacy_http_server::routing::Route::new,
         ))
-+
+    }
-+
+}
-+
 impl<S, R> ::tower::Service<R> for CustomValidationExample<S>
 where
     S: ::tower::Service<R>,
-+
+{
     type Response = S::Response;
     type Error = S::Error;
     type Future = S::Future;
-+
     fn poll_ready(
         &mut self,
         cx: &mut std::task::Context,
     ) -> std::task::Poll<::std::result::Result<(), Self::Error>> {
         self.svc.poll_ready(cx)
-+
+    }
-+
     fn call(&mut self, request: R) -> Self::Future {
         self.svc.call(request)
-+
+    }
-+
+}
-+
 /// An enumeration of all [operations](https://smithy.io/2.0/spec/service-types.html#operation) in CustomValidationExample.
 #[allow(clippy::enum_variant_names)]
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub enum Operation {
     TestOperation,
-+
+}
-+
 impl Operation {
     /// Returns the [operations](https://smithy.io/2.0/spec/service-types.html#operation) [`ShapeId`](::aws_smithy_legacy_http_server::shape_id::ShapeId).
     pub fn shape_id(&self) -> ::aws_smithy_legacy_http_server::shape_id::ShapeId {
         match self {
             Operation::TestOperation => ::aws_smithy_legacy_http_server::shape_id::ShapeId::new(
                 "com.aws.example#TestOperation",
                 "com.aws.example",
                 "TestOperation",
             ),
-+
+        }
-+
+    }
-+
+}
 impl<L>
     ::aws_smithy_legacy_http_server::service::ContainsOperation<
         crate::operation_shape::TestOperation,
     > for CustomValidationExample<L>
-+
+{
     const VALUE: Operation = Operation::TestOperation;
-+
+}
-+
 impl<S> ::aws_smithy_legacy_http_server::service::ServiceShape for CustomValidationExample<S> {
     const ID: ::aws_smithy_legacy_http_server::shape_id::ShapeId =
         ::aws_smithy_legacy_http_server::shape_id::ShapeId::new(
             "com.aws.example#CustomValidationExample",
             "com.aws.example",
             "CustomValidationExample",
         );
-+
     const VERSION: Option<&'static str> = Some("1.0.0");
-+
     type Protocol = ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1;
-+
     type Operations = Operation;
-+
+}
 /// Configuration for the [`CustomValidationExample`]. This is the central place where to register and
 /// configure [`::tower::Layer`]s, HTTP plugins, and model plugins.
 ///
 /// ```rust,no_run
 /// # use custom_validation_exception_example_http0x::CustomValidationExampleConfig;
 /// # use ::aws_smithy_legacy_http_server::plugin::IdentityPlugin;
 /// # use ::tower::layer::util::Identity;
 /// # let authentication_plugin = IdentityPlugin;
 /// # let authorization_plugin = IdentityPlugin;
 /// # let server_request_id_provider_layer = Identity::new();
 /// let config = CustomValidationExampleConfig::builder()
 ///     // Layers get executed first...
 ///     .layer(server_request_id_provider_layer)
 ///     // ...then HTTP plugins...
 ///     .http_plugin(authentication_plugin)
 ///     // ...and right after deserialization, model plugins.
 ///     .model_plugin(authorization_plugin)
 ///     .build();
 /// ```
 ///
 /// See the [`plugin`] system for details.
 ///
 /// [`plugin`]: ::aws_smithy_legacy_http_server::plugin
 #[derive(::std::fmt::Debug)]
 pub struct CustomValidationExampleConfig<L, H, M> {
     layers: L,
     http_plugins: H,
     model_plugins: M,
-+
+}
-+
 impl CustomValidationExampleConfig<(), (), ()> {
     /// Returns a builder to construct the configuration.
     pub fn builder() -> CustomValidationExampleConfigBuilder<
         ::tower::layer::util::Identity,
         ::aws_smithy_legacy_http_server::plugin::IdentityPlugin,
         ::aws_smithy_legacy_http_server::plugin::IdentityPlugin,
     > {
         CustomValidationExampleConfigBuilder {
             layers: ::tower::layer::util::Identity::new(),
             http_plugins: ::aws_smithy_legacy_http_server::plugin::IdentityPlugin,
             model_plugins: ::aws_smithy_legacy_http_server::plugin::IdentityPlugin,
-+
+        }
-+
+    }
-+
+}
-+
 /// Builder returned by [`CustomValidationExampleConfig::builder()`].
 #[derive(::std::fmt::Debug)]
 pub struct CustomValidationExampleConfigBuilder<L, H, M> {
     pub(crate) layers: L,
     pub(crate) http_plugins: H,
     pub(crate) model_plugins: M,
-+
+}
-+
 impl<L, H, M> CustomValidationExampleConfigBuilder<L, H, M> {
     /// Add a [`::tower::Layer`] to the service.
     pub fn layer<NewLayer>(
         self,
         layer: NewLayer,
     ) -> CustomValidationExampleConfigBuilder<::tower::layer::util::Stack<NewLayer, L>, H, M> {
         CustomValidationExampleConfigBuilder {
             layers: ::tower::layer::util::Stack::new(layer, self.layers),
             http_plugins: self.http_plugins,
             model_plugins: self.model_plugins,
-+
+        }
-+
+    }
-+
     /// Add a HTTP [plugin] to the service.
     ///
     /// [plugin]: ::aws_smithy_legacy_http_server::plugin
     // We eagerly require `NewPlugin: HttpMarker`, despite not really needing it, because compiler
     // errors get _substantially_ better if the user makes a mistake.
     pub fn http_plugin<NewPlugin: ::aws_smithy_legacy_http_server::plugin::HttpMarker>(
         self,
         http_plugin: NewPlugin,
     ) -> CustomValidationExampleConfigBuilder<
         L,
         ::aws_smithy_legacy_http_server::plugin::PluginStack<NewPlugin, H>,
         M,
     > {
         CustomValidationExampleConfigBuilder {
             layers: self.layers,
             http_plugins: ::aws_smithy_legacy_http_server::plugin::PluginStack::new(
                 http_plugin,
                 self.http_plugins,
             ),
             model_plugins: self.model_plugins,
-+
+        }
-+
+    }
-+
     /// Add a model [plugin] to the service.
     ///
     /// [plugin]: ::aws_smithy_legacy_http_server::plugin
     // We eagerly require `NewPlugin: ModelMarker`, despite not really needing it, because compiler
     // errors get _substantially_ better if the user makes a mistake.
     pub fn model_plugin<NewPlugin: ::aws_smithy_legacy_http_server::plugin::ModelMarker>(
         self,
         model_plugin: NewPlugin,
     ) -> CustomValidationExampleConfigBuilder<
         L,
         H,
         ::aws_smithy_legacy_http_server::plugin::PluginStack<NewPlugin, M>,
     > {
         CustomValidationExampleConfigBuilder {
             layers: self.layers,
             http_plugins: self.http_plugins,
             model_plugins: ::aws_smithy_legacy_http_server::plugin::PluginStack::new(
                 model_plugin,
                 self.model_plugins,
             ),
-+
+        }
-+
+    }
-+
     /// Build the configuration.
     pub fn build(self) -> super::CustomValidationExampleConfig<L, H, M> {
         super::CustomValidationExampleConfig {
             layers: self.layers,
             http_plugins: self.http_plugins,
             model_plugins: self.model_plugins,
-+
+        }
-+
+    }
-+
+}
 /// A macro to help with scoping [plugins](crate::server::plugin) to a subset of all operations.
 ///
 /// In contrast to [`crate::server::scope`](crate::server::scope), this macro has knowledge
 /// of the service and any operations _not_ specified will be placed in the opposing group.
 ///
 /// # Example
 ///
 /// ```rust
 /// scope! {
 ///     /// Includes [`TestOperation`], excluding all other operations.
 ///     struct ScopeA {
 ///         includes: [TestOperation]
 ///     }
 /// }
 ///
 /// scope! {
 ///     /// Excludes [`TestOperation`], excluding all other operations.
 ///     struct ScopeB {
 ///         excludes: [TestOperation]
 ///     }
 /// }
 ///
 /// # use custom_validation_exception_example_http0x::server::plugin::{Plugin, Scoped};
 /// # use custom_validation_exception_example_http0x::scope;
 /// # struct MockPlugin;
 /// # impl<S, Op, T> Plugin<S, Op, T> for MockPlugin { type Output = u32; fn apply(&self, input: T) -> u32 { 3 } }
 /// # let scoped_a = Scoped::new::<ScopeA>(MockPlugin);
 /// # let scoped_b = Scoped::new::<ScopeB>(MockPlugin);
 /// # let a = Plugin::<(), custom_validation_exception_example_http0x::operation_shape::TestOperation, u64>::apply(&scoped_a, 6);
 /// # let b = Plugin::<(), custom_validation_exception_example_http0x::operation_shape::TestOperation, u64>::apply(&scoped_b, 6);
 /// # assert_eq!(a, 3_u32);
 /// # assert_eq!(b, 6_u64);
 /// ```
 #[macro_export]
 macro_rules! scope {
                     // Completed, render impls
                     (@ $ name: ident, $ contains: ident () ($($ temp: ident)*) ($($ not_member: ident)*)) => {
                         $(
                             impl $ crate::server::plugin::scoped::Membership<$ temp> for $ name {
                                 type Contains = $ crate::server::plugin::scoped::$ contains;
-+
+                            }
                         )*
                         $(
                             impl $ crate::server::plugin::scoped::Membership<$ not_member> for $ name {
                                 type Contains = $ crate::server::plugin::scoped::$ contains;
-+
+                            }
                         )*
                     };
                     // All `not_member`s exhausted, move `temp` into `not_member`
                     (@ $ name: ident, $ contains: ident ($($ member: ident)*) ($($ temp: ident)*) ()) => {
                         scope! { @ $ name, $ contains ($($ member)*) () ($($ temp)*) }
                     };
-+
                         // TestOperation match found, pop from both `member` and `not_member`
                         (@ $ name: ident, $ contains: ident (TestOperation $($ member: ident)*) ($($ temp: ident)*) (TestOperation $($ not_member: ident)*)) => {
                             scope! { @ $ name, $ contains ($($ member)*) ($($ temp)*) ($($ not_member)*) }
                         };
                         // TestOperation match not found, pop from `not_member` into `temp` stack
                         (@ $ name: ident, $ contains: ident (TestOperation $($ member: ident)*) ($($ temp: ident)*) ($ other: ident $($ not_member: ident)*)) => {
                             scope! { @ $ name, $ contains (TestOperation $($ member)*) ($ other $($ temp)*) ($($ not_member)*) }
                         };
-+
-+
+                    (
                         $(#[$ attrs:meta])*
                         $ vis:vis struct $ name:ident {
                             includes: [$($ include:ident),*]
-+
+                        }
                     ) => {
                         use $ crate::operation_shape::*;
                         $ crate::server::scope! {
                             $(#[$ attrs])*
                             $ vis struct $ name {
                                 includes: [$($ include),*],
                                 excludes: []
-+
+                            }
-+
+                        }
                         scope! { @ $ name, False ($($ include)*) () (TestOperation) }
                     };
-+
+                    (
                         $(#[$ attrs:meta])*
                         $ vis:vis struct $ name:ident {
                             excludes: [$($ exclude:ident),*]
-+
+                        }
                     ) => {
                         use $ crate::operation_shape::*;
-+
                         $ crate::server::scope! {
                             $(#[$ attrs])*
                             $ vis struct $ name {
                                 includes: [],
                                 excludes: [$($ exclude),*]
-+
+                            }
-+
+                        }
                         scope! { @ $ name, True ($($ exclude)*) () (TestOperation) }
                     };
-+
+                }

Server Test

Files changed: