Add testcase

Author: owjs3901

crates/vespera_core/src/schema.rs

@@ -463,4 +463,79 @@ mod tests {
         let required = schema.required.expect("required should be initialized");
         assert!(required.is_empty());
     }
+
+    #[test]
+    fn serialize_minimum_whole_number_as_integer() {
+        let schema = Schema {
+            minimum: Some(0.0),
+            ..Schema::integer()
+        };
+        let json = serde_json::to_string(&schema).unwrap();
+        // Must be "minimum":0 (integer), NOT "minimum":0.0
+        assert!(
+            json.contains("\"minimum\":0"),
+            "expected integer 0, got: {json}"
+        );
+        assert!(
+            !json.contains("\"minimum\":0.0"),
+            "must not contain 0.0: {json}"
+        );
+    }
+
+    #[test]
+    fn serialize_minimum_fractional_as_float() {
+        let schema = Schema {
+            minimum: Some(1.5),
+            ..Schema::number()
+        };
+        let json = serde_json::to_string(&schema).unwrap();
+        assert!(
+            json.contains("\"minimum\":1.5"),
+            "expected 1.5, got: {json}"
+        );
+    }
+
+    #[test]
+    fn serialize_minimum_none_omitted() {
+        let schema = Schema::integer();
+        let json = serde_json::to_string(&schema).unwrap();
+        assert!(
+            !json.contains("minimum"),
+            "None minimum should be omitted: {json}"
+        );
+    }
+
+    #[test]
+    fn serialize_maximum_whole_number_as_integer() {
+        let schema = Schema {
+            maximum: Some(100.0),
+            ..Schema::integer()
+        };
+        let json = serde_json::to_string(&schema).unwrap();
+        assert!(
+            json.contains("\"maximum\":100"),
+            "expected integer 100, got: {json}"
+        );
+        assert!(
+            !json.contains("\"maximum\":100.0"),
+            "must not contain 100.0: {json}"
+        );
+    }
+
+    #[test]
+    fn serialize_multiple_of_whole_number_as_integer() {
+        let schema = Schema {
+            multiple_of: Some(2.0),
+            ..Schema::integer()
+        };
+        let json = serde_json::to_string(&schema).unwrap();
+        assert!(
+            json.contains("\"multipleOf\":2"),
+            "expected integer 2, got: {json}"
+        );
+        assert!(
+            !json.contains("\"multipleOf\":2.0"),
+            "must not contain 2.0: {json}"
+        );
+    }
 }

crates/vespera_macro/src/openapi_generator.rs

@@ -1594,4 +1594,73 @@ pub fn create_users() -> String {
 
         assert!(properties.is_empty(), "Should not insert new properties");
     }
+
+    #[test]
+    fn test_extract_schema_default_attr_with_value() {
+        let attrs: Vec<syn::Attribute> = vec![syn::parse_quote!(#[schema(default = "42")])];
+        let result = extract_schema_default_attr(&attrs);
+        assert_eq!(result, Some("42".to_string()));
+    }
+
+    #[test]
+    fn test_extract_schema_default_attr_no_default() {
+        let attrs: Vec<syn::Attribute> = vec![syn::parse_quote!(#[schema(rename = "foo")])];
+        let result = extract_schema_default_attr(&attrs);
+        assert_eq!(result, None);
+    }
+
+    #[test]
+    fn test_extract_schema_default_attr_non_schema() {
+        let attrs: Vec<syn::Attribute> = vec![syn::parse_quote!(#[serde(default)])];
+        let result = extract_schema_default_attr(&attrs);
+        assert_eq!(result, None);
+    }
+
+    #[test]
+    fn test_parse_default_string_to_json_value_integer() {
+        let result = parse_default_string_to_json_value("42");
+        assert_eq!(result, serde_json::Value::Number(42.into()));
+    }
+
+    #[test]
+    fn test_parse_default_string_to_json_value_float() {
+        let result = parse_default_string_to_json_value("3.14");
+        assert_eq!(result, serde_json::json!(3.14));
+    }
+
+    #[test]
+    fn test_parse_default_string_to_json_value_bool() {
+        let result = parse_default_string_to_json_value("true");
+        assert_eq!(result, serde_json::Value::Bool(true));
+    }
+
+    #[test]
+    fn test_parse_default_string_to_json_value_string_fallback() {
+        let result = parse_default_string_to_json_value("hello world");
+        assert_eq!(result, serde_json::Value::String("hello world".to_string()));
+    }
+
+    #[test]
+    fn test_process_default_functions_with_schema_default_attr() {
+        use vespera_core::schema::{Schema, SchemaRef};
+
+        let file_ast: syn::File = syn::parse_str("").unwrap();
+        let struct_item: syn::ItemStruct =
+            syn::parse_str(r#"pub struct Test { #[schema(default = "100")] pub count: i32 }"#)
+                .unwrap();
+        let mut schema = Schema::object();
+        let props = schema.properties.get_or_insert_with(BTreeMap::new);
+        props.insert(
+            "count".to_string(),
+            SchemaRef::Inline(Box::new(Schema::integer())),
+        );
+        process_default_functions(&struct_item, &file_ast, &mut schema);
+        if let Some(SchemaRef::Inline(prop_schema)) =
+            schema.properties.as_ref().unwrap().get("count")
+        {
+            assert_eq!(prop_schema.default, Some(serde_json::json!(100)));
+        } else {
+            panic!("Expected inline schema with default");
+        }
+    }
 }

crates/vespera_macro/src/schema_macro/codegen.rs

@@ -446,4 +446,30 @@ mod tests {
         assert!(output.contains("id"));
         assert!(output.contains("name"));
     }
+
+    #[test]
+    fn test_schema_to_tokens_with_minimum() {
+        let mut schema = Schema::new(SchemaType::Integer);
+        schema.minimum = Some(0.0);
+        let tokens = schema_to_tokens(&schema);
+        let output = tokens.to_string();
+        assert!(
+            output.contains("minimum"),
+            "should contain minimum: {output}"
+        );
+        assert!(output.contains("Some"), "should contain Some: {output}");
+    }
+
+    #[test]
+    fn test_schema_to_tokens_with_maximum() {
+        let mut schema = Schema::new(SchemaType::Integer);
+        schema.maximum = Some(255.0);
+        let tokens = schema_to_tokens(&schema);
+        let output = tokens.to_string();
+        assert!(
+            output.contains("maximum"),
+            "should contain maximum: {output}"
+        );
+        assert!(output.contains("Some"), "should contain Some: {output}");
+    }
 }

crates/vespera_macro/src/schema_macro/seaorm.rs

@@ -1173,6 +1173,30 @@ mod tests {
         assert_eq!(result, None);
     }
 
+    #[test]
+    fn test_extract_sea_orm_default_value_non_list_meta() {
+        // #[sea_orm] as a path attribute (non-Meta::List) — line 222 branch
+        let attrs: Vec<syn::Attribute> = vec![syn::parse_quote!(#[sea_orm])];
+        let result = extract_sea_orm_default_value(&attrs);
+        assert_eq!(result, None);
+    }
+
+    #[test]
+    fn test_extract_sea_orm_default_value_empty_value_after_equals() {
+        // default_value = , (empty value) — line 236 branch
+        let attrs: Vec<syn::Attribute> = vec![syn::parse_quote!(#[sea_orm(default_value = )])];
+        let result = extract_sea_orm_default_value(&attrs);
+        assert_eq!(result, None);
+    }
+
+    #[test]
+    fn test_extract_sea_orm_default_value_no_default_value_key() {
+        let attrs: Vec<syn::Attribute> =
+            vec![syn::parse_quote!(#[sea_orm(primary_key, auto_increment)])];
+        let result = extract_sea_orm_default_value(&attrs);
+        assert_eq!(result, None);
+    }
+
     // =========================================================================
     // Tests for is_sql_function_default
     // =========================================================================

crates/vespera_macro/src/schema_macro/tests.rs

@@ -244,7 +244,165 @@ fn test_generate_schema_type_code_no_from_impl_with_add() {
     assert!(result.is_ok());
     let (tokens, _metadata) = result.unwrap();
     let output = tokens.to_string();
-    assert!(!output.contains("impl From"));
+    assert!(
+        output.contains("UserWithExtra"),
+        "expected struct UserWithExtra in output: {output}"
+    );
+    assert!(
+        !output.contains("impl From"),
+        "expected no From impl when `add` is used: {output}"
+    );
+}
+
+// ========================
+// is_parseable_type tests
+// ========================
+
+#[test]
+fn test_is_parseable_type_primitives() {
+    for ty_str in &[
+        "i8", "i16", "i32", "i64", "i128", "isize", "u8", "u16", "u32", "u64", "u128", "usize",
+        "f32", "f64", "bool", "String", "Decimal",
+    ] {
+        let ty: syn::Type = syn::parse_str(ty_str).unwrap();
+        assert!(is_parseable_type(&ty), "{ty_str} should be parseable");
+    }
+}
+
+#[test]
+fn test_is_parseable_type_non_parseable() {
+    let ty: syn::Type = syn::parse_str("MyEnum").unwrap();
+    assert!(!is_parseable_type(&ty));
+}
+
+#[test]
+fn test_is_parseable_type_non_path() {
+    let ty: syn::Type = syn::parse_str("&str").unwrap();
+    assert!(!is_parseable_type(&ty));
+}
+
+// ======================================
+// generate_sea_orm_default_attrs tests
+// ======================================
+
+#[test]
+fn test_sea_orm_default_attrs_optional_field_skips() {
+    let attrs: Vec<syn::Attribute> = vec![syn::parse_quote!(#[sea_orm(default_value = "42")])];
+    let struct_name = syn::Ident::new("Test", proc_macro2::Span::call_site());
+    let ty: syn::Type = syn::parse_str("i32").unwrap();
+    let mut fns = Vec::new();
+    let (serde, schema) =
+        generate_sea_orm_default_attrs(&attrs, &struct_name, "count", &ty, &ty, true, &mut fns);
+    assert!(serde.is_empty());
+    assert!(schema.is_empty());
+    assert!(fns.is_empty());
+}
+
+#[test]
+fn test_sea_orm_default_attrs_no_default_value() {
+    let attrs: Vec<syn::Attribute> = vec![syn::parse_quote!(#[sea_orm(primary_key)])];
+    let struct_name = syn::Ident::new("Test", proc_macro2::Span::call_site());
+    let ty: syn::Type = syn::parse_str("i32").unwrap();
+    let mut fns = Vec::new();
+    let (serde, schema) =
+        generate_sea_orm_default_attrs(&attrs, &struct_name, "id", &ty, &ty, false, &mut fns);
+    assert!(serde.is_empty());
+    assert!(schema.is_empty());
+}
+
+#[test]
+fn test_sea_orm_default_attrs_sql_function_skips() {
+    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("String").unwrap();
+    let mut fns = Vec::new();
+    let (serde, schema) = generate_sea_orm_default_attrs(
+        &attrs,
+        &struct_name,
+        "created_at",
+        &ty,
+        &ty,
+        false,
+        &mut fns,
+    );
+    assert!(serde.is_empty());
+    assert!(schema.is_empty());
+}
+
+#[test]
+fn test_sea_orm_default_attrs_existing_serde_default() {
+    let attrs: Vec<syn::Attribute> = vec![
+        syn::parse_quote!(#[sea_orm(default_value = "42")]),
+        syn::parse_quote!(#[serde(default)]),
+    ];
+    let struct_name = syn::Ident::new("Test", proc_macro2::Span::call_site());
+    let ty: syn::Type = syn::parse_str("i32").unwrap();
+    let mut fns = Vec::new();
+    let (serde, schema) =
+        generate_sea_orm_default_attrs(&attrs, &struct_name, "count", &ty, &ty, false, &mut fns);
+    // serde attr should be empty (already has serde default)
+    assert!(serde.is_empty());
+    // schema attr should still be generated
+    let schema_str = schema.to_string();
+    assert!(
+        schema_str.contains("schema"),
+        "should have schema attr: {schema_str}"
+    );
+    assert!(
+        fns.is_empty(),
+        "no default fn needed when serde(default) exists"
+    );
+}
+
+#[test]
+fn test_sea_orm_default_attrs_non_parseable_type() {
+    let attrs: Vec<syn::Attribute> = vec![syn::parse_quote!(#[sea_orm(default_value = "Active")])];
+    let struct_name = syn::Ident::new("Test", proc_macro2::Span::call_site());
+    let ty: syn::Type = syn::parse_str("MyEnum").unwrap();
+    let mut fns = Vec::new();
+    let (serde, schema) =
+        generate_sea_orm_default_attrs(&attrs, &struct_name, "status", &ty, &ty, false, &mut fns);
+    // serde attr empty (non-parseable type)
+    assert!(serde.is_empty());
+    // schema attr still generated
+    let schema_str = schema.to_string();
+    assert!(
+        schema_str.contains("schema"),
+        "should have schema attr: {schema_str}"
+    );
+    assert!(fns.is_empty());
+}
+
+#[test]
+fn test_sea_orm_default_attrs_full_generation() {
+    let attrs: Vec<syn::Attribute> = vec![syn::parse_quote!(#[sea_orm(default_value = "42")])];
+    let struct_name = syn::Ident::new("Test", proc_macro2::Span::call_site());
+    let ty: syn::Type = syn::parse_str("i32").unwrap();
+    let mut fns = Vec::new();
+    let (serde, schema) =
+        generate_sea_orm_default_attrs(&attrs, &struct_name, "count", &ty, &ty, false, &mut fns);
+    // Both serde and schema attrs should be generated
+    let serde_str = serde.to_string();
+    assert!(
+        serde_str.contains("serde"),
+        "should have serde attr: {serde_str}"
+    );
+    assert!(
+        serde_str.contains("default_Test_count"),
+        "should reference generated fn: {serde_str}"
+    );
+    let schema_str = schema.to_string();
+    assert!(
+        schema_str.contains("schema"),
+        "should have schema attr: {schema_str}"
+    );
+    // Default function should be generated
+    assert_eq!(fns.len(), 1, "should generate one default function");
+    let fn_str = fns[0].to_string();
+    assert!(
+        fn_str.contains("default_Test_count"),
+        "fn name should match: {fn_str}"
+    );
 }
 
 #[test]