chore: Add hook support to contract tests

contract-tests/client_entity.py

@@ -3,7 +3,7 @@
 import os
 import sys
 import requests
-from typing import Optional
+from hook import PostingHook
 
 from big_segment_store_fixture import BigSegmentStoreFixture
 
@@ -52,6 +52,9 @@ def __init__(self, tag, config):
         else:
             opts["send_events"] = False
 
+        if config.get("hooks") is not None:
+            opts["hooks"] = [PostingHook(h["name"], h["callbackUri"], h.get("data", {}), h.get("errors", {})) for h in config["hooks"]["hooks"]]
+
         if config.get("bigSegments") is not None:
             big_params = config["bigSegments"]
             big_config = {

contract-tests/hook.py

@@ -0,0 +1,45 @@
+from ldclient.hook import Hook, EvaluationSeriesContext
+from ldclient.evaluation import EvaluationDetail
+
+from typing import Any, Optional
+import requests
+
+
+class PostingHook(Hook):
+    def __init__(self, name: str, callback: str, data: dict, errors: dict):
+        self.__name = name
+        self.__callback = callback
+        self.__data = data
+        self.__errors = errors
+
+    def before_evaluation(self, series_context: EvaluationSeriesContext, data: dict) -> Any:
+        return self.__post("beforeEvaluation", series_context, data, None)
+
+    def after_evaluation(self, series_context: EvaluationSeriesContext, data: Any, detail: EvaluationDetail) -> Any:
+        return self.__post("afterEvaluation", series_context, data, detail)
+
+    def __post(self, stage: str, series_context: EvaluationSeriesContext, data: Any, detail: Optional[EvaluationDetail]) -> Any:
+        if stage in self.__errors:
+            raise Exception(self.__errors[stage])
+
+        payload = {
+            'evaluationSeriesContext': {
+                'flagKey': series_context.key,
+                'context': series_context.context.to_dict(),
+                'defaultValue': series_context.default_value,
+                'method': series_context.method,
+            },
+            'evaluationSeriesData': data,
+            'stage': stage,
+        }
+
+        if detail is not None:
+            payload['evaluationDetail'] = {
+                'value': detail.value,
+                'variationIndex': detail.variation_index,
+                'reason': detail.reason,
+            }
+
+        requests.post(self.__callback, json=payload)
+
+        return {**(data or {}), **self.__data.get(stage, {})}

contract-tests/service.py

@@ -74,6 +74,7 @@ def status():
             'polling-gzip',
             'inline-context',
             'anonymous-redaction',
+            'evaluation-hooks'
         ]
     }
     return (json.dumps(body), 200, {'Content-type': 'application/json'})

ldclient/client.py

@@ -2,15 +2,14 @@
 This submodule contains the client class that provides most of the SDK functionality.
 """
 
-from typing import Optional, Any, Dict, Mapping, Union, Tuple, Callable, List
+from typing import Optional, Any, Dict, Mapping, Tuple, Callable, List
 
 from .impl import AnyNum
 
 import hashlib
 import hmac
 import threading
 import traceback
-import warnings
 
 from ldclient.config import Config
 from ldclient.context import Context
@@ -451,7 +450,7 @@ def evaluate():
             tracker = OpTracker(key, flag, context, detail, default_stage)
             return _EvaluationWithHookResult(evaluation_detail=detail, results={'default_stage': default_stage, 'tracker': tracker})
 
-        hook_result = self.__evaluate_with_hooks(key=key, context=context, default_value=default_stage, method="migration_variation", block=evaluate)
+        hook_result = self.__evaluate_with_hooks(key=key, context=context, default_value=default_stage.value, method="migration_variation", block=evaluate)
         return hook_result.results['default_stage'], hook_result.results['tracker']
 
     def _evaluate_internal(self, key: str, context: Context, default: Any, event_factory) -> Tuple[EvaluationDetail, Optional[FeatureFlag]]:
@@ -652,7 +651,7 @@ def __execute_after_evaluation(self, hooks: List[Hook], series_context: Evaluati
             for (hook, data) in reversed(list(zip(hooks, hook_data)))
         ]
 
-    def __try_execute_stage(self, method: str, hook_name: str, block: Callable[[], dict]) -> Optional[dict]:
+    def __try_execute_stage(self, method: str, hook_name: str, block: Callable[[], Any]) -> Any:
         try:
             return block()
         except BaseException as e:

ldclient/hook.py

@@ -48,7 +48,7 @@ def metadata(self) -> Metadata:
         return Metadata(name='UNDEFINED')
 
     @abstractmethod
-    def before_evaluation(self, series_context: EvaluationSeriesContext, data: dict) -> dict:
+    def before_evaluation(self, series_context: EvaluationSeriesContext, data: Any) -> Any:
         """
         The before method is called during the execution of a variation method
         before the flag value has been determined. The method is executed
@@ -63,7 +63,7 @@ def before_evaluation(self, series_context: EvaluationSeriesContext, data: dict)
         return data
 
     @abstractmethod
-    def after_evaluation(self, series_context: EvaluationSeriesContext, data: dict, detail: EvaluationDetail) -> dict:
+    def after_evaluation(self, series_context: EvaluationSeriesContext, data: Any, detail: EvaluationDetail) -> dict:
         """
         The after method is called during the execution of the variation method
         after the flag value has been determined. The method is executed