Fix composed property enum mapping

Author: sdairs

crates/clickhouse-openapi-analyzer/src/compare.rs

@@ -864,6 +864,30 @@ mod tests {
         }));
     }
 
+    #[test]
+    fn maps_property_enum_beneath_top_level_composition() {
+        let report = analyze_fixture(
+            r#"
+                pub struct Widget { pub status: Status }
+                pub enum Status { #[serde(rename = "on")] On }
+            "#,
+            serde_json::json!({
+                "allOf": [{
+                    "properties": {"status": {"enum": ["on", "off"]}}
+                }]
+            }),
+            AnalyzerConfig::default(),
+        );
+
+        assert!(report.findings.iter().any(|finding| {
+            finding.kind == FindingKind::MissingEnumValue
+                && finding.details.get("enum").map(String::as_str) == Some("Status")
+                && finding.details.get("value").map(String::as_str) == Some("off")
+                && finding.rust_item.as_deref() == Some("models.rs::Widget::status")
+        }));
+        assert!(report.unsupported_enum_constraints.is_empty());
+    }
+
     #[test]
     fn nested_chain_through_non_struct_reports_unsupported() {
         let report = analyze_fixture(

crates/clickhouse-openapi-analyzer/src/openapi.rs

@@ -637,11 +637,17 @@ fn enum_context(root: &Value, path: &[String]) -> EnumContext {
             schema: path[2].clone(),
         };
     }
-    if path.len() >= 5 && path[0] == "components" && path[1] == "schemas" && path[3] == "properties"
+    if path.len() >= 5
+        && path[0] == "components"
+        && path[1] == "schemas"
+        && let Some(properties_index) = path[3..]
+            .iter()
+            .position(|part| part == "properties")
+            .map(|index| index + 3)
     {
         return EnumContext::Property {
             schema: path[2].clone(),
-            steps: property_steps(&path[3..]),
+            steps: property_steps(&path[properties_index..]),
         };
     }
     if path.len() > 3
@@ -895,6 +901,82 @@ mod tests {
         }
     }
 
+    #[test]
+    fn attributes_property_enums_beneath_top_level_compositions() {
+        let spec = serde_json::json!({
+            "paths": {},
+            "components": {"schemas": {
+                "AllOfWidget": {"allOf": [{"properties": {
+                    "status": {"enum": ["on"]}
+                }}]},
+                "OneOfWidget": {"oneOf": [{"properties": {
+                    "states": {"type": "array", "items": {"enum": ["ready"]}}
+                }}]},
+                "AnyOfWidget": {"anyOf": [{"properties": {
+                    "settings": {"properties": {
+                        "mode": {"enum": ["fast"]}
+                    }}
+                }}]},
+                "NamedChoice": {"allOf": [{"enum": ["a"]}]}
+            }}
+        });
+        let inventory = OpenApiInventory::build(&spec, &AnalyzerConfig::default()).unwrap();
+        let by_pointer: BTreeMap<String, EnumContext> = inventory
+            .enum_constraints
+            .iter()
+            .map(|constraint| (constraint.pointer.clone(), constraint.context.clone()))
+            .collect();
+
+        for (pointer, schema, steps) in [
+            (
+                "/components/schemas/AllOfWidget/allOf/0/properties/status",
+                "AllOfWidget",
+                vec![PropertyStep {
+                    property: "status".to_string(),
+                    array_item: false,
+                }],
+            ),
+            (
+                "/components/schemas/OneOfWidget/oneOf/0/properties/states/items",
+                "OneOfWidget",
+                vec![PropertyStep {
+                    property: "states".to_string(),
+                    array_item: true,
+                }],
+            ),
+            (
+                "/components/schemas/AnyOfWidget/anyOf/0/properties/settings/properties/mode",
+                "AnyOfWidget",
+                vec![
+                    PropertyStep {
+                        property: "settings".to_string(),
+                        array_item: false,
+                    },
+                    PropertyStep {
+                        property: "mode".to_string(),
+                        array_item: false,
+                    },
+                ],
+            ),
+        ] {
+            match &by_pointer[pointer] {
+                EnumContext::Property {
+                    schema: actual_schema,
+                    steps: actual_steps,
+                } => {
+                    assert_eq!(actual_schema, schema);
+                    assert_eq!(actual_steps, &steps);
+                }
+                other => panic!("expected property context for {pointer}, got {other:?}"),
+            }
+        }
+
+        assert!(matches!(
+            &by_pointer["/components/schemas/NamedChoice/allOf/0"],
+            EnumContext::NamedSchema { schema } if schema == "NamedChoice"
+        ));
+    }
+
     #[test]
     fn keeps_single_property_chains_for_the_common_case() {
         let spec = serde_json::json!({