getObjectEvaluation(String key, Value defaultValue, EvaluationContext ctx);
+
+ /**
+ * This method is called before a provider is used to evaluate flags. Providers
+ * can overwrite this method,
+ * if they have special initialization needed prior being called for flag
+ * evaluation.
+ *
+ * It is ok, if the method is expensive as it is executed in the background. All
+ * runtime exceptions will be
+ * caught and logged.
+ *
+ */
+ default void initialize(EvaluationContext evaluationContext) throws Exception {
+ // Intentionally left blank
+ }
+
+ /**
+ * This method is called when a new provider is about to be used to evaluate
+ * flags, or the SDK is shut down.
+ * Providers can overwrite this method, if they have special shutdown actions
+ * needed.
+ *
+ * It is ok, if the method is expensive as it is executed in the background. All
+ * runtime exceptions will be
+ * caught and logged.
+ *
+ */
+ default void shutdown() {
+ // Intentionally left blank
+ }
+
+ /**
+ * Returns a representation of the current readiness of the provider.
+ * Providers which do not implement this method are assumed to be ready immediately.
+ *
+ * @return ProviderState
+ */
+ default ProviderState getState() {
+ return ProviderState.READY;
+ }
+
}
diff --git a/src/main/java/dev/openfeature/sdk/FlagEvaluationDetails.java b/src/main/java/dev/openfeature/sdk/FlagEvaluationDetails.java
index 67ee853d..78e04c71 100644
--- a/src/main/java/dev/openfeature/sdk/FlagEvaluationDetails.java
+++ b/src/main/java/dev/openfeature/sdk/FlagEvaluationDetails.java
@@ -1,29 +1,37 @@
package dev.openfeature.sdk;
+import javax.annotation.Nullable;
+
+import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
-
-import javax.annotation.Nullable;
+import lombok.NoArgsConstructor;
/**
- * Contains information about how the evaluation happened, including any resolved values.
+ * Contains information about how the provider resolved a flag, including the resolved value.
+ *
* @param the type of the flag being evaluated.
*/
-@Data @Builder
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
public class FlagEvaluationDetails implements BaseEvaluation {
+
private String flagKey;
private T value;
@Nullable private String variant;
@Nullable private String reason;
private ErrorCode errorCode;
@Nullable private String errorMessage;
+ @Builder.Default private ImmutableMetadata flagMetadata = ImmutableMetadata.builder().build();
/**
* Generate detail payload from the provider response.
*
* @param providerEval provider response
- * @param flagKey key for the flag being evaluated
- * @param type of flag being returned
+ * @param flagKey key for the flag being evaluated
+ * @param type of flag being returned
* @return detail payload
*/
public static FlagEvaluationDetails from(ProviderEvaluation providerEval, String flagKey) {
@@ -33,6 +41,7 @@ public static FlagEvaluationDetails from(ProviderEvaluation providerEv
.variant(providerEval.getVariant())
.reason(providerEval.getReason())
.errorCode(providerEval.getErrorCode())
+ .flagMetadata(providerEval.getFlagMetadata())
.build();
}
}
diff --git a/src/main/java/dev/openfeature/sdk/ImmutableMetadata.java b/src/main/java/dev/openfeature/sdk/ImmutableMetadata.java
new file mode 100644
index 00000000..1bc130b4
--- /dev/null
+++ b/src/main/java/dev/openfeature/sdk/ImmutableMetadata.java
@@ -0,0 +1,191 @@
+package dev.openfeature.sdk;
+
+import lombok.extern.slf4j.Slf4j;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Immutable Flag Metadata representation. Implementation is backed by a {@link Map} and immutability is provided
+ * through builder and accessors.
+ */
+@Slf4j
+public class ImmutableMetadata {
+ private final Map metadata;
+
+ private ImmutableMetadata(Map metadata) {
+ this.metadata = metadata;
+ }
+
+ /**
+ * Retrieve a {@link String} value for the given key. A {@code null} value is returned if the key does not exist
+ * or if the value is of a different type.
+ *
+ * @param key flag metadata key to retrieve
+ */
+ public String getString(final String key) {
+ return getValue(key, String.class);
+ }
+
+ /**
+ * Retrieve a {@link Integer} value for the given key. A {@code null} value is returned if the key does not exist
+ * or if the value is of a different type.
+ *
+ * @param key flag metadata key to retrieve
+ */
+ public Integer getInteger(final String key) {
+ return getValue(key, Integer.class);
+ }
+
+ /**
+ * Retrieve a {@link Long} value for the given key. A {@code null} value is returned if the key does not exist
+ * or if the value is of a different type.
+ *
+ * @param key flag metadata key to retrieve
+ */
+ public Long getLong(final String key) {
+ return getValue(key, Long.class);
+ }
+
+ /**
+ * Retrieve a {@link Float} value for the given key. A {@code null} value is returned if the key does not exist
+ * or if the value is of a different type.
+ *
+ * @param key flag metadata key to retrieve
+ */
+ public Float getFloat(final String key) {
+ return getValue(key, Float.class);
+ }
+
+ /**
+ * Retrieve a {@link Double} value for the given key. A {@code null} value is returned if the key does not exist
+ * or if the value is of a different type.
+ *
+ * @param key flag metadata key to retrieve
+ */
+ public Double getDouble(final String key) {
+ return getValue(key, Double.class);
+ }
+
+ /**
+ * Retrieve a {@link Boolean} value for the given key. A {@code null} value is returned if the key does not exist
+ * or if the value is of a different type.
+ *
+ * @param key flag metadata key to retrieve
+ */
+ public Boolean getBoolean(final String key) {
+ return getValue(key, Boolean.class);
+ }
+
+ /**
+ * Generic value retrieval for the given key.
+ */
+ public T getValue(final String key, final Class type) {
+ final Object o = metadata.get(key);
+
+ if (o == null) {
+ log.debug("Metadata key " + key + "does not exist");
+ return null;
+ }
+
+ try {
+ return type.cast(o);
+ } catch (ClassCastException e) {
+ log.debug("Error retrieving value for key " + key, e);
+ return null;
+ }
+ }
+
+
+ /**
+ * Obtain a builder for {@link ImmutableMetadata}.
+ */
+ public static ImmutableMetadataBuilder builder() {
+ return new ImmutableMetadataBuilder();
+ }
+
+ /**
+ * Immutable builder for {@link ImmutableMetadata}.
+ */
+ public static class ImmutableMetadataBuilder {
+ private final Map metadata;
+
+ private ImmutableMetadataBuilder() {
+ metadata = new HashMap<>();
+ }
+
+ /**
+ * Add String value to the metadata.
+ *
+ * @param key flag metadata key to add
+ * @param value flag metadata value to add
+ */
+ public ImmutableMetadataBuilder addString(final String key, final String value) {
+ metadata.put(key, value);
+ return this;
+ }
+
+ /**
+ * Add Integer value to the metadata.
+ *
+ * @param key flag metadata key to add
+ * @param value flag metadata value to add
+ */
+ public ImmutableMetadataBuilder addInteger(final String key, final Integer value) {
+ metadata.put(key, value);
+ return this;
+ }
+
+ /**
+ * Add Long value to the metadata.
+ *
+ * @param key flag metadata key to add
+ * @param value flag metadata value to add
+ */
+ public ImmutableMetadataBuilder addLong(final String key, final Long value) {
+ metadata.put(key, value);
+ return this;
+ }
+
+ /**
+ * Add Float value to the metadata.
+ *
+ * @param key flag metadata key to add
+ * @param value flag metadata value to add
+ */
+ public ImmutableMetadataBuilder addFloat(final String key, final Float value) {
+ metadata.put(key, value);
+ return this;
+ }
+
+ /**
+ * Add Double value to the metadata.
+ *
+ * @param key flag metadata key to add
+ * @param value flag metadata value to add
+ */
+ public ImmutableMetadataBuilder addDouble(final String key, final Double value) {
+ metadata.put(key, value);
+ return this;
+ }
+
+ /**
+ * Add Boolean value to the metadata.
+ *
+ * @param key flag metadata key to add
+ * @param value flag metadata value to add
+ */
+ public ImmutableMetadataBuilder addBoolean(final String key, final Boolean value) {
+ metadata.put(key, value);
+ return this;
+ }
+
+ /**
+ * Retrieve {@link ImmutableMetadata} with provided key,value pairs.
+ */
+ public ImmutableMetadata build() {
+ return new ImmutableMetadata(this.metadata);
+ }
+
+ }
+}
diff --git a/src/main/java/dev/openfeature/sdk/MutableContext.java b/src/main/java/dev/openfeature/sdk/MutableContext.java
index 6abd74a5..9e7069ca 100644
--- a/src/main/java/dev/openfeature/sdk/MutableContext.java
+++ b/src/main/java/dev/openfeature/sdk/MutableContext.java
@@ -4,6 +4,7 @@
import java.util.List;
import java.util.Map;
+import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
@@ -16,6 +17,7 @@
* be modified after instantiation.
*/
@ToString
+@EqualsAndHashCode
@SuppressWarnings("PMD.BeanMembersShouldSerialize")
public class MutableContext implements EvaluationContext {
@@ -88,7 +90,7 @@ public MutableContext add(String key, List value) {
@Override
public EvaluationContext merge(EvaluationContext overridingContext) {
if (overridingContext == null) {
- return new MutableContext(this.asMap());
+ return new MutableContext(this.targetingKey, this.asMap());
}
Map merged = this.merge(map -> new MutableStructure(map),
diff --git a/src/main/java/dev/openfeature/sdk/NoOpProvider.java b/src/main/java/dev/openfeature/sdk/NoOpProvider.java
index c2e841a5..d3d9ca21 100644
--- a/src/main/java/dev/openfeature/sdk/NoOpProvider.java
+++ b/src/main/java/dev/openfeature/sdk/NoOpProvider.java
@@ -10,6 +10,12 @@ public class NoOpProvider implements FeatureProvider {
@Getter
private final String name = "No-op Provider";
+ // The Noop provider is ALWAYS NOT_READY, otherwise READY handlers would run immediately when attached.
+ @Override
+ public ProviderState getState() {
+ return ProviderState.NOT_READY;
+ }
+
@Override
public Metadata getMetadata() {
return new Metadata() {
diff --git a/src/main/java/dev/openfeature/sdk/OpenFeatureAPI.java b/src/main/java/dev/openfeature/sdk/OpenFeatureAPI.java
index e85f4e13..42ff4708 100644
--- a/src/main/java/dev/openfeature/sdk/OpenFeatureAPI.java
+++ b/src/main/java/dev/openfeature/sdk/OpenFeatureAPI.java
@@ -3,27 +3,31 @@
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
+import java.util.Set;
+import java.util.function.Consumer;
import javax.annotation.Nullable;
import dev.openfeature.sdk.internal.AutoCloseableLock;
import dev.openfeature.sdk.internal.AutoCloseableReentrantReadWriteLock;
+import lombok.extern.slf4j.Slf4j;
/**
- * A global singleton which holds base configuration for the OpenFeature library.
+ * A global singleton which holds base configuration for the OpenFeature
+ * library.
* Configuration here will be shared across all {@link Client}s.
*/
-public class OpenFeatureAPI {
+@Slf4j
+public class OpenFeatureAPI implements EventBus {
// package-private multi-read/single-write lock
- static AutoCloseableReentrantReadWriteLock hooksLock = new AutoCloseableReentrantReadWriteLock();
- static AutoCloseableReentrantReadWriteLock providerLock = new AutoCloseableReentrantReadWriteLock();
- static AutoCloseableReentrantReadWriteLock contextLock = new AutoCloseableReentrantReadWriteLock();
- private FeatureProvider provider;
+ static AutoCloseableReentrantReadWriteLock lock = new AutoCloseableReentrantReadWriteLock();
private EvaluationContext evaluationContext;
- private List apiHooks;
+ private final List apiHooks;
+ private ProviderRepository providerRepository = new ProviderRepository();
+ private EventSupport eventSupport = new EventSupport();
- private OpenFeatureAPI() {
- this.apiHooks = new ArrayList<>();
+ protected OpenFeatureAPI() {
+ apiHooks = new ArrayList<>();
}
private static class SingletonHolder {
@@ -32,6 +36,7 @@ private static class SingletonHolder {
/**
* Provisions the {@link OpenFeatureAPI} singleton (if needed) and returns it.
+ *
* @return The singleton instance.
*/
public static OpenFeatureAPI getInstance() {
@@ -39,26 +44,41 @@ public static OpenFeatureAPI getInstance() {
}
public Metadata getProviderMetadata() {
- return provider.getMetadata();
+ return getProvider().getMetadata();
}
+ public Metadata getProviderMetadata(String clientName) {
+ return getProvider(clientName).getMetadata();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
public Client getClient() {
return getClient(null, null);
}
+ /**
+ * {@inheritDoc}
+ */
public Client getClient(@Nullable String name) {
return getClient(name, null);
}
+ /**
+ * {@inheritDoc}
+ */
public Client getClient(@Nullable String name, @Nullable String version) {
- return new OpenFeatureClient(this, name, version);
+ return new OpenFeatureClient(this,
+ name,
+ version);
}
/**
* {@inheritDoc}
*/
public void setEvaluationContext(EvaluationContext evaluationContext) {
- try (AutoCloseableLock __ = contextLock.writeLockAutoCloseable()) {
+ try (AutoCloseableLock __ = lock.writeLockAutoCloseable()) {
this.evaluationContext = evaluationContext;
}
}
@@ -67,34 +87,87 @@ public void setEvaluationContext(EvaluationContext evaluationContext) {
* {@inheritDoc}
*/
public EvaluationContext getEvaluationContext() {
- try (AutoCloseableLock __ = contextLock.readLockAutoCloseable()) {
+ try (AutoCloseableLock __ = lock.readLockAutoCloseable()) {
return this.evaluationContext;
}
}
/**
- * {@inheritDoc}
+ * Set the default provider.
*/
public void setProvider(FeatureProvider provider) {
- try (AutoCloseableLock __ = providerLock.writeLockAutoCloseable()) {
- this.provider = provider;
+ try (AutoCloseableLock __ = lock.writeLockAutoCloseable()) {
+ providerRepository.setProvider(
+ provider,
+ (p) -> attachEventProvider(p),
+ (p) -> emitReady(p),
+ (p) -> detachEventProvider(p),
+ (p, message) -> emitError(p, message));
}
}
/**
- * {@inheritDoc}
+ * Add a provider for a named client.
+ *
+ * @param clientName The name of the client.
+ * @param provider The provider to set.
*/
- public FeatureProvider getProvider() {
- try (AutoCloseableLock __ = providerLock.readLockAutoCloseable()) {
- return this.provider;
+ public void setProvider(String clientName, FeatureProvider provider) {
+ try (AutoCloseableLock __ = lock.writeLockAutoCloseable()) {
+ providerRepository.setProvider(clientName,
+ provider,
+ this::attachEventProvider,
+ this::emitReady,
+ this::detachEventProvider,
+ this::emitError);
+ }
+ }
+
+ private void attachEventProvider(FeatureProvider provider) {
+ if (provider instanceof EventProvider) {
+ ((EventProvider)provider).attach((p, event, details) -> {
+ runHandlersForProvider(p, event, details);
+ });
}
}
+ private void emitReady(FeatureProvider provider) {
+ runHandlersForProvider(provider, ProviderEvent.PROVIDER_READY, ProviderEventDetails.builder().build());
+ }
+
+ private void detachEventProvider(FeatureProvider provider) {
+ if (provider instanceof EventProvider) {
+ ((EventProvider)provider).detach();
+ }
+ }
+
+ private void emitError(FeatureProvider provider, String message) {
+ runHandlersForProvider(provider, ProviderEvent.PROVIDER_ERROR,
+ ProviderEventDetails.builder().message(message).build());
+ }
+
+ /**
+ * Return the default provider.
+ */
+ public FeatureProvider getProvider() {
+ return providerRepository.getProvider();
+ }
+
+ /**
+ * Fetch a provider for a named client. If not found, return the default.
+ *
+ * @param name The client name to look for.
+ * @return A named {@link FeatureProvider}
+ */
+ public FeatureProvider getProvider(String name) {
+ return providerRepository.getProvider(name);
+ }
+
/**
* {@inheritDoc}
*/
public void addHooks(Hook... hooks) {
- try (AutoCloseableLock __ = hooksLock.writeLockAutoCloseable()) {
+ try (AutoCloseableLock __ = lock.writeLockAutoCloseable()) {
this.apiHooks.addAll(Arrays.asList(hooks));
}
}
@@ -103,7 +176,7 @@ public void addHooks(Hook... hooks) {
* {@inheritDoc}
*/
public List getHooks() {
- try (AutoCloseableLock __ = hooksLock.readLockAutoCloseable()) {
+ try (AutoCloseableLock __ = lock.readLockAutoCloseable()) {
return this.apiHooks;
}
}
@@ -112,8 +185,124 @@ public List getHooks() {
* {@inheritDoc}
*/
public void clearHooks() {
- try (AutoCloseableLock __ = hooksLock.writeLockAutoCloseable()) {
+ try (AutoCloseableLock __ = lock.writeLockAutoCloseable()) {
this.apiHooks.clear();
}
}
+
+ public void shutdown() {
+ providerRepository.shutdown();
+ eventSupport.shutdown();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public OpenFeatureAPI onProviderReady(Consumer handler) {
+ return this.on(ProviderEvent.PROVIDER_READY, handler);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public OpenFeatureAPI onProviderConfigurationChanged(Consumer handler) {
+ return this.on(ProviderEvent.PROVIDER_CONFIGURATION_CHANGED, handler);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public OpenFeatureAPI onProviderStale(Consumer handler) {
+ return this.on(ProviderEvent.PROVIDER_STALE, handler);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public OpenFeatureAPI onProviderError(Consumer handler) {
+ return this.on(ProviderEvent.PROVIDER_ERROR, handler);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public OpenFeatureAPI on(ProviderEvent event, Consumer handler) {
+ try (AutoCloseableLock __ = lock.writeLockAutoCloseable()) {
+ this.eventSupport.addGlobalHandler(event, handler);
+ return this;
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public OpenFeatureAPI removeHandler(ProviderEvent event, Consumer handler) {
+ this.eventSupport.removeGlobalHandler(event, handler);
+ return this;
+ }
+
+ void removeHandler(String clientName, ProviderEvent event, Consumer handler) {
+ try (AutoCloseableLock __ = lock.writeLockAutoCloseable()) {
+ eventSupport.removeClientHandler(clientName, event, handler);
+ }
+ }
+
+ void addHandler(String clientName, ProviderEvent event, Consumer handler) {
+ try (AutoCloseableLock __ = lock.writeLockAutoCloseable()) {
+ // if the provider is READY, run immediately
+ if (ProviderEvent.PROVIDER_READY.equals(event)
+ && ProviderState.READY.equals(this.providerRepository.getProvider(clientName).getState())) {
+ eventSupport.runHandler(handler, EventDetails.builder().clientName(clientName).build());
+ }
+ eventSupport.addClientHandler(clientName, event, handler);
+ }
+ }
+
+ /**
+ * This method is only here for testing as otherwise all tests after the API
+ * shutdown test would fail.
+ */
+ final void reset() {
+ providerRepository = new ProviderRepository();
+ eventSupport = new EventSupport();
+ }
+
+ /**
+ * 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
+ */
+ private void runHandlersForProvider(FeatureProvider provider, ProviderEvent event, ProviderEventDetails details) {
+ try (AutoCloseableLock __ = lock.readLockAutoCloseable()) {
+
+ List clientNamesForProvider = providerRepository
+ .getClientNamesForProvider(provider);
+
+ // run the global handlers
+ eventSupport.runGlobalHandlers(event, EventDetails.fromProviderEventDetails(details));
+
+ // run the handlers associated with named clients for this provider
+ clientNamesForProvider.forEach(name -> {
+ eventSupport.runClientHandlers(name, event, EventDetails.fromProviderEventDetails(details, name));
+ });
+
+ if (providerRepository.isDefaultProvider(provider)) {
+ // run handlers for clients that have no bound providers (since this is the default)
+ Set allClientNames = eventSupport.getAllClientNames();
+ Set boundClientNames = providerRepository.getAllBoundClientNames();
+ allClientNames.removeAll(boundClientNames);
+ allClientNames.forEach(name -> {
+ eventSupport.runClientHandlers(name, event, EventDetails.fromProviderEventDetails(details, name));
+ });
+ }
+ }
+ }
}
diff --git a/src/main/java/dev/openfeature/sdk/OpenFeatureClient.java b/src/main/java/dev/openfeature/sdk/OpenFeatureClient.java
index a13eb942..05d79d02 100644
--- a/src/main/java/dev/openfeature/sdk/OpenFeatureClient.java
+++ b/src/main/java/dev/openfeature/sdk/OpenFeatureClient.java
@@ -5,6 +5,7 @@
import java.util.Collections;
import java.util.List;
import java.util.Map;
+import java.util.function.Consumer;
import dev.openfeature.sdk.exceptions.GeneralError;
import dev.openfeature.sdk.exceptions.OpenFeatureError;
@@ -33,13 +34,16 @@ public class OpenFeatureClient implements Client {
private EvaluationContext evaluationContext;
/**
- * Client for evaluating the flag. There may be multiples of these floating
- * around.
+ * Deprecated public constructor. Use OpenFeature.API.getClient() instead.
*
* @param openFeatureAPI Backing global singleton
* @param name Name of the client (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
public OpenFeatureClient(OpenFeatureAPI openFeatureAPI, String name, String version) {
this.openfeatureApi = openFeatureAPI;
this.name = name;
@@ -95,21 +99,17 @@ private FlagEvaluationDetails evaluateFlag(FlagValueType type, String key
Map hints = Collections.unmodifiableMap(flagOptions.getHookHints());
ctx = ObjectUtils.defaultIfNull(ctx, () -> new ImmutableContext());
-
FlagEvaluationDetails details = null;
List mergedHooks = null;
HookContext hookCtx = null;
- FeatureProvider provider = null;
+ FeatureProvider provider;
try {
final EvaluationContext apiContext;
final EvaluationContext clientContext;
// openfeatureApi.getProvider() must be called once to maintain a consistent reference
- provider = ObjectUtils.defaultIfNull(openfeatureApi.getProvider(), () -> {
- log.debug("No provider configured, using no-op provider.");
- return new NoOpProvider();
- });
+ provider = openfeatureApi.getProvider(this.name);
mergedHooks = ObjectUtils.merge(provider.getProviderHooks(), flagOptions.getHooks(), clientHooks,
openfeatureApi.getHooks());
@@ -344,4 +344,54 @@ public FlagEvaluationDetails getObjectDetails(String key, Value defaultVa
public Metadata getMetadata() {
return () -> name;
}
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public Client onProviderReady(Consumer handler) {
+ return on(ProviderEvent.PROVIDER_READY, handler);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public Client onProviderConfigurationChanged(Consumer handler) {
+ return on(ProviderEvent.PROVIDER_CONFIGURATION_CHANGED, handler);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public Client onProviderError(Consumer handler) {
+ return on(ProviderEvent.PROVIDER_ERROR, handler);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public Client onProviderStale(Consumer handler) {
+ return on(ProviderEvent.PROVIDER_STALE, handler);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public Client on(ProviderEvent event, Consumer handler) {
+ OpenFeatureAPI.getInstance().addHandler(name, event, handler);
+ return this;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public Client removeHandler(ProviderEvent event, Consumer handler) {
+ OpenFeatureAPI.getInstance().removeHandler(name, event, handler);
+ return this;
+ }
}
diff --git a/src/main/java/dev/openfeature/sdk/ProviderEvaluation.java b/src/main/java/dev/openfeature/sdk/ProviderEvaluation.java
index 9ba1ab9a..c4720263 100644
--- a/src/main/java/dev/openfeature/sdk/ProviderEvaluation.java
+++ b/src/main/java/dev/openfeature/sdk/ProviderEvaluation.java
@@ -1,16 +1,27 @@
package dev.openfeature.sdk;
+import javax.annotation.Nullable;
+
+import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
+import lombok.NoArgsConstructor;
-import javax.annotation.Nullable;
-
-@SuppressWarnings("checkstyle:MissingJavadocType")
-@Data @Builder
+/**
+ * Contains information about how the a flag was evaluated, including the resolved value.
+ *
+ * @param the type of the flag being evaluated.
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
public class ProviderEvaluation implements BaseEvaluation {
T value;
@Nullable String variant;
@Nullable private String reason;
ErrorCode errorCode;
@Nullable private String errorMessage;
+ @Builder.Default
+ private ImmutableMetadata flagMetadata = ImmutableMetadata.builder().build();
}
diff --git a/src/main/java/dev/openfeature/sdk/ProviderEvent.java b/src/main/java/dev/openfeature/sdk/ProviderEvent.java
new file mode 100644
index 00000000..dcefd606
--- /dev/null
+++ b/src/main/java/dev/openfeature/sdk/ProviderEvent.java
@@ -0,0 +1,8 @@
+package dev.openfeature.sdk;
+
+/**
+ * Provider event types.
+ */
+public enum ProviderEvent {
+ PROVIDER_READY, PROVIDER_CONFIGURATION_CHANGED, PROVIDER_ERROR, PROVIDER_STALE;
+}
diff --git a/src/main/java/dev/openfeature/sdk/ProviderEventDetails.java b/src/main/java/dev/openfeature/sdk/ProviderEventDetails.java
new file mode 100644
index 00000000..149c92a7
--- /dev/null
+++ b/src/main/java/dev/openfeature/sdk/ProviderEventDetails.java
@@ -0,0 +1,18 @@
+package dev.openfeature.sdk;
+
+import java.util.List;
+
+import javax.annotation.Nullable;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+
+/**
+ * The details of a particular event.
+ */
+@Data @SuperBuilder(toBuilder = true)
+public class ProviderEventDetails {
+ @Nullable private List flagsChanged;
+ @Nullable private String message;
+ @Nullable private ImmutableMetadata eventMetadata;
+}
diff --git a/src/main/java/dev/openfeature/sdk/ProviderRepository.java b/src/main/java/dev/openfeature/sdk/ProviderRepository.java
new file mode 100644
index 00000000..0ff3b70b
--- /dev/null
+++ b/src/main/java/dev/openfeature/sdk/ProviderRepository.java
@@ -0,0 +1,164 @@
+package dev.openfeature.sdk;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import javax.annotation.Nullable;
+
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+class ProviderRepository {
+
+ private final Map providers = new ConcurrentHashMap<>();
+ private final AtomicReference defaultProvider = new AtomicReference<>(new NoOpProvider());
+ private final ExecutorService taskExecutor = Executors.newCachedThreadPool();
+
+ /**
+ * Return the default provider.
+ */
+ public FeatureProvider getProvider() {
+ return defaultProvider.get();
+ }
+
+ /**
+ * Fetch a provider for a named client. If not found, return the default.
+ *
+ * @param name The client name to look for.
+ * @return A named {@link FeatureProvider}
+ */
+ public FeatureProvider getProvider(String name) {
+ return Optional.ofNullable(name).map(this.providers::get).orElse(this.defaultProvider.get());
+ }
+
+ public List getClientNamesForProvider(FeatureProvider provider) {
+ return providers.entrySet().stream()
+ .filter(entry -> entry.getValue().equals(provider))
+ .map(entry -> entry.getKey()).collect(Collectors.toList());
+ }
+
+ public Set getAllBoundClientNames() {
+ return providers.keySet();
+ }
+
+ public boolean isDefaultProvider(FeatureProvider provider) {
+ return this.getProvider().equals(provider);
+ }
+
+ /**
+ * Set the default provider.
+ */
+ public void setProvider(FeatureProvider provider,
+ Consumer afterSet,
+ Consumer afterInit,
+ Consumer afterShutdown,
+ BiConsumer afterError) {
+ if (provider == null) {
+ throw new IllegalArgumentException("Provider cannot be null");
+ }
+ initializeProvider(null, provider, afterSet, afterInit, afterShutdown, afterError);
+ }
+
+ /**
+ * Add a provider for a named client.
+ *
+ * @param clientName The name of the client.
+ * @param provider The provider to set.
+ */
+ public void setProvider(String clientName,
+ FeatureProvider provider,
+ Consumer afterSet,
+ Consumer afterInit,
+ Consumer afterShutdown,
+ BiConsumer afterError) {
+ if (provider == null) {
+ throw new IllegalArgumentException("Provider cannot be null");
+ }
+ if (clientName == null) {
+ throw new IllegalArgumentException("clientName cannot be null");
+ }
+ initializeProvider(clientName, provider, afterSet, afterInit, afterShutdown, afterError);
+ }
+
+ private void initializeProvider(@Nullable String clientName,
+ FeatureProvider newProvider,
+ Consumer afterSet,
+ Consumer afterInit,
+ Consumer afterShutdown,
+ BiConsumer afterError) {
+ // provider is set immediately, on this thread
+ FeatureProvider oldProvider = clientName != null
+ ? this.providers.put(clientName, newProvider)
+ : this.defaultProvider.getAndSet(newProvider);
+ afterSet.accept(newProvider);
+ taskExecutor.submit(() -> {
+ // initialization happens in a different thread
+ try {
+ if (ProviderState.NOT_READY.equals(newProvider.getState())) {
+ newProvider.initialize(OpenFeatureAPI.getInstance().getEvaluationContext());
+ afterInit.accept(newProvider);
+ }
+ shutDownOld(oldProvider, afterShutdown);
+ } catch (Exception e) {
+ log.error("Exception when initializing feature provider {}", newProvider.getClass().getName(), e);
+ afterError.accept(newProvider, e.getMessage());
+ }
+ });
+ }
+
+ private void shutDownOld(FeatureProvider oldProvider,Consumer afterShutdown) {
+ if (!isProviderRegistered(oldProvider)) {
+ shutdownProvider(oldProvider);
+ afterShutdown.accept(oldProvider);
+ }
+ }
+
+ private boolean isProviderRegistered(FeatureProvider oldProvider) {
+ return this.providers.containsValue(oldProvider) || this.defaultProvider.get().equals(oldProvider);
+ }
+
+ private void shutdownProvider(FeatureProvider provider) {
+ taskExecutor.submit(() -> {
+ try {
+ // detachProviderEvents(provider);
+ provider.shutdown();
+ } catch (Exception e) {
+ log.error("Exception when shutting down feature provider {}", provider.getClass().getName(), e);
+ }
+ });
+ }
+
+ /**
+ * Shuts down this repository which includes shutting down all FeatureProviders
+ * that are registered,
+ * including the default feature provider.
+ */
+ public void shutdown() {
+ Stream
+ .concat(Stream.of(this.defaultProvider.get()), this.providers.values().stream())
+ .distinct()
+ .forEach(this::shutdownProvider);
+ setProvider(new NoOpProvider(),
+ (FeatureProvider fp) -> {
+ },
+ (FeatureProvider fp) -> {
+ },
+ (FeatureProvider fp) -> {
+ },
+ (FeatureProvider fp,
+ String message) -> {
+ });
+ this.providers.clear();
+ taskExecutor.shutdown();
+ }
+}
diff --git a/src/main/java/dev/openfeature/sdk/ProviderState.java b/src/main/java/dev/openfeature/sdk/ProviderState.java
new file mode 100644
index 00000000..6685f8fe
--- /dev/null
+++ b/src/main/java/dev/openfeature/sdk/ProviderState.java
@@ -0,0 +1,8 @@
+package dev.openfeature.sdk;
+
+/**
+ * Indicates the state of the provider.
+ */
+public enum ProviderState {
+ READY, NOT_READY, ERROR;
+}
diff --git a/src/main/java/dev/openfeature/sdk/internal/ObjectUtils.java b/src/main/java/dev/openfeature/sdk/internal/ObjectUtils.java
index ff16422e..34caadae 100644
--- a/src/main/java/dev/openfeature/sdk/internal/ObjectUtils.java
+++ b/src/main/java/dev/openfeature/sdk/internal/ObjectUtils.java
@@ -69,5 +69,4 @@ public static List merge(List... sources) {
.flatMap(Collection::stream)
.collect(Collectors.toList());
}
-
}
diff --git a/src/main/java/dev/openfeature/sdk/internal/TriConsumer.java b/src/main/java/dev/openfeature/sdk/internal/TriConsumer.java
new file mode 100644
index 00000000..723f4aeb
--- /dev/null
+++ b/src/main/java/dev/openfeature/sdk/internal/TriConsumer.java
@@ -0,0 +1,38 @@
+package dev.openfeature.sdk.internal;
+
+import java.util.Objects;
+
+/**
+ * Like {@link java.util.function.BiConsumer} but with 3 params.
+ *
+ * @see java.util.function.BiConsumer
+ */
+@FunctionalInterface
+public interface TriConsumer {
+
+ /**
+ * Performs this operation on the given arguments.
+ *
+ * @param t the first input argument
+ * @param u the second input argument
+ * @param v the third input argument
+ */
+ void accept(T t, U u, V v);
+
+ /**
+ * Returns a composed {@code TriConsumer} that performs an additional operation.
+ *
+ * @param after the operation to perform after this operation
+ * @return a composed {@code TriConsumer} that performs in sequence this
+ * operation followed by the {@code after} operation
+ * @throws NullPointerException if {@code after} is null
+ */
+ default TriConsumer andThen(TriConsumer after) {
+ Objects.requireNonNull(after);
+
+ return (t, u, v) -> {
+ accept(t, u, v);
+ after.accept(t, u, v);
+ };
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/dev/openfeature/sdk/ClientProviderMappingTest.java b/src/test/java/dev/openfeature/sdk/ClientProviderMappingTest.java
new file mode 100644
index 00000000..8f022a38
--- /dev/null
+++ b/src/test/java/dev/openfeature/sdk/ClientProviderMappingTest.java
@@ -0,0 +1,23 @@
+package dev.openfeature.sdk;
+
+import dev.openfeature.sdk.testutils.FeatureProviderTestUtils;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class ClientProviderMappingTest {
+
+ @Test
+ void clientProviderTest() {
+ OpenFeatureAPI api = OpenFeatureAPI.getInstance();
+
+ FeatureProviderTestUtils.setFeatureProvider("client1", new DoSomethingProvider());
+ FeatureProviderTestUtils.setFeatureProvider("client2", new NoOpProvider());
+
+ Client c1 = api.getClient("client1");
+ Client c2 = api.getClient("client2");
+
+ assertTrue(c1.getBooleanValue("test", false));
+ assertFalse(c2.getBooleanValue("test", false));
+ }
+}
diff --git a/src/test/java/dev/openfeature/sdk/DeveloperExperienceTest.java b/src/test/java/dev/openfeature/sdk/DeveloperExperienceTest.java
index f32711a2..b5e5bedf 100644
--- a/src/test/java/dev/openfeature/sdk/DeveloperExperienceTest.java
+++ b/src/test/java/dev/openfeature/sdk/DeveloperExperienceTest.java
@@ -12,6 +12,7 @@
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;
@@ -19,15 +20,6 @@
class DeveloperExperienceTest implements HookFixtures {
transient String flagKey = "mykey";
- @Test void noProviderSet() {
- final String noOp = "no-op";
- OpenFeatureAPI api = OpenFeatureAPI.getInstance();
- api.setProvider(null);
- Client client = api.getClient();
- String retval = client.getStringValue(flagKey, noOp);
- assertEquals(noOp, retval);
- }
-
@Test void simpleBooleanFlag() {
OpenFeatureAPI api = OpenFeatureAPI.getInstance();
api.setProvider(new NoOpProvider());
@@ -86,7 +78,7 @@ class DeveloperExperienceTest implements HookFixtures {
@Test void brokenProvider() {
OpenFeatureAPI api = OpenFeatureAPI.getInstance();
- api.setProvider(new AlwaysBrokenProvider());
+ FeatureProviderTestUtils.setFeatureProvider(new AlwaysBrokenProvider());
Client client = api.getClient();
FlagEvaluationDetails retval = client.getBooleanDetails(flagKey, false);
assertEquals(ErrorCode.FLAG_NOT_FOUND, retval.getErrorCode());
@@ -96,14 +88,14 @@ class DeveloperExperienceTest implements HookFixtures {
}
@Test
- void providerLockedPerTransaction() throws InterruptedException {
+ void providerLockedPerTransaction() {
class MutatingHook implements Hook {
@Override
// change the provider during a before hook - this should not impact the evaluation in progress
public Optional before(HookContext ctx, Map hints) {
- OpenFeatureAPI.getInstance().setProvider(new NoOpProvider());
+ FeatureProviderTestUtils.setFeatureProvider(new NoOpProvider());
return Optional.empty();
}
}
@@ -111,7 +103,7 @@ public Optional before(HookContext ctx, Map hints) {
final String defaultValue = "string-value";
final OpenFeatureAPI api = OpenFeatureAPI.getInstance();
final Client client = api.getClient();
- api.setProvider(new DoSomethingProvider());
+ FeatureProviderTestUtils.setFeatureProvider(new DoSomethingProvider());
api.addHooks(new MutatingHook());
// if provider is changed during an evaluation transaction it should proceed with the original provider
diff --git a/src/test/java/dev/openfeature/sdk/DoSomethingProvider.java b/src/test/java/dev/openfeature/sdk/DoSomethingProvider.java
index d87fa374..8d1c4514 100644
--- a/src/test/java/dev/openfeature/sdk/DoSomethingProvider.java
+++ b/src/test/java/dev/openfeature/sdk/DoSomethingProvider.java
@@ -1,11 +1,14 @@
package dev.openfeature.sdk;
-public class DoSomethingProvider implements FeatureProvider {
+class DoSomethingProvider implements FeatureProvider {
+
+ static final String name = "Something";
+ // Flag evaluation metadata
+ static final ImmutableMetadata flagMetadata = ImmutableMetadata.builder().build();
- public static final String name = "Something";
private EvaluationContext savedContext;
- public EvaluationContext getMergedContext() {
+ EvaluationContext getMergedContext() {
return savedContext;
}
@@ -18,13 +21,16 @@ public Metadata getMetadata() {
public ProviderEvaluation getBooleanEvaluation(String key, Boolean defaultValue, EvaluationContext ctx) {
savedContext = ctx;
return ProviderEvaluation.builder()
- .value(!defaultValue).build();
+ .value(!defaultValue)
+ .flagMetadata(flagMetadata)
+ .build();
}
@Override
public ProviderEvaluation getStringEvaluation(String key, String defaultValue, EvaluationContext ctx) {
return ProviderEvaluation.builder()
.value(new StringBuilder(defaultValue).reverse().toString())
+ .flagMetadata(flagMetadata)
.build();
}
@@ -33,6 +39,7 @@ public ProviderEvaluation getIntegerEvaluation(String key, Integer defa
savedContext = ctx;
return ProviderEvaluation.builder()
.value(defaultValue * 100)
+ .flagMetadata(flagMetadata)
.build();
}
@@ -41,6 +48,7 @@ public ProviderEvaluation getDoubleEvaluation(String key, Double default
savedContext = ctx;
return ProviderEvaluation.builder()
.value(defaultValue * 100)
+ .flagMetadata(flagMetadata)
.build();
}
@@ -49,6 +57,7 @@ public ProviderEvaluation getObjectEvaluation(String key, Value defaultVa
savedContext = invocationContext;
return ProviderEvaluation.builder()
.value(null)
+ .flagMetadata(flagMetadata)
.build();
}
}
diff --git a/src/test/java/dev/openfeature/sdk/EvalContextTest.java b/src/test/java/dev/openfeature/sdk/EvalContextTest.java
index 29fd0898..f4cd804c 100644
--- a/src/test/java/dev/openfeature/sdk/EvalContextTest.java
+++ b/src/test/java/dev/openfeature/sdk/EvalContextTest.java
@@ -162,6 +162,13 @@ public class EvalContextTest {
assertEquals(key1, ctxMerged.getTargetingKey());
}
+ @Test void merge_null_returns_value() {
+ MutableContext ctx1 = new MutableContext("key");
+ ctx1.add("mything", "value");
+ EvaluationContext result = ctx1.merge(null);
+ assertEquals(ctx1, result);
+ }
+
@Test void merge_targeting_key() {
String key1 = "key1";
MutableContext ctx1 = new MutableContext(key1);
diff --git a/src/test/java/dev/openfeature/sdk/EventProviderTest.java b/src/test/java/dev/openfeature/sdk/EventProviderTest.java
new file mode 100644
index 00000000..cb73b529
--- /dev/null
+++ b/src/test/java/dev/openfeature/sdk/EventProviderTest.java
@@ -0,0 +1,130 @@
+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 org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import dev.openfeature.sdk.internal.TriConsumer;
+
+class EventProviderTest {
+
+ @Test
+ @DisplayName("should run attached onEmit with emitters")
+ void emitsEventsWhenAttached() {
+ TestEventProvider eventProvider = new TestEventProvider();
+ TriConsumer onEmit = mockOnEmit();
+ eventProvider.attach(onEmit);
+
+ ProviderEventDetails details = ProviderEventDetails.builder().build();
+ eventProvider.emit(ProviderEvent.PROVIDER_READY, details);
+ eventProvider.emitProviderReady(details);
+ eventProvider.emitProviderConfigurationChanged(details);
+ eventProvider.emitProviderStale(details);
+ eventProvider.emitProviderError(details);
+
+ verify(onEmit, times(2)).accept(eventProvider, ProviderEvent.PROVIDER_READY, details);
+ verify(onEmit, times(1)).accept(eventProvider, ProviderEvent.PROVIDER_CONFIGURATION_CHANGED, details);
+ verify(onEmit, times(1)).accept(eventProvider, ProviderEvent.PROVIDER_STALE, details);
+ verify(onEmit, times(1)).accept(eventProvider, ProviderEvent.PROVIDER_ERROR, details);
+ }
+
+ @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();
+
+ ProviderEventDetails details = ProviderEventDetails.builder().build();
+ eventProvider.emit(ProviderEvent.PROVIDER_READY, details);
+ eventProvider.emitProviderReady(details);
+ eventProvider.emitProviderConfigurationChanged(details);
+ eventProvider.emitProviderStale(details);
+ eventProvider.emitProviderError(details);
+
+ // should not be called
+ verify(onEmit, never()).accept(any(), any(), any());
+ }
+
+ @Test
+ @DisplayName("should throw if second different onEmit attached")
+ void throwsWhenOnEmitDifferent() {
+ TestEventProvider eventProvider = new TestEventProvider();
+ TriConsumer onEmit1 = mockOnEmit();
+ TriConsumer onEmit2 = mockOnEmit();
+ eventProvider.attach(onEmit1);
+ assertThrows(IllegalStateException.class, () -> eventProvider.attach(onEmit2));
+ }
+
+
+ @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 {
+
+ @Override
+ public Metadata getMetadata() {
+ return new Metadata() {
+ @Override
+ public String getName() {
+ return "TestEventProvider";
+ }
+ };
+ }
+
+ @Override
+ public ProviderEvaluation getBooleanEvaluation(String key, Boolean defaultValue,
+ EvaluationContext ctx) {
+ // TODO Auto-generated method stub
+ throw new UnsupportedOperationException("Unimplemented method 'getBooleanEvaluation'");
+ }
+
+ @Override
+ public ProviderEvaluation getStringEvaluation(String key, String defaultValue,
+ EvaluationContext ctx) {
+ // TODO Auto-generated method stub
+ throw new UnsupportedOperationException("Unimplemented method 'getStringEvaluation'");
+ }
+
+ @Override
+ public ProviderEvaluation getIntegerEvaluation(String key, Integer defaultValue,
+ EvaluationContext ctx) {
+ // TODO Auto-generated method stub
+ throw new UnsupportedOperationException("Unimplemented method 'getIntegerEvaluation'");
+ }
+
+ @Override
+ public ProviderEvaluation getDoubleEvaluation(String key, Double defaultValue,
+ EvaluationContext ctx) {
+ // TODO Auto-generated method stub
+ throw new UnsupportedOperationException("Unimplemented method 'getDoubleEvaluation'");
+ }
+
+ @Override
+ public ProviderEvaluation getObjectEvaluation(String key, Value defaultValue,
+ EvaluationContext ctx) {
+ // TODO Auto-generated method stub
+ throw new UnsupportedOperationException("Unimplemented method 'getObjectEvaluation'");
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ private TriConsumer mockOnEmit() {
+ 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
new file mode 100644
index 00000000..70f81657
--- /dev/null
+++ b/src/test/java/dev/openfeature/sdk/EventsTest.java
@@ -0,0 +1,599 @@
+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 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;
+
+class EventsTest {
+
+ private static final int TIMEOUT = 200;
+ private static final int INIT_DELAY = TIMEOUT / 2;
+
+ @AfterAll
+ public static void resetDefaultProvider() {
+ OpenFeatureAPI.getInstance().setProvider(new NoOpProvider());
+ }
+
+ @Nested
+ class ApiEvents {
+
+ @Nested
+ @DisplayName("named provider")
+ class NamedProvider {
+
+ @Nested
+ @DisplayName("initialization")
+ class Initialization {
+
+ @Test
+ @DisplayName("should fire initial READY event when provider init succeeds")
+ @Specification(number = "5.3.1", text = "If the provider's initialize function terminates normally," +
+ " PROVIDER_READY handlers MUST run.")
+ void apiInitReady() {
+ final Consumer handler = (Consumer)mockHandler();
+ final String name = "apiInitReady";
+
+ TestEventsProvider provider = new TestEventsProvider(INIT_DELAY);
+ OpenFeatureAPI.getInstance().onProviderReady(handler);
+ OpenFeatureAPI.getInstance().setProvider(name, provider);
+ verify(handler, timeout(TIMEOUT).atLeastOnce())
+ .accept(any());
+ }
+
+ @Test
+ @DisplayName("should fire initial ERROR event when provider init errors")
+ @Specification(number = "5.3.2", text = "If the provider's initialize function terminates abnormally," +
+ " PROVIDER_ERROR handlers MUST run.")
+ void apiInitError() {
+ final Consumer handler = mockHandler();
+ final String name = "apiInitError";
+ final String errMessage = "oh no!";
+
+ TestEventsProvider provider = new TestEventsProvider(INIT_DELAY, true, errMessage);
+ OpenFeatureAPI.getInstance().onProviderError(handler);
+ OpenFeatureAPI.getInstance().setProvider(name, provider);
+ verify(handler, timeout(TIMEOUT)).accept(argThat(details -> {
+ return errMessage.equals(details.getMessage());
+ }));
+ }
+ }
+
+ @Nested
+ @DisplayName("provider events")
+ class ProviderEvents {
+
+ @Test
+ @DisplayName("should propagate events")
+ @Specification(number = "5.1.2", text = "When a provider signals the occurrence of a particular event, "
+ +
+ "the associated client and API event handlers MUST run.")
+ void apiShouldPropagateEvents() {
+ final Consumer handler = mockHandler();
+ final String name = "apiShouldPropagateEvents";
+
+ TestEventsProvider provider = new TestEventsProvider(INIT_DELAY);
+ OpenFeatureAPI.getInstance().setProvider(name, provider);
+ OpenFeatureAPI.getInstance().onProviderConfigurationChanged(handler);
+
+ provider.mockEvent(ProviderEvent.PROVIDER_CONFIGURATION_CHANGED, EventDetails.builder().build());
+ verify(handler, timeout(TIMEOUT)).accept(any());
+ }
+
+ @Test
+ @DisplayName("should support all event types")
+ @Specification(number = "5.1.1", text = "The provider MAY define a mechanism for signaling the occurrence "
+ + "of one of a set of events, including PROVIDER_READY, PROVIDER_ERROR, "
+ + "PROVIDER_CONFIGURATION_CHANGED and PROVIDER_STALE, with a provider event details payload.")
+ @Specification(number = "5.2.2", text = "The API MUST provide a function for associating handler functions"
+ +
+ " with a particular provider event type.")
+ void apiShouldSupportAllEventTypes() throws Exception {
+ final String name = "apiShouldSupportAllEventTypes";
+ final Consumer handler1 = mockHandler();
+ final Consumer handler2 = mockHandler();
+ final Consumer handler3 = mockHandler();
+ final Consumer handler4 = mockHandler();
+
+ TestEventsProvider provider = new TestEventsProvider(INIT_DELAY);
+ OpenFeatureAPI.getInstance().setProvider(name, provider);
+
+ OpenFeatureAPI.getInstance().onProviderReady(handler1);
+ OpenFeatureAPI.getInstance().onProviderConfigurationChanged(handler2);
+ OpenFeatureAPI.getInstance().onProviderStale(handler3);
+ OpenFeatureAPI.getInstance().onProviderError(handler4);
+
+ Arrays.asList(ProviderEvent.values()).stream().forEach(eventType -> {
+ provider.mockEvent(eventType, ProviderEventDetails.builder().build());
+ });
+
+ verify(handler1, timeout(TIMEOUT).atLeastOnce()).accept(any());
+ verify(handler2, timeout(TIMEOUT).atLeastOnce()).accept(any());
+ verify(handler3, timeout(TIMEOUT).atLeastOnce()).accept(any());
+ verify(handler4, timeout(TIMEOUT).atLeastOnce()).accept(any());
+ }
+ }
+ }
+ }
+
+ @Nested
+ @DisplayName("client events")
+ class ClientEvents {
+
+ @Nested
+ @DisplayName("default provider")
+ class DefaultProvider {
+
+ @Nested
+ @DisplayName("provider events")
+ class ProviderEvents {
+
+ @Test
+ @DisplayName("should propagate events for default provider and anonymous client")
+ @Specification(number = "5.1.2", text = "When a provider signals the occurrence of a particular event, the associated client and API event handlers MUST run.")
+ void shouldPropagateDefaultAndAnon() {
+ final Consumer handler = mockHandler();
+
+ TestEventsProvider provider = new TestEventsProvider(INIT_DELAY);
+ // set provider before getting a client
+ OpenFeatureAPI.getInstance().setProvider(provider);
+ Client client = OpenFeatureAPI.getInstance().getClient();
+ client.onProviderStale(handler);
+
+ provider.mockEvent(ProviderEvent.PROVIDER_STALE, EventDetails.builder().build());
+ verify(handler, timeout(TIMEOUT)).accept(any());
+ }
+
+ @Test
+ @DisplayName("should propagate events for default provider and named client")
+ @Specification(number = "5.1.2", text = "When a provider signals the occurrence of a particular event, the associated client and API event handlers MUST run.")
+ void shouldPropagateDefaultAndNamed() {
+ final Consumer handler = mockHandler();
+ final String name = "shouldPropagateDefaultAndNamed";
+
+ TestEventsProvider provider = new TestEventsProvider(INIT_DELAY);
+ // set provider before getting a client
+ OpenFeatureAPI.getInstance().setProvider(provider);
+ Client client = OpenFeatureAPI.getInstance().getClient(name);
+ client.onProviderStale(handler);
+
+ provider.mockEvent(ProviderEvent.PROVIDER_STALE, EventDetails.builder().build());
+ verify(handler, timeout(TIMEOUT)).accept(any());
+ }
+ }
+ }
+ }
+
+ @Nested
+ @DisplayName("named provider")
+ class NamedProvider {
+
+ @Nested
+ @DisplayName("initialization")
+ class Initialization {
+ @Test
+ @DisplayName("should fire initial READY event when provider init succeeds after client retrieved")
+ @Specification(number = "5.3.1", text = "If the provider's initialize function terminates normally, PROVIDER_READY handlers MUST run.")
+ void initReadyProviderBefore() throws InterruptedException {
+ final Consumer handler = mockHandler();
+ final String name = "initReadyProviderBefore";
+
+ TestEventsProvider provider = new TestEventsProvider(INIT_DELAY);
+ Client client = OpenFeatureAPI.getInstance().getClient(name);
+ client.onProviderReady(handler);
+ // set provider after getting a client
+ OpenFeatureAPI.getInstance().setProvider(name, provider);
+ verify(handler, timeout(TIMEOUT).atLeastOnce())
+ .accept(argThat(details -> details.getClientName().equals(name)));
+ }
+
+ @Test
+ @DisplayName("should fire initial READY event when provider init succeeds before client retrieved")
+ @Specification(number = "5.3.1", text = "If the provider's initialize function terminates normally, PROVIDER_READY handlers MUST run.")
+ void initReadyProviderAfter() {
+ final Consumer handler = mockHandler();
+ final String name = "initReadyProviderAfter";
+
+ TestEventsProvider provider = new TestEventsProvider(INIT_DELAY);
+ // set provider before getting a client
+ OpenFeatureAPI.getInstance().setProvider(name, provider);
+ Client client = OpenFeatureAPI.getInstance().getClient(name);
+ client.onProviderReady(handler);
+ verify(handler, timeout(TIMEOUT).atLeastOnce())
+ .accept(argThat(details -> details.getClientName().equals(name)));
+ }
+
+ @Test
+ @DisplayName("should fire initial ERROR event when provider init errors after client retrieved")
+ @Specification(number = "5.3.2", text = "If the provider's initialize function terminates abnormally, PROVIDER_ERROR handlers MUST run.")
+ void initErrorProviderAfter() {
+ final Consumer handler = mockHandler();
+ final String name = "initErrorProviderAfter";
+ final String errMessage = "oh no!";
+
+ TestEventsProvider provider = new TestEventsProvider(INIT_DELAY, true, errMessage);
+ Client client = OpenFeatureAPI.getInstance().getClient(name);
+ client.onProviderError(handler);
+ // set provider after getting a client
+ OpenFeatureAPI.getInstance().setProvider(name, provider);
+ verify(handler, timeout(TIMEOUT)).accept(argThat(details -> {
+ return name.equals(details.getClientName())
+ && errMessage.equals(details.getMessage());
+ }));
+ }
+
+ @Test
+ @DisplayName("should fire initial ERROR event when provider init errors before client retrieved")
+ @Specification(number = "5.3.2", text = "If the provider's initialize function terminates abnormally, PROVIDER_ERROR handlers MUST run.")
+ void initErrorProviderBefore() {
+ final Consumer handler = mockHandler();
+ final String name = "initErrorProviderBefore";
+ final String errMessage = "oh no!";
+
+ TestEventsProvider provider = new TestEventsProvider(INIT_DELAY, true, errMessage);
+ // set provider after getting a client
+ OpenFeatureAPI.getInstance().setProvider(name, provider);
+ Client client = OpenFeatureAPI.getInstance().getClient(name);
+ client.onProviderError(handler);
+ verify(handler, timeout(TIMEOUT)).accept(argThat(details -> {
+ return name.equals(details.getClientName())
+ && errMessage.equals(details.getMessage());
+ }));
+ }
+ }
+
+ @Nested
+ @DisplayName("provider events")
+ class ProviderEvents {
+
+ @Test
+ @DisplayName("should propagate events when provider set before client retrieved")
+ @Specification(number = "5.1.2", text = "When a provider signals the occurrence of a particular event, the associated client and API event handlers MUST run.")
+ void shouldPropagateBefore() {
+ final Consumer handler = mockHandler();
+ final String name = "shouldPropagateBefore";
+
+ TestEventsProvider provider = new TestEventsProvider(INIT_DELAY);
+ // set provider before getting a client
+ OpenFeatureAPI.getInstance().setProvider(name, provider);
+ Client client = OpenFeatureAPI.getInstance().getClient(name);
+ client.onProviderConfigurationChanged(handler);
+
+ provider.mockEvent(ProviderEvent.PROVIDER_CONFIGURATION_CHANGED, EventDetails.builder().build());
+ verify(handler, timeout(TIMEOUT)).accept(argThat(details -> details.getClientName().equals(name)));
+ }
+
+ @Test
+ @DisplayName("should propagate events when provider set after client retrieved")
+ @Specification(number = "5.1.2", text = "When a provider signals the occurrence of a particular event, the associated client and API event handlers MUST run.")
+ void shouldPropagateAfter() {
+
+ final Consumer handler = mockHandler();
+ final String name = "shouldPropagateAfter";
+
+ TestEventsProvider provider = new TestEventsProvider(INIT_DELAY);
+ Client client = OpenFeatureAPI.getInstance().getClient(name);
+ client.onProviderConfigurationChanged(handler);
+ // set provider after getting a client
+ OpenFeatureAPI.getInstance().setProvider(name, provider);
+
+ provider.mockEvent(ProviderEvent.PROVIDER_CONFIGURATION_CHANGED, EventDetails.builder().build());
+ verify(handler, timeout(TIMEOUT)).accept(argThat(details -> details.getClientName().equals(name)));
+ }
+
+ @Test
+ @DisplayName("should support all event types")
+ @Specification(number = "5.1.1", text = "The provider MAY define a mechanism for signaling the occurrence "
+ + "of one of a set of events, including PROVIDER_READY, PROVIDER_ERROR, "
+ + "PROVIDER_CONFIGURATION_CHANGED and PROVIDER_STALE, with a provider event details payload.")
+ @Specification(number = "5.2.1", text = "The client MUST provide a function for associating handler functions"
+ +
+ " with a particular provider event type.")
+ void shouldSupportAllEventTypes() throws Exception {
+ final String name = "shouldSupportAllEventTypes";
+ final Consumer handler1 = mockHandler();
+ final Consumer handler2 = mockHandler();
+ final Consumer handler3 = mockHandler();
+ final Consumer handler4 = mockHandler();
+
+ TestEventsProvider provider = new TestEventsProvider(INIT_DELAY);
+ OpenFeatureAPI.getInstance().setProvider(name, provider);
+ Client client = OpenFeatureAPI.getInstance().getClient(name);
+
+ client.onProviderReady(handler1);
+ client.onProviderConfigurationChanged(handler2);
+ client.onProviderStale(handler3);
+ client.onProviderError(handler4);
+
+ Arrays.asList(ProviderEvent.values()).stream().forEach(eventType -> {
+ provider.mockEvent(eventType, ProviderEventDetails.builder().build());
+ });
+ ArgumentMatcher nameMatches = (EventDetails details) -> details.getClientName()
+ .equals(name);
+ verify(handler1, timeout(TIMEOUT).atLeastOnce()).accept(argThat(nameMatches));
+ verify(handler2, timeout(TIMEOUT).atLeastOnce()).accept(argThat(nameMatches));
+ verify(handler3, timeout(TIMEOUT).atLeastOnce()).accept(argThat(nameMatches));
+ verify(handler4, timeout(TIMEOUT).atLeastOnce()).accept(argThat(nameMatches));
+ }
+ }
+ }
+
+ @Test
+ @DisplayName("shutdown provider should not run handlers")
+ void shouldNotRunHandlers() throws Exception {
+ 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);
+ Client client = OpenFeatureAPI.getInstance().getClient(name);
+
+ // attached handlers
+ OpenFeatureAPI.getInstance().onProviderConfigurationChanged(handler1);
+ client.onProviderConfigurationChanged(handler2);
+
+ OpenFeatureAPI.getInstance().setProvider(name, provider2);
+
+ // wait for the new provider to be ready and make sure things are cleaned up.
+ await().until(() -> provider1.isShutDown());
+
+ // fire old event
+ provider1.mockEvent(ProviderEvent.PROVIDER_CONFIGURATION_CHANGED, EventDetails.builder().build());
+
+ // a bit of waiting here, but we want to make sure these are indeed never
+ // called.
+ verify(handler1, after(TIMEOUT).never()).accept(any());
+ verify(handler2, never()).accept(any());
+ }
+
+ @Test
+ @DisplayName("other client handlers should not run")
+ @Specification(number = "5.1.3", text = "When a provider signals the occurrence of a particular event, " +
+ "event handlers on clients which are not associated with that provider MUST NOT run.")
+ void otherClientHandlersShouldNotRun() throws Exception {
+ final String name1 = "otherClientHandlersShouldNotRun1";
+ final String name2 = "otherClientHandlersShouldNotRun2";
+ final Consumer handlerToRun = mockHandler();
+ final Consumer handlerNotToRun = mockHandler();
+
+ TestEventsProvider provider1 = new TestEventsProvider(INIT_DELAY);
+ TestEventsProvider provider2 = new TestEventsProvider(INIT_DELAY);
+ OpenFeatureAPI.getInstance().setProvider(name1, provider1);
+ OpenFeatureAPI.getInstance().setProvider(name2, provider2);
+
+ Client client1 = OpenFeatureAPI.getInstance().getClient(name1);
+ Client client2 = OpenFeatureAPI.getInstance().getClient(name2);
+
+ client1.onProviderConfigurationChanged(handlerToRun);
+ client2.onProviderConfigurationChanged(handlerNotToRun);
+
+ provider1.mockEvent(ProviderEvent.PROVIDER_CONFIGURATION_CHANGED, ProviderEventDetails.builder().build());
+
+ verify(handlerToRun, timeout(TIMEOUT)).accept(any());
+ verify(handlerNotToRun, never()).accept(any());
+ }
+
+ @Test
+ @DisplayName("bound named client handlers should not run with default")
+ @Specification(number = "5.1.3", text = "When a provider signals the occurrence of a particular event, " +
+ "event handlers on clients which are not associated with that provider MUST NOT run.")
+ void boundShouldNotRunWithDefault() throws Exception {
+ final String name = "boundShouldNotRunWithDefault";
+ final Consumer handlerNotToRun = mockHandler();
+
+ TestEventsProvider namedProvider = new TestEventsProvider(INIT_DELAY);
+ TestEventsProvider defaultProvider = new TestEventsProvider(INIT_DELAY);
+ OpenFeatureAPI.getInstance().setProvider(defaultProvider);
+
+ Client client = OpenFeatureAPI.getInstance().getClient(name);
+ client.onProviderConfigurationChanged(handlerNotToRun);
+ OpenFeatureAPI.getInstance().setProvider(name, namedProvider);
+
+ // await the new provider to make sure the old one is shut down
+ await().until(() -> namedProvider.getState().equals(ProviderState.READY));
+
+ // fire event on default provider
+ defaultProvider.mockEvent(ProviderEvent.PROVIDER_CONFIGURATION_CHANGED, ProviderEventDetails.builder().build());
+
+ verify(handlerNotToRun, after(TIMEOUT).never()).accept(any());
+ OpenFeatureAPI.getInstance().setProvider(new NoOpProvider());
+ }
+
+ @Test
+ @DisplayName("unbound named client handlers should run with default")
+ @Specification(number = "5.1.3", text = "When a provider signals the occurrence of a particular event, " +
+ "event handlers on clients which are not associated with that provider MUST NOT run.")
+ void unboundShouldRunWithDefault() throws Exception {
+ final String name = "unboundShouldRunWithDefault";
+ final Consumer handlerToRun = mockHandler();
+
+ TestEventsProvider defaultProvider = new TestEventsProvider(INIT_DELAY);
+ OpenFeatureAPI.getInstance().setProvider(defaultProvider);
+
+ Client client = OpenFeatureAPI.getInstance().getClient(name);
+ client.onProviderConfigurationChanged(handlerToRun);
+
+ // await the new provider to make sure the old one is shut down
+ await().until(() -> defaultProvider.getState().equals(ProviderState.READY));
+
+ // fire event on default provider
+ defaultProvider.mockEvent(ProviderEvent.PROVIDER_CONFIGURATION_CHANGED, ProviderEventDetails.builder().build());
+
+ verify(handlerToRun, timeout(TIMEOUT)).accept(any());
+ OpenFeatureAPI.getInstance().setProvider(new NoOpProvider());
+ }
+
+ @Test
+ @DisplayName("subsequent handlers run if earlier throws")
+ @Specification(number = "5.2.5", text = "If a handler function terminates abnormally, other handler functions MUST run.")
+ void handlersRunIfOneThrows() throws Exception {
+ final String name = "handlersRunIfOneThrows";
+ final Consumer errorHandler = mockHandler();
+ doThrow(new NullPointerException()).when(errorHandler).accept(any());
+ final Consumer nextHandler = mockHandler();
+ final Consumer lastHandler = mockHandler();
+
+ TestEventsProvider provider = new TestEventsProvider(INIT_DELAY);
+ OpenFeatureAPI.getInstance().setProvider(name, provider);
+
+ Client client1 = OpenFeatureAPI.getInstance().getClient(name);
+
+ client1.onProviderConfigurationChanged(errorHandler);
+ client1.onProviderConfigurationChanged(nextHandler);
+ client1.onProviderConfigurationChanged(lastHandler);
+
+ provider.mockEvent(ProviderEvent.PROVIDER_CONFIGURATION_CHANGED, ProviderEventDetails.builder().build());
+ verify(errorHandler, timeout(TIMEOUT)).accept(any());
+ verify(nextHandler, timeout(TIMEOUT)).accept(any());
+ verify(lastHandler, timeout(TIMEOUT)).accept(any());
+ }
+
+ @Test
+ @DisplayName("should have all properties")
+ @Specification(number = "5.2.4", text = "The handler function MUST accept a event details parameter.")
+ @Specification(number = "5.2.3", text = "The event details MUST contain the client name associated with the event.")
+ void shouldHaveAllProperties() throws Exception {
+ final Consumer handler1 = mockHandler();
+ final Consumer handler2 = mockHandler();
+ final String name = "shouldHaveAllProperties";
+
+ TestEventsProvider provider = new TestEventsProvider(INIT_DELAY);
+ OpenFeatureAPI.getInstance().setProvider(name, provider);
+ Client client = OpenFeatureAPI.getInstance().getClient(name);
+
+ // attached handlers
+ OpenFeatureAPI.getInstance().onProviderConfigurationChanged(handler1);
+ client.onProviderConfigurationChanged(handler2);
+
+ List flagsChanged = Arrays.asList("flag");
+ ImmutableMetadata metadata = ImmutableMetadata.builder().addInteger("int", 1).build();
+ String message = "a message";
+ ProviderEventDetails details = ProviderEventDetails.builder()
+ .eventMetadata(metadata)
+ .flagsChanged(flagsChanged)
+ .message(message)
+ .build();
+
+ provider.mockEvent(ProviderEvent.PROVIDER_CONFIGURATION_CHANGED, details);
+
+ // both global and client handler should have all the fields.
+ verify(handler1, timeout(TIMEOUT))
+ .accept(argThat((EventDetails eventDetails) -> {
+ return metadata.equals(eventDetails.getEventMetadata())
+ // TODO: issue for client name in events
+ && flagsChanged.equals(eventDetails.getFlagsChanged())
+ && message.equals(eventDetails.getMessage());
+ }));
+ verify(handler2, timeout(TIMEOUT))
+ .accept(argThat((EventDetails eventDetails) -> {
+ return metadata.equals(eventDetails.getEventMetadata())
+ && flagsChanged.equals(eventDetails.getFlagsChanged())
+ && message.equals(eventDetails.getMessage())
+ && name.equals(eventDetails.getClientName());
+ }));
+ }
+
+ @Test
+ @DisplayName("if the provider is ready handlers must run immediately")
+ @Specification(number = "5.3.3", text = "PROVIDER_READY handlers attached after the provider is already in a ready state MUST run immediately.")
+ void readyMustRunImmediately() throws Exception {
+ final String name = "readyMustRunImmediately";
+ final Consumer handler = mockHandler();
+
+ // provider which is already ready
+ TestEventsProvider provider = new TestEventsProvider(ProviderState.READY);
+ OpenFeatureAPI.getInstance().setProvider(name, provider);
+
+ // should run even thought handler was added after ready
+ Client client = OpenFeatureAPI.getInstance().getClient(name);
+ client.onProviderReady(handler);
+ verify(handler, timeout(TIMEOUT)).accept(any());
+ }
+
+ @Test
+ @DisplayName("must persist across changes")
+ @Specification(number = "5.2.6", text = "Event handlers MUST persist across provider changes.")
+ void mustPersistAcrossChanges() throws Exception {
+ final String name = "mustPersistAcrossChanges";
+ final Consumer handler = mockHandler();
+
+ TestEventsProvider provider1 = new TestEventsProvider(INIT_DELAY);
+ TestEventsProvider provider2 = new TestEventsProvider(INIT_DELAY);
+
+ OpenFeatureAPI.getInstance().setProvider(name, provider1);
+ Client client = OpenFeatureAPI.getInstance().getClient(name);
+ client.onProviderConfigurationChanged(handler);
+
+ provider1.mockEvent(ProviderEvent.PROVIDER_CONFIGURATION_CHANGED, ProviderEventDetails.builder().build());
+ ArgumentMatcher nameMatches = (EventDetails details) -> details.getClientName().equals(name);
+
+ 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));
+
+ // verify that with the new provider under the same name, the handler is called
+ // again.
+ provider2.mockEvent(ProviderEvent.PROVIDER_CONFIGURATION_CHANGED, ProviderEventDetails.builder().build());
+ verify(handler, timeout(TIMEOUT).times(2)).accept(argThat(nameMatches));
+ }
+
+ @Nested
+ class HandlerRemoval {
+ @Test
+ @DisplayName("should not run removed events")
+ 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);
+ Client client = OpenFeatureAPI.getInstance().getClient(name);
+
+ // attached handlers
+ OpenFeatureAPI.getInstance().onProviderStale(handler1);
+ client.onProviderConfigurationChanged(handler2);
+
+ OpenFeatureAPI.getInstance().removeHandler(ProviderEvent.PROVIDER_STALE, handler1);
+ client.removeHandler(ProviderEvent.PROVIDER_CONFIGURATION_CHANGED, handler2);
+
+ // 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());
+ }
+ }
+
+ @Specification(number = "5.1.4", text = "PROVIDER_ERROR events SHOULD populate the provider event details's error message field.")
+ @Test
+ void thisIsAProviderRequirement() {
+ }
+
+ @SuppressWarnings("unchecked")
+ private static Consumer mockHandler() {
+ return mock(Consumer.class);
+ }
+}
diff --git a/src/test/java/dev/openfeature/sdk/FlagEvaluationDetailsTest.java b/src/test/java/dev/openfeature/sdk/FlagEvaluationDetailsTest.java
new file mode 100644
index 00000000..9a6df1a6
--- /dev/null
+++ b/src/test/java/dev/openfeature/sdk/FlagEvaluationDetailsTest.java
@@ -0,0 +1,48 @@
+package dev.openfeature.sdk;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class FlagEvaluationDetailsTest {
+
+ @Test
+ @DisplayName("Should have empty constructor")
+ public void empty() {
+ FlagEvaluationDetails details = new FlagEvaluationDetails();
+ assertNotNull(details);
+ }
+
+ @Test
+ @DisplayName("Should have flagKey, value, variant, reason, errorCode, errorMessage, metadata constructor")
+ // removeing this constructor is a breaking change!
+ public void sevenArgConstructor() {
+
+ String flagKey = "my-flag";
+ Integer value = 100;
+ String variant = "1-hundred";
+ Reason reason = Reason.DEFAULT;
+ ErrorCode errorCode = ErrorCode.GENERAL;
+ String errorMessage = "message";
+ ImmutableMetadata metadata = ImmutableMetadata.builder().build();
+
+ FlagEvaluationDetails details = new FlagEvaluationDetails<>(
+ flagKey,
+ value,
+ variant,
+ reason.toString(),
+ errorCode,
+ errorMessage,
+ metadata);
+
+ assertEquals(flagKey, details.getFlagKey());
+ assertEquals(value, details.getValue());
+ assertEquals(variant, details.getVariant());
+ assertEquals(reason.toString(), details.getReason());
+ assertEquals(errorCode, details.getErrorCode());
+ assertEquals(errorMessage, details.getErrorMessage());
+ assertEquals(metadata, details.getFlagMetadata());
+ }
+}
diff --git a/src/test/java/dev/openfeature/sdk/FlagEvaluationSpecTest.java b/src/test/java/dev/openfeature/sdk/FlagEvaluationSpecTest.java
index e246c6d6..eb41fd95 100644
--- a/src/test/java/dev/openfeature/sdk/FlagEvaluationSpecTest.java
+++ b/src/test/java/dev/openfeature/sdk/FlagEvaluationSpecTest.java
@@ -1,7 +1,8 @@
package dev.openfeature.sdk;
+import static dev.openfeature.sdk.DoSomethingProvider.flagMetadata;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.InstanceOfAssertFactories.optional;
+import static org.assertj.core.api.Assertions.assertThatCode;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
@@ -12,36 +13,38 @@
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
-import java.io.Serializable;
-import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
-
-import dev.openfeature.sdk.exceptions.FlagNotFoundError;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
-
-import dev.openfeature.sdk.fixtures.HookFixtures;
import org.mockito.ArgumentMatchers;
import org.mockito.Mockito;
import org.simplify4u.slf4jmock.LoggerMock;
import org.slf4j.Logger;
+import dev.openfeature.sdk.exceptions.FlagNotFoundError;
+import dev.openfeature.sdk.fixtures.HookFixtures;
+import dev.openfeature.sdk.testutils.FeatureProviderTestUtils;
+
class FlagEvaluationSpecTest implements HookFixtures {
private Logger logger;
+ private OpenFeatureAPI api;
private Client _client() {
- OpenFeatureAPI api = OpenFeatureAPI.getInstance();
- api.setProvider(new NoOpProvider());
+ FeatureProviderTestUtils.setFeatureProvider(new NoOpProvider());
return api.getClient();
}
+ @BeforeEach
+ void getApiInstance() {
+ api = OpenFeatureAPI.getInstance();
+ }
+
@AfterEach void reset_ctx() {
- OpenFeatureAPI api = OpenFeatureAPI.getInstance();
api.setEvaluationContext(null);
}
@@ -59,26 +62,23 @@ private Client _client() {
assertSame(OpenFeatureAPI.getInstance(), OpenFeatureAPI.getInstance());
}
- @Specification(number="1.1.2", text="The API MUST provide a function to set the global provider singleton, which accepts an API-conformant provider implementation.")
+ @Specification(number="1.1.2.1", text="The API MUST define a provider mutator, a function to set the default provider, which accepts an API-conformant provider implementation.")
@Test void provider() {
- OpenFeatureAPI api = OpenFeatureAPI.getInstance();
FeatureProvider mockProvider = mock(FeatureProvider.class);
- api.setProvider(mockProvider);
- assertEquals(mockProvider, api.getProvider());
+ FeatureProviderTestUtils.setFeatureProvider(mockProvider);
+ assertThat(api.getProvider()).isEqualTo(mockProvider);
}
- @Specification(number="1.1.4", text="The API MUST provide a function for retrieving the metadata field of the configured provider.")
+ @Specification(number="1.1.5", text="The API MUST provide a function for retrieving the metadata field of the configured provider.")
@Test void provider_metadata() {
- OpenFeatureAPI api = OpenFeatureAPI.getInstance();
- api.setProvider(new DoSomethingProvider());
- assertEquals(DoSomethingProvider.name, api.getProviderMetadata().getName());
+ FeatureProviderTestUtils.setFeatureProvider(new DoSomethingProvider());
+ assertThat(api.getProviderMetadata().getName()).isEqualTo(DoSomethingProvider.name);
}
- @Specification(number="1.1.3", text="The API MUST provide a function to add hooks which accepts one or more API-conformant hooks, and appends them to the collection of any previously added hooks. When new hooks are added, previously added hooks are not removed.")
+ @Specification(number="1.1.4", text="The API MUST provide a function to add hooks which accepts one or more API-conformant hooks, and appends them to the collection of any previously added hooks. When new hooks are added, previously added hooks are not removed.")
@Test void hook_addition() {
Hook h1 = mock(Hook.class);
Hook h2 = mock(Hook.class);
- OpenFeatureAPI api = OpenFeatureAPI.getInstance();
api.addHooks(h1);
assertEquals(1, api.getHooks().size());
@@ -89,10 +89,9 @@ private Client _client() {
assertEquals(h2, api.getHooks().get(1));
}
- @Specification(number="1.1.5", text="The API MUST provide a function for creating a client which accepts the following options: - name (optional): A logical string identifier for the client.")
+ @Specification(number="1.1.6", text="The API MUST provide a function for creating a client which accepts the following options: - name (optional): A logical string identifier for the client.")
@Test void namedClient() {
- OpenFeatureAPI api = OpenFeatureAPI.getInstance();
- Client c = api.getClient("Sir Calls-a-lot");
+ assertThatCode(() -> api.getClient("Sir Calls-a-lot")).doesNotThrowAnyException();
// TODO: Doesn't say that you can *get* the client name.. which seems useful?
}
@@ -112,8 +111,8 @@ private Client _client() {
@Specification(number="1.3.1", text="The client MUST provide methods for typed flag evaluation, including boolean, numeric, string, and structure, with parameters flag key (string, required), default value (boolean | number | string | structure, required), evaluation context (optional), and evaluation options (optional), which returns the flag value.")
@Specification(number="1.3.2.1", text="The client SHOULD provide functions for floating-point numbers and integers, consistent with language idioms.")
@Test void value_flags() {
- OpenFeatureAPI api = OpenFeatureAPI.getInstance();
- api.setProvider(new DoSomethingProvider());
+ FeatureProviderTestUtils.setFeatureProvider(new DoSomethingProvider());
+
Client c = api.getClient();
String key = "key";
@@ -145,8 +144,7 @@ private Client _client() {
@Specification(number="1.4.5", text="In cases of normal execution, the evaluation details structure's variant field MUST contain the value of the variant field in the flag resolution structure returned by the configured provider, if the field is set.")
@Specification(number="1.4.6", text="In cases of normal execution, the evaluation details structure's reason field MUST contain the value of the reason field in the flag resolution structure returned by the configured provider, if the field is set.")
@Test void detail_flags() {
- OpenFeatureAPI api = OpenFeatureAPI.getInstance();
- api.setProvider(new DoSomethingProvider());
+ FeatureProviderTestUtils.setFeatureProvider(new DoSomethingProvider());
Client c = api.getClient();
String key = "key";
@@ -154,6 +152,7 @@ private Client _client() {
.flagKey(key)
.value(false)
.variant(null)
+ .flagMetadata(flagMetadata)
.build();
assertEquals(bd, c.getBooleanDetails(key, true));
assertEquals(bd, c.getBooleanDetails(key, true, new ImmutableContext()));
@@ -163,6 +162,7 @@ private Client _client() {
.flagKey(key)
.value("tset")
.variant(null)
+ .flagMetadata(flagMetadata)
.build();
assertEquals(sd, c.getStringDetails(key, "test"));
assertEquals(sd, c.getStringDetails(key, "test", new ImmutableContext()));
@@ -171,6 +171,7 @@ private Client _client() {
FlagEvaluationDetails id = FlagEvaluationDetails.builder()
.flagKey(key)
.value(400)
+ .flagMetadata(flagMetadata)
.build();
assertEquals(id, c.getIntegerDetails(key, 4));
assertEquals(id, c.getIntegerDetails(key, 4, new ImmutableContext()));
@@ -179,6 +180,7 @@ private Client _client() {
FlagEvaluationDetails dd = FlagEvaluationDetails.builder()
.flagKey(key)
.value(40.0)
+ .flagMetadata(flagMetadata)
.build();
assertEquals(dd, c.getDoubleDetails(key, .4));
assertEquals(dd, c.getDoubleDetails(key, .4, new ImmutableContext()));
@@ -204,8 +206,7 @@ private Client _client() {
@Specification(number="1.4.7", text="In cases of abnormal execution, the `evaluation details` structure's `error code` field **MUST** contain an `error code`.")
@Specification(number="1.4.12", text="In cases of abnormal execution, the `evaluation details` structure's `error message` field **MAY** contain a string containing additional details about the nature of the error.")
@Test void broken_provider() {
- OpenFeatureAPI api = OpenFeatureAPI.getInstance();
- api.setProvider(new AlwaysBrokenProvider());
+ FeatureProviderTestUtils.setFeatureProvider(new AlwaysBrokenProvider());
Client c = api.getClient();
assertFalse(c.getBooleanValue("key", false));
FlagEvaluationDetails details = c.getBooleanDetails("key", false);
@@ -215,8 +216,7 @@ private Client _client() {
@Specification(number="1.4.10", text="In the case of abnormal execution, the client SHOULD log an informative error message.")
@Test void log_on_error() throws NotImplementedException {
- OpenFeatureAPI api = OpenFeatureAPI.getInstance();
- api.setProvider(new AlwaysBrokenProvider());
+ FeatureProviderTestUtils.setFeatureProvider(new AlwaysBrokenProvider());
Client c = api.getClient();
FlagEvaluationDetails result = c.getBooleanDetails("test", false);
@@ -232,16 +232,14 @@ private Client _client() {
Client c = _client();
assertNull(c.getMetadata().getName());
- OpenFeatureAPI api = OpenFeatureAPI.getInstance();
- api.setProvider(new AlwaysBrokenProvider());
+ FeatureProviderTestUtils.setFeatureProvider(new AlwaysBrokenProvider());
Client c2 = api.getClient("test");
assertEquals("test", c2.getMetadata().getName());
}
@Specification(number="1.4.8", text="In cases of abnormal execution (network failure, unhandled error, etc) the reason field in the evaluation details SHOULD indicate an error.")
@Test void reason_is_error_when_there_are_errors() {
- OpenFeatureAPI api = OpenFeatureAPI.getInstance();
- api.setProvider(new AlwaysBrokenProvider());
+ FeatureProviderTestUtils.setFeatureProvider(new AlwaysBrokenProvider());
Client c = api.getClient();
FlagEvaluationDetails result = c.getBooleanDetails("test", false);
assertEquals(Reason.ERROR.toString(), result.getReason());
@@ -250,9 +248,8 @@ private Client _client() {
@Specification(number="3.2.1", text="The API, Client and invocation MUST have a method for supplying evaluation context.")
@Specification(number="3.2.2", text="Evaluation context MUST be merged in the order: API (global; lowest precedence) - client - invocation - before hooks (highest precedence), with duplicate values being overwritten.")
@Test void multi_layer_context_merges_correctly() {
- OpenFeatureAPI api = OpenFeatureAPI.getInstance();
DoSomethingProvider provider = new DoSomethingProvider();
- api.setProvider(provider);
+ FeatureProviderTestUtils.setFeatureProvider(provider);
Map attributes = new HashMap<>();
attributes.put("common", new Value("1"));
@@ -289,7 +286,7 @@ private Client _client() {
@Specification(number="1.3.3", text="The client SHOULD guarantee the returned value of any typed flag evaluation method is of the expected type. If the value returned by the underlying provider implementation does not match the expected type, it's to be considered abnormal execution, and the supplied default value should be returned.")
@Test void type_system_prevents_this() {}
- @Specification(number="1.1.6", text="The client creation function MUST NOT throw, or otherwise abnormally terminate.")
+ @Specification(number="1.1.7", text="The client creation function MUST NOT throw, or otherwise abnormally terminate.")
@Test void constructor_does_not_throw() {}
@Specification(number="1.4.11", text="The client SHOULD provide asynchronous or non-blocking mechanisms for flag evaluation.")
diff --git a/src/test/java/dev/openfeature/sdk/FlagMetadataTest.java b/src/test/java/dev/openfeature/sdk/FlagMetadataTest.java
new file mode 100644
index 00000000..c300daa0
--- /dev/null
+++ b/src/test/java/dev/openfeature/sdk/FlagMetadataTest.java
@@ -0,0 +1,64 @@
+package dev.openfeature.sdk;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class FlagMetadataTest {
+
+ @Test
+ @DisplayName("Test metadata payload construction and retrieval")
+ public void builder_validation() {
+ // given
+ ImmutableMetadata flagMetadata = ImmutableMetadata.builder()
+ .addString("string", "string")
+ .addInteger("integer", 1)
+ .addLong("long", 1L)
+ .addFloat("float", 1.5f)
+ .addDouble("double", Double.MAX_VALUE)
+ .addBoolean("boolean", Boolean.FALSE)
+ .build();
+
+ // then
+ assertThat(flagMetadata.getString("string")).isEqualTo("string");
+ assertThat(flagMetadata.getValue("string", String.class)).isEqualTo("string");
+
+ assertThat(flagMetadata.getInteger("integer")).isEqualTo(1);
+ assertThat(flagMetadata.getValue("integer", Integer.class)).isEqualTo(1);
+
+ assertThat(flagMetadata.getLong("long")).isEqualTo(1L);
+ assertThat(flagMetadata.getValue("long", Long.class)).isEqualTo(1L);
+
+ assertThat(flagMetadata.getFloat("float")).isEqualTo(1.5f);
+ assertThat(flagMetadata.getValue("float", Float.class)).isEqualTo(1.5f);
+
+ assertThat(flagMetadata.getDouble("double")).isEqualTo(Double.MAX_VALUE);
+ assertThat(flagMetadata.getValue("double", Double.class)).isEqualTo(Double.MAX_VALUE);
+
+ assertThat(flagMetadata.getBoolean("boolean")).isEqualTo(Boolean.FALSE);
+ assertThat(flagMetadata.getValue("boolean", Boolean.class)).isEqualTo(Boolean.FALSE);
+ }
+
+ @Test
+ @DisplayName("Value type mismatch returns a null")
+ public void value_type_validation() {
+ // given
+ ImmutableMetadata flagMetadata = ImmutableMetadata.builder()
+ .addString("string", "string")
+ .build();
+
+ // then
+ assertThat(flagMetadata.getBoolean("string")).isNull();
+ }
+
+ @Test
+ @DisplayName("A null is returned if key does not exist")
+ public void notfound_error_validation() {
+ // given
+ ImmutableMetadata flagMetadata = ImmutableMetadata.builder().build();
+
+ // then
+ assertThat(flagMetadata.getBoolean("string")).isNull();
+ }
+}
diff --git a/src/test/java/dev/openfeature/sdk/HookSpecTest.java b/src/test/java/dev/openfeature/sdk/HookSpecTest.java
index 26a1b49e..d1daa705 100644
--- a/src/test/java/dev/openfeature/sdk/HookSpecTest.java
+++ b/src/test/java/dev/openfeature/sdk/HookSpecTest.java
@@ -21,7 +21,7 @@
import java.util.Map;
import java.util.Optional;
-import io.cucumber.java.hu.Ha;
+import dev.openfeature.sdk.testutils.FeatureProviderTestUtils;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
@@ -30,7 +30,7 @@
import dev.openfeature.sdk.fixtures.HookFixtures;
import lombok.SneakyThrows;
-public class HookSpecTest implements HookFixtures {
+class HookSpecTest implements HookFixtures {
@AfterEach
void emptyApiHooks() {
// it's a singleton. Don't pollute each test.
@@ -390,7 +390,7 @@ public void finallyAfter(HookContext ctx, Map hints) {
InOrder order = inOrder(hook, provider);
OpenFeatureAPI api = OpenFeatureAPI.getInstance();
- api.setProvider(provider);
+ FeatureProviderTestUtils.setFeatureProvider(provider);
Client client = api.getClient();
client.getBooleanValue("key", false, new ImmutableContext(),
FlagEvaluationOptions.builder().hook(hook).build());
@@ -493,7 +493,7 @@ public void finallyAfter(HookContext ctx, Map hints) {
.build());
OpenFeatureAPI api = OpenFeatureAPI.getInstance();
- api.setProvider(provider);
+ FeatureProviderTestUtils.setFeatureProvider(provider);
Client client = api.getClient();
client.getBooleanValue("key", false, invocationCtx,
FlagEvaluationOptions.builder()
@@ -551,12 +551,11 @@ public void finallyAfter(HookContext ctx, Map hints) {
private Client getClient(FeatureProvider provider) {
OpenFeatureAPI api = OpenFeatureAPI.getInstance();
if (provider == null) {
- api.setProvider(new NoOpProvider());
+ FeatureProviderTestUtils.setFeatureProvider(new NoOpProvider());
} else {
- api.setProvider(provider);
+ FeatureProviderTestUtils.setFeatureProvider(provider);
}
- Client client = api.getClient();
- return client;
+ return api.getClient();
}
@Specification(number="4.3.1", text="Hooks MUST specify at least one stage.")
@@ -565,14 +564,12 @@ private Client getClient(FeatureProvider provider) {
@Specification(number="4.3.8.1", text="Instead of finally, finallyAfter SHOULD be used.")
@SneakyThrows
@Test void doesnt_use_finally() {
- try {
- Hook.class.getMethod("finally", HookContext.class, Map.class);
- fail("Not possible. Finally is a reserved word.");
- } catch (NoSuchMethodException e) {
- // expected
- }
+ assertThatCode(() -> Hook.class.getMethod("finally", HookContext.class, Map.class))
+ .as("Not possible. Finally is a reserved word.")
+ .isInstanceOf(NoSuchMethodException.class);
- Hook.class.getMethod("finallyAfter", HookContext.class, Map.class);
+ assertThatCode(() -> Hook.class.getMethod("finallyAfter", HookContext.class, Map.class))
+ .doesNotThrowAnyException();
}
}
diff --git a/src/test/java/dev/openfeature/sdk/ImmutableStructureTest.java b/src/test/java/dev/openfeature/sdk/ImmutableStructureTest.java
index 49cd236a..d7453452 100644
--- a/src/test/java/dev/openfeature/sdk/ImmutableStructureTest.java
+++ b/src/test/java/dev/openfeature/sdk/ImmutableStructureTest.java
@@ -111,4 +111,15 @@ void GettingAMissingValueShouldReturnNull() {
Object value = structure.getValue("missing");
assertNull(value);
}
+
+ @Test void objectMapTest() {
+ Map attrs = new HashMap<>();
+ attrs.put("test", new Value(45));
+ ImmutableStructure structure = new ImmutableStructure(attrs);
+
+ Map expected = new HashMap<>();
+ expected.put("test", 45);
+
+ assertEquals(expected, structure.asObjectMap());
+ }
}
diff --git a/src/test/java/dev/openfeature/sdk/InitializeBehaviorSpecTest.java b/src/test/java/dev/openfeature/sdk/InitializeBehaviorSpecTest.java
new file mode 100644
index 00000000..0ab5e371
--- /dev/null
+++ b/src/test/java/dev/openfeature/sdk/InitializeBehaviorSpecTest.java
@@ -0,0 +1,85 @@
+package dev.openfeature.sdk;
+
+import dev.openfeature.sdk.testutils.exception.TestException;
+import org.junit.jupiter.api.*;
+
+import static org.assertj.core.api.Assertions.assertThatCode;
+import static org.mockito.Mockito.*;
+
+class InitializeBehaviorSpecTest {
+
+ @BeforeEach
+ void setupTest() {
+ OpenFeatureAPI.getInstance().setProvider(new NoOpProvider());
+ }
+
+ @Nested
+ class DefaultProvider {
+
+ @Specification(number = "1.1.2.2", text = "The `provider mutator` function MUST invoke the `initialize` "
+ + "function on the newly registered provider before using it to resolve flag values.")
+ @Test
+ @DisplayName("must call initialize function of the newly registered provider before using it for "
+ + "flag evaluation")
+ void mustCallInitializeFunctionOfTheNewlyRegisteredProviderBeforeUsingItForFlagEvaluation() throws Exception {
+ FeatureProvider featureProvider = mock(FeatureProvider.class);
+ doReturn(ProviderState.NOT_READY).when(featureProvider).getState();
+
+ OpenFeatureAPI.getInstance().setProvider(featureProvider);
+
+ verify(featureProvider, timeout(1000)).initialize(any());
+ }
+
+ @Specification(number = "1.4.9", text = "Methods, functions, or operations on the client MUST NOT throw "
+ + "exceptions, or otherwise abnormally terminate. Flag evaluation calls must always return the "
+ + "`default value` in the event of abnormal execution. Exceptions include functions or methods for "
+ + "the purposes for configuration or setup.")
+ @Test
+ @DisplayName("should catch exception thrown by the provider on initialization")
+ void shouldCatchExceptionThrownByTheProviderOnInitialization() throws Exception {
+ FeatureProvider featureProvider = mock(FeatureProvider.class);
+ doReturn(ProviderState.NOT_READY).when(featureProvider).getState();
+ doThrow(TestException.class).when(featureProvider).initialize(any());
+
+ assertThatCode(() -> OpenFeatureAPI.getInstance().setProvider(featureProvider))
+ .doesNotThrowAnyException();
+
+ verify(featureProvider, timeout(1000)).initialize(any());
+ }
+ }
+
+ @Nested
+ class ProviderForNamedClient {
+
+ @Specification(number = "1.1.2.2", text = "The `provider mutator` function MUST invoke the `initialize`"
+ + " function on the newly registered provider before using it to resolve flag values.")
+ @Test
+ @DisplayName("must call initialize function of the newly registered named provider before using it "
+ + "for flag evaluation")
+ void mustCallInitializeFunctionOfTheNewlyRegisteredNamedProviderBeforeUsingItForFlagEvaluation() throws Exception {
+ FeatureProvider featureProvider = mock(FeatureProvider.class);
+ doReturn(ProviderState.NOT_READY).when(featureProvider).getState();
+
+ OpenFeatureAPI.getInstance().setProvider("clientName", featureProvider);
+
+ verify(featureProvider, timeout(1000)).initialize(any());
+ }
+
+ @Specification(number = "1.4.9", text = "Methods, functions, or operations on the client MUST NOT throw "
+ + "exceptions, or otherwise abnormally terminate. Flag evaluation calls must always return the "
+ + "`default value` in the event of abnormal execution. Exceptions include functions or methods for "
+ + "the purposes for configuration or setup.")
+ @Test
+ @DisplayName("should catch exception thrown by the named client provider on initialization")
+ void shouldCatchExceptionThrownByTheNamedClientProviderOnInitialization() throws Exception {
+ FeatureProvider featureProvider = mock(FeatureProvider.class);
+ doReturn(ProviderState.NOT_READY).when(featureProvider).getState();
+ doThrow(TestException.class).when(featureProvider).initialize(any());
+
+ assertThatCode(() -> OpenFeatureAPI.getInstance().setProvider("clientName", featureProvider))
+ .doesNotThrowAnyException();
+
+ verify(featureProvider, timeout(1000)).initialize(any());
+ }
+ }
+}
diff --git a/src/test/java/dev/openfeature/sdk/LockingTest.java b/src/test/java/dev/openfeature/sdk/LockingTest.java
index f8dceee6..d9601e85 100644
--- a/src/test/java/dev/openfeature/sdk/LockingTest.java
+++ b/src/test/java/dev/openfeature/sdk/LockingTest.java
@@ -6,20 +6,20 @@
import static org.mockito.Mockito.when;
import java.util.concurrent.locks.ReentrantReadWriteLock;
+import java.util.function.Consumer;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import dev.openfeature.sdk.internal.AutoCloseableReentrantReadWriteLock;
class LockingTest {
-
+
private static OpenFeatureAPI api;
private OpenFeatureClient client;
- private AutoCloseableReentrantReadWriteLock apiContextLock;
- private AutoCloseableReentrantReadWriteLock apiHooksLock;
- private AutoCloseableReentrantReadWriteLock apiProviderLock;
+ private AutoCloseableReentrantReadWriteLock apiLock;
private AutoCloseableReentrantReadWriteLock clientContextLock;
private AutoCloseableReentrantReadWriteLock clientHooksLock;
@@ -32,12 +32,8 @@ static void beforeAll() {
void beforeEach() {
client = (OpenFeatureClient) api.getClient();
- apiContextLock = setupLock(apiContextLock, mockInnerReadLock(), mockInnerWriteLock());
- apiProviderLock = setupLock(apiProviderLock, mockInnerReadLock(), mockInnerWriteLock());
- apiHooksLock = setupLock(apiHooksLock, mockInnerReadLock(), mockInnerWriteLock());
- OpenFeatureAPI.contextLock = apiContextLock;
- OpenFeatureAPI.providerLock = apiProviderLock;
- OpenFeatureAPI.hooksLock = apiHooksLock;
+ apiLock = setupLock(apiLock, mockInnerReadLock(), mockInnerWriteLock());
+ OpenFeatureAPI.lock = apiLock;
clientContextLock = setupLock(clientContextLock, mockInnerReadLock(), mockInnerWriteLock());
clientHooksLock = setupLock(clientHooksLock, mockInnerReadLock(), mockInnerWriteLock());
@@ -45,6 +41,101 @@ void beforeEach() {
client.hooksLock = clientHooksLock;
}
+ @Nested
+ class EventsLocking {
+
+ @Nested
+ class Api {
+
+ @Test
+ void onShouldWriteLockAndUnlock() {
+ Consumer handler = mock(Consumer.class);
+ api.on(ProviderEvent.PROVIDER_READY, handler);
+ verify(apiLock.writeLock()).lock();
+ verify(apiLock.writeLock()).unlock();
+ }
+
+ @Test
+ void onProviderReadyShouldWriteLockAndUnlock() {
+ Consumer handler = mock(Consumer.class);
+ api.onProviderReady(handler);
+ verify(apiLock.writeLock()).lock();
+ verify(apiLock.writeLock()).unlock();
+ }
+
+ @Test
+ void onProviderConfigurationChangedShouldWriteLockAndUnlock() {
+ Consumer handler = mock(Consumer.class);
+ api.onProviderConfigurationChanged(handler);
+ verify(apiLock.writeLock()).lock();
+ verify(apiLock.writeLock()).unlock();
+ }
+
+ @Test
+ void onProviderStaleShouldWriteLockAndUnlock() {
+ Consumer handler = mock(Consumer.class);
+ api.onProviderStale(handler);
+ verify(apiLock.writeLock()).lock();
+ verify(apiLock.writeLock()).unlock();
+ }
+
+ @Test
+ void onProviderErrorShouldWriteLockAndUnlock() {
+ Consumer handler = mock(Consumer.class);
+ api.onProviderError(handler);
+ verify(apiLock.writeLock()).lock();
+ verify(apiLock.writeLock()).unlock();
+ }
+ }
+
+ @Nested
+ class Client {
+
+ // Note that the API lock is used for adding client handlers, they are all added (indirectly) on the API object.
+
+ @Test
+ void onShouldApiWriteLockAndUnlock() {
+ Consumer handler = mock(Consumer.class);
+ client.on(ProviderEvent.PROVIDER_READY, handler);
+ verify(apiLock.writeLock()).lock();
+ verify(apiLock.writeLock()).unlock();
+ }
+
+ @Test
+ void onProviderReadyShouldApiWriteLockAndUnlock() {
+ Consumer handler = mock(Consumer.class);
+ api.onProviderReady(handler);
+ verify(apiLock.writeLock()).lock();
+ verify(apiLock.writeLock()).unlock();
+ }
+
+ @Test
+ void onProviderConfigurationChangedProviderReadyShouldApiWriteLockAndUnlock() {
+ Consumer handler = mock(Consumer.class);
+ api.onProviderConfigurationChanged(handler);
+ verify(apiLock.writeLock()).lock();
+ verify(apiLock.writeLock()).unlock();
+ }
+
+ @Test
+ void onProviderStaleProviderReadyShouldApiWriteLockAndUnlock() {
+ Consumer handler = mock(Consumer.class);
+ api.onProviderStale(handler);
+ verify(apiLock.writeLock()).lock();
+ verify(apiLock.writeLock()).unlock();
+ }
+
+ @Test
+ void onProviderErrorProviderReadyShouldApiWriteLockAndUnlock() {
+ Consumer handler = mock(Consumer.class);
+ api.onProviderError(handler);
+ verify(apiLock.writeLock()).lock();
+ verify(apiLock.writeLock()).unlock();
+ }
+ }
+ }
+
+
@Test
void addHooksShouldWriteLockAndUnlock() {
client.addHooks(new Hook() {
@@ -54,8 +145,8 @@ void addHooksShouldWriteLockAndUnlock() {
api.addHooks(new Hook() {
});
- verify(apiHooksLock.writeLock()).lock();
- verify(apiHooksLock.writeLock()).unlock();
+ verify(apiLock.writeLock()).lock();
+ verify(apiLock.writeLock()).unlock();
}
@Test
@@ -65,8 +156,8 @@ void getHooksShouldReadLockAndUnlock() {
verify(clientHooksLock.readLock()).unlock();
api.getHooks();
- verify(apiHooksLock.readLock()).lock();
- verify(apiHooksLock.readLock()).unlock();
+ verify(apiLock.readLock()).lock();
+ verify(apiLock.readLock()).unlock();
}
@Test
@@ -76,8 +167,8 @@ void setContextShouldWriteLockAndUnlock() {
verify(clientContextLock.writeLock()).unlock();
api.setEvaluationContext(new ImmutableContext());
- verify(apiContextLock.writeLock()).lock();
- verify(apiContextLock.writeLock()).unlock();
+ verify(apiLock.writeLock()).lock();
+ verify(apiLock.writeLock()).unlock();
}
@Test
@@ -87,22 +178,16 @@ void getContextShouldReadLockAndUnlock() {
verify(clientContextLock.readLock()).unlock();
api.getEvaluationContext();
- verify(apiContextLock.readLock()).lock();
- verify(apiContextLock.readLock()).unlock();
+ verify(apiLock.readLock()).lock();
+ verify(apiLock.readLock()).unlock();
}
- @Test
- void setProviderShouldWriteLockAndUnlock() {
- api.setProvider(new DoSomethingProvider());
- verify(apiProviderLock.writeLock()).lock();
- verify(apiProviderLock.writeLock()).unlock();
- }
@Test
void clearHooksShouldWriteLockAndUnlock() {
api.clearHooks();
- verify(apiHooksLock.writeLock()).lock();
- verify(apiHooksLock.writeLock()).unlock();
+ verify(apiLock.writeLock()).lock();
+ verify(apiLock.writeLock()).unlock();
}
private static ReentrantReadWriteLock.ReadLock mockInnerReadLock() {
diff --git a/src/test/java/dev/openfeature/sdk/OpenFeatureAPITest.java b/src/test/java/dev/openfeature/sdk/OpenFeatureAPITest.java
new file mode 100644
index 00000000..a49bf643
--- /dev/null
+++ b/src/test/java/dev/openfeature/sdk/OpenFeatureAPITest.java
@@ -0,0 +1,39 @@
+package dev.openfeature.sdk;
+
+import dev.openfeature.sdk.testutils.FeatureProviderTestUtils;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatCode;
+
+class OpenFeatureAPITest {
+
+ private static final String CLIENT_NAME = "client name";
+
+ private OpenFeatureAPI api;
+
+ @BeforeEach
+ void setupTest() {
+ api = OpenFeatureAPI.getInstance();
+ }
+
+ @Test
+ void namedProviderTest() {
+ FeatureProvider provider = new NoOpProvider();
+ FeatureProviderTestUtils.setFeatureProvider("namedProviderTest", provider);
+
+ assertThat(provider.getMetadata().getName())
+ .isEqualTo(api.getProviderMetadata("namedProviderTest").getName());
+ }
+
+ @Test
+ void settingDefaultProviderToNullErrors() {
+ assertThatCode(() -> api.setProvider(null)).isInstanceOf(IllegalArgumentException.class);
+ }
+
+ @Test
+ void settingNamedClientProviderToNullErrors() {
+ assertThatCode(() -> api.setProvider(CLIENT_NAME, null)).isInstanceOf(IllegalArgumentException.class);
+ }
+}
diff --git a/src/test/java/dev/openfeature/sdk/OpenFeatureClientTest.java b/src/test/java/dev/openfeature/sdk/OpenFeatureClientTest.java
index ac150677..9036576d 100644
--- a/src/test/java/dev/openfeature/sdk/OpenFeatureClientTest.java
+++ b/src/test/java/dev/openfeature/sdk/OpenFeatureClientTest.java
@@ -27,7 +27,7 @@ class OpenFeatureClientTest implements HookFixtures {
@DisplayName("should not throw exception if hook has different type argument than hookContext")
void shouldNotThrowExceptionIfHookHasDifferentTypeArgumentThanHookContext() {
OpenFeatureAPI api = mock(OpenFeatureAPI.class);
- when(api.getProvider()).thenReturn(new DoSomethingProvider());
+ when(api.getProvider(any())).thenReturn(new DoSomethingProvider());
when(api.getHooks()).thenReturn(Arrays.asList(mockBooleanHook(), mockStringHook()));
OpenFeatureClient client = new OpenFeatureClient(api, "name", "version");
@@ -57,6 +57,8 @@ void mergeContextTest() {
context -> context.getTargetingKey().equals(targetingKey)))).thenReturn(ProviderEvaluation.builder()
.value(true).build());
when(api.getProvider()).thenReturn(mockProvider);
+ when(api.getProvider(any())).thenReturn(mockProvider);
+
OpenFeatureClient client = new OpenFeatureClient(api, "name", "version");
client.setEvaluationContext(ctx);
diff --git a/src/test/java/dev/openfeature/sdk/ProviderEvaluationTest.java b/src/test/java/dev/openfeature/sdk/ProviderEvaluationTest.java
new file mode 100644
index 00000000..16215dc1
--- /dev/null
+++ b/src/test/java/dev/openfeature/sdk/ProviderEvaluationTest.java
@@ -0,0 +1,45 @@
+package dev.openfeature.sdk;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class ProviderEvaluationTest {
+
+ @Test
+ @DisplayName("Should have empty constructor")
+ public void empty() {
+ ProviderEvaluation details = new ProviderEvaluation();
+ assertNotNull(details);
+ }
+
+ @Test
+ @DisplayName("Should have value, variant, reason, errorCode, errorMessage, metadata constructor")
+ // removeing this constructor is a breaking change!
+ public void sixArgConstructor() {
+
+ Integer value = 100;
+ String variant = "1-hundred";
+ Reason reason = Reason.DEFAULT;
+ ErrorCode errorCode = ErrorCode.GENERAL;
+ String errorMessage = "message";
+ ImmutableMetadata metadata = ImmutableMetadata.builder().build();
+
+ ProviderEvaluation details = new ProviderEvaluation<>(
+ value,
+ variant,
+ reason.toString(),
+ errorCode,
+ errorMessage,
+ metadata);
+
+ assertEquals(value, details.getValue());
+ assertEquals(variant, details.getVariant());
+ assertEquals(reason.toString(), details.getReason());
+ assertEquals(errorCode, details.getErrorCode());
+ assertEquals(errorMessage, details.getErrorMessage());
+ assertEquals(metadata, details.getFlagMetadata());
+ }
+}
diff --git a/src/test/java/dev/openfeature/sdk/ProviderRepositoryTest.java b/src/test/java/dev/openfeature/sdk/ProviderRepositoryTest.java
new file mode 100644
index 00000000..5b6dac1b
--- /dev/null
+++ b/src/test/java/dev/openfeature/sdk/ProviderRepositoryTest.java
@@ -0,0 +1,364 @@
+package dev.openfeature.sdk;
+
+import static dev.openfeature.sdk.fixtures.ProviderFixture.createMockedErrorProvider;
+import static dev.openfeature.sdk.fixtures.ProviderFixture.createMockedProvider;
+import static dev.openfeature.sdk.fixtures.ProviderFixture.createMockedReadyProvider;
+import static dev.openfeature.sdk.testutils.stubbing.ConditionStubber.doDelayResponse;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatCode;
+import static org.awaitility.Awaitility.await;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+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.time.Duration;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import dev.openfeature.sdk.testutils.exception.TestException;
+
+class ProviderRepositoryTest {
+
+ private static final String CLIENT_NAME = "client name";
+ private static final String ANOTHER_CLIENT_NAME = "another client name";
+ private static final int TIMEOUT = 5000;
+
+ private final ExecutorService executorService = Executors.newCachedThreadPool();
+
+ private ProviderRepository providerRepository;
+
+ @BeforeEach
+ void setupTest() {
+ providerRepository = new ProviderRepository();
+ }
+
+ @Nested
+ class InitializationBehavior {
+
+ @Nested
+ class DefaultProvider {
+
+ @Test
+ @DisplayName("should reject null as default provider")
+ void shouldRejectNullAsDefaultProvider() {
+ assertThatCode(() -> providerRepository.setProvider(null, mockAfterSet(), mockAfterInit(),
+ mockAfterShutdown(), mockAfterError())).isInstanceOf(IllegalArgumentException.class);
+ }
+
+ @Test
+ @DisplayName("should have NoOpProvider set as default on initialization")
+ void shouldHaveNoOpProviderSetAsDefaultOnInitialization() {
+ assertThat(providerRepository.getProvider()).isInstanceOf(NoOpProvider.class);
+ }
+
+ @Test
+ @DisplayName("should immediately return when calling the provider mutator")
+ void shouldImmediatelyReturnWhenCallingTheProviderMutator() throws Exception {
+ FeatureProvider featureProvider = createMockedProvider();
+ doDelayResponse(Duration.ofSeconds(10)).when(featureProvider).initialize(new ImmutableContext());
+
+ await()
+ .alias("wait for provider mutator to return")
+ .pollDelay(Duration.ofMillis(1))
+ .atMost(Duration.ofSeconds(1))
+ .until(() -> {
+ providerRepository.setProvider(featureProvider, mockAfterSet(), mockAfterInit(),
+ mockAfterShutdown(), mockAfterError());
+ verify(featureProvider, timeout(TIMEOUT)).initialize(any());
+ return true;
+ });
+
+ verify(featureProvider, timeout(TIMEOUT)).initialize(any());
+ }
+
+ @Test
+ @DisplayName("should avoid additional initialization call if provider has been initialized already")
+ void shouldAvoidAdditionalInitializationCallIfProviderHasBeenInitializedAlready() throws Exception {
+ FeatureProvider provider = createMockedReadyProvider();
+ setFeatureProvider(provider);
+
+ verify(provider, never()).initialize(any());
+ }
+ }
+
+ @Nested
+ class NamedProvider {
+
+ @Test
+ @DisplayName("should reject null as named provider")
+ void shouldRejectNullAsNamedProvider() {
+ assertThatCode(() -> providerRepository.setProvider(CLIENT_NAME, null, mockAfterSet(), mockAfterInit(),
+ mockAfterShutdown(), mockAfterError()))
+ .isInstanceOf(IllegalArgumentException.class);
+ }
+
+ @Test
+ @DisplayName("should reject null as client name")
+ void shouldRejectNullAsDefaultProvider() {
+ NoOpProvider provider = new NoOpProvider();
+ assertThatCode(() -> providerRepository.setProvider(null, provider, mockAfterSet(), mockAfterInit(),
+ mockAfterShutdown(), mockAfterError()))
+ .isInstanceOf(IllegalArgumentException.class);
+ }
+
+ @Test
+ @DisplayName("should immediately return when calling the named client provider mutator")
+ void shouldImmediatelyReturnWhenCallingTheNamedClientProviderMutator() throws Exception {
+ FeatureProvider featureProvider = createMockedProvider();
+ doDelayResponse(Duration.ofSeconds(10)).when(featureProvider).initialize(any());
+
+ await()
+ .alias("wait for provider mutator to return")
+ .pollDelay(Duration.ofMillis(1))
+ .atMost(Duration.ofSeconds(1))
+ .until(() -> {
+ providerRepository.setProvider("named client", featureProvider, mockAfterSet(),
+ mockAfterInit(), mockAfterShutdown(), mockAfterError());
+ verify(featureProvider, timeout(TIMEOUT)).initialize(any());
+ return true;
+ });
+ }
+
+ @Test
+ @DisplayName("should avoid additional initialization call if provider has been initialized already")
+ void shouldAvoidAdditionalInitializationCallIfProviderHasBeenInitializedAlready() throws Exception {
+ FeatureProvider provider = createMockedReadyProvider();
+ setFeatureProvider(CLIENT_NAME, provider);
+
+ verify(provider, never()).initialize(any());
+ }
+ }
+ }
+
+ @Nested
+ class ShutdownBehavior {
+
+ @Nested
+ class DefaultProvider {
+
+ @Test
+ @DisplayName("should immediately return when calling the provider mutator")
+ void shouldImmediatelyReturnWhenCallingTheProviderMutator() throws Exception {
+ FeatureProvider newProvider = createMockedProvider();
+ doDelayResponse(Duration.ofSeconds(10)).when(newProvider).initialize(any());
+
+ await()
+ .alias("wait for provider mutator to return")
+ .pollDelay(Duration.ofMillis(1))
+ .atMost(Duration.ofSeconds(1))
+ .until(() -> {
+ providerRepository.setProvider(newProvider, mockAfterSet(), mockAfterInit(),
+ mockAfterShutdown(), mockAfterError());
+ verify(newProvider, timeout(TIMEOUT)).initialize(any());
+ return true;
+ });
+
+ verify(newProvider, timeout(TIMEOUT)).initialize(any());
+ }
+
+ @Test
+ @DisplayName("should not call shutdown if replaced default provider is bound as named provider")
+ void shouldNotCallShutdownIfReplacedDefaultProviderIsBoundAsNamedProvider() {
+ FeatureProvider oldProvider = createMockedProvider();
+ FeatureProvider newProvider = createMockedProvider();
+ setFeatureProvider(oldProvider);
+ setFeatureProvider(CLIENT_NAME, oldProvider);
+
+ setFeatureProvider(newProvider);
+
+ verify(oldProvider, never()).shutdown();
+ }
+ }
+
+ @Nested
+ class NamedProvider {
+
+ @Test
+ @DisplayName("should immediately return when calling the provider mutator")
+ void shouldImmediatelyReturnWhenCallingTheProviderMutator() throws Exception {
+ FeatureProvider newProvider = createMockedProvider();
+ doDelayResponse(Duration.ofSeconds(10)).when(newProvider).initialize(any());
+
+ Future providerMutation = executorService
+ .submit(() -> providerRepository.setProvider(CLIENT_NAME, newProvider, mockAfterSet(),
+ mockAfterInit(), mockAfterShutdown(), mockAfterError()));
+
+ await()
+ .alias("wait for provider mutator to return")
+ .pollDelay(Duration.ofMillis(1))
+ .atMost(Duration.ofSeconds(1))
+ .until(providerMutation::isDone);
+ }
+
+ @Test
+ @DisplayName("should not call shutdown if replaced provider is bound to multiple names")
+ void shouldNotCallShutdownIfReplacedProviderIsBoundToMultipleNames() throws InterruptedException {
+ FeatureProvider oldProvider = createMockedProvider();
+ FeatureProvider newProvider = createMockedProvider();
+ setFeatureProvider(CLIENT_NAME, oldProvider);
+
+ setFeatureProvider(ANOTHER_CLIENT_NAME, oldProvider);
+
+ setFeatureProvider(CLIENT_NAME, newProvider);
+
+ verify(oldProvider, never()).shutdown();
+ }
+
+ @Test
+ @DisplayName("should not call shutdown if replaced provider is bound as default provider")
+ void shouldNotCallShutdownIfReplacedProviderIsBoundAsDefaultProvider() {
+ FeatureProvider oldProvider = createMockedProvider();
+ FeatureProvider newProvider = createMockedProvider();
+ setFeatureProvider(oldProvider);
+ setFeatureProvider(CLIENT_NAME, oldProvider);
+
+ setFeatureProvider(CLIENT_NAME, newProvider);
+
+ verify(oldProvider, never()).shutdown();
+ }
+
+ @Test
+ @DisplayName("should not throw exception if provider throws one on shutdown")
+ void shouldNotThrowExceptionIfProviderThrowsOneOnShutdown() {
+ FeatureProvider provider = createMockedProvider();
+ doThrow(TestException.class).when(provider).shutdown();
+ setFeatureProvider(provider);
+
+ assertThatCode(() -> setFeatureProvider(new NoOpProvider())).doesNotThrowAnyException();
+
+ verify(provider, timeout(TIMEOUT)).shutdown();
+ }
+ }
+
+ @Nested
+ class LifecyleLambdas {
+ @Test
+ @DisplayName("should run afterSet, afterInit, afterShutdown on successful set/init")
+ @SuppressWarnings("unchecked")
+ void shouldRunLambdasOnSuccessful() {
+ Consumer afterSet = mock(Consumer.class);
+ Consumer afterInit = mock(Consumer.class);
+ Consumer afterShutdown = mock(Consumer.class);
+ BiConsumer afterError = mock(BiConsumer.class);
+
+ FeatureProvider oldProvider = providerRepository.getProvider();
+ FeatureProvider featureProvider1 = createMockedProvider();
+ FeatureProvider featureProvider2 = createMockedProvider();
+
+ setFeatureProvider(featureProvider1, afterSet, afterInit, afterShutdown, afterError);
+ setFeatureProvider(featureProvider2);
+ verify(afterSet, timeout(TIMEOUT)).accept(featureProvider1);
+ verify(afterInit, timeout(TIMEOUT)).accept(featureProvider1);
+ verify(afterShutdown, timeout(TIMEOUT)).accept(oldProvider);
+ verify(afterError, never()).accept(any(), any());
+ }
+
+ @Test
+ @DisplayName("should run afterSet, afterError on unsuccessful set/init")
+ @SuppressWarnings("unchecked")
+ void shouldRunLambdasOnError() throws Exception {
+ Consumer afterSet = mock(Consumer.class);
+ Consumer afterInit = mock(Consumer.class);
+ Consumer afterShutdown = mock(Consumer.class);
+ BiConsumer afterError = mock(BiConsumer.class);
+
+ FeatureProvider errorFeatureProvider = createMockedErrorProvider();
+
+ setFeatureProvider(errorFeatureProvider, afterSet, afterInit, afterShutdown, afterError);
+ verify(afterSet, timeout(TIMEOUT)).accept(errorFeatureProvider);
+ verify(afterInit, never()).accept(any());;
+ verify(afterError, timeout(TIMEOUT)).accept(eq(errorFeatureProvider), any());
+ }
+ }
+ }
+
+ @Test
+ @DisplayName("should shutdown all feature providers on shutdown")
+ void shouldShutdownAllFeatureProvidersOnShutdown() {
+ FeatureProvider featureProvider1 = createMockedProvider();
+ FeatureProvider featureProvider2 = createMockedProvider();
+
+ setFeatureProvider(featureProvider1);
+ setFeatureProvider(CLIENT_NAME, featureProvider1);
+ setFeatureProvider(ANOTHER_CLIENT_NAME, featureProvider2);
+
+ providerRepository.shutdown();
+
+ await()
+ .pollDelay(Duration.ofMillis(1))
+ .atMost(Duration.ofSeconds(TIMEOUT))
+ .untilAsserted(() -> {
+ assertThat(providerRepository.getProvider()).isInstanceOf(NoOpProvider.class);
+ assertThat(providerRepository.getProvider(CLIENT_NAME)).isInstanceOf(NoOpProvider.class);
+ assertThat(providerRepository.getProvider(ANOTHER_CLIENT_NAME)).isInstanceOf(NoOpProvider.class);
+ });
+ verify(featureProvider1, timeout(TIMEOUT)).shutdown();
+ verify(featureProvider2, timeout(TIMEOUT)).shutdown();
+ }
+
+ private void setFeatureProvider(FeatureProvider provider) {
+ providerRepository.setProvider(provider, mockAfterSet(), mockAfterInit(), mockAfterShutdown(),
+ mockAfterError());
+ waitForSettingProviderHasBeenCompleted(ProviderRepository::getProvider, provider);
+ }
+
+
+ private void setFeatureProvider(FeatureProvider provider, Consumer afterSet,
+ Consumer afterInit, Consumer afterShutdown,
+ BiConsumer afterError) {
+ providerRepository.setProvider(provider, afterSet, afterInit, afterShutdown,
+ afterError);
+ waitForSettingProviderHasBeenCompleted(ProviderRepository::getProvider, provider);
+ }
+
+ private void setFeatureProvider(String namedProvider, FeatureProvider provider) {
+ providerRepository.setProvider(namedProvider, provider, mockAfterSet(), mockAfterInit(), mockAfterShutdown(),
+ mockAfterError());
+ waitForSettingProviderHasBeenCompleted(repository -> repository.getProvider(namedProvider), provider);
+ }
+
+ private void waitForSettingProviderHasBeenCompleted(
+ Function extractor,
+ FeatureProvider provider) {
+ await()
+ .pollDelay(Duration.ofMillis(1))
+ .atMost(Duration.ofSeconds(5))
+ .until(() -> {
+ return extractor.apply(providerRepository) == provider;
+ });
+ }
+
+ private Consumer mockAfterSet() {
+ return fp -> {
+ };
+ }
+
+ private Consumer mockAfterInit() {
+ return fp -> {
+ };
+ }
+
+ private Consumer mockAfterShutdown() {
+ return fp -> {
+ };
+ }
+
+ private BiConsumer mockAfterError() {
+ return (fp, message) -> {
+ };
+ }
+
+}
diff --git a/src/test/java/dev/openfeature/sdk/ProviderSpecTest.java b/src/test/java/dev/openfeature/sdk/ProviderSpecTest.java
index 31a6a5e8..f5e5e6a4 100644
--- a/src/test/java/dev/openfeature/sdk/ProviderSpecTest.java
+++ b/src/test/java/dev/openfeature/sdk/ProviderSpecTest.java
@@ -18,7 +18,7 @@ void name_accessor() {
@Specification(number = "2.2.2.1", text = "The feature provider interface MUST define methods for typed " +
"flag resolution, including boolean, numeric, string, and structure.")
@Specification(number = "2.2.3", text = "In cases of normal execution, the `provider` MUST populate the `resolution details` structure's `value` field with the resolved flag value.")
- @Specification(number = "2.2.1", text = "The `feature provider` interface MUST define methods to resolve flag values, with parameters `flag key` (string, required), `default value` (boolean | number | string | structure, required) + and `evaluation context` (optional), which returns a `resolution details` structure.")
+ @Specification(number = "2.2.1", text = "The `feature provider` interface MUST define methods to resolve flag values, with parameters `flag key` (string, required), `default value` (boolean | number | string | structure, required) and `evaluation context` (optional), which returns a `resolution details` structure.")
@Specification(number = "2.2.8.1", text = "The `resolution details` structure SHOULD accept a generic argument (or use an equivalent language feature) which indicates the type of the wrapped `value` field.")
@Test
void flag_value_set() {
diff --git a/src/test/java/dev/openfeature/sdk/ShutdownBehaviorSpecTest.java b/src/test/java/dev/openfeature/sdk/ShutdownBehaviorSpecTest.java
new file mode 100644
index 00000000..e470819f
--- /dev/null
+++ b/src/test/java/dev/openfeature/sdk/ShutdownBehaviorSpecTest.java
@@ -0,0 +1,117 @@
+package dev.openfeature.sdk;
+
+import dev.openfeature.sdk.fixtures.ProviderFixture;
+import dev.openfeature.sdk.testutils.exception.TestException;
+import org.awaitility.Awaitility;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import java.time.Duration;
+
+import static dev.openfeature.sdk.testutils.FeatureProviderTestUtils.setFeatureProvider;
+import static org.mockito.Mockito.*;
+
+class ShutdownBehaviorSpecTest {
+
+ @BeforeEach
+ void resetFeatureProvider() {
+ setFeatureProvider(new NoOpProvider());
+ }
+
+ @Nested
+ class DefaultProvider {
+
+ @Specification(number = "1.1.2.3", text = "The `provider mutator` function MUST invoke the `shutdown` function on the previously registered provider once it's no longer being used to resolve flag values.")
+ @Test
+ @DisplayName("must invoke shutdown method on previously registered provider once it should not be used for flag evaluation anymore")
+ void mustInvokeShutdownMethodOnPreviouslyRegisteredProviderOnceItShouldNotBeUsedForFlagEvaluationAnymore() {
+ FeatureProvider featureProvider = ProviderFixture.createMockedProvider();
+
+ setFeatureProvider(featureProvider);
+ setFeatureProvider(new NoOpProvider());
+
+ verify(featureProvider, timeout(1000)).shutdown();
+ }
+
+ @Specification(number = "1.4.9", text = "Methods, functions, or operations on the client MUST NOT throw "
+ + "exceptions, or otherwise abnormally terminate. Flag evaluation calls must always return the "
+ + "`default value` in the event of abnormal execution. Exceptions include functions or methods for "
+ + "the purposes for configuration or setup.")
+ @Test
+ @DisplayName("should catch exception thrown by the provider on shutdown")
+ void shouldCatchExceptionThrownByTheProviderOnShutdown() {
+ FeatureProvider featureProvider = ProviderFixture.createMockedProvider();
+ doThrow(TestException.class).when(featureProvider).shutdown();
+
+ setFeatureProvider(featureProvider);
+ setFeatureProvider(new NoOpProvider());
+
+ verify(featureProvider, timeout(1000)).shutdown();
+ }
+ }
+
+ @Nested
+ class NamedProvider {
+
+ @Specification(number = "1.1.2.3", text = "The `provider mutator` function MUST invoke the `shutdown` function on the previously registered provider once it's no longer being used to resolve flag values.")
+ @Test
+ @DisplayName("must invoke shutdown method on previously registered provider once it should not be used for flag evaluation anymore")
+ void mustInvokeShutdownMethodOnPreviouslyRegisteredProviderOnceItShouldNotBeUsedForFlagEvaluationAnymore() {
+ String clientName = "clientName";
+ FeatureProvider featureProvider = ProviderFixture.createMockedProvider();
+
+ setFeatureProvider(clientName, featureProvider);
+ setFeatureProvider(clientName, new NoOpProvider());
+
+ verify(featureProvider, timeout(1000)).shutdown();
+ }
+
+ @Specification(number = "1.4.9", text = "Methods, functions, or operations on the client MUST NOT throw "
+ + "exceptions, or otherwise abnormally terminate. Flag evaluation calls must always return the "
+ + "`default value` in the event of abnormal execution. Exceptions include functions or methods for "
+ + "the purposes for configuration or setup.")
+ @Test
+ @DisplayName("should catch exception thrown by the named client provider on shutdown")
+ void shouldCatchExceptionThrownByTheNamedClientProviderOnShutdown() {
+ String clientName = "clientName";
+ FeatureProvider featureProvider = ProviderFixture.createMockedProvider();
+ doThrow(TestException.class).when(featureProvider).shutdown();
+
+ setFeatureProvider(clientName, featureProvider);
+ setFeatureProvider(clientName, new NoOpProvider());
+
+ verify(featureProvider, timeout(1000)).shutdown();
+ }
+ }
+
+ @Nested
+ class General {
+
+ @Specification(number = "1.6.1", text = "The API MUST define a mechanism to propagate a shutdown request to active providers.")
+ @Test
+ @DisplayName("must shutdown all providers on shutting down api")
+ void mustShutdownAllProvidersOnShuttingDownApi() {
+ FeatureProvider defaultProvider = ProviderFixture.createMockedProvider();
+ FeatureProvider namedProvider = ProviderFixture.createMockedProvider();
+ setFeatureProvider(defaultProvider);
+ setFeatureProvider("clientName", namedProvider);
+ OpenFeatureAPI api = OpenFeatureAPI.getInstance();
+
+ synchronized (OpenFeatureAPI.class) {
+ api.shutdown();
+
+ Awaitility
+ .await()
+ .atMost(Duration.ofSeconds(1))
+ .untilAsserted(() -> {
+ verify(defaultProvider).shutdown();
+ verify(namedProvider).shutdown();
+ });
+
+ api.reset();
+ }
+ }
+ }
+}
diff --git a/src/test/java/dev/openfeature/sdk/integration/RunCucumberTest.java b/src/test/java/dev/openfeature/sdk/e2e/RunCucumberTest.java
similarity index 92%
rename from src/test/java/dev/openfeature/sdk/integration/RunCucumberTest.java
rename to src/test/java/dev/openfeature/sdk/e2e/RunCucumberTest.java
index 6a13ed29..2c652338 100644
--- a/src/test/java/dev/openfeature/sdk/integration/RunCucumberTest.java
+++ b/src/test/java/dev/openfeature/sdk/e2e/RunCucumberTest.java
@@ -1,4 +1,4 @@
-package dev.openfeature.sdk.integration;
+package dev.openfeature.sdk.e2e;
import org.junit.platform.suite.api.ConfigurationParameter;
import org.junit.platform.suite.api.IncludeEngines;
diff --git a/src/test/java/dev/openfeature/sdk/integration/StepDefinitions.java b/src/test/java/dev/openfeature/sdk/e2e/StepDefinitions.java
similarity index 99%
rename from src/test/java/dev/openfeature/sdk/integration/StepDefinitions.java
rename to src/test/java/dev/openfeature/sdk/e2e/StepDefinitions.java
index 41c4dafc..7048fc0b 100644
--- a/src/test/java/dev/openfeature/sdk/integration/StepDefinitions.java
+++ b/src/test/java/dev/openfeature/sdk/e2e/StepDefinitions.java
@@ -1,4 +1,4 @@
-package dev.openfeature.sdk.integration;
+package dev.openfeature.sdk.e2e;
import dev.openfeature.contrib.providers.flagd.FlagdProvider;
import dev.openfeature.sdk.Client;
diff --git a/src/test/java/dev/openfeature/sdk/fixtures/ProviderFixture.java b/src/test/java/dev/openfeature/sdk/fixtures/ProviderFixture.java
new file mode 100644
index 00000000..c00b8ff2
--- /dev/null
+++ b/src/test/java/dev/openfeature/sdk/fixtures/ProviderFixture.java
@@ -0,0 +1,66 @@
+package dev.openfeature.sdk.fixtures;
+
+import static dev.openfeature.sdk.testutils.stubbing.ConditionStubber.doBlock;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+
+import java.io.FileNotFoundException;
+import java.util.concurrent.CountDownLatch;
+
+import org.mockito.stubbing.Answer;
+
+import dev.openfeature.sdk.FeatureProvider;
+import dev.openfeature.sdk.ImmutableContext;
+import dev.openfeature.sdk.ProviderState;
+import lombok.experimental.UtilityClass;
+
+@UtilityClass
+public class ProviderFixture {
+
+ public static FeatureProvider createMockedProvider() {
+ FeatureProvider provider = mock(FeatureProvider.class);
+ doReturn(ProviderState.NOT_READY).when(provider).getState();
+ return provider;
+ }
+
+ public static FeatureProvider createMockedReadyProvider() {
+ FeatureProvider provider = mock(FeatureProvider.class);
+ doReturn(ProviderState.READY).when(provider).getState();
+ return provider;
+ }
+
+ public static FeatureProvider createMockedErrorProvider() throws Exception {
+ FeatureProvider provider = mock(FeatureProvider.class);
+ doReturn(ProviderState.NOT_READY).when(provider).getState();
+ doThrow(FileNotFoundException.class).when(provider).initialize(any());
+ return provider;
+ }
+
+ public static FeatureProvider createBlockedProvider(CountDownLatch latch, Runnable onAnswer) throws Exception {
+ FeatureProvider provider = createMockedProvider();
+ doBlock(latch, createAnswerExecutingCode(onAnswer)).when(provider).initialize(new ImmutableContext());
+ doReturn("blockedProvider").when(provider).toString();
+ return provider;
+ }
+
+ private static Answer createAnswerExecutingCode(Runnable onAnswer) {
+ return invocation -> {
+ onAnswer.run();
+ return null;
+ };
+ }
+
+ public static FeatureProvider createUnblockingProvider(CountDownLatch latch) throws Exception {
+ FeatureProvider provider = createMockedProvider();
+ doAnswer(invocation -> {
+ latch.countDown();
+ return null;
+ }).when(provider).initialize(new ImmutableContext());
+ doReturn("unblockingProvider").when(provider).toString();
+ return provider;
+ }
+
+}
diff --git a/src/test/java/dev/openfeature/sdk/internal/TriConsumerTest.java b/src/test/java/dev/openfeature/sdk/internal/TriConsumerTest.java
new file mode 100644
index 00000000..0c85a7cc
--- /dev/null
+++ b/src/test/java/dev/openfeature/sdk/internal/TriConsumerTest.java
@@ -0,0 +1,34 @@
+package dev.openfeature.sdk.internal;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class TriConsumerTest {
+
+ @Test
+ @DisplayName("should run accept")
+ void shouldRunAccept() {
+ AtomicInteger result = new AtomicInteger(0);
+ TriConsumer triConsumer = (num1, num2, num3) -> {
+ result.set(result.get() + num1 + num2 + num3);
+ };
+ triConsumer.accept(1, 2, 3);
+ assertEquals(6, result.get());
+ }
+
+ @Test
+ @DisplayName("should run after accept")
+ void shouldRunAfterAccept() {
+ AtomicInteger result = new AtomicInteger(0);
+ TriConsumer triConsumer = (num1, num2, num3) -> {
+ result.set(result.get() + num1 + num2 + num3);
+ };
+ TriConsumer composed = triConsumer.andThen(triConsumer);
+ composed.accept(1, 2, 3);
+ assertEquals(12, result.get());
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/dev/openfeature/sdk/testutils/FeatureProviderTestUtils.java b/src/test/java/dev/openfeature/sdk/testutils/FeatureProviderTestUtils.java
new file mode 100644
index 00000000..5f8c13db
--- /dev/null
+++ b/src/test/java/dev/openfeature/sdk/testutils/FeatureProviderTestUtils.java
@@ -0,0 +1,30 @@
+package dev.openfeature.sdk.testutils;
+
+import java.time.Duration;
+import java.util.function.Function;
+
+import dev.openfeature.sdk.*;
+import lombok.experimental.UtilityClass;
+
+import static org.awaitility.Awaitility.await;
+
+@UtilityClass
+public class FeatureProviderTestUtils {
+
+ public static void setFeatureProvider(FeatureProvider provider) {
+ OpenFeatureAPI.getInstance().setProvider(provider);
+ waitForProviderInitializationComplete(OpenFeatureAPI::getProvider, provider);
+ }
+
+ private static void waitForProviderInitializationComplete(Function extractor, FeatureProvider provider) {
+ await()
+ .pollDelay(Duration.ofMillis(1))
+ .atMost(Duration.ofSeconds(1))
+ .until(() -> extractor.apply(OpenFeatureAPI.getInstance()) == provider);
+ }
+
+ public static void setFeatureProvider(String namedProvider, FeatureProvider provider) {
+ OpenFeatureAPI.getInstance().setProvider(namedProvider, provider);
+ waitForProviderInitializationComplete(api -> api.getProvider(namedProvider), provider);
+ }
+}
diff --git a/src/test/java/dev/openfeature/sdk/testutils/TestEventsProvider.java b/src/test/java/dev/openfeature/sdk/testutils/TestEventsProvider.java
new file mode 100644
index 00000000..3fcb5888
--- /dev/null
+++ b/src/test/java/dev/openfeature/sdk/testutils/TestEventsProvider.java
@@ -0,0 +1,99 @@
+package dev.openfeature.sdk.testutils;
+
+import dev.openfeature.sdk.EvaluationContext;
+import dev.openfeature.sdk.EventProvider;
+import dev.openfeature.sdk.Metadata;
+import dev.openfeature.sdk.ProviderEvaluation;
+import dev.openfeature.sdk.ProviderEvent;
+import dev.openfeature.sdk.ProviderEventDetails;
+import dev.openfeature.sdk.ProviderState;
+import dev.openfeature.sdk.Value;
+
+public class TestEventsProvider extends EventProvider {
+
+ private boolean initError = false;
+ private String initErrorMessage;
+ private ProviderState state = ProviderState.NOT_READY;
+ private boolean shutDown = false;
+ private int initTimeout = 0;
+
+ @Override
+ public ProviderState getState() {
+ return this.state;
+ }
+
+ public TestEventsProvider(int initTimeout) {
+ this.initTimeout = initTimeout;
+ }
+
+ public TestEventsProvider(int initTimeout, boolean initError, String initErrorMessage) {
+ this.initTimeout = initTimeout;
+ this.initError = initError;
+ this.initErrorMessage = initErrorMessage;
+ }
+
+ public TestEventsProvider(ProviderState initialState) {
+ this.state = initialState;
+ }
+
+ public void mockEvent(ProviderEvent event, ProviderEventDetails details) {
+ emit(event, details);
+ }
+
+ public boolean isShutDown() {
+ return this.shutDown;
+ }
+
+ @Override
+ public void shutdown() {
+ this.shutDown = true;
+ }
+
+ @Override
+ public void initialize(EvaluationContext evaluationContext) throws Exception {
+ if (ProviderState.NOT_READY.equals(state)) {
+ // wait half the TIMEOUT, otherwise some init/errors can be fired before we add handlers
+ Thread.sleep(initTimeout);
+ if (this.initError) {
+ this.state = ProviderState.ERROR;
+ throw new Exception(initErrorMessage);
+ }
+ this.state = ProviderState.READY;
+ }
+ }
+
+ @Override
+ public Metadata getMetadata() {
+ throw new UnsupportedOperationException("Unimplemented method 'getMetadata'");
+ }
+
+ @Override
+ public ProviderEvaluation getBooleanEvaluation(String key, Boolean defaultValue,
+ EvaluationContext ctx) {
+ throw new UnsupportedOperationException("Unimplemented method 'getBooleanEvaluation'");
+ }
+
+ @Override
+ public ProviderEvaluation getStringEvaluation(String key, String defaultValue,
+ EvaluationContext ctx) {
+ throw new UnsupportedOperationException("Unimplemented method 'getStringEvaluation'");
+ }
+
+ @Override
+ public ProviderEvaluation getIntegerEvaluation(String key, Integer defaultValue,
+ EvaluationContext ctx) {
+ throw new UnsupportedOperationException("Unimplemented method 'getIntegerEvaluation'");
+ }
+
+ @Override
+ public ProviderEvaluation getDoubleEvaluation(String key, Double defaultValue,
+ EvaluationContext ctx) {
+ throw new UnsupportedOperationException("Unimplemented method 'getDoubleEvaluation'");
+ }
+
+ @Override
+ public ProviderEvaluation getObjectEvaluation(String key, Value defaultValue,
+ EvaluationContext ctx) {
+ throw new UnsupportedOperationException("Unimplemented method 'getObjectEvaluation'");
+ }
+};
\ No newline at end of file
diff --git a/src/test/java/dev/openfeature/sdk/testutils/exception/TestException.java b/src/test/java/dev/openfeature/sdk/testutils/exception/TestException.java
new file mode 100644
index 00000000..c6918b02
--- /dev/null
+++ b/src/test/java/dev/openfeature/sdk/testutils/exception/TestException.java
@@ -0,0 +1,9 @@
+package dev.openfeature.sdk.testutils.exception;
+
+public class TestException extends RuntimeException {
+
+ @Override
+ public String getMessage() {
+ return "don't panic, it's just a test";
+ }
+}
diff --git a/src/test/java/dev/openfeature/sdk/testutils/stubbing/ConditionStubber.java b/src/test/java/dev/openfeature/sdk/testutils/stubbing/ConditionStubber.java
new file mode 100644
index 00000000..11cf2649
--- /dev/null
+++ b/src/test/java/dev/openfeature/sdk/testutils/stubbing/ConditionStubber.java
@@ -0,0 +1,37 @@
+package dev.openfeature.sdk.testutils.stubbing;
+
+import java.time.Duration;
+import java.util.concurrent.CountDownLatch;
+
+import lombok.experimental.UtilityClass;
+import org.mockito.stubbing.*;
+
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static org.mockito.Mockito.doAnswer;
+
+@UtilityClass
+public class ConditionStubber {
+
+ @SuppressWarnings("java:S2925")
+ public static Stubber doDelayResponse(Duration duration) {
+ return doAnswer(invocation -> {
+ MILLISECONDS.sleep(duration.toMillis());
+ return null;
+ });
+ }
+
+ public static Stubber doBlock(CountDownLatch latch) {
+ return doAnswer(invocation -> {
+ latch.await();
+ return null;
+ });
+ }
+
+ public static Stubber doBlock(CountDownLatch latch, Answer answer) {
+ return doAnswer(invocation -> {
+ latch.await();
+ return answer.answer(invocation);
+ });
+ }
+
+}
diff --git a/version.txt b/version.txt
index 3a3cd8cc..88c5fb89 100644
--- a/version.txt
+++ b/version.txt
@@ -1 +1 @@
-1.3.1
+1.4.0