feat(provider): allow injecting custom cache to Unleash client

Signed-off-by: Kiki L Hakiem <[email protected]>

Author: kikihakiem

providers/openfeature-provider-unleash/src/openfeature/contrib/provider/unleash/__init__.py

@@ -2,6 +2,7 @@
 from typing import Any, Callable, Optional, Union
 
 from UnleashClient import UnleashClient
+from UnleashClient.cache import BaseCache
 from UnleashClient.events import BaseEvent, UnleashReadyEvent
 
 from openfeature.evaluation_context import EvaluationContext
@@ -25,6 +26,8 @@ def __init__(
         app_name: str,
         api_token: str,
         environment: str = "development",
+        fetch_toggles: bool = True,
+        cache: Optional[BaseCache] = None,
     ) -> None:
         """Initialize the Unleash provider.
 
@@ -33,11 +36,14 @@ def __init__(
             app_name: The application name
             api_token: The API token for authentication
             environment: The environment to connect to (default: "development")
+            fetch_toggles: Whether to fetch toggles from server on initialization (default: True)
+            cache: Optional cache implementation to use (default: UnleashClient's default)
         """
         self.url = url
         self.app_name = app_name
         self.api_token = api_token
         self.environment = environment
+        self.cache = cache
         self.client: Optional[UnleashClient] = None
         self._status = ProviderStatus.NOT_READY
         self._last_context: Optional[EvaluationContext] = None
@@ -50,6 +56,7 @@ def __init__(
         self._tracking_manager = Tracker(self)
         self._event_manager = EventManager(self)
         self._flag_evaluator = FlagEvaluator(self)
+        self.fetch_toggles = fetch_toggles
 
     def initialize(
         self, evaluation_context: Optional[EvaluationContext] = None
@@ -66,8 +73,9 @@ def initialize(
                 environment=self.environment,
                 custom_headers={"Authorization": self.api_token},
                 event_callback=self._unleash_event_callback,
+                cache=self.cache,
             )
-            self.client.initialize_client()
+            self.client.initialize_client(fetch_toggles=self.fetch_toggles)
             self._status = ProviderStatus.READY
             self._event_manager.emit_event(ProviderEvent.PROVIDER_READY)
         except Exception as e:

providers/openfeature-provider-unleash/tests/test_provider.py

@@ -5,6 +5,32 @@
 from openfeature.provider import ProviderStatus
 
 
+# Mock feature response for testing cache functionality
+MOCK_FEATURE_RESPONSE = {
+    "version": 1,
+    "features": [
+        {
+            "name": "testFlag",
+            "description": "This is a test!",
+            "enabled": True,
+            "strategies": [{"name": "default", "parameters": {}}],
+            "createdAt": "2018-10-04T01:27:28.477Z",
+            "impressionData": True,
+        },
+        {
+            "name": "testFlag2",
+            "description": "Test flag 2",
+            "enabled": False,
+            "strategies": [
+                {"name": "gradualRolloutRandom", "parameters": {"percentage": "50"}}
+            ],
+            "createdAt": "2018-10-04T11:03:56.062Z",
+            "impressionData": False,
+        },
+    ],
+}
+
+
 def test_unleash_provider_import():
     """Test that UnleashProvider can be imported."""
     assert UnleashProvider is not None
@@ -160,3 +186,49 @@ def test_unleash_provider_flag_metadata():
         assert result.flag_metadata["app_name"] == "test-app"
 
         provider.shutdown()
+
+
+def test_unleash_provider_with_custom_cache():
+    """Test that UnleashProvider properly uses a custom cache with mocked features."""
+    from UnleashClient.cache import FileCache
+
+    # Create a custom cache with mocked features
+    custom_cache = FileCache("test-app")
+    custom_cache.bootstrap_from_dict(MOCK_FEATURE_RESPONSE)
+
+    # Create provider with custom cache
+    provider = UnleashProvider(
+        url="http://localhost:4242",
+        app_name="test-app",
+        api_token="test-token",
+        cache=custom_cache,
+        fetch_toggles=False,
+    )
+
+    # Verify cache was stored
+    assert provider.cache is custom_cache
+
+    # Initialize the provider with fetch_toggles=False to prevent server connection
+    provider.initialize()
+
+    # Verify the provider is ready
+    assert provider.get_status() == ProviderStatus.READY
+    assert provider.client is not None
+
+    # Test flag evaluation using the cached features
+    # testFlag should be enabled (True in mock data)
+    result = provider.resolve_boolean_details("testFlag", False)
+    assert result.value is True
+    assert result.reason.value == "TARGETING_MATCH"
+
+    # testFlag2 should be disabled (False in mock data)
+    result = provider.resolve_boolean_details("testFlag2", True)
+    assert result.value is False
+    assert result.reason.value == "DEFAULT"
+
+    # Test string resolution with default value for non-existent flag
+    result = provider.resolve_string_details("nonExistentFlag", "default_value")
+    assert result.value == "default_value"
+    assert result.reason.value == "DEFAULT"
+
+    provider.shutdown()