use lombok delegate, add tests and fix codestyle

Signed-off-by: christian.lutnik <[email protected]>

Author: chrfwow

src/main/java/dev/openfeature/sdk/EventProvider.java

@@ -2,7 +2,6 @@
 
 import dev.openfeature.sdk.internal.TriConsumer;
 
-import javax.annotation.Nullable;
 
 /**
  * Abstract EventProvider. Providers must extend this class to support events.
@@ -17,9 +16,9 @@
  * @see FeatureProvider
  */
 public abstract class EventProvider implements FeatureProvider {
-    private @Nullable EventProviderListener eventProviderListener;
+    private EventProviderListener eventProviderListener;
 
-    void setEventProviderListener(@Nullable EventProviderListener eventProviderListener) {
+    void setEventProviderListener(EventProviderListener eventProviderListener) {
         this.eventProviderListener = eventProviderListener;
     }
 

src/main/java/dev/openfeature/sdk/FeatureProvider.java

@@ -56,16 +56,15 @@ default void shutdown() {
     }
 
     /**
-     * @deprecated State is handled by the SDK internally.
-     * <p>
      * Returns a representation of the current readiness of the provider.
      * If the provider needs to be initialized, it should return {@link ProviderState#NOT_READY}.
      * If the provider is in an error state, it should return {@link ProviderState#ERROR}.
      * If the provider is functioning normally, it should return {@link ProviderState#READY}.
-     * 
+     *
      * <p><i>Providers which do not implement this method are assumed to be ready immediately.</i></p>
-     * 
+     *
      * @return ProviderState
+     * @deprecated The state is handled by the SDK internally. Query the state from the {@link Client} instead.
      */
     @Deprecated
     default ProviderState getState() {

src/main/java/dev/openfeature/sdk/FeatureProviderWrapper.java

@@ -1,11 +1,21 @@
 package dev.openfeature.sdk;
 
 import dev.openfeature.sdk.exceptions.OpenFeatureError;
+import lombok.experimental.Delegate;
 
-import java.util.List;
 import java.util.concurrent.atomic.AtomicBoolean;
 
-public class FeatureProviderWrapper implements FeatureProvider, EventProviderListener {
+class FeatureProviderWrapper implements FeatureProvider, EventProviderListener {
+
+    private interface ExcludeFromDelegate {
+        void initialize(EvaluationContext evaluationContext) throws Exception;
+
+        void shutdown();
+
+        ProviderState getState();
+    }
+
+    @Delegate(excludes = ExcludeFromDelegate.class)
     private final FeatureProvider delegate;
     private final AtomicBoolean isInitialized = new AtomicBoolean();
     private ProviderState state = ProviderState.NOT_READY;
@@ -17,41 +27,6 @@ public FeatureProviderWrapper(FeatureProvider delegate) {
         }
     }
 
-    @Override
-    public Metadata getMetadata() {
-        return delegate.getMetadata();
-    }
-
-    @Override
-    public List<Hook> getProviderHooks() {
-        return delegate.getProviderHooks();
-    }
-
-    @Override
-    public ProviderEvaluation<Boolean> getBooleanEvaluation(String key, Boolean defaultValue, EvaluationContext ctx) {
-        return delegate.getBooleanEvaluation(key, defaultValue, ctx);
-    }
-
-    @Override
-    public ProviderEvaluation<String> getStringEvaluation(String key, String defaultValue, EvaluationContext ctx) {
-        return delegate.getStringEvaluation(key, defaultValue, ctx);
-    }
-
-    @Override
-    public ProviderEvaluation<Integer> getIntegerEvaluation(String key, Integer defaultValue, EvaluationContext ctx) {
-        return delegate.getIntegerEvaluation(key, defaultValue, ctx);
-    }
-
-    @Override
-    public ProviderEvaluation<Double> getDoubleEvaluation(String key, Double defaultValue, EvaluationContext ctx) {
-        return delegate.getDoubleEvaluation(key, defaultValue, ctx);
-    }
-
-    @Override
-    public ProviderEvaluation<Value> getObjectEvaluation(String key, Value defaultValue, EvaluationContext ctx) {
-        return delegate.getObjectEvaluation(key, defaultValue, ctx);
-    }
-
     @Override
     public void initialize(EvaluationContext evaluationContext) throws Exception {
         if (isInitialized.getAndSet(true)) {
@@ -94,7 +69,9 @@ public int hashCode() {
 
     @Override
     public boolean equals(Object obj) {
-        if (this == obj) return true;
+        if (this == obj) {
+            return true;
+        }
         if (obj instanceof FeatureProviderWrapper) {
             return delegate.equals(((FeatureProviderWrapper) obj).delegate);
         }
@@ -112,7 +89,7 @@ public void onEmit(ProviderEvent event, ProviderEventDetails details) {
         }
     }
 
-    FeatureProvider getDelegate(){
+    FeatureProvider getDelegate() {
         return delegate;
     }
 }

src/main/java/dev/openfeature/sdk/OpenFeatureAPI.java

@@ -275,13 +275,6 @@ public FeatureProvider getProvider() {
         return providerRepository.getProvider();
     }
 
-    /**
-     * Return the state of the default provider.
-     */
-    public ProviderState getProviderState() {
-        return providerRepository.getProviderState();
-    }
-
     /**
      * Fetch a provider for a domain. If not found, return the default.
      *
@@ -292,6 +285,13 @@ public FeatureProvider getProvider(String domain) {
         return providerRepository.getProvider(domain);
     }
 
+    /**
+     * Return the state of the default provider.
+     */
+    public ProviderState getProviderState() {
+        return providerRepository.getProviderState();
+    }
+
     /**
      * Get the state of the provider for a domain. If no provider with the domain is found, returns the state of the
      * default provider.

src/main/java/dev/openfeature/sdk/ProviderRepository.java

@@ -21,7 +21,9 @@
 class ProviderRepository {
 
     private final Map<String, FeatureProviderWrapper> providers = new ConcurrentHashMap<>();
-    private final AtomicReference<FeatureProviderWrapper> defaultProvider = new AtomicReference<>(new FeatureProviderWrapper(new NoOpProvider()));
+    private final AtomicReference<FeatureProviderWrapper> defaultProvider = new AtomicReference<>(
+            new FeatureProviderWrapper(new NoOpProvider())
+    );
     private final ExecutorService taskExecutor = Executors.newCachedThreadPool(runnable -> {
         final Thread thread = new Thread(runnable);
         thread.setDaemon(true);
@@ -148,10 +150,18 @@ private void initializeProvider(FeatureProviderWrapper newProvider,
             }
             shutDownOld(oldProvider, afterShutdown);
         } catch (OpenFeatureError e) {
-            log.error("Exception when initializing feature provider {}", newProvider.getDelegate().getClass().getName(), e);
+            log.error(
+                    "Exception when initializing feature provider {}",
+                    newProvider.getDelegate().getClass().getName(),
+                    e
+            );
             afterError.accept(newProvider.getDelegate(), e);
         } catch (Exception e) {
-            log.error("Exception when initializing feature provider {}", newProvider.getDelegate().getClass().getName(), e);
+            log.error(
+                    "Exception when initializing feature provider {}",
+                    newProvider.getDelegate().getClass().getName(),
+                    e
+            );
             afterError.accept(newProvider.getDelegate(), new GeneralError(e));
         }
     }

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

@@ -8,6 +8,7 @@
 
 import java.util.*;
 
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.mockito.ArgumentMatchers.any;
@@ -121,4 +122,54 @@ public Optional before(HookContext ctx, Map hints) {
         String noOpValue = client.getStringValue("val", defaultValue);
         assertEquals(noOpValue, defaultValue);
     }
+
+    @Test
+    void setProviderAndWaitShouldPutTheProviderInReadyState() {
+        String domain = "domain";
+        OpenFeatureAPI api = OpenFeatureAPI.getInstance();
+        api.setProviderAndWait(domain, new TestEventsProvider());
+        Client client = api.getClient(domain);
+        assertThat(client.getProviderState()).isEqualTo(ProviderState.READY);
+    }
+
+    @Specification(number = "5.3.5", text = "If the provider emits an event, the value of the client's provider status MUST be updated accordingly.")
+    @Test
+    void shouldPutTheProviderInStateErrorAfterEmittingErrorEvent() {
+        String domain = "domain";
+        OpenFeatureAPI api = OpenFeatureAPI.getInstance();
+        TestEventsProvider provider = new TestEventsProvider();
+        api.setProviderAndWait(domain, provider);
+        Client client = api.getClient(domain);
+        assertThat(client.getProviderState()).isEqualTo(ProviderState.READY);
+        provider.emitProviderError(ProviderEventDetails.builder().build());
+        assertThat(client.getProviderState()).isEqualTo(ProviderState.ERROR);
+    }
+
+    @Specification(number = "5.3.5", text = "If the provider emits an event, the value of the client's provider status MUST be updated accordingly.")
+    @Test
+    void shouldPutTheProviderInStateStaleAfterEmittingStaleEvent() {
+        String domain = "domain";
+        OpenFeatureAPI api = OpenFeatureAPI.getInstance();
+        TestEventsProvider provider = new TestEventsProvider();
+        api.setProviderAndWait(domain, provider);
+        Client client = api.getClient(domain);
+        assertThat(client.getProviderState()).isEqualTo(ProviderState.READY);
+        provider.emitProviderStale(ProviderEventDetails.builder().build());
+        assertThat(client.getProviderState()).isEqualTo(ProviderState.STALE);
+    }
+
+    @Specification(number = "5.3.5", text = "If the provider emits an event, the value of the client's provider status MUST be updated accordingly.")
+    @Test
+    void shouldPutTheProviderInStateReadyAfterEmittingReadyEvent() {
+        String domain = "domain";
+        OpenFeatureAPI api = OpenFeatureAPI.getInstance();
+        TestEventsProvider provider = new TestEventsProvider();
+        api.setProviderAndWait(domain, provider);
+        Client client = api.getClient(domain);
+        assertThat(client.getProviderState()).isEqualTo(ProviderState.READY);
+        provider.emitProviderStale(ProviderEventDetails.builder().build());
+        assertThat(client.getProviderState()).isEqualTo(ProviderState.STALE);
+        provider.emitProviderReady(ProviderEventDetails.builder().build());
+        assertThat(client.getProviderState()).isEqualTo(ProviderState.READY);
+    }
 }