Add test

Author: owjs3901

.gitignore

@@ -2,3 +2,4 @@ target
 lcov.info
 coverage
 build_rs_cov.profraw
+.sisyphus/

crates/vespera_macro/src/openapi_generator.rs

@@ -1154,4 +1154,181 @@ pub fn get_config() -> Config {
         let schemas = doc.components.as_ref().unwrap().schemas.as_ref().unwrap();
         assert!(schemas.contains_key("Config"));
     }
+
+    // ======== Tests for uncovered lines ========
+
+    #[test]
+    fn test_fallback_struct_finding_in_route_files() {
+        // Test line 65: fallback loop that finds struct in any route file when direct search fails
+        let temp_dir = TempDir::new().expect("Failed to create temp dir");
+
+        // Create TWO route files - struct is in second file, route references it from first
+        let route1_content = r#"
+pub fn get_users() -> Vec<User> {
+    vec![]
+}
+"#;
+        let route1_file = create_temp_file(&temp_dir, "users.rs", route1_content);
+
+        let route2_content = r#"
+fn default_name() -> String {
+    "Guest".to_string()
+}
+
+struct User {
+    #[serde(default = "default_name")]
+    name: String,
+}
+
+pub fn get_user() -> User {
+    User { name: "Alice".to_string() }
+}
+"#;
+        let route2_file = create_temp_file(&temp_dir, "user.rs", route2_content);
+
+        let mut metadata = CollectedMetadata::new();
+        // Add struct but point to route1 (which doesn't contain the struct)
+        // This forces the fallback loop to search other route files
+        metadata.structs.push(StructMetadata {
+            name: "User".to_string(),
+            definition: r#"struct User { #[serde(default = "default_name")] name: String }"#
+                .to_string(),
+        });
+        // Add BOTH routes - the first doesn't contain User struct, so fallback searches the second
+        metadata.routes.push(RouteMetadata {
+            method: "GET".to_string(),
+            path: "/users".to_string(),
+            function_name: "get_users".to_string(),
+            module_path: "test::users".to_string(),
+            file_path: route1_file.to_string_lossy().to_string(),
+            signature: "fn get_users() -> Vec<User>".to_string(),
+            error_status: None,
+            tags: None,
+            description: None,
+        });
+        metadata.routes.push(RouteMetadata {
+            method: "GET".to_string(),
+            path: "/user".to_string(),
+            function_name: "get_user".to_string(),
+            module_path: "test::user".to_string(),
+            file_path: route2_file.to_string_lossy().to_string(),
+            signature: "fn get_user() -> User".to_string(),
+            error_status: None,
+            tags: None,
+            description: None,
+        });
+
+        let doc = generate_openapi_doc_with_metadata(None, None, None, &metadata);
+
+        // Struct should be found via fallback and processed
+        assert!(doc.components.as_ref().unwrap().schemas.is_some());
+        let schemas = doc.components.as_ref().unwrap().schemas.as_ref().unwrap();
+        assert!(schemas.contains_key("User"));
+    }
+
+    #[test]
+    fn test_process_default_functions_with_no_properties() {
+        // Test line 152: early return when schema.properties is None
+        // This happens when a struct has no named fields (unit struct or tuple struct)
+        use vespera_core::schema::Schema;
+
+        let struct_item: syn::ItemStruct = syn::parse_str("struct Empty;").unwrap();
+        let file_ast: syn::File = syn::parse_str("fn foo() {}").unwrap();
+        let mut schema = Schema::object();
+        schema.properties = None; // Explicitly set to None
+
+        // This should return early without panic
+        process_default_functions(&struct_item, &file_ast, &mut schema);
+
+        // Schema should remain unchanged
+        assert!(schema.properties.is_none());
+    }
+
+    #[test]
+    fn test_extract_value_from_expr_int_parse_failure() {
+        // Test line 253: int parse failure (overflow)
+        // Create an integer literal that's too large to parse as i64
+        // Use a literal that syn will parse but i64::parse will fail on
+        let expr: syn::Expr = syn::parse_str("999999999999999999999999999999").unwrap();
+        let value = extract_value_from_expr(&expr);
+        assert!(value.is_none());
+    }
+
+    #[test]
+    fn test_extract_value_from_expr_float_parse_failure() {
+        // Test line 260: float parse failure
+        // Create a float literal that's too large/invalid
+        let expr: syn::Expr = syn::parse_str("1e999999").unwrap();
+        let value = extract_value_from_expr(&expr);
+        // This may parse successfully to infinity or fail - either way should handle it
+        // The important thing is no panic
+        let _ = value;
+    }
+
+    #[test]
+    fn test_extract_value_from_expr_method_call_with_nested_receiver() {
+        // Test lines 275-276: recursive extraction from method call receiver
+        // When receiver is not a direct string literal, it tries to extract recursively
+        // But the recursive call also won't find a Lit, so it returns None
+        // This test verifies the recursive path is exercised (line 275-276)
+        let expr: syn::Expr = syn::parse_str(r#"("hello").to_string()"#).unwrap();
+        let value = extract_value_from_expr(&expr);
+        // The receiver is a Paren expression - recursive call is made but returns None
+        // because Paren is not handled in the match
+        assert!(value.is_none());
+    }
+
+    #[test]
+    fn test_extract_value_from_expr_method_call_with_non_literal_receiver() {
+        // Test lines 275-276: recursive extraction fails for non-literal
+        let expr: syn::Expr = syn::parse_str(r#"some_var.to_string()"#).unwrap();
+        let value = extract_value_from_expr(&expr);
+        // Cannot extract value from a variable
+        assert!(value.is_none());
+    }
+
+    #[test]
+    fn test_extract_value_from_expr_method_call_chained_to_string() {
+        // Test lines 275-276: another case where recursive extraction is attempted
+        // Chained method calls: 42.to_string() has int literal as receiver
+        let expr: syn::Expr = syn::parse_str(r#"42.to_string()"#).unwrap();
+        let value = extract_value_from_expr(&expr);
+        // Line 275 recursive call extracts 42 as Number, then line 276 returns it
+        assert_eq!(value, Some(serde_json::Value::Number(42.into())));
+    }
+
+    #[test]
+    fn test_get_type_default_empty_path_segments() {
+        // Test line 307: empty path segments returns None
+        // Create a type with empty path segments
+
+        // Use parse to create a valid type, then we verify the normal path works
+        let ty: syn::Type = syn::parse_str("::String").unwrap();
+        // This has segments, so it should work
+        let value = get_type_default(&ty);
+        // Global path ::String still has "String" as last segment
+        assert!(value.is_some());
+
+        // Test reference type (non-path type)
+        let ref_ty: syn::Type = syn::parse_str("&str").unwrap();
+        let ref_value = get_type_default(&ref_ty);
+        // Reference is not a Path type, so returns None via line 310
+        assert!(ref_value.is_none());
+    }
+
+    #[test]
+    fn test_get_type_default_tuple_type() {
+        // Test line 310: non-Path type returns None
+        let ty: syn::Type = syn::parse_str("(i32, String)").unwrap();
+        let value = get_type_default(&ty);
+        assert!(value.is_none());
+    }
+
+    #[test]
+    fn test_get_type_default_array_type() {
+        // Test line 310: array type returns None
+        let ty: syn::Type = syn::parse_str("[i32; 3]").unwrap();
+        let value = get_type_default(&ty);
+        assert!(value.is_none());
+    }
 }

crates/vespera_macro/src/parser/operation.rs

@@ -526,4 +526,126 @@ mod tests {
         assert_body(&op, &expected_body);
         assert_responses(&op, &expected_resps);
     }
+
+    // ======== Tests for uncovered lines ========
+
+    #[test]
+    fn test_single_path_param_with_single_type() {
+        // Test line 55: Path<T> with single type (not tuple) and exactly ONE path param
+        // This exercises the branch: path_params.len() == 1 with non-tuple type
+        let op = build("fn get(Path(id): Path<i32>) -> String", "/users/{id}", None);
+
+        // Should have exactly 1 path parameter with Integer type
+        let params = op.parameters.as_ref().expect("parameters expected");
+        assert_eq!(params.len(), 1);
+        assert_eq!(params[0].name, "id");
+        assert_eq!(param_schema_type(&params[0]), Some(SchemaType::Integer));
+    }
+
+    #[test]
+    fn test_single_path_param_with_string_type() {
+        // Another test for line 55: Path<String> with single path param
+        let op = build(
+            "fn get(Path(id): Path<String>) -> String",
+            "/users/{user_id}",
+            None,
+        );
+
+        let params = op.parameters.as_ref().expect("parameters expected");
+        assert_eq!(params.len(), 1);
+        assert_eq!(params[0].name, "user_id");
+        assert_eq!(param_schema_type(&params[0]), Some(SchemaType::String));
+    }
+
+    #[test]
+    fn test_non_path_extractor_with_query() {
+        // Test lines 85, 89: non-Path extractor handling
+        // When input is Query<T>, it should NOT be treated as Path
+        let op = build(
+            "fn search(Query(params): Query<QueryParams>) -> String",
+            "/search",
+            None,
+        );
+
+        // Query params should be extended to parameters (line 89)
+        // But QueryParams is not in known_schemas/struct_definitions so it won't appear
+        // The key is that it doesn't treat Query as a Path extractor (line 85 returns false)
+        assert!(op.request_body.is_none()); // Query is not a body
+    }
+
+    #[test]
+    fn test_non_path_extractor_with_state() {
+        // Test lines 85, 89: State<T> should be ignored (not Path)
+        let op = build(
+            "fn handler(State(state): State<AppState>) -> String",
+            "/handler",
+            None,
+        );
+
+        // State is not a path extractor, and State params are typically ignored
+        // line 85 returns false, so line 89 extends parameters (but State is usually filtered out)
+        assert!(op.parameters.is_none() || op.parameters.as_ref().unwrap().is_empty());
+    }
+
+    #[test]
+    fn test_string_body_fallback() {
+        // Test lines 100-107: String as last arg becomes text/plain body
+        let op = build("fn upload(content: String) -> String", "/upload", None);
+
+        let body = op.request_body.as_ref().expect("request body expected");
+        assert!(body.content.contains_key("text/plain"));
+        let media = body.content.get("text/plain").unwrap();
+        match media.schema.as_ref().unwrap() {
+            SchemaRef::Inline(schema) => {
+                assert_eq!(schema.schema_type, Some(SchemaType::String));
+            }
+            _ => panic!("expected inline schema"),
+        }
+    }
+
+    #[test]
+    fn test_str_ref_body_fallback() {
+        // Test lines 100-106: &str as last arg becomes text/plain body
+        let op = build("fn upload(content: &str) -> String", "/upload", None);
+
+        let body = op.request_body.as_ref().expect("request body expected");
+        assert!(body.content.contains_key("text/plain"));
+    }
+
+    #[test]
+    fn test_type_reference_with_string() {
+        // Test lines 100-102, 104: Type::Reference branch - &String
+        let op = build("fn upload(content: &String) -> String", "/upload", None);
+
+        // &String reference should be detected as string type
+        // Line 101-102 checks if Type::Reference elem is a Path with String/str
+        let body = op.request_body.as_ref().expect("request body expected");
+        assert!(body.content.contains_key("text/plain"));
+    }
+
+    #[test]
+    fn test_non_string_last_arg_not_body() {
+        // Test line 107: last arg that's NOT String/&str should NOT become body
+        let op = build("fn process(count: i32) -> String", "/process", None);
+
+        // i32 is not String/&str, so line 107 returns false, no body created
+        // However, bare i32 without extractor is also ignored
+        assert!(op.request_body.is_none());
+    }
+
+    #[test]
+    fn test_multiple_path_params_with_single_type() {
+        // Test line 57-60: multiple path params but single type - uses type for all
+        let op = build(
+            "fn get(Path(id): Path<String>) -> String",
+            "/shops/{shop_id}/items/{item_id}",
+            None,
+        );
+
+        // Both params should use String type
+        let params = op.parameters.as_ref().expect("parameters expected");
+        assert_eq!(params.len(), 2);
+        assert_eq!(param_schema_type(&params[0]), Some(SchemaType::String));
+        assert_eq!(param_schema_type(&params[1]), Some(SchemaType::String));
+    }
 }