Fix Add testcase

Author: owjs3901

crates/vespera_core/src/schema.rs

@@ -437,6 +437,14 @@ mod tests {
         assert!(required.is_empty());
     }
 
+    #[test]
+    fn serialize_number_constraint_none_serializes_null() {
+        // Direct call bypasses skip_serializing_if to cover the None branch
+        let result =
+            super::serialize_number_constraint(&None, serde_json::value::Serializer).unwrap();
+        assert_eq!(result, serde_json::Value::Null);
+    }
+
     #[test]
     fn serialize_minimum_whole_number_as_integer() {
         let schema = Schema {

crates/vespera_macro/src/schema_macro/circular.rs

@@ -62,9 +62,8 @@ pub fn analyze_circular_refs(source_module_path: &[String], definition: &str) ->
     let mut circular_field_required = HashMap::new();
 
     for field in &fields_named.named {
-        let Some(field_ident) = field.ident.as_ref() else {
-            continue;
-        };
+        // FieldsNamed guarantees all fields have identifiers
+        let field_ident = field.ident.as_ref().expect("named field has ident");
         let field_name = field_ident.to_string();
         let ty_str = quote!(#field.ty).to_string().replace(' ', "");
 

crates/vespera_macro/src/schema_macro/tests.rs

@@ -471,7 +471,175 @@ fn test_generate_schema_type_code_with_partial_fields() {
     assert!(result.is_ok());
     let (tokens, _metadata) = result.unwrap();
     let output = tokens.to_string();
-    assert!(output.contains("UpdateUser"));
+    assert!(
+        output.contains("UpdateUser"),
+        "should contain generated struct name: {output}"
+    );
+}
+
+// --- Coverage: sql_function_default_body branches ---
+
+#[test]
+fn test_sql_function_default_non_path_type_skips() {
+    // Reference type (&str) is Type::Reference, not Type::Path → sql_function_default_body returns None
+    let attrs: Vec<syn::Attribute> = vec![syn::parse_quote!(#[sea_orm(default_value = "GEN()")])];
+    let struct_name = syn::Ident::new("Test", proc_macro2::Span::call_site());
+    let ty: syn::Type = syn::parse_str("&str").unwrap();
+    let mut fns = Vec::new();
+    let (serde, schema) =
+        generate_sea_orm_default_attrs(&attrs, &struct_name, "val", &ty, &ty, false, &mut fns);
+    assert!(serde.is_empty());
+    assert!(schema.is_empty());
+    assert!(fns.is_empty());
+}
+
+#[test]
+fn test_sql_function_default_datetime_with_timezone() {
+    let attrs: Vec<syn::Attribute> = vec![syn::parse_quote!(#[sea_orm(default_value = "NOW()")])];
+    let struct_name = syn::Ident::new("Test", proc_macro2::Span::call_site());
+    let ty: syn::Type = syn::parse_str("DateTimeWithTimeZone").unwrap();
+    let mut fns = Vec::new();
+    let (serde, schema) =
+        generate_sea_orm_default_attrs(&attrs, &struct_name, "ts", &ty, &ty, false, &mut fns);
+    let serde_str = serde.to_string();
+    assert!(
+        serde_str.contains("serde"),
+        "should have serde attr: {serde_str}"
+    );
+    assert!(schema.is_empty());
+    assert_eq!(fns.len(), 1);
+    let fn_str = fns[0].to_string();
+    assert!(
+        fn_str.contains("UNIX_EPOCH"),
+        "should use epoch default: {fn_str}"
+    );
+}
+
+#[test]
+fn test_sql_function_default_datetime_utc() {
+    let attrs: Vec<syn::Attribute> = vec![syn::parse_quote!(#[sea_orm(default_value = "NOW()")])];
+    let struct_name = syn::Ident::new("Test", proc_macro2::Span::call_site());
+    let ty: syn::Type = syn::parse_str("DateTimeUtc").unwrap();
+    let mut fns = Vec::new();
+    let (serde, schema) =
+        generate_sea_orm_default_attrs(&attrs, &struct_name, "ts", &ty, &ty, false, &mut fns);
+    let serde_str = serde.to_string();
+    assert!(
+        serde_str.contains("serde"),
+        "should have serde attr: {serde_str}"
+    );
+    assert!(schema.is_empty());
+    assert_eq!(fns.len(), 1);
+    let fn_str = fns[0].to_string();
+    assert!(
+        fn_str.contains("UNIX_EPOCH"),
+        "should use epoch default: {fn_str}"
+    );
+}
+
+#[test]
+fn test_sql_function_default_datetime_local() {
+    let attrs: Vec<syn::Attribute> = vec![syn::parse_quote!(#[sea_orm(default_value = "NOW()")])];
+    let struct_name = syn::Ident::new("Test", proc_macro2::Span::call_site());
+    let ty: syn::Type = syn::parse_str("DateTimeLocal").unwrap();
+    let mut fns = Vec::new();
+    let (serde, schema) =
+        generate_sea_orm_default_attrs(&attrs, &struct_name, "ts", &ty, &ty, false, &mut fns);
+    let serde_str = serde.to_string();
+    assert!(
+        serde_str.contains("serde"),
+        "should have serde attr: {serde_str}"
+    );
+    assert!(schema.is_empty());
+    assert_eq!(fns.len(), 1);
+    let fn_str = fns[0].to_string();
+    assert!(
+        fn_str.contains("UNIX_EPOCH"),
+        "should use epoch default: {fn_str}"
+    );
+}
+
+#[test]
+fn test_sql_function_default_naive_datetime() {
+    let attrs: Vec<syn::Attribute> = vec![syn::parse_quote!(#[sea_orm(default_value = "NOW()")])];
+    let struct_name = syn::Ident::new("Test", proc_macro2::Span::call_site());
+    let ty: syn::Type = syn::parse_str("NaiveDateTime").unwrap();
+    let mut fns = Vec::new();
+    let (serde, schema) =
+        generate_sea_orm_default_attrs(&attrs, &struct_name, "ts", &ty, &ty, false, &mut fns);
+    let serde_str = serde.to_string();
+    assert!(
+        serde_str.contains("serde"),
+        "should have serde attr: {serde_str}"
+    );
+    assert!(schema.is_empty());
+    assert_eq!(fns.len(), 1);
+    let fn_str = fns[0].to_string();
+    assert!(
+        fn_str.contains("UNIX_EPOCH"),
+        "should use epoch default: {fn_str}"
+    );
+}
+
+#[test]
+fn test_sql_function_default_naive_date() {
+    let attrs: Vec<syn::Attribute> =
+        vec![syn::parse_quote!(#[sea_orm(default_value = "CURDATE()")])];
+    let struct_name = syn::Ident::new("Test", proc_macro2::Span::call_site());
+    let ty: syn::Type = syn::parse_str("NaiveDate").unwrap();
+    let mut fns = Vec::new();
+    let (serde, schema) =
+        generate_sea_orm_default_attrs(&attrs, &struct_name, "d", &ty, &ty, false, &mut fns);
+    let serde_str = serde.to_string();
+    assert!(
+        serde_str.contains("serde"),
+        "should have serde attr: {serde_str}"
+    );
+    assert!(schema.is_empty());
+    assert_eq!(fns.len(), 1);
+    let fn_str = fns[0].to_string();
+    assert!(
+        fn_str.contains("from_ymd_opt"),
+        "should use ymd default: {fn_str}"
+    );
+}
+
+#[test]
+fn test_sql_function_default_naive_time() {
+    let attrs: Vec<syn::Attribute> =
+        vec![syn::parse_quote!(#[sea_orm(default_value = "CURTIME()")])];
+    let struct_name = syn::Ident::new("Test", proc_macro2::Span::call_site());
+    let ty: syn::Type = syn::parse_str("NaiveTime").unwrap();
+    let mut fns = Vec::new();
+    let (serde, schema) =
+        generate_sea_orm_default_attrs(&attrs, &struct_name, "t", &ty, &ty, false, &mut fns);
+    let serde_str = serde.to_string();
+    assert!(
+        serde_str.contains("serde"),
+        "should have serde attr: {serde_str}"
+    );
+    assert!(schema.is_empty());
+    assert_eq!(fns.len(), 1);
+    let fn_str = fns[0].to_string();
+    assert!(
+        fn_str.contains("from_hms_opt"),
+        "should use hms default: {fn_str}"
+    );
+}
+
+// --- Coverage: is_parseable_type empty segments ---
+
+#[test]
+fn test_is_parseable_type_empty_segments() {
+    // Synthetically construct a Type::Path with empty segments (impossible through parsing)
+    let ty = syn::Type::Path(syn::TypePath {
+        qself: None,
+        path: syn::Path {
+            leading_colon: None,
+            segments: syn::punctuated::Punctuated::new(),
+        },
+    });
+    assert!(!is_parseable_type(&ty));
 }
 
 #[test]