fix/classcastexceptions

-introduces specialized hook interfaces for supported types
-adds a fixture for hooks for tests
-adds type safety measure for before hook call

Author: lopitz

lib/src/main/java/dev/openfeature/javasdk/BooleanHook.java

@@ -0,0 +1,9 @@
+package dev.openfeature.javasdk;
+
+public interface BooleanHook extends Hook<Boolean> {
+
+    @Override
+    default FlagValueType supportsFlagValueType() {
+        return FlagValueType.BOOLEAN;
+    }
+}

lib/src/main/java/dev/openfeature/javasdk/HookSupport.java

@@ -2,28 +2,33 @@
 
 import java.util.*;
 import java.util.function.Consumer;
+import java.util.stream.Stream;
 
 import com.google.common.collect.Lists;
-import lombok.*;
+import lombok.RequiredArgsConstructor;
 import org.slf4j.Logger;
 
 @RequiredArgsConstructor
 class HookSupport {
 
     private final Logger log;
 
+    @SuppressWarnings({"unchecked", "rawtypes"})
     public void errorHooks(FlagValueType flagValueType, HookContext hookCtx, Exception e, List<Hook> hooks, Map<String, Object> hints) {
         executeHooks(flagValueType, hooks, "error", hook -> hook.error(hookCtx, e, hints));
     }
 
+    @SuppressWarnings({"unchecked", "rawtypes"})
     public void afterAllHooks(FlagValueType flagValueType, HookContext hookCtx, List<Hook> hooks, Map<String, Object> hints) {
         executeHooks(flagValueType, hooks, "finally", hook -> hook.finallyAfter(hookCtx, hints));
     }
 
+    @SuppressWarnings({"unchecked", "rawtypes"})
     public void afterHooks(FlagValueType flagValueType, HookContext hookContext, FlagEvaluationDetails details, List<Hook> hooks, Map<String, Object> hints) {
-        executeHooksUnsafe(flagValueType, hooks, hook -> hook.after(hookContext, details, hints));
+        executeHooksUnchecked(flagValueType, hooks, hook -> hook.after(hookContext, details, hints));
     }
 
+    @SuppressWarnings({"unchecked", "rawtypes"})
     private <T> void executeHooks(
         FlagValueType flagValueType, List<Hook> hooks,
         String hookMethod,
@@ -35,7 +40,8 @@ private <T> void executeHooks(
             .forEach(hook -> executeChecked(hook, hookCode, hookMethod));
     }
 
-    private <T> void executeHooksUnsafe(
+    @SuppressWarnings("rawtypes")
+    private <T> void executeHooksUnchecked(
         FlagValueType flagValueType, List<Hook> hooks,
         Consumer<Hook<T>> hookCode
     ) {
@@ -53,17 +59,28 @@ private <T> void executeChecked(Hook<T> hook, Consumer<Hook<T>> hookCode, String
         }
     }
 
-    public EvaluationContext beforeHooks(HookContext hookCtx, List<Hook> hooks, Map<String, Object> hints) {
+    @SuppressWarnings("rawtypes")
+    public EvaluationContext beforeHooks(FlagValueType flagValueType, HookContext hookCtx, List<Hook> hooks, Map<String, Object> hints) {
+        var result = callBeforeHooks(flagValueType, hookCtx, hooks, hints);
+        return EvaluationContext.merge(hookCtx.getCtx(), collectContexts(result));
+    }
+
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    private Stream<EvaluationContext> callBeforeHooks(FlagValueType flagValueType, HookContext hookCtx, List<Hook> hooks, Map<String, Object> hints) {
         // These traverse backwards from normal.
-        EvaluationContext ctx = hookCtx.getCtx();
-        for (Hook hook : Lists.reverse(hooks)) {
-            Optional<EvaluationContext> newCtx = hook.before(hookCtx, hints);
-            if (newCtx != null && newCtx.isPresent()) {
-                ctx = EvaluationContext.merge(ctx, newCtx.get());
-                hookCtx = hookCtx.withCtx(ctx);
-            }
-        }
-        return ctx;
+        return Lists
+            .reverse(hooks)
+            .stream()
+            .filter(hook -> hook.supportsFlagValueType() == flagValueType)
+            .map(hook -> hook.before(hookCtx, hints))
+            .filter(Objects::nonNull)
+            .flatMap(Optional::stream);
     }
 
+    //for whatever reason, an error `error: incompatible types: invalid method reference` is thrown on compilation with javac
+    //when the reduce call is appended directly as stream call chain above. moving it to its own method works however...
+    private EvaluationContext collectContexts(Stream<EvaluationContext> result) {
+        return result
+            .reduce(new EvaluationContext(), EvaluationContext::merge, EvaluationContext::merge);
+    }
 }

lib/src/main/java/dev/openfeature/javasdk/IntegerHook.java

@@ -0,0 +1,9 @@
+package dev.openfeature.javasdk;
+
+public interface IntegerHook extends Hook<Integer> {
+
+    @Override
+    default FlagValueType supportsFlagValueType() {
+        return FlagValueType.INTEGER;
+    }
+}

lib/src/main/java/dev/openfeature/javasdk/OpenFeatureClient.java

@@ -50,7 +50,7 @@ private <T> FlagEvaluationDetails<T> evaluateFlag(FlagValueType type, String key
 
         FlagEvaluationDetails<T> details = null;
         try {
-            EvaluationContext ctxFromHook = hookSupport.beforeHooks(hookCtx, mergedHooks, hints);
+            EvaluationContext ctxFromHook = hookSupport.beforeHooks(type, hookCtx, mergedHooks, hints);
             EvaluationContext invocationContext = EvaluationContext.merge(ctxFromHook, ctx);
 
             ProviderEvaluation<T> providerEval = (ProviderEvaluation<T>) createProviderEvaluation(type, key, defaultValue, options, provider, invocationContext);

lib/src/main/java/dev/openfeature/javasdk/StringHook.java

@@ -0,0 +1,9 @@
+package dev.openfeature.javasdk;
+
+public interface StringHook extends Hook<String> {
+
+    @Override
+    default FlagValueType supportsFlagValueType() {
+        return FlagValueType.STRING;
+    }
+}

lib/src/test/java/dev/openfeature/javasdk/FlagEvaluationSpecTests.java

@@ -1,7 +1,7 @@
 package dev.openfeature.javasdk;
 
+import dev.openfeature.javasdk.fixtures.HookFixtures;
 import org.junit.jupiter.api.*;
-import org.slf4j.*;
 import uk.org.lidalia.slf4jtest.*;
 
 import java.util.List;
@@ -10,7 +10,7 @@
 import static org.junit.jupiter.api.Assertions.*;
 import static org.mockito.Mockito.*;
 
-class FlagEvaluationSpecTests {
+class FlagEvaluationSpecTests implements HookFixtures {
 
     private static final TestLogger TEST_LOGGER = TestLoggerFactory.getTestLogger(OpenFeatureClient.class);
 
@@ -143,9 +143,9 @@ private Client _client() {
 
     @Specification(number="1.5.1", text="The evaluation options structure's hooks field denotes an ordered collection of hooks that the client MUST execute for the respective flag evaluation, in addition to those already configured.")
     @Test void hooks() {
-        Client c = _client();
-        Hook clientHook = mock(Hook.class);
-        Hook invocationHook = mock(Hook.class);
+        var c = _client();
+        var clientHook = mockBooleanHook();
+        var invocationHook = mockBooleanHook();
         c.addHooks(clientHook);
         c.getBooleanValue("key", false, null, FlagEvaluationOptions.builder()
                         .hook(invocationHook)