Server Test

rev. d7e136c7f19b622057e137a83fe33a6962eff2ca

Files changed:

tmp-codegen-diff/codegen-server-test/pokemon-service-server-sdk-http0x/rust-server-codegen/src/model.rs

@@ -343,343 +429,429 @@

     /// /* EnumGenerator.kt:184 */American English.
     /* EnumGenerator.kt:171 */
     English,
     /// /* EnumGenerator.kt:184 */Español.
     /* EnumGenerator.kt:171 */
     Spanish,
     /// /* EnumGenerator.kt:184 */Italiano.
     /* EnumGenerator.kt:171 */
     Italian,
     /// /* EnumGenerator.kt:184 */日本語。
     /* EnumGenerator.kt:171 */
     Japanese,
     /* EnumGenerator.kt:302 */
-356
+}
 /// /* CodegenDelegator.kt:52 */See [`Language`](crate::model::Language).
 pub mod language {
     #[derive(Debug, PartialEq)]
     pub struct ConstraintViolation(pub(crate) ::std::string::String);
-361
     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#Language' failed to satisfy constraint: Member must satisfy enum value set: [en, es, it, jp]"#
-367
+            )
-368
+        }
-369
+    }
-370
     impl ::std::error::Error for ConstraintViolation {}
-372
     /* ServerEnumGenerator.kt:48 */
     /* ServerEnumGenerator.kt:50 */
-374
+}
 /* ServerEnumGenerator.kt:89 */
 /* ServerEnumGenerator.kt:91 */
 impl ::std::convert::TryFrom<&str> for Language {
     type Error = crate::model::language::ConstraintViolation;
     fn try_from(
         s: &str,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<&str>>::Error> {
         match s {
             "en" => Ok(Language::English),
             "es" => Ok(Language::Spanish),
             "it" => Ok(Language::Italian),
             "jp" => Ok(Language::Japanese),
             _ => Err(crate::model::language::ConstraintViolation(s.to_owned())),
-387
+        }
-388
+    }
-389
+}
 impl ::std::convert::TryFrom<::std::string::String> for Language {
     type Error = crate::model::language::ConstraintViolation;
     fn try_from(
         s: ::std::string::String,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<::std::string::String>>::Error>
-395
+    {
         s.as_str().try_into()
-397
+    }
-398
+}
 /* ServerEnumGenerator.kt:149 */
 /* ServerEnumGenerator.kt:151 */
 impl std::str::FromStr for Language {
     type Err = crate::model::language::ConstraintViolation;
     fn from_str(s: &str) -> std::result::Result<Self, <Self as std::str::FromStr>::Err> {
         Self::try_from(s)
-404
+    }
-405
+}
 /* EnumGenerator.kt:313 */
 impl Language {
     /// Returns the `&str` value of the enum member.
     pub fn as_str(&self) -> &str {

↧ Expand context

         match self {
             Language::English => "en",
             Language::Spanish => "es",
             Language::Italian => "it",
             Language::Japanese => "jp",
-415
+        }
-416
+    }
     /// Returns all the `&str` representations of the enum members.
     pub const fn values() -> &'static [&'static str] {
         &["en", "es", "it", "jp"]
-420
+    }
-421
+}
 /* EnumGenerator.kt:258 */
 impl ::std::convert::AsRef<str> for Language {
     fn as_ref(&self) -> &str {
         self.as_str()
-426
+    }
-427
+}
 /* ConstrainedTraitForEnumGenerator.kt:36 */
 impl crate::constrained::Constrained for Language {

tmp-codegen-diff/codegen-server-test/pokemon-service-server-sdk/rust-server-codegen/src/model.rs

@@ -343,343 +429,429 @@

↥ Expand context

     /// /* EnumGenerator.kt:184 */American English.
     /* EnumGenerator.kt:171 */
     English,
     /// /* EnumGenerator.kt:184 */Español.
     /* EnumGenerator.kt:171 */
     Spanish,
     /// /* EnumGenerator.kt:184 */Italiano.
     /* EnumGenerator.kt:171 */
     Italian,
     /// /* EnumGenerator.kt:184 */日本語。
     /* EnumGenerator.kt:171 */
     Japanese,
     /* EnumGenerator.kt:302 */
-356
+}
 /// /* CodegenDelegator.kt:52 */See [`Language`](crate::model::Language).
 pub mod language {
     #[derive(Debug, PartialEq)]
     pub struct ConstraintViolation(pub(crate) ::std::string::String);
-361
     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#Language' failed to satisfy constraint: Member must satisfy enum value set: [en, es, it, jp]"#
-367
+            )
-368
+        }
-369
+    }
-370
     impl ::std::error::Error for ConstraintViolation {}
-372
     /* ServerEnumGenerator.kt:48 */
     /* ServerEnumGenerator.kt:50 */
-374
+}
 /* ServerEnumGenerator.kt:89 */
 /* ServerEnumGenerator.kt:91 */
 impl ::std::convert::TryFrom<&str> for Language {
     type Error = crate::model::language::ConstraintViolation;
     fn try_from(
         s: &str,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<&str>>::Error> {
         match s {
             "en" => Ok(Language::English),
             "es" => Ok(Language::Spanish),
             "it" => Ok(Language::Italian),
             "jp" => Ok(Language::Japanese),
             _ => Err(crate::model::language::ConstraintViolation(s.to_owned())),
-387
+        }
-388
+    }
-389
+}
 impl ::std::convert::TryFrom<::std::string::String> for Language {
     type Error = crate::model::language::ConstraintViolation;
     fn try_from(
         s: ::std::string::String,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<::std::string::String>>::Error>
-395
+    {
         s.as_str().try_into()
-397
+    }
-398
+}
 /* ServerEnumGenerator.kt:149 */
 /* ServerEnumGenerator.kt:151 */
 impl std::str::FromStr for Language {
     type Err = crate::model::language::ConstraintViolation;
     fn from_str(s: &str) -> std::result::Result<Self, <Self as std::str::FromStr>::Err> {
         Self::try_from(s)
-404
+    }
-405
+}
 /* EnumGenerator.kt:313 */
 impl Language {
     /// Returns the `&str` value of the enum member.
     pub fn as_str(&self) -> &str {

↧ Expand context

         match self {
             Language::English => "en",
             Language::Spanish => "es",
             Language::Italian => "it",
             Language::Japanese => "jp",
-415
+        }
-416
+    }
     /// Returns all the `&str` representations of the enum members.
     pub const fn values() -> &'static [&'static str] {
         &["en", "es", "it", "jp"]
-420
+    }
-421
+}
 /* EnumGenerator.kt:258 */
 impl ::std::convert::AsRef<str> for Language {
     fn as_ref(&self) -> &str {
         self.as_str()
-426
+    }
-427
+}
 /* ConstrainedTraitForEnumGenerator.kt:36 */
 impl crate::constrained::Constrained for Language {

tmp-codegen-diff/codegen-server-test/rest_json-http0x/rust-server-codegen/src/model.rs

@@ -124,124 +211,211 @@

↥ Expand context

 /// /* CodegenDelegator.kt:52 */See [`FooEnum`](crate::model::FooEnum).
 pub mod foo_enum {
     #[derive(Debug, PartialEq)]
     pub struct ConstraintViolation(pub(crate) ::std::string::String);
-128
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             write!(
                 f,
                 r#"Value provided for 'aws.protocoltests.shared#FooEnum' failed to satisfy constraint: Member must satisfy enum value set: [Foo, Baz, Bar, 1, 0]"#
-134
+            )
-135
+        }
-136
+    }
-137
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {

             crate::model::ValidationExceptionField {
                 message: format!(
                     r#"Value at '{}' failed to satisfy constraint: Member must satisfy enum value set: [Foo, Baz, Bar, 1, 0]"#,
                     &path
                 ),
                 path,
-150
+            }
-151
+        }
-152
+    }
-153
     /* ServerEnumGenerator.kt:48 */
     /* ServerEnumGenerator.kt:50 */
-155
+}
 /* ServerEnumGenerator.kt:89 */
 /* ServerEnumGenerator.kt:91 */
 impl ::std::convert::TryFrom<&str> for FooEnum {
     type Error = crate::model::foo_enum::ConstraintViolation;
     fn try_from(
         s: &str,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<&str>>::Error> {
         match s {
             "0" => Ok(FooEnum::Zero),
             "1" => Ok(FooEnum::One),
             "Bar" => Ok(FooEnum::Bar),
             "Baz" => Ok(FooEnum::Baz),
             "Foo" => Ok(FooEnum::Foo),
             _ => Err(crate::model::foo_enum::ConstraintViolation(s.to_owned())),
-169
+        }
-170
+    }
-171
+}
 impl ::std::convert::TryFrom<::std::string::String> for FooEnum {
     type Error = crate::model::foo_enum::ConstraintViolation;
     fn try_from(
         s: ::std::string::String,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<::std::string::String>>::Error>
-177
+    {
         s.as_str().try_into()
-179
+    }
-180
+}
 /* ServerEnumGenerator.kt:149 */
 /* ServerEnumGenerator.kt:151 */
 impl std::str::FromStr for FooEnum {
     type Err = crate::model::foo_enum::ConstraintViolation;
     fn from_str(s: &str) -> std::result::Result<Self, <Self as std::str::FromStr>::Err> {
         Self::try_from(s)
-186
+    }
-187
+}
 /* EnumGenerator.kt:313 */
 impl FooEnum {
     /// Returns the `&str` value of the enum member.
     pub fn as_str(&self) -> &str {

↧ Expand context

         match self {
             FooEnum::Zero => "0",
             FooEnum::One => "1",
             FooEnum::Bar => "Bar",
             FooEnum::Baz => "Baz",
             FooEnum::Foo => "Foo",
-198
+        }
-199
+    }
     /// Returns all the `&str` representations of the enum members.
     pub const fn values() -> &'static [&'static str] {
         &["0", "1", "Bar", "Baz", "Foo"]
-203
+    }
-204
+}
 /* EnumGenerator.kt:258 */
 impl ::std::convert::AsRef<str> for FooEnum {
     fn as_ref(&self) -> &str {
         self.as_str()
-209
+    }
-210
+}
 /* ConstrainedTraitForEnumGenerator.kt:36 */

@@ -377,377 +460,460 @@

↥ Expand context

 /// /* CodegenDelegator.kt:52 */See [`StringEnum`](crate::model::StringEnum).
 pub mod string_enum {
     #[derive(Debug, PartialEq)]
     pub struct ConstraintViolation(pub(crate) ::std::string::String);
-381
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             write!(
                 f,
                 r#"Value provided for 'aws.protocoltests.restjson#StringEnum' failed to satisfy constraint: Member must satisfy enum value set: [enumvalue]"#
-387
+            )
-388
+        }
-389
+    }
-390
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {

             crate::model::ValidationExceptionField {
                 message: format!(
                     r#"Value at '{}' failed to satisfy constraint: Member must satisfy enum value set: [enumvalue]"#,
                     &path
                 ),
                 path,
-403
+            }
-404
+        }
-405
+    }
-406
     /* ServerEnumGenerator.kt:48 */
     /* ServerEnumGenerator.kt:50 */
-408
+}
 /* ServerEnumGenerator.kt:89 */
 /* ServerEnumGenerator.kt:91 */
 impl ::std::convert::TryFrom<&str> for StringEnum {
     type Error = crate::model::string_enum::ConstraintViolation;
     fn try_from(
         s: &str,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<&str>>::Error> {
         match s {
             "enumvalue" => Ok(StringEnum::V),
             _ => Err(crate::model::string_enum::ConstraintViolation(s.to_owned())),
-418
+        }
-419
+    }
-420
+}
 impl ::std::convert::TryFrom<::std::string::String> for StringEnum {
     type Error = crate::model::string_enum::ConstraintViolation;
     fn try_from(
         s: ::std::string::String,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<::std::string::String>>::Error>
-426
+    {
         s.as_str().try_into()
-428
+    }
-429
+}
 /* ServerEnumGenerator.kt:149 */
 /* ServerEnumGenerator.kt:151 */
 impl std::str::FromStr for StringEnum {
     type Err = crate::model::string_enum::ConstraintViolation;
     fn from_str(s: &str) -> std::result::Result<Self, <Self as std::str::FromStr>::Err> {
         Self::try_from(s)
-435
+    }
-436
+}
 /* EnumGenerator.kt:313 */
 impl StringEnum {
     /// Returns the `&str` value of the enum member.
     pub fn as_str(&self) -> &str {

↧ Expand context

         match self {
             StringEnum::V => "enumvalue",
-443
+        }
-444
+    }
     /// Returns all the `&str` representations of the enum members.
     pub const fn values() -> &'static [&'static str] {
         &["enumvalue"]
-448
+    }
-449
+}
 /* EnumGenerator.kt:258 */
 impl ::std::convert::AsRef<str> for StringEnum {
     fn as_ref(&self) -> &str {
         self.as_str()
-454
+    }
-455
+}
 /* ConstrainedTraitForEnumGenerator.kt:36 */
 impl crate::constrained::Constrained for StringEnum {
     type Unconstrained = ::std::string::String;
-459
+}
-460

@@ -1772,1772 +1857,1857 @@

↥ Expand context

 /// /* CodegenDelegator.kt:52 */See [`TestEnum`](crate::model::TestEnum).
 pub mod test_enum {
     #[derive(Debug, PartialEq)]
     pub struct ConstraintViolation(pub(crate) ::std::string::String);
-1776
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             write!(
                 f,
                 r#"Value provided for 'aws.protocoltests.restjson#TestEnum' failed to satisfy constraint: Member must satisfy enum value set: [FOO, BAR, BAZ]"#
-1782
+            )
-1783
+        }
-1784
+    }
-1785
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {

             crate::model::ValidationExceptionField {
                 message: format!(
                     r#"Value at '{}' failed to satisfy constraint: Member must satisfy enum value set: [FOO, BAR, BAZ]"#,
                     &path
                 ),
                 path,
-1798
+            }
-1799
+        }
-1800
+    }
-1801
     /* ServerEnumGenerator.kt:48 */
     /* ServerEnumGenerator.kt:50 */
-1803
+}
 /* ServerEnumGenerator.kt:89 */
 /* ServerEnumGenerator.kt:91 */
 impl ::std::convert::TryFrom<&str> for TestEnum {
     type Error = crate::model::test_enum::ConstraintViolation;
     fn try_from(
         s: &str,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<&str>>::Error> {
         match s {
             "BAR" => Ok(TestEnum::Bar),
             "BAZ" => Ok(TestEnum::Baz),
             "FOO" => Ok(TestEnum::Foo),
             _ => Err(crate::model::test_enum::ConstraintViolation(s.to_owned())),
-1815
+        }
-1816
+    }
-1817
+}
 impl ::std::convert::TryFrom<::std::string::String> for TestEnum {
     type Error = crate::model::test_enum::ConstraintViolation;
     fn try_from(
         s: ::std::string::String,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<::std::string::String>>::Error>
-1823
+    {
         s.as_str().try_into()
-1825
+    }
-1826
+}
 /* ServerEnumGenerator.kt:149 */
 /* ServerEnumGenerator.kt:151 */
 impl std::str::FromStr for TestEnum {
     type Err = crate::model::test_enum::ConstraintViolation;
     fn from_str(s: &str) -> std::result::Result<Self, <Self as std::str::FromStr>::Err> {
         Self::try_from(s)
-1832
+    }
-1833
+}
 /* EnumGenerator.kt:313 */
 impl TestEnum {
     /// Returns the `&str` value of the enum member.
     pub fn as_str(&self) -> &str {

↧ Expand context

         match self {
             TestEnum::Bar => "BAR",
             TestEnum::Baz => "BAZ",
             TestEnum::Foo => "FOO",
-1842
+        }
-1843
+    }
     /// Returns all the `&str` representations of the enum members.
     pub const fn values() -> &'static [&'static str] {
         &["BAR", "BAZ", "FOO"]
-1847
+    }
-1848
+}
 /* EnumGenerator.kt:258 */
 impl ::std::convert::AsRef<str> for TestEnum {
     fn as_ref(&self) -> &str {
         self.as_str()
-1853
+    }
-1854
+}
 /* ConstrainedTraitForEnumGenerator.kt:36 */
 impl crate::constrained::Constrained for TestEnum {
     type Unconstrained = ::std::string::String;

tmp-codegen-diff/codegen-server-test/rest_json/rust-server-codegen/src/model.rs

@@ -124,124 +211,211 @@

↥ Expand context

 /// /* CodegenDelegator.kt:52 */See [`FooEnum`](crate::model::FooEnum).
 pub mod foo_enum {
     #[derive(Debug, PartialEq)]
     pub struct ConstraintViolation(pub(crate) ::std::string::String);
-128
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             write!(
                 f,
                 r#"Value provided for 'aws.protocoltests.shared#FooEnum' failed to satisfy constraint: Member must satisfy enum value set: [Foo, Baz, Bar, 1, 0]"#
-134
+            )
-135
+        }
-136
+    }
-137
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {

             crate::model::ValidationExceptionField {
                 message: format!(
                     r#"Value at '{}' failed to satisfy constraint: Member must satisfy enum value set: [Foo, Baz, Bar, 1, 0]"#,
                     &path
                 ),
                 path,
-150
+            }
-151
+        }
-152
+    }
-153
     /* ServerEnumGenerator.kt:48 */
     /* ServerEnumGenerator.kt:50 */
-155
+}
 /* ServerEnumGenerator.kt:89 */
 /* ServerEnumGenerator.kt:91 */
 impl ::std::convert::TryFrom<&str> for FooEnum {
     type Error = crate::model::foo_enum::ConstraintViolation;
     fn try_from(
         s: &str,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<&str>>::Error> {
         match s {
             "0" => Ok(FooEnum::Zero),
             "1" => Ok(FooEnum::One),
             "Bar" => Ok(FooEnum::Bar),
             "Baz" => Ok(FooEnum::Baz),
             "Foo" => Ok(FooEnum::Foo),
             _ => Err(crate::model::foo_enum::ConstraintViolation(s.to_owned())),
-169
+        }
-170
+    }
-171
+}
 impl ::std::convert::TryFrom<::std::string::String> for FooEnum {
     type Error = crate::model::foo_enum::ConstraintViolation;
     fn try_from(
         s: ::std::string::String,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<::std::string::String>>::Error>
-177
+    {
         s.as_str().try_into()
-179
+    }
-180
+}
 /* ServerEnumGenerator.kt:149 */
 /* ServerEnumGenerator.kt:151 */
 impl std::str::FromStr for FooEnum {
     type Err = crate::model::foo_enum::ConstraintViolation;
     fn from_str(s: &str) -> std::result::Result<Self, <Self as std::str::FromStr>::Err> {
         Self::try_from(s)
-186
+    }
-187
+}
 /* EnumGenerator.kt:313 */
 impl FooEnum {
     /// Returns the `&str` value of the enum member.
     pub fn as_str(&self) -> &str {

↧ Expand context

         match self {
             FooEnum::Zero => "0",
             FooEnum::One => "1",
             FooEnum::Bar => "Bar",
             FooEnum::Baz => "Baz",
             FooEnum::Foo => "Foo",
-198
+        }
-199
+    }
     /// Returns all the `&str` representations of the enum members.
     pub const fn values() -> &'static [&'static str] {
         &["0", "1", "Bar", "Baz", "Foo"]
-203
+    }
-204
+}
 /* EnumGenerator.kt:258 */
 impl ::std::convert::AsRef<str> for FooEnum {
     fn as_ref(&self) -> &str {
         self.as_str()
-209
+    }
-210
+}
 /* ConstrainedTraitForEnumGenerator.kt:36 */

@@ -377,377 +460,460 @@

↥ Expand context

 /// /* CodegenDelegator.kt:52 */See [`StringEnum`](crate::model::StringEnum).
 pub mod string_enum {
     #[derive(Debug, PartialEq)]
     pub struct ConstraintViolation(pub(crate) ::std::string::String);
-381
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             write!(
                 f,
                 r#"Value provided for 'aws.protocoltests.restjson#StringEnum' failed to satisfy constraint: Member must satisfy enum value set: [enumvalue]"#
-387
+            )
-388
+        }
-389
+    }
-390
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {

             crate::model::ValidationExceptionField {
                 message: format!(
                     r#"Value at '{}' failed to satisfy constraint: Member must satisfy enum value set: [enumvalue]"#,
                     &path
                 ),
                 path,
-403
+            }
-404
+        }
-405
+    }
-406
     /* ServerEnumGenerator.kt:48 */
     /* ServerEnumGenerator.kt:50 */
-408
+}
 /* ServerEnumGenerator.kt:89 */
 /* ServerEnumGenerator.kt:91 */
 impl ::std::convert::TryFrom<&str> for StringEnum {
     type Error = crate::model::string_enum::ConstraintViolation;
     fn try_from(
         s: &str,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<&str>>::Error> {
         match s {
             "enumvalue" => Ok(StringEnum::V),
             _ => Err(crate::model::string_enum::ConstraintViolation(s.to_owned())),
-418
+        }
-419
+    }
-420
+}
 impl ::std::convert::TryFrom<::std::string::String> for StringEnum {
     type Error = crate::model::string_enum::ConstraintViolation;
     fn try_from(
         s: ::std::string::String,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<::std::string::String>>::Error>
-426
+    {
         s.as_str().try_into()
-428
+    }
-429
+}
 /* ServerEnumGenerator.kt:149 */
 /* ServerEnumGenerator.kt:151 */
 impl std::str::FromStr for StringEnum {
     type Err = crate::model::string_enum::ConstraintViolation;
     fn from_str(s: &str) -> std::result::Result<Self, <Self as std::str::FromStr>::Err> {
         Self::try_from(s)
-435
+    }
-436
+}
 /* EnumGenerator.kt:313 */
 impl StringEnum {
     /// Returns the `&str` value of the enum member.
     pub fn as_str(&self) -> &str {

↧ Expand context

         match self {
             StringEnum::V => "enumvalue",
-443
+        }
-444
+    }
     /// Returns all the `&str` representations of the enum members.
     pub const fn values() -> &'static [&'static str] {
         &["enumvalue"]
-448
+    }
-449
+}
 /* EnumGenerator.kt:258 */
 impl ::std::convert::AsRef<str> for StringEnum {
     fn as_ref(&self) -> &str {
         self.as_str()
-454
+    }
-455
+}
 /* ConstrainedTraitForEnumGenerator.kt:36 */
 impl crate::constrained::Constrained for StringEnum {
     type Unconstrained = ::std::string::String;
-459
+}
-460

@@ -1772,1772 +1857,1857 @@

↥ Expand context

 /// /* CodegenDelegator.kt:52 */See [`TestEnum`](crate::model::TestEnum).
 pub mod test_enum {
     #[derive(Debug, PartialEq)]
     pub struct ConstraintViolation(pub(crate) ::std::string::String);
-1776
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             write!(
                 f,
                 r#"Value provided for 'aws.protocoltests.restjson#TestEnum' failed to satisfy constraint: Member must satisfy enum value set: [FOO, BAR, BAZ]"#
-1782
+            )
-1783
+        }
-1784
+    }
-1785
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {

             crate::model::ValidationExceptionField {
                 message: format!(
                     r#"Value at '{}' failed to satisfy constraint: Member must satisfy enum value set: [FOO, BAR, BAZ]"#,
                     &path
                 ),
                 path,
-1798
+            }
-1799
+        }
-1800
+    }
-1801
     /* ServerEnumGenerator.kt:48 */
     /* ServerEnumGenerator.kt:50 */
-1803
+}
 /* ServerEnumGenerator.kt:89 */
 /* ServerEnumGenerator.kt:91 */
 impl ::std::convert::TryFrom<&str> for TestEnum {
     type Error = crate::model::test_enum::ConstraintViolation;
     fn try_from(
         s: &str,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<&str>>::Error> {
         match s {
             "BAR" => Ok(TestEnum::Bar),
             "BAZ" => Ok(TestEnum::Baz),
             "FOO" => Ok(TestEnum::Foo),
             _ => Err(crate::model::test_enum::ConstraintViolation(s.to_owned())),
-1815
+        }
-1816
+    }
-1817
+}
 impl ::std::convert::TryFrom<::std::string::String> for TestEnum {
     type Error = crate::model::test_enum::ConstraintViolation;
     fn try_from(
         s: ::std::string::String,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<::std::string::String>>::Error>
-1823
+    {
         s.as_str().try_into()
-1825
+    }
-1826
+}
 /* ServerEnumGenerator.kt:149 */
 /* ServerEnumGenerator.kt:151 */
 impl std::str::FromStr for TestEnum {
     type Err = crate::model::test_enum::ConstraintViolation;
     fn from_str(s: &str) -> std::result::Result<Self, <Self as std::str::FromStr>::Err> {
         Self::try_from(s)
-1832
+    }
-1833
+}
 /* EnumGenerator.kt:313 */
 impl TestEnum {
     /// Returns the `&str` value of the enum member.
     pub fn as_str(&self) -> &str {

↧ Expand context

         match self {
             TestEnum::Bar => "BAR",
             TestEnum::Baz => "BAZ",
             TestEnum::Foo => "FOO",
-1842
+        }
-1843
+    }
     /// Returns all the `&str` representations of the enum members.
     pub const fn values() -> &'static [&'static str] {
         &["BAR", "BAZ", "FOO"]
-1847
+    }
-1848
+}
 /* EnumGenerator.kt:258 */
 impl ::std::convert::AsRef<str> for TestEnum {
     fn as_ref(&self) -> &str {
         self.as_str()
-1853
+    }
-1854
+}
 /* ConstrainedTraitForEnumGenerator.kt:36 */
 impl crate::constrained::Constrained for TestEnum {
     type Unconstrained = ::std::string::String;

tmp-codegen-diff/codegen-server-test/rest_json_validation-http0x/rust-server-codegen/src/model.rs

@@ -2,2 +75,75 @@

↥ Expand context

 #[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,
     ::std::marker::Copy,
 )]
 pub enum EnumString {
     #[allow(missing_docs)] // documentation missing in model
     Abc,
     #[allow(missing_docs)] // documentation missing in model
     Def,
     #[allow(missing_docs)] // documentation missing in model
     Ghi,
     #[allow(missing_docs)] // documentation missing in model
     Jkl,

-22
+}
 /// See [`EnumString`](crate::model::EnumString).
 pub mod enum_string {
     #[derive(Debug, PartialEq)]
     pub struct ConstraintViolation(pub(crate) ::std::string::String);
-27
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             write!(
                 f,
                 r#"Value provided for 'aws.protocoltests.restjson.validation#EnumString' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, ghi, jkl]"#
                 r#"Value provided for 'aws.protocoltests.restjson.validation#EnumString' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]"#
-33
+            )
-34
+        }
-35
+    }
-36
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {
             crate::model::ValidationExceptionField {
                 message: format!(
                     r#"Value at '{}' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, ghi, jkl]"#,
                     r#"Value at '{}' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]"#,
                     &path
                 ),
                 path,
-49
+            }
-50
+        }
-51
+    }
-52
+}
 impl ::std::convert::TryFrom<&str> for EnumString {
     type Error = crate::model::enum_string::ConstraintViolation;
     fn try_from(

↧ Expand context

         s: &str,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<&str>>::Error> {
         match s {
             "abc" => Ok(EnumString::Abc),
             "def" => Ok(EnumString::Def),
             "ghi" => Ok(EnumString::Ghi),
             "jkl" => Ok(EnumString::Jkl),
             _ => Err(crate::model::enum_string::ConstraintViolation(s.to_owned())),
-64
+        }
-65
+    }
-66
+}
 impl ::std::convert::TryFrom<::std::string::String> for EnumString {
     type Error = crate::model::enum_string::ConstraintViolation;
     fn try_from(
         s: ::std::string::String,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<::std::string::String>>::Error>
-72
+    {
         s.as_str().try_into()
-74
+    }
-75
+}

@@ -112,112 +185,185 @@

↥ Expand context

-112
+}
-113
 #[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,
     ::std::marker::Copy,
 )]
 pub enum EnumTraitString {
     #[allow(missing_docs)] // documentation missing in model
     Abc,
     #[allow(missing_docs)] // documentation missing in model
     Def,
     #[allow(missing_docs)] // documentation missing in model
     Ghi,

-132
+}
 /// See [`EnumTraitString`](crate::model::EnumTraitString).
 pub mod enum_trait_string {
     #[derive(Debug, PartialEq)]
     pub struct ConstraintViolation(pub(crate) ::std::string::String);
-137
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             write!(
                 f,
                 r#"Value provided for 'aws.protocoltests.restjson.validation#EnumTraitString' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, ghi]"#
                 r#"Value provided for 'aws.protocoltests.restjson.validation#EnumTraitString' failed to satisfy constraint: Member must satisfy enum value set: [abc, def]"#
-143
+            )
-144
+        }
-145
+    }
-146
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {
             crate::model::ValidationExceptionField {
                 message: format!(
                     r#"Value at '{}' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, ghi]"#,
                     r#"Value at '{}' failed to satisfy constraint: Member must satisfy enum value set: [abc, def]"#,
                     &path
                 ),
                 path,
-159
+            }
-160
+        }
-161
+    }
-162
+}
 impl ::std::convert::TryFrom<&str> for EnumTraitString {
     type Error = crate::model::enum_trait_string::ConstraintViolation;
     fn try_from(

↧ Expand context

         s: &str,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<&str>>::Error> {
         match s {
             "abc" => Ok(EnumTraitString::Abc),
             "def" => Ok(EnumTraitString::Def),
             "ghi" => Ok(EnumTraitString::Ghi),
             _ => Err(crate::model::enum_trait_string::ConstraintViolation(
                 s.to_owned(),
             )),
-175
+        }
-176
+    }
-177
+}
 impl ::std::convert::TryFrom<::std::string::String> for EnumTraitString {
     type Error = crate::model::enum_trait_string::ConstraintViolation;
     fn try_from(
         s: ::std::string::String,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<::std::string::String>>::Error>
-183
+    {
         s.as_str().try_into()
-185
+    }

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

@@ -81,81 +801,789 @@

↥ Expand context

     > for crate::error::MalformedEnumError
-82
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_enum::ser_malformed_enum_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-92
+            }
             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))
-96
+            }
-97
+        }
-98
+    }
-99
+}
-100

 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod malformed_enum_test {
-104
     /// When a string member does not contain a valid enum value,
     /// the response should be a 400 ValidationException. Internal-only
     /// enum values are excluded from the response message.
     /// Test ID: RestJsonMalformedEnumString_case0
     #[::tokio::test]
     #[::tracing_test::traced_test]
     #[should_panic]
     async fn rest_json_malformed_enum_string_case0_malformed_request() {
-112
+        {
             #[allow(unused_mut)]
             let mut http_request = ::http::Request::builder()
                 .uri("/MalformedEnum")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_legacy_http_server::body::Body::from(
                     ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                         "{ \"string\" : \"ABC\" }".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::RestJsonValidationConfig::builder().build();
             let service = crate::service::RestJsonValidation::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_enum(
                                 // Rust 1.94+ flags the moved `sender` as "value captured is never read"
                                 // since `send()` only borrows it.
                                 #[allow(unused_assignments)]
                                 move |input: crate::input::MalformedEnumInput| {
                                     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::MalformedEnumOutput, crate::error::MalformedEnumError> };
                                         sender.send(()).await.expect("receiver dropped early");
                                         result
-139
+                                    }
-140
+                                }
-141
+                            )
                             .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_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())
                 .await
                 .expect("unable to extract body to bytes");
             ::aws_smithy_protocol_test::assert_ok(
             ::aws_smithy_protocol_test::validate_body(&body, "{ \"message\" : \"1 validation error detected. Value at '/string' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]\",\n  \"fieldList\" : [{\"message\": \"Value at '/string' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]\", \"path\": \"/string\"}]}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
             );
-161
+        }
-162
+    }
-163
     /// When a string member does not contain a valid enum value,
     /// the response should be a 400 ValidationException. Internal-only
     /// enum values are excluded from the response message.
     /// Test ID: RestJsonMalformedEnumString_case1
     #[::tokio::test]
     #[::tracing_test::traced_test]
     #[should_panic]
     async fn rest_json_malformed_enum_string_case1_malformed_request() {
-171
+        {
             #[allow(unused_mut)]
             let mut http_request = ::http::Request::builder()
                 .uri("/MalformedEnum")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_legacy_http_server::body::Body::from(
                     ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                         "{ \"string\" : \"XYZ\" }".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::RestJsonValidationConfig::builder().build();
             let service = crate::service::RestJsonValidation::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_enum(
                                 // Rust 1.94+ flags the moved `sender` as "value captured is never read"
                                 // since `send()` only borrows it.
                                 #[allow(unused_assignments)]
                                 move |input: crate::input::MalformedEnumInput| {
                                     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::MalformedEnumOutput, crate::error::MalformedEnumError> };
                                         sender.send(()).await.expect("receiver dropped early");
                                         result
-198
+                                    }
-199
+                                }
-200
+                            )
                             .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_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())
                 .await
                 .expect("unable to extract body to bytes");
             ::aws_smithy_protocol_test::assert_ok(
             ::aws_smithy_protocol_test::validate_body(&body, "{ \"message\" : \"1 validation error detected. Value at '/string' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]\",\n  \"fieldList\" : [{\"message\": \"Value at '/string' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]\", \"path\": \"/string\"}]}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
             );
-220
+        }
-221
+    }
-222
     /// When a string member does not contain a valid enum value,
     /// the response should be a 400 ValidationException. Internal-only
     /// enum values are excluded from the response message.
     /// Test ID: RestJsonMalformedEnumTraitString_case0
     #[::tokio::test]
     #[::tracing_test::traced_test]
     #[should_panic]
     async fn rest_json_malformed_enum_trait_string_case0_malformed_request() {
-230
+        {
             #[allow(unused_mut)]
             let mut http_request = ::http::Request::builder()
                 .uri("/MalformedEnum")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_legacy_http_server::body::Body::from(
                     ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                         "{ \"stringWithEnumTrait\" : \"ABC\" }".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::RestJsonValidationConfig::builder().build();
             let service = crate::service::RestJsonValidation::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_enum(
                                 // Rust 1.94+ flags the moved `sender` as "value captured is never read"
                                 // since `send()` only borrows it.
                                 #[allow(unused_assignments)]
                                 move |input: crate::input::MalformedEnumInput| {
                                     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::MalformedEnumOutput, crate::error::MalformedEnumError> };
                                         sender.send(()).await.expect("receiver dropped early");
                                         result
-257
+                                    }
-258
+                                }
-259
+                            )
                             .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_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())
                 .await
                 .expect("unable to extract body to bytes");
             ::aws_smithy_protocol_test::assert_ok(
             ::aws_smithy_protocol_test::validate_body(&body, "{ \"message\" : \"1 validation error detected. Value at '/stringWithEnumTrait' failed to satisfy constraint: Member must satisfy enum value set: [abc, def]\",\n  \"fieldList\" : [{\"message\": \"Value at '/stringWithEnumTrait' failed to satisfy constraint: Member must satisfy enum value set: [abc, def]\", \"path\": \"/stringWithEnumTrait\"}]}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
             );
-279
+        }
-280
+    }
-281
     /// When a string member does not contain a valid enum value,
     /// the response should be a 400 ValidationException. Internal-only
     /// enum values are excluded from the response message.
     /// Test ID: RestJsonMalformedEnumTraitString_case1
     #[::tokio::test]
     #[::tracing_test::traced_test]
     #[should_panic]
     async fn rest_json_malformed_enum_trait_string_case1_malformed_request() {
-289
+        {
             #[allow(unused_mut)]
             let mut http_request = ::http::Request::builder()
                 .uri("/MalformedEnum")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_legacy_http_server::body::Body::from(
                     ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                         "{ \"stringWithEnumTrait\" : \"XYZ\" }".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::RestJsonValidationConfig::builder().build();
             let service = crate::service::RestJsonValidation::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_enum(
                                 // Rust 1.94+ flags the moved `sender` as "value captured is never read"
                                 // since `send()` only borrows it.
                                 #[allow(unused_assignments)]
                                 move |input: crate::input::MalformedEnumInput| {
                                     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::MalformedEnumOutput, crate::error::MalformedEnumError> };
                                         sender.send(()).await.expect("receiver dropped early");
                                         result
-316
+                                    }
-317
+                                }
-318
+                            )
                             .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_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())
                 .await
                 .expect("unable to extract body to bytes");
             ::aws_smithy_protocol_test::assert_ok(
             ::aws_smithy_protocol_test::validate_body(&body, "{ \"message\" : \"1 validation error detected. Value at '/stringWithEnumTrait' failed to satisfy constraint: Member must satisfy enum value set: [abc, def]\",\n  \"fieldList\" : [{\"message\": \"Value at '/stringWithEnumTrait' failed to satisfy constraint: Member must satisfy enum value set: [abc, def]\", \"path\": \"/stringWithEnumTrait\"}]}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
             );
-338
+        }
-339
+    }
-340
     /// When a list member value does not contain a valid enum value,
     /// the response should be a 400 ValidationException. Internal-only
     /// enum values are excluded from the response message.
     /// Test ID: RestJsonMalformedEnumList_case0
     #[::tokio::test]
     #[::tracing_test::traced_test]
     #[should_panic]
     async fn rest_json_malformed_enum_list_case0_malformed_request() {
-348
+        {
             #[allow(unused_mut)]
             let mut http_request = ::http::Request::builder()
                 .uri("/MalformedEnum")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_legacy_http_server::body::Body::from(
                     ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                         "{ \"list\" : [\"ABC\"] }".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::RestJsonValidationConfig::builder().build();
             let service = crate::service::RestJsonValidation::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_enum(
                                 // Rust 1.94+ flags the moved `sender` as "value captured is never read"
                                 // since `send()` only borrows it.
                                 #[allow(unused_assignments)]
                                 move |input: crate::input::MalformedEnumInput| {
                                     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::MalformedEnumOutput, crate::error::MalformedEnumError> };
                                         sender.send(()).await.expect("receiver dropped early");
                                         result
-375
+                                    }
-376
+                                }
-377
+                            )
                             .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_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())
                 .await
                 .expect("unable to extract body to bytes");
             ::aws_smithy_protocol_test::assert_ok(
             ::aws_smithy_protocol_test::validate_body(&body, "{ \"message\" : \"1 validation error detected. Value at '/list/0' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]\",\n  \"fieldList\" : [{\"message\": \"Value at '/list/0' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]\", \"path\": \"/list/0\"}]}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
             );
-397
+        }
-398
+    }
-399
     /// When a list member value does not contain a valid enum value,
     /// the response should be a 400 ValidationException. Internal-only
     /// enum values are excluded from the response message.
     /// Test ID: RestJsonMalformedEnumList_case1
     #[::tokio::test]
     #[::tracing_test::traced_test]
     #[should_panic]
     async fn rest_json_malformed_enum_list_case1_malformed_request() {
-407
+        {
             #[allow(unused_mut)]
             let mut http_request = ::http::Request::builder()
                 .uri("/MalformedEnum")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_legacy_http_server::body::Body::from(
                     ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                         "{ \"list\" : [\"XYZ\"] }".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::RestJsonValidationConfig::builder().build();
             let service = crate::service::RestJsonValidation::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_enum(
                                 // Rust 1.94+ flags the moved `sender` as "value captured is never read"
                                 // since `send()` only borrows it.
                                 #[allow(unused_assignments)]
                                 move |input: crate::input::MalformedEnumInput| {
                                     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::MalformedEnumOutput, crate::error::MalformedEnumError> };
                                         sender.send(()).await.expect("receiver dropped early");
                                         result
-434
+                                    }
-435
+                                }
-436
+                            )
                             .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_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())
                 .await
                 .expect("unable to extract body to bytes");
             ::aws_smithy_protocol_test::assert_ok(
             ::aws_smithy_protocol_test::validate_body(&body, "{ \"message\" : \"1 validation error detected. Value at '/list/0' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]\",\n  \"fieldList\" : [{\"message\": \"Value at '/list/0' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]\", \"path\": \"/list/0\"}]}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
             );
-456
+        }
-457
+    }
-458
     /// When a map member's key does not contain a valid enum value,
     /// the response should be a 400 ValidationException. Internal-only
     /// enum values are excluded from the response message.
     /// Test ID: RestJsonMalformedEnumMapKey_case0
     #[::tokio::test]
     #[::tracing_test::traced_test]
     #[should_panic]
     async fn rest_json_malformed_enum_map_key_case0_malformed_request() {
-466
+        {
             #[allow(unused_mut)]
             let mut http_request = ::http::Request::builder()
                 .uri("/MalformedEnum")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_legacy_http_server::body::Body::from(
                     ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                         "{ \"map\" : { \"ABC\" : \"abc\" } }".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::RestJsonValidationConfig::builder().build();
             let service = crate::service::RestJsonValidation::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_enum(
                                 // Rust 1.94+ flags the moved `sender` as "value captured is never read"
                                 // since `send()` only borrows it.
                                 #[allow(unused_assignments)]
                                 move |input: crate::input::MalformedEnumInput| {
                                     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::MalformedEnumOutput, crate::error::MalformedEnumError> };
                                         sender.send(()).await.expect("receiver dropped early");
                                         result
-493
+                                    }
-494
+                                }
-495
+                            )
                             .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_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())
                 .await
                 .expect("unable to extract body to bytes");
             ::aws_smithy_protocol_test::assert_ok(
             ::aws_smithy_protocol_test::validate_body(&body, "{ \"message\" : \"1 validation error detected. Value at '/map' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]\",\n  \"fieldList\" : [{\"message\": \"Value at '/map' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]\", \"path\": \"/map\"}]}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
             );
-515
+        }
-516
+    }
-517
     /// When a map member's key does not contain a valid enum value,
     /// the response should be a 400 ValidationException. Internal-only
     /// enum values are excluded from the response message.
     /// Test ID: RestJsonMalformedEnumMapKey_case1
     #[::tokio::test]
     #[::tracing_test::traced_test]
     #[should_panic]
     async fn rest_json_malformed_enum_map_key_case1_malformed_request() {
-525
+        {
             #[allow(unused_mut)]
             let mut http_request = ::http::Request::builder()
                 .uri("/MalformedEnum")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_legacy_http_server::body::Body::from(
                     ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                         "{ \"map\" : { \"XYZ\" : \"abc\" } }".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::RestJsonValidationConfig::builder().build();
             let service = crate::service::RestJsonValidation::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_enum(
                                 // Rust 1.94+ flags the moved `sender` as "value captured is never read"
                                 // since `send()` only borrows it.
                                 #[allow(unused_assignments)]
                                 move |input: crate::input::MalformedEnumInput| {
                                     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::MalformedEnumOutput, crate::error::MalformedEnumError> };
                                         sender.send(()).await.expect("receiver dropped early");
                                         result
-552
+                                    }
-553
+                                }
-554
+                            )
                             .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_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())
                 .await
                 .expect("unable to extract body to bytes");
             ::aws_smithy_protocol_test::assert_ok(
             ::aws_smithy_protocol_test::validate_body(&body, "{ \"message\" : \"1 validation error detected. Value at '/map' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]\",\n  \"fieldList\" : [{\"message\": \"Value at '/map' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]\", \"path\": \"/map\"}]}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
             );
-574
+        }
-575
+    }
-576
     /// When a map member's value does not contain a valid enum value,
     /// the response should be a 400 ValidationException. Internal-only
     /// enum values are excluded from the response message.
     /// Test ID: RestJsonMalformedEnumMapValue_case0
     #[::tokio::test]
     #[::tracing_test::traced_test]
     #[should_panic]
     async fn rest_json_malformed_enum_map_value_case0_malformed_request() {
-584
+        {
             #[allow(unused_mut)]
             let mut http_request = ::http::Request::builder()
                 .uri("/MalformedEnum")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_legacy_http_server::body::Body::from(
                     ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                         "{ \"map\" : { \"abc\": \"ABC\" } }".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::RestJsonValidationConfig::builder().build();
             let service = crate::service::RestJsonValidation::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_enum(
                                 // Rust 1.94+ flags the moved `sender` as "value captured is never read"
                                 // since `send()` only borrows it.
                                 #[allow(unused_assignments)]
                                 move |input: crate::input::MalformedEnumInput| {
                                     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::MalformedEnumOutput, crate::error::MalformedEnumError> };
                                         sender.send(()).await.expect("receiver dropped early");
                                         result
-611
+                                    }
-612
+                                }
-613
+                            )
                             .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_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())
                 .await
                 .expect("unable to extract body to bytes");
             ::aws_smithy_protocol_test::assert_ok(
             ::aws_smithy_protocol_test::validate_body(&body, "{ \"message\" : \"1 validation error detected. Value at '/map/abc' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]\",\n  \"fieldList\" : [{\"message\": \"Value at '/map/abc' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]\", \"path\": \"/map/abc\"}]}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
             );
-633
+        }
-634
+    }
-635
     /// When a map member's value does not contain a valid enum value,
     /// the response should be a 400 ValidationException. Internal-only
     /// enum values are excluded from the response message.
     /// Test ID: RestJsonMalformedEnumMapValue_case1
     #[::tokio::test]
     #[::tracing_test::traced_test]
     #[should_panic]
     async fn rest_json_malformed_enum_map_value_case1_malformed_request() {
-643
+        {
             #[allow(unused_mut)]
             let mut http_request = ::http::Request::builder()
                 .uri("/MalformedEnum")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_legacy_http_server::body::Body::from(
                     ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                         "{ \"map\" : { \"abc\": \"XYZ\" } }".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::RestJsonValidationConfig::builder().build();
             let service = crate::service::RestJsonValidation::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_enum(
                                 // Rust 1.94+ flags the moved `sender` as "value captured is never read"
                                 // since `send()` only borrows it.
                                 #[allow(unused_assignments)]
                                 move |input: crate::input::MalformedEnumInput| {
                                     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::MalformedEnumOutput, crate::error::MalformedEnumError> };
                                         sender.send(()).await.expect("receiver dropped early");
                                         result
-670
+                                    }
-671
+                                }
-672
+                            )
                             .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_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())
                 .await
                 .expect("unable to extract body to bytes");
             ::aws_smithy_protocol_test::assert_ok(
             ::aws_smithy_protocol_test::validate_body(&body, "{ \"message\" : \"1 validation error detected. Value at '/map/abc' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]\",\n  \"fieldList\" : [{\"message\": \"Value at '/map/abc' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]\", \"path\": \"/map/abc\"}]}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
             );
-692
+        }
-693
+    }
-694
     /// When a union member's value does not contain a valid enum value,
     /// the response should be a 400 ValidationException. Internal-only
     /// enum values are excluded from the response message.
     /// Test ID: RestJsonMalformedEnumUnion_case0
     #[::tokio::test]
     #[::tracing_test::traced_test]
     #[should_panic]
     async fn rest_json_malformed_enum_union_case0_malformed_request() {
-702
+        {
             #[allow(unused_mut)]
             let mut http_request = ::http::Request::builder()
                 .uri("/MalformedEnum")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_legacy_http_server::body::Body::from(
                     ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                         "{ \"union\" : { \"first\": \"ABC\" } }".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::RestJsonValidationConfig::builder().build();
             let service = crate::service::RestJsonValidation::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_enum(
                                 // Rust 1.94+ flags the moved `sender` as "value captured is never read"
                                 // since `send()` only borrows it.
                                 #[allow(unused_assignments)]
                                 move |input: crate::input::MalformedEnumInput| {
                                     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::MalformedEnumOutput, crate::error::MalformedEnumError> };
                                         sender.send(()).await.expect("receiver dropped early");
                                         result
-729
+                                    }
-730
+                                }
-731
+                            )
                             .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_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())
                 .await
                 .expect("unable to extract body to bytes");
             ::aws_smithy_protocol_test::assert_ok(
             ::aws_smithy_protocol_test::validate_body(&body, "{ \"message\" : \"1 validation error detected. Value at '/union/first' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]\",\n  \"fieldList\" : [{\"message\": \"Value at '/union/first' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]\", \"path\": \"/union/first\"}]}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
             );
-751
+        }
-752
+    }
-753
     /// When a union member's value does not contain a valid enum value,
     /// the response should be a 400 ValidationException. Internal-only
     /// enum values are excluded from the response message.
     /// Test ID: RestJsonMalformedEnumUnion_case1
     #[::tokio::test]
     #[::tracing_test::traced_test]
     #[should_panic]
     async fn rest_json_malformed_enum_union_case1_malformed_request() {
-761
+        {
             #[allow(unused_mut)]
             let mut http_request = ::http::Request::builder()
                 .uri("/MalformedEnum")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_legacy_http_server::body::Body::from(
                     ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                         "{ \"union\" : { \"first\": \"XYZ\" } }".as_bytes(),

↧ Expand context

                         ::aws_smithy_protocol_test::MediaType::from("unknown"),
                     )),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonValidationConfig::builder().build();
             let service = crate::service::RestJsonValidation::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_enum(
                                 // Rust 1.94+ flags the moved `sender` as "value captured is never read"
                                 // since `send()` only borrows it.
                                 #[allow(unused_assignments)]
                                 move |input: crate::input::MalformedEnumInput| {
                                     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::MalformedEnumOutput, crate::error::MalformedEnumError> };
                                         sender.send(()).await.expect("receiver dropped early");
                                         result
-788
+                                    }
-789
+                                }

tmp-codegen-diff/codegen-server-test/rest_json_validation/rust-server-codegen/src/model.rs

@@ -2,2 +75,75 @@

↥ Expand context

 #[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,
     ::std::marker::Copy,
 )]
 pub enum EnumString {
     #[allow(missing_docs)] // documentation missing in model
     Abc,
     #[allow(missing_docs)] // documentation missing in model
     Def,
     #[allow(missing_docs)] // documentation missing in model
     Ghi,
     #[allow(missing_docs)] // documentation missing in model
     Jkl,

-22
+}
 /// See [`EnumString`](crate::model::EnumString).
 pub mod enum_string {
     #[derive(Debug, PartialEq)]
     pub struct ConstraintViolation(pub(crate) ::std::string::String);
-27
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             write!(
                 f,
                 r#"Value provided for 'aws.protocoltests.restjson.validation#EnumString' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, ghi, jkl]"#
                 r#"Value provided for 'aws.protocoltests.restjson.validation#EnumString' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]"#
-33
+            )
-34
+        }
-35
+    }
-36
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {
             crate::model::ValidationExceptionField {
                 message: format!(
                     r#"Value at '{}' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, ghi, jkl]"#,
                     r#"Value at '{}' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]"#,
                     &path
                 ),
                 path,
-49
+            }
-50
+        }
-51
+    }
-52
+}
 impl ::std::convert::TryFrom<&str> for EnumString {
     type Error = crate::model::enum_string::ConstraintViolation;
     fn try_from(

↧ Expand context

         s: &str,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<&str>>::Error> {
         match s {
             "abc" => Ok(EnumString::Abc),
             "def" => Ok(EnumString::Def),
             "ghi" => Ok(EnumString::Ghi),
             "jkl" => Ok(EnumString::Jkl),
             _ => Err(crate::model::enum_string::ConstraintViolation(s.to_owned())),
-64
+        }
-65
+    }
-66
+}
 impl ::std::convert::TryFrom<::std::string::String> for EnumString {
     type Error = crate::model::enum_string::ConstraintViolation;
     fn try_from(
         s: ::std::string::String,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<::std::string::String>>::Error>
-72
+    {
         s.as_str().try_into()
-74
+    }
-75
+}

@@ -112,112 +185,185 @@

↥ Expand context

-112
+}
-113
 #[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,
     ::std::marker::Copy,
 )]
 pub enum EnumTraitString {
     #[allow(missing_docs)] // documentation missing in model
     Abc,
     #[allow(missing_docs)] // documentation missing in model
     Def,
     #[allow(missing_docs)] // documentation missing in model
     Ghi,

-132
+}
 /// See [`EnumTraitString`](crate::model::EnumTraitString).
 pub mod enum_trait_string {
     #[derive(Debug, PartialEq)]
     pub struct ConstraintViolation(pub(crate) ::std::string::String);
-137
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             write!(
                 f,
                 r#"Value provided for 'aws.protocoltests.restjson.validation#EnumTraitString' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, ghi]"#
                 r#"Value provided for 'aws.protocoltests.restjson.validation#EnumTraitString' failed to satisfy constraint: Member must satisfy enum value set: [abc, def]"#
-143
+            )
-144
+        }
-145
+    }
-146
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {
             crate::model::ValidationExceptionField {
                 message: format!(
                     r#"Value at '{}' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, ghi]"#,
                     r#"Value at '{}' failed to satisfy constraint: Member must satisfy enum value set: [abc, def]"#,
                     &path
                 ),
                 path,
-159
+            }
-160
+        }
-161
+    }
-162
+}
 impl ::std::convert::TryFrom<&str> for EnumTraitString {
     type Error = crate::model::enum_trait_string::ConstraintViolation;
     fn try_from(

↧ Expand context

         s: &str,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<&str>>::Error> {
         match s {
             "abc" => Ok(EnumTraitString::Abc),
             "def" => Ok(EnumTraitString::Def),
             "ghi" => Ok(EnumTraitString::Ghi),
             _ => Err(crate::model::enum_trait_string::ConstraintViolation(
                 s.to_owned(),
             )),
-175
+        }
-176
+    }
-177
+}
 impl ::std::convert::TryFrom<::std::string::String> for EnumTraitString {
     type Error = crate::model::enum_trait_string::ConstraintViolation;
     fn try_from(
         s: ::std::string::String,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<::std::string::String>>::Error>
-183
+    {
         s.as_str().try_into()
-185
+    }

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

@@ -82,82 +142,141 @@

↥ Expand context

     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedEnumError
-85
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_enum::ser_malformed_enum_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 response
-93
+            }
             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))
-97
+            }
-98
+        }
-99
+    }
-100
+}
-101

 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod malformed_enum_test {
-105
     /// When a string member does not contain a valid enum value,
     /// the response should be a 400 ValidationException. Internal-only
     /// enum values are excluded from the response message.
     /// Test ID: RestJsonMalformedEnumString_case0
     #[::tokio::test]
     #[::tracing_test::traced_test]
     #[should_panic]
     async fn rest_json_malformed_enum_string_case0_malformed_request() {
-113
+        {
             #[allow(unused_mut)]
             let mut http_request = ::http_1x::Request::builder()
                 .uri("/MalformedEnum")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::boxed(
                     ::http_body_util::Full::new(::bytes::Bytes::copy_from_slice(
                         &::aws_smithy_protocol_test::decode_body_data(

↧ Expand context

                             "{ \"string\" : \"ABC\" }".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::RestJsonValidationConfig::builder().build();
             let service = crate::service::RestJsonValidation::builder::<::aws_smithy_http_server::body::BoxBody, _, _, _>(config)
                             .malformed_enum(
                                 // Rust 1.94+ flags the moved `sender` as "value captured is never read"
                                 // since `send()` only borrows it.
                                 #[allow(unused_assignments)]
                                 move |input: crate::input::MalformedEnumInput| {
                                     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::MalformedEnumOutput, crate::error::MalformedEnumError> };
                                         sender.send(()).await.expect("receiver dropped early");
                                         result

@@ -148,147 +208,206 @@

↥ Expand context

                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 ::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,
             ));
             use ::http_body_util::BodyExt;
             let body = http_response
                 .into_body()
                 .collect()
                 .await
                 .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 at '/string' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]\",\n  \"fieldList\" : [{\"message\": \"Value at '/string' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]\", \"path\": \"/string\"}]}", ::aws_smithy_protocol_test::MediaType::from("application/json"))

             );
-168
+        }
-169
+    }
-170
     /// When a string member does not contain a valid enum value,
     /// the response should be a 400 ValidationException. Internal-only
     /// enum values are excluded from the response message.
     /// Test ID: RestJsonMalformedEnumString_case1
     #[::tokio::test]
     #[::tracing_test::traced_test]
     #[should_panic]
     async fn rest_json_malformed_enum_string_case1_malformed_request() {
-178
+        {
             #[allow(unused_mut)]
             let mut http_request = ::http_1x::Request::builder()
                 .uri("/MalformedEnum")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::boxed(
                     ::http_body_util::Full::new(::bytes::Bytes::copy_from_slice(
                         &::aws_smithy_protocol_test::decode_body_data(

↧ Expand context

                             "{ \"string\" : \"XYZ\" }".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::RestJsonValidationConfig::builder().build();
             let service = crate::service::RestJsonValidation::builder::<::aws_smithy_http_server::body::BoxBody, _, _, _>(config)
                             .malformed_enum(
                                 // Rust 1.94+ flags the moved `sender` as "value captured is never read"
                                 // since `send()` only borrows it.
                                 #[allow(unused_assignments)]
                                 move |input: crate::input::MalformedEnumInput| {
                                     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::MalformedEnumOutput, crate::error::MalformedEnumError> };
                                         sender.send(()).await.expect("receiver dropped early");
                                         result

@@ -214,212 +274,271 @@

↥ Expand context

                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 ::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,
             ));
             use ::http_body_util::BodyExt;
             let body = http_response
                 .into_body()
                 .collect()
                 .await
                 .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 at '/string' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]\",\n  \"fieldList\" : [{\"message\": \"Value at '/string' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]\", \"path\": \"/string\"}]}", ::aws_smithy_protocol_test::MediaType::from("application/json"))

             );
-233
+        }
-234
+    }
-235
     /// When a string member does not contain a valid enum value,
     /// the response should be a 400 ValidationException. Internal-only
     /// enum values are excluded from the response message.
     /// Test ID: RestJsonMalformedEnumTraitString_case0
     #[::tokio::test]
     #[::tracing_test::traced_test]
     #[should_panic]
     async fn rest_json_malformed_enum_trait_string_case0_malformed_request() {
-243
+        {
             #[allow(unused_mut)]
             let mut http_request = ::http_1x::Request::builder()
                 .uri("/MalformedEnum")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::boxed(
                     ::http_body_util::Full::new(::bytes::Bytes::copy_from_slice(
                         &::aws_smithy_protocol_test::decode_body_data(

↧ Expand context

                             "{ \"stringWithEnumTrait\" : \"ABC\" }".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::RestJsonValidationConfig::builder().build();
             let service = crate::service::RestJsonValidation::builder::<::aws_smithy_http_server::body::BoxBody, _, _, _>(config)
                             .malformed_enum(
                                 // Rust 1.94+ flags the moved `sender` as "value captured is never read"
                                 // since `send()` only borrows it.
                                 #[allow(unused_assignments)]
                                 move |input: crate::input::MalformedEnumInput| {
                                     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::MalformedEnumOutput, crate::error::MalformedEnumError> };
                                         sender.send(()).await.expect("receiver dropped early");
                                         result

@@ -280,277 +340,336 @@

↥ Expand context

                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 ::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,
             ));
             use ::http_body_util::BodyExt;
             let body = http_response
                 .into_body()
                 .collect()
                 .await
                 .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 at '/stringWithEnumTrait' failed to satisfy constraint: Member must satisfy enum value set: [abc, def]\",\n  \"fieldList\" : [{\"message\": \"Value at '/stringWithEnumTrait' failed to satisfy constraint: Member must satisfy enum value set: [abc, def]\", \"path\": \"/stringWithEnumTrait\"}]}", ::aws_smithy_protocol_test::MediaType::from("application/json"))

             );
-298
+        }
-299
+    }
-300
     /// When a string member does not contain a valid enum value,
     /// the response should be a 400 ValidationException. Internal-only
     /// enum values are excluded from the response message.
     /// Test ID: RestJsonMalformedEnumTraitString_case1
     #[::tokio::test]
     #[::tracing_test::traced_test]
     #[should_panic]
     async fn rest_json_malformed_enum_trait_string_case1_malformed_request() {
-308
+        {
             #[allow(unused_mut)]
             let mut http_request = ::http_1x::Request::builder()
                 .uri("/MalformedEnum")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::boxed(
                     ::http_body_util::Full::new(::bytes::Bytes::copy_from_slice(
                         &::aws_smithy_protocol_test::decode_body_data(

↧ Expand context

                             "{ \"stringWithEnumTrait\" : \"XYZ\" }".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::RestJsonValidationConfig::builder().build();
             let service = crate::service::RestJsonValidation::builder::<::aws_smithy_http_server::body::BoxBody, _, _, _>(config)
                             .malformed_enum(
                                 // Rust 1.94+ flags the moved `sender` as "value captured is never read"
                                 // since `send()` only borrows it.
                                 #[allow(unused_assignments)]
                                 move |input: crate::input::MalformedEnumInput| {
                                     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::MalformedEnumOutput, crate::error::MalformedEnumError> };
                                         sender.send(()).await.expect("receiver dropped early");
                                         result

@@ -346,342 +406,401 @@

↥ Expand context

                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 ::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,
             ));
             use ::http_body_util::BodyExt;
             let body = http_response
                 .into_body()
                 .collect()
                 .await
                 .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 at '/stringWithEnumTrait' failed to satisfy constraint: Member must satisfy enum value set: [abc, def]\",\n  \"fieldList\" : [{\"message\": \"Value at '/stringWithEnumTrait' failed to satisfy constraint: Member must satisfy enum value set: [abc, def]\", \"path\": \"/stringWithEnumTrait\"}]}", ::aws_smithy_protocol_test::MediaType::from("application/json"))

             );
-363
+        }
-364
+    }
-365
     /// When a list member value does not contain a valid enum value,
     /// the response should be a 400 ValidationException. Internal-only
     /// enum values are excluded from the response message.
     /// Test ID: RestJsonMalformedEnumList_case0
     #[::tokio::test]
     #[::tracing_test::traced_test]
     #[should_panic]
     async fn rest_json_malformed_enum_list_case0_malformed_request() {
-373
+        {
             #[allow(unused_mut)]
             let mut http_request = ::http_1x::Request::builder()
                 .uri("/MalformedEnum")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::boxed(
                     ::http_body_util::Full::new(::bytes::Bytes::copy_from_slice(
                         &::aws_smithy_protocol_test::decode_body_data(

↧ Expand context

                             "{ \"list\" : [\"ABC\"] }".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::RestJsonValidationConfig::builder().build();
             let service = crate::service::RestJsonValidation::builder::<::aws_smithy_http_server::body::BoxBody, _, _, _>(config)
                             .malformed_enum(
                                 // Rust 1.94+ flags the moved `sender` as "value captured is never read"
                                 // since `send()` only borrows it.
                                 #[allow(unused_assignments)]
                                 move |input: crate::input::MalformedEnumInput| {
                                     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::MalformedEnumOutput, crate::error::MalformedEnumError> };
                                         sender.send(()).await.expect("receiver dropped early");
                                         result

@@ -412,407 +472,466 @@

↥ Expand context

                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 ::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,
             ));
             use ::http_body_util::BodyExt;
             let body = http_response
                 .into_body()
                 .collect()
                 .await
                 .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 at '/list/0' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]\",\n  \"fieldList\" : [{\"message\": \"Value at '/list/0' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]\", \"path\": \"/list/0\"}]}", ::aws_smithy_protocol_test::MediaType::from("application/json"))

             );
-428
+        }
-429
+    }
-430
     /// When a list member value does not contain a valid enum value,
     /// the response should be a 400 ValidationException. Internal-only
     /// enum values are excluded from the response message.
     /// Test ID: RestJsonMalformedEnumList_case1
     #[::tokio::test]
     #[::tracing_test::traced_test]
     #[should_panic]
     async fn rest_json_malformed_enum_list_case1_malformed_request() {
-438
+        {
             #[allow(unused_mut)]
             let mut http_request = ::http_1x::Request::builder()
                 .uri("/MalformedEnum")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::boxed(
                     ::http_body_util::Full::new(::bytes::Bytes::copy_from_slice(
                         &::aws_smithy_protocol_test::decode_body_data(

↧ Expand context

                             "{ \"list\" : [\"XYZ\"] }".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::RestJsonValidationConfig::builder().build();
             let service = crate::service::RestJsonValidation::builder::<::aws_smithy_http_server::body::BoxBody, _, _, _>(config)
                             .malformed_enum(
                                 // Rust 1.94+ flags the moved `sender` as "value captured is never read"
                                 // since `send()` only borrows it.
                                 #[allow(unused_assignments)]
                                 move |input: crate::input::MalformedEnumInput| {
                                     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::MalformedEnumOutput, crate::error::MalformedEnumError> };
                                         sender.send(()).await.expect("receiver dropped early");
                                         result

@@ -478,472 +538,531 @@

↥ Expand context

                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 ::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,
             ));
             use ::http_body_util::BodyExt;
             let body = http_response
                 .into_body()
                 .collect()
                 .await
                 .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 at '/list/0' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]\",\n  \"fieldList\" : [{\"message\": \"Value at '/list/0' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]\", \"path\": \"/list/0\"}]}", ::aws_smithy_protocol_test::MediaType::from("application/json"))

             );
-493
+        }
-494
+    }
-495
     /// When a map member's key does not contain a valid enum value,
     /// the response should be a 400 ValidationException. Internal-only
     /// enum values are excluded from the response message.
     /// Test ID: RestJsonMalformedEnumMapKey_case0
     #[::tokio::test]
     #[::tracing_test::traced_test]
     #[should_panic]
     async fn rest_json_malformed_enum_map_key_case0_malformed_request() {
-503
+        {
             #[allow(unused_mut)]
             let mut http_request = ::http_1x::Request::builder()
                 .uri("/MalformedEnum")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::boxed(
                     ::http_body_util::Full::new(::bytes::Bytes::copy_from_slice(
                         &::aws_smithy_protocol_test::decode_body_data(

↧ Expand context

                             "{ \"map\" : { \"ABC\" : \"abc\" } }".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::RestJsonValidationConfig::builder().build();
             let service = crate::service::RestJsonValidation::builder::<::aws_smithy_http_server::body::BoxBody, _, _, _>(config)
                             .malformed_enum(
                                 // Rust 1.94+ flags the moved `sender` as "value captured is never read"
                                 // since `send()` only borrows it.
                                 #[allow(unused_assignments)]
                                 move |input: crate::input::MalformedEnumInput| {
                                     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::MalformedEnumOutput, crate::error::MalformedEnumError> };
                                         sender.send(()).await.expect("receiver dropped early");
                                         result

@@ -544,537 +604,596 @@

↥ Expand context

                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 ::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,
             ));
             use ::http_body_util::BodyExt;
             let body = http_response
                 .into_body()
                 .collect()
                 .await
                 .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 at '/map' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]\",\n  \"fieldList\" : [{\"message\": \"Value at '/map' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]\", \"path\": \"/map\"}]}", ::aws_smithy_protocol_test::MediaType::from("application/json"))

             );
-558
+        }
-559
+    }
-560
     /// When a map member's key does not contain a valid enum value,
     /// the response should be a 400 ValidationException. Internal-only
     /// enum values are excluded from the response message.
     /// Test ID: RestJsonMalformedEnumMapKey_case1
     #[::tokio::test]
     #[::tracing_test::traced_test]
     #[should_panic]
     async fn rest_json_malformed_enum_map_key_case1_malformed_request() {
-568
+        {
             #[allow(unused_mut)]
             let mut http_request = ::http_1x::Request::builder()
                 .uri("/MalformedEnum")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::boxed(
                     ::http_body_util::Full::new(::bytes::Bytes::copy_from_slice(
                         &::aws_smithy_protocol_test::decode_body_data(

↧ Expand context

                             "{ \"map\" : { \"XYZ\" : \"abc\" } }".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::RestJsonValidationConfig::builder().build();
             let service = crate::service::RestJsonValidation::builder::<::aws_smithy_http_server::body::BoxBody, _, _, _>(config)
                             .malformed_enum(
                                 // Rust 1.94+ flags the moved `sender` as "value captured is never read"
                                 // since `send()` only borrows it.
                                 #[allow(unused_assignments)]
                                 move |input: crate::input::MalformedEnumInput| {
                                     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::MalformedEnumOutput, crate::error::MalformedEnumError> };
                                         sender.send(()).await.expect("receiver dropped early");
                                         result

@@ -610,602 +670,661 @@

↥ Expand context

                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 ::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,
             ));
             use ::http_body_util::BodyExt;
             let body = http_response
                 .into_body()
                 .collect()
                 .await
                 .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 at '/map' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]\",\n  \"fieldList\" : [{\"message\": \"Value at '/map' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]\", \"path\": \"/map\"}]}", ::aws_smithy_protocol_test::MediaType::from("application/json"))

             );
-623
+        }
-624
+    }
-625
     /// When a map member's value does not contain a valid enum value,
     /// the response should be a 400 ValidationException. Internal-only
     /// enum values are excluded from the response message.
     /// Test ID: RestJsonMalformedEnumMapValue_case0
     #[::tokio::test]
     #[::tracing_test::traced_test]
     #[should_panic]
     async fn rest_json_malformed_enum_map_value_case0_malformed_request() {
-633
+        {
             #[allow(unused_mut)]
             let mut http_request = ::http_1x::Request::builder()
                 .uri("/MalformedEnum")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::boxed(
                     ::http_body_util::Full::new(::bytes::Bytes::copy_from_slice(
                         &::aws_smithy_protocol_test::decode_body_data(

↧ Expand context

                             "{ \"map\" : { \"abc\": \"ABC\" } }".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::RestJsonValidationConfig::builder().build();
             let service = crate::service::RestJsonValidation::builder::<::aws_smithy_http_server::body::BoxBody, _, _, _>(config)
                             .malformed_enum(
                                 // Rust 1.94+ flags the moved `sender` as "value captured is never read"
                                 // since `send()` only borrows it.
                                 #[allow(unused_assignments)]
                                 move |input: crate::input::MalformedEnumInput| {
                                     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::MalformedEnumOutput, crate::error::MalformedEnumError> };
                                         sender.send(()).await.expect("receiver dropped early");
                                         result

@@ -676,667 +736,726 @@

↥ Expand context

                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 ::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,
             ));
             use ::http_body_util::BodyExt;
             let body = http_response
                 .into_body()
                 .collect()
                 .await
                 .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 at '/map/abc' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]\",\n  \"fieldList\" : [{\"message\": \"Value at '/map/abc' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]\", \"path\": \"/map/abc\"}]}", ::aws_smithy_protocol_test::MediaType::from("application/json"))

             );
-688
+        }
-689
+    }
-690
     /// When a map member's value does not contain a valid enum value,
     /// the response should be a 400 ValidationException. Internal-only
     /// enum values are excluded from the response message.
     /// Test ID: RestJsonMalformedEnumMapValue_case1
     #[::tokio::test]
     #[::tracing_test::traced_test]
     #[should_panic]
     async fn rest_json_malformed_enum_map_value_case1_malformed_request() {
-698
+        {
             #[allow(unused_mut)]
             let mut http_request = ::http_1x::Request::builder()
                 .uri("/MalformedEnum")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::boxed(
                     ::http_body_util::Full::new(::bytes::Bytes::copy_from_slice(
                         &::aws_smithy_protocol_test::decode_body_data(

↧ Expand context

                             "{ \"map\" : { \"abc\": \"XYZ\" } }".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::RestJsonValidationConfig::builder().build();
             let service = crate::service::RestJsonValidation::builder::<::aws_smithy_http_server::body::BoxBody, _, _, _>(config)
                             .malformed_enum(
                                 // Rust 1.94+ flags the moved `sender` as "value captured is never read"
                                 // since `send()` only borrows it.
                                 #[allow(unused_assignments)]
                                 move |input: crate::input::MalformedEnumInput| {
                                     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::MalformedEnumOutput, crate::error::MalformedEnumError> };
                                         sender.send(()).await.expect("receiver dropped early");
                                         result

@@ -742,732 +802,791 @@

↥ Expand context

                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 ::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,
             ));
             use ::http_body_util::BodyExt;
             let body = http_response
                 .into_body()
                 .collect()
                 .await
                 .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 at '/map/abc' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]\",\n  \"fieldList\" : [{\"message\": \"Value at '/map/abc' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]\", \"path\": \"/map/abc\"}]}", ::aws_smithy_protocol_test::MediaType::from("application/json"))

             );
-753
+        }
-754
+    }
-755
     /// When a union member's value does not contain a valid enum value,
     /// the response should be a 400 ValidationException. Internal-only
     /// enum values are excluded from the response message.
     /// Test ID: RestJsonMalformedEnumUnion_case0
     #[::tokio::test]
     #[::tracing_test::traced_test]
     #[should_panic]
     async fn rest_json_malformed_enum_union_case0_malformed_request() {
-763
+        {
             #[allow(unused_mut)]
             let mut http_request = ::http_1x::Request::builder()
                 .uri("/MalformedEnum")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::boxed(
                     ::http_body_util::Full::new(::bytes::Bytes::copy_from_slice(
                         &::aws_smithy_protocol_test::decode_body_data(

↧ Expand context

                             "{ \"union\" : { \"first\": \"ABC\" } }".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::RestJsonValidationConfig::builder().build();
             let service = crate::service::RestJsonValidation::builder::<::aws_smithy_http_server::body::BoxBody, _, _, _>(config)
                             .malformed_enum(
                                 // Rust 1.94+ flags the moved `sender` as "value captured is never read"
                                 // since `send()` only borrows it.
                                 #[allow(unused_assignments)]
                                 move |input: crate::input::MalformedEnumInput| {
                                     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::MalformedEnumOutput, crate::error::MalformedEnumError> };
                                         sender.send(()).await.expect("receiver dropped early");
                                         result

@@ -808,797 +868,856 @@

↥ Expand context

                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 ::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,
             ));
             use ::http_body_util::BodyExt;
             let body = http_response
                 .into_body()
                 .collect()
                 .await
                 .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 at '/union/first' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]\",\n  \"fieldList\" : [{\"message\": \"Value at '/union/first' failed to satisfy constraint: Member must satisfy enum value set: [abc, def, jkl]\", \"path\": \"/union/first\"}]}", ::aws_smithy_protocol_test::MediaType::from("application/json"))

             );
-818
+        }
-819
+    }
-820
     /// When a union member's value does not contain a valid enum value,
     /// the response should be a 400 ValidationException. Internal-only
     /// enum values are excluded from the response message.
     /// Test ID: RestJsonMalformedEnumUnion_case1
     #[::tokio::test]
     #[::tracing_test::traced_test]
     #[should_panic]
     async fn rest_json_malformed_enum_union_case1_malformed_request() {
-828
+        {
             #[allow(unused_mut)]
             let mut http_request = ::http_1x::Request::builder()
                 .uri("/MalformedEnum")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::boxed(
                     ::http_body_util::Full::new(::bytes::Bytes::copy_from_slice(
                         &::aws_smithy_protocol_test::decode_body_data(

↧ Expand context

                             "{ \"union\" : { \"first\": \"XYZ\" } }".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::RestJsonValidationConfig::builder().build();
             let service = crate::service::RestJsonValidation::builder::<::aws_smithy_http_server::body::BoxBody, _, _, _>(config)
                             .malformed_enum(
                                 // Rust 1.94+ flags the moved `sender` as "value captured is never read"
                                 // since `send()` only borrows it.
                                 #[allow(unused_assignments)]
                                 move |input: crate::input::MalformedEnumInput| {
                                     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::MalformedEnumOutput, crate::error::MalformedEnumError> };
                                         sender.send(()).await.expect("receiver dropped early");
                                         result

Pages: 1