feat: Add flag dependency test cases

schema.json

@@ -3,7 +3,7 @@
   "type": "object",
   "properties": {
     "context": {
-      "$ref": "https://raw.githubusercontent.com/Flagsmith/flagsmith/refs/heads/main/sdk/evaluation-context.json"
+      "$ref": "https://raw.githubusercontent.com/Flagsmith/flagsmith/refs/heads/feat/dependent-flags-evaluation-context/sdk/evaluation-context.json"
     },
     "result": {
       "$ref": "https://raw.githubusercontent.com/Flagsmith/flagsmith/refs/heads/main/sdk/evaluation-result.json"

test_cases/test_flag_dependency__absent_prerequisite__should_not_override.jsonc

@@ -0,0 +1,61 @@
+{
+  // Given: A segment conditioned on a feature that is not in the context
+  // When: The context is evaluated
+  // Then: The override is not applied, and evaluation does not fail
+  //
+  // NOTE: A dependency on an absent feature resolves to no value, as an
+  //       unset property would. It is not an error.
+  "$schema": "https://raw.githubusercontent.com/Flagsmith/engine-test-data/refs/heads/test/flag-dependencies/schema.json",
+  "context": {
+    "environment": {
+      "key": "key",
+      "name": "Environment"
+    },
+    "features": {
+      "dependent": {
+        "key": "2",
+        "name": "dependent",
+        "enabled": false,
+        "value": "off"
+      }
+    },
+    "segments": {
+      "1": {
+        "key": "1",
+        "name": "dependency_on_absent",
+        "rules": [
+          {
+            "type": "ALL",
+            "conditions": [
+              {
+                "operator": "EQUAL",
+                "property": "$.flags.nonexistent.enabled",
+                "value": "true"
+              }
+            ]
+          }
+        ],
+        "overrides": [
+          {
+            "key": "2",
+            "name": "dependent",
+            "enabled": true,
+            "value": "on"
+          }
+        ]
+      }
+    }
+  },
+  "result": {
+    "flags": {
+      "dependent": {
+        "enabled": false,
+        "name": "dependent",
+        "reason": "DEFAULT",
+        "value": "off",
+        "variant": null
+      }
+    },
+    "segments": []
+  }
+}

test_cases/test_flag_dependency__bracket_rooted_property__should_not_override.jsonc

@@ -0,0 +1,79 @@
+{
+  // Given: A segment overriding `dependent`, conditioned on a property that
+  //        is a valid JSONPath query but is rooted with a bracket
+  // When: The context is evaluated with `prerequisite` enabled
+  // Then: No override is applied, and the segment does not match
+  //
+  // NOTE: Only a property prefixed `$.` is treated as a JSONPath query. A
+  //       bracket-rooted query such as `$['flags']['prerequisite']` is a
+  //       trait key, and as no such trait is set it resolves to no value.
+  //       This is deliberate, and pinned here so that an implementation
+  //       using a full JSONPath parser for the prefix test does not start
+  //       honouring it and diverge.
+  "$schema": "https://raw.githubusercontent.com/Flagsmith/engine-test-data/refs/heads/test/flag-dependencies/schema.json",
+  "context": {
+    "environment": {
+      "key": "key",
+      "name": "Environment"
+    },
+    "features": {
+      "prerequisite": {
+        "key": "1",
+        "name": "prerequisite",
+        "enabled": true,
+        "value": null
+      },
+      "dependent": {
+        "key": "2",
+        "name": "dependent",
+        "enabled": false,
+        "value": "off"
+      }
+    },
+    "segments": {
+      "1": {
+        "key": "1",
+        "name": "dependency_on_prerequisite",
+        "rules": [
+          {
+            "type": "ALL",
+            "conditions": [
+              {
+                "operator": "EQUAL",
+                "property": "$['flags']['prerequisite'].enabled",
+                "value": "true"
+              }
+            ]
+          }
+        ],
+        "overrides": [
+          {
+            "key": "2",
+            "name": "dependent",
+            "enabled": true,
+            "value": "on"
+          }
+        ]
+      }
+    }
+  },
+  "result": {
+    "flags": {
+      "prerequisite": {
+        "enabled": true,
+        "name": "prerequisite",
+        "reason": "DEFAULT",
+        "value": null,
+        "variant": null
+      },
+      "dependent": {
+        "enabled": false,
+        "name": "dependent",
+        "reason": "DEFAULT",
+        "value": "off",
+        "variant": null
+      }
+    },
+    "segments": []
+  }
+}

test_cases/test_flag_dependency__bracketed_field__should_override.jsonc

@@ -0,0 +1,81 @@
+{
+  // Given: A segment overriding `dependent`, conditioned on `prerequisite`
+  //        with the *field* selected by a bracketed name rather than a dot
+  // When: The context is evaluated with `prerequisite` enabled
+  // Then: The dependency is satisfied, so `dependent` takes the override
+  //
+  // NOTE: `$.flags.prerequisite['enabled']` selects the same node as
+  //       `$.flags.prerequisite.enabled`. An implementation that matches the
+  //       property as text, rather than parsing it, is liable to miss this
+  //       spelling and leave the dependency unresolved.
+  "$schema": "https://raw.githubusercontent.com/Flagsmith/engine-test-data/refs/heads/test/flag-dependencies/schema.json",
+  "context": {
+    "environment": {
+      "key": "key",
+      "name": "Environment"
+    },
+    "features": {
+      "prerequisite": {
+        "key": "1",
+        "name": "prerequisite",
+        "enabled": true,
+        "value": null
+      },
+      "dependent": {
+        "key": "2",
+        "name": "dependent",
+        "enabled": false,
+        "value": "off"
+      }
+    },
+    "segments": {
+      "1": {
+        "key": "1",
+        "name": "dependency_on_prerequisite",
+        "rules": [
+          {
+            "type": "ALL",
+            "conditions": [
+              {
+                "operator": "EQUAL",
+                "property": "$.flags.prerequisite['enabled']",
+                "value": "true"
+              }
+            ]
+          }
+        ],
+        "overrides": [
+          {
+            "key": "2",
+            "name": "dependent",
+            "enabled": true,
+            "value": "on"
+          }
+        ]
+      }
+    }
+  },
+  "result": {
+    "flags": {
+      "prerequisite": {
+        "enabled": true,
+        "name": "prerequisite",
+        "reason": "DEFAULT",
+        "value": null,
+        "variant": null
+      },
+      "dependent": {
+        "enabled": true,
+        "name": "dependent",
+        "reason": "TARGETING_MATCH; segment=dependency_on_prerequisite",
+        "value": "on",
+        "variant": null
+      }
+    },
+    "segments": [
+      {
+        "name": "dependency_on_prerequisite"
+      }
+    ]
+  }
+}

test_cases/test_flag_dependency__competing_overrides__lowest_priority_wins.jsonc

@@ -0,0 +1,108 @@
+{
+  // Given: Two matching segments overriding `dependent`, both conditioned
+  //        on `prerequisite`, with different override priorities
+  // When: The context is evaluated with the dependency satisfied
+  // Then: The lower priority number wins, as for any segment override
+  //
+  // NOTE: Resolving dependencies must not disturb override precedence, and
+  //       in particular must not make it depend on resolution order.
+  "$schema": "https://raw.githubusercontent.com/Flagsmith/engine-test-data/refs/heads/test/flag-dependencies/schema.json",
+  "context": {
+    "environment": {
+      "key": "key",
+      "name": "Environment"
+    },
+    "features": {
+      "prerequisite": {
+        "key": "1",
+        "name": "prerequisite",
+        "enabled": true,
+        "value": null
+      },
+      "dependent": {
+        "key": "2",
+        "name": "dependent",
+        "enabled": false,
+        "value": "off"
+      }
+    },
+    "segments": {
+      "weak": {
+        "key": "weak",
+        "name": "weaker_dependency",
+        "rules": [
+          {
+            "type": "ALL",
+            "conditions": [
+              {
+                "operator": "EQUAL",
+                "property": "$.flags.prerequisite.enabled",
+                "value": "true"
+              }
+            ]
+          }
+        ],
+        "overrides": [
+          {
+            "key": "2",
+            "name": "dependent",
+            "enabled": true,
+            "value": "weaker",
+            "priority": 10
+          }
+        ]
+      },
+      "strong": {
+        "key": "strong",
+        "name": "stronger_dependency",
+        "rules": [
+          {
+            "type": "ALL",
+            "conditions": [
+              {
+                "operator": "EQUAL",
+                "property": "$.flags.prerequisite.enabled",
+                "value": "true"
+              }
+            ]
+          }
+        ],
+        "overrides": [
+          {
+            "key": "2",
+            "name": "dependent",
+            "enabled": true,
+            "value": "stronger",
+            "priority": 1
+          }
+        ]
+      }
+    }
+  },
+  "result": {
+    "flags": {
+      "prerequisite": {
+        "enabled": true,
+        "name": "prerequisite",
+        "reason": "DEFAULT",
+        "value": null,
+        "variant": null
+      },
+      "dependent": {
+        "enabled": true,
+        "name": "dependent",
+        "reason": "TARGETING_MATCH; segment=stronger_dependency",
+        "value": "stronger",
+        "variant": null
+      }
+    },
+    "segments": [
+      {
+        "name": "weaker_dependency"
+      },
+      {
+        "name": "stronger_dependency"
+      }
+    ]
+  }
+}