add response status validation

Author: robjtede

.gitignore

@@ -1,3 +1,4 @@
 target
 Cargo.lock
 *.bk
+.env

Cargo.toml

@@ -23,8 +23,11 @@ serde_json = "1"
 serde_yaml = "0.8"
 url = "1.7"
 url_serde = "0.2"
+reqwest = "0.9"
 
 [dev-dependencies]
+dotenv = "0.14"
+colored = "1"
 maplit = "1"
 pretty_assertions = "0.6"
 pretty_env_logger = "0.3"

examples/conformance.rs

@@ -0,0 +1,139 @@
+#![feature(todo_macro)]
+#![allow(dead_code, unused_imports, unused_variables)]
+
+use std::env;
+
+use colored::Colorize;
+use http::{Method, StatusCode};
+use log::{debug, info};
+use oas3::{
+    conformance::{
+        ConformanceTestSpec, OperationSpec, RequestSpec, ResolvedConformanceTestSpec, ResponseSpec,
+        TestAuthorization, TestRequest,
+    },
+    validation::Error as ValidationError,
+    Error, Spec,
+};
+
+fn do_request(req: &TestRequest) -> Result<reqwest::Response, reqwest::Error> {
+    let base_url = "http://localhost:9000/api/auth/v1";
+    let client = reqwest::Client::new();
+
+    // TODO: add url params
+    // TODO: add qs params
+
+    let method: reqwest::Method = req.operation.method.as_str().parse().unwrap();
+    let url: String = [base_url, &req.operation.path].concat();
+
+    client
+        .request(method, &url)
+        .headers(req.headers.clone())
+        .body(req.body.to_vec())
+        .send()
+}
+
+fn do_test(spec: &Spec, test: ResolvedConformanceTestSpec) -> Result<(), ValidationError> {
+    debug!("request: {:?}", &test.request);
+    debug!("response spec: {:?}", &test.response);
+
+    let mut res = do_request(&test.request).unwrap();
+    let body = res.json().map_err(|_| ValidationError::NotJson)?;
+    let status = res.status();
+
+    debug!("response: {:?}", &res);
+
+    let validation = test.response.validate_status(&res.status())?;
+    info!("validation: {:?}", &validation);
+
+    let validation = test.response.validate_body(&body)?;
+    info!("validation: {:?}", &validation);
+
+    Ok(())
+}
+
+fn do_tests(
+    spec: &Spec,
+    tests: &[&ConformanceTestSpec],
+) -> Vec<(ConformanceTestSpec, Option<Error>)> {
+    let mut results = vec![];
+
+    for test in tests {
+        match test.resolve(&spec) {
+            Ok(resolved_test) => {
+                let validation = do_test(&spec, resolved_test);
+                results.push(((*test).clone(), validation.map_err(Error::Validation).err()));
+            }
+            Err(err) => results.push(((*test).clone(), Some(err))),
+        }
+    }
+
+    results
+}
+
+fn main() {
+    let _ = dotenv::dotenv();
+    pretty_env_logger::init();
+
+    let spec = oas3::from_path("../app/docs/api.yml")
+        .expect("api spec parse error");
+
+    let auth_method = TestAuthorization::bearer(env::var("TOKEN").unwrap());
+
+    let test_pass0 = ConformanceTestSpec::new(
+        OperationSpec::post("/token"),
+        RequestSpec::from_example("application/json", "basic"),
+        ResponseSpec::from_schema("200", "application/json"),
+    );
+
+    let test_pass1 = ConformanceTestSpec::new(
+        OperationSpec::post("/verify"),
+        RequestSpec::from_json_example("revoked"),
+        ResponseSpec::from_example("200", "application/json", "revoked"),
+    );
+
+    let test_fail0 = ConformanceTestSpec::new(
+        OperationSpec::operation_id("signin"),
+        RequestSpec::from_json_example("unregistered"),
+        ResponseSpec::from_example("401", "application/json", "success"),
+    );
+
+    let test_fail1 = ConformanceTestSpec::new(
+        OperationSpec::operation_id("checkLoggedIn"),
+        RequestSpec::empty().with_auth(&auth_method),
+        ResponseSpec::from_status("200"),
+    );
+
+    let results = do_tests(&spec, &[&test_pass0, &test_pass1, &test_fail0, &test_fail1]);
+
+    println!("");
+    print_test_results(results.as_slice());
+    println!("");
+}
+
+fn print_test_results(results: &[(ConformanceTestSpec, Option<Error>)]) {
+    for (test, error) in results {
+        let mut msg = vec![];
+
+        let op = &test.operation;
+
+        if error.is_some() {
+            msg.push("❌ Err".red());
+        } else {
+            msg.push("✅ Ok ".green());
+        }
+
+        msg.push(" | ".normal());
+        msg.push(format!("{}", &op).normal());
+
+        if let Some(ref err) = error {
+            msg.push(" | ".normal());
+            msg.push(err.to_string().red());
+        }
+
+        for part in msg {
+            print!("{}", part);
+        }
+
+        println!("");
+    }
+}

src/components.rs

@@ -1,8 +1,8 @@
 use std::collections::BTreeMap;
 
 use crate::{
-    Callback, Example, Header, Link, Parameter, RequestBody, Response, Schema,
-    SecurityScheme, ObjectOrReference,
+    Callback, Example, Header, Link, ObjectOrReference, Parameter, RequestBody, Response, Schema,
+    SecurityScheme,
 };
 
 /// Holds a set of reusable objects for different aspects of the OAS.

src/conformance/auth.rs

@@ -0,0 +1,15 @@
+use http::{Method, StatusCode};
+
+use crate::{validation::Error as ValidationError, Operation, Spec};
+
+
+#[derive(Debug, Clone)]
+pub enum TestAuthorization {
+    Bearer(String)
+}
+
+impl TestAuthorization {
+    pub fn bearer<T: Into<String>>(token: T) -> Self {
+        Self::Bearer(token.into())
+    }
+}

src/conformance/mod.rs

@@ -1,9 +1,11 @@
+mod auth;
 mod error;
 mod operation;
 mod request;
 mod response;
 mod test;
 
+pub use auth::*;
 pub use error::*;
 pub use operation::*;
 pub use request::*;

src/conformance/operation.rs

@@ -1,14 +1,18 @@
+use std::fmt;
+
 use http::{Method, StatusCode};
 
+use crate::{validation::Error as ValidationError, Operation, Spec};
+
 #[derive(Debug, Clone)]
-pub struct OperationSpec {
-    pub method: Method,
-    pub path: String,
+pub enum OperationSpec {
+    Parts { method: Method, path: String },
+    OperationId(String),
 }
 
 impl OperationSpec {
     pub fn new<P: Into<String>>(method: Method, path: P) -> Self {
-        Self {
+        Self::Parts {
             method,
             path: path.into(),
         }
@@ -19,4 +23,36 @@ impl OperationSpec {
     pub fn patch<P: Into<String>>(path: P) -> Self { Self::new(Method::PATCH, path) }
     pub fn put<P: Into<String>>(path: P) -> Self { Self::new(Method::PUT, path) }
     pub fn delete<P: Into<String>>(path: P) -> Self { Self::new(Method::DELETE, path) }
+
+    pub fn operation_id<P: Into<String>>(op_id: P) -> Self { Self::OperationId(op_id.into()) }
+}
+
+impl fmt::Display for OperationSpec {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Parts { method, path } => write!(f, "{} {}", method, path),
+            Self::OperationId(op_id) => write!(f, "Operation ID: {}", op_id)
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct TestOperation {
+    pub method: Method,
+    pub path: String,
+}
+
+impl TestOperation {
+    pub fn new<P: Into<String>>(method: Method, path: P) -> Self {
+        Self {
+            method,
+            path: path.into(),
+        }
+    }
+
+    pub fn resolve_operation<'a>(&self, spec: &'a Spec) -> Result<&'a Operation, ValidationError> {
+        spec.get_operation(&self.method, &self.path).ok_or_else(|| {
+            ValidationError::OperationNotFound(self.method.clone(), self.path.clone())
+        })
+    }
 }

src/conformance/request.rs

@@ -1,21 +1,31 @@
 use bytes::Bytes;
 use http::HeaderMap;
 
-use super::OperationSpec;
+use super::{OperationSpec, TestAuthorization, TestOperation};
 
 #[derive(Debug, Clone)]
 pub enum RequestSource {
     Example { media_type: String, name: String },
     Raw(Bytes),
+    Empty,
 }
 
 #[derive(Debug, Clone)]
 pub struct RequestSpec {
     pub source: RequestSource,
     pub bad: bool,
+    pub auth: Option<TestAuthorization>,
 }
 
 impl RequestSpec {
+    pub fn empty() -> Self {
+        Self {
+            source: RequestSource::Empty,
+            bad: false,
+            auth: None,
+        }
+    }
+
     pub fn from_example<M, N>(media_type: M, name: N) -> Self
     where
         M: Into<String>,
@@ -27,6 +37,7 @@ impl RequestSpec {
                 name: name.into(),
             },
             bad: false,
+            auth: None,
         }
     }
 
@@ -40,6 +51,7 @@ impl RequestSpec {
                 name: name.into(),
             },
             bad: false,
+            auth: None,
         }
     }
 
@@ -50,14 +62,21 @@ impl RequestSpec {
         Self {
             source: RequestSource::Raw(body.into()),
             bad: true,
+            auth: None,
         }
     }
-}
 
+    pub fn with_auth(self, auth: &TestAuthorization) -> Self {
+        Self {
+            auth: Some(auth.clone()),
+            ..self
+        }
+    }
+}
 
 #[derive(Debug, Clone)]
 pub struct TestRequest {
-    pub operation: OperationSpec,
+    pub operation: TestOperation,
     pub headers: HeaderMap,
     // pub parameters: Vec<_>,
     pub body: Bytes,

src/conformance/response.rs

@@ -1,11 +1,13 @@
 use bytes::Bytes;
 use http::StatusCode;
+use serde_json::Value as JsonValue;
 
-use super::OperationSpec;
+use super::{OperationSpec, TestOperation};
 use crate::validation::{Error as ValidationError, SchemaValidator};
 
 #[derive(Debug, Clone)]
 pub enum ResponseSpecSource {
+    Status(StatusCode),
     Schema {
         status: StatusCode,
         media_type: String,
@@ -24,6 +26,12 @@ pub struct ResponseSpec {
 }
 
 impl ResponseSpec {
+    pub fn from_status(status: &str) -> Self {
+        Self {
+            source: ResponseSpecSource::Status(status.parse().unwrap()),
+        }
+    }
+
     pub fn from_schema<M>(status: &str, media_type: M) -> Self
     where
         M: Into<String>,
@@ -53,14 +61,31 @@ impl ResponseSpec {
 
 #[derive(Debug, Clone)]
 pub struct TestResponseSpec {
-    pub operation: OperationSpec,
-    pub body_validator: SchemaValidator,
+    pub operation: TestOperation,
+    pub status: StatusCode,
+    pub body_validator: Option<SchemaValidator>,
 }
 
 impl TestResponseSpec {
-    pub fn validate(&self, val: &serde_json::Value) -> Result<(), ValidationError> {
-        self.body_validator
-            .validate_type(val)
-            .and(self.body_validator.validate_required_fields(val))
+    // TODO: own response type
+
+    pub fn validate_status(&self, val: &StatusCode) -> Result<(), ValidationError> {
+        if &self.status == val {
+            Ok(())
+        } else {
+            Err(ValidationError::StatusMismatch(
+                self.status.clone(),
+                val.clone(),
+            ))
+        }
+    }
+
+    pub fn validate_body(&self, body: &JsonValue) -> Result<(), ValidationError> {
+        if let Some(ref vltr) = self.body_validator {
+            vltr.validate_type(body)?;
+            vltr.validate_required_fields(body)?;
+        }
+
+        Ok(())
     }
 }