reallife tests

Author: aeltorio

.github/workflows/ci.yml

@@ -43,7 +43,7 @@ jobs:
         shell: bash
         run: |
           cargo install cargo-tarpaulin
-          cargo tarpaulin --out Xml --output-dir . 
+          cargo tarpaulin --workspace --all-targets --out Xml --output-dir .
           ls -la cobertura.xml
 
       # Upload coverage to Codecov

examples/custom_schema/Cargo.toml

@@ -11,5 +11,6 @@ rocket_okapi = { path = "../../rocket-okapi", features = [
     "rapidoc",
 ] }
 serde = { workspace = true, features = ["derive"] }
-serde_json = { workspace = true }
 schemars = "1.1.0"
+
+serde_json = "1.0"

examples/custom_schema/src/main.rs

@@ -135,7 +135,10 @@ fn custom_openapi_spec() -> OpenApi {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use rocket::http::Status;
+    use rocket::local::asynchronous::Client;
     use rocket_okapi::openapi_get_spec;
+    use serde_json::Value;
 
     #[test]
     fn custom_spec_contains_home_path() {
@@ -150,4 +153,46 @@ mod tests {
         let spec = rocket_okapi::openapi_get_spec![settings: post::create_post, post::get_post];
         assert!(spec.paths.keys().any(|k| k.contains("/")));
     }
+
+    async fn fetch_openapi_spec(client: &Client, path: &str) -> Value {
+        let response = client.get(path).dispatch().await;
+        assert_eq!(response.status(), Status::Ok);
+        let body = response.into_string().await.expect("body string");
+        serde_json::from_str(&body).expect("valid json")
+    }
+
+    #[rocket::async_test]
+    async fn server_provides_openapi_json_v1_and_routes_match() {
+        // Start the server using the factory from this example
+        let rocket = create_server();
+        let client = Client::tracked(rocket).await.expect("valid client");
+
+        // Request the generated OpenAPI JSON that the example mounts to /v1/openapi.json
+        let spec = fetch_openapi_spec(&client, "/v1/openapi.json").await;
+
+        // Quick sanity checks
+        assert!(spec["openapi"].is_string());
+        assert!(spec["paths"].is_object());
+
+        // Helper: checks that every documented path is present in Rocket's mounted routes
+        let paths = spec["paths"].as_object().unwrap();
+        for path in paths.keys() {
+            // If the path is from an external custom spec, it's valid in OpenAPI but not a Rocket route
+            if path.starts_with("/external") {
+                continue;
+            }
+            // Convert OpenAPI style path (e.g. /user/{id}) to Rocket style (/user/<id>)
+            let rocket_style = path.replace('{', "<").replace('}', ">");
+            let rocket_style_alt = rocket_style.replace('>', "..>");
+            let found = client.rocket().routes().any(|r| {
+                r.uri.to_string().contains(&rocket_style)
+                    || r.uri.to_string().contains(&rocket_style_alt)
+            });
+            assert!(
+                found,
+                "OpenApi path '{}' not found among Rocket routes",
+                path
+            );
+        }
+    }
 }

examples/dyn_templates/Cargo.toml

@@ -15,3 +15,6 @@ rocket_okapi = { path = "../../rocket-okapi", features = [
 serde = { workspace = true, features = ["derive"] }
 rocket_dyn_templates = { workspace = true, features = ["handlebars"] }
 handlebars = "5.0.0"
+
+[dev-dependencies]
+serde_json = "1.0"

examples/dyn_templates/src/main.rs

@@ -50,11 +50,48 @@ async fn main() {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use rocket::http::Status;
+    use rocket::local::asynchronous::Client;
     use rocket_okapi::openapi_get_spec;
+    use serde_json::Value;
 
     #[test]
     fn spec_contains_page_route() {
         let spec = openapi_get_spec![get_page];
         assert!(spec.paths.keys().any(|k| k.contains("/page")));
     }
+
+    async fn fetch_openapi_spec(client: &Client, path: &str) -> Value {
+        let response = client.get(path).dispatch().await;
+        assert_eq!(response.status(), Status::Ok);
+        let body = response.into_string().await.expect("body string");
+        serde_json::from_str(&body).expect("valid json")
+    }
+
+    #[rocket::async_test]
+    async fn server_provides_openapi_json_and_matches_routes() {
+        let rocket = rocket::build()
+            .mount("/", openapi_get_routes![get_page])
+            .attach(Template::fairing());
+        let client = Client::tracked(rocket).await.expect("client");
+        let spec = fetch_openapi_spec(&client, "/openapi.json").await;
+        assert!(spec["paths"]
+            .as_object()
+            .unwrap()
+            .keys()
+            .any(|k| k.contains("/page")));
+        for path in spec["paths"].as_object().unwrap().keys() {
+            let rocket_style = path.replace('{', "<").replace('}', ">");
+            let rocket_style_alt = rocket_style.replace('>', "..>");
+            let found = client.rocket().routes().any(|r| {
+                r.uri.to_string().contains(&rocket_style)
+                    || r.uri.to_string().contains(&rocket_style_alt)
+            });
+            assert!(
+                found,
+                "OpenApi path '{}' not found among Rocket routes",
+                path
+            );
+        }
+    }
 }

examples/json-web-api/Cargo.toml

@@ -12,3 +12,6 @@ rocket_okapi = { path = "../../rocket-okapi", features = [
 ] }
 serde = { workspace = true, features = ["derive"] }
 schemars = "1.1.0"
+
+[dev-dependencies]
+serde_json = "1.0"

examples/json-web-api/src/main.rs

@@ -139,7 +139,10 @@ async fn main() {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use rocket::http::Status;
+    use rocket::local::asynchronous::Client;
     use rocket_okapi::openapi_get_spec;
+    use serde_json::Value;
 
     #[test]
     fn generated_spec_contains_user_routes() {
@@ -155,4 +158,87 @@ mod tests {
         // The `hidden` endpoint is marked skip
         assert!(!spec.paths.keys().any(|k| k.contains("/hidden")));
     }
+
+    async fn fetch_openapi_spec(client: &Client, path: &str) -> Value {
+        let response = client.get(path).dispatch().await;
+        assert_eq!(response.status(), Status::Ok);
+        let body = response.into_string().await.expect("body string");
+        serde_json::from_str(&body).expect("valid json")
+    }
+
+    #[rocket::async_test]
+    async fn server_openapi_contains_and_matches_routes() {
+        // Rebuild the Rocket instance similarly to `main` so the example's routes are mounted
+        let rocket = rocket::build()
+            .mount(
+                "/",
+                openapi_get_routes![
+                    get_all_users,
+                    get_user,
+                    get_user_by_name,
+                    create_user,
+                    hidden,
+                    create_post_by_query,
+                ],
+            )
+            .mount(
+                "/swagger-ui/",
+                make_swagger_ui(&SwaggerUIConfig {
+                    url: "../openapi.json".to_owned(),
+                    ..Default::default()
+                }),
+            )
+            .mount(
+                "/rapidoc/",
+                make_rapidoc(&RapiDocConfig {
+                    general: GeneralConfig {
+                        spec_urls: vec![UrlObject::new("General", "../openapi.json")],
+                        ..Default::default()
+                    },
+                    hide_show: HideShowConfig {
+                        allow_spec_url_load: false,
+                        allow_spec_file_load: false,
+                        ..Default::default()
+                    },
+                    ..Default::default()
+                }),
+            );
+
+        let client = Client::tracked(rocket).await.expect("client");
+        let spec = fetch_openapi_spec(&client, "/openapi.json").await;
+
+        // The spec should include the user related route paths
+        assert!(spec["paths"]
+            .as_object()
+            .unwrap()
+            .keys()
+            .any(|k| k.contains("/user")));
+        assert!(spec["paths"]
+            .as_object()
+            .unwrap()
+            .keys()
+            .any(|k| k.contains("post_by_query")));
+        // And the `hidden` route should be omitted
+        assert!(!spec["paths"]
+            .as_object()
+            .unwrap()
+            .keys()
+            .any(|k| k.contains("/hidden")));
+
+        // Cross-check: every documented path should match a Rocket route
+        let paths = spec["paths"].as_object().unwrap();
+        for path in paths.keys() {
+            let rocket_style = path.replace('{', "<").replace('}', ">");
+            let rocket_style_alt = rocket_style.replace('>', "..>");
+            let found = client.rocket().routes().any(|r| {
+                r.uri.to_string().contains(&rocket_style)
+                    || r.uri.to_string().contains(&rocket_style_alt)
+            });
+            assert!(
+                found,
+                "OpenApi path '{}' not found among Rocket routes",
+                path
+            );
+        }
+    }
 }

examples/nested/Cargo.toml

@@ -3,13 +3,16 @@ name = "nested"
 version = "0.1.0"
 authors = [
     "Maxime Borges <[email protected]>",
-    "Ralph Bisschops <ralph.bisschops[email protected]>",
+    "Ralph Bisschops <ralph.bissops[email protected]>",
 ]
 edition = "2021"
 
 [dependencies]
 rocket = { workspace = true }
 rocket_okapi = { path = "../../rocket-okapi", features = ["rapidoc"] }
 serde = { workspace = true, features = ["derive"] }
-serde_json = { workspace = true }
+serde_json = "1.0"
 schemars = "1.1.0"
+
+[dev-dependencies]
+serde_json = "1.0"

examples/nested/src/main.rs

@@ -125,13 +125,45 @@ fn custom_openapi_spec() -> OpenApi {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use rocket_okapi::openapi_get_spec;
+    use rocket::http::Status;
+    use rocket::local::asynchronous::Client;
     use rocket_okapi::settings::OpenApiSettings;
+    use serde_json::Value;
 
     #[test]
     fn nested_api_spec_contains_paths() {
         let settings = OpenApiSettings::default();
         let (_routes, spec) = api::get_routes_and_docs(&settings);
         assert!(spec.paths.keys().any(|k| k.contains("/")));
     }
+
+    async fn fetch_openapi_spec(client: &Client, path: &str) -> Value {
+        let response = client.get(path).dispatch().await;
+        assert_eq!(response.status(), Status::Ok);
+        let body = response.into_string().await.expect("body string");
+        serde_json::from_str(&body).expect("valid json")
+    }
+
+    #[rocket::async_test]
+    async fn server_provides_v1_openapi_and_matches_routes() {
+        let rocket = create_server();
+        let client = Client::tracked(rocket).await.expect("client");
+        let spec = fetch_openapi_spec(&client, "/v1/openapi.json").await;
+        assert!(spec["paths"].is_object());
+        for path in spec["paths"].as_object().unwrap().keys() {
+            if path.starts_with("/external") {
+                continue;
+            }
+            let rocket_style = path.replace('{', "<").replace('}', ">");
+            let found = client
+                .rocket()
+                .routes()
+                .any(|r| r.uri.to_string().contains(&rocket_style));
+            assert!(
+                found,
+                "OpenApi path '{}' not found among Rocket routes",
+                path
+            );
+        }
+    }
 }

examples/openapi_attributes/Cargo.toml

@@ -6,5 +6,12 @@ edition = "2021"
 
 [dependencies]
 rocket = { workspace = true }
-rocket_okapi = { path = "../../rocket-okapi", features = ["swagger", "rapidoc"] }
+rocket_okapi = { path = "../../rocket-okapi", features = [
+    "swagger",
+    "rapidoc",
+] }
 serde = { workspace = true }
+schemars = "1.1.0"
+
+[dev-dependencies]
+serde_json = "1.0"