loafle/openapi-generator-original
3
0
Fork 1
mirror of https://github.com/OpenAPITools/openapi-generator.git synced 2025-11-04 10:43:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

Map type date to correct rust type NaiveDate (#17095)

Browse Source 
* Fix clippy errors (rustc 1.73.0)

* Add feature docker-in-docker

* Fix mapping of "date"

See issue #9769

The type
  type: string
  format: date
was mapped to DateTime<Utc> which violates the OpenAPI spec

see https://swagger.io/docs/specification/data-models/data-types/
This commit is contained in:
Markus Lenger 2023-11-18 03:33:45 +01:00 committed by GitHub
parent 5c69284928
commit 1ce95ff41e
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
19 changed files with 207 additions and 202 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
.devcontainer/devcontainer.json
View File

@ -9,7 +9,12 @@
"ghcr.io/devcontainers/features/node:1": { "ghcr.io/devcontainers/features/node:1": {
"version": "lts" "version": "lts"
}, },
"ghcr.io/snebjorn/devcontainer-feature/chromium:latest": {} "ghcr.io/snebjorn/devcontainer-feature/chromium:latest": {},
"docker-in-docker": {
"version": "latest",
"moby": true,
"dockerDashComposeVersion": "v1"
}
}, },
// Configure tool-specific properties. // Configure tool-specific properties.
"customizations": { "customizations": {

2
modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/RustServerCodegen.java
View File

@ -193,7 +193,7 @@ public class RustServerCodegen extends AbstractRustCodegen implements CodegenCon
typeMapping.put("ByteArray", bytesType); typeMapping.put("ByteArray", bytesType);
typeMapping.put("binary", bytesType); typeMapping.put("binary", bytesType);
typeMapping.put("boolean", "bool"); typeMapping.put("boolean", "bool");
typeMapping.put("date", "chrono::DateTime::<chrono::Utc>"); typeMapping.put("date", "chrono::naive::NaiveDate");
typeMapping.put("DateTime", "chrono::DateTime::<chrono::Utc>"); typeMapping.put("DateTime", "chrono::DateTime::<chrono::Utc>");
typeMapping.put("password", "String"); typeMapping.put("password", "String");
typeMapping.put("File", bytesType); typeMapping.put("File", bytesType);

6
modules/openapi-generator/src/main/resources/rust-server/client-operation.mustache vendored
View File

@ -310,7 +310,7 @@
match auth_data { match auth_data {
{{#authMethods}} {{#authMethods}}
{{#isBasicBasic}} {{#isBasicBasic}}
&AuthData::Basic(ref basic_header) => { AuthData::Basic(basic_header) => {
let auth = swagger::auth::Header(basic_header.clone()); let auth = swagger::auth::Header(basic_header.clone());
let header = match HeaderValue::from_str(&format!("{}", auth)) { let header = match HeaderValue::from_str(&format!("{}", auth)) {
Ok(h) => h, Ok(h) => h,
@ -322,7 +322,7 @@
}, },
{{/isBasicBasic}} {{/isBasicBasic}}
{{#isBasicBearer}} {{#isBasicBearer}}
&AuthData::Bearer(ref bearer_header) => { AuthData::Bearer(bearer_header) => {
let auth = swagger::auth::Header(bearer_header.clone()); let auth = swagger::auth::Header(bearer_header.clone());
let header = match HeaderValue::from_str(&format!("{}", auth)) { let header = match HeaderValue::from_str(&format!("{}", auth)) {
Ok(h) => h, Ok(h) => h,
@ -335,7 +335,7 @@
{{/isBasicBearer}} {{/isBasicBearer}}
{{#isOAuth}} {{#isOAuth}}
{{^isBasicBearer}} {{^isBasicBearer}}
&AuthData::Bearer(ref bearer_header) => { AuthData::Bearer(bearer_header) => {
let auth = swagger::auth::Header(bearer_header.clone()); let auth = swagger::auth::Header(bearer_header.clone());
let header = match HeaderValue::from_str(&format!("{}", auth)) { let header = match HeaderValue::from_str(&format!("{}", auth)) {
Ok(h) => h, Ok(h) => h,

2
modules/openapi-generator/src/main/resources/rust-server/models.mustache vendored
View File

@ -389,7 +389,7 @@ impl std::string::ToString for {{{classname}}} {
{{/required}} {{/required}}
{{^required}} {{^required}}
self.{{{name}}}.as_ref().map(|{{{name}}}| { self.{{{name}}}.as_ref().map(|{{{name}}}| {
vec![ [
"{{{baseName}}}".to_string(), "{{{baseName}}}".to_string(),
{{^isArray}} {{^isArray}}
{{#isNullable}} {{#isNullable}}

12
modules/openapi-generator/src/main/resources/rust-server/server-operation.mustache vendored
View File

@ -574,27 +574,27 @@
{{#vendorExtensions}} {{#vendorExtensions}}
{{#x-produces-xml}} {{#x-produces-xml}}
{{^x-has-namespace}} {{^x-has-namespace}}
let body = serde_xml_rs::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_xml_rs::to_string(&body).expect("impossible to fail to serialize");
{{/x-has-namespace}} {{/x-has-namespace}}
{{#x-has-namespace}} {{#x-has-namespace}}
let mut namespaces = std::collections::BTreeMap::new(); let mut namespaces = std::collections::BTreeMap::new();
// An empty string is used to indicate a global namespace in xmltree. // An empty string is used to indicate a global namespace in xmltree.
namespaces.insert("".to_string(), {{{dataType}}}::NAMESPACE.to_string()); namespaces.insert("".to_string(), {{{dataType}}}::NAMESPACE.to_string());
let body = serde_xml_rs::to_string_with_namespaces(&body, namespaces).expect("impossible to fail to serialize"); let body_content = serde_xml_rs::to_string_with_namespaces(&body, namespaces).expect("impossible to fail to serialize");
{{/x-has-namespace}} {{/x-has-namespace}}
{{/x-produces-xml}} {{/x-produces-xml}}
{{#x-produces-json}} {{#x-produces-json}}
let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_json::to_string(&body).expect("impossible to fail to serialize");
{{/x-produces-json}} {{/x-produces-json}}
{{#x-produces-bytes}} {{#x-produces-bytes}}
let body = body.0; let body_content = body.0;
{{/x-produces-bytes}} {{/x-produces-bytes}}
{{#x-produces-plain-text}} {{#x-produces-plain-text}}
let body = body; let body_content = body;
{{/x-produces-plain-text}} {{/x-produces-plain-text}}
{{/vendorExtensions}} {{/vendorExtensions}}
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
{{/dataType}} {{/dataType}}
}, },
{{/responses}} {{/responses}}

2
samples/server/petstore/rust-server/output/multipart-v3/src/models.rs
View File

@ -180,7 +180,7 @@ impl std::string::ToString for MultipartRequestObjectField {
self.field_b.as_ref().map(|field_b| { self.field_b.as_ref().map(|field_b| {
vec![ [
"field_b".to_string(), "field_b".to_string(),
field_b.iter().map(|x| x.to_string()).collect::<Vec<_>>().join(","), field_b.iter().map(|x| x.to_string()).collect::<Vec<_>>().join(","),
].join(",") ].join(",")

4
samples/server/petstore/rust-server/output/openapi-v3/src/client/mod.rs
View File

@ -1165,7 +1165,7 @@ impl<S, C> Api<C> for Client<S, C> where
// Currently only authentication with Basic and Bearer are supported // Currently only authentication with Basic and Bearer are supported
#[allow(clippy::single_match, clippy::match_single_binding)] #[allow(clippy::single_match, clippy::match_single_binding)]
match auth_data { match auth_data {
&AuthData::Bearer(ref bearer_header) => { AuthData::Bearer(bearer_header) => {
let auth = swagger::auth::Header(bearer_header.clone()); let auth = swagger::auth::Header(bearer_header.clone());
let header = match HeaderValue::from_str(&format!("{}", auth)) { let header = match HeaderValue::from_str(&format!("{}", auth)) {
Ok(h) => h, Ok(h) => h,
@ -1489,7 +1489,7 @@ impl<S, C> Api<C> for Client<S, C> where
// Currently only authentication with Basic and Bearer are supported // Currently only authentication with Basic and Bearer are supported
#[allow(clippy::single_match, clippy::match_single_binding)] #[allow(clippy::single_match, clippy::match_single_binding)]
match auth_data { match auth_data {
&AuthData::Bearer(ref bearer_header) => { AuthData::Bearer(bearer_header) => {
let auth = swagger::auth::Header(bearer_header.clone()); let auth = swagger::auth::Header(bearer_header.clone());
let header = match HeaderValue::from_str(&format!("{}", auth)) { let header = match HeaderValue::from_str(&format!("{}", auth)) {
Ok(h) => h, Ok(h) => h,

24
samples/server/petstore/rust-server/output/openapi-v3/src/models.rs
View File

@ -295,7 +295,7 @@ impl std::string::ToString for AnotherXmlObject {
let params: Vec<Option<String>> = vec![ let params: Vec<Option<String>> = vec![
self.inner_string.as_ref().map(|inner_string| { self.inner_string.as_ref().map(|inner_string| {
vec![ [
"inner_string".to_string(), "inner_string".to_string(),
inner_string.to_string(), inner_string.to_string(),
].join(",") ].join(",")
@ -815,7 +815,7 @@ impl std::string::ToString for DuplicateXmlObject {
let params: Vec<Option<String>> = vec![ let params: Vec<Option<String>> = vec![
self.inner_string.as_ref().map(|inner_string| { self.inner_string.as_ref().map(|inner_string| {
vec![ [
"inner_string".to_string(), "inner_string".to_string(),
inner_string.to_string(), inner_string.to_string(),
].join(",") ].join(",")
@ -1233,7 +1233,7 @@ impl std::string::ToString for MultigetGet201Response {
let params: Vec<Option<String>> = vec![ let params: Vec<Option<String>> = vec![
self.foo.as_ref().map(|foo| { self.foo.as_ref().map(|foo| {
vec![ [
"foo".to_string(), "foo".to_string(),
foo.to_string(), foo.to_string(),
].join(",") ].join(",")
@ -1574,7 +1574,7 @@ impl std::string::ToString for NullableTest {
self.nullable_with_null_default.as_ref().map(|nullable_with_null_default| { self.nullable_with_null_default.as_ref().map(|nullable_with_null_default| {
vec![ [
"nullableWithNullDefault".to_string(), "nullableWithNullDefault".to_string(),
nullable_with_null_default.as_ref().map_or("null".to_string(), |x| x.to_string()), nullable_with_null_default.as_ref().map_or("null".to_string(), |x| x.to_string()),
].join(",") ].join(",")
@ -1582,7 +1582,7 @@ impl std::string::ToString for NullableTest {
self.nullable_with_present_default.as_ref().map(|nullable_with_present_default| { self.nullable_with_present_default.as_ref().map(|nullable_with_present_default| {
vec![ [
"nullableWithPresentDefault".to_string(), "nullableWithPresentDefault".to_string(),
nullable_with_present_default.as_ref().map_or("null".to_string(), |x| x.to_string()), nullable_with_present_default.as_ref().map_or("null".to_string(), |x| x.to_string()),
].join(",") ].join(",")
@ -1590,7 +1590,7 @@ impl std::string::ToString for NullableTest {
self.nullable_with_no_default.as_ref().map(|nullable_with_no_default| { self.nullable_with_no_default.as_ref().map(|nullable_with_no_default| {
vec![ [
"nullableWithNoDefault".to_string(), "nullableWithNoDefault".to_string(),
nullable_with_no_default.as_ref().map_or("null".to_string(), |x| x.to_string()), nullable_with_no_default.as_ref().map_or("null".to_string(), |x| x.to_string()),
].join(",") ].join(",")
@ -1598,7 +1598,7 @@ impl std::string::ToString for NullableTest {
self.nullable_array.as_ref().map(|nullable_array| { self.nullable_array.as_ref().map(|nullable_array| {
vec![ [
"nullableArray".to_string(), "nullableArray".to_string(),
nullable_array.as_ref().map_or("null".to_string(), |x| x.iter().map(|x| x.to_string()).collect::<Vec<_>>().join(",")), nullable_array.as_ref().map_or("null".to_string(), |x| x.iter().map(|x| x.to_string()).collect::<Vec<_>>().join(",")),
].join(",") ].join(",")
@ -1750,7 +1750,7 @@ impl std::string::ToString for ObjectHeader {
self.optional_object_header.as_ref().map(|optional_object_header| { self.optional_object_header.as_ref().map(|optional_object_header| {
vec![ [
"optionalObjectHeader".to_string(), "optionalObjectHeader".to_string(),
optional_object_header.to_string(), optional_object_header.to_string(),
].join(",") ].join(",")
@ -1895,7 +1895,7 @@ impl std::string::ToString for ObjectParam {
self.optional_param.as_ref().map(|optional_param| { self.optional_param.as_ref().map(|optional_param| {
vec![ [
"optionalParam".to_string(), "optionalParam".to_string(),
optional_param.to_string(), optional_param.to_string(),
].join(",") ].join(",")
@ -2189,7 +2189,7 @@ impl std::string::ToString for ObjectWithArrayOfObjects {
let params: Vec<Option<String>> = vec![ let params: Vec<Option<String>> = vec![
self.object_array.as_ref().map(|object_array| { self.object_array.as_ref().map(|object_array| {
vec![ [
"objectArray".to_string(), "objectArray".to_string(),
object_array.iter().map(|x| x.to_string()).collect::<Vec<_>>().join(","), object_array.iter().map(|x| x.to_string()).collect::<Vec<_>>().join(","),
].join(",") ].join(",")
@ -2963,7 +2963,7 @@ impl std::string::ToString for XmlObject {
let params: Vec<Option<String>> = vec![ let params: Vec<Option<String>> = vec![
self.inner_string.as_ref().map(|inner_string| { self.inner_string.as_ref().map(|inner_string| {
vec![ [
"innerString".to_string(), "innerString".to_string(),
inner_string.to_string(), inner_string.to_string(),
].join(",") ].join(",")
@ -2971,7 +2971,7 @@ impl std::string::ToString for XmlObject {
self.other_inner_rename.as_ref().map(|other_inner_rename| { self.other_inner_rename.as_ref().map(|other_inner_rename| {
vec![ [
"other_inner_rename".to_string(), "other_inner_rename".to_string(),
other_inner_rename.to_string(), other_inner_rename.to_string(),
].join(",") ].join(",")

80
samples/server/petstore/rust-server/output/openapi-v3/src/server/mod.rs
View File

@ -257,8 +257,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("application/json") HeaderValue::from_str("application/json")
.expect("Unable to create Content-Type header for ANY_OF_GET_SUCCESS")); .expect("Unable to create Content-Type header for ANY_OF_GET_SUCCESS"));
let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_json::to_string(&body).expect("impossible to fail to serialize");
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
AnyOfGetResponse::AlternateSuccess AnyOfGetResponse::AlternateSuccess
(body) (body)
@ -268,8 +268,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("application/json") HeaderValue::from_str("application/json")
.expect("Unable to create Content-Type header for ANY_OF_GET_ALTERNATE_SUCCESS")); .expect("Unable to create Content-Type header for ANY_OF_GET_ALTERNATE_SUCCESS"));
let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_json::to_string(&body).expect("impossible to fail to serialize");
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
AnyOfGetResponse::AnyOfSuccess AnyOfGetResponse::AnyOfSuccess
(body) (body)
@ -279,8 +279,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("application/json") HeaderValue::from_str("application/json")
.expect("Unable to create Content-Type header for ANY_OF_GET_ANY_OF_SUCCESS")); .expect("Unable to create Content-Type header for ANY_OF_GET_ANY_OF_SUCCESS"));
let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_json::to_string(&body).expect("impossible to fail to serialize");
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
}, },
Err(_) => { Err(_) => {
@ -569,8 +569,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("application/merge-patch+json") HeaderValue::from_str("application/merge-patch+json")
.expect("Unable to create Content-Type header for MERGE_PATCH_JSON_GET_MERGE")); .expect("Unable to create Content-Type header for MERGE_PATCH_JSON_GET_MERGE"));
let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_json::to_string(&body).expect("impossible to fail to serialize");
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
}, },
Err(_) => { Err(_) => {
@ -605,8 +605,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("application/json") HeaderValue::from_str("application/json")
.expect("Unable to create Content-Type header for MULTIGET_GET_JSON_RSP")); .expect("Unable to create Content-Type header for MULTIGET_GET_JSON_RSP"));
let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_json::to_string(&body).expect("impossible to fail to serialize");
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
MultigetGetResponse::XMLRsp MultigetGetResponse::XMLRsp
(body) (body)
@ -616,8 +616,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("application/xml") HeaderValue::from_str("application/xml")
.expect("Unable to create Content-Type header for MULTIGET_GET_XML_RSP")); .expect("Unable to create Content-Type header for MULTIGET_GET_XML_RSP"));
let body = serde_xml_rs::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_xml_rs::to_string(&body).expect("impossible to fail to serialize");
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
MultigetGetResponse::OctetRsp MultigetGetResponse::OctetRsp
(body) (body)
@ -627,8 +627,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("application/octet-stream") HeaderValue::from_str("application/octet-stream")
.expect("Unable to create Content-Type header for MULTIGET_GET_OCTET_RSP")); .expect("Unable to create Content-Type header for MULTIGET_GET_OCTET_RSP"));
let body = body.0; let body_content = body.0;
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
MultigetGetResponse::StringRsp MultigetGetResponse::StringRsp
(body) (body)
@ -638,8 +638,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("text/plain") HeaderValue::from_str("text/plain")
.expect("Unable to create Content-Type header for MULTIGET_GET_STRING_RSP")); .expect("Unable to create Content-Type header for MULTIGET_GET_STRING_RSP"));
let body = body; let body_content = body;
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
MultigetGetResponse::DuplicateResponseLongText MultigetGetResponse::DuplicateResponseLongText
(body) (body)
@ -649,8 +649,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("application/json") HeaderValue::from_str("application/json")
.expect("Unable to create Content-Type header for MULTIGET_GET_DUPLICATE_RESPONSE_LONG_TEXT")); .expect("Unable to create Content-Type header for MULTIGET_GET_DUPLICATE_RESPONSE_LONG_TEXT"));
let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_json::to_string(&body).expect("impossible to fail to serialize");
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
MultigetGetResponse::DuplicateResponseLongText_2 MultigetGetResponse::DuplicateResponseLongText_2
(body) (body)
@ -660,8 +660,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("application/json") HeaderValue::from_str("application/json")
.expect("Unable to create Content-Type header for MULTIGET_GET_DUPLICATE_RESPONSE_LONG_TEXT_2")); .expect("Unable to create Content-Type header for MULTIGET_GET_DUPLICATE_RESPONSE_LONG_TEXT_2"));
let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_json::to_string(&body).expect("impossible to fail to serialize");
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
MultigetGetResponse::DuplicateResponseLongText_3 MultigetGetResponse::DuplicateResponseLongText_3
(body) (body)
@ -671,8 +671,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("application/json") HeaderValue::from_str("application/json")
.expect("Unable to create Content-Type header for MULTIGET_GET_DUPLICATE_RESPONSE_LONG_TEXT_3")); .expect("Unable to create Content-Type header for MULTIGET_GET_DUPLICATE_RESPONSE_LONG_TEXT_3"));
let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_json::to_string(&body).expect("impossible to fail to serialize");
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
}, },
Err(_) => { Err(_) => {
@ -766,8 +766,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("application/json") HeaderValue::from_str("application/json")
.expect("Unable to create Content-Type header for ONE_OF_GET_SUCCESS")); .expect("Unable to create Content-Type header for ONE_OF_GET_SUCCESS"));
let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_json::to_string(&body).expect("impossible to fail to serialize");
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
}, },
Err(_) => { Err(_) => {
@ -888,8 +888,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("application/json") HeaderValue::from_str("application/json")
.expect("Unable to create Content-Type header for PARAMGET_GET_JSON_RSP")); .expect("Unable to create Content-Type header for PARAMGET_GET_JSON_RSP"));
let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_json::to_string(&body).expect("impossible to fail to serialize");
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
}, },
Err(_) => { Err(_) => {
@ -1145,8 +1145,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("application/json") HeaderValue::from_str("application/json")
.expect("Unable to create Content-Type header for RESPONSES_WITH_HEADERS_GET_SUCCESS")); .expect("Unable to create Content-Type header for RESPONSES_WITH_HEADERS_GET_SUCCESS"));
let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_json::to_string(&body).expect("impossible to fail to serialize");
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
ResponsesWithHeadersGetResponse::PreconditionFailed ResponsesWithHeadersGetResponse::PreconditionFailed
{ {
@ -1221,8 +1221,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("application/json") HeaderValue::from_str("application/json")
.expect("Unable to create Content-Type header for RFC7807_GET_OK")); .expect("Unable to create Content-Type header for RFC7807_GET_OK"));
let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_json::to_string(&body).expect("impossible to fail to serialize");
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
Rfc7807GetResponse::NotFound Rfc7807GetResponse::NotFound
(body) (body)
@ -1232,8 +1232,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("application/problem+json") HeaderValue::from_str("application/problem+json")
.expect("Unable to create Content-Type header for RFC7807_GET_NOT_FOUND")); .expect("Unable to create Content-Type header for RFC7807_GET_NOT_FOUND"));
let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_json::to_string(&body).expect("impossible to fail to serialize");
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
Rfc7807GetResponse::NotAcceptable Rfc7807GetResponse::NotAcceptable
(body) (body)
@ -1243,8 +1243,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("application/problem+xml") HeaderValue::from_str("application/problem+xml")
.expect("Unable to create Content-Type header for RFC7807_GET_NOT_ACCEPTABLE")); .expect("Unable to create Content-Type header for RFC7807_GET_NOT_ACCEPTABLE"));
let body = serde_xml_rs::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_xml_rs::to_string(&body).expect("impossible to fail to serialize");
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
}, },
Err(_) => { Err(_) => {
@ -1342,8 +1342,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("application/json") HeaderValue::from_str("application/json")
.expect("Unable to create Content-Type header for UUID_GET_DUPLICATE_RESPONSE_LONG_TEXT")); .expect("Unable to create Content-Type header for UUID_GET_DUPLICATE_RESPONSE_LONG_TEXT"));
let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_json::to_string(&body).expect("impossible to fail to serialize");
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
}, },
Err(_) => { Err(_) => {
@ -1477,8 +1477,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
// An empty string is used to indicate a global namespace in xmltree. // An empty string is used to indicate a global namespace in xmltree.
namespaces.insert("".to_string(), models::AnotherXmlObject::NAMESPACE.to_string()); namespaces.insert("".to_string(), models::AnotherXmlObject::NAMESPACE.to_string());
let body = serde_xml_rs::to_string_with_namespaces(&body, namespaces).expect("impossible to fail to serialize"); let body_content = serde_xml_rs::to_string_with_namespaces(&body, namespaces).expect("impossible to fail to serialize");
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
XmlOtherPostResponse::BadRequest XmlOtherPostResponse::BadRequest
=> { => {
@ -1821,8 +1821,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("application/json") HeaderValue::from_str("application/json")
.expect("Unable to create Content-Type header for GET_REPO_INFO_OK")); .expect("Unable to create Content-Type header for GET_REPO_INFO_OK"));
let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_json::to_string(&body).expect("impossible to fail to serialize");
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
}, },
Err(_) => { Err(_) => {

2
samples/server/petstore/rust-server/output/petstore-with-fake-endpoints-models-for-testing/docs/FormatTest.md
View File

@ -12,7 +12,7 @@ Name | Type | Description | Notes
**string** | **String** | | [optional] [default to None] **string** | **String** | | [optional] [default to None]
**byte** | [***swagger::ByteArray**](ByteArray.md) | | **byte** | [***swagger::ByteArray**](ByteArray.md) | |
**binary** | [***swagger::ByteArray**](file.md) | | [optional] [default to None] **binary** | [***swagger::ByteArray**](file.md) | | [optional] [default to None]
**date** | [***chrono::DateTime::<chrono::Utc>**](date.md) | | **date** | [***chrono::naive::NaiveDate**](date.md) | |
**date_time** | [**chrono::DateTime::<chrono::Utc>**](DateTime.md) | | [optional] [default to None] **date_time** | [**chrono::DateTime::<chrono::Utc>**](DateTime.md) | | [optional] [default to None]
**uuid** | [***uuid::Uuid**](UUID.md) | | [optional] [default to None] **uuid** | [***uuid::Uuid**](UUID.md) | | [optional] [default to None]
**password** | **String** | | **password** | **String** | |

2
samples/server/petstore/rust-server/output/petstore-with-fake-endpoints-models-for-testing/docs/fake_api.md
View File

@ -311,7 +311,7 @@ Name | Type | Description | Notes
**float** | **f32**| None | **float** | **f32**| None |
**string** | **String**| None | **string** | **String**| None |
**binary** | **swagger::ByteArray**| None | **binary** | **swagger::ByteArray**| None |
**date** | **chrono::DateTime::<chrono::Utc>**| None | **date** | **chrono::naive::NaiveDate**| None |
**date_time** | **chrono::DateTime::<chrono::Utc>**| None | **date_time** | **chrono::DateTime::<chrono::Utc>**| None |
**password** | **String**| None | **password** | **String**| None |
**callback** | **String**| None | **callback** | **String**| None |

2
samples/server/petstore/rust-server/output/petstore-with-fake-endpoints-models-for-testing/examples/server/server.rs
View File

@ -241,7 +241,7 @@ impl<C> Api<C> for Server<C> where C: Has<XSpanIdString> + Send + Sync
float: Option<f32>, float: Option<f32>,
string: Option<String>, string: Option<String>,
binary: Option<swagger::ByteArray>, binary: Option<swagger::ByteArray>,
date: Option<chrono::DateTime::<chrono::Utc>>, date: Option<chrono::naive::NaiveDate>,
date_time: Option<chrono::DateTime::<chrono::Utc>>, date_time: Option<chrono::DateTime::<chrono::Utc>>,
password: Option<String>, password: Option<String>,
callback: Option<String>, callback: Option<String>,

18
samples/server/petstore/rust-server/output/petstore-with-fake-endpoints-models-for-testing/src/client/mod.rs
View File

@ -1250,7 +1250,7 @@ impl<S, C> Api<C> for Client<S, C> where
param_float: Option<f32>, param_float: Option<f32>,
param_string: Option<String>, param_string: Option<String>,
param_binary: Option<swagger::ByteArray>, param_binary: Option<swagger::ByteArray>,
param_date: Option<chrono::DateTime::<chrono::Utc>>, param_date: Option<chrono::naive::NaiveDate>,
param_date_time: Option<chrono::DateTime::<chrono::Utc>>, param_date_time: Option<chrono::DateTime::<chrono::Utc>>,
param_password: Option<String>, param_password: Option<String>,
param_callback: Option<String>, param_callback: Option<String>,
@ -1320,7 +1320,7 @@ impl<S, C> Api<C> for Client<S, C> where
// Currently only authentication with Basic and Bearer are supported // Currently only authentication with Basic and Bearer are supported
#[allow(clippy::single_match, clippy::match_single_binding)] #[allow(clippy::single_match, clippy::match_single_binding)]
match auth_data { match auth_data {
&AuthData::Basic(ref basic_header) => { AuthData::Basic(basic_header) => {
let auth = swagger::auth::Header(basic_header.clone()); let auth = swagger::auth::Header(basic_header.clone());
let header = match HeaderValue::from_str(&format!("{}", auth)) { let header = match HeaderValue::from_str(&format!("{}", auth)) {
Ok(h) => h, Ok(h) => h,
@ -1824,7 +1824,7 @@ impl<S, C> Api<C> for Client<S, C> where
// Currently only authentication with Basic and Bearer are supported // Currently only authentication with Basic and Bearer are supported
#[allow(clippy::single_match, clippy::match_single_binding)] #[allow(clippy::single_match, clippy::match_single_binding)]
match auth_data { match auth_data {
&AuthData::Bearer(ref bearer_header) => { AuthData::Bearer(bearer_header) => {
let auth = swagger::auth::Header(bearer_header.clone()); let auth = swagger::auth::Header(bearer_header.clone());
let header = match HeaderValue::from_str(&format!("{}", auth)) { let header = match HeaderValue::from_str(&format!("{}", auth)) {
Ok(h) => h, Ok(h) => h,
@ -1914,7 +1914,7 @@ impl<S, C> Api<C> for Client<S, C> where
// Currently only authentication with Basic and Bearer are supported // Currently only authentication with Basic and Bearer are supported
#[allow(clippy::single_match, clippy::match_single_binding)] #[allow(clippy::single_match, clippy::match_single_binding)]
match auth_data { match auth_data {
&AuthData::Bearer(ref bearer_header) => { AuthData::Bearer(bearer_header) => {
let auth = swagger::auth::Header(bearer_header.clone()); let auth = swagger::auth::Header(bearer_header.clone());
let header = match HeaderValue::from_str(&format!("{}", auth)) { let header = match HeaderValue::from_str(&format!("{}", auth)) {
Ok(h) => h, Ok(h) => h,
@ -2022,7 +2022,7 @@ impl<S, C> Api<C> for Client<S, C> where
// Currently only authentication with Basic and Bearer are supported // Currently only authentication with Basic and Bearer are supported
#[allow(clippy::single_match, clippy::match_single_binding)] #[allow(clippy::single_match, clippy::match_single_binding)]
match auth_data { match auth_data {
&AuthData::Bearer(ref bearer_header) => { AuthData::Bearer(bearer_header) => {
let auth = swagger::auth::Header(bearer_header.clone()); let auth = swagger::auth::Header(bearer_header.clone());
let header = match HeaderValue::from_str(&format!("{}", auth)) { let header = match HeaderValue::from_str(&format!("{}", auth)) {
Ok(h) => h, Ok(h) => h,
@ -2127,7 +2127,7 @@ impl<S, C> Api<C> for Client<S, C> where
// Currently only authentication with Basic and Bearer are supported // Currently only authentication with Basic and Bearer are supported
#[allow(clippy::single_match, clippy::match_single_binding)] #[allow(clippy::single_match, clippy::match_single_binding)]
match auth_data { match auth_data {
&AuthData::Bearer(ref bearer_header) => { AuthData::Bearer(bearer_header) => {
let auth = swagger::auth::Header(bearer_header.clone()); let auth = swagger::auth::Header(bearer_header.clone());
let header = match HeaderValue::from_str(&format!("{}", auth)) { let header = match HeaderValue::from_str(&format!("{}", auth)) {
Ok(h) => h, Ok(h) => h,
@ -2337,7 +2337,7 @@ impl<S, C> Api<C> for Client<S, C> where
// Currently only authentication with Basic and Bearer are supported // Currently only authentication with Basic and Bearer are supported
#[allow(clippy::single_match, clippy::match_single_binding)] #[allow(clippy::single_match, clippy::match_single_binding)]
match auth_data { match auth_data {
&AuthData::Bearer(ref bearer_header) => { AuthData::Bearer(bearer_header) => {
let auth = swagger::auth::Header(bearer_header.clone()); let auth = swagger::auth::Header(bearer_header.clone());
let header = match HeaderValue::from_str(&format!("{}", auth)) { let header = match HeaderValue::from_str(&format!("{}", auth)) {
Ok(h) => h, Ok(h) => h,
@ -2450,7 +2450,7 @@ impl<S, C> Api<C> for Client<S, C> where
// Currently only authentication with Basic and Bearer are supported // Currently only authentication with Basic and Bearer are supported
#[allow(clippy::single_match, clippy::match_single_binding)] #[allow(clippy::single_match, clippy::match_single_binding)]
match auth_data { match auth_data {
&AuthData::Bearer(ref bearer_header) => { AuthData::Bearer(bearer_header) => {
let auth = swagger::auth::Header(bearer_header.clone()); let auth = swagger::auth::Header(bearer_header.clone());
let header = match HeaderValue::from_str(&format!("{}", auth)) { let header = match HeaderValue::from_str(&format!("{}", auth)) {
Ok(h) => h, Ok(h) => h,
@ -2596,7 +2596,7 @@ impl<S, C> Api<C> for Client<S, C> where
// Currently only authentication with Basic and Bearer are supported // Currently only authentication with Basic and Bearer are supported
#[allow(clippy::single_match, clippy::match_single_binding)] #[allow(clippy::single_match, clippy::match_single_binding)]
match auth_data { match auth_data {
&AuthData::Bearer(ref bearer_header) => { AuthData::Bearer(bearer_header) => {
let auth = swagger::auth::Header(bearer_header.clone()); let auth = swagger::auth::Header(bearer_header.clone());
let header = match HeaderValue::from_str(&format!("{}", auth)) { let header = match HeaderValue::from_str(&format!("{}", auth)) {
Ok(h) => h, Ok(h) => h,

6
samples/server/petstore/rust-server/output/petstore-with-fake-endpoints-models-for-testing/src/lib.rs
View File

@ -387,7 +387,7 @@ pub trait Api<C: Send + Sync> {
float: Option<f32>, float: Option<f32>,
string: Option<String>, string: Option<String>,
binary: Option<swagger::ByteArray>, binary: Option<swagger::ByteArray>,
date: Option<chrono::DateTime::<chrono::Utc>>, date: Option<chrono::naive::NaiveDate>,
date_time: Option<chrono::DateTime::<chrono::Utc>>, date_time: Option<chrono::DateTime::<chrono::Utc>>,
password: Option<String>, password: Option<String>,
callback: Option<String>, callback: Option<String>,
@ -624,7 +624,7 @@ pub trait ApiNoContext<C: Send + Sync> {
float: Option<f32>, float: Option<f32>,
string: Option<String>, string: Option<String>,
binary: Option<swagger::ByteArray>, binary: Option<swagger::ByteArray>,
date: Option<chrono::DateTime::<chrono::Utc>>, date: Option<chrono::naive::NaiveDate>,
date_time: Option<chrono::DateTime::<chrono::Utc>>, date_time: Option<chrono::DateTime::<chrono::Utc>>,
password: Option<String>, password: Option<String>,
callback: Option<String>, callback: Option<String>,
@ -915,7 +915,7 @@ impl<T: Api<C> + Send + Sync, C: Clone + Send + Sync> ApiNoContext<C> for Contex
float: Option<f32>, float: Option<f32>,
string: Option<String>, string: Option<String>,
binary: Option<swagger::ByteArray>, binary: Option<swagger::ByteArray>,
date: Option<chrono::DateTime::<chrono::Utc>>, date: Option<chrono::naive::NaiveDate>,
date_time: Option<chrono::DateTime::<chrono::Utc>>, date_time: Option<chrono::DateTime::<chrono::Utc>>,
password: Option<String>, password: Option<String>,
callback: Option<String>, callback: Option<String>,

138
samples/server/petstore/rust-server/output/petstore-with-fake-endpoints-models-for-testing/src/models.rs
View File

@ -178,7 +178,7 @@ impl std::string::ToString for Animal {
self.color.as_ref().map(|color| { self.color.as_ref().map(|color| {
vec![ [
"color".to_string(), "color".to_string(),
color.to_string(), color.to_string(),
].join(",") ].join(",")
@ -463,7 +463,7 @@ impl std::string::ToString for ApiResponse {
let params: Vec<Option<String>> = vec![ let params: Vec<Option<String>> = vec![
self.code.as_ref().map(|code| { self.code.as_ref().map(|code| {
vec![ [
"code".to_string(), "code".to_string(),
code.to_string(), code.to_string(),
].join(",") ].join(",")
@ -471,7 +471,7 @@ impl std::string::ToString for ApiResponse {
self.r#type.as_ref().map(|r#type| { self.r#type.as_ref().map(|r#type| {
vec![ [
"type".to_string(), "type".to_string(),
r#type.to_string(), r#type.to_string(),
].join(",") ].join(",")
@ -479,7 +479,7 @@ impl std::string::ToString for ApiResponse {
self.message.as_ref().map(|message| { self.message.as_ref().map(|message| {
vec![ [
"message".to_string(), "message".to_string(),
message.to_string(), message.to_string(),
].join(",") ].join(",")
@ -746,7 +746,7 @@ impl std::string::ToString for ArrayOfNumberOnly {
let params: Vec<Option<String>> = vec![ let params: Vec<Option<String>> = vec![
self.array_number.as_ref().map(|array_number| { self.array_number.as_ref().map(|array_number| {
vec![ [
"ArrayNumber".to_string(), "ArrayNumber".to_string(),
array_number.iter().map(|x| x.to_string()).collect::<Vec<_>>().join(","), array_number.iter().map(|x| x.to_string()).collect::<Vec<_>>().join(","),
].join(",") ].join(",")
@ -894,7 +894,7 @@ impl std::string::ToString for ArrayTest {
let params: Vec<Option<String>> = vec![ let params: Vec<Option<String>> = vec![
self.array_of_string.as_ref().map(|array_of_string| { self.array_of_string.as_ref().map(|array_of_string| {
vec![ [
"array_of_string".to_string(), "array_of_string".to_string(),
array_of_string.iter().map(|x| x.to_string()).collect::<Vec<_>>().join(","), array_of_string.iter().map(|x| x.to_string()).collect::<Vec<_>>().join(","),
].join(",") ].join(",")
@ -906,7 +906,7 @@ impl std::string::ToString for ArrayTest {
self.array_of_enum.as_ref().map(|array_of_enum| { self.array_of_enum.as_ref().map(|array_of_enum| {
vec![ [
"array_of_enum".to_string(), "array_of_enum".to_string(),
array_of_enum.iter().map(|x| x.to_string()).collect::<Vec<_>>().join(","), array_of_enum.iter().map(|x| x.to_string()).collect::<Vec<_>>().join(","),
].join(",") ].join(",")
@ -1073,7 +1073,7 @@ impl std::string::ToString for Capitalization {
let params: Vec<Option<String>> = vec![ let params: Vec<Option<String>> = vec![
self.small_camel.as_ref().map(|small_camel| { self.small_camel.as_ref().map(|small_camel| {
vec![ [
"smallCamel".to_string(), "smallCamel".to_string(),
small_camel.to_string(), small_camel.to_string(),
].join(",") ].join(",")
@ -1081,7 +1081,7 @@ impl std::string::ToString for Capitalization {
self.capital_camel.as_ref().map(|capital_camel| { self.capital_camel.as_ref().map(|capital_camel| {
vec![ [
"CapitalCamel".to_string(), "CapitalCamel".to_string(),
capital_camel.to_string(), capital_camel.to_string(),
].join(",") ].join(",")
@ -1089,7 +1089,7 @@ impl std::string::ToString for Capitalization {
self.small_snake.as_ref().map(|small_snake| { self.small_snake.as_ref().map(|small_snake| {
vec![ [
"small_Snake".to_string(), "small_Snake".to_string(),
small_snake.to_string(), small_snake.to_string(),
].join(",") ].join(",")
@ -1097,7 +1097,7 @@ impl std::string::ToString for Capitalization {
self.capital_snake.as_ref().map(|capital_snake| { self.capital_snake.as_ref().map(|capital_snake| {
vec![ [
"Capital_Snake".to_string(), "Capital_Snake".to_string(),
capital_snake.to_string(), capital_snake.to_string(),
].join(",") ].join(",")
@ -1105,7 +1105,7 @@ impl std::string::ToString for Capitalization {
self.sca_eth_flow_points.as_ref().map(|sca_eth_flow_points| { self.sca_eth_flow_points.as_ref().map(|sca_eth_flow_points| {
vec![ [
"SCA_ETH_Flow_Points".to_string(), "SCA_ETH_Flow_Points".to_string(),
sca_eth_flow_points.to_string(), sca_eth_flow_points.to_string(),
].join(",") ].join(",")
@ -1113,7 +1113,7 @@ impl std::string::ToString for Capitalization {
self.att_name.as_ref().map(|att_name| { self.att_name.as_ref().map(|att_name| {
vec![ [
"ATT_NAME".to_string(), "ATT_NAME".to_string(),
att_name.to_string(), att_name.to_string(),
].join(",") ].join(",")
@ -1279,7 +1279,7 @@ impl std::string::ToString for Cat {
self.color.as_ref().map(|color| { self.color.as_ref().map(|color| {
vec![ [
"color".to_string(), "color".to_string(),
color.to_string(), color.to_string(),
].join(",") ].join(",")
@ -1287,7 +1287,7 @@ impl std::string::ToString for Cat {
self.declawed.as_ref().map(|declawed| { self.declawed.as_ref().map(|declawed| {
vec![ [
"declawed".to_string(), "declawed".to_string(),
declawed.to_string(), declawed.to_string(),
].join(",") ].join(",")
@ -1434,7 +1434,7 @@ impl std::string::ToString for Category {
let params: Vec<Option<String>> = vec![ let params: Vec<Option<String>> = vec![
self.id.as_ref().map(|id| { self.id.as_ref().map(|id| {
vec![ [
"id".to_string(), "id".to_string(),
id.to_string(), id.to_string(),
].join(",") ].join(",")
@ -1442,7 +1442,7 @@ impl std::string::ToString for Category {
self.name.as_ref().map(|name| { self.name.as_ref().map(|name| {
vec![ [
"name".to_string(), "name".to_string(),
name.to_string(), name.to_string(),
].join(",") ].join(",")
@ -1580,7 +1580,7 @@ impl std::string::ToString for ClassModel {
let params: Vec<Option<String>> = vec![ let params: Vec<Option<String>> = vec![
self._class.as_ref().map(|_class| { self._class.as_ref().map(|_class| {
vec![ [
"_class".to_string(), "_class".to_string(),
_class.to_string(), _class.to_string(),
].join(",") ].join(",")
@ -1713,7 +1713,7 @@ impl std::string::ToString for Client {
let params: Vec<Option<String>> = vec![ let params: Vec<Option<String>> = vec![
self.client.as_ref().map(|client| { self.client.as_ref().map(|client| {
vec![ [
"client".to_string(), "client".to_string(),
client.to_string(), client.to_string(),
].join(",") ].join(",")
@ -1859,7 +1859,7 @@ impl std::string::ToString for Dog {
self.color.as_ref().map(|color| { self.color.as_ref().map(|color| {
vec![ [
"color".to_string(), "color".to_string(),
color.to_string(), color.to_string(),
].join(",") ].join(",")
@ -1867,7 +1867,7 @@ impl std::string::ToString for Dog {
self.breed.as_ref().map(|breed| { self.breed.as_ref().map(|breed| {
vec![ [
"breed".to_string(), "breed".to_string(),
breed.to_string(), breed.to_string(),
].join(",") ].join(",")
@ -2009,7 +2009,7 @@ impl std::string::ToString for DollarSpecialLeftSquareBracketModelPeriodNameRigh
let params: Vec<Option<String>> = vec![ let params: Vec<Option<String>> = vec![
self.dollar_special_left_square_bracket_property_period_name_right_square_bracket.as_ref().map(|dollar_special_left_square_bracket_property_period_name_right_square_bracket| { self.dollar_special_left_square_bracket_property_period_name_right_square_bracket.as_ref().map(|dollar_special_left_square_bracket_property_period_name_right_square_bracket| {
vec![ [
"$special[property.name]".to_string(), "$special[property.name]".to_string(),
dollar_special_left_square_bracket_property_period_name_right_square_bracket.to_string(), dollar_special_left_square_bracket_property_period_name_right_square_bracket.to_string(),
].join(",") ].join(",")
@ -2155,7 +2155,7 @@ impl std::string::ToString for EnumArrays {
let params: Vec<Option<String>> = vec![ let params: Vec<Option<String>> = vec![
self.just_symbol.as_ref().map(|just_symbol| { self.just_symbol.as_ref().map(|just_symbol| {
vec![ [
"just_symbol".to_string(), "just_symbol".to_string(),
just_symbol.to_string(), just_symbol.to_string(),
].join(",") ].join(",")
@ -2163,7 +2163,7 @@ impl std::string::ToString for EnumArrays {
self.array_enum.as_ref().map(|array_enum| { self.array_enum.as_ref().map(|array_enum| {
vec![ [
"array_enum".to_string(), "array_enum".to_string(),
array_enum.iter().map(|x| x.to_string()).collect::<Vec<_>>().join(","), array_enum.iter().map(|x| x.to_string()).collect::<Vec<_>>().join(","),
].join(",") ].join(",")
@ -2375,7 +2375,7 @@ impl std::string::ToString for EnumTest {
let params: Vec<Option<String>> = vec![ let params: Vec<Option<String>> = vec![
self.enum_string.as_ref().map(|enum_string| { self.enum_string.as_ref().map(|enum_string| {
vec![ [
"enum_string".to_string(), "enum_string".to_string(),
enum_string.to_string(), enum_string.to_string(),
].join(",") ].join(",")
@ -2387,7 +2387,7 @@ impl std::string::ToString for EnumTest {
self.enum_integer.as_ref().map(|enum_integer| { self.enum_integer.as_ref().map(|enum_integer| {
vec![ [
"enum_integer".to_string(), "enum_integer".to_string(),
enum_integer.to_string(), enum_integer.to_string(),
].join(",") ].join(",")
@ -2395,7 +2395,7 @@ impl std::string::ToString for EnumTest {
self.enum_number.as_ref().map(|enum_number| { self.enum_number.as_ref().map(|enum_number| {
vec![ [
"enum_number".to_string(), "enum_number".to_string(),
enum_number.to_string(), enum_number.to_string(),
].join(",") ].join(",")
@ -2578,7 +2578,7 @@ pub struct FormatTest {
pub binary: Option<swagger::ByteArray>, pub binary: Option<swagger::ByteArray>,
#[serde(rename = "date")] #[serde(rename = "date")]
pub date: chrono::DateTime::<chrono::Utc>, pub date: chrono::naive::NaiveDate,
#[serde(rename = "dateTime")] #[serde(rename = "dateTime")]
#[serde(skip_serializing_if="Option::is_none")] #[serde(skip_serializing_if="Option::is_none")]
@ -2613,7 +2613,7 @@ fn validate_byte_formattest_byte(
impl FormatTest { impl FormatTest {
#[allow(clippy::new_without_default)] #[allow(clippy::new_without_default)]
pub fn new(number: f64, byte: swagger::ByteArray, date: chrono::DateTime::<chrono::Utc>, password: String, ) -> FormatTest { pub fn new(number: f64, byte: swagger::ByteArray, date: chrono::naive::NaiveDate, password: String, ) -> FormatTest {
FormatTest { FormatTest {
integer: None, integer: None,
int32: None, int32: None,
@ -2640,7 +2640,7 @@ impl std::string::ToString for FormatTest {
let params: Vec<Option<String>> = vec![ let params: Vec<Option<String>> = vec![
self.integer.as_ref().map(|integer| { self.integer.as_ref().map(|integer| {
vec![ [
"integer".to_string(), "integer".to_string(),
integer.to_string(), integer.to_string(),
].join(",") ].join(",")
@ -2648,7 +2648,7 @@ impl std::string::ToString for FormatTest {
self.int32.as_ref().map(|int32| { self.int32.as_ref().map(|int32| {
vec![ [
"int32".to_string(), "int32".to_string(),
int32.to_string(), int32.to_string(),
].join(",") ].join(",")
@ -2656,7 +2656,7 @@ impl std::string::ToString for FormatTest {
self.int64.as_ref().map(|int64| { self.int64.as_ref().map(|int64| {
vec![ [
"int64".to_string(), "int64".to_string(),
int64.to_string(), int64.to_string(),
].join(",") ].join(",")
@ -2668,7 +2668,7 @@ impl std::string::ToString for FormatTest {
self.float.as_ref().map(|float| { self.float.as_ref().map(|float| {
vec![ [
"float".to_string(), "float".to_string(),
float.to_string(), float.to_string(),
].join(",") ].join(",")
@ -2676,7 +2676,7 @@ impl std::string::ToString for FormatTest {
self.double.as_ref().map(|double| { self.double.as_ref().map(|double| {
vec![ [
"double".to_string(), "double".to_string(),
double.to_string(), double.to_string(),
].join(",") ].join(",")
@ -2684,7 +2684,7 @@ impl std::string::ToString for FormatTest {
self.string.as_ref().map(|string| { self.string.as_ref().map(|string| {
vec![ [
"string".to_string(), "string".to_string(),
string.to_string(), string.to_string(),
].join(",") ].join(",")
@ -2732,7 +2732,7 @@ impl std::str::FromStr for FormatTest {
pub string: Vec<String>, pub string: Vec<String>,
pub byte: Vec<swagger::ByteArray>, pub byte: Vec<swagger::ByteArray>,
pub binary: Vec<swagger::ByteArray>, pub binary: Vec<swagger::ByteArray>,
pub date: Vec<chrono::DateTime::<chrono::Utc>>, pub date: Vec<chrono::naive::NaiveDate>,
pub date_time: Vec<chrono::DateTime::<chrono::Utc>>, pub date_time: Vec<chrono::DateTime::<chrono::Utc>>,
pub uuid: Vec<uuid::Uuid>, pub uuid: Vec<uuid::Uuid>,
pub password: Vec<String>, pub password: Vec<String>,
@ -2770,7 +2770,7 @@ impl std::str::FromStr for FormatTest {
"byte" => return std::result::Result::Err("Parsing binary data in this style is not supported in FormatTest".to_string()), "byte" => return std::result::Result::Err("Parsing binary data in this style is not supported in FormatTest".to_string()),
"binary" => return std::result::Result::Err("Parsing binary data in this style is not supported in FormatTest".to_string()), "binary" => return std::result::Result::Err("Parsing binary data in this style is not supported in FormatTest".to_string()),
#[allow(clippy::redundant_clone)] #[allow(clippy::redundant_clone)]
"date" => intermediate_rep.date.push(<chrono::DateTime::<chrono::Utc> as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?), "date" => intermediate_rep.date.push(<chrono::naive::NaiveDate as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?),
#[allow(clippy::redundant_clone)] #[allow(clippy::redundant_clone)]
"dateTime" => intermediate_rep.date_time.push(<chrono::DateTime::<chrono::Utc> as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?), "dateTime" => intermediate_rep.date_time.push(<chrono::DateTime::<chrono::Utc> as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?),
#[allow(clippy::redundant_clone)] #[allow(clippy::redundant_clone)]
@ -2884,7 +2884,7 @@ impl std::string::ToString for HasOnlyReadOnly {
let params: Vec<Option<String>> = vec![ let params: Vec<Option<String>> = vec![
self.bar.as_ref().map(|bar| { self.bar.as_ref().map(|bar| {
vec![ [
"bar".to_string(), "bar".to_string(),
bar.to_string(), bar.to_string(),
].join(",") ].join(",")
@ -2892,7 +2892,7 @@ impl std::string::ToString for HasOnlyReadOnly {
self.foo.as_ref().map(|foo| { self.foo.as_ref().map(|foo| {
vec![ [
"foo".to_string(), "foo".to_string(),
foo.to_string(), foo.to_string(),
].join(",") ].join(",")
@ -3029,7 +3029,7 @@ impl std::string::ToString for List {
let params: Vec<Option<String>> = vec![ let params: Vec<Option<String>> = vec![
self.param_123_list.as_ref().map(|param_123_list| { self.param_123_list.as_ref().map(|param_123_list| {
vec![ [
"123-list".to_string(), "123-list".to_string(),
param_123_list.to_string(), param_123_list.to_string(),
].join(",") ].join(",")
@ -3468,7 +3468,7 @@ impl std::string::ToString for Model200Response {
let params: Vec<Option<String>> = vec![ let params: Vec<Option<String>> = vec![
self.name.as_ref().map(|name| { self.name.as_ref().map(|name| {
vec![ [
"name".to_string(), "name".to_string(),
name.to_string(), name.to_string(),
].join(",") ].join(",")
@ -3476,7 +3476,7 @@ impl std::string::ToString for Model200Response {
self.class.as_ref().map(|class| { self.class.as_ref().map(|class| {
vec![ [
"class".to_string(), "class".to_string(),
class.to_string(), class.to_string(),
].join(",") ].join(",")
@ -3633,7 +3633,7 @@ impl std::string::ToString for Name {
self.snake_case.as_ref().map(|snake_case| { self.snake_case.as_ref().map(|snake_case| {
vec![ [
"snake_case".to_string(), "snake_case".to_string(),
snake_case.to_string(), snake_case.to_string(),
].join(",") ].join(",")
@ -3641,7 +3641,7 @@ impl std::string::ToString for Name {
self.property.as_ref().map(|property| { self.property.as_ref().map(|property| {
vec![ [
"property".to_string(), "property".to_string(),
property.to_string(), property.to_string(),
].join(",") ].join(",")
@ -3649,7 +3649,7 @@ impl std::string::ToString for Name {
self.param_123_number.as_ref().map(|param_123_number| { self.param_123_number.as_ref().map(|param_123_number| {
vec![ [
"123Number".to_string(), "123Number".to_string(),
param_123_number.to_string(), param_123_number.to_string(),
].join(",") ].join(",")
@ -3794,7 +3794,7 @@ impl std::string::ToString for NumberOnly {
let params: Vec<Option<String>> = vec![ let params: Vec<Option<String>> = vec![
self.just_number.as_ref().map(|just_number| { self.just_number.as_ref().map(|just_number| {
vec![ [
"JustNumber".to_string(), "JustNumber".to_string(),
just_number.to_string(), just_number.to_string(),
].join(",") ].join(",")
@ -4141,7 +4141,7 @@ impl std::string::ToString for Order {
let params: Vec<Option<String>> = vec![ let params: Vec<Option<String>> = vec![
self.id.as_ref().map(|id| { self.id.as_ref().map(|id| {
vec![ [
"id".to_string(), "id".to_string(),
id.to_string(), id.to_string(),
].join(",") ].join(",")
@ -4149,7 +4149,7 @@ impl std::string::ToString for Order {
self.pet_id.as_ref().map(|pet_id| { self.pet_id.as_ref().map(|pet_id| {
vec![ [
"petId".to_string(), "petId".to_string(),
pet_id.to_string(), pet_id.to_string(),
].join(",") ].join(",")
@ -4157,7 +4157,7 @@ impl std::string::ToString for Order {
self.quantity.as_ref().map(|quantity| { self.quantity.as_ref().map(|quantity| {
vec![ [
"quantity".to_string(), "quantity".to_string(),
quantity.to_string(), quantity.to_string(),
].join(",") ].join(",")
@ -4167,7 +4167,7 @@ impl std::string::ToString for Order {
self.status.as_ref().map(|status| { self.status.as_ref().map(|status| {
vec![ [
"status".to_string(), "status".to_string(),
status.to_string(), status.to_string(),
].join(",") ].join(",")
@ -4175,7 +4175,7 @@ impl std::string::ToString for Order {
self.complete.as_ref().map(|complete| { self.complete.as_ref().map(|complete| {
vec![ [
"complete".to_string(), "complete".to_string(),
complete.to_string(), complete.to_string(),
].join(",") ].join(",")
@ -4377,7 +4377,7 @@ impl std::string::ToString for OuterComposite {
let params: Vec<Option<String>> = vec![ let params: Vec<Option<String>> = vec![
self.my_number.as_ref().map(|my_number| { self.my_number.as_ref().map(|my_number| {
vec![ [
"my_number".to_string(), "my_number".to_string(),
my_number.to_string(), my_number.to_string(),
].join(",") ].join(",")
@ -4385,7 +4385,7 @@ impl std::string::ToString for OuterComposite {
self.my_string.as_ref().map(|my_string| { self.my_string.as_ref().map(|my_string| {
vec![ [
"my_string".to_string(), "my_string".to_string(),
my_string.to_string(), my_string.to_string(),
].join(",") ].join(",")
@ -4393,7 +4393,7 @@ impl std::string::ToString for OuterComposite {
self.my_boolean.as_ref().map(|my_boolean| { self.my_boolean.as_ref().map(|my_boolean| {
vec![ [
"my_boolean".to_string(), "my_boolean".to_string(),
my_boolean.to_string(), my_boolean.to_string(),
].join(",") ].join(",")
@ -4699,7 +4699,7 @@ impl std::string::ToString for Pet {
let params: Vec<Option<String>> = vec![ let params: Vec<Option<String>> = vec![
self.id.as_ref().map(|id| { self.id.as_ref().map(|id| {
vec![ [
"id".to_string(), "id".to_string(),
id.to_string(), id.to_string(),
].join(",") ].join(",")
@ -4719,7 +4719,7 @@ impl std::string::ToString for Pet {
self.status.as_ref().map(|status| { self.status.as_ref().map(|status| {
vec![ [
"status".to_string(), "status".to_string(),
status.to_string(), status.to_string(),
].join(",") ].join(",")
@ -4875,7 +4875,7 @@ impl std::string::ToString for ReadOnlyFirst {
let params: Vec<Option<String>> = vec![ let params: Vec<Option<String>> = vec![
self.bar.as_ref().map(|bar| { self.bar.as_ref().map(|bar| {
vec![ [
"bar".to_string(), "bar".to_string(),
bar.to_string(), bar.to_string(),
].join(",") ].join(",")
@ -4883,7 +4883,7 @@ impl std::string::ToString for ReadOnlyFirst {
self.baz.as_ref().map(|baz| { self.baz.as_ref().map(|baz| {
vec![ [
"baz".to_string(), "baz".to_string(),
baz.to_string(), baz.to_string(),
].join(",") ].join(",")
@ -5022,7 +5022,7 @@ impl std::string::ToString for Return {
let params: Vec<Option<String>> = vec![ let params: Vec<Option<String>> = vec![
self.r#return.as_ref().map(|r#return| { self.r#return.as_ref().map(|r#return| {
vec![ [
"return".to_string(), "return".to_string(),
r#return.to_string(), r#return.to_string(),
].join(",") ].join(",")
@ -5161,7 +5161,7 @@ impl std::string::ToString for Tag {
let params: Vec<Option<String>> = vec![ let params: Vec<Option<String>> = vec![
self.id.as_ref().map(|id| { self.id.as_ref().map(|id| {
vec![ [
"id".to_string(), "id".to_string(),
id.to_string(), id.to_string(),
].join(",") ].join(",")
@ -5169,7 +5169,7 @@ impl std::string::ToString for Tag {
self.name.as_ref().map(|name| { self.name.as_ref().map(|name| {
vec![ [
"name".to_string(), "name".to_string(),
name.to_string(), name.to_string(),
].join(",") ].join(",")
@ -5343,7 +5343,7 @@ impl std::string::ToString for User {
let params: Vec<Option<String>> = vec![ let params: Vec<Option<String>> = vec![
self.id.as_ref().map(|id| { self.id.as_ref().map(|id| {
vec![ [
"id".to_string(), "id".to_string(),
id.to_string(), id.to_string(),
].join(",") ].join(",")
@ -5351,7 +5351,7 @@ impl std::string::ToString for User {
self.username.as_ref().map(|username| { self.username.as_ref().map(|username| {
vec![ [
"username".to_string(), "username".to_string(),
username.to_string(), username.to_string(),
].join(",") ].join(",")
@ -5359,7 +5359,7 @@ impl std::string::ToString for User {
self.first_name.as_ref().map(|first_name| { self.first_name.as_ref().map(|first_name| {
vec![ [
"firstName".to_string(), "firstName".to_string(),
first_name.to_string(), first_name.to_string(),
].join(",") ].join(",")
@ -5367,7 +5367,7 @@ impl std::string::ToString for User {
self.last_name.as_ref().map(|last_name| { self.last_name.as_ref().map(|last_name| {
vec![ [
"lastName".to_string(), "lastName".to_string(),
last_name.to_string(), last_name.to_string(),
].join(",") ].join(",")
@ -5375,7 +5375,7 @@ impl std::string::ToString for User {
self.email.as_ref().map(|email| { self.email.as_ref().map(|email| {
vec![ [
"email".to_string(), "email".to_string(),
email.to_string(), email.to_string(),
].join(",") ].join(",")
@ -5383,7 +5383,7 @@ impl std::string::ToString for User {
self.password.as_ref().map(|password| { self.password.as_ref().map(|password| {
vec![ [
"password".to_string(), "password".to_string(),
password.to_string(), password.to_string(),
].join(",") ].join(",")
@ -5391,7 +5391,7 @@ impl std::string::ToString for User {
self.phone.as_ref().map(|phone| { self.phone.as_ref().map(|phone| {
vec![ [
"phone".to_string(), "phone".to_string(),
phone.to_string(), phone.to_string(),
].join(",") ].join(",")
@ -5399,7 +5399,7 @@ impl std::string::ToString for User {
self.user_status.as_ref().map(|user_status| { self.user_status.as_ref().map(|user_status| {
vec![ [
"userStatus".to_string(), "userStatus".to_string(),
user_status.to_string(), user_status.to_string(),
].join(",") ].join(",")

64
samples/server/petstore/rust-server/output/petstore-with-fake-endpoints-models-for-testing/src/server/mod.rs
View File

@ -316,8 +316,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("application/json") HeaderValue::from_str("application/json")
.expect("Unable to create Content-Type header for TEST_SPECIAL_TAGS_SUCCESSFUL_OPERATION")); .expect("Unable to create Content-Type header for TEST_SPECIAL_TAGS_SUCCESSFUL_OPERATION"));
let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_json::to_string(&body).expect("impossible to fail to serialize");
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
}, },
Err(_) => { Err(_) => {
@ -415,8 +415,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("*/*") HeaderValue::from_str("*/*")
.expect("Unable to create Content-Type header for FAKE_OUTER_BOOLEAN_SERIALIZE_OUTPUT_BOOLEAN")); .expect("Unable to create Content-Type header for FAKE_OUTER_BOOLEAN_SERIALIZE_OUTPUT_BOOLEAN"));
let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_json::to_string(&body).expect("impossible to fail to serialize");
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
}, },
Err(_) => { Err(_) => {
@ -485,8 +485,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("*/*") HeaderValue::from_str("*/*")
.expect("Unable to create Content-Type header for FAKE_OUTER_COMPOSITE_SERIALIZE_OUTPUT_COMPOSITE")); .expect("Unable to create Content-Type header for FAKE_OUTER_COMPOSITE_SERIALIZE_OUTPUT_COMPOSITE"));
let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_json::to_string(&body).expect("impossible to fail to serialize");
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
}, },
Err(_) => { Err(_) => {
@ -555,8 +555,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("*/*") HeaderValue::from_str("*/*")
.expect("Unable to create Content-Type header for FAKE_OUTER_NUMBER_SERIALIZE_OUTPUT_NUMBER")); .expect("Unable to create Content-Type header for FAKE_OUTER_NUMBER_SERIALIZE_OUTPUT_NUMBER"));
let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_json::to_string(&body).expect("impossible to fail to serialize");
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
}, },
Err(_) => { Err(_) => {
@ -625,8 +625,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("*/*") HeaderValue::from_str("*/*")
.expect("Unable to create Content-Type header for FAKE_OUTER_STRING_SERIALIZE_OUTPUT_STRING")); .expect("Unable to create Content-Type header for FAKE_OUTER_STRING_SERIALIZE_OUTPUT_STRING"));
let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_json::to_string(&body).expect("impossible to fail to serialize");
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
}, },
Err(_) => { Err(_) => {
@ -888,8 +888,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("application/json") HeaderValue::from_str("application/json")
.expect("Unable to create Content-Type header for TEST_CLIENT_MODEL_SUCCESSFUL_OPERATION")); .expect("Unable to create Content-Type header for TEST_CLIENT_MODEL_SUCCESSFUL_OPERATION"));
let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_json::to_string(&body).expect("impossible to fail to serialize");
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
}, },
Err(_) => { Err(_) => {
@ -1302,8 +1302,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("application/json") HeaderValue::from_str("application/json")
.expect("Unable to create Content-Type header for TEST_CLASSNAME_SUCCESSFUL_OPERATION")); .expect("Unable to create Content-Type header for TEST_CLASSNAME_SUCCESSFUL_OPERATION"));
let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_json::to_string(&body).expect("impossible to fail to serialize");
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
}, },
Err(_) => { Err(_) => {
@ -1588,8 +1588,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("application/xml") HeaderValue::from_str("application/xml")
.expect("Unable to create Content-Type header for FIND_PETS_BY_STATUS_SUCCESSFUL_OPERATION")); .expect("Unable to create Content-Type header for FIND_PETS_BY_STATUS_SUCCESSFUL_OPERATION"));
let body = serde_xml_rs::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_xml_rs::to_string(&body).expect("impossible to fail to serialize");
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
FindPetsByStatusResponse::InvalidStatusValue FindPetsByStatusResponse::InvalidStatusValue
=> { => {
@ -1665,8 +1665,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("application/xml") HeaderValue::from_str("application/xml")
.expect("Unable to create Content-Type header for FIND_PETS_BY_TAGS_SUCCESSFUL_OPERATION")); .expect("Unable to create Content-Type header for FIND_PETS_BY_TAGS_SUCCESSFUL_OPERATION"));
let body = serde_xml_rs::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_xml_rs::to_string(&body).expect("impossible to fail to serialize");
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
FindPetsByTagsResponse::InvalidTagValue FindPetsByTagsResponse::InvalidTagValue
=> { => {
@ -1739,8 +1739,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("application/xml") HeaderValue::from_str("application/xml")
.expect("Unable to create Content-Type header for GET_PET_BY_ID_SUCCESSFUL_OPERATION")); .expect("Unable to create Content-Type header for GET_PET_BY_ID_SUCCESSFUL_OPERATION"));
let body = serde_xml_rs::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_xml_rs::to_string(&body).expect("impossible to fail to serialize");
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
GetPetByIdResponse::InvalidIDSupplied GetPetByIdResponse::InvalidIDSupplied
=> { => {
@ -2115,8 +2115,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("application/json") HeaderValue::from_str("application/json")
.expect("Unable to create Content-Type header for UPLOAD_FILE_SUCCESSFUL_OPERATION")); .expect("Unable to create Content-Type header for UPLOAD_FILE_SUCCESSFUL_OPERATION"));
let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_json::to_string(&body).expect("impossible to fail to serialize");
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
}, },
Err(_) => { Err(_) => {
@ -2224,8 +2224,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("application/json") HeaderValue::from_str("application/json")
.expect("Unable to create Content-Type header for GET_INVENTORY_SUCCESSFUL_OPERATION")); .expect("Unable to create Content-Type header for GET_INVENTORY_SUCCESSFUL_OPERATION"));
let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_json::to_string(&body).expect("impossible to fail to serialize");
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
}, },
Err(_) => { Err(_) => {
@ -2284,8 +2284,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("application/xml") HeaderValue::from_str("application/xml")
.expect("Unable to create Content-Type header for GET_ORDER_BY_ID_SUCCESSFUL_OPERATION")); .expect("Unable to create Content-Type header for GET_ORDER_BY_ID_SUCCESSFUL_OPERATION"));
let body = serde_xml_rs::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_xml_rs::to_string(&body).expect("impossible to fail to serialize");
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
GetOrderByIdResponse::InvalidIDSupplied GetOrderByIdResponse::InvalidIDSupplied
=> { => {
@ -2366,8 +2366,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("application/xml") HeaderValue::from_str("application/xml")
.expect("Unable to create Content-Type header for PLACE_ORDER_SUCCESSFUL_OPERATION")); .expect("Unable to create Content-Type header for PLACE_ORDER_SUCCESSFUL_OPERATION"));
let body = serde_xml_rs::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_xml_rs::to_string(&body).expect("impossible to fail to serialize");
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
PlaceOrderResponse::InvalidOrder PlaceOrderResponse::InvalidOrder
=> { => {
@ -2712,8 +2712,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("application/xml") HeaderValue::from_str("application/xml")
.expect("Unable to create Content-Type header for GET_USER_BY_NAME_SUCCESSFUL_OPERATION")); .expect("Unable to create Content-Type header for GET_USER_BY_NAME_SUCCESSFUL_OPERATION"));
let body = serde_xml_rs::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_xml_rs::to_string(&body).expect("impossible to fail to serialize");
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
GetUserByNameResponse::InvalidUsernameSupplied GetUserByNameResponse::InvalidUsernameSupplied
=> { => {
@ -2845,8 +2845,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("application/xml") HeaderValue::from_str("application/xml")
.expect("Unable to create Content-Type header for LOGIN_USER_SUCCESSFUL_OPERATION")); .expect("Unable to create Content-Type header for LOGIN_USER_SUCCESSFUL_OPERATION"));
let body = serde_xml_rs::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_xml_rs::to_string(&body).expect("impossible to fail to serialize");
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
LoginUserResponse::InvalidUsername LoginUserResponse::InvalidUsername
=> { => {

2
samples/server/petstore/rust-server/output/ping-bearer-auth/src/client/mod.rs
View File

@ -424,7 +424,7 @@ impl<S, C> Api<C> for Client<S, C> where
// Currently only authentication with Basic and Bearer are supported // Currently only authentication with Basic and Bearer are supported
#[allow(clippy::single_match, clippy::match_single_binding)] #[allow(clippy::single_match, clippy::match_single_binding)]
match auth_data { match auth_data {
&AuthData::Bearer(ref bearer_header) => { AuthData::Bearer(bearer_header) => {
let auth = swagger::auth::Header(bearer_header.clone()); let auth = swagger::auth::Header(bearer_header.clone());
let header = match HeaderValue::from_str(&format!("{}", auth)) { let header = match HeaderValue::from_str(&format!("{}", auth)) {
Ok(h) => h, Ok(h) => h,

14
samples/server/petstore/rust-server/output/rust-server-test/src/models.rs
View File

@ -39,7 +39,7 @@ impl std::string::ToString for ANullableContainer {
let params: Vec<Option<String>> = vec![ let params: Vec<Option<String>> = vec![
self.nullable_thing.as_ref().map(|nullable_thing| { self.nullable_thing.as_ref().map(|nullable_thing| {
vec![ [
"NullableThing".to_string(), "NullableThing".to_string(),
nullable_thing.as_ref().map_or("null".to_string(), |x| x.to_string()), nullable_thing.as_ref().map_or("null".to_string(), |x| x.to_string()),
].join(",") ].join(",")
@ -225,7 +225,7 @@ impl std::string::ToString for AllOfObject {
let params: Vec<Option<String>> = vec![ let params: Vec<Option<String>> = vec![
self.sample_property.as_ref().map(|sample_property| { self.sample_property.as_ref().map(|sample_property| {
vec![ [
"sampleProperty".to_string(), "sampleProperty".to_string(),
sample_property.to_string(), sample_property.to_string(),
].join(",") ].join(",")
@ -233,7 +233,7 @@ impl std::string::ToString for AllOfObject {
self.sample_base_property.as_ref().map(|sample_base_property| { self.sample_base_property.as_ref().map(|sample_base_property| {
vec![ [
"sampleBaseProperty".to_string(), "sampleBaseProperty".to_string(),
sample_base_property.to_string(), sample_base_property.to_string(),
].join(",") ].join(",")
@ -361,7 +361,7 @@ impl std::string::ToString for BaseAllOf {
let params: Vec<Option<String>> = vec![ let params: Vec<Option<String>> = vec![
self.sample_base_property.as_ref().map(|sample_base_property| { self.sample_base_property.as_ref().map(|sample_base_property| {
vec![ [
"sampleBaseProperty".to_string(), "sampleBaseProperty".to_string(),
sample_base_property.to_string(), sample_base_property.to_string(),
].join(",") ].join(",")
@ -493,7 +493,7 @@ impl std::string::ToString for DummyPutRequest {
self.password.as_ref().map(|password| { self.password.as_ref().map(|password| {
vec![ [
"password".to_string(), "password".to_string(),
password.to_string(), password.to_string(),
].join(",") ].join(",")
@ -623,7 +623,7 @@ impl std::string::ToString for GetYamlResponse {
let params: Vec<Option<String>> = vec![ let params: Vec<Option<String>> = vec![
self.value.as_ref().map(|value| { self.value.as_ref().map(|value| {
vec![ [
"value".to_string(), "value".to_string(),
value.to_string(), value.to_string(),
].join(",") ].join(",")
@ -874,7 +874,7 @@ impl std::string::ToString for ObjectOfObjectsInner {
self.optional_thing.as_ref().map(|optional_thing| { self.optional_thing.as_ref().map(|optional_thing| {
vec![ [
"optional_thing".to_string(), "optional_thing".to_string(),
optional_thing.to_string(), optional_thing.to_string(),
].join(",") ].join(",")

20
samples/server/petstore/rust-server/output/rust-server-test/src/server/mod.rs
View File

@ -182,8 +182,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("*/*") HeaderValue::from_str("*/*")
.expect("Unable to create Content-Type header for ALL_OF_GET_OK")); .expect("Unable to create Content-Type header for ALL_OF_GET_OK"));
let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_json::to_string(&body).expect("impossible to fail to serialize");
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
}, },
Err(_) => { Err(_) => {
@ -320,8 +320,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("application/json") HeaderValue::from_str("application/json")
.expect("Unable to create Content-Type header for FILE_RESPONSE_GET_SUCCESS")); .expect("Unable to create Content-Type header for FILE_RESPONSE_GET_SUCCESS"));
let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_json::to_string(&body).expect("impossible to fail to serialize");
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
}, },
Err(_) => { Err(_) => {
@ -356,8 +356,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("application/yaml") HeaderValue::from_str("application/yaml")
.expect("Unable to create Content-Type header for GET_STRUCTURED_YAML_OK")); .expect("Unable to create Content-Type header for GET_STRUCTURED_YAML_OK"));
let body = body; let body_content = body;
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
}, },
Err(_) => { Err(_) => {
@ -418,8 +418,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("text/html") HeaderValue::from_str("text/html")
.expect("Unable to create Content-Type header for HTML_POST_SUCCESS")); .expect("Unable to create Content-Type header for HTML_POST_SUCCESS"));
let body = body; let body_content = body;
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
}, },
Err(_) => { Err(_) => {
@ -521,8 +521,8 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
CONTENT_TYPE, CONTENT_TYPE,
HeaderValue::from_str("*/*") HeaderValue::from_str("*/*")
.expect("Unable to create Content-Type header for RAW_JSON_GET_SUCCESS")); .expect("Unable to create Content-Type header for RAW_JSON_GET_SUCCESS"));
let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); let body_content = serde_json::to_string(&body).expect("impossible to fail to serialize");
*response.body_mut() = Body::from(body); *response.body_mut() = Body::from(body_content);
}, },
}, },
Err(_) => { Err(_) => {