fixup: make tests run, only 4 tests are missing now

Signed-off-by: Simon Schrottner <[email protected]>

Author: aepfli

.gitmodules

@@ -4,3 +4,6 @@
 [submodule "providers/openfeature-provider-flagd/test-harness"]
 	path = providers/openfeature-provider-flagd/test-harness
 	url = [email protected]:open-feature/flagd-testbed.git
+[submodule "providers/openfeature-provider-flagd/spec"]
+	path = providers/openfeature-provider-flagd/spec
+	url = https://github.com/open-feature/spec

providers/openfeature-provider-flagd/pyproject.toml

@@ -37,6 +37,9 @@ dependencies = [
   "coverage[toml]>=6.5",
   "pytest",
   "pytest-bdd",
+  "testcontainers",
+  "asserts",
+  "grpc_health",
 ]
 post-install-commands = [
   "./scripts/gen_protos.sh"

providers/openfeature-provider-flagd/spec

@@ -0,0 +1,54 @@
+import time
+from time import sleep
+
+import grpc
+from grpc_health.v1 import health_pb2, health_pb2_grpc
+from testcontainers.core.container import DockerContainer
+from testcontainers.core.utils import raise_for_deprecated_parameter
+from testcontainers.core.waiting_utils import wait_container_is_ready
+
+HEALTH_CHECK = 8014
+
+
+class FlagDContainer(DockerContainer):
+    def __init__(
+        self,
+        image: str = "ghcr.io/open-feature/flagd-testbed:v0.5.10",
+        port: int = 8013,
+        **kwargs,
+    ) -> None:
+        raise_for_deprecated_parameter(kwargs, "port_to_expose", "port")
+        super().__init__(image, **kwargs)
+        self.port = port
+        self.with_exposed_ports(self.port, HEALTH_CHECK)
+
+    def start(self) -> "FlagDContainer":
+        super().start()
+        time.sleep(1)
+        self._checker(self.get_container_host_ip(), self.get_exposed_port(HEALTH_CHECK))
+        return self
+
+    @wait_container_is_ready(ConnectionError)
+    def _checker(self, host: str, port: str) -> None:
+        with grpc.insecure_channel(host + ":" + port) as channel:
+            health_stub = health_pb2_grpc.HealthStub(channel)
+
+            def health_check_call(stub: health_pb2_grpc.HealthStub):
+                request = health_pb2.HealthCheckRequest()
+                resp = stub.Check(request)
+                if resp.status == health_pb2.HealthCheckResponse.SERVING:
+                    return True
+                elif resp.status == health_pb2.HealthCheckResponse.NOT_SERVING:
+                    return False
+
+            # Should succeed
+            # Check health status every 1 second for 30 seconds
+            ok = False
+            for _ in range(30):
+                ok = health_check_call(health_stub)
+                if ok:
+                    break
+                sleep(1)
+
+            if not ok:
+                raise ConnectionError("flagD not ready in time")

providers/openfeature-provider-flagd/tests/e2eGherkin/flagd_container.py

@@ -2,13 +2,16 @@
 import typing
 
 import pytest
+from asserts import assert_equal
 from pytest_bdd import given, parsers, then, when
 from tests.e2e.parsers import to_bool
 
 from openfeature import api
 from openfeature.client import OpenFeatureClient
 from openfeature.evaluation_context import EvaluationContext
 from openfeature.event import EventDetails, ProviderEvent
+from openfeature.flag_evaluation import ErrorCode, FlagEvaluationDetails, Reason
+from openfeature.provider import ProviderStatus
 
 JsonPrimitive = typing.Union[str, bool, float, int]
 
@@ -19,44 +22,44 @@ def evaluation_context() -> EvaluationContext:
 
 
 @given("a flagd provider is set", target_fixture="client")
+@given("a provider is registered", target_fixture="client")
 def setup_provider() -> OpenFeatureClient:
-    return api.get_client()
+    client = api.get_client()
+    wait_for(lambda: client.get_provider_status() == ProviderStatus.READY)
+    return client
 
 
 @when(
     parsers.cfparse(
-        'a zero-value boolean flag with key "{key}" is evaluated with default value "{default:bool}"',
-        extra_types={"bool": to_bool},
+        'a {ignored:s?}boolean flag with key "{key}" is evaluated with {details:s?}default value "{default:bool}"',
+        extra_types={"bool": to_bool, "s": str},
     ),
     target_fixture="key_and_default",
 )
 @when(
     parsers.cfparse(
-        'a zero-value string flag with key "{key}" is evaluated with default value "{default}"',
+        'a {ignored:s?}string flag with key "{key}" is evaluated with {details:s?}default value "{default}"',
+        extra_types={"s": str},
     ),
     target_fixture="key_and_default",
 )
 @when(
     parsers.cfparse(
-        'a string flag with key "{key}" is evaluated with default value "{default}"'
+        'a{ignored:s?} integer flag with key "{key}" is evaluated with {details:s?}default value {default:d}',
+        extra_types={"s": str},
     ),
     target_fixture="key_and_default",
 )
 @when(
     parsers.cfparse(
-        'a zero-value integer flag with key "{key}" is evaluated with default value {default:d}',
+        'a {ignored:s?}float flag with key "{key}" is evaluated with {details:s?}default value {default:f}',
+        extra_types={"s": str},
     ),
     target_fixture="key_and_default",
 )
 @when(
     parsers.cfparse(
-        'an integer flag with key "{key}" is evaluated with default value {default:d}',
-    ),
-    target_fixture="key_and_default",
-)
-@when(
-    parsers.cfparse(
-        'a zero-value float flag with key "{key}" is evaluated with default value {default:f}',
+        'a string flag with key "{key}" is evaluated as an integer, with details and a default value {default:d}',
     ),
     target_fixture="key_and_default",
 )
@@ -111,6 +114,12 @@ def update_context_nested(
     evaluation_context.attributes[outer][inner] = value
 
 
+@then(
+    parsers.cfparse(
+        'the resolved boolean value should be "{expected_value:bool}"',
+        extra_types={"bool": to_bool},
+    )
+)
 @then(
     parsers.cfparse(
         'the resolved boolean zero-value should be "{expected_value:bool}"',
@@ -125,12 +134,34 @@ def assert_boolean_value(
 ):
     key, default = key_and_default
     evaluation_result = client.get_boolean_value(key, default, evaluation_context)
-    assert evaluation_result == expected_value
+    assert_equal(evaluation_result, expected_value)
 
 
 @then(
     parsers.cfparse(
-        "the resolved integer zero-value should be {expected_value:d}",
+        'the resolved boolean details value should be "{expected_value:bool}", the variant should be "{variant}", and the reason should be "{reason}"',
+        extra_types={"bool": to_bool},
+    )
+)
+def assert_boolean_value_with_details(
+    client: OpenFeatureClient,
+    key_and_default: tuple,
+    expected_value: bool,
+    variant: str,
+    reason: str,
+    evaluation_context: EvaluationContext,
+):
+    key, default = key_and_default
+    evaluation_result = client.get_boolean_details(key, default, evaluation_context)
+    assert_equal(evaluation_result.value, expected_value)
+    assert_equal(evaluation_result.reason, reason)
+    assert_equal(evaluation_result.variant, variant)
+
+
+@then(
+    parsers.cfparse(
+        "the resolved integer {ignored:s?}value should be {expected_value:d}",
+        extra_types={"s": str},
     )
 )
 @then(parsers.cfparse("the returned value should be {expected_value:d}"))
@@ -139,15 +170,36 @@ def assert_integer_value(
     key_and_default: tuple,
     expected_value: bool,
     evaluation_context: EvaluationContext,
+):
+    key, default = key_and_default
+    evaluation_result = client.get_integer_value(key, default, evaluation_context)
+    assert_equal(evaluation_result, expected_value)
+
+
+@then(
+    parsers.cfparse(
+        'the resolved integer details value should be {expected_value:d}, the variant should be "{variant}", and the reason should be "{reason}"',
+    )
+)
+def assert_integer_value_with_details(
+    client: OpenFeatureClient,
+    key_and_default: tuple,
+    expected_value: int,
+    variant: str,
+    reason: str,
+    evaluation_context: EvaluationContext,
 ):
     key, default = key_and_default
     evaluation_result = client.get_integer_details(key, default, evaluation_context)
-    assert evaluation_result == expected_value
+    assert_equal(evaluation_result.value, expected_value)
+    assert_equal(evaluation_result.reason, reason)
+    assert_equal(evaluation_result.variant, variant)
 
 
 @then(
     parsers.cfparse(
-        "the resolved float zero-value should be {expected_value:f}",
+        "the resolved float {ignored:s?}value should be {expected_value:f}",
+        extra_types={"s": str},
     )
 )
 def assert_float_value(
@@ -158,7 +210,27 @@ def assert_float_value(
 ):
     key, default = key_and_default
     evaluation_result = client.get_float_value(key, default, evaluation_context)
-    assert evaluation_result == expected_value
+    assert_equal(evaluation_result, expected_value)
+
+
+@then(
+    parsers.cfparse(
+        'the resolved float details value should be {expected_value:f}, the variant should be "{variant}", and the reason should be "{reason}"',
+    )
+)
+def assert_float_value_with_details(
+    client: OpenFeatureClient,
+    key_and_default: tuple,
+    expected_value: float,
+    variant: str,
+    reason: str,
+    evaluation_context: EvaluationContext,
+):
+    key, default = key_and_default
+    evaluation_result = client.get_float_details(key, default, evaluation_context)
+    assert_equal(evaluation_result.value, expected_value)
+    assert_equal(evaluation_result.reason, reason)
+    assert_equal(evaluation_result.variant, variant)
 
 
 @then(parsers.cfparse('the returned value should be "{expected_value}"'))
@@ -169,8 +241,8 @@ def assert_string_value(
     evaluation_context: EvaluationContext,
 ):
     key, default = key_and_default
-    evaluation_result = client.get_string_value(key, default, evaluation_context)
-    assert evaluation_result == expected_value
+    evaluation_details = client.get_string_details(key, default, evaluation_context)
+    assert_equal(evaluation_details.value, expected_value)
 
 
 @then(
@@ -182,10 +254,98 @@ def assert_empty_string(
     client: OpenFeatureClient,
     key_and_default: tuple,
     evaluation_context: EvaluationContext,
+):
+    assert_string(client, key_and_default, evaluation_context, "")
+
+
+@then(
+    parsers.cfparse(
+        'the resolved string value should be "{expected_value}"',
+    )
+)
+def assert_string(
+    client: OpenFeatureClient,
+    key_and_default: tuple,
+    evaluation_context: EvaluationContext,
+    expected_value: str,
 ):
     key, default = key_and_default
     evaluation_result = client.get_string_value(key, default, evaluation_context)
-    assert evaluation_result == ""
+    assert_equal(evaluation_result, expected_value)
+
+
+@then(
+    parsers.cfparse(
+        "the default string value should be returned",
+    ),
+    target_fixture="evaluation_details",
+)
+def assert_default_string(
+    client: OpenFeatureClient,
+    key_and_default: tuple,
+    evaluation_context: EvaluationContext,
+) -> FlagEvaluationDetails[str]:
+    key, default = key_and_default
+    evaluation_result = client.get_string_details(key, default, evaluation_context)
+    assert_equal(evaluation_result.value, default)
+    return evaluation_result
+
+
+@then(
+    parsers.cfparse(
+        "the default integer value should be returned",
+    ),
+    target_fixture="evaluation_details",
+)
+def assert_default_integer(
+    client: OpenFeatureClient,
+    key_and_default: tuple,
+    evaluation_context: EvaluationContext,
+) -> FlagEvaluationDetails[int]:
+    key, default = key_and_default
+    evaluation_result = client.get_integer_details(key, default, evaluation_context)
+    assert_equal(evaluation_result.value, default)
+    return evaluation_result
+
+
+@then(
+    parsers.cfparse(
+        'the reason should indicate an error and the error code should indicate a missing flag with "{error}"',
+    )
+)
+@then(
+    parsers.cfparse(
+        'the reason should indicate an error and the error code should indicate a type mismatch with "{error}"',
+    )
+)
+def assert_for_error(
+    client: OpenFeatureClient,
+    evaluation_details: FlagEvaluationDetails,
+    error: str,
+):
+    assert_equal(evaluation_details.error_code, ErrorCode[error])
+    assert_equal(evaluation_details.reason, Reason.ERROR)
+
+
+@then(
+    parsers.cfparse(
+        'the resolved string details value should be "{expected_value}", the variant should be "{variant}", and the reason should be "{reason}"',
+        extra_types={"bool": to_bool},
+    )
+)
+def assert_string_value_with_details(
+    client: OpenFeatureClient,
+    key_and_default: tuple,
+    expected_value: str,
+    variant: str,
+    reason: str,
+    evaluation_context: EvaluationContext,
+):
+    key, default = key_and_default
+    evaluation_result = client.get_string_details(key, default, evaluation_context)
+    assert_equal(evaluation_result.value, expected_value)
+    assert_equal(evaluation_result.reason, reason)
+    assert_equal(evaluation_result.variant, variant)
 
 
 @then(parsers.cfparse('the returned reason should be "{reason}"'))
@@ -198,7 +358,7 @@ def assert_reason(
     """the returned reason should be <reason>."""
     key, default = key_and_default
     evaluation_result = client.get_string_details(key, default, evaluation_context)
-    assert evaluation_result.reason.value == reason
+    assert_equal(evaluation_result.reason, reason)
 
 
 provider_ready_ran = False