feat: Tests for headers

dbanty · dbanty · commit 33936babb300 · 2022-01-17T19:43:58.000-07:00
diff --git a/deny.toml b/deny.toml
@@ -48,7 +48,7 @@ notice = "warn"
 # A list of advisory IDs to ignore. Note that ignored advisories will still
 # output a note when they are encountered.
 ignore = [
-    "RUSTSEC-2021-0131",  # Open PR to resolve this https://github.com/actix/actix-web/pull/2538
+    # "RUSTSEC-2021-0131",
 ]
 # Threshold for security vulnerabilities, any vulnerability with a CVSS score
 # lower than the range specified will be ignored. Note that ignored advisories
diff --git a/openapi.json b/openapi.json
@@ -133,6 +133,94 @@
           }
         }
       }
+    },
+    "/parameters/header": {
+      "description": "Test the valid types to send in headers.",
+      "post": {
+        "tags": [
+          "parameters"
+        ],
+        "parameters": [
+          {
+            "required": true,
+            "schema": {
+              "type": "boolean"
+            },
+            "name": "Boolean-Header",
+            "in": "header"
+          },
+          {
+            "required": true,
+            "schema": {
+              "type": "string"
+            },
+            "name": "String-Header",
+            "in": "header"
+          },
+          {
+            "required": true,
+            "schema": {
+              "type": "number"
+            },
+            "name": "Number-Header",
+            "in": "header"
+          },
+          {
+            "required": true,
+            "schema": {
+              "type": "integer"
+            },
+            "name": "Integer-Header",
+            "in": "header"
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "OK",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "boolean": {
+                      "type": "boolean",
+                      "description": "Echo of the 'Boolean-Header' input parameter from the header."
+                    },
+                    "string": {
+                      "type": "string",
+                      "description": "Echo of the 'String-Header' input parameter from the header."
+                    },
+                    "number": {
+                      "type": "number",
+                      "description": "Echo of the 'Number-Header' input parameter from the header."
+                    },
+                    "integer": {
+                      "type": "integer",
+                      "description": "Echo of the 'Integer-Header' input parameter from the header."
+                    }
+                  },
+                  "required": [
+                    "boolean",
+                    "string",
+                    "number",
+                    "integer"
+                  ]
+                }
+              }
+            }
+          },
+          "400": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/PublicError"
+                }
+              }
+            },
+            "description": "Bad Request"
+          }
+        }
+      }
     }
   }
 }
diff --git a/src/headers.rs b/src/headers.rs
@@ -0,0 +1,81 @@
+use axum::http::HeaderMap;
+use axum::Json;
+use serde::Serialize;
+
+use crate::PublicError;
+
+const STRING_HEADER_NAME: &str = "String-Header";
+const INTEGER_HEADER_NAME: &str = "Integer-Header";
+const NUMBER_HEADER_NAME: &str = "Number-Header";
+const BOOLEAN_HEADER_NAME: &str = "Boolean-Header";
+
+pub(crate) async fn main(mut headers: HeaderMap) -> Result<Json<Data>, PublicError> {
+    let string = match headers.remove(STRING_HEADER_NAME) {
+        Some(value) => value
+            .to_str()
+            .map_err(|_| PublicError::invalid(STRING_HEADER_NAME, "Not a valid string"))?
+            .to_string(),
+        None => return Err(PublicError::missing(STRING_HEADER_NAME)),
+    };
+    let integer = match headers.remove(INTEGER_HEADER_NAME) {
+        Some(value) => {
+            let str_value = value.to_str().map_err(|_| {
+                PublicError::invalid(
+                    INTEGER_HEADER_NAME,
+                    "Header needs to be a string to parse a number from.",
+                )
+            })?;
+            str_value
+                .parse::<i32>()
+                .map_err(|_| PublicError::invalid(INTEGER_HEADER_NAME, "Not a valid integer"))?
+        }
+        None => return Err(PublicError::missing(INTEGER_HEADER_NAME)),
+    };
+    let number = match headers.remove(NUMBER_HEADER_NAME) {
+        Some(value) => {
+            let str_value = value.to_str().map_err(|_| {
+                PublicError::invalid(
+                    NUMBER_HEADER_NAME,
+                    "Header must be a string to parse a number from",
+                )
+            })?;
+            str_value
+                .parse::<f64>()
+                .map_err(|_| PublicError::invalid(NUMBER_HEADER_NAME, "Not a valid number"))?
+        }
+        None => return Err(PublicError::missing(NUMBER_HEADER_NAME)),
+    };
+    let boolean = match headers.remove(BOOLEAN_HEADER_NAME) {
+        Some(value) => {
+            let str_value = value.to_str().map_err(|_| {
+                PublicError::invalid(BOOLEAN_HEADER_NAME, "Header must be a string")
+            })?;
+            match str_value {
+                "true" => true,
+                "false" => false,
+                _ => {
+                    return Err(PublicError::invalid(
+                        BOOLEAN_HEADER_NAME,
+                        "Value must either be 'true' or 'false'",
+                    ))
+                }
+            }
+        }
+        None => return Err(PublicError::missing(BOOLEAN_HEADER_NAME)),
+    };
+
+    Ok(Json(Data {
+        string,
+        integer,
+        number,
+        boolean,
+    }))
+}
+
+#[derive(Debug, Serialize)]
+pub(crate) struct Data {
+    string: String,
+    integer: i32,
+    number: f64,
+    boolean: bool,
+}
diff --git a/src/main.rs b/src/main.rs
@@ -1,21 +1,26 @@
 #![deny(clippy::all)]
 #![deny(clippy::pedantic)]
 #![forbid(unsafe_code)]
+#![allow(clippy::unused_async)]
 
 use std::net::SocketAddr;
 
-use axum::{extract::Multipart, http::StatusCode, Json, Router};
-use axum::extract::multipart::MultipartError;
 use axum::response::{IntoResponse, Response};
 use axum::routing::{get, post};
+use axum::{http::StatusCode, Json, Router};
 use serde::Serialize;
 
+mod headers;
+mod multipart;
+
 #[tokio::main]
 async fn main() {
-    // initialize tracing
     tracing_subscriber::fmt::init();
 
-    let app = Router::new().route("/body/multipart", post(upload)).route("/openapi.json", get(openapi));
+    let app = Router::new()
+        .route("/body/multipart", post(multipart::upload))
+        .route("/parameters/header", post(headers::main))
+        .route("/openapi.json", get(openapi));
     let addr = SocketAddr::from(([0, 0, 0, 0], 3000));
     tracing::debug!("listening on {}", addr);
     axum::Server::bind(&addr)
@@ -36,153 +41,39 @@ struct PublicError {
     missing_parameters: Vec<String>,
 }
 
-#[derive(Debug, Serialize)]
-struct Problem {
-    parameter_name: String,
-    description: String,
-}
-
-impl IntoResponse for PublicError {
-    fn into_response(self) -> Response {
-        (StatusCode::BAD_REQUEST, Json(self)).into_response()
-    }
-}
-
-impl From<MultipartError> for PublicError {
-    fn from(e: MultipartError) -> Self {
+impl PublicError {
+    pub(crate) fn missing(parameter: &str) -> Self {
         PublicError {
-            errors: vec![format!("Invalid multipart request: {}", e.to_string())],
-            ..Default::default()
+            missing_parameters: vec![String::from(parameter)],
+            ..Self::default()
         }
     }
-}
-
-async fn upload(mut multipart: Multipart) -> Result<Json<File>, PublicError> {
-    let mut err: Option<PublicError> = None;
-    let mut a_string = None;
-    let mut description = None;
-    let mut file_content_type = None;
-    let mut file_name = None;
-    let mut file_data = None;
-
-    while let Some(field) = multipart.next_field().await? {
-        let field_name = match field.name() {
-            Some(name) => name,
-            None => {
-                err.get_or_insert_with(Default::default)
-                    .extra_parameters
-                    .push(String::from("unnamed parameter"));
-                continue;
-            }
-        };
 
-        match field_name {
-            "a_string" => {
-                if let Ok(value) = field.text().await {
-                    a_string = Some(value);
-                } else {
-                    err.get_or_insert_with(Default::default)
-                        .invalid_parameters
-                        .push(Problem {
-                            parameter_name: String::from("a_string"),
-                            description: String::from("must be a string"),
-                        });
-                }
-            }
-            "description" => {
-                if let Ok(value) = field.text().await {
-                    description = Some(value);
-                } else {
-                    err.get_or_insert_with(Default::default)
-                        .invalid_parameters
-                        .push(Problem {
-                            parameter_name: String::from("description"),
-                            description: String::from("must be a string"),
-                        });
-                }
-            }
-            "file" => {
-                if let Some(value) = field.file_name() {
-                    file_name = Some(value.to_string());
-                } else {
-                    err.get_or_insert_with(Default::default)
-                        .invalid_parameters
-                        .push(Problem {
-                            parameter_name: String::from("file"),
-                            description: String::from("must have a file name"),
-                        });
-                }
-
-                if let Some(value) = field.content_type() {
-                    file_content_type = Some(value.to_string());
-                } else {
-                    err.get_or_insert_with(Default::default)
-                        .invalid_parameters
-                        .push(Problem {
-                            parameter_name: String::from("file"),
-                            description: String::from("must have a content type"),
-                        });
-                }
-
-                if let Ok(value) = field.bytes().await {
-                    file_data = Some(value);
-                } else {
-                    err.get_or_insert_with(Default::default)
-                        .invalid_parameters
-                        .push(Problem {
-                            parameter_name: String::from("file"),
-                            description: String::from("must have data"),
-                        });
-                }
-            }
-            field_name => {
-                err.get_or_insert_with(Default::default)
-                    .extra_parameters
-                    .push(String::from(field_name));
-            }
+    pub(crate) fn invalid(parameter_name: &str, description: &str) -> Self {
+        PublicError {
+            invalid_parameters: vec![Problem::new(parameter_name, description)],
+            ..Self::default()
         }
     }
+}
 
-    let a_string = match a_string {
-        Some(name) => name,
-        None => {
-            let mut err = err.unwrap_or_default();
-            err.missing_parameters.push(String::from("a_string"));
-            return Err(err);
-        }
-    };
+#[derive(Debug, Serialize)]
+struct Problem {
+    parameter_name: String,
+    description: String,
+}
 
-    let (file_content_type, file_name, file_data) = match (file_content_type, file_name, file_data) {
-        (Some(file_content_type), Some(file_name), Some(file_data)) => (
-            file_content_type.to_string(),
-            String::from(file_name),
-            file_data.to_vec(),
-        ),
-        _ => {
-            let mut err = err.unwrap_or_default();
-            err.missing_parameters.push(String::from("file"));
-            return Err(err);
+impl Problem {
+    pub(crate) fn new(parameter_name: &str, description: &str) -> Self {
+        Problem {
+            parameter_name: String::from(parameter_name),
+            description: String::from(description),
         }
-    };
-
-    if let Some(err) = err {
-        Err(err)
-    } else {
-        Ok(Json(File {
-            a_string,
-            description,
-            file_content_type,
-            file_name,
-            file_data: String::from_utf8_lossy(&file_data).to_string(),
-        }))
     }
 }
 
-#[derive(Debug, Serialize)]
-struct File {
-    a_string: String,
-    description: Option<String>,
-    file_content_type: String,
-    file_name: String,
-    file_data: String,
+impl IntoResponse for PublicError {
+    fn into_response(self) -> Response {
+        (StatusCode::BAD_REQUEST, Json(self)).into_response()
+    }
 }
diff --git a/src/multipart.rs b/src/multipart.rs

Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ notice = "warn"`
`48`	`48`	`# A list of advisory IDs to ignore. Note that ignored advisories will still`
`49`	`49`	`# output a note when they are encountered.`
`50`	`50`	`ignore = [`
`51`		`- "RUSTSEC-2021-0131", # Open PR to resolve this https://github.com/actix/actix-web/pull/2538`
	`51`	`+ # "RUSTSEC-2021-0131",`
`52`	`52`	`]`
`53`	`53`	`# Threshold for security vulnerabilities, any vulnerability with a CVSS score`
`54`	`54`	`# lower than the range specified will be ignored. Note that ignored advisories`