fix: respect rule type for sub-rules in segment evaluation

.gitmodules

@@ -1,4 +1,4 @@
 [submodule "tests/engine_tests/engine-test-data"]
 	path = tests/engine_tests/engine-test-data
 	url = https://github.com/flagsmith/engine-test-data.git
-	branch = v3.5.0
+	branch = v3.7.0

src/engine_eval/segment_evaluator.rs

@@ -37,14 +37,28 @@ fn context_matches_segment_rule(
         return false;
     }
 
-    // Check nested rules
-    for nested_rule in &rule.rules {
-        if !context_matches_segment_rule(ec, nested_rule, segment_key) {
-            return false;
-        }
+    // Check nested rules using rule type
+    if rule.rules.is_empty() {
+        return true;
     }
 
-    true
+    matches_sub_rules_by_rule_type(ec, &rule.rules, &rule.rule_type, segment_key)
+}
+
+fn matches_sub_rules_by_rule_type(
+    ec: &EngineEvaluationContext,
+    sub_rules: &[SegmentRule],
+    rule_type: &SegmentRuleType,
+    segment_key: &str,
+) -> bool {
+    let mut results = sub_rules
+        .iter()
+        .map(|sr| context_matches_segment_rule(ec, sr, segment_key));
+    match rule_type {
+        SegmentRuleType::All => results.all(|r| r),
+        SegmentRuleType::Any => results.any(|r| r),
+        SegmentRuleType::None => !results.any(|r| r),
+    }
 }
 
 /// Checks if conditions match according to the rule type

src/segments/evaluator.rs

@@ -41,29 +41,34 @@ pub fn evaluate_identity_in_segment(
             .all(|result| result)
 }
 
+fn matches_by_rule_type(rule_type: &str, mut results: impl Iterator<Item = bool>) -> bool {
+    match rule_type {
+        constants::ANY_RULE => results.any(|r| r),
+        constants::ALL_RULE => results.all(|r| r),
+        constants::NONE_RULE => !results.any(|r| r),
+        _ => false,
+    }
+}
+
 fn traits_match_segment_rule(
     identity_traits: &Vec<identities::Trait>,
     rule: &SegmentRule,
     segment_id: &str,
     identity_id: &str,
 ) -> bool {
-    let mut rules_iterator = rule.conditions.iter().map(|condition| {
+    let conditions_iterator = rule.conditions.iter().map(|condition| {
         traits_match_segment_condition(&identity_traits, condition, segment_id, identity_id)
     });
-    let matches_condtion = match rule.segment_rule_type.as_str() {
-        constants::ANY_RULE => rules_iterator.any(|result| result == true),
-        constants::ALL_RULE => rules_iterator.all(|result| result == true),
-        constants::NONE_RULE => true,
-        _ => false,
-    };
-    return matches_condtion
-        && rule
-            .rules
-            .iter()
-            .map(|rule| {
-                traits_match_segment_rule(&identity_traits, rule.as_ref(), segment_id, identity_id)
-            })
-            .all(|result| result == true);
+    if !matches_by_rule_type(rule.segment_rule_type.as_str(), conditions_iterator) {
+        return false;
+    }
+    if rule.rules.is_empty() {
+        return true;
+    }
+    let sub_rules_iterator = rule.rules.iter().map(|sub_rule| {
+        traits_match_segment_rule(&identity_traits, sub_rule.as_ref(), segment_id, identity_id)
+    });
+    matches_by_rule_type(rule.segment_rule_type.as_str(), sub_rules_iterator)
 }
 
 fn traits_match_segment_condition(