Fix coverage

Author: owjs3901

crates/vespera/src/lib.rs

@@ -20,7 +20,7 @@ pub mod openapi {
 pub use vespera_core::openapi::OpenApi;
 
 // Re-export macros from vespera_macro
-pub use vespera_macro::{export_app, route, schema, schema_type, vespera, Schema};
+pub use vespera_macro::{Schema, export_app, route, schema, schema_type, vespera};
 
 // Re-export serde_json for merge feature (runtime spec merging)
 pub use serde_json;

crates/vespera_macro/src/parser/operation.rs

@@ -487,7 +487,7 @@ mod tests {
 
     #[test]
     fn test_single_path_param_with_single_type() {
-        // Test line 55: Path<T> with single type (not tuple) and exactly ONE path param
+        // Test: Path<T> with single type
         // This exercises the branch: path_params.len() == 1 with non-tuple type
         let op = build("fn get(Path(id): Path<i32>) -> String", "/users/{id}", None);
 
@@ -515,23 +515,23 @@ mod tests {
 
     #[test]
     fn test_non_path_extractor_with_query() {
-        // Test lines 85, 89: non-Path extractor handling
+        // Test: non-Path extractor handling
         // When input is Query<T>, it should NOT be treated as Path
         let op = build(
             "fn search(Query(params): Query<QueryParams>) -> String",
             "/search",
             None,
         );
 
-        // Query params should be extended to parameters (line 89)
+        // Test: Query params should be extended to parameters
         // But QueryParams is not in known_schemas/struct_definitions so it won't appear
         // The key is that it doesn't treat Query as a Path extractor (line 85 returns false)
         assert!(op.request_body.is_none()); // Query is not a body
     }
 
     #[test]
     fn test_non_path_extractor_with_state() {
-        // Test lines 85, 89: State<T> should be ignored (not Path)
+        // Test: State<T> should be ignored
         let op = build(
             "fn handler(State(state): State<AppState>) -> String",
             "/handler",
@@ -586,7 +586,7 @@ mod tests {
 
     #[test]
     fn test_multiple_path_params_with_single_type() {
-        // Test line 57-60: multiple path params but single type - uses type for all
+        // Test: multiple path params but single type
         let op = build(
             "fn get(Path(id): Path<String>) -> String",
             "/shops/{shop_id}/items/{item_id}",
@@ -634,7 +634,7 @@ mod tests {
 
     #[test]
     fn test_non_path_extractor_generates_params_and_extends() {
-        // Test lines 85, 89: non-Path extractor that DOES generate params
+        // Test: non-Path extractor that generates params
         // Query<T> where T is a known struct generates query parameters
         let sig: syn::Signature = syn::parse_str("fn search(Query(params): Query<SearchParams>, TypedHeader(auth): TypedHeader<Authorization>) -> String").unwrap();
 

crates/vespera_macro/src/parser/parameters.rs

@@ -580,6 +580,24 @@ mod tests {
         vec![vec![ParameterLocation::Header]],
         "header_custom"
     )]
+    #[case(
+        "fn test(input: Form<User>) {}",
+        vec![],
+        vec![vec![]],
+        "form_body"
+    )]
+    #[case(
+        "fn test(upload: TypedMultipart<UploadRequest>) {}",
+        vec![],
+        vec![vec![]],
+        "typed_multipart_body"
+    )]
+    #[case(
+        "fn test(multipart: Multipart) {}",
+        vec![],
+        vec![vec![]],
+        "raw_multipart_body"
+    )]
     fn test_parse_function_parameter_cases(
         #[case] func_src: &str,
         #[case] path_params: Vec<String>,
@@ -901,7 +919,7 @@ mod tests {
         };
         let ty = Type::Path(type_path);
 
-        // This MUST hit line 209 because path.segments.is_empty() is true
+        // Tests: path.segments.is_empty() is true
         assert!(!is_known_type(&ty, &known_schemas, &struct_definitions));
     }
 
@@ -941,7 +959,7 @@ mod tests {
         };
         let ty = Type::Path(type_path);
 
-        // This MUST hit line 245 because path.segments.is_empty() is true
+        // Tests: path.segments.is_empty() is true
         let result = parse_query_struct_to_parameters(&ty, &known_schemas, &struct_definitions);
         assert!(
             result.is_none(),

crates/vespera_macro/src/parser/request_body.rs

@@ -113,16 +113,15 @@ pub fn parse_request_body(
                 }
 
                 // Raw Multipart extractor (untyped) → multipart/form-data with generic object schema
-                if ident_str == "Multipart"
-                    && matches!(segment.arguments, syn::PathArguments::None)
+                if ident_str == "Multipart" && matches!(segment.arguments, syn::PathArguments::None)
                 {
                     let mut content = BTreeMap::new();
                     content.insert(
                         "multipart/form-data".to_string(),
                         MediaType {
-                            schema: Some(SchemaRef::Inline(Box::new(
-                                Schema::new(SchemaType::Object),
-                            ))),
+                            schema: Some(SchemaRef::Inline(Box::new(Schema::new(
+                                SchemaType::Object,
+                            )))),
                             example: None,
                             examples: None,
                         },
@@ -188,6 +187,11 @@ mod tests {
     #[case::str("fn test(just_str: &str) {}", true, "str")]
     #[case::i32("fn test(just_i32: i32) {}", false, "i32")]
     #[case::vec_string("fn test(just_vec_string: Vec<String>) {}", false, "vec_string")]
+    #[case::typed_multipart(
+        "fn test(TypedMultipart(req): TypedMultipart<UploadRequest>) {}",
+        true,
+        "typed_multipart"
+    )]
     #[case::multipart_raw("fn test(multipart: Multipart) {}", true, "multipart_raw")]
     #[case::self_ref("fn test(&self) {}", false, "self_ref")]
     fn test_parse_request_body_cases(

crates/vespera_macro/src/parser/response.rs

@@ -464,7 +464,7 @@ mod tests {
     #[test]
     fn test_extract_result_types_ref_to_non_path() {
         // Test line 43: &(Tuple) - Reference to non-Path type
-        // This hits the else branch at line 42-43
+        // Tests: else branch
         let ty: syn::Type = syn::parse_str("&(i32, String)").unwrap();
         let result = extract_result_types(&ty);
         // The Reference's elem is a Tuple, not a Path, so line 39 condition fails
@@ -487,7 +487,7 @@ mod tests {
         };
         let ty = syn::Type::Path(type_path);
 
-        // This MUST hit line 48 because path.segments.is_empty() is true
+        // Tests: path.segments.is_empty() is true
         let result = extract_result_types(&ty);
         assert!(
             result.is_none(),
@@ -518,7 +518,7 @@ mod tests {
             elem: Box::new(inner_ty),
         });
 
-        // This goes through line 38-41 (reference to path), then hits line 48
+        // Tests: reference to path then empty segments
         let result = extract_result_types(&ty);
         assert!(
             result.is_none(),
@@ -535,7 +535,7 @@ mod tests {
         // Note: This doesn't actually work because is_keyword_type_by_type_path
         // checks for Result type, but ref to Result is different
         // The important thing is the code doesn't panic
-        // This exercises lines 38-41 even if result is None
+        // Tests: exercises reference path even if result is None
     }
 
     #[test]
@@ -606,7 +606,7 @@ mod tests {
         // Should have 200 and 400 responses
         assert!(responses.contains_key("200"));
         let ok_response = responses.get("200").unwrap();
-        // Headers should be None (line 95)
+        // Headers should be None
         assert!(ok_response.headers.is_none());
     }
 }

crates/vespera_macro/src/parser/schema/enum_schema.rs

@@ -1582,7 +1582,7 @@ mod tests {
             });
         }
 
-        // Edge case: Empty struct variant (lines 275, 280 - empty properties/required)
+        // Edge case: Empty struct variant (empty properties/required)
         #[test]
         fn test_externally_tagged_empty_struct_variant() {
             let enum_item: syn::ItemEnum = syn::parse_str(
@@ -1621,7 +1621,7 @@ mod tests {
             });
         }
 
-        // Edge case: Internally tagged enum with tuple variant (line 468 - continue/skip)
+        // Edge case: Internally tagged enum with tuple variant
         #[test]
         fn test_internally_tagged_skips_tuple_variant() {
             let enum_item: syn::ItemEnum = syn::parse_str(
@@ -1654,7 +1654,7 @@ mod tests {
             });
         }
 
-        // Edge case: Untagged enum with tuple variant referencing a known schema (line 338)
+        // Edge case: Untagged enum with tuple variant referencing a known schema
         #[test]
         fn test_untagged_tuple_variant_with_known_schema_ref() {
             let enum_item: syn::ItemEnum = syn::parse_str(
@@ -1704,7 +1704,7 @@ mod tests {
             }
         }
 
-        // Edge case: Untagged enum with multi-field tuple variant (lines 592, 600-611)
+        // Edge case: Untagged enum with multi-field tuple variant
         #[test]
         fn test_untagged_multi_field_tuple_variant() {
             let enum_item: syn::ItemEnum = syn::parse_str(

crates/vespera_macro/src/parser/schema/serde_attrs.rs

@@ -1492,7 +1492,7 @@ mod tests {
             assert!(skip_if_result);
         }
 
-        /// Test extract_rename_all fallback parsing (lines 44-47)
+        /// Test extract_rename_all fallback parsing
         #[test]
         fn test_extract_rename_all_fallback_manual_parsing() {
             let tokens = quote!(rename_all = "kebab-case");
@@ -1638,7 +1638,7 @@ mod tests {
         }
 
         /// Test extract_field_rename - ensure rename_all is not matched as rename
-        /// This tests the word boundary logic at lines 168-181
+        /// Test the word boundary logic
         #[test]
         fn test_extract_field_rename_fallback_avoids_rename_all() {
             let tokens: TokenStream = "some::rename_all = \"camelCase\"".parse().unwrap();
@@ -1718,8 +1718,7 @@ mod tests {
         /// Test extract_field_rename with form_data but no field_name key
         #[test]
         fn test_extract_field_rename_form_data_no_field_name() {
-            let struct_src =
-                r#"struct Foo { #[form_data(limit = "10MiB")] field: i32 }"#;
+            let struct_src = r#"struct Foo { #[form_data(limit = "10MiB")] field: i32 }"#;
             let item: syn::ItemStruct = syn::parse_str(struct_src).unwrap();
             if let syn::Fields::Named(fields) = &item.fields {
                 let field = fields.named.first().unwrap();
@@ -1731,32 +1730,26 @@ mod tests {
         /// Test extract_rename_all falls back to #[try_from_multipart(rename_all = "...")]
         #[test]
         fn test_extract_rename_all_try_from_multipart_fallback() {
-            let item: syn::ItemStruct = syn::parse_str(
-                r#"#[try_from_multipart(rename_all = "camelCase")] struct Foo;"#,
-            )
-            .unwrap();
+            let item: syn::ItemStruct =
+                syn::parse_str(r#"#[try_from_multipart(rename_all = "camelCase")] struct Foo;"#)
+                    .unwrap();
             let result = extract_rename_all(&item.attrs);
             assert_eq!(result.as_deref(), Some("camelCase"));
         }
 
         /// Test serde rename_all takes priority over try_from_multipart rename_all
         #[test]
         fn test_extract_rename_all_serde_over_try_from_multipart() {
-            let item: syn::ItemStruct = syn::parse_str(
-                r#"#[serde(rename_all = "snake_case")] #[try_from_multipart(rename_all = "camelCase")] struct Foo;"#,
-            )
-            .unwrap();
+            let item: syn::ItemStruct = syn::parse_str(r#"#[serde(rename_all = "snake_case")] #[try_from_multipart(rename_all = "camelCase")] struct Foo;"#).unwrap();
             let result = extract_rename_all(&item.attrs);
             assert_eq!(result.as_deref(), Some("snake_case"));
         }
 
         /// Test extract_rename_all with try_from_multipart but no rename_all key
         #[test]
         fn test_extract_rename_all_try_from_multipart_no_rename_all() {
-            let item: syn::ItemStruct = syn::parse_str(
-                r#"#[try_from_multipart(strict)] struct Foo;"#,
-            )
-            .unwrap();
+            let item: syn::ItemStruct =
+                syn::parse_str(r#"#[try_from_multipart(strict)] struct Foo;"#).unwrap();
             let result = extract_rename_all(&item.attrs);
             assert_eq!(result, None);
         }
@@ -2047,7 +2040,7 @@ mod tests {
             }
         }
 
-        /// Test extract_tag with non-list serde attribute (line 524)
+        /// Test extract_tag with non-list serde attribute
         /// When require_list() fails, extract_tag should continue to next attribute
         #[test]
         fn test_extract_tag_non_list_attr_continues() {
@@ -2064,15 +2057,15 @@ mod tests {
             assert_eq!(result.as_deref(), Some("type"));
         }
 
-        /// Test extract_tag with only non-list serde attribute returns None (line 524)
+        /// Test extract_tag with only non-list serde attribute returns None
         #[test]
         fn test_extract_tag_only_non_list_attr_returns_none() {
             let path_attr = create_path_only_serde_attr();
             let result = extract_tag(&[path_attr]);
             assert_eq!(result, None);
         }
 
-        /// Test extract_content with non-list serde attribute (line 574)
+        /// Test extract_content with non-list serde attribute
         /// When require_list() fails, extract_content should continue to next attribute
         #[test]
         fn test_extract_content_non_list_attr_continues() {
@@ -2089,7 +2082,7 @@ mod tests {
             assert_eq!(result.as_deref(), Some("data"));
         }
 
-        /// Test extract_content with only non-list serde attribute returns None (line 574)
+        /// Test extract_content with only non-list serde attribute returns None
         #[test]
         fn test_extract_content_only_non_list_attr_returns_none() {
             let path_attr = create_path_only_serde_attr();

crates/vespera_macro/src/parser/schema/type_schema.rs

@@ -232,15 +232,15 @@ pub(crate) fn parse_type_to_schema_ref_with_schemas(
                     format: Some("duration".to_string()),
                     ..Schema::string()
                 })),
-                    // File upload types (axum_typed_multipart / tempfile)
-                    // FieldData<NamedTempFile> → string with binary format
-                    "FieldData" | "NamedTempFile" => SchemaRef::Inline(Box::new(Schema {
-                        format: Some("binary".to_string()),
-                        ..Schema::string()
-                    })),
-                    // Standard library types that should not be referenced
-                    // Note: HashMap and BTreeMap are handled above in generic types
-                    "Vec" | "Option" | "Result" | "Json" | "Path" | "Query" | "Header" => {
+                // File upload types (axum_typed_multipart / tempfile)
+                // FieldData<NamedTempFile> → string with binary format
+                "FieldData" | "NamedTempFile" => SchemaRef::Inline(Box::new(Schema {
+                    format: Some("binary".to_string()),
+                    ..Schema::string()
+                })),
+                // Standard library types that should not be referenced
+                // Note: HashMap and BTreeMap are handled above in generic types
+                "Vec" | "Option" | "Result" | "Json" | "Path" | "Query" | "Header" => {
                     // These are not schema types, return object schema
                     SchemaRef::Inline(Box::new(Schema::new(SchemaType::Object)))
                 }
@@ -755,7 +755,7 @@ mod tests {
         }
     }
 
-    // Tests for date/time types from chrono crate (lines 205-215)
+    // Tests for date/time types from chrono crate
     #[rstest]
     #[case("DateTime", "date-time")]
     #[case("NaiveDateTime", "date-time")]
@@ -790,7 +790,7 @@ mod tests {
         }
     }
 
-    // Tests for date/time types from time crate (lines 218-228)
+    // Tests for date/time types from time crate
     #[rstest]
     #[case("OffsetDateTime", "date-time")]
     #[case("PrimitiveDateTime", "date-time")]
@@ -822,7 +822,7 @@ mod tests {
         }
     }
 
-    // Test for Duration type (line 231-233)
+    // Test for Duration type
     #[test]
     fn test_parse_type_to_schema_ref_duration() {
         let ty: Type = syn::parse_str("Duration").unwrap();

crates/vespera_macro/src/parser/snapshots/vespera_macro__parser__parameters__tests__parse_function_parameter_cases@params_form_body.snap

@@ -0,0 +1,5 @@
+---
+source: crates/vespera_macro/src/parser/parameters.rs
+expression: parameters
+---
+[]

crates/vespera_macro/src/parser/snapshots/vespera_macro__parser__parameters__tests__parse_function_parameter_cases@params_raw_multipart_body.snap

@@ -0,0 +1,5 @@
+---
+source: crates/vespera_macro/src/parser/parameters.rs
+expression: parameters
+---
+[]