onEmit) {
if (this.onEmit != null && this.onEmit != onEmit) {
@@ -50,11 +49,14 @@ void detach() {
/**
* Emit the specified {@link ProviderEvent}.
- *
+ *
* @param event The event type
* @param details The details of the event
*/
public void emit(ProviderEvent event, ProviderEventDetails details) {
+ if (eventProviderListener != null) {
+ eventProviderListener.onEmit(event, details);
+ }
if (this.onEmit != null) {
this.onEmit.accept(this, event, details);
}
@@ -63,7 +65,7 @@ public void emit(ProviderEvent event, ProviderEventDetails details) {
/**
* Emit a {@link ProviderEvent#PROVIDER_READY} event.
* Shorthand for {@link #emit(ProviderEvent, ProviderEventDetails)}
- *
+ *
* @param details The details of the event
*/
public void emitProviderReady(ProviderEventDetails details) {
@@ -74,7 +76,7 @@ public void emitProviderReady(ProviderEventDetails details) {
* Emit a
* {@link ProviderEvent#PROVIDER_CONFIGURATION_CHANGED}
* event. Shorthand for {@link #emit(ProviderEvent, ProviderEventDetails)}
- *
+ *
* @param details The details of the event
*/
public void emitProviderConfigurationChanged(ProviderEventDetails details) {
@@ -84,7 +86,7 @@ public void emitProviderConfigurationChanged(ProviderEventDetails details) {
/**
* Emit a {@link ProviderEvent#PROVIDER_STALE} event.
* Shorthand for {@link #emit(ProviderEvent, ProviderEventDetails)}
- *
+ *
* @param details The details of the event
*/
public void emitProviderStale(ProviderEventDetails details) {
@@ -94,7 +96,7 @@ public void emitProviderStale(ProviderEventDetails details) {
/**
* Emit a {@link ProviderEvent#PROVIDER_ERROR} event.
* Shorthand for {@link #emit(ProviderEvent, ProviderEventDetails)}
- *
+ *
* @param details The details of the event
*/
public void emitProviderError(ProviderEventDetails details) {
diff --git a/src/main/java/dev/openfeature/sdk/EventProviderListener.java b/src/main/java/dev/openfeature/sdk/EventProviderListener.java
new file mode 100644
index 000000000..c1f839aab
--- /dev/null
+++ b/src/main/java/dev/openfeature/sdk/EventProviderListener.java
@@ -0,0 +1,6 @@
+package dev.openfeature.sdk;
+
+@FunctionalInterface
+interface EventProviderListener {
+ void onEmit(ProviderEvent event, ProviderEventDetails details);
+}
diff --git a/src/main/java/dev/openfeature/sdk/FeatureProvider.java b/src/main/java/dev/openfeature/sdk/FeatureProvider.java
index e1e06d0ab..706818e85 100644
--- a/src/main/java/dev/openfeature/sdk/FeatureProvider.java
+++ b/src/main/java/dev/openfeature/sdk/FeatureProvider.java
@@ -60,13 +60,25 @@ default void shutdown() {
* 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}.
- *
+ *
* Providers which do not implement this method are assumed to be ready immediately.
- *
+ *
* @return ProviderState
+ * @deprecated The state is handled by the SDK internally. Query the state from the {@link Client} instead.
*/
+ @Deprecated
default ProviderState getState() {
return ProviderState.READY;
}
+ /**
+ * Feature provider implementations can opt in for to support Tracking by implementing this method.
+ *
+ * @param eventName The name of the tracking event
+ * @param context Evaluation context used in flag evaluation (Optional)
+ * @param details Data pertinent to a particular tracking event (Optional)
+ */
+ default void track(String eventName, EvaluationContext context, TrackingEventDetails details) {
+
+ }
}
diff --git a/src/main/java/dev/openfeature/sdk/FeatureProviderStateManager.java b/src/main/java/dev/openfeature/sdk/FeatureProviderStateManager.java
new file mode 100644
index 000000000..973d46997
--- /dev/null
+++ b/src/main/java/dev/openfeature/sdk/FeatureProviderStateManager.java
@@ -0,0 +1,71 @@
+package dev.openfeature.sdk;
+
+import dev.openfeature.sdk.exceptions.OpenFeatureError;
+import lombok.Getter;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+class FeatureProviderStateManager implements EventProviderListener {
+ private final FeatureProvider delegate;
+ private final AtomicBoolean isInitialized = new AtomicBoolean();
+ @Getter
+ private ProviderState state = ProviderState.NOT_READY;
+
+ public FeatureProviderStateManager(FeatureProvider delegate) {
+ this.delegate = delegate;
+ if (delegate instanceof EventProvider) {
+ ((EventProvider) delegate).setEventProviderListener(this);
+ }
+ }
+
+ public void initialize(EvaluationContext evaluationContext) throws Exception {
+ if (isInitialized.getAndSet(true)) {
+ return;
+ }
+ try {
+ delegate.initialize(evaluationContext);
+ state = ProviderState.READY;
+ } catch (OpenFeatureError openFeatureError) {
+ if (ErrorCode.PROVIDER_FATAL.equals(openFeatureError.getErrorCode())) {
+ state = ProviderState.FATAL;
+ } else {
+ state = ProviderState.ERROR;
+ }
+ isInitialized.set(false);
+ throw openFeatureError;
+ } catch (Exception e) {
+ state = ProviderState.ERROR;
+ isInitialized.set(false);
+ throw e;
+ }
+ }
+
+ public void shutdown() {
+ delegate.shutdown();
+ state = ProviderState.NOT_READY;
+ isInitialized.set(false);
+ }
+
+ @Override
+ public void onEmit(ProviderEvent event, ProviderEventDetails details) {
+ if (ProviderEvent.PROVIDER_ERROR.equals(event)) {
+ if (details != null && details.getErrorCode() == ErrorCode.PROVIDER_FATAL) {
+ state = ProviderState.FATAL;
+ } else {
+ state = ProviderState.ERROR;
+ }
+ } else if (ProviderEvent.PROVIDER_STALE.equals(event)) {
+ state = ProviderState.STALE;
+ } else if (ProviderEvent.PROVIDER_READY.equals(event)) {
+ state = ProviderState.READY;
+ }
+ }
+
+ FeatureProvider getProvider() {
+ return delegate;
+ }
+
+ public boolean hasSameProvider(FeatureProvider featureProvider) {
+ return this.delegate.equals(featureProvider);
+ }
+}
diff --git a/src/main/java/dev/openfeature/sdk/HookSupport.java b/src/main/java/dev/openfeature/sdk/HookSupport.java
index 52c5b9727..f0216b255 100644
--- a/src/main/java/dev/openfeature/sdk/HookSupport.java
+++ b/src/main/java/dev/openfeature/sdk/HookSupport.java
@@ -1,13 +1,11 @@
package dev.openfeature.sdk;
+import java.util.ArrayList;
+import java.util.Collections;
import java.util.List;
import java.util.Map;
-import java.util.Objects;
import java.util.Optional;
import java.util.function.Consumer;
-import java.util.stream.Collectors;
-import java.util.stream.IntStream;
-import java.util.stream.Stream;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
@@ -19,11 +17,7 @@ class HookSupport {
public EvaluationContext beforeHooks(FlagValueType flagValueType, HookContext hookCtx, List hooks,
Map hints) {
- Stream result = callBeforeHooks(flagValueType, hookCtx, hooks, hints);
- return hookCtx.getCtx().merge(
- result.reduce(hookCtx.getCtx(), (EvaluationContext accumulated, EvaluationContext current) -> {
- return accumulated.merge(current);
- }));
+ return callBeforeHooks(flagValueType, hookCtx, hooks, hints);
}
public void afterHooks(FlagValueType flagValueType, HookContext hookContext, FlagEvaluationDetails details,
@@ -46,10 +40,11 @@ private void executeHooks(
String hookMethod,
Consumer> hookCode) {
if (hooks != null) {
- hooks
- .stream()
- .filter(hook -> hook.supportsFlagValueType(flagValueType))
- .forEach(hook -> executeChecked(hook, hookCode, hookMethod));
+ for (Hook hook : hooks) {
+ if (hook.supportsFlagValueType(flagValueType)) {
+ executeChecked(hook, hookCode, hookMethod);
+ }
+ }
}
}
@@ -68,29 +63,29 @@ private void executeHooksUnchecked(
FlagValueType flagValueType, List hooks,
Consumer> hookCode) {
if (hooks != null) {
- hooks
- .stream()
- .filter(hook -> hook.supportsFlagValueType(flagValueType))
- .forEach(hookCode::accept);
+ for (Hook hook : hooks) {
+ if (hook.supportsFlagValueType(flagValueType)) {
+ hookCode.accept(hook);
+ }
+ }
}
}
- private Stream callBeforeHooks(FlagValueType flagValueType, HookContext hookCtx,
+ private EvaluationContext callBeforeHooks(FlagValueType flagValueType, HookContext hookCtx,
List hooks, Map hints) {
// These traverse backwards from normal.
- List reversedHooks = IntStream
- .range(0, hooks.size())
- .map(i -> hooks.size() - 1 - i)
- .mapToObj(hooks::get)
- .collect(Collectors.toList());
-
- return reversedHooks
- .stream()
- .filter(hook -> hook.supportsFlagValueType(flagValueType))
- .map(hook -> hook.before(hookCtx, hints))
- .filter(Objects::nonNull)
- .filter(Optional::isPresent)
- .map(Optional::get)
- .map(EvaluationContext.class::cast);
+ List reversedHooks = new ArrayList<>(hooks);
+ Collections.reverse(reversedHooks);
+ EvaluationContext context = hookCtx.getCtx();
+ for (Hook hook : reversedHooks) {
+ if (hook.supportsFlagValueType(flagValueType)) {
+ Optional optional = Optional.ofNullable(hook.before(hookCtx, hints))
+ .orElse(Optional.empty());
+ if (optional.isPresent()) {
+ context = context.merge(optional.get());
+ }
+ }
+ }
+ return context;
}
}
diff --git a/src/main/java/dev/openfeature/sdk/ImmutableContext.java b/src/main/java/dev/openfeature/sdk/ImmutableContext.java
index fd2ff2a68..d0dae6051 100644
--- a/src/main/java/dev/openfeature/sdk/ImmutableContext.java
+++ b/src/main/java/dev/openfeature/sdk/ImmutableContext.java
@@ -3,6 +3,7 @@
import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;
+
import dev.openfeature.sdk.internal.ExcludeFromGeneratedCoverageReport;
import lombok.ToString;
import lombok.experimental.Delegate;
@@ -10,7 +11,8 @@
/**
* The EvaluationContext is a container for arbitrary contextual data
* that can be used as a basis for dynamic evaluation.
- * The ImmutableContext is an EvaluationContext implementation which is threadsafe, and whose attributes can
+ * The ImmutableContext is an EvaluationContext implementation which is
+ * threadsafe, and whose attributes can
* not be modified after instantiation.
*/
@ToString
@@ -21,7 +23,8 @@ public final class ImmutableContext implements EvaluationContext {
private final ImmutableStructure structure;
/**
- * Create an immutable context with an empty targeting_key and attributes provided.
+ * Create an immutable context with an empty targeting_key and attributes
+ * provided.
*/
public ImmutableContext() {
this(new HashMap<>());
@@ -42,7 +45,7 @@ public ImmutableContext(String targetingKey) {
* @param attributes evaluation context attributes
*/
public ImmutableContext(Map attributes) {
- this("", attributes);
+ this(null, attributes);
}
/**
@@ -53,9 +56,7 @@ public ImmutableContext(Map attributes) {
*/
public ImmutableContext(String targetingKey, Map attributes) {
if (targetingKey != null && !targetingKey.trim().isEmpty()) {
- final Map actualAttribs = new HashMap<>(attributes);
- actualAttribs.put(TARGETING_KEY, new Value(targetingKey));
- this.structure = new ImmutableStructure(actualAttribs);
+ this.structure = new ImmutableStructure(targetingKey, attributes);
} else {
this.structure = new ImmutableStructure(attributes);
}
@@ -71,28 +72,33 @@ public String getTargetingKey() {
}
/**
- * Merges this EvaluationContext object with the passed EvaluationContext, overriding in case of conflict.
+ * Merges this EvaluationContext object with the passed EvaluationContext,
+ * overriding in case of conflict.
*
* @param overridingContext overriding context
* @return new, resulting merged context
*/
@Override
public EvaluationContext merge(EvaluationContext overridingContext) {
- if (overridingContext == null) {
- return new ImmutableContext(this.asMap());
+ if (overridingContext == null || overridingContext.isEmpty()) {
+ return new ImmutableContext(this.asUnmodifiableMap());
+ }
+ if (this.isEmpty()) {
+ return new ImmutableContext(overridingContext.asUnmodifiableMap());
}
- return new ImmutableContext(
- this.merge(ImmutableStructure::new, this.asMap(), overridingContext.asMap()));
+ Map attributes = this.asMap();
+ EvaluationContext.mergeMaps(ImmutableStructure::new, attributes,
+ overridingContext.asUnmodifiableMap());
+ return new ImmutableContext(attributes);
}
@SuppressWarnings("all")
private static class DelegateExclusions {
@ExcludeFromGeneratedCoverageReport
- public Map merge(Function, Structure> newStructure,
+ public Map merge(Function, Structure> newStructure,
Map base,
Map overriding) {
-
return null;
}
}
diff --git a/src/main/java/dev/openfeature/sdk/ImmutableStructure.java b/src/main/java/dev/openfeature/sdk/ImmutableStructure.java
index d70a01637..06c2551ff 100644
--- a/src/main/java/dev/openfeature/sdk/ImmutableStructure.java
+++ b/src/main/java/dev/openfeature/sdk/ImmutableStructure.java
@@ -3,6 +3,7 @@
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
+import java.util.Map.Entry;
import java.util.Optional;
import java.util.Set;
@@ -35,14 +36,11 @@ public ImmutableStructure() {
* @param attributes attributes.
*/
public ImmutableStructure(Map attributes) {
- super(new HashMap<>(attributes.entrySet()
- .stream()
- .collect(HashMap::new,
- (accumulated, entry) -> accumulated.put(entry.getKey(),
- Optional.ofNullable(entry.getValue())
- .map(Value::clone)
- .orElse(null)),
- HashMap::putAll)));
+ super(copyAttributes(attributes, null));
+ }
+
+ protected ImmutableStructure(String targetingKey, Map attributes) {
+ super(copyAttributes(attributes, targetingKey));
}
@Override
@@ -53,7 +51,7 @@ public Set keySet() {
// getters
@Override
public Value getValue(String key) {
- Value value = this.attributes.get(key);
+ Value value = attributes.get(key);
return value != null ? value.clone() : null;
}
@@ -64,14 +62,23 @@ public Value getValue(String key) {
*/
@Override
public Map asMap() {
- return attributes
- .entrySet()
- .stream()
- .collect(HashMap::new,
- (accumulated, entry) -> accumulated.put(entry.getKey(),
- Optional.ofNullable(entry.getValue())
- .map(Value::clone)
- .orElse(null)),
- HashMap::putAll);
+ return copyAttributes(attributes);
+ }
+
+ private static Map copyAttributes(Map in) {
+ return copyAttributes(in, null);
}
+
+ private static Map copyAttributes(Map in, String targetingKey) {
+ Map copy = new HashMap<>();
+ for (Entry entry : in.entrySet()) {
+ copy.put(entry.getKey(),
+ Optional.ofNullable(entry.getValue()).map((Value val) -> val.clone()).orElse(null));
+ }
+ if (targetingKey != null) {
+ copy.put(EvaluationContext.TARGETING_KEY, new Value(targetingKey));
+ }
+ return copy;
+ }
+
}
diff --git a/src/main/java/dev/openfeature/sdk/ImmutableTrackingEventDetails.java b/src/main/java/dev/openfeature/sdk/ImmutableTrackingEventDetails.java
new file mode 100644
index 000000000..b535bb7da
--- /dev/null
+++ b/src/main/java/dev/openfeature/sdk/ImmutableTrackingEventDetails.java
@@ -0,0 +1,53 @@
+package dev.openfeature.sdk;
+
+import dev.openfeature.sdk.internal.ExcludeFromGeneratedCoverageReport;
+import lombok.experimental.Delegate;
+
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.Function;
+
+
+/**
+ * ImmutableTrackingEventDetails represents data pertinent to a particular tracking event.
+ */
+public class ImmutableTrackingEventDetails implements TrackingEventDetails {
+
+ @Delegate(excludes = DelegateExclusions.class)
+ private final ImmutableStructure structure;
+
+ private final Number value;
+
+ public ImmutableTrackingEventDetails() {
+ this.value = null;
+ this.structure = new ImmutableStructure();
+ }
+
+ public ImmutableTrackingEventDetails(final Number value) {
+ this.value = value;
+ this.structure = new ImmutableStructure();
+ }
+
+ public ImmutableTrackingEventDetails(final Number value, final Map attributes) {
+ this.value = value;
+ this.structure = new ImmutableStructure(attributes);
+ }
+
+ /**
+ * Returns the optional tracking value.
+ */
+ public Optional getValue() {
+ return Optional.ofNullable(value);
+ }
+
+
+ @SuppressWarnings("all")
+ private static class DelegateExclusions {
+ @ExcludeFromGeneratedCoverageReport
+ public Map merge(Function, Structure> newStructure,
+ Map base,
+ Map overriding) {
+ return null;
+ }
+ }
+}
diff --git a/src/main/java/dev/openfeature/sdk/MutableContext.java b/src/main/java/dev/openfeature/sdk/MutableContext.java
index 653441d31..ffab28af2 100644
--- a/src/main/java/dev/openfeature/sdk/MutableContext.java
+++ b/src/main/java/dev/openfeature/sdk/MutableContext.java
@@ -33,7 +33,7 @@ public MutableContext(String targetingKey) {
}
public MutableContext(Map attributes) {
- this("", attributes);
+ this(null, new HashMap<>(attributes));
}
/**
@@ -44,7 +44,7 @@ public MutableContext(Map attributes) {
* @param attributes evaluation context attributes
*/
public MutableContext(String targetingKey, Map attributes) {
- this.structure = new MutableStructure(attributes);
+ this.structure = new MutableStructure(new HashMap<>(attributes));
if (targetingKey != null && !targetingKey.trim().isEmpty()) {
this.structure.attributes.put(TARGETING_KEY, new Value(targetingKey));
}
@@ -114,13 +114,17 @@ public String getTargetingKey() {
*/
@Override
public EvaluationContext merge(EvaluationContext overridingContext) {
- if (overridingContext == null) {
- return new MutableContext(this.asMap());
+ if (overridingContext == null || overridingContext.isEmpty()) {
+ return this;
+ }
+ if (this.isEmpty()) {
+ return overridingContext;
}
- Map merged = this.merge(
- MutableStructure::new, this.asMap(), overridingContext.asMap());
- return new MutableContext(merged);
+ Map attributes = this.asMap();
+ EvaluationContext.mergeMaps(
+ MutableStructure::new, attributes, overridingContext.asUnmodifiableMap());
+ return new MutableContext(attributes);
}
/**
diff --git a/src/main/java/dev/openfeature/sdk/MutableStructure.java b/src/main/java/dev/openfeature/sdk/MutableStructure.java
index fadd68051..1246aa5ef 100644
--- a/src/main/java/dev/openfeature/sdk/MutableStructure.java
+++ b/src/main/java/dev/openfeature/sdk/MutableStructure.java
@@ -30,13 +30,13 @@ public MutableStructure(Map attributes) {
@Override
public Set keySet() {
- return this.attributes.keySet();
+ return attributes.keySet();
}
// getters
@Override
public Value getValue(String key) {
- return this.attributes.get(key);
+ return attributes.get(key);
}
// adders
@@ -87,6 +87,6 @@ public MutableStructure add(String key, List value) {
*/
@Override
public Map asMap() {
- return new HashMap<>(this.attributes);
+ return new HashMap<>(attributes);
}
}
diff --git a/src/main/java/dev/openfeature/sdk/MutableTrackingEventDetails.java b/src/main/java/dev/openfeature/sdk/MutableTrackingEventDetails.java
new file mode 100644
index 000000000..9f0de8c3a
--- /dev/null
+++ b/src/main/java/dev/openfeature/sdk/MutableTrackingEventDetails.java
@@ -0,0 +1,94 @@
+package dev.openfeature.sdk;
+
+import dev.openfeature.sdk.internal.ExcludeFromGeneratedCoverageReport;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+import lombok.experimental.Delegate;
+
+import java.time.Instant;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.Function;
+
+/**
+ * MutableTrackingEventDetails represents data pertinent to a particular tracking event.
+ */
+@EqualsAndHashCode
+@ToString
+public class MutableTrackingEventDetails implements TrackingEventDetails {
+
+ private final Number value;
+ @Delegate(excludes = MutableTrackingEventDetails.DelegateExclusions.class)
+ private final MutableStructure structure;
+
+ public MutableTrackingEventDetails() {
+ this.value = null;
+ this.structure = new MutableStructure();
+ }
+
+ public MutableTrackingEventDetails(final Number value) {
+ this.value = value;
+ this.structure = new MutableStructure();
+ }
+
+ /**
+ * Returns the optional tracking value.
+ */
+ public Optional getValue() {
+ return Optional.ofNullable(value);
+ }
+
+ // override @Delegate methods so that we can use "add" methods and still return MutableTrackingEventDetails,
+ // not Structure
+ public MutableTrackingEventDetails add(String key, Boolean value) {
+ this.structure.add(key, value);
+ return this;
+ }
+
+ public MutableTrackingEventDetails add(String key, String value) {
+ this.structure.add(key, value);
+ return this;
+ }
+
+ public MutableTrackingEventDetails add(String key, Integer value) {
+ this.structure.add(key, value);
+ return this;
+ }
+
+ public MutableTrackingEventDetails add(String key, Double value) {
+ this.structure.add(key, value);
+ return this;
+ }
+
+ public MutableTrackingEventDetails add(String key, Instant value) {
+ this.structure.add(key, value);
+ return this;
+ }
+
+ public MutableTrackingEventDetails add(String key, Structure value) {
+ this.structure.add(key, value);
+ return this;
+ }
+
+ public MutableTrackingEventDetails add(String key, List value) {
+ this.structure.add(key, value);
+ return this;
+ }
+
+ public MutableTrackingEventDetails add(String key, Value value) {
+ this.structure.add(key, value);
+ return this;
+ }
+
+
+ @SuppressWarnings("all")
+ private static class DelegateExclusions {
+ @ExcludeFromGeneratedCoverageReport
+ public Map merge(Function, Structure> newStructure,
+ Map base,
+ Map overriding) {
+ return null;
+ }
+ }
+}
diff --git a/src/main/java/dev/openfeature/sdk/NoOpProvider.java b/src/main/java/dev/openfeature/sdk/NoOpProvider.java
index ef8cf1f83..2ad59c8bf 100644
--- a/src/main/java/dev/openfeature/sdk/NoOpProvider.java
+++ b/src/main/java/dev/openfeature/sdk/NoOpProvider.java
@@ -59,7 +59,7 @@ public ProviderEvaluation getDoubleEvaluation(String key, Double default
@Override
public ProviderEvaluation getObjectEvaluation(String key, Value defaultValue,
- EvaluationContext invocationContext) {
+ EvaluationContext invocationContext) {
return ProviderEvaluation.builder()
.value(defaultValue)
.variant(PASSED_IN_DEFAULT)
diff --git a/src/main/java/dev/openfeature/sdk/OpenFeatureAPI.java b/src/main/java/dev/openfeature/sdk/OpenFeatureAPI.java
index f4d20caf2..ad528568a 100644
--- a/src/main/java/dev/openfeature/sdk/OpenFeatureAPI.java
+++ b/src/main/java/dev/openfeature/sdk/OpenFeatureAPI.java
@@ -5,11 +5,7 @@
import dev.openfeature.sdk.internal.AutoCloseableReentrantReadWriteLock;
import lombok.extern.slf4j.Slf4j;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Optional;
-import java.util.Set;
+import java.util.*;
import java.util.function.Consumer;
/**
@@ -69,7 +65,7 @@ public Metadata getProviderMetadata(String domain) {
}
/**
- * A factory function for creating new, OpenFeature clients.
+ * A factory function for creating new, OpenFeature client.
* Clients can contain their own state (e.g. logger, hook, context).
* Multiple clients can be used to segment feature flag configuration.
* All un-named or unbound clients use the default provider.
@@ -81,12 +77,12 @@ public Client getClient() {
}
/**
- * A factory function for creating new domainless OpenFeature clients.
+ * A factory function for creating new domainless OpenFeature client.
* Clients can contain their own state (e.g. logger, hook, context).
* Multiple clients can be used to segment feature flag configuration.
* If there is already a provider bound to this domain, this provider will be used.
* Otherwise, the default provider is used until a provider is assigned to that domain.
- *
+ *
* @param domain an identifier which logically binds clients with providers
* @return a new client instance
*/
@@ -95,20 +91,22 @@ public Client getClient(String domain) {
}
/**
- * A factory function for creating new domainless OpenFeature clients.
+ * A factory function for creating new domainless OpenFeature client.
* Clients can contain their own state (e.g. logger, hook, context).
* Multiple clients can be used to segment feature flag configuration.
* If there is already a provider bound to this domain, this provider will be used.
* Otherwise, the default provider is used until a provider is assigned to that domain.
- *
- * @param domain a identifier which logically binds clients with providers
+ *
+ * @param domain a identifier which logically binds clients with providers
* @param version a version identifier
* @return a new client instance
*/
public Client getClient(String domain, String version) {
- return new OpenFeatureClient(this,
+ return new OpenFeatureClient(
+ this,
domain,
- version);
+ version
+ );
}
/**
@@ -193,8 +191,8 @@ public void setProvider(FeatureProvider provider) {
/**
* Add a provider for a domain.
*
- * @param domain The domain to bind the provider to.
- * @param provider The provider to set.
+ * @param domain The domain to bind the provider to.
+ * @param provider The provider to set.
*/
public void setProvider(String domain, FeatureProvider provider) {
try (AutoCloseableLock __ = lock.writeLockAutoCloseable()) {
@@ -226,8 +224,8 @@ public void setProviderAndWait(FeatureProvider provider) throws OpenFeatureError
/**
* Add a provider for a domain and wait for initialization to finish.
*
- * @param domain The domain to bind the provider to.
- * @param provider The provider to set.
+ * @param domain The domain to bind the provider to.
+ * @param provider The provider to set.
*/
public void setProviderAndWait(String domain, FeatureProvider provider) throws OpenFeatureError {
try (AutoCloseableLock __ = lock.writeLockAutoCloseable()) {
@@ -300,6 +298,7 @@ public void addHooks(Hook... hooks) {
/**
* Fetch the hooks associated to this client.
+ *
* @return A list of {@link Hook}s.
*/
public List getHooks() {
@@ -394,7 +393,7 @@ void removeHandler(String domain, ProviderEvent event, Consumer ha
void addHandler(String domain, ProviderEvent event, Consumer handler) {
try (AutoCloseableLock __ = lock.writeLockAutoCloseable()) {
// if the provider is in the state associated with event, run immediately
- if (Optional.ofNullable(this.providerRepository.getProvider(domain).getState())
+ if (Optional.ofNullable(this.providerRepository.getProviderState(domain))
.orElse(ProviderState.READY).matchesEvent(event)) {
eventSupport.runHandler(handler, EventDetails.builder().domain(domain).build());
}
@@ -402,9 +401,13 @@ void addHandler(String domain, ProviderEvent event, Consumer handl
}
}
+ FeatureProviderStateManager getFeatureProviderStateManager(String domain) {
+ return providerRepository.getFeatureProviderStateManager(domain);
+ }
+
/**
* Runs the handlers associated with a particular provider.
- *
+ *
* @param provider the provider from where this event originated
* @param event the event type
* @param details the event details
diff --git a/src/main/java/dev/openfeature/sdk/OpenFeatureClient.java b/src/main/java/dev/openfeature/sdk/OpenFeatureClient.java
index d8004e5de..ea566e652 100644
--- a/src/main/java/dev/openfeature/sdk/OpenFeatureClient.java
+++ b/src/main/java/dev/openfeature/sdk/OpenFeatureClient.java
@@ -1,32 +1,36 @@
package dev.openfeature.sdk;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-import java.util.function.Consumer;
-
+import dev.openfeature.sdk.exceptions.ExceptionUtils;
+import dev.openfeature.sdk.exceptions.FatalError;
import dev.openfeature.sdk.exceptions.GeneralError;
import dev.openfeature.sdk.exceptions.OpenFeatureError;
+import dev.openfeature.sdk.exceptions.ProviderNotReadyError;
import dev.openfeature.sdk.internal.AutoCloseableLock;
import dev.openfeature.sdk.internal.AutoCloseableReentrantReadWriteLock;
-import dev.openfeature.sdk.exceptions.ExceptionUtils;
import dev.openfeature.sdk.internal.ObjectUtils;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.function.Consumer;
+
/**
* OpenFeature Client implementation.
* You should not instantiate this or reference this class.
* Use the dev.openfeature.sdk.Client interface instead.
+ *
* @see Client
- *
* @deprecated // TODO: eventually we will make this non-public. See issue #872
*/
@Slf4j
-@SuppressWarnings({ "PMD.DataflowAnomalyAnalysis", "PMD.BeanMembersShouldSerialize",
- "PMD.UnusedLocalVariable", "unchecked", "rawtypes" })
+@SuppressWarnings({"PMD.DataflowAnomalyAnalysis", "PMD.BeanMembersShouldSerialize", "PMD.UnusedLocalVariable",
+ "unchecked", "rawtypes"})
@Deprecated() // TODO: eventually we will make this non-public. See issue #872
public class OpenFeatureClient implements Client {
@@ -45,14 +49,18 @@ public class OpenFeatureClient implements Client {
* Deprecated public constructor. Use OpenFeature.API.getClient() instead.
*
* @param openFeatureAPI Backing global singleton
- * @param domain An identifier which logically binds clients with providers (used by observability tools).
+ * @param domain An identifier which logically binds clients with
+ * providers (used by observability tools).
* @param version Version of the client (used by observability tools).
* @deprecated Do not use this constructor. It's for internal use only.
* Clients created using it will not run event handlers.
* Use the OpenFeatureAPI's getClient factory method instead.
*/
@Deprecated() // TODO: eventually we will make this non-public. See issue #872
- public OpenFeatureClient(OpenFeatureAPI openFeatureAPI, String domain, String version) {
+ public OpenFeatureClient(
+ OpenFeatureAPI openFeatureAPI,
+ String domain,
+ String version) {
this.openfeatureApi = openFeatureAPI;
this.domain = domain;
this.version = version;
@@ -60,6 +68,56 @@ public OpenFeatureClient(OpenFeatureAPI openFeatureAPI, String domain, String ve
this.hookSupport = new HookSupport();
}
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public ProviderState getProviderState() {
+ return openfeatureApi.getFeatureProviderStateManager(domain).getState();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void track(String trackingEventName) {
+ validateTrackingEventName(trackingEventName);
+ invokeTrack(trackingEventName, null, null);
+ }
+
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void track(String trackingEventName, EvaluationContext context) {
+ validateTrackingEventName(trackingEventName);
+ Objects.requireNonNull(context);
+ invokeTrack(trackingEventName, context, null);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void track(String trackingEventName, TrackingEventDetails details) {
+ validateTrackingEventName(trackingEventName);
+ Objects.requireNonNull(details);
+ invokeTrack(trackingEventName, null, details);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void track(String trackingEventName, EvaluationContext context, TrackingEventDetails details) {
+ validateTrackingEventName(trackingEventName);
+ Objects.requireNonNull(context);
+ Objects.requireNonNull(details);
+ invokeTrack(trackingEventName, mergeEvaluationContext(context), details);
+ }
+
+
/**
* {@inheritDoc}
*/
@@ -103,11 +161,10 @@ public EvaluationContext getEvaluationContext() {
}
private FlagEvaluationDetails evaluateFlag(FlagValueType type, String key, T defaultValue,
- EvaluationContext ctx, FlagEvaluationOptions options) {
+ EvaluationContext ctx, FlagEvaluationOptions options) {
FlagEvaluationOptions flagOptions = ObjectUtils.defaultIfNull(options,
() -> FlagEvaluationOptions.builder().build());
Map hints = Collections.unmodifiableMap(flagOptions.getHookHints());
- ctx = ObjectUtils.defaultIfNull(ctx, () -> new ImmutableContext());
FlagEvaluationDetails details = null;
List mergedHooks = null;
@@ -115,8 +172,16 @@ private FlagEvaluationDetails evaluateFlag(FlagValueType type, String key
FeatureProvider provider;
try {
- // openfeatureApi.getProvider() must be called once to maintain a consistent reference
- provider = openfeatureApi.getProvider(this.domain);
+ FeatureProviderStateManager stateManager = openfeatureApi.getFeatureProviderStateManager(this.domain);
+ // provider must be accessed once to maintain a consistent reference
+ provider = stateManager.getProvider();
+ ProviderState state = stateManager.getState();
+ if (ProviderState.NOT_READY.equals(state)) {
+ throw new ProviderNotReadyError("provider not yet initialized");
+ }
+ if (ProviderState.FATAL.equals(state)) {
+ throw new FatalError("provider is in an irrecoverable error state");
+ }
mergedHooks = ObjectUtils.merge(provider.getProviderHooks(), flagOptions.getHooks(), clientHooks,
openfeatureApi.getHooks());
@@ -132,7 +197,11 @@ private FlagEvaluationDetails evaluateFlag(FlagValueType type, String key
details = FlagEvaluationDetails.from(providerEval, key);
if (details.getErrorCode() != null) {
- throw ExceptionUtils.instantiateErrorByErrorCode(details.getErrorCode(), details.getErrorMessage());
+ OpenFeatureError error = ExceptionUtils.instantiateErrorByErrorCode(
+ details.getErrorCode(),
+ details.getErrorMessage());
+ enrichDetailsWithErrorDefaults(defaultValue, details);
+ hookSupport.errorHooks(type, afterHookContext, error, mergedHooks, hints);
} else {
hookSupport.afterHooks(type, afterHookContext, details, mergedHooks, hints);
}
@@ -146,8 +215,7 @@ private FlagEvaluationDetails evaluateFlag(FlagValueType type, String key
details.setErrorCode(ErrorCode.GENERAL);
}
details.setErrorMessage(e.getMessage());
- details.setValue(defaultValue);
- details.setReason(Reason.ERROR.toString());
+ enrichDetailsWithErrorDefaults(defaultValue, details);
hookSupport.errorHooks(type, afterHookContext, e, mergedHooks, hints);
} finally {
hookSupport.afterAllHooks(type, afterHookContext, mergedHooks, hints);
@@ -156,6 +224,24 @@ private FlagEvaluationDetails evaluateFlag(FlagValueType type, String key
return details;
}
+ private static void enrichDetailsWithErrorDefaults(T defaultValue, FlagEvaluationDetails details) {
+ details.setValue(defaultValue);
+ details.setReason(Reason.ERROR.toString());
+ }
+
+ private static void validateTrackingEventName(String str) {
+ Objects.requireNonNull(str);
+ if (str.isEmpty()) {
+ throw new IllegalArgumentException("trackingEventName cannot be empty");
+ }
+ }
+
+ private void invokeTrack(String trackingEventName, EvaluationContext context, TrackingEventDetails details) {
+ openfeatureApi.getFeatureProviderStateManager(domain)
+ .getProvider()
+ .track(trackingEventName, mergeEvaluationContext(context), details);
+ }
+
/**
* Merge invocation contexts with API, transaction and client contexts.
* Does not merge before context.
@@ -164,17 +250,23 @@ private FlagEvaluationDetails evaluateFlag(FlagValueType type, String key
* @return merged evaluation context
*/
private EvaluationContext mergeEvaluationContext(EvaluationContext invocationContext) {
- final EvaluationContext apiContext = openfeatureApi.getEvaluationContext() != null
- ? openfeatureApi.getEvaluationContext()
- : new ImmutableContext();
- final EvaluationContext clientContext = this.getEvaluationContext() != null
- ? this.getEvaluationContext()
- : new ImmutableContext();
- final EvaluationContext transactionContext = openfeatureApi.getTransactionContext() != null
- ? openfeatureApi.getTransactionContext()
- : new ImmutableContext();
-
- return apiContext.merge(transactionContext.merge(clientContext.merge(invocationContext)));
+ final EvaluationContext apiContext = openfeatureApi.getEvaluationContext();
+ final EvaluationContext clientContext = this.getEvaluationContext();
+ final EvaluationContext transactionContext = openfeatureApi.getTransactionContext();
+ return mergeContextMaps(apiContext, transactionContext, clientContext, invocationContext);
+ }
+
+ private EvaluationContext mergeContextMaps(EvaluationContext... contexts) {
+ // avoid any unnecessary context instantiations and stream usage here; this is
+ // called with every evaluation.
+ Map merged = new HashMap<>();
+ for (EvaluationContext evaluationContext : contexts) {
+ if (evaluationContext != null && !evaluationContext.isEmpty()) {
+ EvaluationContext.mergeMaps(ImmutableStructure::new, merged,
+ evaluationContext.asUnmodifiableMap());
+ }
+ }
+ return new ImmutableContext(merged);
}
private ProviderEvaluation createProviderEvaluation(
@@ -211,7 +303,7 @@ public Boolean getBooleanValue(String key, Boolean defaultValue, EvaluationConte
@Override
public Boolean getBooleanValue(String key, Boolean defaultValue, EvaluationContext ctx,
- FlagEvaluationOptions options) {
+ FlagEvaluationOptions options) {
return getBooleanDetails(key, defaultValue, ctx, options).getValue();
}
@@ -227,7 +319,7 @@ public FlagEvaluationDetails getBooleanDetails(String key, Boolean defa
@Override
public FlagEvaluationDetails getBooleanDetails(String key, Boolean defaultValue, EvaluationContext ctx,
- FlagEvaluationOptions options) {
+ FlagEvaluationOptions options) {
return this.evaluateFlag(FlagValueType.BOOLEAN, key, defaultValue, ctx, options);
}
@@ -243,7 +335,7 @@ public String getStringValue(String key, String defaultValue, EvaluationContext
@Override
public String getStringValue(String key, String defaultValue, EvaluationContext ctx,
- FlagEvaluationOptions options) {
+ FlagEvaluationOptions options) {
return getStringDetails(key, defaultValue, ctx, options).getValue();
}
@@ -259,7 +351,7 @@ public FlagEvaluationDetails getStringDetails(String key, String default
@Override
public FlagEvaluationDetails getStringDetails(String key, String defaultValue, EvaluationContext ctx,
- FlagEvaluationOptions options) {
+ FlagEvaluationOptions options) {
return this.evaluateFlag(FlagValueType.STRING, key, defaultValue, ctx, options);
}
@@ -275,7 +367,7 @@ public Integer getIntegerValue(String key, Integer defaultValue, EvaluationConte
@Override
public Integer getIntegerValue(String key, Integer defaultValue, EvaluationContext ctx,
- FlagEvaluationOptions options) {
+ FlagEvaluationOptions options) {
return getIntegerDetails(key, defaultValue, ctx, options).getValue();
}
@@ -291,7 +383,7 @@ public FlagEvaluationDetails getIntegerDetails(String key, Integer defa
@Override
public FlagEvaluationDetails getIntegerDetails(String key, Integer defaultValue, EvaluationContext ctx,
- FlagEvaluationOptions options) {
+ FlagEvaluationOptions options) {
return this.evaluateFlag(FlagValueType.INTEGER, key, defaultValue, ctx, options);
}
@@ -307,7 +399,7 @@ public Double getDoubleValue(String key, Double defaultValue, EvaluationContext
@Override
public Double getDoubleValue(String key, Double defaultValue, EvaluationContext ctx,
- FlagEvaluationOptions options) {
+ FlagEvaluationOptions options) {
return this.evaluateFlag(FlagValueType.DOUBLE, key, defaultValue, ctx, options).getValue();
}
@@ -323,7 +415,7 @@ public FlagEvaluationDetails getDoubleDetails(String key, Double default
@Override
public FlagEvaluationDetails getDoubleDetails(String key, Double defaultValue, EvaluationContext ctx,
- FlagEvaluationOptions options) {
+ FlagEvaluationOptions options) {
return this.evaluateFlag(FlagValueType.DOUBLE, key, defaultValue, ctx, options);
}
@@ -339,7 +431,7 @@ public Value getObjectValue(String key, Value defaultValue, EvaluationContext ct
@Override
public Value getObjectValue(String key, Value defaultValue, EvaluationContext ctx,
- FlagEvaluationOptions options) {
+ FlagEvaluationOptions options) {
return getObjectDetails(key, defaultValue, ctx, options).getValue();
}
@@ -350,13 +442,13 @@ public FlagEvaluationDetails getObjectDetails(String key, Value defaultVa
@Override
public FlagEvaluationDetails getObjectDetails(String key, Value defaultValue,
- EvaluationContext ctx) {
+ EvaluationContext ctx) {
return getObjectDetails(key, defaultValue, ctx, FlagEvaluationOptions.builder().build());
}
@Override
public FlagEvaluationDetails getObjectDetails(String key, Value defaultValue, EvaluationContext ctx,
- FlagEvaluationOptions options) {
+ FlagEvaluationOptions options) {
return this.evaluateFlag(FlagValueType.OBJECT, key, defaultValue, ctx, options);
}
diff --git a/src/main/java/dev/openfeature/sdk/ProviderEventDetails.java b/src/main/java/dev/openfeature/sdk/ProviderEventDetails.java
index d28da9e50..d927e4291 100644
--- a/src/main/java/dev/openfeature/sdk/ProviderEventDetails.java
+++ b/src/main/java/dev/openfeature/sdk/ProviderEventDetails.java
@@ -13,4 +13,5 @@ public class ProviderEventDetails {
private List flagsChanged;
private String message;
private ImmutableMetadata eventMetadata;
+ private ErrorCode errorCode;
}
diff --git a/src/main/java/dev/openfeature/sdk/ProviderRepository.java b/src/main/java/dev/openfeature/sdk/ProviderRepository.java
index 47b9ecf58..d3a5c1acc 100644
--- a/src/main/java/dev/openfeature/sdk/ProviderRepository.java
+++ b/src/main/java/dev/openfeature/sdk/ProviderRepository.java
@@ -1,5 +1,9 @@
package dev.openfeature.sdk;
+import dev.openfeature.sdk.exceptions.GeneralError;
+import dev.openfeature.sdk.exceptions.OpenFeatureError;
+import lombok.extern.slf4j.Slf4j;
+
import java.util.List;
import java.util.Map;
import java.util.Optional;
@@ -13,26 +17,41 @@
import java.util.stream.Collectors;
import java.util.stream.Stream;
-import dev.openfeature.sdk.exceptions.GeneralError;
-import dev.openfeature.sdk.exceptions.OpenFeatureError;
-import lombok.extern.slf4j.Slf4j;
-
@Slf4j
class ProviderRepository {
- private final Map providers = new ConcurrentHashMap<>();
- private final AtomicReference defaultProvider = new AtomicReference<>(new NoOpProvider());
+ private final Map stateManagers = new ConcurrentHashMap<>();
+ private final AtomicReference defaultStateManger = new AtomicReference<>(
+ new FeatureProviderStateManager(new NoOpProvider())
+ );
private final ExecutorService taskExecutor = Executors.newCachedThreadPool(runnable -> {
final Thread thread = new Thread(runnable);
thread.setDaemon(true);
return thread;
});
+ private final Object registerStateManagerLock = new Object();
+
+ FeatureProviderStateManager getFeatureProviderStateManager() {
+ return defaultStateManger.get();
+ }
+
+ FeatureProviderStateManager getFeatureProviderStateManager(String domain) {
+ if (domain == null) {
+ return defaultStateManger.get();
+ }
+ FeatureProviderStateManager fromMap = this.stateManagers.get(domain);
+ if (fromMap == null) {
+ return this.defaultStateManger.get();
+ } else {
+ return fromMap;
+ }
+ }
/**
* Return the default provider.
*/
public FeatureProvider getProvider() {
- return defaultProvider.get();
+ return defaultStateManger.get().getProvider();
}
/**
@@ -42,17 +61,46 @@ public FeatureProvider getProvider() {
* @return A named {@link FeatureProvider}
*/
public FeatureProvider getProvider(String domain) {
- return Optional.ofNullable(domain).map(this.providers::get).orElse(this.defaultProvider.get());
+ return getFeatureProviderStateManager(domain).getProvider();
+ }
+
+ public ProviderState getProviderState() {
+ return getFeatureProviderStateManager().getState();
+ }
+
+ public ProviderState getProviderState(FeatureProvider featureProvider) {
+ if (featureProvider instanceof FeatureProviderStateManager) {
+ return ((FeatureProviderStateManager) featureProvider).getState();
+ }
+
+ FeatureProviderStateManager defaultProvider = this.defaultStateManger.get();
+ if (defaultProvider.hasSameProvider(featureProvider)) {
+ return defaultProvider.getState();
+ }
+
+ for (FeatureProviderStateManager wrapper : stateManagers.values()) {
+ if (wrapper.hasSameProvider(featureProvider)) {
+ return wrapper.getState();
+ }
+ }
+ return null;
+ }
+
+ public ProviderState getProviderState(String domain) {
+ return Optional.ofNullable(domain)
+ .map(this.stateManagers::get)
+ .orElse(this.defaultStateManger.get())
+ .getState();
}
public List getDomainsForProvider(FeatureProvider provider) {
- return providers.entrySet().stream()
- .filter(entry -> entry.getValue().equals(provider))
- .map(entry -> entry.getKey()).collect(Collectors.toList());
+ return stateManagers.entrySet().stream()
+ .filter(entry -> entry.getValue().hasSameProvider(provider))
+ .map(Map.Entry::getKey).collect(Collectors.toList());
}
public Set getAllBoundDomains() {
- return providers.keySet();
+ return stateManagers.keySet();
}
public boolean isDefaultProvider(FeatureProvider provider) {
@@ -63,11 +111,11 @@ public boolean isDefaultProvider(FeatureProvider provider) {
* Set the default provider.
*/
public void setProvider(FeatureProvider provider,
- Consumer afterSet,
- Consumer afterInit,
- Consumer afterShutdown,
- BiConsumer afterError,
- boolean waitForInit) {
+ Consumer afterSet,
+ Consumer afterInit,
+ Consumer afterShutdown,
+ BiConsumer afterError,
+ boolean waitForInit) {
if (provider == null) {
throw new IllegalArgumentException("Provider cannot be null");
}
@@ -83,12 +131,12 @@ public void setProvider(FeatureProvider provider,
* Otherwise, initialization happens in the background.
*/
public void setProvider(String domain,
- FeatureProvider provider,
- Consumer afterSet,
- Consumer afterInit,
- Consumer afterShutdown,
- BiConsumer afterError,
- boolean waitForInit) {
+ FeatureProvider provider,
+ Consumer afterSet,
+ Consumer afterInit,
+ Consumer afterShutdown,
+ BiConsumer afterError,
+ boolean waitForInit) {
if (provider == null) {
throw new IllegalArgumentException("Provider cannot be null");
}
@@ -99,68 +147,105 @@ public void setProvider(String domain,
}
private void prepareAndInitializeProvider(String domain,
- FeatureProvider newProvider,
- Consumer afterSet,
- Consumer afterInit,
- Consumer afterShutdown,
- BiConsumer afterError,
- boolean waitForInit) {
-
- if (!isProviderRegistered(newProvider)) {
- // only run afterSet if new provider is not already attached
- afterSet.accept(newProvider);
- }
+ FeatureProvider newProvider,
+ Consumer afterSet,
+ Consumer afterInit,
+ Consumer afterShutdown,
+ BiConsumer afterError,
+ boolean waitForInit) {
+ final FeatureProviderStateManager newStateManager;
+ final FeatureProviderStateManager oldStateManager;
+
+ synchronized (registerStateManagerLock) {
+ FeatureProviderStateManager existing = getExistingStateManagerForProvider(newProvider);
+ if (existing == null) {
+ newStateManager = new FeatureProviderStateManager(newProvider);
+ // only run afterSet if new provider is not already attached
+ afterSet.accept(newProvider);
+ } else {
+ newStateManager = existing;
+ }
- // provider is set immediately, on this thread
- FeatureProvider oldProvider = domain != null
- ? this.providers.put(domain, newProvider)
- : this.defaultProvider.getAndSet(newProvider);
+ // provider is set immediately, on this thread
+ oldStateManager = domain != null
+ ? this.stateManagers.put(domain, newStateManager)
+ : this.defaultStateManger.getAndSet(newStateManager);
+ }
if (waitForInit) {
- initializeProvider(newProvider, afterInit, afterShutdown, afterError, oldProvider);
+ initializeProvider(newStateManager, afterInit, afterShutdown, afterError, oldStateManager);
} else {
taskExecutor.submit(() -> {
- // initialization happens in a different thread if we're not waiting it
- initializeProvider(newProvider, afterInit, afterShutdown, afterError, oldProvider);
+ // initialization happens in a different thread if we're not waiting for it
+ initializeProvider(newStateManager, afterInit, afterShutdown, afterError, oldStateManager);
});
}
}
- private void initializeProvider(FeatureProvider newProvider,
- Consumer afterInit,
- Consumer afterShutdown,
- BiConsumer afterError,
- FeatureProvider oldProvider) {
+ private FeatureProviderStateManager getExistingStateManagerForProvider(FeatureProvider provider) {
+ for (FeatureProviderStateManager stateManager : stateManagers.values()) {
+ if (stateManager.hasSameProvider(provider)) {
+ return stateManager;
+ }
+ }
+ FeatureProviderStateManager defaultFeatureProviderStateManager = defaultStateManger.get();
+ if (defaultFeatureProviderStateManager.hasSameProvider(provider)) {
+ return defaultFeatureProviderStateManager;
+ }
+ return null;
+ }
+
+ private void initializeProvider(FeatureProviderStateManager newManager,
+ Consumer afterInit,
+ Consumer afterShutdown,
+ BiConsumer afterError,
+ FeatureProviderStateManager oldManager) {
try {
- if (ProviderState.NOT_READY.equals(newProvider.getState())) {
- newProvider.initialize(OpenFeatureAPI.getInstance().getEvaluationContext());
- afterInit.accept(newProvider);
+ if (ProviderState.NOT_READY.equals(newManager.getState())) {
+ newManager.initialize(OpenFeatureAPI.getInstance().getEvaluationContext());
+ afterInit.accept(newManager.getProvider());
}
- shutDownOld(oldProvider, afterShutdown);
+ shutDownOld(oldManager, afterShutdown);
} catch (OpenFeatureError e) {
- log.error("Exception when initializing feature provider {}", newProvider.getClass().getName(), e);
- afterError.accept(newProvider, e);
+ log.error(
+ "Exception when initializing feature provider {}",
+ newManager.getProvider().getClass().getName(),
+ e
+ );
+ afterError.accept(newManager.getProvider(), e);
} catch (Exception e) {
- log.error("Exception when initializing feature provider {}", newProvider.getClass().getName(), e);
- afterError.accept(newProvider, new GeneralError(e));
+ log.error(
+ "Exception when initializing feature provider {}",
+ newManager.getProvider().getClass().getName(),
+ e
+ );
+ afterError.accept(newManager.getProvider(), new GeneralError(e));
}
}
- private void shutDownOld(FeatureProvider oldProvider, Consumer afterShutdown) {
- if (!isProviderRegistered(oldProvider)) {
- shutdownProvider(oldProvider);
- afterShutdown.accept(oldProvider);
+ private void shutDownOld(FeatureProviderStateManager oldManager, Consumer afterShutdown) {
+ if (oldManager != null && !isStateManagerRegistered(oldManager)) {
+ shutdownProvider(oldManager);
+ afterShutdown.accept(oldManager.getProvider());
}
}
/**
- * Helper to check if provider is already known (registered).
- * @param provider provider to check for registration
+ * Helper to check if manager is already known (registered).
+ *
+ * @param manager manager to check for registration
* @return boolean true if already registered, false otherwise
*/
- private boolean isProviderRegistered(FeatureProvider provider) {
- return provider != null
- && (this.providers.containsValue(provider) || this.defaultProvider.get().equals(provider));
+ private boolean isStateManagerRegistered(FeatureProviderStateManager manager) {
+ return manager != null
+ && (this.stateManagers.containsValue(manager) || this.defaultStateManger.get().equals(manager));
+ }
+
+ private void shutdownProvider(FeatureProviderStateManager manager) {
+ if (manager == null) {
+ return;
+ }
+ shutdownProvider(manager.getProvider());
}
private void shutdownProvider(FeatureProvider provider) {
@@ -180,10 +265,10 @@ private void shutdownProvider(FeatureProvider provider) {
*/
public void shutdown() {
Stream
- .concat(Stream.of(this.defaultProvider.get()), this.providers.values().stream())
+ .concat(Stream.of(this.defaultStateManger.get()), this.stateManagers.values().stream())
.distinct()
.forEach(this::shutdownProvider);
- this.providers.clear();
+ this.stateManagers.clear();
taskExecutor.shutdown();
}
}
diff --git a/src/main/java/dev/openfeature/sdk/ProviderState.java b/src/main/java/dev/openfeature/sdk/ProviderState.java
index a66d4e944..b924b4d22 100644
--- a/src/main/java/dev/openfeature/sdk/ProviderState.java
+++ b/src/main/java/dev/openfeature/sdk/ProviderState.java
@@ -4,7 +4,7 @@
* Indicates the state of the provider.
*/
public enum ProviderState {
- READY, NOT_READY, ERROR, STALE;
+ READY, NOT_READY, ERROR, STALE, FATAL;
/**
* Returns true if the passed ProviderEvent maps to this ProviderState.
diff --git a/src/main/java/dev/openfeature/sdk/Structure.java b/src/main/java/dev/openfeature/sdk/Structure.java
index f3768e958..f2fdc53e7 100644
--- a/src/main/java/dev/openfeature/sdk/Structure.java
+++ b/src/main/java/dev/openfeature/sdk/Structure.java
@@ -5,8 +5,6 @@
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
-import java.util.Map.Entry;
-import java.util.function.Function;
import java.util.stream.Collectors;
import static dev.openfeature.sdk.Value.objectToValue;
@@ -18,6 +16,12 @@
@SuppressWarnings("PMD.BeanMembersShouldSerialize")
public interface Structure {
+ /**
+ * Boolean indicating if this structure is empty.
+ * @return boolean for emptiness
+ */
+ boolean isEmpty();
+
/**
* Get all keys.
*
@@ -40,6 +44,14 @@ public interface Structure {
*/
Map asMap();
+ /**
+ * Get all values, as a map of Values.
+ *
+ * @return all attributes on the structure into a Map
+ */
+ Map asUnmodifiableMap();
+
+
/**
* Get all values, with as a map of Object.
*
@@ -89,7 +101,7 @@ default Object convertValue(Value value) {
if (value.isStructure()) {
Structure s = value.asStructure();
- return s.asMap()
+ return s.asUnmodifiableMap()
.entrySet()
.stream()
.collect(HashMap::new,
@@ -101,34 +113,6 @@ default Object convertValue(Value value) {
throw new ValueNotConvertableError();
}
- /**
- * Recursively merges the base map with the overriding map.
- *
- * @param Structure type
- * @param newStructure function to create the right structure
- * @param base base map to merge
- * @param overriding overriding map to merge
- * @return resulting merged map
- */
- default Map merge(Function, Structure> newStructure,
- Map base,
- Map overriding) {
-
- final Map merged = new HashMap<>(base);
- for (Entry overridingEntry : overriding.entrySet()) {
- String key = overridingEntry.getKey();
- if (overridingEntry.getValue().isStructure() && merged.containsKey(key) && merged.get(key).isStructure()) {
- Structure mergedValue = merged.get(key).asStructure();
- Structure overridingValue = overridingEntry.getValue().asStructure();
- Map newMap = this.merge(newStructure, mergedValue.asMap(), overridingValue.asMap());
- merged.put(key, new Value(newStructure.apply(newMap)));
- } else {
- merged.put(key, overridingEntry.getValue());
- }
- }
- return merged;
- }
-
/**
* Transform an object map to a {@link Structure} type.
*
diff --git a/src/main/java/dev/openfeature/sdk/Tracking.java b/src/main/java/dev/openfeature/sdk/Tracking.java
new file mode 100644
index 000000000..ec9c8a8fe
--- /dev/null
+++ b/src/main/java/dev/openfeature/sdk/Tracking.java
@@ -0,0 +1,42 @@
+package dev.openfeature.sdk;
+
+/**
+ * Interface for Tracking events.
+ */
+public interface Tracking {
+ /**
+ * Performs tracking of a particular action or application state.
+ *
+ * @param trackingEventName Event name to track
+ * @throws IllegalArgumentException if {@code trackingEventName} is null
+ */
+ void track(String trackingEventName);
+
+ /**
+ * Performs tracking of a particular action or application state.
+ *
+ * @param trackingEventName Event name to track
+ * @param context Evaluation context used in flag evaluation
+ * @throws IllegalArgumentException if {@code trackingEventName} is null
+ */
+ void track(String trackingEventName, EvaluationContext context);
+
+ /**
+ * Performs tracking of a particular action or application state.
+ *
+ * @param trackingEventName Event name to track
+ * @param details Data pertinent to a particular tracking event
+ * @throws IllegalArgumentException if {@code trackingEventName} is null
+ */
+ void track(String trackingEventName, TrackingEventDetails details);
+
+ /**
+ * Performs tracking of a particular action or application state.
+ *
+ * @param trackingEventName Event name to track
+ * @param context Evaluation context used in flag evaluation
+ * @param details Data pertinent to a particular tracking event
+ * @throws IllegalArgumentException if {@code trackingEventName} is null
+ */
+ void track(String trackingEventName, EvaluationContext context, TrackingEventDetails details);
+}
diff --git a/src/main/java/dev/openfeature/sdk/TrackingEventDetails.java b/src/main/java/dev/openfeature/sdk/TrackingEventDetails.java
new file mode 100644
index 000000000..76b20fbbf
--- /dev/null
+++ b/src/main/java/dev/openfeature/sdk/TrackingEventDetails.java
@@ -0,0 +1,7 @@
+package dev.openfeature.sdk;
+
+/**
+ * Data pertinent to a particular tracking event.
+ */
+public interface TrackingEventDetails extends Structure {
+}
diff --git a/src/main/java/dev/openfeature/sdk/Value.java b/src/main/java/dev/openfeature/sdk/Value.java
index f0fdc8d45..7464ce5af 100644
--- a/src/main/java/dev/openfeature/sdk/Value.java
+++ b/src/main/java/dev/openfeature/sdk/Value.java
@@ -274,7 +274,7 @@ protected Value clone() {
return new Value(copy);
}
if (this.isStructure()) {
- return new Value(new ImmutableStructure(this.asStructure().asMap()));
+ return new Value(new ImmutableStructure(this.asStructure().asUnmodifiableMap()));
}
if (this.isInstant()) {
Instant copy = Instant.ofEpochMilli(this.asInstant().toEpochMilli());
diff --git a/src/main/java/dev/openfeature/sdk/exceptions/FatalError.java b/src/main/java/dev/openfeature/sdk/exceptions/FatalError.java
new file mode 100644
index 000000000..d50d1a42c
--- /dev/null
+++ b/src/main/java/dev/openfeature/sdk/exceptions/FatalError.java
@@ -0,0 +1,13 @@
+package dev.openfeature.sdk.exceptions;
+
+import dev.openfeature.sdk.ErrorCode;
+import lombok.Getter;
+import lombok.experimental.StandardException;
+
+@SuppressWarnings("checkstyle:MissingJavadocType")
+@StandardException
+public class FatalError extends OpenFeatureError {
+ private static final long serialVersionUID = 1L;
+ @Getter
+ private final ErrorCode errorCode = ErrorCode.PROVIDER_FATAL;
+}
\ No newline at end of file
diff --git a/src/main/java/dev/openfeature/sdk/exceptions/FlagNotFoundError.java b/src/main/java/dev/openfeature/sdk/exceptions/FlagNotFoundError.java
index 6685f96d5..7c88ebb44 100644
--- a/src/main/java/dev/openfeature/sdk/exceptions/FlagNotFoundError.java
+++ b/src/main/java/dev/openfeature/sdk/exceptions/FlagNotFoundError.java
@@ -4,14 +4,11 @@
import lombok.Getter;
import lombok.experimental.StandardException;
-@SuppressWarnings("checkstyle:MissingJavadocType")
+@SuppressWarnings({"checkstyle:MissingJavadocType", "squid:S110"})
@StandardException
-public class FlagNotFoundError extends OpenFeatureError {
+public class FlagNotFoundError extends OpenFeatureErrorWithoutStacktrace {
private static final long serialVersionUID = 1L;
- @Getter private final ErrorCode errorCode = ErrorCode.FLAG_NOT_FOUND;
+ @Getter
+ private final ErrorCode errorCode = ErrorCode.FLAG_NOT_FOUND;
- @Override
- public synchronized Throwable fillInStackTrace() {
- return this;
- }
}
diff --git a/src/main/java/dev/openfeature/sdk/exceptions/OpenFeatureErrorWithoutStacktrace.java b/src/main/java/dev/openfeature/sdk/exceptions/OpenFeatureErrorWithoutStacktrace.java
new file mode 100644
index 000000000..2931e6bbb
--- /dev/null
+++ b/src/main/java/dev/openfeature/sdk/exceptions/OpenFeatureErrorWithoutStacktrace.java
@@ -0,0 +1,14 @@
+package dev.openfeature.sdk.exceptions;
+
+import lombok.experimental.StandardException;
+
+@SuppressWarnings("checkstyle:MissingJavadocType")
+@StandardException
+public abstract class OpenFeatureErrorWithoutStacktrace extends OpenFeatureError {
+ private static final long serialVersionUID = 1L;
+
+ @Override
+ public synchronized Throwable fillInStackTrace() {
+ return this;
+ }
+}
diff --git a/src/main/java/dev/openfeature/sdk/exceptions/ProviderNotReadyError.java b/src/main/java/dev/openfeature/sdk/exceptions/ProviderNotReadyError.java
index 218073441..0416eae26 100644
--- a/src/main/java/dev/openfeature/sdk/exceptions/ProviderNotReadyError.java
+++ b/src/main/java/dev/openfeature/sdk/exceptions/ProviderNotReadyError.java
@@ -4,9 +4,9 @@
import lombok.Getter;
import lombok.experimental.StandardException;
-@SuppressWarnings("checkstyle:MissingJavadocType")
+@SuppressWarnings({"checkstyle:MissingJavadocType", "squid:S110"})
@StandardException
-public class ProviderNotReadyError extends OpenFeatureError {
+public class ProviderNotReadyError extends OpenFeatureErrorWithoutStacktrace {
private static final long serialVersionUID = 1L;
@Getter private final ErrorCode errorCode = ErrorCode.PROVIDER_NOT_READY;
}
diff --git a/src/main/java/dev/openfeature/sdk/exceptions/TypeMismatchError.java b/src/main/java/dev/openfeature/sdk/exceptions/TypeMismatchError.java
index d27c6209f..9d88922c7 100644
--- a/src/main/java/dev/openfeature/sdk/exceptions/TypeMismatchError.java
+++ b/src/main/java/dev/openfeature/sdk/exceptions/TypeMismatchError.java
@@ -7,6 +7,7 @@
/**
* The type of the flag value does not match the expected type.
*/
+@SuppressWarnings({"checkstyle:MissingJavadocType", "squid:S110"})
@StandardException
public class TypeMismatchError extends OpenFeatureError {
private static final long serialVersionUID = 1L;
diff --git a/src/main/java/dev/openfeature/sdk/internal/ObjectUtils.java b/src/main/java/dev/openfeature/sdk/internal/ObjectUtils.java
index 34caadaea..9e5dcf613 100644
--- a/src/main/java/dev/openfeature/sdk/internal/ObjectUtils.java
+++ b/src/main/java/dev/openfeature/sdk/internal/ObjectUtils.java
@@ -1,11 +1,9 @@
package dev.openfeature.sdk.internal;
-import java.util.Arrays;
-import java.util.Collection;
+import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.function.Supplier;
-import java.util.stream.Collectors;
import lombok.experimental.UtilityClass;
@@ -64,9 +62,10 @@ public static T defaultIfNull(T source, Supplier defaultValue) {
*/
@SafeVarargs
public static List merge(List... sources) {
- return Arrays
- .stream(sources)
- .flatMap(Collection::stream)
- .collect(Collectors.toList());
+ List merged = new ArrayList<>();
+ for (List source : sources) {
+ merged.addAll(source);
+ }
+ return merged;
}
}
diff --git a/src/main/java/dev/openfeature/sdk/providers/memory/InMemoryProvider.java b/src/main/java/dev/openfeature/sdk/providers/memory/InMemoryProvider.java
index 5b6d28702..2bea3e4ef 100644
--- a/src/main/java/dev/openfeature/sdk/providers/memory/InMemoryProvider.java
+++ b/src/main/java/dev/openfeature/sdk/providers/memory/InMemoryProvider.java
@@ -1,18 +1,7 @@
package dev.openfeature.sdk.providers.memory;
-import dev.openfeature.sdk.EvaluationContext;
-import dev.openfeature.sdk.EventProvider;
-import dev.openfeature.sdk.Metadata;
-import dev.openfeature.sdk.ProviderEvaluation;
-import dev.openfeature.sdk.ProviderEventDetails;
-import dev.openfeature.sdk.ProviderState;
-import dev.openfeature.sdk.Reason;
-import dev.openfeature.sdk.Value;
-import dev.openfeature.sdk.exceptions.FlagNotFoundError;
-import dev.openfeature.sdk.exceptions.GeneralError;
-import dev.openfeature.sdk.exceptions.OpenFeatureError;
-import dev.openfeature.sdk.exceptions.ProviderNotReadyError;
-import dev.openfeature.sdk.exceptions.TypeMismatchError;
+import dev.openfeature.sdk.*;
+import dev.openfeature.sdk.exceptions.*;
import lombok.Getter;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
@@ -63,6 +52,7 @@ public void initialize(EvaluationContext evaluationContext) throws Exception {
* Updates the provider flags configuration.
* For existing flags, the new configurations replace the old one.
* For new flags, they are added to the configuration.
+ *
* @param newFlags the new flag configurations
*/
public void updateFlags(Map> newFlags) {
@@ -80,6 +70,7 @@ public void updateFlags(Map> newFlags) {
* Updates a single provider flag configuration.
* For existing flag, the new configuration replaces the old one.
* For new flag, they are added to the configuration.
+ *
* @param newFlag the flag to update
*/
public void updateFlag(String flagKey, Flag newFlag) {
@@ -93,32 +84,32 @@ public void updateFlag(String flagKey, Flag newFlag) {
@Override
public ProviderEvaluation getBooleanEvaluation(String key, Boolean defaultValue,
- EvaluationContext evaluationContext) {
+ EvaluationContext evaluationContext) {
return getEvaluation(key, evaluationContext, Boolean.class);
}
@Override
public ProviderEvaluation getStringEvaluation(String key, String defaultValue,
- EvaluationContext evaluationContext) {
+ EvaluationContext evaluationContext) {
return getEvaluation(key, evaluationContext, String.class);
}
@Override
public ProviderEvaluation getIntegerEvaluation(String key, Integer defaultValue,
- EvaluationContext evaluationContext) {
+ EvaluationContext evaluationContext) {
return getEvaluation(key, evaluationContext, Integer.class);
}
@Override
public ProviderEvaluation getDoubleEvaluation(String key, Double defaultValue,
- EvaluationContext evaluationContext) {
+ EvaluationContext evaluationContext) {
return getEvaluation(key, evaluationContext, Double.class);
}
@SneakyThrows
@Override
public ProviderEvaluation getObjectEvaluation(String key, Value defaultValue,
- EvaluationContext evaluationContext) {
+ EvaluationContext evaluationContext) {
return getEvaluation(key, evaluationContext, Value.class);
}
@@ -129,6 +120,9 @@ private ProviderEvaluation getEvaluation(
if (ProviderState.NOT_READY.equals(state)) {
throw new ProviderNotReadyError("provider not yet initialized");
}
+ if (ProviderState.FATAL.equals(state)) {
+ throw new FatalError("provider in fatal error state");
+ }
throw new GeneralError("unknown error");
}
Flag flag = flags.get(key);
@@ -149,5 +143,4 @@ private ProviderEvaluation getEvaluation(
.reason(Reason.STATIC.toString())
.build();
}
-
}
diff --git a/src/test/java/dev/openfeature/sdk/AlwaysBrokenProvider.java b/src/test/java/dev/openfeature/sdk/AlwaysBrokenProvider.java
index c10976232..841d738e5 100644
--- a/src/test/java/dev/openfeature/sdk/AlwaysBrokenProvider.java
+++ b/src/test/java/dev/openfeature/sdk/AlwaysBrokenProvider.java
@@ -4,11 +4,11 @@
public class AlwaysBrokenProvider implements FeatureProvider {
+ private final String name = "always broken";
+
@Override
public Metadata getMetadata() {
- return () -> {
- throw new FlagNotFoundError(TestConstants.BROKEN_MESSAGE);
- };
+ return () -> name;
}
@Override
diff --git a/src/test/java/dev/openfeature/sdk/AlwaysBrokenWithDetailsProvider.java b/src/test/java/dev/openfeature/sdk/AlwaysBrokenWithDetailsProvider.java
new file mode 100644
index 000000000..b3ead41bd
--- /dev/null
+++ b/src/test/java/dev/openfeature/sdk/AlwaysBrokenWithDetailsProvider.java
@@ -0,0 +1,53 @@
+package dev.openfeature.sdk;
+
+import dev.openfeature.sdk.exceptions.FlagNotFoundError;
+
+public class AlwaysBrokenWithDetailsProvider implements FeatureProvider {
+
+ @Override
+ public Metadata getMetadata() {
+ return () -> {
+ throw new FlagNotFoundError(TestConstants.BROKEN_MESSAGE);
+ };
+ }
+
+ @Override
+ public ProviderEvaluation getBooleanEvaluation(String key, Boolean defaultValue, EvaluationContext ctx) {
+ return ProviderEvaluation.builder()
+ .errorMessage(TestConstants.BROKEN_MESSAGE)
+ .errorCode(ErrorCode.FLAG_NOT_FOUND)
+ .build();
+ }
+
+ @Override
+ public ProviderEvaluation getStringEvaluation(String key, String defaultValue, EvaluationContext ctx) {
+ return ProviderEvaluation.builder()
+ .errorMessage(TestConstants.BROKEN_MESSAGE)
+ .errorCode(ErrorCode.FLAG_NOT_FOUND)
+ .build();
+ }
+
+ @Override
+ public ProviderEvaluation getIntegerEvaluation(String key, Integer defaultValue, EvaluationContext ctx) {
+ return ProviderEvaluation.builder()
+ .errorMessage(TestConstants.BROKEN_MESSAGE)
+ .errorCode(ErrorCode.FLAG_NOT_FOUND)
+ .build();
+ }
+
+ @Override
+ public ProviderEvaluation getDoubleEvaluation(String key, Double defaultValue, EvaluationContext ctx) {
+ return ProviderEvaluation.builder()
+ .errorMessage(TestConstants.BROKEN_MESSAGE)
+ .errorCode(ErrorCode.FLAG_NOT_FOUND)
+ .build();
+ }
+
+ @Override
+ public ProviderEvaluation getObjectEvaluation(String key, Value defaultValue, EvaluationContext invocationContext) {
+ return ProviderEvaluation.builder()
+ .errorMessage(TestConstants.BROKEN_MESSAGE)
+ .errorCode(ErrorCode.FLAG_NOT_FOUND)
+ .build();
+ }
+}
diff --git a/src/test/java/dev/openfeature/sdk/DeveloperExperienceTest.java b/src/test/java/dev/openfeature/sdk/DeveloperExperienceTest.java
index b5e5bedf3..4502699b1 100644
--- a/src/test/java/dev/openfeature/sdk/DeveloperExperienceTest.java
+++ b/src/test/java/dev/openfeature/sdk/DeveloperExperienceTest.java
@@ -1,38 +1,38 @@
package dev.openfeature.sdk;
+import dev.openfeature.sdk.fixtures.HookFixtures;
+import dev.openfeature.sdk.testutils.FeatureProviderTestUtils;
+import dev.openfeature.sdk.testutils.TestEventsProvider;
+import lombok.SneakyThrows;
+import org.junit.jupiter.api.Test;
+
+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;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-
-import dev.openfeature.sdk.testutils.FeatureProviderTestUtils;
-import org.junit.jupiter.api.Test;
-
-import dev.openfeature.sdk.fixtures.HookFixtures;
-
class DeveloperExperienceTest implements HookFixtures {
transient String flagKey = "mykey";
- @Test void simpleBooleanFlag() {
+ @Test
+ void simpleBooleanFlag() {
OpenFeatureAPI api = OpenFeatureAPI.getInstance();
- api.setProvider(new NoOpProvider());
+ api.setProviderAndWait(new TestEventsProvider());
Client client = api.getClient();
Boolean retval = client.getBooleanValue(flagKey, false);
assertFalse(retval);
}
- @Test void clientHooks() {
+ @Test
+ void clientHooks() {
Hook exampleHook = mockBooleanHook();
OpenFeatureAPI api = OpenFeatureAPI.getInstance();
- api.setProvider(new NoOpProvider());
+ api.setProviderAndWait(new TestEventsProvider());
Client client = api.getClient();
client.addHooks(exampleHook);
Boolean retval = client.getBooleanValue(flagKey, false);
@@ -40,12 +40,13 @@ class DeveloperExperienceTest implements HookFixtures {
assertFalse(retval);
}
- @Test void evalHooks() {
+ @Test
+ void evalHooks() {
Hook clientHook = mockBooleanHook();
Hook evalHook = mockBooleanHook();
OpenFeatureAPI api = OpenFeatureAPI.getInstance();
- api.setProvider(new NoOpProvider());
+ api.setProviderAndWait(new TestEventsProvider());
Client client = api.getClient();
client.addHooks(clientHook);
Boolean retval = client.getBooleanValue(flagKey, false, null,
@@ -59,10 +60,11 @@ class DeveloperExperienceTest implements HookFixtures {
* As an application author, you probably know special things about your users. You can communicate these to the
* provider via {@link MutableContext}
*/
- @Test void providingContext() {
+ @Test
+ void providingContext() {
OpenFeatureAPI api = OpenFeatureAPI.getInstance();
- api.setProvider(new NoOpProvider());
+ api.setProviderAndWait(new TestEventsProvider());
Client client = api.getClient();
Map attributes = new HashMap<>();
List values = Arrays.asList(new Value(2), new Value(4));
@@ -76,7 +78,8 @@ class DeveloperExperienceTest implements HookFixtures {
assertFalse(retval);
}
- @Test void brokenProvider() {
+ @Test
+ void brokenProvider() {
OpenFeatureAPI api = OpenFeatureAPI.getInstance();
FeatureProviderTestUtils.setFeatureProvider(new AlwaysBrokenProvider());
Client client = api.getClient();
@@ -93,13 +96,16 @@ void providerLockedPerTransaction() {
class MutatingHook implements Hook {
@Override
+ @SneakyThrows
// change the provider during a before hook - this should not impact the evaluation in progress
public Optional before(HookContext ctx, Map hints) {
- FeatureProviderTestUtils.setFeatureProvider(new NoOpProvider());
+
+ FeatureProviderTestUtils.setFeatureProvider(TestEventsProvider.newInitializedTestEventsProvider());
+
return Optional.empty();
}
}
-
+
final String defaultValue = "string-value";
final OpenFeatureAPI api = OpenFeatureAPI.getInstance();
final Client client = api.getClient();
@@ -111,9 +117,59 @@ public Optional before(HookContext ctx, Map hints) {
assertEquals(new StringBuilder(defaultValue).reverse().toString(), doSomethingValue);
api.clearHooks();
-
+
// subsequent evaluations should now use new provider set by hook
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);
+ }
}
diff --git a/src/test/java/dev/openfeature/sdk/EventProviderTest.java b/src/test/java/dev/openfeature/sdk/EventProviderTest.java
index a5be8589c..acf2ce6b3 100644
--- a/src/test/java/dev/openfeature/sdk/EventProviderTest.java
+++ b/src/test/java/dev/openfeature/sdk/EventProviderTest.java
@@ -1,23 +1,34 @@
package dev.openfeature.sdk;
-import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-
+import dev.openfeature.sdk.exceptions.FatalError;
+import dev.openfeature.sdk.exceptions.GeneralError;
+import dev.openfeature.sdk.internal.TriConsumer;
+import lombok.SneakyThrows;
+import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
-import dev.openfeature.sdk.internal.TriConsumer;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
class EventProviderTest {
+ private TestEventProvider eventProvider;
+
+ @BeforeEach
+ @SneakyThrows
+ void setup() {
+ eventProvider = new TestEventProvider();
+ eventProvider.initialize(null);
+ }
+
@Test
@DisplayName("should run attached onEmit with emitters")
void emitsEventsWhenAttached() {
- TestEventProvider eventProvider = new TestEventProvider();
TriConsumer onEmit = mockOnEmit();
eventProvider.attach(onEmit);
@@ -37,8 +48,6 @@ void emitsEventsWhenAttached() {
@Test
@DisplayName("should do nothing with emitters if no onEmit attached")
void doesNotEmitsEventsWhenNotAttached() {
- TestEventProvider eventProvider = new TestEventProvider();
-
// don't attach this emitter
TriConsumer onEmit = mockOnEmit();
@@ -56,7 +65,6 @@ void doesNotEmitsEventsWhenNotAttached() {
@Test
@DisplayName("should throw if second different onEmit attached")
void throwsWhenOnEmitDifferent() {
- TestEventProvider eventProvider = new TestEventProvider();
TriConsumer onEmit1 = mockOnEmit();
TriConsumer onEmit2 = mockOnEmit();
eventProvider.attach(onEmit1);
@@ -67,15 +75,13 @@ void throwsWhenOnEmitDifferent() {
@Test
@DisplayName("should not throw if second same onEmit attached")
void doesNotThrowWhenOnEmitSame() {
- TestEventProvider eventProvider = new TestEventProvider();
TriConsumer onEmit1 = mockOnEmit();
TriConsumer onEmit2 = onEmit1;
eventProvider.attach(onEmit1);
eventProvider.attach(onEmit2); // should not throw, same instance. noop
}
-
- class TestEventProvider extends EventProvider {
+ static class TestEventProvider extends EventProvider {
private static final String NAME = "TestEventProvider";
@@ -86,47 +92,42 @@ public Metadata getMetadata() {
@Override
public ProviderEvaluation getBooleanEvaluation(String key, Boolean defaultValue,
- EvaluationContext ctx) {
- // TODO Auto-generated method stub
+ EvaluationContext ctx) {
throw new UnsupportedOperationException("Unimplemented method 'getBooleanEvaluation'");
}
@Override
public ProviderEvaluation getStringEvaluation(String key, String defaultValue,
- EvaluationContext ctx) {
- // TODO Auto-generated method stub
+ EvaluationContext ctx) {
throw new UnsupportedOperationException("Unimplemented method 'getStringEvaluation'");
}
@Override
public ProviderEvaluation getIntegerEvaluation(String key, Integer defaultValue,
- EvaluationContext ctx) {
- // TODO Auto-generated method stub
+ EvaluationContext ctx) {
throw new UnsupportedOperationException("Unimplemented method 'getIntegerEvaluation'");
}
@Override
public ProviderEvaluation getDoubleEvaluation(String key, Double defaultValue,
- EvaluationContext ctx) {
- // TODO Auto-generated method stub
+ EvaluationContext ctx) {
throw new UnsupportedOperationException("Unimplemented method 'getDoubleEvaluation'");
}
@Override
public ProviderEvaluation getObjectEvaluation(String key, Value defaultValue,
- EvaluationContext ctx) {
- // TODO Auto-generated method stub
+ EvaluationContext ctx) {
throw new UnsupportedOperationException("Unimplemented method 'getObjectEvaluation'");
}
@Override
- public ProviderState getState() {
- return ProviderState.READY;
+ public void attach(TriConsumer onEmit) {
+ super.attach(onEmit);
}
}
@SuppressWarnings("unchecked")
private TriConsumer mockOnEmit() {
- return (TriConsumer)mock(TriConsumer.class);
+ return (TriConsumer) mock(TriConsumer.class);
}
}
\ No newline at end of file
diff --git a/src/test/java/dev/openfeature/sdk/EventsTest.java b/src/test/java/dev/openfeature/sdk/EventsTest.java
index 6b70617f6..41bcf86c4 100644
--- a/src/test/java/dev/openfeature/sdk/EventsTest.java
+++ b/src/test/java/dev/openfeature/sdk/EventsTest.java
@@ -1,26 +1,22 @@
package dev.openfeature.sdk;
-import static org.awaitility.Awaitility.await;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.argThat;
-import static org.mockito.Mockito.after;
-import static org.mockito.Mockito.doThrow;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.timeout;
-import static org.mockito.Mockito.verify;
-
-import java.util.Arrays;
-import java.util.List;
-import java.util.function.Consumer;
-
+import dev.openfeature.sdk.testutils.TestEventsProvider;
+import io.cucumber.java.AfterAll;
+import lombok.SneakyThrows;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentMatcher;
-import dev.openfeature.sdk.testutils.TestEventsProvider;
-import io.cucumber.java.AfterAll;
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Consumer;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.awaitility.Awaitility.await;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.Mockito.*;
class EventsTest {
@@ -29,7 +25,7 @@ class EventsTest {
@AfterAll
public static void resetDefaultProvider() {
- OpenFeatureAPI.getInstance().setProvider(new NoOpProvider());
+ OpenFeatureAPI.getInstance().setProviderAndWait(new NoOpProvider());
}
@Nested
@@ -53,7 +49,7 @@ void apiInitReady() {
TestEventsProvider provider = new TestEventsProvider(INIT_DELAY);
OpenFeatureAPI.getInstance().onProviderReady(handler);
- OpenFeatureAPI.getInstance().setProvider(name, provider);
+ OpenFeatureAPI.getInstance().setProviderAndWait(name, provider);
verify(handler, timeout(TIMEOUT).atLeastOnce())
.accept(any());
}
@@ -90,7 +86,7 @@ void apiShouldPropagateEvents() {
final String name = "apiShouldPropagateEvents";
TestEventsProvider provider = new TestEventsProvider(INIT_DELAY);
- OpenFeatureAPI.getInstance().setProvider(name, provider);
+ OpenFeatureAPI.getInstance().setProviderAndWait(name, provider);
OpenFeatureAPI.getInstance().onProviderConfigurationChanged(handler);
provider.mockEvent(ProviderEvent.PROVIDER_CONFIGURATION_CHANGED, EventDetails.builder().build());
@@ -113,7 +109,7 @@ void apiShouldSupportAllEventTypes() {
final Consumer handler4 = mockHandler();
TestEventsProvider provider = new TestEventsProvider(INIT_DELAY);
- OpenFeatureAPI.getInstance().setProvider(name, provider);
+ OpenFeatureAPI.getInstance().setProviderAndWait(name, provider);
OpenFeatureAPI.getInstance().onProviderReady(handler1);
OpenFeatureAPI.getInstance().onProviderConfigurationChanged(handler2);
@@ -153,7 +149,7 @@ void shouldPropagateDefaultAndAnon() {
TestEventsProvider provider = new TestEventsProvider(INIT_DELAY);
// set provider before getting a client
- OpenFeatureAPI.getInstance().setProvider(provider);
+ OpenFeatureAPI.getInstance().setProviderAndWait(provider);
Client client = OpenFeatureAPI.getInstance().getClient();
client.onProviderStale(handler);
@@ -170,7 +166,7 @@ void shouldPropagateDefaultAndNamed() {
TestEventsProvider provider = new TestEventsProvider(INIT_DELAY);
// set provider before getting a client
- OpenFeatureAPI.getInstance().setProvider(provider);
+ OpenFeatureAPI.getInstance().setProviderAndWait(provider);
Client client = OpenFeatureAPI.getInstance().getClient(name);
client.onProviderStale(handler);
@@ -199,7 +195,7 @@ void initReadyProviderBefore() {
Client client = OpenFeatureAPI.getInstance().getClient(name);
client.onProviderReady(handler);
// set provider after getting a client
- OpenFeatureAPI.getInstance().setProvider(name, provider);
+ OpenFeatureAPI.getInstance().setProviderAndWait(name, provider);
verify(handler, timeout(TIMEOUT).atLeastOnce())
.accept(argThat(details -> details.getDomain().equals(name)));
}
@@ -213,7 +209,7 @@ void initReadyProviderAfter() {
TestEventsProvider provider = new TestEventsProvider(INIT_DELAY);
// set provider before getting a client
- OpenFeatureAPI.getInstance().setProvider(name, provider);
+ OpenFeatureAPI.getInstance().setProviderAndWait(name, provider);
Client client = OpenFeatureAPI.getInstance().getClient(name);
client.onProviderReady(handler);
verify(handler, timeout(TIMEOUT).atLeastOnce())
@@ -272,7 +268,7 @@ void shouldPropagateBefore() {
TestEventsProvider provider = new TestEventsProvider(INIT_DELAY);
// set provider before getting a client
- OpenFeatureAPI.getInstance().setProvider(name, provider);
+ OpenFeatureAPI.getInstance().setProviderAndWait(name, provider);
Client client = OpenFeatureAPI.getInstance().getClient(name);
client.onProviderConfigurationChanged(handler);
@@ -292,7 +288,7 @@ void shouldPropagateAfter() {
Client client = OpenFeatureAPI.getInstance().getClient(name);
client.onProviderConfigurationChanged(handler);
// set provider after getting a client
- OpenFeatureAPI.getInstance().setProvider(name, provider);
+ OpenFeatureAPI.getInstance().setProviderAndWait(name, provider);
provider.mockEvent(ProviderEvent.PROVIDER_CONFIGURATION_CHANGED, EventDetails.builder().build());
verify(handler, timeout(TIMEOUT)).accept(argThat(details -> details.getDomain().equals(name)));
@@ -314,7 +310,7 @@ void shouldSupportAllEventTypes() {
final Consumer handler4 = mockHandler();
TestEventsProvider provider = new TestEventsProvider(INIT_DELAY);
- OpenFeatureAPI.getInstance().setProvider(name, provider);
+ OpenFeatureAPI.getInstance().setProviderAndWait(name, provider);
Client client = OpenFeatureAPI.getInstance().getClient(name);
client.onProviderReady(handler1);
@@ -337,21 +333,21 @@ void shouldSupportAllEventTypes() {
@Test
@DisplayName("shutdown provider should not run handlers")
- void shouldNotRunHandlers() {
+ void shouldNotRunHandlers() {
final Consumer handler1 = mockHandler();
final Consumer handler2 = mockHandler();
final String name = "shouldNotRunHandlers";
TestEventsProvider provider1 = new TestEventsProvider(INIT_DELAY);
TestEventsProvider provider2 = new TestEventsProvider(INIT_DELAY);
- OpenFeatureAPI.getInstance().setProvider(name, provider1);
+ OpenFeatureAPI.getInstance().setProviderAndWait(name, provider1);
Client client = OpenFeatureAPI.getInstance().getClient(name);
// attached handlers
OpenFeatureAPI.getInstance().onProviderConfigurationChanged(handler1);
client.onProviderConfigurationChanged(handler2);
- OpenFeatureAPI.getInstance().setProvider(name, provider2);
+ OpenFeatureAPI.getInstance().setProviderAndWait(name, provider2);
// wait for the new provider to be ready and make sure things are cleaned up.
await().until(() -> provider1.isShutDown());
@@ -377,8 +373,8 @@ void otherClientHandlersShouldNotRun() {
TestEventsProvider provider1 = new TestEventsProvider(INIT_DELAY);
TestEventsProvider provider2 = new TestEventsProvider(INIT_DELAY);
- OpenFeatureAPI.getInstance().setProvider(name1, provider1);
- OpenFeatureAPI.getInstance().setProvider(name2, provider2);
+ OpenFeatureAPI.getInstance().setProviderAndWait(name1, provider1);
+ OpenFeatureAPI.getInstance().setProviderAndWait(name2, provider2);
Client client1 = OpenFeatureAPI.getInstance().getClient(name1);
Client client2 = OpenFeatureAPI.getInstance().getClient(name2);
@@ -402,11 +398,11 @@ void boundShouldNotRunWithDefault() {
TestEventsProvider namedProvider = new TestEventsProvider(INIT_DELAY);
TestEventsProvider defaultProvider = new TestEventsProvider(INIT_DELAY);
- OpenFeatureAPI.getInstance().setProvider(defaultProvider);
+ OpenFeatureAPI.getInstance().setProviderAndWait(defaultProvider);
Client client = OpenFeatureAPI.getInstance().getClient(name);
client.onProviderConfigurationChanged(handlerNotToRun);
- OpenFeatureAPI.getInstance().setProvider(name, namedProvider);
+ OpenFeatureAPI.getInstance().setProviderAndWait(name, namedProvider);
// await the new provider to make sure the old one is shut down
await().until(() -> namedProvider.getState().equals(ProviderState.READY));
@@ -415,7 +411,7 @@ void boundShouldNotRunWithDefault() {
defaultProvider.mockEvent(ProviderEvent.PROVIDER_CONFIGURATION_CHANGED, ProviderEventDetails.builder().build());
verify(handlerNotToRun, after(TIMEOUT).never()).accept(any());
- OpenFeatureAPI.getInstance().setProvider(new NoOpProvider());
+ OpenFeatureAPI.getInstance().setProviderAndWait(new NoOpProvider());
}
@Test
@@ -427,7 +423,7 @@ void unboundShouldRunWithDefault() {
final Consumer handlerToRun = mockHandler();
TestEventsProvider defaultProvider = new TestEventsProvider(INIT_DELAY);
- OpenFeatureAPI.getInstance().setProvider(defaultProvider);
+ OpenFeatureAPI.getInstance().setProviderAndWait(defaultProvider);
Client client = OpenFeatureAPI.getInstance().getClient(name);
client.onProviderConfigurationChanged(handlerToRun);
@@ -439,7 +435,7 @@ void unboundShouldRunWithDefault() {
defaultProvider.mockEvent(ProviderEvent.PROVIDER_CONFIGURATION_CHANGED, ProviderEventDetails.builder().build());
verify(handlerToRun, timeout(TIMEOUT)).accept(any());
- OpenFeatureAPI.getInstance().setProvider(new NoOpProvider());
+ OpenFeatureAPI.getInstance().setProviderAndWait(new NoOpProvider());
}
@Test
@@ -453,7 +449,7 @@ void handlersRunIfOneThrows() {
final Consumer lastHandler = mockHandler();
TestEventsProvider provider = new TestEventsProvider(INIT_DELAY);
- OpenFeatureAPI.getInstance().setProvider(name, provider);
+ OpenFeatureAPI.getInstance().setProviderAndWait(name, provider);
Client client1 = OpenFeatureAPI.getInstance().getClient(name);
@@ -477,7 +473,7 @@ void shouldHaveAllProperties() {
final String name = "shouldHaveAllProperties";
TestEventsProvider provider = new TestEventsProvider(INIT_DELAY);
- OpenFeatureAPI.getInstance().setProvider(name, provider);
+ OpenFeatureAPI.getInstance().setProviderAndWait(name, provider);
Client client = OpenFeatureAPI.getInstance().getClient(name);
// attached handlers
@@ -520,8 +516,8 @@ void matchingReadyEventsMustRunImmediately() {
final Consumer handler = mockHandler();
// provider which is already ready
- TestEventsProvider provider = new TestEventsProvider(ProviderState.READY);
- OpenFeatureAPI.getInstance().setProvider(name, provider);
+ TestEventsProvider provider = new TestEventsProvider();
+ OpenFeatureAPI.getInstance().setProviderAndWait(name, provider);
// should run even thought handler was added after ready
Client client = OpenFeatureAPI.getInstance().getClient(name);
@@ -535,13 +531,16 @@ void matchingReadyEventsMustRunImmediately() {
void matchingStaleEventsMustRunImmediately() {
final String name = "matchingEventsMustRunImmediately";
final Consumer handler = mockHandler();
+ OpenFeatureAPI api = OpenFeatureAPI.getInstance();
// provider which is already stale
- TestEventsProvider provider = new TestEventsProvider(ProviderState.STALE);
- OpenFeatureAPI.getInstance().setProvider(name, provider);
+ TestEventsProvider provider = TestEventsProvider.newInitializedTestEventsProvider();
+ Client client = api.getClient(name);
+ api.setProviderAndWait(name, provider);
+ provider.emitProviderStale(ProviderEventDetails.builder().build());
+ assertThat(client.getProviderState()).isEqualTo(ProviderState.STALE);
// should run even thought handler was added after stale
- Client client = OpenFeatureAPI.getInstance().getClient(name);
client.onProviderStale(handler);
verify(handler, timeout(TIMEOUT)).accept(any());
}
@@ -552,13 +551,17 @@ void matchingStaleEventsMustRunImmediately() {
void matchingErrorEventsMustRunImmediately() {
final String name = "matchingEventsMustRunImmediately";
final Consumer handler = mockHandler();
+ OpenFeatureAPI api = OpenFeatureAPI.getInstance();
// provider which is already in error
- TestEventsProvider provider = new TestEventsProvider(ProviderState.ERROR);
- OpenFeatureAPI.getInstance().setProvider(name, provider);
+ TestEventsProvider provider = new TestEventsProvider();
+ Client client = api.getClient(name);
+ api.setProviderAndWait(name, provider);
+ provider.emitProviderError(ProviderEventDetails.builder().build());
+ assertThat(client.getProviderState()).isEqualTo(ProviderState.ERROR);
+
// should run even thought handler was added after error
- Client client = OpenFeatureAPI.getInstance().getClient(name);
client.onProviderError(handler);
verify(handler, timeout(TIMEOUT)).accept(any());
}
@@ -573,7 +576,7 @@ void mustPersistAcrossChanges() {
TestEventsProvider provider1 = new TestEventsProvider(INIT_DELAY);
TestEventsProvider provider2 = new TestEventsProvider(INIT_DELAY);
- OpenFeatureAPI.getInstance().setProvider(name, provider1);
+ OpenFeatureAPI.getInstance().setProviderAndWait(name, provider1);
Client client = OpenFeatureAPI.getInstance().getClient(name);
client.onProviderConfigurationChanged(handler);
@@ -583,8 +586,7 @@ void mustPersistAcrossChanges() {
verify(handler, timeout(TIMEOUT).times(1)).accept(argThat(nameMatches));
// wait for the new provider to be ready.
- OpenFeatureAPI.getInstance().setProvider(name, provider2);
- await().until(() -> provider2.getState().equals(ProviderState.READY));
+ OpenFeatureAPI.getInstance().setProviderAndWait(name, provider2);
// verify that with the new provider under the same name, the handler is called
// again.
@@ -594,16 +596,17 @@ void mustPersistAcrossChanges() {
@Nested
class HandlerRemoval {
- @Specification(number="5.2.7", text="The API and client MUST provide a function allowing the removal of event handlers.")
+ @Specification(number = "5.2.7", text = "The API and client MUST provide a function allowing the removal of event handlers.")
@Test
@DisplayName("should not run removed events")
+ @SneakyThrows
void removedEventsShouldNotRun() {
final String name = "removedEventsShouldNotRun";
final Consumer handler1 = mockHandler();
final Consumer handler2 = mockHandler();
TestEventsProvider provider = new TestEventsProvider(INIT_DELAY);
- OpenFeatureAPI.getInstance().setProvider(name, provider);
+ OpenFeatureAPI.getInstance().setProviderAndWait(name, provider);
Client client = OpenFeatureAPI.getInstance().getClient(name);
// attached handlers
@@ -615,7 +618,7 @@ void removedEventsShouldNotRun() {
// emit event
provider.mockEvent(ProviderEvent.PROVIDER_CONFIGURATION_CHANGED, ProviderEventDetails.builder().build());
-
+
// both global and client handlers should not run.
verify(handler1, after(TIMEOUT).never()).accept(any());
verify(handler2, never()).accept(any());
diff --git a/src/test/java/dev/openfeature/sdk/FeatureProviderStateManagerTest.java b/src/test/java/dev/openfeature/sdk/FeatureProviderStateManagerTest.java
new file mode 100644
index 000000000..9d05524f1
--- /dev/null
+++ b/src/test/java/dev/openfeature/sdk/FeatureProviderStateManagerTest.java
@@ -0,0 +1,181 @@
+package dev.openfeature.sdk;
+
+import dev.openfeature.sdk.exceptions.FatalError;
+import dev.openfeature.sdk.exceptions.GeneralError;
+import lombok.SneakyThrows;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import javax.annotation.Nullable;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+class FeatureProviderStateManagerTest {
+
+ private FeatureProviderStateManager wrapper;
+ private TestDelegate testDelegate;
+
+ @BeforeEach
+ public void setUp() {
+ testDelegate = new TestDelegate();
+ wrapper = new FeatureProviderStateManager(testDelegate);
+ }
+
+ @SneakyThrows
+ @Test
+ void shouldOnlyCallInitOnce() {
+ wrapper.initialize(null);
+ wrapper.initialize(null);
+ assertThat(testDelegate.initCalled.get()).isOne();
+ }
+
+ @SneakyThrows
+ @Test
+ void shouldCallInitTwiceWhenShutDownInTheMeantime() {
+ wrapper.initialize(null);
+ wrapper.shutdown();
+ wrapper.initialize(null);
+ assertThat(testDelegate.initCalled.get()).isEqualTo(2);
+ assertThat(testDelegate.shutdownCalled.get()).isOne();
+ }
+
+ @Test
+ void shouldSetStateToNotReadyAfterConstruction() {
+ assertThat(wrapper.getState()).isEqualTo(ProviderState.NOT_READY);
+ }
+
+ @SneakyThrows
+ @Test
+ @Specification(number = "1.7.3", text = "The client's provider status accessor MUST indicate READY if the initialize function of the associated provider terminates normally.")
+ void shouldSetStateToReadyAfterInit() {
+ assertThat(wrapper.getState()).isEqualTo(ProviderState.NOT_READY);
+ wrapper.initialize(null);
+ assertThat(wrapper.getState()).isEqualTo(ProviderState.READY);
+ }
+
+ @SneakyThrows
+ @Test
+ void shouldSetStateToNotReadyAfterShutdown() {
+ assertThat(wrapper.getState()).isEqualTo(ProviderState.NOT_READY);
+ wrapper.initialize(null);
+ assertThat(wrapper.getState()).isEqualTo(ProviderState.READY);
+ wrapper.shutdown();
+ assertThat(wrapper.getState()).isEqualTo(ProviderState.NOT_READY);
+ }
+
+ @Specification(number = "1.7.4", text = "The client's provider status accessor MUST indicate ERROR if the initialize function of the associated provider terminates abnormally.")
+ @Test
+ void shouldSetStateToErrorAfterErrorOnInit() {
+ testDelegate.throwOnInit = new Exception();
+ assertThat(wrapper.getState()).isEqualTo(ProviderState.NOT_READY);
+ assertThrows(Exception.class, () -> wrapper.initialize(null));
+ assertThat(wrapper.getState()).isEqualTo(ProviderState.ERROR);
+ }
+
+ @Specification(number = "1.7.4", text = "The client's provider status accessor MUST indicate ERROR if the initialize function of the associated provider terminates abnormally.")
+ @Test
+ void shouldSetStateToErrorAfterOpenFeatureErrorOnInit() {
+ testDelegate.throwOnInit = new GeneralError();
+ assertThat(wrapper.getState()).isEqualTo(ProviderState.NOT_READY);
+ assertThrows(GeneralError.class, () -> wrapper.initialize(null));
+ assertThat(wrapper.getState()).isEqualTo(ProviderState.ERROR);
+ }
+
+ @Specification(number = "1.7.5", text = "The client's provider status accessor MUST indicate FATAL if the initialize function of the associated provider terminates abnormally and indicates error code PROVIDER_FATAL.")
+ @Test
+ void shouldSetStateToErrorAfterFatalErrorOnInit() {
+ testDelegate.throwOnInit = new FatalError();
+ assertThat(wrapper.getState()).isEqualTo(ProviderState.NOT_READY);
+ assertThrows(FatalError.class, () -> wrapper.initialize(null));
+ assertThat(wrapper.getState()).isEqualTo(ProviderState.FATAL);
+ }
+
+ @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 shouldSetTheStateToReadyWhenAReadyEventIsEmitted() {
+ assertThat(wrapper.getState()).isEqualTo(ProviderState.NOT_READY);
+ wrapper.onEmit(ProviderEvent.PROVIDER_READY, null);
+ assertThat(wrapper.getState()).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 shouldSetTheStateToStaleWhenAStaleEventIsEmitted() {
+ assertThat(wrapper.getState()).isEqualTo(ProviderState.NOT_READY);
+ wrapper.onEmit(ProviderEvent.PROVIDER_STALE, null);
+ assertThat(wrapper.getState()).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 shouldSetTheStateToErrorWhenAnErrorEventIsEmitted() {
+ assertThat(wrapper.getState()).isEqualTo(ProviderState.NOT_READY);
+ wrapper.onEmit(
+ ProviderEvent.PROVIDER_ERROR,
+ ProviderEventDetails.builder().errorCode(ErrorCode.GENERAL).build()
+ );
+ assertThat(wrapper.getState()).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 shouldSetTheStateToFatalWhenAFatalErrorEventIsEmitted() {
+ assertThat(wrapper.getState()).isEqualTo(ProviderState.NOT_READY);
+ wrapper.onEmit(
+ ProviderEvent.PROVIDER_ERROR,
+ ProviderEventDetails.builder().errorCode(ErrorCode.PROVIDER_FATAL).build()
+ );
+ assertThat(wrapper.getState()).isEqualTo(ProviderState.FATAL);
+ }
+
+ static class TestDelegate extends EventProvider {
+ private final AtomicInteger initCalled = new AtomicInteger();
+ private final AtomicInteger shutdownCalled = new AtomicInteger();
+ private @Nullable Exception throwOnInit;
+
+ @Override
+ public Metadata getMetadata() {
+ return null;
+ }
+
+ @Override
+ public ProviderEvaluation getBooleanEvaluation(String key, Boolean defaultValue, EvaluationContext ctx) {
+ return null;
+ }
+
+ @Override
+ public ProviderEvaluation getStringEvaluation(String key, String defaultValue, EvaluationContext ctx) {
+ return null;
+ }
+
+ @Override
+ public ProviderEvaluation getIntegerEvaluation(String key, Integer defaultValue, EvaluationContext ctx) {
+ return null;
+ }
+
+ @Override
+ public ProviderEvaluation getDoubleEvaluation(String key, Double defaultValue, EvaluationContext ctx) {
+ return null;
+ }
+
+ @Override
+ public ProviderEvaluation getObjectEvaluation(String key, Value defaultValue, EvaluationContext ctx) {
+ return null;
+ }
+
+ @Override
+ public void initialize(EvaluationContext evaluationContext) throws Exception {
+ initCalled.incrementAndGet();
+ if (throwOnInit != null) {
+ throw throwOnInit;
+ }
+ }
+
+ @Override
+ public void shutdown() {
+ shutdownCalled.incrementAndGet();
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/dev/openfeature/sdk/FlagEvaluationSpecTest.java b/src/test/java/dev/openfeature/sdk/FlagEvaluationSpecTest.java
index b4978cb4b..a2316a59c 100644
--- a/src/test/java/dev/openfeature/sdk/FlagEvaluationSpecTest.java
+++ b/src/test/java/dev/openfeature/sdk/FlagEvaluationSpecTest.java
@@ -1,28 +1,11 @@
package dev.openfeature.sdk;
-import static dev.openfeature.sdk.DoSomethingProvider.DEFAULT_METADATA;
-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.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertNull;
-import static org.junit.jupiter.api.Assertions.assertSame;
-import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.argThat;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-
-import org.awaitility.Awaitility;
+import dev.openfeature.sdk.exceptions.GeneralError;
+import dev.openfeature.sdk.fixtures.HookFixtures;
+import dev.openfeature.sdk.providers.memory.InMemoryProvider;
+import dev.openfeature.sdk.testutils.FeatureProviderTestUtils;
+import dev.openfeature.sdk.testutils.TestEventsProvider;
+import lombok.SneakyThrows;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@@ -30,12 +13,17 @@
import org.simplify4u.slf4jmock.LoggerMock;
import org.slf4j.Logger;
-import dev.openfeature.sdk.exceptions.GeneralError;
-import dev.openfeature.sdk.fixtures.HookFixtures;
-import dev.openfeature.sdk.providers.memory.InMemoryProvider;
-import dev.openfeature.sdk.testutils.FeatureProviderTestUtils;
-import dev.openfeature.sdk.testutils.TestEventsProvider;
-import lombok.SneakyThrows;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+import static dev.openfeature.sdk.DoSomethingProvider.DEFAULT_METADATA;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.Mockito.*;
class FlagEvaluationSpecTest implements HookFixtures {
@@ -47,6 +35,14 @@ private Client _client() {
return api.getClient();
}
+ @SneakyThrows
+ private Client _initializedClient() {
+ TestEventsProvider provider = new TestEventsProvider();
+ provider.initialize(null);
+ FeatureProviderTestUtils.setFeatureProvider(provider);
+ return api.getClient();
+ }
+
@BeforeEach
void getApiInstance() {
api = OpenFeatureAPI.getInstance();
@@ -82,12 +78,14 @@ void getApiInstance() {
@Test void providerAndWait() {
FeatureProvider provider = new TestEventsProvider(500);
OpenFeatureAPI.getInstance().setProviderAndWait(provider);
- assertThat(api.getProvider().getState()).isEqualTo(ProviderState.READY);
+ Client client = api.getClient();
+ assertThat(client.getProviderState()).isEqualTo(ProviderState.READY);
provider = new TestEventsProvider(500);
String providerName = "providerAndWait";
OpenFeatureAPI.getInstance().setProviderAndWait(providerName, provider);
- assertThat(api.getProvider(providerName).getState()).isEqualTo(ProviderState.READY);
+ Client client2 = api.getClient(providerName);
+ assertThat(client2.getProviderState()).isEqualTo(ProviderState.READY);
}
@SneakyThrows
@@ -103,17 +101,13 @@ void getApiInstance() {
@Specification(number="2.4.5", text="The provider SHOULD indicate an error if flag resolution is attempted before the provider is ready.")
@Test void shouldReturnNotReadyIfNotInitialized() {
- FeatureProvider provider = new InMemoryProvider(new HashMap<>()) {
- @Override
- public void initialize(EvaluationContext evaluationContext) throws Exception {
- Awaitility.await().wait(3000);
- }
- };
+ FeatureProvider provider = new TestEventsProvider(100);
String providerName = "shouldReturnNotReadyIfNotInitialized";
OpenFeatureAPI.getInstance().setProvider(providerName, provider);
- assertThat(api.getProvider(providerName).getState()).isEqualTo(ProviderState.NOT_READY);
Client client = OpenFeatureAPI.getInstance().getClient(providerName);
- assertEquals(ErrorCode.PROVIDER_NOT_READY, client.getBooleanDetails("return_error_when_not_initialized", false).getErrorCode());
+ FlagEvaluationDetails details = client.getBooleanDetails("return_error_when_not_initialized", false);
+ assertEquals(ErrorCode.PROVIDER_NOT_READY, details.getErrorCode());
+ assertEquals(Reason.ERROR.toString(), details.getReason());
}
@Specification(number="1.1.5", text="The API MUST provide a function for retrieving the metadata field of the configured provider.")
@@ -240,8 +234,9 @@ public void initialize(EvaluationContext evaluationContext) throws Exception {
}
@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();
+ @SneakyThrows
+ @Test void hooks() {
+ Client c = _initializedClient();
Hook clientHook = mockBooleanHook();
Hook invocationHook = mockBooleanHook();
c.addHooks(clientHook);
@@ -259,10 +254,29 @@ public void initialize(EvaluationContext evaluationContext) throws Exception {
@Test void broken_provider() {
FeatureProviderTestUtils.setFeatureProvider(new AlwaysBrokenProvider());
Client c = api.getClient();
- assertFalse(c.getBooleanValue("key", false));
- FlagEvaluationDetails
+ 
@@ -59,7 +59,7 @@ Note that this library is intended to be used in server-side contexts and has no