feat: Add support for fallback-action

src/main/java/no/finn/unleash/DefaultUnleash.java

@@ -5,6 +5,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
+import java.util.function.BiFunction;
 
 import no.finn.unleash.event.EventDispatcher;
 import no.finn.unleash.event.ToggleEvaluated;
@@ -14,7 +15,16 @@
 import no.finn.unleash.repository.HttpToggleFetcher;
 import no.finn.unleash.repository.ToggleBackupHandlerFile;
 import no.finn.unleash.repository.ToggleRepository;
-import no.finn.unleash.strategy.*;
+import no.finn.unleash.strategy.ApplicationHostnameStrategy;
+import no.finn.unleash.strategy.DefaultStrategy;
+import no.finn.unleash.strategy.FlexibleRolloutStrategy;
+import no.finn.unleash.strategy.GradualRolloutRandomStrategy;
+import no.finn.unleash.strategy.GradualRolloutSessionIdStrategy;
+import no.finn.unleash.strategy.GradualRolloutUserIdStrategy;
+import no.finn.unleash.strategy.RemoteAddressStrategy;
+import no.finn.unleash.strategy.Strategy;
+import no.finn.unleash.strategy.UnknownStrategy;
+import no.finn.unleash.strategy.UserWithIdStrategy;
 import no.finn.unleash.util.UnleashConfig;
 
 import static java.util.Optional.ofNullable;
@@ -41,14 +51,6 @@ public final class DefaultUnleash implements Unleash {
     private final UnleashConfig config;
 
 
-    private static FeatureToggleRepository defaultToggleRepository(UnleashConfig unleashConfig) {
-        return new FeatureToggleRepository(
-                unleashConfig,
-                new HttpToggleFetcher(unleashConfig),
-                new ToggleBackupHandlerFile(unleashConfig)
-        );
-    }
-
     public DefaultUnleash(UnleashConfig unleashConfig, Strategy... strategies) {
         this(unleashConfig, defaultToggleRepository(unleashConfig), strategies);
     }
@@ -63,6 +65,14 @@ public DefaultUnleash(UnleashConfig unleashConfig, ToggleRepository toggleReposi
         metricService.register(strategyMap.keySet());
     }
 
+    private static FeatureToggleRepository defaultToggleRepository(UnleashConfig unleashConfig) {
+        return new FeatureToggleRepository(
+                unleashConfig,
+                new HttpToggleFetcher(unleashConfig),
+                new ToggleBackupHandlerFile(unleashConfig)
+        );
+    }
+
     @Override
     public boolean isEnabled(final String toggleName) {
         return isEnabled(toggleName, false);
@@ -74,27 +84,32 @@ public boolean isEnabled(final String toggleName, final boolean defaultSetting)
     }
 
     @Override
-    public boolean isEnabled(final String toggleName, final UnleashContext context ,final boolean defaultSetting) {
-        FeatureToggle featureToggle = toggleRepository.getToggle(toggleName);
-        boolean enabled = isEnabled(featureToggle, context, defaultSetting);
-        count(toggleName, enabled);
-        eventDispatcher.dispatch(new ToggleEvaluated(toggleName,enabled));
-        return enabled;
+    public boolean isEnabled(final String toggleName, final UnleashContext context, final boolean defaultSetting) {
+        return isEnabled(toggleName, context, (n, c) -> defaultSetting);
     }
 
-    private boolean isEnabled(FeatureToggle featureToggle, UnleashContext context, boolean defaultSetting) {
+    @Override
+    public boolean isEnabled(final String toggleName, final BiFunction<String, UnleashContext, Boolean> fallbackAction) {
+        return isEnabled(toggleName, contextProvider.getContext(), fallbackAction);
+    }
+
+    public boolean isEnabled(String toggleName, UnleashContext context, BiFunction<String, UnleashContext, Boolean> fallbackAction) {
+        FeatureToggle featureToggle = toggleRepository.getToggle(toggleName);
         boolean enabled;
+        UnleashContext enhancedContext = context.applyStaticFields(config);
+
         if (featureToggle == null) {
-            enabled = defaultSetting;
+            enabled = fallbackAction.apply(toggleName, enhancedContext);
         } else if(!featureToggle.isEnabled()) {
             enabled = false;
         } else if(featureToggle.getStrategies().size() == 0) {
             return true;
         } else {
-            UnleashContext enhancedContext = context.applyStaticFields(config);
             enabled = featureToggle.getStrategies().stream()
                     .anyMatch(as -> getStrategy(as.getName()).isEnabled(as.getParameters(), enhancedContext, as.getConstraints()));
         }
+        count(toggleName, enabled);
+        eventDispatcher.dispatch(new ToggleEvaluated(toggleName, enabled));
         return enabled;
     }
 
@@ -106,7 +121,7 @@ public Variant getVariant(String toggleName, UnleashContext context) {
     @Override
     public Variant getVariant(String toggleName, UnleashContext context, Variant defaultValue) {
         FeatureToggle featureToggle = toggleRepository.getToggle(toggleName);
-        boolean enabled = isEnabled(featureToggle, context, false);
+        boolean enabled = isEnabled(toggleName, context, (n, c) -> false);
         Variant variant = enabled ? selectVariant(featureToggle, context, defaultValue) : defaultValue;
         metricService.countVariant(toggleName, variant.getName());
         return variant;

src/main/java/no/finn/unleash/FakeUnleash.java

@@ -4,6 +4,7 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.function.BiFunction;
 
 public final class FakeUnleash implements Unleash {
     private boolean enableAll = false;
@@ -27,6 +28,19 @@ public boolean isEnabled(String toggleName, boolean defaultSetting) {
         }
     }
 
+    @Override
+    public boolean isEnabled(String toggleName, UnleashContext context, BiFunction<String, UnleashContext, Boolean> fallbackAction) {
+        return isEnabled(toggleName, fallbackAction);
+    }
+
+    @Override
+    public boolean isEnabled(String toggleName, BiFunction<String, UnleashContext, Boolean> fallbackAction) {
+        if(!features.containsKey(toggleName)) {
+            return fallbackAction.apply(toggleName, UnleashContext.builder().build());
+        }
+        return isEnabled(toggleName);
+    }
+
     @Override
     public Variant getVariant(String toggleName, UnleashContext context) {
         return getVariant(toggleName, Variant.DISABLED_VARIANT);

src/main/java/no/finn/unleash/Unleash.java

@@ -1,6 +1,7 @@
 package no.finn.unleash;
 
 import java.util.List;
+import java.util.function.BiFunction;
 
 public interface Unleash {
     boolean isEnabled(String toggleName);
@@ -15,6 +16,14 @@ default boolean isEnabled(String toggleName, UnleashContext context, boolean def
         return isEnabled(toggleName, defaultSetting);
     }
 
+    default boolean isEnabled(String toggleName, BiFunction<String, UnleashContext, Boolean> fallbackAction) {
+        return isEnabled(toggleName, false);
+    }
+
+    default boolean isEnabled(String toggleName, UnleashContext context, BiFunction<String, UnleashContext, Boolean> fallbackAction) {
+        return isEnabled(toggleName, context, false);
+    }
+
     Variant getVariant(final String toggleName, final UnleashContext context);
 
     Variant getVariant(final String toggleName, final UnleashContext context, final Variant defaultValue);

src/test/java/no/finn/unleash/UnleashTest.java

@@ -7,6 +7,8 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
 
 import no.finn.unleash.repository.ToggleRepository;
 import no.finn.unleash.strategy.Strategy;
@@ -15,21 +17,18 @@
 
 import no.finn.unleash.variant.Payload;
 import no.finn.unleash.variant.VariantDefinition;
+import org.hamcrest.CoreMatchers;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
 
 import static java.util.Arrays.asList;
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.CoreMatchers.notNullValue;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.mockito.ArgumentMatchers.isNull;
-import static org.mockito.Mockito.any;
-import static org.mockito.Mockito.anyMap;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
 
 public class UnleashTest {
 
@@ -81,6 +80,49 @@ public void unknown_feature_should_use_default_setting() {
         assertThat(unleash.isEnabled("test", true), is(true));
     }
 
+    @Test
+    public void fallback_function_should_be_invoked_and_return_true() {
+        when(toggleRepository.getToggle("test")).thenReturn(null);
+        BiFunction<String, UnleashContext, Boolean>  fallbackAction = mock(BiFunction.class);
+        when(fallbackAction.apply(eq("test"), any(UnleashContext.class))).thenReturn(true);
+
+        assertThat(unleash.isEnabled("test", fallbackAction), is(true));
+        verify(fallbackAction, times(1)).apply(anyString(), any(UnleashContext.class));
+    }
+
+    @Test
+    public void fallback_function_should_be_invoked_also_with_context() {
+        when(toggleRepository.getToggle("test")).thenReturn(null);
+        BiFunction<String, UnleashContext, Boolean>  fallbackAction = mock(BiFunction.class);
+        when(fallbackAction.apply(eq("test"), any(UnleashContext.class))).thenReturn(true);
+
+        UnleashContext context = UnleashContext.builder().userId("123").build();
+
+        assertThat(unleash.isEnabled("test", context, fallbackAction), is(true));
+        verify(fallbackAction, times(1)).apply(anyString(), any(UnleashContext.class));
+    }
+
+    @Test
+    void fallback_function_should_be_invoked_and_return_false() {
+        when(toggleRepository.getToggle("test")).thenReturn(null);
+        BiFunction<String, UnleashContext, Boolean>  fallbackAction = mock(BiFunction.class);
+        when(fallbackAction.apply(eq("test"), any(UnleashContext.class))).thenReturn(false);
+
+        assertThat(unleash.isEnabled("test", fallbackAction), is(false));
+        verify(fallbackAction, times(1)).apply(anyString(), any(UnleashContext.class));
+    }
+
+	@Test
+	void fallback_function_should_not_be_called_when_toggle_is_defined() {
+		when(toggleRepository.getToggle("test")).thenReturn(new FeatureToggle("test", true, asList(new ActivationStrategy("default", null))));
+
+        BiFunction<String, UnleashContext, Boolean>  fallbackAction = mock(BiFunction.class);
+        when(fallbackAction.apply(eq("test"), any(UnleashContext.class))).thenReturn(false);
+
+		assertThat(unleash.isEnabled("test", fallbackAction), is(true));
+        verify(fallbackAction, never()).apply(anyString(), any(UnleashContext.class));
+	}
+
     @Test
     public void should_register_custom_strategies() {
         //custom strategy