Add testcase

Author: owjs3901

Cargo.lock

@@ -23,3 +23,4 @@ anyhow = "1.0"
 rstest = "0.26"
 insta = "1.46"
 tempfile = "3"
+serial_test = "3"

crates/vespera_macro/Cargo.toml

@@ -259,6 +259,7 @@ pub fn generate_inline_type_definition(inline_type: &InlineRelationType) -> Toke
 #[cfg(test)]
 mod tests {
     use super::*;
+    use serial_test::serial;
 
     #[test]
     fn test_generate_inline_type_definition() {
@@ -796,6 +797,7 @@ mod tests {
     // These require setting up a temp directory with model files
 
     #[test]
+    #[serial]
     fn test_generate_inline_relation_type_with_file_lookup() {
         use tempfile::TempDir;
 
@@ -865,6 +867,7 @@ pub struct Model {
     }
 
     #[test]
+    #[serial]
     fn test_generate_inline_relation_type_no_relations_with_file_lookup() {
         use tempfile::TempDir;
 
@@ -930,6 +933,7 @@ pub struct Model {
     }
 
     #[test]
+    #[serial]
     fn test_generate_inline_relation_type_file_not_found() {
         use tempfile::TempDir;
 
@@ -971,6 +975,7 @@ pub struct Model {
     }
 
     #[test]
+    #[serial]
     fn test_generate_inline_relation_type_no_relations_file_not_found() {
         use tempfile::TempDir;
 

crates/vespera_macro/src/schema_macro/inline_types.rs

@@ -99,10 +99,10 @@ pub fn generate_schema_type_code(
             find_struct_from_path(&input.source_type, schema_name_hint)
         {
             struct_def_owned = found;
-            // Use the module path from the file lookup if the extracted one is empty
-            if source_module_path.is_empty() {
-                source_module_path = module_path;
-            }
+            // Always use the module path from file lookup for qualified paths
+            // The file lookup derives module path from actual file location, which is more accurate
+            // for resolving relative paths like `super::user::Entity`
+            source_module_path = module_path;
             &struct_def_owned
         } else if let Some(found) = schema_storage.iter().find(|s| s.name == source_type_name) {
             found
@@ -637,6 +637,7 @@ pub fn generate_schema_type_code(
 #[cfg(test)]
 mod tests {
     use super::*;
+    use serial_test::serial;
 
     fn create_test_struct_metadata(name: &str, definition: &str) -> StructMetadata {
         StructMetadata::new(name.to_string(), definition.to_string())
@@ -1450,6 +1451,7 @@ mod tests {
     }
 
     #[test]
+    #[serial]
     fn test_generate_schema_type_code_qualified_path_file_lookup_success() {
         // Coverage for lines 76, 78-79, 81
         // Tests: qualified path found via file lookup, module_path used when source is empty
@@ -1502,6 +1504,7 @@ pub struct Model {
     }
 
     #[test]
+    #[serial]
     fn test_generate_schema_type_code_simple_name_file_lookup_fallback() {
         // Coverage for lines 100, 103-104
         // Tests: simple name (not in storage) found via file lookup with schema_name hint
@@ -1560,6 +1563,7 @@ pub struct Model {
     // ============================================================
 
     #[test]
+    #[serial]
     fn test_generate_schema_type_code_has_many_explicit_pick_inline_type() {
         // Coverage for lines 258-260, 262-263, 265, 267-268
         // Tests: HasMany is explicitly picked, inline type is generated
@@ -1625,6 +1629,7 @@ pub struct Model {
     }
 
     #[test]
+    #[serial]
     fn test_generate_schema_type_code_has_many_explicit_pick_file_not_found() {
         // Coverage for line 270
         // Tests: HasMany is explicitly picked but target file not found - should skip field
@@ -1684,6 +1689,7 @@ pub struct Model {
     // ============================================================
 
     #[test]
+    #[serial]
     fn test_generate_schema_type_code_belongs_to_circular_inline_optional() {
         // Coverage for lines 277-278, 281-282, 285, 288-289, 294
         // Tests: BelongsTo with circular reference, optional field (is_optional = true)
@@ -1750,6 +1756,7 @@ pub struct Model {
     }
 
     #[test]
+    #[serial]
     fn test_generate_schema_type_code_has_one_circular_inline_required() {
         // Coverage for lines 277-278, 281-282, 285, 291, 294
         // Tests: HasOne with circular reference, required field (is_optional = false)
@@ -1818,6 +1825,191 @@ pub struct Model {
     }
 
     #[test]
+    #[serial]
+    fn test_generate_schema_type_code_belongs_to_circular_inline_required_file() {
+        // Coverage for line 291 specifically
+        // Tests: BelongsTo with circular reference AND required FK (is_optional = false)
+        // This requires file-based lookup with:
+        // 1. #[sea_orm(from = "required_fk")] where required_fk is NOT Option<T>
+        // 2. Circular reference between two models
+        use tempfile::TempDir;
+
+        let temp_dir = TempDir::new().unwrap();
+        let src_dir = temp_dir.path().join("src");
+        let models_dir = src_dir.join("models");
+        std::fs::create_dir_all(&models_dir).unwrap();
+
+        // Create user.rs with Model that references memo (circular)
+        let user_model = r#"
+#[sea_orm(table_name = "users")]
+pub struct Model {
+    pub id: i32,
+    pub name: String,
+    pub memo_id: i32,
+    #[sea_orm(belongs_to, from = "memo_id", to = "id")]
+    pub memo: BelongsTo<super::memo::Entity>,
+}
+"#;
+        std::fs::write(models_dir.join("user.rs"), user_model).unwrap();
+
+        // Create memo.rs with Model that references user (completing the circle)
+        // Note: using flag-style `belongs_to` with `from = "user_id"`
+        let memo_model = r#"
+#[sea_orm(table_name = "memos")]
+pub struct Model {
+    pub id: i32,
+    pub title: String,
+    pub user_id: i32,
+    #[sea_orm(belongs_to, from = "user_id", to = "id")]
+    pub user: BelongsTo<super::user::Entity>,
+}
+"#;
+        std::fs::write(models_dir.join("memo.rs"), memo_model).unwrap();
+
+        // Save original CARGO_MANIFEST_DIR
+        let original_manifest_dir = std::env::var("CARGO_MANIFEST_DIR").ok();
+        // SAFETY: This is a test that runs single-threaded
+        unsafe { std::env::set_var("CARGO_MANIFEST_DIR", temp_dir.path()) };
+
+        // Generate schema from memo - has BelongsTo user which has circular ref back
+        // The user_id field is required (not Option), so is_optional = false
+        // This should generate Box<...> instead of Option<Box<...>>
+        let tokens = quote!(MemoSchema from crate::models::memo::Model);
+        let input: SchemaTypeInput = syn::parse2(tokens).unwrap();
+        let storage: Vec<StructMetadata> = vec![];
+
+        let result = generate_schema_type_code(&input, &storage);
+
+        // Restore CARGO_MANIFEST_DIR
+        // SAFETY: This is a test that runs single-threaded
+        unsafe {
+            if let Some(dir) = original_manifest_dir {
+                std::env::set_var("CARGO_MANIFEST_DIR", dir);
+            } else {
+                std::env::remove_var("CARGO_MANIFEST_DIR");
+            }
+        }
+
+        assert!(result.is_ok(), "Should generate schema: {:?}", result.err());
+        let (tokens, _metadata) = result.unwrap();
+        let output = tokens.to_string();
+        // Should have inline type definition for circular relation
+        assert!(
+            output.contains("MemoSchema"),
+            "Should contain MemoSchema: {}",
+            output
+        );
+        assert!(
+            output.contains("user"),
+            "Should contain user field: {}",
+            output
+        );
+        // BelongsTo with required FK (user_id: i32) should generate Box<...> not Option<Box<...>>
+        // This hits line 291: quote! { Box<#inline_type_name> }
+        assert!(
+            output.contains("pub user : Box <"),
+            "BelongsTo with required FK should generate Box<>, not Option<Box<>>. Output: {}",
+            output
+        );
+    }
+
+    #[test]
+    fn test_seaorm_relation_required_fk_directly() {
+        // Test the convert_relation_type_to_schema_with_info function directly
+        // to verify is_optional = false when FK is required
+        use crate::schema_macro::seaorm::{
+            convert_relation_type_to_schema_with_info, extract_belongs_to_from_field,
+            is_field_optional_in_struct,
+        };
+
+        // Use the same attribute format that works in seaorm tests: belongs_to (flag), not belongs_to = "..."
+        let struct_def = r#"
+#[sea_orm(table_name = "memos")]
+pub struct Model {
+    pub id: i32,
+    pub user_id: i32,
+    #[sea_orm(belongs_to, from = "user_id", to = "id")]
+    pub user: BelongsTo<super::user::Entity>,
+}
+"#;
+        let parsed_struct: syn::ItemStruct = syn::parse_str(struct_def).unwrap();
+
+        // Get the user field
+        let fields_named = match &parsed_struct.fields {
+            syn::Fields::Named(f) => f,
+            _ => panic!("Expected named fields"),
+        };
+
+        let user_field = fields_named
+            .named
+            .iter()
+            .find(|f| f.ident.as_ref().map(|i| i == "user").unwrap_or(false))
+            .expect("user field not found");
+
+        // Debug: Check if extract_belongs_to_from_field works
+        let fk_field = extract_belongs_to_from_field(&user_field.attrs);
+        assert_eq!(
+            fk_field,
+            Some("user_id".to_string()),
+            "Should extract FK field from attribute"
+        );
+
+        // Debug: Check if is_field_optional_in_struct works
+        let is_fk_optional = is_field_optional_in_struct(&parsed_struct, "user_id");
+        assert!(!is_fk_optional, "user_id: i32 should not be optional");
+
+        let result = convert_relation_type_to_schema_with_info(
+            &user_field.ty,
+            &user_field.attrs,
+            &parsed_struct,
+            &[
+                "crate".to_string(),
+                "models".to_string(),
+                "memo".to_string(),
+            ],
+            user_field.ident.clone().unwrap(),
+        );
+
+        assert!(result.is_some(), "Should convert BelongsTo relation");
+        let (_, rel_info) = result.unwrap();
+        assert_eq!(rel_info.relation_type, "BelongsTo");
+        // The FK field user_id is i32 (not Option), so is_optional should be false
+        assert!(
+            !rel_info.is_optional,
+            "BelongsTo with required FK (user_id: i32) should have is_optional = false"
+        );
+    }
+
+    #[test]
+    fn test_extract_belongs_to_from_field_with_equals_value() {
+        // Test that extract_belongs_to_from_field works with belongs_to = "..." format
+        use crate::schema_macro::seaorm::extract_belongs_to_from_field;
+
+        // Format 1: belongs_to (flag style) - known to work
+        let attrs1: Vec<syn::Attribute> = vec![syn::parse_quote!(
+            #[sea_orm(belongs_to, from = "user_id", to = "id")]
+        )];
+        let result1 = extract_belongs_to_from_field(&attrs1);
+        assert_eq!(
+            result1,
+            Some("user_id".to_string()),
+            "Flag style should work"
+        );
+
+        // Format 2: belongs_to = "..." (value style) - testing this
+        let attrs2: Vec<syn::Attribute> = vec![syn::parse_quote!(
+            #[sea_orm(belongs_to = "super::user::Entity", from = "user_id", to = "id")]
+        )];
+        let result2 = extract_belongs_to_from_field(&attrs2);
+        assert_eq!(
+            result2,
+            Some("user_id".to_string()),
+            "Value style should also work"
+        );
+    }
+
+    #[test]
+    #[serial]
     fn test_generate_schema_type_code_qualified_path_with_nonempty_module_path() {
         // Coverage for line 78 (the else branch where source_module_path is NOT empty)
         // Tests: qualified path with explicit module segments that are not empty