diff --git a/providers/openfeature-provider-flagd/openfeature/test-harness b/providers/openfeature-provider-flagd/openfeature/test-harness index 2f8f72176..952a05ff4 160000 --- a/providers/openfeature-provider-flagd/openfeature/test-harness +++ b/providers/openfeature-provider-flagd/openfeature/test-harness @@ -1 +1 @@ -Subproject commit 2f8f72176b99d85a31b23cd331a775a7c3015423 +Subproject commit 952a05ff4787696a18218b069674f77dd2900494 diff --git a/providers/openfeature-provider-flagd/tests/e2e/inprocess/conftest.py b/providers/openfeature-provider-flagd/tests/e2e/inprocess/conftest.py index d900fdcae..d3c170200 100644 --- a/providers/openfeature-provider-flagd/tests/e2e/inprocess/conftest.py +++ b/providers/openfeature-provider-flagd/tests/e2e/inprocess/conftest.py @@ -10,6 +10,9 @@ "~deprecated", "~fractional-v1", "~fractional-v2", + # the released testbed image has no "resolve" launchpad config, and its flagd + # does not support resolve yet + "~resolve", ] diff --git a/providers/openfeature-provider-flagd/tests/e2e/rpc/conftest.py b/providers/openfeature-provider-flagd/tests/e2e/rpc/conftest.py index b06e71369..dd4c470e4 100644 --- a/providers/openfeature-provider-flagd/tests/e2e/rpc/conftest.py +++ b/providers/openfeature-provider-flagd/tests/e2e/rpc/conftest.py @@ -12,6 +12,9 @@ "~deprecated", "~fractional-v1", "~fractional-v2", + # the released testbed image has no "resolve" launchpad config, and its flagd + # does not support resolve yet + "~resolve", ] diff --git a/providers/openfeature-provider-flagd/tests/e2e/step/flag_step.py b/providers/openfeature-provider-flagd/tests/e2e/step/flag_step.py index 1827055d0..2f3e0ca5b 100644 --- a/providers/openfeature-provider-flagd/tests/e2e/step/flag_step.py +++ b/providers/openfeature-provider-flagd/tests/e2e/step/flag_step.py @@ -117,8 +117,7 @@ def resolve_details_empty_error_code( @then(parsers.cfparse("the resolved metadata should contain")) def metadata_contains(details: FlagEvaluationDetails[JsonPrimitive], datatable): - assert_equal(len(details.flag_metadata), len(datatable) - 1) # skip table header - for i in range(1, len(datatable)): + for i in range(1, len(datatable)): # skip table header key, metadata_type, expected = datatable[i] assert_equal(details.flag_metadata[key], type_cast[metadata_type](expected)) diff --git a/providers/openfeature-provider-flagd/tests/e2e/step/provider_steps.py b/providers/openfeature-provider-flagd/tests/e2e/step/provider_steps.py index a2d00c3ab..a11c5c8ac 100644 --- a/providers/openfeature-provider-flagd/tests/e2e/step/provider_steps.py +++ b/providers/openfeature-provider-flagd/tests/e2e/step/provider_steps.py @@ -33,6 +33,7 @@ class TestProviderType(Enum): SSL = "ssl" SOCKET = "socket" METADATA = "metadata" + RESOLVE = "resolve" SYNCPAYLOAD = "syncpayload" FORBIDDEN = "forbidden" @@ -79,6 +80,10 @@ def get_default_options_for_provider( return options, wait elif t == TestProviderType.METADATA: launchpad = "metadata" + elif t == TestProviderType.RESOLVE and resolver_type != ResolverType.FILE: + # file mode reads the harness flag file directly, so it doesn't need the + # "resolve" launchpad config, which the released testbed image lacks + launchpad = "resolve" elif t == TestProviderType.SYNCPAYLOAD: launchpad = "sync-payload" diff --git a/tools/openfeature-flagd-core/README.md b/tools/openfeature-flagd-core/README.md index ba8f1353c..96d13b7cf 100644 --- a/tools/openfeature-flagd-core/README.md +++ b/tools/openfeature-flagd-core/README.md @@ -1,6 +1,6 @@ # OpenFeature flagd Core -Reference implementation of the flagd evaluator -- flag parsing, targeting rules (JSON logic), and custom operators (fractional, sem_ver, starts_with, ends_with). Mirrors the Java `flagd-core` module. +Reference implementation of the flagd evaluator -- flag parsing, targeting rules (JSON logic), and custom operators (fractional, sem_ver, starts_with, ends_with, resolve). Mirrors the Java `flagd-core` module. It is part of the [OpenFeature Python SDK contrib](https://github.com/open-feature/python-sdk-contrib) project. diff --git a/tools/openfeature-flagd-core/src/openfeature/contrib/tools/flagd/core/flagd_core.py b/tools/openfeature-flagd-core/src/openfeature/contrib/tools/flagd/core/flagd_core.py index c4b1123fc..dfd0351c8 100644 --- a/tools/openfeature-flagd-core/src/openfeature/contrib/tools/flagd/core/flagd_core.py +++ b/tools/openfeature-flagd-core/src/openfeature/contrib/tools/flagd/core/flagd_core.py @@ -1,4 +1,5 @@ import json +import logging import threading import typing from collections.abc import Mapping, Sequence @@ -15,9 +16,15 @@ from .model.flag import Flag from .model.flag_store import FlagStore from .targeting import targeting +from .targeting.custom_ops import ResolveResult T = typing.TypeVar("T") +logger = logging.getLogger("openfeature.contrib") + +# flag set metadata keys a resolve rule can't override; the schema only catches literal keys +RESERVED_METADATA_KEYS = frozenset({"flagSetId", "version"}) + # Type map for each resolve method _TYPE_MAP: dict[str, tuple[type | tuple[type, ...], str]] = { "boolean": ((bool,), "bool"), @@ -39,6 +46,36 @@ def _merge_metadata( return metadata +def _merge_rule_metadata( + metadata: Mapping[str, float | int | str | bool], + rule_metadata: Mapping[str, float | int | str | bool], +) -> Mapping[str, float | int | str | bool]: + merged = dict(metadata) + for key, value in rule_metadata.items(): + if key in RESERVED_METADATA_KEYS: + logger.debug(f"Ignoring reserved resolve metadata key {key}") + continue + merged[key] = value + return merged + + +def _targeting_match( + resolved: typing.Any, metadata: Mapping[str, float | int | str | bool] +) -> tuple[str, str, Mapping[str, float | int | str | bool]]: + """Variant, reason and metadata of a non-null targeting result.""" + if isinstance(resolved, ResolveResult): + reason = Reason.TARGETING_MATCH if resolved.reason is None else resolved.reason + return ( + resolved.variant, + reason, + _merge_rule_metadata(metadata, resolved.metadata), + ) + # convert to string to support shorthand + if isinstance(resolved, bool): + return str(resolved).lower(), Reason.TARGETING_MATCH, metadata + return str(resolved), Reason.TARGETING_MATCH, metadata + + def _default_resolve( flag: Flag, default_value: T, @@ -151,27 +188,21 @@ def _resolve( return result try: - variant = targeting(flag.key, flag.targeting, evaluation_context) - if variant is None: - result = _default_resolve( - flag, default_value, metadata, Reason.DEFAULT - ) - self._check_type(result, flag_type) - return result - - if isinstance(variant, bool): - variant = str(variant).lower() - elif not isinstance(variant, str): - variant = str(variant) - - if variant not in flag.variants: - raise GeneralError( - f"Resolved variant {variant} not in variants config." - ) - + resolved = targeting(flag.key, flag.targeting, evaluation_context) except ReferenceError as e: raise ParseError(f"Invalid targeting {flag.targeting}") from e + if resolved is None: + result = _default_resolve(flag, default_value, metadata, Reason.DEFAULT) + self._check_type(result, flag_type) + return result + + variant, reason, metadata = _targeting_match(resolved, metadata) + if variant not in flag.variants: + raise GeneralError( + f"Resolved variant {variant} not in variants config." + ) + variant, value = flag.get_variant(variant) if value is None: raise GeneralError( @@ -181,7 +212,7 @@ def _resolve( result = FlagResolutionDetails( value, variant=variant, - reason=Reason.TARGETING_MATCH, + reason=reason, flag_metadata=metadata, ) self._check_type(result, flag_type) @@ -195,11 +226,9 @@ def _check_type( """Validate the resolved value type matches the expected flag type.""" if flag_type is None: return - # Skip type check when value is the caller's default (no variant resolved) - # This happens for DEFAULT reason with no variant, or DISABLED flags - if result.reason == Reason.DISABLED: - return - if result.reason == Reason.DEFAULT and result.variant is None: + # Skip type check when value is the caller's default (no variant resolved). + # Not by reason: a resolve rule may return any reason, DISABLED included. + if result.variant is None: return type_info = _TYPE_MAP.get(flag_type) diff --git a/tools/openfeature-flagd-core/src/openfeature/contrib/tools/flagd/core/targeting/custom_ops.py b/tools/openfeature-flagd-core/src/openfeature/contrib/tools/flagd/core/targeting/custom_ops.py index 5047bb979..d2dde7c39 100644 --- a/tools/openfeature-flagd-core/src/openfeature/contrib/tools/flagd/core/targeting/custom_ops.py +++ b/tools/openfeature-flagd-core/src/openfeature/contrib/tools/flagd/core/targeting/custom_ops.py @@ -1,11 +1,13 @@ import logging +import math import typing -from collections.abc import Sequence -from dataclasses import dataclass +from collections.abc import Mapping, Sequence +from dataclasses import dataclass, field import cbor2 import mmh3 import semver +from json_logic.builtins import to_number MAX_WEIGHT_SUM = 2_147_483_647 # MaxInt32 @@ -17,10 +19,25 @@ @dataclass class Fraction: - variant: str | float | int | bool | None + # whatever the variant expression evaluated to, the resolver decides what to do with it + variant: typing.Any weight: int = 1 +@dataclass(frozen=True) +class ResolveResult: + """Result of the terminal ``resolve`` operator. + + No JSON input decodes to this type, so evaluation context data can't forge one. + """ + + variant: str + # None keeps TARGETING_MATCH + reason: str | None = None + # merged over flag set and flag metadata + metadata: Mapping[str, str | bool | int | float] = field(default_factory=dict) + + def _resolve_bucket_by(data: dict, args: tuple) -> tuple[typing.Any, tuple]: if not isinstance(args[0], (list, tuple)): return args[0], args[1:] @@ -54,7 +71,7 @@ def normalize_numbers(data: typing.Any) -> typing.Any: return data -def fractional(data: dict, *args: typing.Any) -> str | float | int | bool | None: +def fractional(data: dict, *args: typing.Any) -> typing.Any: if not args: logger.error("No arguments provided to fractional operator.") return None @@ -104,6 +121,24 @@ def fractional(data: dict, *args: typing.Any) -> str | float | int | bool | None return None +def divide( + data: dict, a: typing.Any = None, b: typing.Any = None, *_: typing.Any +) -> float: + """JsonLogic ``/`` that divides by zero like JavaScript, the JsonLogic reference. + + The builtin raises ZeroDivisionError, which fails the whole evaluation; JavaScript, + and the Go and Java flagd cores, return Infinity or NaN. + """ + dividend: float = to_number(a) + divisor: float = to_number(b) + try: + return dividend / divisor + except ZeroDivisionError: + if dividend == 0 or math.isnan(dividend): + return math.nan + return math.copysign(math.inf, dividend) * math.copysign(1, divisor) + + def _parse_fraction(arg: JsonLogicArg) -> Fraction: if not isinstance(arg, (tuple, list)) or not arg or len(arg) > 2: raise ValueError( @@ -216,3 +251,70 @@ def normalize_version(arg: typing.Any) -> semver.Version: version = numeric_part + ".0" * (2 - dot_count) + version[len(numeric_part) :] return semver.Version.parse(version) + + +def resolve(data: dict, *args: typing.Any) -> ResolveResult | None: + """Terminal ``resolve`` operator: ``["variant", "reason"?, [["key", value], ...]?]``. + + Placement is enforced by the targeting schema. Malformed (computed) arguments return + None like the other custom operators, so the flag falls back to its default variant. + """ + if not 1 <= len(args) <= 3: + logger.debug("resolve takes 1 to 3 arguments") + return None + + variant = _resolve_variant_key(args[0]) + if variant is None: + logger.debug("resolve variant must be a string, boolean, or finite number") + return None + + reason = args[1] if len(args) > 1 else None + if reason is not None and not isinstance(reason, str): + logger.debug("resolve reason must be a string or null") + return None + + pairs = args[2] if len(args) > 2 else None + metadata = {} if pairs is None else _resolve_metadata(pairs) + if metadata is None: + return None + + return ResolveResult(variant, reason, metadata) + + +def _resolve_variant_key(value: typing.Any) -> str | None: + # coerce like a plain targeting result + if isinstance(value, bool): + return str(value).lower() + if isinstance(value, str): + return value + if isinstance(value, int) or (isinstance(value, float) and math.isfinite(value)): + return str(value) + return None + + +def _resolve_metadata( + pairs: typing.Any, +) -> dict[str, str | bool | int | float] | None: + if not isinstance(pairs, (list, tuple)): + logger.debug("resolve metadata must be an array of [key, value] pairs") + return None + metadata: dict[str, str | bool | int | float] = {} + for pair in pairs: + if ( + not isinstance(pair, (list, tuple)) + or len(pair) != 2 + or not isinstance(pair[0], str) + ): + logger.debug("resolve metadata pair must be a [string, value] array") + return None + key, value = pair + # NaN and Infinity (e.g. a computed 1/0) can't be encoded as JSON + if not isinstance(value, (str, bool, int)) and not ( + isinstance(value, float) and math.isfinite(value) + ): + logger.debug( + "resolve metadata value must be a string, finite number, or boolean" + ) + return None + metadata[key] = value + return metadata diff --git a/tools/openfeature-flagd-core/src/openfeature/contrib/tools/flagd/core/targeting/targeting.py b/tools/openfeature-flagd-core/src/openfeature/contrib/tools/flagd/core/targeting/targeting.py index b3a6d5e92..dfc5cca8a 100644 --- a/tools/openfeature-flagd-core/src/openfeature/contrib/tools/flagd/core/targeting/targeting.py +++ b/tools/openfeature-flagd-core/src/openfeature/contrib/tools/flagd/core/targeting/targeting.py @@ -10,18 +10,22 @@ from openfeature.exception import ParseError from .custom_ops import ( + divide, ends_with, fractional, + resolve, sem_ver, starts_with, ) OPERATORS = { **builtins.BUILTINS, + "/": divide, "fractional": fractional, "starts_with": starts_with, "ends_with": ends_with, "sem_ver": sem_ver, + "resolve": resolve, } diff --git a/tools/openfeature-flagd-core/tests/test_resolve.py b/tools/openfeature-flagd-core/tests/test_resolve.py new file mode 100644 index 000000000..f0dbc9447 --- /dev/null +++ b/tools/openfeature-flagd-core/tests/test_resolve.py @@ -0,0 +1,593 @@ +import json +import typing + +import pytest + +from openfeature.contrib.tools.flagd.core import FlagdCore +from openfeature.contrib.tools.flagd.core.targeting.custom_ops import ( + ResolveResult, + resolve, +) +from openfeature.evaluation_context import EvaluationContext +from openfeature.exception import GeneralError, TypeMismatchError +from openfeature.flag_evaluation import Reason + +VARIANTS = { + "red": "#FF0000", + "blue": "#0000FF", + "green": "#00FF00", + "yellow": "#FFFF00", +} + + +def resolve_flag(targeting: typing.Any, **extra: typing.Any) -> dict: + return { + "flags": { + "color": { + "state": "ENABLED", + "defaultVariant": "yellow", + "variants": VARIANTS, + "targeting": targeting, + } + }, + **extra, + } + + +def evaluate(flags: dict, attributes: dict | None = None, flag_key: str = "color"): + core = FlagdCore() + core.set_flags(json.dumps(flags)) + return core.resolve_string_value( + flag_key, "default", EvaluationContext(attributes=attributes or {}) + ) + + +NESTED_BRANCHES = { + "if": [ + {"==": [{"var": "id"}, "a"]}, + {"resolve": ["red", "ALLOWLIST", [["details", "customer-a"]]]}, + {"==": [{"var": "id"}, "b"]}, + {"resolve": ["red", "SPLIT", [["details", "customer-b"]]]}, + {"resolve": ["blue", "FALLTHROUGH", [["details", "else"]]]}, + ] +} + +# variants named "true", "false" and "1", which only a coerced variant can select +COERCED_KEYS = { + "flags": { + "coerced": { + "state": "ENABLED", + "defaultVariant": "false", + "variants": {"true": "#00FF00", "false": "#FF0000", "1": "#0000FF"}, + } + } +} + + +def coerced_flag(targeting: dict) -> dict: + flags = json.loads(json.dumps(COERCED_KEYS)) + flags["flags"]["coerced"]["targeting"] = targeting + return flags + + +@pytest.mark.parametrize( + ("flags", "context", "variant", "reason", "metadata"), + [ + pytest.param( + resolve_flag({"resolve": ["red"]}), + None, + "red", + Reason.TARGETING_MATCH, + {}, + id="whole rule keeps targeting match", + ), + pytest.param( + resolve_flag({"resolve": ["blue", "ALLOWLIST"]}), + None, + "blue", + "ALLOWLIST", + {}, + id="custom reason", + ), + # the reason is free-form; flagd's own reason names must not change the value or variant + *( + pytest.param( + resolve_flag({"resolve": ["blue", reason]}), + None, + "blue", + reason, + {}, + id=f"{reason} reason keeps value and variant", + ) + for reason in ("FALLBACK", "DISABLED", "ERROR", "DEFAULT", "STATIC") + ), + pytest.param( + resolve_flag({"resolve": ["green", None, [["details", "pilot"]]]}), + None, + "green", + Reason.TARGETING_MATCH, + {"details": "pilot"}, + id="null reason keeps targeting match and adds metadata", + ), + pytest.param( + resolve_flag(NESTED_BRANCHES), + {"id": "a"}, + "red", + "ALLOWLIST", + {"details": "customer-a"}, + id="nested if first branch", + ), + pytest.param( + resolve_flag(NESTED_BRANCHES), + {"id": "b"}, + "red", + "SPLIT", + {"details": "customer-b"}, + id="nested if second branch", + ), + pytest.param( + resolve_flag(NESTED_BRANCHES), + {"id": "z"}, + "blue", + "FALLTHROUGH", + {"details": "else"}, + id="nested if else branch", + ), + pytest.param( + resolve_flag({"if": [{"resolve": ["green", "ALLOWLIST"]}]}), + None, + "green", + "ALLOWLIST", + {}, + id="single if clause", + ), + # a fixed bucketing value and zero weights pick the bucket deterministically + pytest.param( + resolve_flag( + { + "fractional": [ + "key", + [{"resolve": ["red", "SPLIT", [["details", "treatment"]]]}, 1], + [{"resolve": ["blue", "SPLIT", [["details", "holdback"]]]}, 0], + ] + } + ), + None, + "red", + "SPLIT", + {"details": "treatment"}, + id="fractional bucket variant", + ), + pytest.param( + resolve_flag( + {"fractional": ["key", [{"resolve": ["red", "SPLIT"]}, 0], ["blue", 1]]} + ), + None, + "blue", + Reason.TARGETING_MATCH, + {}, + id="fractional mixes plain and resolve buckets", + ), + pytest.param( + resolve_flag( + { + "fractional": [ + "key", + [{"resolve": ["red", "SPLIT"]}, 0], + [{"cat": ["gr", "een"]}, 1], + ] + } + ), + None, + "green", + Reason.TARGETING_MATCH, + {}, + id="fractional computed plain bucket variant", + ), + pytest.param( + resolve_flag( + { + "fractional": [ + "key", + [{"resolve": [{"cat": ["r", "ed"]}, "SPLIT"]}, 1], + ["blue", 0], + ] + } + ), + None, + "red", + "SPLIT", + {}, + id="fractional resolve with computed variant", + ), + pytest.param( + resolve_flag( + { + "if": [ + True, + { + "fractional": [ + "key", + [ + { + "resolve": [ + "green", + "SPLIT", + [["details", "treatment"]], + ] + }, + 1, + ], + ] + }, + "blue", + ] + } + ), + None, + "green", + "SPLIT", + {"details": "treatment"}, + id="fractional in an if result", + ), + pytest.param( + resolve_flag( + { + "resolve": [ + {"if": [True, "red", "blue"]}, + {"cat": ["ALLOW", "LIST"]}, + [["details", {"cat": ["us-", {"var": "bucket"}]}]], + ] + } + ), + {"bucket": "10pct"}, + "red", + "ALLOWLIST", + {"details": "us-10pct"}, + id="computed variant reason and details", + ), + pytest.param( + resolve_flag({"resolve": ["red", None, {"var": "meta"}]}), + {"meta": [["details", "from-context"]]}, + "red", + Reason.TARGETING_MATCH, + {"details": "from-context"}, + id="computed metadata list", + ), + pytest.param( + resolve_flag({"resolve": ["red", None, [{"var": "pair"}]]}), + {"pair": ["details", "from-context"]}, + "red", + Reason.TARGETING_MATCH, + {"details": "from-context"}, + id="computed metadata pair", + ), + pytest.param( + resolve_flag( + { + "resolve": [ + "red", + None, + [[{"cat": ["az-", {"var": "zone"}]}, "served"]], + ] + } + ), + {"zone": "a"}, + "red", + Reason.TARGETING_MATCH, + {"az-a": "served"}, + id="computed metadata key", + ), + pytest.param( + resolve_flag( + { + "resolve": [ + "red", + "SPLIT", + [ + ["percent", 10], + ["share", {"/": [{"var": "hits"}, 4]}], + ["enabled", False], + ], + ] + } + ), + {"hits": 1}, + "red", + "SPLIT", + {"percent": 10, "share": 0.25, "enabled": False}, + id="numeric and boolean metadata", + ), + pytest.param( + resolve_flag( + {"$ref": "picked"}, + **{"$evaluators": {"picked": {"resolve": ["blue", "ALLOWLIST"]}}}, + ), + None, + "blue", + "ALLOWLIST", + {}, + id="shared evaluator", + ), + # a multi-key object is literal data to JsonLogic, so a nested "resolve" key is just data + pytest.param( + resolve_flag( + { + "if": [ + { + "some": [ + [{"payload": {"resolve": "eu"}, "tag": 1}], + {"==": [{"var": "payload.resolve"}, "eu"]}, + ] + }, + {"resolve": ["red", "EU"]}, + "blue", + ] + } + ), + None, + "red", + "EU", + {}, + id="literal data keeps a nested resolve key", + ), + ], +) +def test_resolve(flags, context, variant, reason, metadata) -> None: + result = evaluate(flags, context) + assert result.variant == variant + assert result.value == VARIANTS[variant] + assert result.reason == reason + assert result.error_code is None + for key, value in metadata.items(): + assert result.flag_metadata[key] == value + assert type(result.flag_metadata[key]) is type(value) + + +@pytest.mark.parametrize( + ("targeting", "context", "variant"), + [ + pytest.param({"resolve": [True, "BETA"]}, None, "true", id="boolean variant"), + pytest.param( + {"resolve": [{"var": "pick"}]}, {"pick": 1}, "1", id="computed number" + ), + ], +) +def test_resolve_coerces_variant_like_a_plain_result( + targeting, context, variant +) -> None: + result = evaluate(coerced_flag(targeting), context, flag_key="coerced") + assert result.variant == variant + + +def test_rule_metadata_wins_over_flag_and_flag_set() -> None: + flags = resolve_flag( + {"resolve": ["red", "ALLOWLIST", [["details", "rule"], ["onlyRule", True]]]}, + metadata={"details": "set", "owner": "set", "team": "set"}, + ) + flags["flags"]["color"]["metadata"] = {"details": "flag", "owner": "flag"} + result = evaluate(flags) + assert result.flag_metadata == { + "details": "rule", + "owner": "flag", + "team": "set", + "onlyRule": True, + } + + +LITERAL_RESERVED = { + "resolve": [ + "red", + None, + [["flagSetId", "rule"], ["version", "rule"], ["details", "rule"]], + ] +} +COMPUTED_RESERVED = { + "resolve": [ + "red", + None, + [ + [{"cat": ["flagSet", "Id"]}, "rule"], + [{"var": "key"}, "rule"], + ["details", "rule"], + ], + ] +} + + +# flagSetId and version belong to flag set metadata, so rule metadata can't override or add them, +# whether the key is literal or computed +@pytest.mark.parametrize( + ("targeting", "flag_set_metadata", "expected"), + [ + pytest.param( + LITERAL_RESERVED, + {"flagSetId": "set", "version": "1"}, + {"flagSetId": "set", "version": "1"}, + id="literal keys keep flag set values", + ), + pytest.param( + COMPUTED_RESERVED, + {"flagSetId": "set", "version": "1"}, + {"flagSetId": "set", "version": "1"}, + id="computed keys keep flag set values", + ), + pytest.param(LITERAL_RESERVED, None, {}, id="literal keys are not added"), + pytest.param(COMPUTED_RESERVED, None, {}, id="computed keys are not added"), + ], +) +def test_resolve_reserved_metadata_keys(targeting, flag_set_metadata, expected) -> None: + extra = {} if flag_set_metadata is None else {"metadata": flag_set_metadata} + result = evaluate(resolve_flag(targeting, **extra), {"key": "version"}) + assert result.variant == "red" + assert result.flag_metadata["details"] == "rule" + for key in ("flagSetId", "version"): + if key in expected: + assert result.flag_metadata[key] == expected[key] + else: + assert key not in result.flag_metadata + + +# a computed ratio that is +Inf for total 0 and NaN for 0/0 +NON_FINITE_METADATA = { + "resolve": [ + "red", + "SPLIT", + [["share", {"/": [{"var": "hits"}, {"var": "total"}]}]], + ] +} + + +# malformed computed arguments return null like the other custom operators, +# so the default variant is selected +@pytest.mark.parametrize( + ("targeting", "context"), + [ + pytest.param({"resolve": [{"var": "pick"}]}, None, id="null variant"), + pytest.param( + {"resolve": [{"var": "pick"}]}, {"pick": {"a": 1}}, id="object variant" + ), + pytest.param( + {"resolve": [{"var": "pick"}]}, {"pick": float("nan")}, id="NaN variant" + ), + pytest.param( + {"resolve": ["red", {"var": "why"}]}, {"why": 1}, id="non-string reason" + ), + pytest.param( + {"resolve": ["red", None, [[{"var": "key"}, "x"]]]}, + {"key": 1}, + id="non-string metadata key", + ), + pytest.param( + {"resolve": ["red", None, [["details", {"var": "obj"}]]]}, + {"obj": {"a": 1}}, + id="non-primitive metadata value", + ), + pytest.param( + {"resolve": ["red", None, [["details", {"var": "missing"}]]]}, + None, + id="null metadata value", + ), + pytest.param( + {"resolve": ["red", None, {"var": "meta"}]}, + {"meta": "nope"}, + id="metadata not a list", + ), + pytest.param( + {"resolve": ["red", None, [{"var": "pair"}]]}, + {"pair": ["details"]}, + id="metadata pair of one", + ), + pytest.param( + {"if": [True, {"resolve": [{"var": "pick"}]}, "blue"]}, + None, + id="inside an if result", + ), + pytest.param( + {"fractional": ["key", [{"resolve": [{"var": "pick"}]}, 1], ["blue", 0]]}, + None, + id="inside a fractional bucket", + ), + pytest.param(NON_FINITE_METADATA, {"hits": 1, "total": 0}, id="+Inf metadata"), + pytest.param(NON_FINITE_METADATA, {"hits": 0, "total": 0}, id="NaN metadata"), + ], +) +def test_resolve_malformed_computed_arguments(targeting, context) -> None: + result = evaluate(resolve_flag(targeting), context) + assert result.value == "#FFFF00" + assert result.variant == "yellow" + assert result.reason == Reason.DEFAULT + assert "share" not in result.flag_metadata + assert "details" not in result.flag_metadata + json.dumps(result.flag_metadata, allow_nan=False) + + +# variant keys are never empty, so an empty variant is missing too +@pytest.mark.parametrize( + ("targeting", "context"), + [ + pytest.param({"resolve": ["missing"]}, None, id="missing variant"), + pytest.param({"resolve": ["", "FALLBACK"]}, None, id="empty variant"), + pytest.param( + {"resolve": [{"var": "pick"}, "FALLBACK"]}, + {"pick": ""}, + id="computed empty variant", + ), + ], +) +def test_resolve_missing_variant_fails_like_a_plain_string(targeting, context) -> None: + with pytest.raises(GeneralError): + evaluate(resolve_flag(targeting), context) + + +def test_resolve_reason_does_not_skip_type_check() -> None: + core = FlagdCore() + core.set_flags(resolve_flag({"resolve": ["red", "DISABLED"]})) + with pytest.raises(TypeMismatchError): + core.resolve_boolean_value("color", False) + + +# context data shaped like an operator result must not be treated as one +def test_context_cannot_forge_a_resolve_result() -> None: + context = { + "pick": { + "variant": "red", + "reason": "INJECTED", + "metadata": {"flagSetId": "spoofed"}, + } + } + with pytest.raises(GeneralError): + evaluate(resolve_flag({"var": "pick"}), context) + + +INJECTED = {"pick": {"resolve": ["red", "INJECTED", [["flagSetId", "spoofed"]]]}} + + +# JsonLogic returns a single-key context map like {"resolve": [...]} from a branch as a value +# and never applies it, so the context can't call resolve; the map is just an invalid variant +@pytest.mark.parametrize( + "targeting", + [ + pytest.param({"if": [True, {"var": "pick"}, "blue"]}, id="nested if"), + pytest.param({"if": [False, "blue", {"var": "pick"}]}, id="nested if else"), + pytest.param({"?:": [True, {"var": "pick"}, "blue"]}, id="ternary"), + pytest.param( + {"fractional": ["key", [{"var": "pick"}, 1]]}, id="fractional bucket" + ), + ], +) +def test_context_cannot_invoke_resolve(targeting) -> None: + with pytest.raises(GeneralError): + evaluate(resolve_flag(targeting), INJECTED) + + +# as a resolve variant the map is malformed, so the default variant is selected +def test_context_cannot_invoke_resolve_inside_resolve() -> None: + result = evaluate( + resolve_flag({"resolve": [{"if": [True, {"var": "pick"}, "blue"]}]}), INJECTED + ) + assert result.variant == "yellow" + assert result.reason == Reason.DEFAULT + assert "flagSetId" not in result.flag_metadata + + +class TestResolveOperator: + def test_all_arguments(self) -> None: + assert resolve({}, "red", "ALLOWLIST", [["details", "x"], ["n", 2]]) == ( + ResolveResult("red", "ALLOWLIST", {"details": "x", "n": 2}) + ) + + def test_variant_only(self) -> None: + assert resolve({}, "red") == ResolveResult("red") + + @pytest.mark.parametrize( + "args", + [ + pytest.param((), id="no arguments"), + pytest.param(("red", None, [], "extra"), id="too many arguments"), + pytest.param(("red", None, "nope"), id="metadata not a list"), + pytest.param(("red", None, [["n", float("inf")]]), id="infinite metadata"), + ], + ) + def test_malformed_arguments_return_none(self, args) -> None: + assert resolve({}, *args) is None diff --git a/tools/openfeature-flagd-core/tests/test_targeting.py b/tools/openfeature-flagd-core/tests/test_targeting.py index 4e016b660..8554dfa4e 100644 --- a/tools/openfeature-flagd-core/tests/test_targeting.py +++ b/tools/openfeature-flagd-core/tests/test_targeting.py @@ -1,5 +1,10 @@ +import math + +import pytest + from openfeature.contrib.tools.flagd.core.targeting import targeting from openfeature.contrib.tools.flagd.core.targeting.custom_ops import ( + divide, ends_with, fractional, normalize_numbers, @@ -271,3 +276,29 @@ def test_out_of_range_float_stays_float(self) -> None: norm = normalize_numbers(huge) assert norm == huge assert isinstance(norm, float) + + +class TestDivide: + def test_divides(self) -> None: + assert divide({}, 1, 4) == 0.25 + + @pytest.mark.parametrize( + ("dividend", "divisor", "expected"), + [ + (1, 0, math.inf), + (-1, 0, -math.inf), + (1, -0.0, -math.inf), + (2.5, 0.0, math.inf), + ], + ) + def test_divide_by_zero_is_infinite(self, dividend, divisor, expected) -> None: + assert divide({}, dividend, divisor) == expected + + @pytest.mark.parametrize("dividend", [0, 0.0, math.nan]) + def test_divide_zero_or_nan_by_zero_is_nan(self, dividend) -> None: + assert math.isnan(divide({}, dividend, 0)) + + def test_targeting_divides_by_zero_like_javascript(self) -> None: + rule = {"if": [{">": [{"/": [{"var": "hits"}, 0]}, 1]}, "big", "small"]} + ctx = EvaluationContext(attributes={"hits": 1}) + assert targeting("test-flag", rule, ctx) == "big"