Add testcase

Author: owjs3901

crates/vespera_macro/src/multipart_impl.rs

@@ -984,4 +984,203 @@ mod tests {
             "non-strict should not check for unknown fields"
         );
     }
+
+    // ─── process_fields direct tests ────────────────────────────────────
+    //
+    // Exercise process_fields directly to ensure quote! token construction
+    // for each branch (parse_value, strict assignment, field matching) is
+    // fully traced by the coverage tool.
+
+    fn parse_fields_from(code: &str) -> syn::DeriveInput {
+        syn::parse_str(code).unwrap()
+    }
+
+    fn get_named_fields(
+        input: &syn::DeriveInput,
+    ) -> &syn::punctuated::Punctuated<syn::Field, syn::token::Comma> {
+        match &input.data {
+            syn::Data::Struct(s) => match &s.fields {
+                Fields::Named(n) => &n.named,
+                _ => panic!("expected named fields"),
+            },
+            _ => panic!("expected struct"),
+        }
+    }
+
+    #[test]
+    fn test_process_fields_required_field_generates_parse_value() {
+        let input = parse_fields_from("struct T { pub name: String }");
+        let fields = get_named_fields(&input);
+        let cg = process_fields(fields.iter(), None, false, false);
+
+        // parse_value is interpolated into each assignment
+        let assignment_code = cg
+            .assignments
+            .iter()
+            .map(ToString::to_string)
+            .collect::<Vec<_>>()
+            .join(" ");
+        assert!(
+            assignment_code.contains("TryFromFieldWithState"),
+            "parse_value should contain turbofish call"
+        );
+        assert!(
+            assignment_code.contains("try_from_field_with_state"),
+            "should call try_from_field_with_state"
+        );
+        assert!(
+            assignment_code.contains("\"name\""),
+            "should match on field name"
+        );
+
+        // post_loop should have MissingField check for required fields
+        let post_code = cg
+            .post_loop
+            .iter()
+            .map(ToString::to_string)
+            .collect::<Vec<_>>()
+            .join(" ");
+        assert!(
+            post_code.contains("MissingField"),
+            "required field should have MissingField check"
+        );
+    }
+
+    #[test]
+    fn test_process_fields_strict_required_field_generates_duplicate_check() {
+        let input = parse_fields_from("struct T { pub name: String, pub age: i32 }");
+        let fields = get_named_fields(&input);
+        let cg = process_fields(fields.iter(), None, true, false);
+
+        // strict mode: assignments should contain is_none + DuplicateField check
+        let assignment_code = cg
+            .assignments
+            .iter()
+            .map(ToString::to_string)
+            .collect::<Vec<_>>()
+            .join(" ");
+        assert!(
+            assignment_code.contains("is_none"),
+            "strict assignment should check is_none"
+        );
+        assert!(
+            assignment_code.contains("DuplicateField"),
+            "strict assignment should have DuplicateField"
+        );
+        assert!(
+            assignment_code.contains("\"name\""),
+            "should match name field"
+        );
+        assert!(
+            assignment_code.contains("\"age\""),
+            "should match age field"
+        );
+
+        // Both fields should have parse_value with turbofish
+        assert!(
+            assignment_code.contains("TryFromFieldWithState"),
+            "should contain turbofish"
+        );
+    }
+
+    #[test]
+    fn test_process_fields_vec_field_generates_push() {
+        let input = parse_fields_from("struct T { pub tags: Vec<String> }");
+        let fields = get_named_fields(&input);
+        let cg = process_fields(fields.iter(), None, false, false);
+
+        let decl_code = cg
+            .declarations
+            .iter()
+            .map(ToString::to_string)
+            .collect::<Vec<_>>()
+            .join(" ");
+        assert!(
+            decl_code.contains("Vec :: new"),
+            "Vec field should initialize with Vec::new()"
+        );
+
+        let assignment_code = cg
+            .assignments
+            .iter()
+            .map(ToString::to_string)
+            .collect::<Vec<_>>()
+            .join(" ");
+        assert!(
+            assignment_code.contains("push"),
+            "Vec field assignment should use push"
+        );
+
+        // Vec fields should NOT have post_loop (no MissingField check)
+        assert!(
+            cg.post_loop.is_empty(),
+            "Vec fields should not have post-loop checks"
+        );
+    }
+
+    #[test]
+    fn test_process_fields_option_field_no_missing_check() {
+        let input = parse_fields_from("struct T { pub bio: Option<String> }");
+        let fields = get_named_fields(&input);
+        let cg = process_fields(fields.iter(), None, false, false);
+
+        let decl_code = cg
+            .declarations
+            .iter()
+            .map(ToString::to_string)
+            .collect::<Vec<_>>()
+            .join(" ");
+        assert!(
+            decl_code.contains("Option :: None"),
+            "Option field should initialize to None"
+        );
+
+        // Option fields should NOT have post_loop
+        assert!(
+            cg.post_loop.is_empty(),
+            "Option fields should not have post-loop checks"
+        );
+    }
+
+    #[test]
+    fn test_process_fields_strict_vec_field_uses_push_not_duplicate() {
+        let input = parse_fields_from("struct T { pub tags: Vec<String> }");
+        let fields = get_named_fields(&input);
+        let cg = process_fields(fields.iter(), None, true, false);
+
+        // Even in strict mode, Vec fields use push (not duplicate check)
+        let assignment_code = cg
+            .assignments
+            .iter()
+            .map(ToString::to_string)
+            .collect::<Vec<_>>()
+            .join(" ");
+        assert!(
+            assignment_code.contains("push"),
+            "Vec in strict mode should still use push"
+        );
+        assert!(
+            !assignment_code.contains("DuplicateField"),
+            "Vec should not have duplicate check"
+        );
+    }
+
+    #[test]
+    fn test_process_fields_mixed_types() {
+        let input = parse_fields_from(
+            "struct T { pub name: String, pub tags: Vec<String>, pub bio: Option<String> }",
+        );
+        let fields = get_named_fields(&input);
+        let cg = process_fields(fields.iter(), None, false, false);
+
+        assert_eq!(cg.idents.len(), 3, "should have 3 fields");
+        assert_eq!(cg.declarations.len(), 3, "should have 3 declarations");
+        assert_eq!(cg.assignments.len(), 3, "should have 3 assignments");
+        // Only 'name' is required (not Option, not Vec), so 1 post_loop
+        assert_eq!(
+            cg.post_loop.len(),
+            1,
+            "only required field should have post-loop"
+        );
+    }
 }

examples/axum-example/tests/integration_test.rs

@@ -1743,3 +1743,61 @@ async fn test_struct_level_serde_default_all_provided() {
     assert_eq!(result["count"], 99);
     assert_eq!(result["active"], true);
 }
+
+// ============== Multipart error path coverage tests ==========================
+//
+// These tests trigger real axum MultipartRejection / MultipartError paths
+// to cover From impls and Display arms for InvalidRequest/InvalidRequestBody.
+
+#[tokio::test]
+async fn test_multipart_rejection_non_multipart_content_type() {
+    // Sending JSON to a multipart handler triggers MultipartRejection → InvalidRequest
+    let server = TestServer::new(create_coverage_test_app());
+
+    let response = server
+        .post("/strict-test")
+        .content_type("application/json")
+        .bytes(b"{\"name\":\"x\",\"age\":1}".to_vec().into())
+        .await;
+
+    response.assert_status(axum::http::StatusCode::BAD_REQUEST);
+    let body = response.text();
+    assert!(
+        body.contains("Invalid multipart request"),
+        "Should use InvalidRequest Display: {body}"
+    );
+}
+
+#[tokio::test]
+async fn test_multipart_rejection_missing_content_type() {
+    // Sending raw bytes with no content type triggers MultipartRejection
+    let server = TestServer::new(create_coverage_test_app());
+
+    let response = server
+        .post("/vec-test")
+        .bytes(b"not multipart".to_vec().into())
+        .await;
+
+    // axum rejects with 4xx because there's no multipart content-type
+    assert!(
+        response.status_code().is_client_error(),
+        "Should be a client error, got {}",
+        response.status_code()
+    );
+}
+
+#[tokio::test]
+async fn test_numeric_field_non_utf8_bytes() {
+    // Send non-UTF-8 bytes for a numeric (i32) field → WrongFieldType from from_utf8 error
+    let server = TestServer::new(create_coverage_test_app());
+
+    let invalid_utf8 = Part::bytes(vec![0xFF, 0xFE, 0xFD]).file_name("bad.bin");
+    let form = MultipartForm::new()
+        .add_text("name", "Alice")
+        .add_part("count", invalid_utf8)
+        .add_text("score", "1.0")
+        .add_text("initial", "A");
+
+    let response = server.post("/numeric-char-test").multipart(form).await;
+    response.assert_status(axum::http::StatusCode::UNSUPPORTED_MEDIA_TYPE);
+}