feat: add hook support test to check if data is passed between stages

Author: alexandraoberaigner

src/test/java/dev/openfeature/sdk/HookSupportTest.java

@@ -9,6 +9,7 @@
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import org.junit.jupiter.api.DisplayName;
@@ -89,6 +90,32 @@ void shouldAlwaysCallGenericHook(FlagValueType flagValueType) {
         verify(genericHook).error(any(), any(), any());
     }
 
+    @ParameterizedTest
+    @EnumSource(value = FlagValueType.class)
+    @DisplayName("should pass hook data only between stages")
+    void shouldPassHookDataBetweenStages(FlagValueType flagValueType) {
+        HookSupport hookSupport = new HookSupport();
+        EvaluationContext baseContext = new ImmutableContext();
+        HookContext<Object> hookContext = HookContext.<Object>builder()
+                .flagKey("flagKey")
+                .type(flagValueType)
+                .defaultValue(createDefaultValue(flagValueType))
+                .ctx(baseContext)
+                .clientMetadata(() -> "client")
+                .providerMetadata(() -> "provider")
+                .build();
+
+        TestHook testHook1 = new TestHook("test-key", "value-1");
+        TestHook testHook2 = new TestHook("test-key", 2);
+
+        hookSupport.beforeHooks(flagValueType, hookContext, List.of(testHook1, testHook2), Collections.emptyMap());
+
+        hookSupport.afterAllHooks(flagValueType, hookContext, new FlagEvaluationDetails<>(), List.of(testHook1, testHook2), Collections.emptyMap());
+
+        assertThat(testHook1.onFinallyAfterValue).isEqualTo("value-1");
+        assertThat(testHook2.onFinallyAfterValue).isEqualTo(2);
+    }
+
     private Object createDefaultValue(FlagValueType flagValueType) {
         switch (flagValueType) {
             case INTEGER:
@@ -113,32 +140,29 @@ private EvaluationContext evaluationContextWithValue(String key, String value) {
         return baseContext;
     }
 
-    private static class TestHook implements Hook<String> {
-        boolean beforeCalled = false;
-        boolean afterCalled = false;
-        boolean errorCalled = false;
-        boolean finallyCalled = false;
+    private static class TestHook implements Hook {
 
-        @Override
-        public Optional<EvaluationContext> before(HookContext<String> ctx, Map<String, Object> hints) {
-            beforeCalled = true;
-            return Optional.empty();
-        }
+        private final String key;
+        private final Object value;
 
-        @Override
-        public void after(HookContext<String> ctx, FlagEvaluationDetails<String> details, Map<String, Object> hints) {
-            afterCalled = true;
+        Object onAfterValue;
+        Object onErrorValue;
+        Object onFinallyAfterValue;
+
+        TestHook(String key, Object value) {
+            this.key = key;
+            this.value = value;
         }
 
         @Override
-        public void error(HookContext<String> ctx, Exception error, Map<String, Object> hints) {
-            errorCalled = true;
+        public Optional<EvaluationContext> before(HookContext ctx, Map hints) {
+            ctx.getHookData().set(key, value);
+            return Optional.empty();
         }
 
         @Override
-        public void finallyAfter(
-                HookContext<String> ctx, FlagEvaluationDetails<String> details, Map<String, Object> hints) {
-            finallyCalled = true;
+        public void finallyAfter(HookContext ctx, FlagEvaluationDetails details, Map hints) {
+            onFinallyAfterValue = ctx.getHookData().get(key);
         }
     }
 }