From 41453d9d0bf563a840ca88eaf034d62f2ec2974c Mon Sep 17 00:00:00 2001 From: Evandro Myller Date: Tue, 3 Nov 2026 19:10:36 -0300 Subject: [PATCH] feat(Flag Dependency): Support `$.flags` context values in segment conditions Bump flagsmith-flag-engine to 11.1.1 so segments depending on other flags resolve, and evaluate `/flags` with segments that need no identity. Co-Authored-By: Claude Opus 5.5 (1M context) --- pyproject.toml | 2 +- requirements-dev.lock | 2 +- requirements.lock | 2 +- src/edge_proxy/environments.py | 25 ++++ tests/test_server.py | 217 +++++++++++++++++++++++++++++++++ 5 files changed, 245 insertions(+), 3 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 1cbf4c7..a912510 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ name = "edge-proxy" license = { file = "LICENSE" } dependencies = [ "fastapi", - "flagsmith-flag-engine>=11,<12", + "flagsmith-flag-engine>=11.1.1,<12", "flagsmith>=5", "httpx", "marshmallow", diff --git a/requirements-dev.lock b/requirements-dev.lock index 9bf0604..65a3517 100644 --- a/requirements-dev.lock +++ b/requirements-dev.lock @@ -35,7 +35,7 @@ filelock==3.13.3 # via virtualenv flagsmith==6.2.2 # via edge-proxy -flagsmith-flag-engine==11.0.0 +flagsmith-flag-engine==11.1.1 # via edge-proxy # via flagsmith freezegun==1.4.0 diff --git a/requirements.lock b/requirements.lock index 02d56ee..1273cd7 100644 --- a/requirements.lock +++ b/requirements.lock @@ -27,7 +27,7 @@ fastapi==0.110.1 # via edge-proxy flagsmith==6.2.2 # via edge-proxy -flagsmith-flag-engine==11.0.0 +flagsmith-flag-engine==11.1.1 # via edge-proxy # via flagsmith h11==0.14.0 diff --git a/src/edge_proxy/environments.py b/src/edge_proxy/environments.py index 880930e..e5781ee 100644 --- a/src/edge_proxy/environments.py +++ b/src/edge_proxy/environments.py @@ -6,6 +6,7 @@ import httpx import starlette.status import structlog +from flag_engine.context.types import SegmentRule from flag_engine.engine import get_evaluation_result from flagsmith.mappers import ( map_environment_document_to_context, @@ -33,6 +34,13 @@ SERVER_API_KEY_PREFIX = "ser." +IDENTITY_FREE_PROPERTY_PREFIXES = ( + "$.environment.", + "$.environment[", + "$.flags.", + "$.flags[", +) + def _get_hide_disabled_flags(environment_document: dict[str, Any]) -> bool: return environment_document.get("project", {}).get("hide_disabled_flags", False) @@ -95,6 +103,12 @@ def get_flags_response_data( hide_disabled_flags = _get_hide_disabled_flags(environment_document) context = map_environment_document_to_context(environment_document) + if segments := context.get("segments"): + context["segments"] = { + segment_key: segment_context + for segment_key, segment_context in segments.items() + if _is_identity_free(segment_context["rules"]) + } evaluation_result = get_evaluation_result(context) feature_types = self.cache.get_feature_types(environment_key) @@ -226,3 +240,14 @@ def _get_client_key_from_server_key(self, server_key: str) -> str: if key_pair.server_side_key == server_key: return key_pair.client_side_key raise FlagsmithUnknownKeyError(server_key) + + +def _is_identity_free(rules: list[SegmentRule]) -> bool: + return all( + all( + condition["property"].startswith(IDENTITY_FREE_PROPERTY_PREFIXES) + for condition in rule.get("conditions") or () + ) + and _is_identity_free(rule.get("rules") or []) + for rule in rules + ) diff --git a/tests/test_server.py b/tests/test_server.py index e678d6b..a13803d 100644 --- a/tests/test_server.py +++ b/tests/test_server.py @@ -1,6 +1,8 @@ +import copy import typing import orjson +import pytest from fastapi.testclient import TestClient from pytest_mock import MockerFixture @@ -431,3 +433,218 @@ def test_get_flags__multivariate_feature__returns_correct_type( standard_flag = next(f for f in flags if f["feature"]["name"] == "feature_1") assert standard_flag["feature"]["type"] == "STANDARD" + + +def test_get_flags__segment_needing_identity__returns_environment_default( + mocked_environment_cache, + client: TestClient, +) -> None: + # Given + environment = copy.deepcopy(environment_1) + environment["project"]["segments"] = [ + { + "id": 2, + "name": "without_plan", + "rules": [ + { + "type": "ALL", + "rules": [], + "conditions": [ + {"operator": "IS_NOT_SET", "property_": "plan", "value": None} + ], + } + ], + "feature_states": [ + { + "multivariate_feature_state_values": [], + "feature_state_value": "segment_override", + "featurestate_uuid": "e0b3c5a2-1f4d-4c6e-9a8b-7d2f3e4a5b6c", + "feature": {"name": "feature_2", "type": "STANDARD", "id": 2}, + "enabled": True, + } + ], + } + ] + mocked_environment_cache.get_environment.return_value = environment + + # When + response = client.get( + "/api/v1/flags", + headers={"X-Environment-Key": "test_environment_key"}, + params={"feature": "feature_2"}, + ) + + # Then + assert response.status_code == 200 + assert response.json()["feature_state_value"] == "2.3" + + +@pytest.mark.parametrize( + "prerequisite_enabled, expected_enabled, expected_value", + [ + (True, True, "segment_override"), + (False, False, "feature_1_value"), + ], +) +def test_get_flags__segment_depending_on_flag__serves_flag_by_prerequisite( + mocked_environment_cache, + client: TestClient, + prerequisite_enabled: bool, + expected_enabled: bool, + expected_value: str, +) -> None: + # Given + environment = copy.deepcopy(environment_1) + environment["feature_states"][1]["enabled"] = prerequisite_enabled + environment["project"]["segments"] = [ + { + "id": 2, + "name": "feature_2_on", + "rules": [ + { + "type": "ALL", + "rules": [], + "conditions": [ + { + "operator": "EQUAL", + "property_": '$.flags["feature_2"].enabled', + "value": "true", + } + ], + } + ], + "feature_states": [ + { + "multivariate_feature_state_values": [], + "feature_state_value": "segment_override", + "featurestate_uuid": "b7c1d2e3-4f5a-4b6c-8d7e-9f0a1b2c3d4e", + "feature": {"name": "feature_1", "type": "STANDARD", "id": 1}, + "enabled": True, + } + ], + } + ] + mocked_environment_cache.get_environment.return_value = environment + + # When + response = client.get( + "/api/v1/flags", + headers={"X-Environment-Key": "test_environment_key"}, + params={"feature": "feature_1"}, + ) + + # Then + assert response.status_code == 200 + assert response.json()["enabled"] is expected_enabled + assert response.json()["feature_state_value"] == expected_value + + +def test_get_flags__segment_depending_on_environment__returns_segment_override( + mocked_environment_cache, + client: TestClient, +) -> None: + # Given + environment = copy.deepcopy(environment_1) + environment["project"]["segments"] = [ + { + "id": 2, + "name": "environment_1_only", + "rules": [ + { + "type": "ALL", + "rules": [], + "conditions": [ + { + "operator": "EQUAL", + "property_": "$.environment.name", + "value": "environment_1", + } + ], + } + ], + "feature_states": [ + { + "multivariate_feature_state_values": [], + "feature_state_value": "segment_override", + "featurestate_uuid": "c8d2e3f4-5a6b-4c7d-9e8f-0a1b2c3d4e5f", + "feature": {"name": "feature_2", "type": "STANDARD", "id": 2}, + "enabled": True, + } + ], + } + ] + mocked_environment_cache.get_environment.return_value = environment + + # When + response = client.get( + "/api/v1/flags", + headers={"X-Environment-Key": "test_environment_key"}, + params={"feature": "feature_2"}, + ) + + # Then + assert response.status_code == 200 + assert response.json()["feature_state_value"] == "segment_override" + + +@pytest.mark.parametrize( + "identifier, expected_value", + [ + ("overridden-id", "segment_override"), + ("test_identity", "2.3"), + ], +) +def test_post_identity__segment_depending_on_flag__serves_flag_by_identity_flag( + environment_service: "EnvironmentService", + client: TestClient, + identifier: str, + expected_value: str, +) -> None: + # Given + environment_key = "test_environment_key" + environment = copy.deepcopy(environment_1) + environment["project"]["segments"] = [ + { + "id": 2, + "name": "feature_1_on", + "rules": [ + { + "type": "ALL", + "rules": [], + "conditions": [ + { + "operator": "EQUAL", + "property_": "$.flags.feature_1.enabled", + "value": "true", + } + ], + } + ], + "feature_states": [ + { + "multivariate_feature_state_values": [], + "feature_state_value": "segment_override", + "featurestate_uuid": "d9e3f4a5-6b7c-4d8e-8f9a-1b2c3d4e5f6a", + "feature": {"name": "feature_2", "type": "STANDARD", "id": 2}, + "enabled": True, + } + ], + } + ] + environment_service.cache.put_environment(environment_key, environment) + + # When + response = client.post( + "/api/v1/identities/", + headers={"X-Environment-Key": environment_key}, + content=orjson.dumps({"identifier": identifier}), + ) + + # Then + assert response.status_code == 200 + feature_2 = next( + flag + for flag in response.json()["flags"] + if flag["feature"]["name"] == "feature_2" + ) + assert feature_2["feature_state_value"] == expected_value