Coverage improvements and CI fixes

Author: SamuelMarks

cli/src/from_openapi.rs

@@ -56,27 +56,33 @@ pub enum FromOpenApiCommands {
 pub struct GenerateArgs {
     /// Path or URL to the OpenAPI specification.
     #[clap(short, long, required_unless_present = "input_dir", env = "CDD_INPUT")]
+    /// The input file path
     pub input: Option<PathBuf>,
 
     /// Directory containing OpenAPI specifications.
     #[clap(long, required_unless_present = "input", env = "CDD_INPUT_DIR")]
+    /// The input directory path
     pub input_dir: Option<PathBuf>,
 
     /// Output file or directory path.
     #[clap(short, long = "output", env = "CDD_OUTPUT")]
+    /// The output directory path
     pub output_dir: Option<PathBuf>,
 
     /// Do not generate GitHub Actions scaffolding.
     #[clap(long, env = "CDD_NO_GITHUB_ACTIONS")]
+    /// Whether to skip github actions generation
     pub no_github_actions: bool,
 
     /// Do not generate installable package scaffolding.
     #[clap(long, env = "CDD_NO_INSTALLABLE_PACKAGE")]
+    /// Whether to skip package generation
     pub no_installable_package: bool,
 
     /// Generate integration tests and mocks.
     #[clap(long, env = "CDD_TESTS")]
     #[clap(long, env = "CDD_TESTS")]
+    /// Whether to generate tests
     pub tests: bool,
 
     /// Generate Model Context Protocol (MCP) server and adapter.
@@ -651,17 +657,25 @@ components:
 /// Configuration for `from_openapi` programmatic API
 #[derive(Debug, Default)]
 pub struct FromOpenApiConfig {
+    /// The parsed subcommand
     pub subcommand: String,
+    /// The input file path
     pub input: Option<PathBuf>,
+    /// The input directory path
     pub input_dir: Option<PathBuf>,
+    /// The output directory path
     pub output_dir: Option<PathBuf>,
+    /// Whether to skip github actions generation
     pub no_github_actions: bool,
+    /// Whether to skip package generation
     pub no_installable_package: bool,
 
+    /// Whether to generate tests
     pub tests: bool,
 
     /// Generate Model Context Protocol (MCP) server and adapter.
     pub mcp: bool,
+    /// The server framework to use
     pub framework: ServerFramework,
 }
 

cli/src/mcp.rs

@@ -540,9 +540,9 @@ invalid json
         let mut stdin = input.as_bytes();
         let mut stdout = Vec::new();
 
-        serve_mcp_inner(&mut stdin, &mut stdout).unwrap();
+        serve_mcp_inner(&mut stdin, &mut stdout).expect("must succeed");
 
-        let output = String::from_utf8(stdout).unwrap();
+        let output = String::from_utf8(stdout).expect("must succeed");
         let lines: Vec<&str> = output.trim().split('\n').collect();
 
         assert_eq!(lines.len(), 36);
@@ -601,7 +601,7 @@ invalid json
     fn test_serve_mcp_inner_read_error() {
         let mut stdin = ErrorReader;
         let mut stdout = Vec::new();
-        serve_mcp_inner(&mut stdin, &mut stdout).unwrap();
+        serve_mcp_inner(&mut stdin, &mut stdout).expect("must succeed");
         assert!(stdout.is_empty());
     }
 }

cli/src/serve_json_rpc.rs

@@ -15,10 +15,12 @@ use std::path::PathBuf;
 pub struct ServeJsonRpcArgs {
     /// Port to listen on.
     #[clap(short, long, default_value = "8080", env = "CDD_PORT")]
+    /// The port to listen on
     pub port: u16,
 
     /// Interface to listen on.
     #[clap(short, long, default_value = "127.0.0.1", env = "CDD_LISTEN")]
+    /// The address to listen on
     pub listen: String,
 }
 
@@ -369,7 +371,9 @@ mod tests {
 /// Configuration for `serve_json_rpc` programmatic API
 #[derive(Debug)]
 pub struct ServeJsonRpcConfig {
+    /// The port to listen on
     pub port: u16,
+    /// The address to listen on
     pub listen: String,
 }
 
@@ -428,7 +432,7 @@ mod extra_rpc_tests {
             id: None,
         };
         let res = send_rpc(&req).await;
-        assert_eq!(res.error.unwrap().code, -32602);
+        assert_eq!(res.error.expect("must succeed").code, -32602);
 
         // Invalid params
         let req = RpcRequest {
@@ -438,7 +442,7 @@ mod extra_rpc_tests {
             id: None,
         };
         let res = send_rpc(&req).await;
-        assert_eq!(res.error.unwrap().code, -32602);
+        assert_eq!(res.error.expect("must succeed").code, -32602);
 
         // Success execution - pointing to something that will error inside generate
         let req = RpcRequest {
@@ -448,7 +452,7 @@ mod extra_rpc_tests {
             id: None,
         };
         let res = send_rpc(&req).await;
-        assert_eq!(res.error.unwrap().code, -32000);
+        assert_eq!(res.error.expect("must succeed").code, -32000);
     }
 
     #[actix_rt::test]
@@ -461,7 +465,7 @@ mod extra_rpc_tests {
             id: None,
         };
         let res = send_rpc(&req).await;
-        assert_eq!(res.error.unwrap().code, -32602);
+        assert_eq!(res.error.expect("must succeed").code, -32602);
 
         // Invalid params
         let req = RpcRequest {
@@ -471,7 +475,7 @@ mod extra_rpc_tests {
             id: None,
         };
         let res = send_rpc(&req).await;
-        assert_eq!(res.error.unwrap().code, -32602);
+        assert_eq!(res.error.expect("must succeed").code, -32602);
 
         // Fail inside generate
         let req = RpcRequest {
@@ -481,7 +485,7 @@ mod extra_rpc_tests {
             id: None,
         };
         let res = send_rpc(&req).await;
-        assert_eq!(res.error.unwrap().code, -32000);
+        assert_eq!(res.error.expect("must succeed").code, -32000);
     }
 
     #[actix_rt::test]
@@ -494,7 +498,7 @@ mod extra_rpc_tests {
             id: None,
         };
         let res = send_rpc(&req).await;
-        assert_eq!(res.error.unwrap().code, -32602);
+        assert_eq!(res.error.expect("must succeed").code, -32602);
 
         // Success inside, but it will error
         let req = RpcRequest {
@@ -504,7 +508,7 @@ mod extra_rpc_tests {
             id: None,
         };
         let res = send_rpc(&req).await;
-        assert_eq!(res.error.unwrap().code, -32000);
+        assert_eq!(res.error.expect("must succeed").code, -32000);
 
         let req = RpcRequest {
             jsonrpc: "2.0".to_string(),
@@ -558,21 +562,21 @@ mod extra_rpc_success_tests {
     #[actix_rt::test]
     async fn test_to_openapi_rpc_success() {
         use tempfile::tempdir;
-        let dir = tempdir().unwrap();
+        let dir = tempdir().expect("must succeed");
         let src_dir = dir.path().join("src");
-        std::fs::create_dir_all(&src_dir).unwrap();
+        std::fs::create_dir_all(&src_dir).expect("must succeed");
         let input = src_dir.join("input.rs");
         let output = dir.path().join("out.yaml");
         let schema =
             "pub struct User { pub id: i32 } \n #[get(\"/users\")] pub async fn get_users() {}";
-        std::fs::write(&input, schema).unwrap();
+        std::fs::write(&input, schema).expect("must succeed");
 
         let req = RpcRequest {
             jsonrpc: "2.0".to_string(),
             method: "to_openapi".to_string(),
             params: Some(serde_json::json!({
-                "input": src_dir.to_str().unwrap(),
-                "output": output.to_str().unwrap()
+                "input": src_dir.to_str().expect("must succeed"),
+                "output": output.to_str().expect("must succeed")
             })),
             id: None,
         };
@@ -583,18 +587,18 @@ mod extra_rpc_success_tests {
     #[actix_rt::test]
     async fn test_to_docs_json_rpc_success() {
         use tempfile::tempdir;
-        let dir = tempdir().unwrap();
+        let dir = tempdir().expect("must succeed");
         let input = dir.path().join("input.rs");
         let output = dir.path().join("out.yaml");
         let schema = "openapi: 3.0.0\ninfo:\n  title: API\n  version: 1.0.0\npaths: {}";
-        std::fs::write(&input, schema).unwrap();
+        std::fs::write(&input, schema).expect("must succeed");
 
         let req = RpcRequest {
             jsonrpc: "2.0".to_string(),
             method: "to_docs_json".to_string(),
             params: Some(serde_json::json!({
-                "input": input.to_str().unwrap(),
-                "output": output.to_str().unwrap()
+                "input": input.to_str().expect("must succeed"),
+                "output": output.to_str().expect("must succeed")
             })),
             id: None,
         };
@@ -605,7 +609,7 @@ mod extra_rpc_success_tests {
     #[actix_rt::test]
     async fn test_from_openapi_rpc_success() {
         use tempfile::tempdir;
-        let dir = tempdir().unwrap();
+        let dir = tempdir().expect("must succeed");
         let input = dir.path().join("openapi.yaml");
         let output = dir.path().join("out");
 
@@ -616,14 +620,14 @@ info:
   version: 1.0.0
 paths: {}
         "#;
-        std::fs::write(&input, schema).unwrap();
+        std::fs::write(&input, schema).expect("must succeed");
 
         let req = RpcRequest {
             jsonrpc: "2.0".to_string(),
             method: "from_openapi_to_sdk".to_string(),
             params: Some(serde_json::json!({
-                "input": input.to_str().unwrap(),
-                "output": output.to_str().unwrap()
+                "input": input.to_str().expect("must succeed"),
+                "output": output.to_str().expect("must succeed")
             })),
             id: None,
         };

cli/src/to_docs_json.rs

@@ -12,18 +12,22 @@ use std::fs;
 pub struct ToDocsJsonArgs {
     /// Path or URL to the OpenAPI specification.
     #[clap(short, long, env = "CDD_INPUT")]
+    /// The input file path
     pub input: String,
 
     /// If provided, omit the imports field in the code object.
     #[clap(long, env = "CDD_NO_IMPORTS")]
+    /// Whether to exclude imports
     pub no_imports: bool,
 
     /// If provided, omit the wrapper_start and wrapper_end fields in the code object.
     #[clap(long, env = "CDD_NO_WRAPPING")]
+    /// Whether to disable wrapping
     pub no_wrapping: bool,
 
     /// Output file or directory path.
     #[clap(short, long, env = "CDD_OUTPUT")]
+    /// The output file path
     pub output: Option<String>,
 }
 
@@ -366,9 +370,13 @@ paths: {}
 /// Configuration for `to_docs_json` programmatic API
 #[derive(Debug, Default)]
 pub struct ToDocsJsonConfig {
+    /// The input file path
     pub input: String,
+    /// The output file path
     pub output: Option<String>,
+    /// Whether to exclude imports
     pub no_imports: bool,
+    /// Whether to disable wrapping
     pub no_wrapping: bool,
 }
 

cli/src/to_openapi.rs

@@ -14,10 +14,12 @@ use walkdir::WalkDir;
 pub struct ToOpenApiArgs {
     /// Path to source code directory or file.
     #[clap(short = 'i', long, env = "CDD_INPUT")]
+    /// The input directory path
     pub input: PathBuf,
 
     /// Output file or directory path.
     #[clap(short = 'o', long, env = "CDD_OUTPUT", default_value = "spec.json")]
+    /// The output directory path
     pub output: PathBuf,
 }
 
@@ -190,25 +192,25 @@ mod tests {
     fn test_to_openapi_execute_failures() {
         let dir = tempdir().expect("Failed to create temporary directory");
         let src_dir = dir.path().join("src");
-        std::fs::create_dir_all(&src_dir).unwrap();
+        std::fs::create_dir_all(&src_dir).expect("must succeed");
 
         let out_file = dir.path().join("out.yaml");
 
         // 1. Directory named .rs so read_to_string fails
         let dir_rs = src_dir.join("dir.rs");
-        std::fs::create_dir(&dir_rs).unwrap();
+        std::fs::create_dir(&dir_rs).expect("must succeed");
 
         // 2. File where extract_struct_names fails
         let syntax_err_rs = src_dir.join("syntax.rs");
-        std::fs::write(&syntax_err_rs, "impl Model {").unwrap();
+        std::fs::write(&syntax_err_rs, "impl Model {").expect("must succeed");
 
         // 3. File where extract_model fails
         let model_err_rs = src_dir.join("model_err.rs");
-        std::fs::write(&model_err_rs, "pub struct Partial").unwrap();
+        std::fs::write(&model_err_rs, "pub struct Partial").expect("must succeed");
 
         // 4. File where parse routes fail
         let route_err_rs = src_dir.join("route_err.rs");
-        std::fs::write(&route_err_rs, "pub fn my_route() {}").unwrap();
+        std::fs::write(&route_err_rs, "pub fn my_route() {}").expect("must succeed");
 
         let args = ToOpenApiArgs {
             input: src_dir,
@@ -297,7 +299,9 @@ mod tests {
 /// Configuration for `to_openapi` programmatic API
 #[derive(Debug, Default)]
 pub struct ToOpenApiConfig {
+    /// The input directory path
     pub input: PathBuf,
+    /// The output directory path
     pub output: PathBuf,
 }
 
@@ -317,10 +321,10 @@ mod extra_coverage_tests {
 
     #[test]
     fn test_generate_to_openapi() {
-        let dir = tempdir().unwrap();
+        let dir = tempdir().expect("must succeed");
         let input_file = dir.path().join("input.rs");
         let output_file = dir.path().join("output.yaml");
-        std::fs::write(&input_file, "pub struct MyStruct { pub id: i32 }").unwrap();
+        std::fs::write(&input_file, "pub struct MyStruct { pub id: i32 }").expect("must succeed");
 
         let config = ToOpenApiConfig {
             input: input_file,