Fix lint

Author: owjs3901

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

@@ -552,4 +552,49 @@ mod tests {
         );
         assert!(schema.properties.is_some());
     }
+
+    #[test]
+    fn test_parse_struct_to_schema_transparent_tuple_wrapper_uses_ref_schema() {
+        let struct_item: syn::ItemStruct = syn::parse_str(
+            r"
+            #[serde(transparent)]
+            struct Wrapper(User);
+        ",
+        )
+        .unwrap();
+
+        let mut struct_defs = HashMap::new();
+        struct_defs.insert("User".to_string(), "struct User { id: i32 }".to_string());
+        let mut known = HashSet::new();
+        known.insert("User".to_string());
+
+        let schema = parse_struct_to_schema(&struct_item, &known, &struct_defs);
+        assert!(schema.all_of.is_some());
+        let all_of = schema.all_of.unwrap();
+        assert_eq!(all_of.len(), 1);
+        match &all_of[0] {
+            SchemaRef::Ref(reference) => {
+                assert_eq!(reference.ref_path, "#/components/schemas/User");
+            }
+            SchemaRef::Inline(_) => {
+                panic!("expected $ref wrapper for transparent tuple known schema")
+            }
+        }
+    }
+
+    #[test]
+    fn test_parse_struct_to_schema_transparent_multi_field_tuple_falls_back() {
+        let struct_item: syn::ItemStruct = syn::parse_str(
+            r"
+            #[serde(transparent)]
+            struct Wrapper(String, String);
+        ",
+        )
+        .unwrap();
+
+        let schema = parse_struct_to_schema(&struct_item, &HashSet::new(), &HashMap::new());
+        assert_eq!(schema.schema_type, Some(SchemaType::Object));
+        assert!(schema.properties.is_none());
+        assert!(schema.all_of.is_none());
+    }
 }

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

@@ -1470,4 +1470,36 @@ mod tests {
         let schema_ref = parse_type_to_schema_ref(&ty, &HashSet::new(), &HashMap::new());
         assert!(matches!(schema_ref, SchemaRef::Inline(_)));
     }
+
+    #[test]
+    fn test_known_schema_ref_override_returns_inline_ref_schema() {
+        let mut known = HashSet::new();
+        known.insert("UserSchema".to_string());
+
+        let mut defs = HashMap::new();
+        defs.insert(
+            "UserSchema".to_string(),
+            r#"
+            #[schema(ref = "ExternalUser", nullable)]
+            struct UserSchema {
+                id: i32,
+            }
+            "#
+            .to_string(),
+        );
+
+        let ty: Type = syn::parse_str("UserSchema").unwrap();
+        let schema_ref = parse_type_to_schema_ref(&ty, &known, &defs);
+
+        match schema_ref {
+            SchemaRef::Inline(schema) => {
+                assert_eq!(
+                    schema.ref_path.as_deref(),
+                    Some("#/components/schemas/ExternalUser")
+                );
+                assert_eq!(schema.nullable, Some(true));
+            }
+            SchemaRef::Ref(_) => panic!("expected inline schema ref override"),
+        }
+    }
 }

crates/vespera_macro/src/schema_impl.rs

@@ -630,4 +630,20 @@ struct Config {
         let defaults = extract_field_defaults_from_path(&input, Path::new("/dummy.rs"));
         assert!(defaults.is_empty(), "Enum should return empty defaults");
     }
+
+    #[test]
+    fn test_process_derive_schema_ref_override_excludes_openapi() {
+        let input: syn::DeriveInput = syn::parse_quote! {
+            #[derive(Clone)]
+            #[schema(ref = "ExternalUser")]
+            struct UserSchema {
+                id: i32,
+            }
+        };
+
+        let (metadata, tokens) = process_derive_schema(&input);
+        assert_eq!(metadata.name, "UserSchema");
+        assert!(!metadata.include_in_openapi);
+        assert!(tokens.is_empty());
+    }
 }

crates/vespera_macro/src/schema_macro/mod.rs

@@ -54,6 +54,11 @@ use crate::{
     parser::{extract_default, extract_field_rename, strip_raw_prefix_owned},
 };
 
+#[cfg(test)]
+struct __VesperaSameFileLookupFixture {
+    value: i32,
+}
+
 fn derive_response_base_name(name: &str) -> String {
     for suffix in ["Response", "Request", "Schema"] {
         if let Some(stripped) = name.strip_suffix(suffix)
@@ -73,7 +78,17 @@ fn find_same_file_struct_metadata(
         return Some(metadata.clone());
     }
 
-    let file_path = proc_macro2::Span::call_site().local_file()?;
+    let file_path = proc_macro2::Span::call_site().local_file();
+    #[cfg(test)]
+    let file_path = file_path.or_else(|| {
+        Some(
+            std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+                .join("src")
+                .join("schema_macro")
+                .join("mod.rs"),
+        )
+    });
+    let file_path = file_path?;
     let definition = file_cache::get_struct_definition(&file_path, struct_name)?;
     Some(StructMetadata::new(struct_name.to_string(), definition))
 }

crates/vespera_macro/src/schema_macro/tests.rs

@@ -1616,6 +1616,177 @@ pub struct Model {
     assert!(output.contains("name"));
 }
 
+#[test]
+fn test_derive_response_base_name_handles_known_suffixes_and_fallback() {
+    assert_eq!(derive_response_base_name("UserResponse"), "User");
+    assert_eq!(derive_response_base_name("UserRequest"), "User");
+    assert_eq!(derive_response_base_name("UserSchema"), "User");
+    assert_eq!(derive_response_base_name("User"), "User");
+}
+
+#[test]
+fn test_find_same_file_struct_metadata_reads_test_fixture_from_current_module() {
+    let storage: HashMap<String, StructMetadata> = HashMap::new();
+    let metadata = find_same_file_struct_metadata("__VesperaSameFileLookupFixture", &storage)
+        .expect("fixture should be found in schema_macro/mod.rs");
+
+    assert_eq!(metadata.name, "__VesperaSameFileLookupFixture");
+    assert!(
+        metadata
+            .definition
+            .contains("__VesperaSameFileLookupFixture")
+    );
+    assert!(metadata.definition.contains("value"));
+}
+
+#[test]
+fn test_has_derive_ignores_non_derive_attrs_and_detects_requested_derive() {
+    let struct_item: syn::ItemStruct = syn::parse_str(
+        r#"
+        #[serde(rename_all = "camelCase")]
+        #[derive(Clone, Debug)]
+        struct Sample {
+            value: i32,
+        }
+        "#,
+    )
+    .unwrap();
+
+    assert!(has_derive(&struct_item, "Clone"));
+    assert!(!has_derive(&struct_item, "Deserialize"));
+}
+
+#[test]
+fn test_build_named_struct_field_assignments_rejects_tuple_structs() {
+    let struct_item: syn::ItemStruct = syn::parse_str("struct TupleDto(String);").unwrap();
+    let source_expr = quote!(source);
+    let error = build_named_struct_field_assignments(&struct_item, &source_expr).unwrap_err();
+    assert!(error.to_string().contains("named-field struct"));
+}
+
+#[test]
+fn test_build_proxy_fields_rejects_tuple_structs() {
+    let struct_item: syn::ItemStruct = syn::parse_str("struct TupleDto(String);").unwrap();
+    let error = build_proxy_fields(&struct_item).unwrap_err();
+    assert!(error.to_string().contains("named-field struct"));
+}
+
+#[test]
+fn test_build_proxy_to_dto_assignments_rejects_tuple_structs() {
+    let struct_item: syn::ItemStruct = syn::parse_str("struct TupleDto(String);").unwrap();
+    let error = build_proxy_to_dto_assignments(&struct_item).unwrap_err();
+    assert!(error.to_string().contains("named-field struct"));
+}
+
+#[test]
+fn test_build_clone_assignments_rejects_tuple_structs() {
+    let struct_item: syn::ItemStruct = syn::parse_str("struct TupleDto(String);").unwrap();
+    let error = build_clone_assignments(&struct_item).unwrap_err();
+    assert!(error.to_string().contains("named-field struct"));
+}
+
+#[test]
+fn test_maybe_generate_same_file_relation_override_returns_none_when_dto_is_missing() {
+    let rel_info = RelationFieldInfo {
+        field_name: syn::Ident::new("user", proc_macro2::Span::call_site()),
+        relation_type: "HasOne".to_string(),
+        schema_path: quote!(crate::models::user::Schema),
+        is_optional: true,
+        inline_type_info: None,
+        relation_enum: None,
+        fk_column: None,
+        via_rel: None,
+    };
+
+    let storage: HashMap<String, StructMetadata> = HashMap::new();
+    let new_type_name = syn::Ident::new("ArticleResponse", proc_macro2::Span::call_site());
+
+    let result =
+        maybe_generate_same_file_relation_override(&new_type_name, "user", &rel_info, &storage)
+            .expect("missing dto should not error");
+    assert!(result.is_none());
+}
+
+#[test]
+fn test_maybe_generate_same_file_relation_override_returns_none_for_invalid_model_type() {
+    let rel_info = RelationFieldInfo {
+        field_name: syn::Ident::new("user", proc_macro2::Span::call_site()),
+        relation_type: "HasOne".to_string(),
+        schema_path: quote!(?),
+        is_optional: true,
+        inline_type_info: None,
+        relation_enum: None,
+        fk_column: None,
+        via_rel: None,
+    };
+
+    let storage = to_storage(vec![create_test_struct_metadata(
+        "UserInArticle",
+        "struct UserInArticle { id: i32 }",
+    )]);
+    let new_type_name = syn::Ident::new("ArticleResponse", proc_macro2::Span::call_site());
+
+    let result =
+        maybe_generate_same_file_relation_override(&new_type_name, "user", &rel_info, &storage)
+            .expect("invalid model type should not error");
+    assert!(result.is_none());
+}
+
+#[test]
+fn test_generate_schema_type_code_normal_mode_relation_rename_and_custom_name() {
+    let storage = to_storage(vec![create_test_struct_metadata(
+        "Model",
+        r#"#[sea_orm(table_name = "articles")]
+            pub struct Model {
+                pub id: i32,
+                pub name: String,
+                pub owner: HasOne<super::user::Entity>
+            }"#,
+    )]);
+
+    let tokens = quote!(
+        ArticleResponse from Model,
+        name = "CustomArticleSchema",
+        rename = [("name", "display_name")]
+    );
+    let input: SchemaTypeInput = syn::parse2(tokens).unwrap();
+    let result = generate_schema_type_code(&input, &storage);
+
+    assert!(result.is_ok());
+    let (tokens, metadata) = result.unwrap();
+    let output = tokens.to_string();
+    assert!(output.contains("display_name"));
+    assert!(output.contains("owner"));
+    assert!(output.contains("Clone"));
+    assert!(output.contains("CustomArticleSchema"));
+    assert_eq!(metadata.unwrap().name, "CustomArticleSchema");
+}
+
+#[test]
+fn test_generate_schema_type_code_multipart_with_add_and_custom_name() {
+    let storage = to_storage(vec![create_test_struct_metadata(
+        "Upload",
+        "pub struct Upload { pub id: i32, pub name: String }",
+    )]);
+
+    let tokens = quote!(
+        UploadForm from Upload,
+        multipart,
+        name = "UploadFormSchema",
+        add = [("extra": String)]
+    );
+    let input: SchemaTypeInput = syn::parse2(tokens).unwrap();
+    let result = generate_schema_type_code(&input, &storage);
+
+    assert!(result.is_ok());
+    let (tokens, metadata) = result.unwrap();
+    let output = tokens.to_string();
+    assert!(output.contains("vespera :: Multipart"));
+    assert!(output.contains("extra"));
+    assert!(output.contains("UploadFormSchema"));
+    assert_eq!(metadata.unwrap().name, "UploadFormSchema");
+}
+
 // ============================================================
 // Tests for BelongsTo/HasOne circular reference inline types
 // ============================================================