MultiProviderTest.java

package dev.openfeature.sdk.multiprovider;

import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

import dev.openfeature.sdk.ErrorCode;
import dev.openfeature.sdk.EvaluationContext;
import dev.openfeature.sdk.FeatureProvider;
import dev.openfeature.sdk.Metadata;
import dev.openfeature.sdk.MutableContext;
import dev.openfeature.sdk.ProviderEvaluation;
import dev.openfeature.sdk.Value;
import dev.openfeature.sdk.exceptions.GeneralError;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.function.Function;
import lombok.SneakyThrows;
import org.junit.jupiter.api.Test;

class MultiProviderTest extends BaseStrategyTest {

    @Test
    void shouldInitializeWithEmptyProvidersList() {
        MultiProvider multiProvider = new MultiProvider(new ArrayList<>());
        assertDoesNotThrow(() -> multiProvider.initialize(null));
        assertNotNull(multiProvider.getMetadata());
        assertEquals(MultiProvider.getNAME(), multiProvider.getMetadata().getName());
    }

    @SneakyThrows
    @Test
    void shouldInitializeSuccessfully() {
        List<FeatureProvider> providers = new ArrayList<>(2);
        providers.add(mockProvider1);
        providers.add(mockProvider2);
        Strategy strategy = mock(Strategy.class);
        MultiProvider multiProvider = new MultiProvider(providers, strategy);
        multiProvider.initialize(null);

        MultiProviderMetadata metadata = (MultiProviderMetadata) multiProvider.getMetadata();
        List<Metadata> list = metadata.getOriginalMetadata();
        assertTrue(list.contains(mockMetaData1));
        assertTrue(list.contains(mockMetaData2));
        assertEquals("multiprovider", multiProvider.getMetadata().getName());
    }

    @SneakyThrows
    @Test
    void shouldHandleInitializationFailure() {
        doThrow(new GeneralError()).when(mockProvider1).initialize(any());
        doThrow(new GeneralError()).when(mockProvider1).shutdown();
        List<FeatureProvider> providers = new ArrayList<>(2);
        providers.add(mockProvider1);
        providers.add(mockProvider2);
        Strategy strategy = mock(Strategy.class);
        MultiProvider multiProvider = new MultiProvider(providers, strategy);
        assertThrows(ExecutionException.class, () -> multiProvider.initialize(null));
        assertDoesNotThrow(multiProvider::shutdown);
    }

    @Test
    void shouldHandleDuplicateProviderNames() {
        when(mockProvider1.getMetadata()).thenReturn(() -> "provider");
        when(mockProvider2.getMetadata()).thenReturn(() -> "provider");
        List<FeatureProvider> providers = new ArrayList<>(2);
        providers.add(mockProvider1);
        providers.add(mockProvider2);
        assertDoesNotThrow(() -> new MultiProvider(providers).initialize(null));
    }

    @Test
    void shouldRejectNullStrategyInTwoArgConstructor() {
        List<FeatureProvider> providers = new ArrayList<>();
        providers.add(mockProvider1);

        assertThrows(NullPointerException.class, () -> new MultiProvider(providers, null));
    }

    @SneakyThrows
    @Test
    void shouldRetrieveCorrectMetadataName() {
        List<FeatureProvider> providers = new ArrayList<>();
        providers.add(mockProvider1);
        Strategy mockStrategy = mock(Strategy.class);
        MultiProvider multiProvider = new MultiProvider(providers, mockStrategy);
        multiProvider.initialize(null);
        MultiProviderMetadata metadata = (MultiProviderMetadata) multiProvider.getMetadata();
        List<Metadata> list = metadata.getOriginalMetadata();
        assertTrue(list.contains(mockMetaData1));
    }

    @SneakyThrows
    @Test
    void shouldUseDefaultFirstMatchStrategy() {
        List<FeatureProvider> providers = new ArrayList<>(2);
        providers.add(inMemoryProvider1);
        providers.add(inMemoryProvider2);
        MultiProvider multiProvider = new MultiProvider(providers);
        multiProvider.initialize(null);
        assertEquals(true, multiProvider.getBooleanEvaluation("b1", false, null).getValue());
        assertEquals(1, multiProvider.getIntegerEvaluation("i1", 0, null).getValue());
        assertEquals(1.0, multiProvider.getDoubleEvaluation("d1", 0.0, null).getValue());
        assertEquals("str1", multiProvider.getStringEvaluation("s1", "", null).getValue());
        assertEquals(
                "v1",
                multiProvider.getObjectEvaluation("o1", null, null).getValue().asString());

        ProviderEvaluation<String> providerEvaluation = multiProvider.getStringEvaluation("non-existing", "", null);
        assertEquals(ErrorCode.FLAG_NOT_FOUND, providerEvaluation.getErrorCode());
        assertEquals("Flag not found in any provider", providerEvaluation.getErrorMessage());
    }

    @SneakyThrows
    @Test
    void shouldWorkWithCustomStrategy() {
        Strategy customStrategy = new Strategy() {
            final FirstMatchStrategy fallbackStrategy = new FirstMatchStrategy();

            @Override
            public <T> ProviderEvaluation<T> evaluate(
                    List<FeatureProvider> providers,
                    String key,
                    T defaultValue,
                    EvaluationContext ctx,
                    Function<FeatureProvider, ProviderEvaluation<T>> providerFunction) {

                Value contextProvider = null;
                if (ctx != null) {
                    contextProvider = ctx.getValue("provider");
                }

                if (contextProvider != null && "new-provider".equals(contextProvider.asString())) {
                    return providerFunction.apply(providers.stream()
                            .filter(p -> "new-provider".equals(p.getMetadata().getName()))
                            .findFirst()
                            .orElseThrow());
                }
                return fallbackStrategy.evaluate(providers, key, defaultValue, ctx, providerFunction);
            }
        };

        List<FeatureProvider> providers = new ArrayList<>(2);
        providers.add(inMemoryProvider1);
        providers.add(inMemoryProvider2);
        MultiProvider multiProvider = new MultiProvider(providers, customStrategy);
        multiProvider.initialize(null);
        EvaluationContext context = new MutableContext().add("provider", "new-provider");
        assertEquals(
                false, multiProvider.getBooleanEvaluation("b1", true, context).getValue());
        assertEquals(true, multiProvider.getBooleanEvaluation("b1", true, null).getValue());
    }

    @SneakyThrows
    @Test
    void shouldSupportAllEvaluationTypes() {
        List<FeatureProvider> providers = new ArrayList<>(1);
        providers.add(inMemoryProvider1);
        MultiProvider multiProvider = new MultiProvider(providers);
        multiProvider.initialize(null);
        assertNotNull(multiProvider.getBooleanEvaluation("b1", false, null));
        assertNotNull(multiProvider.getIntegerEvaluation("i1", 0, null));
        assertNotNull(multiProvider.getDoubleEvaluation("d1", 0.0, null));
        assertNotNull(multiProvider.getStringEvaluation("s1", "", null));
        assertNotNull(multiProvider.getObjectEvaluation("o1", null, null));
    }
}