-moves everything to Java 8

lopitz · lopitz · commit 95d012638ca1 · 2022-06-21T18:52:21.000+02:00
diff --git a/.github/workflows/merge.yml b/.github/workflows/merge.yml
@@ -22,10 +22,10 @@ jobs:
 
     steps:
     - uses: actions/checkout@v3
-    - name: Set up JDK 11
+    - name: Set up JDK 8
       uses: actions/setup-java@v3
       with:
-        java-version: '11'
+        java-version: '8'
         distribution: 'temurin'
     - name: Build with Gradle
       uses: gradle/gradle-build-action@0d13054264b0bb894ded474f08ebb30921341cee
diff --git a/.github/workflows/pullrequest.yml b/.github/workflows/pullrequest.yml
@@ -22,10 +22,10 @@ jobs:
 
     steps:
       - uses: actions/checkout@v3
-      - name: Set up JDK 11
+      - name: Set up JDK 8
         uses: actions/setup-java@v3
         with:
-          java-version: '11'
+          java-version: '8'
           distribution: 'temurin'
       - name: Build with Gradle
         uses: gradle/gradle-build-action@0d13054264b0bb894ded474f08ebb30921341cee
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
@@ -21,10 +21,10 @@ jobs:
 
     steps:
     - uses: actions/checkout@v3
-    - name: Set up JDK 11
+    - name: Set up JDK 8
       uses: actions/setup-java@v3
       with:
-        java-version: '11'
+        java-version: '8'
         distribution: 'temurin'
     - name: Build with Gradle
       uses: gradle/gradle-build-action@0d13054264b0bb894ded474f08ebb30921341cee
diff --git a/lib/build.gradle b/lib/build.gradle
@@ -42,6 +42,12 @@ dependencies {
     api 'org.apache.commons:commons-math3:3.6.1'
 }
 
+java {
+    toolchain {
+        languageVersion.set(JavaLanguageVersion.of(8))
+    }
+}
+
 tasks.named('test') {
     // Use JUnit Platform for unit tests.
     useJUnitPlatform()
diff --git a/lib/src/main/java/dev/openfeature/javasdk/FlagEvaluationOptions.java b/lib/src/main/java/dev/openfeature/javasdk/FlagEvaluationOptions.java
@@ -10,5 +10,5 @@ public class FlagEvaluationOptions {
     @Singular
     List<Hook> hooks;
     @Builder.Default
-    Map<String, Object> hookHints = Map.of();
+    Map<String, Object> hookHints = new HashMap<>();
 }
diff --git a/lib/src/main/java/dev/openfeature/javasdk/HookSupport.java b/lib/src/main/java/dev/openfeature/javasdk/HookSupport.java
@@ -1,7 +1,7 @@
 package dev.openfeature.javasdk;
 
 import java.util.*;
-import java.util.function.Consumer;
+import java.util.function.*;
 import java.util.stream.Stream;
 
 import com.google.common.collect.Lists;
@@ -59,7 +59,7 @@ private <T> void executeChecked(Hook<T> hook, Consumer<Hook<T>> hookCode, String
     }
 
     public EvaluationContext beforeHooks(FlagValueType flagValueType, HookContext hookCtx, List<Hook> hooks, Map<String, Object> hints) {
-        var result = callBeforeHooks(flagValueType, hookCtx, hooks, hints);
+        Stream<EvaluationContext> result = callBeforeHooks(flagValueType, hookCtx, hooks, hints);
         return EvaluationContext.merge(hookCtx.getCtx(), collectContexts(result));
     }
 
@@ -71,7 +71,9 @@ private Stream<EvaluationContext> callBeforeHooks(FlagValueType flagValueType, H
             .filter(hook -> isHookCompatible(flagValueType, hook))
             .map(hook -> hook.before(hookCtx, hints))
             .filter(Objects::nonNull)
-            .flatMap(Optional::stream);
+            .filter(Optional::isPresent)
+            .map(Optional::get)
+            .map(EvaluationContext.class::cast);
     }
 
     //for whatever reason, an error `error: incompatible types: invalid method reference` is thrown on compilation with javac
diff --git a/lib/src/main/java/dev/openfeature/javasdk/OpenFeatureClient.java b/lib/src/main/java/dev/openfeature/javasdk/OpenFeatureClient.java
@@ -27,11 +27,11 @@ public OpenFeatureClient(OpenFeatureAPI openFeatureAPI, String name, String vers
 
     @Override
     public void addHooks(Hook... hooks) {
-        this.clientHooks.addAll(List.of(hooks));
+        this.clientHooks.addAll(Arrays.asList(hooks));
     }
 
     private <T> FlagEvaluationDetails<T> evaluateFlag(FlagValueType type, String key, T defaultValue, EvaluationContext ctx, FlagEvaluationOptions options) {
-        var flagOptions = ObjectUtils.defaultIfNull(options, () -> FlagEvaluationOptions.builder().build());
+        FlagEvaluationOptions flagOptions = ObjectUtils.defaultIfNull(options, () -> FlagEvaluationOptions.builder().build());
         FeatureProvider provider = openfeatureApi.getProvider();
         Map<String, Object> hints = Collections.unmodifiableMap(flagOptions.getHookHints());
         if (ctx == null) {
diff --git a/lib/src/test/java/dev/openfeature/javasdk/DeveloperExperienceTest.java b/lib/src/test/java/dev/openfeature/javasdk/DeveloperExperienceTest.java
@@ -33,7 +33,7 @@ class DeveloperExperienceTest {
     }
 
     private Hook<Boolean> createBooleanHook() {
-        var hook = Mockito.mock(Hook.class);
+        Hook hook = mock(Hook.class);
         when(hook.supportsFlagValueType()).thenReturn(FlagValueType.BOOLEAN);
         return hook;
     }
diff --git a/lib/src/test/java/dev/openfeature/javasdk/FlagEvaluationSpecTests.java b/lib/src/test/java/dev/openfeature/javasdk/FlagEvaluationSpecTests.java
@@ -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() {
-        var c = _client();
-        var clientHook = mockBooleanHook();
-        var invocationHook = mockBooleanHook();
+        Client c = _client();
+        Hook<Boolean> clientHook = mockBooleanHook();
+        Hook<Boolean> invocationHook = mockBooleanHook();
         c.addHooks(clientHook);
         c.getBooleanValue("key", false, null, FlagEvaluationOptions.builder()
                         .hook(invocationHook)
diff --git a/lib/src/test/java/dev/openfeature/javasdk/HookSpecTests.java b/lib/src/test/java/dev/openfeature/javasdk/HookSpecTests.java
@@ -2,6 +2,7 @@
 
 import java.util.*;
 
+import com.google.common.collect.ImmutableMap;
 import dev.openfeature.javasdk.fixtures.HookFixtures;
 import lombok.SneakyThrows;
 import org.junit.jupiter.api.*;
@@ -248,7 +249,7 @@ public void finallyAfter(HookContext<Boolean> ctx, Map<String, Object> hints) {
             })
             .build());
 
-        List<String> expectedOrder = List.of(
+        List<String> expectedOrder = Arrays.asList(
             "api before", "client before", "invocation before",
             "invocation after", "client after", "api after",
             "invocation error", "client error", "api error",
@@ -320,7 +321,7 @@ public void finallyAfter(HookContext<Boolean> ctx, Map<String, Object> hints) {
             }
         };
 
-        Map<String, Object> hh = new HashMap<>(Map.of(hintKey, "My hint value"));
+        Map<String, Object> hh = new HashMap<>(ImmutableMap.of(hintKey, "My hint value"));
 
         client.getBooleanValue("key", false, new EvaluationContext(), FlagEvaluationOptions.builder()
                 .hook(mutatingHook)
diff --git a/lib/src/test/java/dev/openfeature/javasdk/HookSupportTest.java b/lib/src/test/java/dev/openfeature/javasdk/HookSupportTest.java
@@ -15,16 +15,16 @@ class HookSupportTest implements HookFixtures {
     @Test
     @DisplayName("should merge EvaluationContexts on before hooks correctly")
     void shouldMergeEvaluationContextsOnBeforeHooksCorrectly() {
-        var baseContext = new EvaluationContext();
+        EvaluationContext baseContext = new EvaluationContext();
         baseContext.addStringAttribute("baseKey", "baseValue");
-        var hookContext = new HookContext<>("flagKey", FlagValueType.STRING, "defaultValue", baseContext, () -> "client", () -> "provider");
-        var hook1 = mockStringHook();
-        var hook2 = mockStringHook();
+        HookContext<String> hookContext = new HookContext<>("flagKey", FlagValueType.STRING, "defaultValue", baseContext, () -> "client", () -> "provider");
+        Hook<String> hook1 = mockStringHook();
+        Hook<String> hook2 = mockStringHook();
         when(hook1.before(any(), any())).thenReturn(Optional.of(evaluationContextWithValue("bla", "blubber")));
         when(hook2.before(any(), any())).thenReturn(Optional.of(evaluationContextWithValue("foo", "bar")));
-        var hookSupport = new HookSupport();
+        HookSupport hookSupport = new HookSupport();
 
-        var result = hookSupport.beforeHooks(FlagValueType.STRING, hookContext, List.of(hook1, hook2), Map.of());
+        EvaluationContext result = hookSupport.beforeHooks(FlagValueType.STRING, hookContext, Arrays.asList(hook1, hook2), Collections.emptyMap());
 
         assertThat(result.getStringAttribute("bla")).isEqualTo("blubber");
         assertThat(result.getStringAttribute("foo")).isEqualTo("bar");
@@ -35,15 +35,16 @@ void shouldMergeEvaluationContextsOnBeforeHooksCorrectly() {
     @EnumSource(value = FlagValueType.class)
     @DisplayName("should always call generic hook")
     void shouldAlwaysCallGenericHook(FlagValueType flagValueType) {
-        var genericHook = mockGenericHook();
-        var hookSupport = new HookSupport();
-        var baseContext = new EvaluationContext();
-        var hookContext = new HookContext<>("flagKey", flagValueType, createDefaultValue(flagValueType), baseContext, () -> "client", () -> "provider");
+        Hook<?> genericHook = mockGenericHook();
+        HookSupport hookSupport = new HookSupport();
+        EvaluationContext baseContext = new EvaluationContext();
+        IllegalStateException expectedException = new IllegalStateException("All fine, just a test");
+        HookContext<Object> hookContext = new HookContext<>("flagKey", flagValueType, createDefaultValue(flagValueType), baseContext, () -> "client", () -> "provider");
 
-        hookSupport.beforeHooks(flagValueType, hookContext, List.of(genericHook), Map.of());
-        hookSupport.afterHooks(flagValueType, hookContext, FlagEvaluationDetails.builder().build(), List.of(genericHook), Map.of());
-        hookSupport.afterAllHooks(flagValueType, hookContext, List.of(genericHook), Map.of());
-        hookSupport.errorHooks(flagValueType, hookContext, new IllegalStateException("All fine, just a test"), List.of(genericHook), Map.of());
+        hookSupport.beforeHooks(flagValueType, hookContext, Collections.singletonList(genericHook), Collections.emptyMap());
+        hookSupport.afterHooks(flagValueType, hookContext, FlagEvaluationDetails.builder().build(), Collections.singletonList(genericHook), Collections.emptyMap());
+        hookSupport.afterAllHooks(flagValueType, hookContext, Collections.singletonList(genericHook), Collections.emptyMap());
+        hookSupport.errorHooks(flagValueType, hookContext, expectedException, Collections.singletonList(genericHook), Collections.emptyMap());
 
         verify(genericHook).before(any(), any());
         verify(genericHook).after(any(), any(), any());
@@ -67,7 +68,7 @@ private Object createDefaultValue(FlagValueType flagValueType) {
     }
 
     private EvaluationContext evaluationContextWithValue(String key, String value) {
-        var result = new EvaluationContext();
+        EvaluationContext result = new EvaluationContext();
         result.addStringAttribute(key, value);
         return result;
     }
diff --git a/lib/src/test/java/dev/openfeature/javasdk/OpenFeatureClientTest.java b/lib/src/test/java/dev/openfeature/javasdk/OpenFeatureClientTest.java
@@ -3,7 +3,6 @@
 import java.util.*;
 
 import dev.openfeature.javasdk.fixtures.HookFixtures;
-import lombok.RequiredArgsConstructor;
 import org.junit.jupiter.api.*;
 import uk.org.lidalia.slf4jext.Level;
 import uk.org.lidalia.slf4jtest.*;
@@ -19,13 +18,13 @@ class OpenFeatureClientTest implements HookFixtures {
     @DisplayName("should not throw exception if hook has different type argument than hookContext")
     void shouldNotThrowExceptionIfHookHasDifferentTypeArgumentThanHookContext() {
         TEST_LOGGER.clear();
-        var api = mock(OpenFeatureAPI.class);
+        OpenFeatureAPI api = mock(OpenFeatureAPI.class);
         when(api.getProvider()).thenReturn(new DoSomethingProvider());
-        when(api.getApiHooks()).thenReturn(List.of(mockBooleanHook(), mockStringHook()));
+        when(api.getApiHooks()).thenReturn(Arrays.asList(mockBooleanHook(), mockStringHook()));
 
-        var client = new OpenFeatureClient(api, "name", "version");
+        OpenFeatureClient client = new OpenFeatureClient(api, "name", "version");
 
-        var actual = client.getBooleanDetails("feature key", Boolean.FALSE);
+        FlagEvaluationDetails<Boolean> actual = client.getBooleanDetails("feature key", Boolean.FALSE);
 
         assertThat(actual.getValue()).isTrue();
         assertThat(TEST_LOGGER.getLoggingEvents()).filteredOn(event -> event.getLevel().equals(Level.ERROR)).isEmpty();
diff --git a/lib/src/test/java/dev/openfeature/javasdk/internal/ObjectUtilsTest.java b/lib/src/test/java/dev/openfeature/javasdk/internal/ObjectUtilsTest.java
@@ -2,6 +2,7 @@
 
 import java.util.*;
 
+import com.google.common.collect.ImmutableMap;
 import org.junit.jupiter.api.*;
 
 import static dev.openfeature.javasdk.internal.ObjectUtils.defaultIfNull;
@@ -14,20 +15,20 @@ class GenericObject {
         @Test
         @DisplayName("should return default value if null")
         void shouldReturnDefaultValueIfNull() {
-            var defaultValue = "default";
+            String defaultValue = "default";
 
-            var actual = defaultIfNull(null, () -> defaultValue);
+            String actual = defaultIfNull(null, () -> defaultValue);
 
             assertThat(actual).isEqualTo(defaultValue);
         }
 
         @Test
         @DisplayName("should return given value if not null")
         void shouldReturnGivenValueIfNotNull() {
-            var defaultValue = "default";
-            var expectedValue = "expected";
+            String defaultValue = "default";
+            String expectedValue = "expected";
 
-            var actual = defaultIfNull(expectedValue, () -> defaultValue);
+            String actual = defaultIfNull(expectedValue, () -> defaultValue);
 
             assertThat(actual).isEqualTo(expectedValue);
         }
@@ -39,20 +40,20 @@ class ListSupport {
         @Test
         @DisplayName("should return default list if given one is null")
         void shouldReturnDefaultListIfGivenOneIsNull() {
-            var defaultValue = List.of("default");
+            List<String> defaultValue = Collections.singletonList("default");
 
-            var actual = defaultIfNull(null, () -> defaultValue);
+            List<String> actual = defaultIfNull(null, () -> defaultValue);
 
             assertThat(actual).isEqualTo(defaultValue);
         }
 
         @Test
         @DisplayName("should return given list if not null")
         void shouldReturnGivenListIfNotNull() {
-            var defaultValue = List.of("default");
-            var expectedValue = List.of("expected");
+            List<String> defaultValue = Collections.singletonList("default");
+            List<String> expectedValue = Collections.singletonList("expected");
 
-            var actual = defaultIfNull(expectedValue, () -> defaultValue);
+            List<String> actual = defaultIfNull(expectedValue, () -> defaultValue);
 
             assertThat(actual).isEqualTo(expectedValue);
         }
@@ -64,20 +65,20 @@ class MapSupport {
         @Test
         @DisplayName("should return default map if given one is null")
         void shouldReturnDefaultMapIfGivenOneIsNull() {
-            var defaultValue = Map.of("key", "default");
+            Map<String, Object> defaultValue = ImmutableMap.of("key", "default");
 
-            var actual = defaultIfNull(null, () -> defaultValue);
+            Map<String, Object> actual = defaultIfNull(null, () -> defaultValue);
 
             assertThat(actual).isEqualTo(defaultValue);
         }
 
         @Test
         @DisplayName("should return given map if not null")
         void shouldReturnGivenMapIfNotNull() {
-            var defaultValue = Map.of("key", "default");
-            var expectedValue = Map.of("key", "expected");
+            Map<String, String> defaultValue = ImmutableMap.of("key", "default");
+            Map<String, String> expectedValue = ImmutableMap.of("key", "expected");
 
-            var actual = defaultIfNull(expectedValue, () -> defaultValue);
+            Map<String, String> actual = defaultIfNull(expectedValue, () -> defaultValue);
 
             assertThat(actual).isEqualTo(expectedValue);
         }

Original file line number	Diff line number	Diff line change
`@@ -10,5 +10,5 @@ public class FlagEvaluationOptions {`
`10`	`10`	`@Singular`
`11`	`11`	`List<Hook> hooks;`
`12`	`12`	`@Builder.Default`
`13`		`- Map<String, Object> hookHints = Map.of();`
	`13`	`+ Map<String, Object> hookHints = new HashMap<>();`
`14`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ class DeveloperExperienceTest {`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`private Hook<Boolean> createBooleanHook() {`
`36`		`- var hook = Mockito.mock(Hook.class);`
	`36`	`+ Hook hook = mock(Hook.class);`
`37`	`37`	`when(hook.supportsFlagValueType()).thenReturn(FlagValueType.BOOLEAN);`
`38`	`38`	`return hook;`
`39`	`39`	`}`