oasert 0.1.4

A library for verifying in-flight requests against a provided OpenAPI 3.1.x or 3.0.x specification.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

use lambda_http::{service_fn, Body, Error, IntoResponse, RequestExt};
use oasert::validator::OpenApiPayloadValidator;
use std::sync::Arc;

#[tokio::main]
async fn main() -> Result<(), Error> {
    let openapi_file =
        std::fs::read_to_string("examples/aws-lambda-http-validation/openapi-v3.1.0.json").unwrap();
    let openapi_value: serde_json::Value = serde_json::from_str(&openapi_file).unwrap();
    let validator = Arc::new(OpenApiPayloadValidator::new(openapi_value).unwrap());
    lambda_http::run(service_fn(|req| {
        validation_function(validator.clone(), req)
    }))
    .await?;
    Ok(())
}

async fn validation_function(
    validator: Arc<OpenApiPayloadValidator>,
    request: http::Request<Body>,
) -> Result<impl IntoResponse, std::convert::Infallible> {
    let _context = request.lambda_context_ref();
    let response = match validator.validate_request(&request, None) {
        Ok(_) => http::Response::builder()
            .status(200)
            .body(String::from("OK")),
        Err(e) => {
            println!("{}", e);
            http::Response::builder()
                .status(400)
                .body(String::from("Bad Request"))
        }
    }
    .unwrap();

    Ok(response)
}

#[cfg(test)]
mod tests {
    use super::*;
    use http::Method;
    use http_body_util::BodyExt;
    use lambda_http::{Body, Context, Request};
    use oasert::validator::OpenApiPayloadValidator;
    use std::sync::Arc;

    // Helper function to create a test request
    fn create_test_request(
        method: Method,
        uri: &str,
        query_params: Option<&[(&str, &str)]>,
        body: Option<Body>,
    ) -> Request {
        let mut request = if let Some(body) = body {
            Request::new(body)
        } else {
            Request::default()
        };
        *request.method_mut() = method;
        *request.uri_mut() = uri.parse().unwrap();
        request.extensions_mut().insert(Context::default());
        request
    }

    fn create_validator() -> Arc<OpenApiPayloadValidator> {
        let openapi_file =
            std::fs::read_to_string("examples/aws-lambda-http-validation/openapi-v3.1.0.json")
                .unwrap();
        let openapi_value: serde_json::Value = serde_json::from_str(&openapi_file).unwrap();
        Arc::new(OpenApiPayloadValidator::new(openapi_value).unwrap())
    }

    #[tokio::test]
    async fn test_validation_function_success() {
        let validator = create_validator();
        let request = create_test_request(Method::GET, "/pets", Some(&[("name", "tester")]), None);
        let response = validation_function(validator, request).await.unwrap();
        let response = response.into_response().await;
        let bytes = response.collect().await.unwrap().to_bytes();
        let response_body = String::from_utf8(bytes.to_vec()).unwrap();
        assert!(response_body.contains("OK"));
    }
}