diff --git a/providers/openfeature-provider-ofrep/README.md b/providers/openfeature-provider-ofrep/README.md index cad6a584c..1326492c9 100644 --- a/providers/openfeature-provider-ofrep/README.md +++ b/providers/openfeature-provider-ofrep/README.md @@ -16,12 +16,25 @@ Instantiate a new OFREPProvider instance and configure the OpenFeature SDK to us from openfeature import api from openfeature.contrib.provider.ofrep import OFREPProvider -api.set_provider(OFREPProvider()) +api.set_provider(OFREPProvider("http://localhost:2321")) ``` ### Configuration options - +| Option | Environment variable | Description | Type | Default | +| ----------------- | -------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------ | ------- | +| `base_url` | `OFREP_ENDPOINT` | OFREP server endpoint, e.g. `http://localhost:2321` | `str` | - | +| `headers_factory` | `OFREP_HEADERS` | Headers sent with each request. The environment variable is a comma-separated list of `key=value` pairs, e.g. `Authorization=Bearer 123,X-Env=prod` | `Callable[[], dict[str, str]]` | - | +| `timeout` | `OFREP_TIMEOUT_MS` | Request timeout. The argument is in seconds, the environment variable in milliseconds | `float` | 5 s | + +Arguments passed to `OFREPProvider` take precedence over environment variables. When `headers_factory` is +given, `OFREP_HEADERS` is ignored. An unset or blank environment variable is treated as not set, and an +invalid value raises a `ValueError`. + +```python +# OFREP_ENDPOINT=http://localhost:2321 OFREP_TIMEOUT_MS=2000 +api.set_provider(OFREPProvider()) +``` ## License diff --git a/providers/openfeature-provider-ofrep/src/openfeature/contrib/provider/ofrep/__init__.py b/providers/openfeature-provider-ofrep/src/openfeature/contrib/provider/ofrep/__init__.py index f9f268f9c..4f0994f07 100644 --- a/providers/openfeature-provider-ofrep/src/openfeature/contrib/provider/ofrep/__init__.py +++ b/providers/openfeature-provider-ofrep/src/openfeature/contrib/provider/ofrep/__init__.py @@ -1,4 +1,6 @@ import logging +import math +import os import re from collections.abc import Callable, Mapping, Sequence from datetime import datetime, timedelta, timezone @@ -7,7 +9,8 @@ from urllib.parse import urljoin import requests -from requests.exceptions import JSONDecodeError +from requests.exceptions import InvalidHeader, JSONDecodeError +from requests.utils import check_header_validity from openfeature.evaluation_context import EvaluationContext from openfeature.exception import ( @@ -41,15 +44,47 @@ _HTTP_AUTH_ERRORS: dict[int, str] = {401: "unauthorized", 403: "forbidden"} +ENV_ENDPOINT = "OFREP_ENDPOINT" +ENV_HEADERS = "OFREP_HEADERS" +ENV_TIMEOUT_MS = "OFREP_TIMEOUT_MS" + +DEFAULT_TIMEOUT_SECONDS = 5.0 + +_HEADER_NAME_PATTERN = re.compile(r"^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$") + class OFREPProvider(AbstractProvider): def __init__( self, - base_url: str, + base_url: str | None = None, *, headers_factory: Callable[[], dict[str, str]] | None = None, - timeout: float = 5.0, + timeout: float | None = None, ): + """ + Arguments take precedence over the ``OFREP_ENDPOINT``, ``OFREP_HEADERS`` + and ``OFREP_TIMEOUT_MS`` environment variables. + + :param base_url: The OFREP server endpoint. Defaults to ``OFREP_ENDPOINT``. + :param headers_factory: Returns the headers to send with each request. + When set, ``OFREP_HEADERS`` is ignored. + :param timeout: Request timeout in seconds. Defaults to + ``OFREP_TIMEOUT_MS`` (milliseconds), or 5 seconds when unset. + :raises ValueError: If no endpoint is configured or an environment + variable has an invalid value. + """ + if base_url is None: + base_url = _get_env(ENV_ENDPOINT) + if base_url is None: + raise ValueError( + f"base_url is required: pass it explicitly or set {ENV_ENDPOINT}" + ) + if headers_factory is None: + env_headers = _parse_env_headers(_get_env(ENV_HEADERS)) + if env_headers: + headers_factory = lambda: dict(env_headers) # noqa: E731 + if timeout is None: + timeout = _parse_env_timeout(_get_env(ENV_TIMEOUT_MS)) self.base_url = base_url self.headers_factory = headers_factory self.timeout = timeout @@ -220,6 +255,57 @@ def _raise_for_http_status( raise OpenFeatureError(ErrorCode.GENERAL, response.text) from exception +def _get_env(name: str) -> str | None: + value = os.environ.get(name, "").strip() + return value or None + + +def _parse_env_headers(value: str | None) -> dict[str, str]: + """Parse ``key=value`` pairs separated by commas (e.g. ``a=b,c=d``).""" + headers: dict[str, str] = {} + if value is None: + return headers + for position, pair in enumerate(value.split(","), start=1): + if not pair.strip(): + continue + name, separator, header_value = pair.partition("=") + name = name.strip() + if not separator or not name: + raise ValueError( + f"Invalid {ENV_HEADERS} entry {position}: expected key=value" + ) + header_value = header_value.strip() + if not _HEADER_NAME_PATTERN.match(name): + raise ValueError( + f"Invalid {ENV_HEADERS} entry {position}: invalid header name or value" + ) + try: + check_header_validity((name, header_value)) + except InvalidHeader: + raise ValueError( + f"Invalid {ENV_HEADERS} entry {position}: invalid header name or value" + ) from None + headers[name] = header_value + return headers + + +def _parse_env_timeout(value: str | None) -> float: + """Convert ``OFREP_TIMEOUT_MS`` to seconds.""" + if value is None: + return DEFAULT_TIMEOUT_SECONDS + try: + timeout_ms = float(value) + except ValueError: + raise ValueError( + f"Invalid {ENV_TIMEOUT_MS} {value!r}: expected a number of milliseconds" + ) from None + if not math.isfinite(timeout_ms) or timeout_ms <= 0: + raise ValueError( + f"Invalid {ENV_TIMEOUT_MS} {value!r}: must be a positive number" + ) + return timeout_ms / 1000 + + def _build_request_data( evaluation_context: EvaluationContext | None, ) -> dict[str, Any]: diff --git a/providers/openfeature-provider-ofrep/tests/test_provider.py b/providers/openfeature-provider-ofrep/tests/test_provider.py index af340d4f0..5ab0e5abe 100644 --- a/providers/openfeature-provider-ofrep/tests/test_provider.py +++ b/providers/openfeature-provider-ofrep/tests/test_provider.py @@ -23,6 +23,97 @@ def test_provider_init(): ) +@pytest.fixture +def clean_env(monkeypatch): + for name in ("OFREP_ENDPOINT", "OFREP_HEADERS", "OFREP_TIMEOUT_MS"): + monkeypatch.delenv(name, raising=False) + return monkeypatch + + +def test_provider_defaults_without_env(clean_env): + provider = OFREPProvider("http://localhost:8080") + assert provider.base_url == "http://localhost:8080" + assert provider.timeout == 5.0 + assert provider.headers_factory is None + + +def test_provider_requires_endpoint(clean_env): + with pytest.raises(ValueError, match="OFREP_ENDPOINT"): + OFREPProvider() + + +def test_provider_blank_endpoint_env_is_unset(clean_env): + clean_env.setenv("OFREP_ENDPOINT", " ") + with pytest.raises(ValueError, match="OFREP_ENDPOINT"): + OFREPProvider() + + +def test_provider_config_from_env(clean_env, requests_mock): + clean_env.setenv("OFREP_ENDPOINT", "http://env-host:2321") + clean_env.setenv("OFREP_HEADERS", "Authorization=Bearer a=b, X-Test = 1 ,") + clean_env.setenv("OFREP_TIMEOUT_MS", "2500") + provider = OFREPProvider() + assert provider.base_url == "http://env-host:2321" + assert provider.timeout == 2.5 + + requests_mock.post( + "http://env-host:2321/ofrep/v1/evaluate/flags/flag_key", + json={"key": "flag_key", "reason": "STATIC", "variant": "on", "value": True}, + ) + assert provider.resolve_boolean_details("flag_key", False).value is True + sent = requests_mock.last_request + assert sent.timeout == 2.5 + assert sent.headers["Authorization"] == "Bearer a=b" + assert sent.headers["X-Test"] == "1" + + +def test_provider_arguments_take_precedence_over_env(clean_env, requests_mock): + clean_env.setenv("OFREP_ENDPOINT", "http://env-host:2321") + clean_env.setenv("OFREP_HEADERS", "X-Env=1") + clean_env.setenv("OFREP_TIMEOUT_MS", "2500") + provider = OFREPProvider( + "http://localhost:8080", + headers_factory=lambda: {"X-Arg": "2"}, + timeout=1.0, + ) + assert provider.base_url == "http://localhost:8080" + assert provider.timeout == 1.0 + + requests_mock.post( + "http://localhost:8080/ofrep/v1/evaluate/flags/flag_key", + json={"key": "flag_key", "reason": "STATIC", "variant": "on", "value": True}, + ) + provider.resolve_boolean_details("flag_key", False) + assert requests_mock.last_request.headers["X-Arg"] == "2" + assert "X-Env" not in requests_mock.last_request.headers + + +@pytest.mark.parametrize("value", ("abc", "0", "-5", "nan", "inf")) +def test_provider_invalid_timeout_env(clean_env, value): + clean_env.setenv("OFREP_TIMEOUT_MS", value) + with pytest.raises(ValueError, match="OFREP_TIMEOUT_MS"): + OFREPProvider("http://localhost:8080") + + +@pytest.mark.parametrize( + "value", + ( + "novalue", + "=value", + "a=b,broken", + "X-Test=one\r\ntwo", + "X:Test=value", + "Authorization: Bearer secret-token", + ), +) +def test_provider_invalid_headers_env(clean_env, value): + clean_env.setenv("OFREP_HEADERS", value) + with pytest.raises(ValueError, match="OFREP_HEADERS") as exc_info: + OFREPProvider("http://localhost:8080") + assert "secret-token" not in str(exc_info.value) + assert "two" not in str(exc_info.value) + + @pytest.mark.parametrize( "flag_type, resolved_value, default_value, get_method", (