Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
17 changes: 15 additions & 2 deletions providers/openfeature-provider-ofrep/README.md
Original file line number Diff line number Diff line change
Expand Up @@ -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

<!-- TODO: add 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

Expand Down
Original file line number Diff line number Diff line change
@@ -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
Expand All @@ -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 (
Expand Down Expand Up @@ -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
Expand Down Expand Up @@ -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))
Comment thread
coderabbitai[bot] marked this conversation as resolved.
Resolved
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]:
Expand Down
91 changes: 91 additions & 0 deletions providers/openfeature-provider-ofrep/tests/test_provider.py
Original file line number Diff line number Diff line change
Expand Up @@ -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",
(
Expand Down
Loading