FeatureFlagTests.java

/*
 * SPDX-License-Identifier: Apache-2.0
 *
 * The OpenSearch Contributors require contributions made to
 * this file be licensed under the Apache-2.0 license or a
 * compatible open source license.
 */

package org.opensearch.common.util;

import org.opensearch.common.SuppressForbidden;
import org.opensearch.common.settings.Setting;
import org.opensearch.common.settings.Settings;
import org.opensearch.test.OpenSearchTestCase;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.rules.TestRule;
import org.junit.runners.model.Statement;

import java.io.IOException;

import static org.opensearch.common.util.FeatureFlags.FEATURE_FLAG_PREFIX;

/**
 * It is easy for the state of feature flags to persist across tests running on multiple threads as:
 * - Feature flags are globally available
 * - Feature flags may be loaded from JVM system properties
 * Here we test underlying implementation (FeatureFlags.FeatureFlagsImpl) to avoid polluting global scope.
 * Other tests should use the set()/reset() helpers provided in FeatureFlags.TestUtils.
 */
public class FeatureFlagTests extends OpenSearchTestCase {
    private static final String TEST_FEATURE = FEATURE_FLAG_PREFIX + "testfeat.enabled";
    private static final Setting<Boolean> TEST_FEATURE_FLAG = Setting.boolSetting(TEST_FEATURE, false, Setting.Property.NodeScope);
    private static final FeatureFlags.FeatureFlagsImpl featureFlagsImpl = new FeatureFlags.FeatureFlagsImpl();

    // Make featureFlagsImpl static to mock global feature flags as used by other test cases.
    // Synchronize on featureFlagsImpl to avoid race conditions when tests run in parallel.
    @Rule
    public TestRule synchronizationRule = (base, description) -> new Statement() {
        @Override
        public void evaluate() throws Throwable {
            synchronized (featureFlagsImpl) {
                base.evaluate();
            }
        }
    };

    @BeforeClass
    public static void setupClass() {
        FeatureFlags.TestUtils.addFlag(TEST_FEATURE_FLAG);
    }

    @AfterClass
    public static void teardownClass() {
        FeatureFlags.TestUtils.removeFlag(TEST_FEATURE_FLAG);
    }

    @SuppressForbidden(reason = "Unit test on isolated feature flag")
    @After
    public void teardown() throws IOException {
        synchronized (TEST_FEATURE) {
            System.clearProperty(TEST_FEATURE);
            featureFlagsImpl.reset();
        }
    }

    public void testFeatureFlagsNotInitialized() {
        assertFalse(featureFlagsImpl.isEnabled(TEST_FEATURE));
    }

    public void testFeatureFlagsFromDefault() {
        featureFlagsImpl.initializeFeatureFlags();
        assertFalse(featureFlagsImpl.isEnabled(TEST_FEATURE));
    }

    public void testFeatureFlagFromEmpty() {
        featureFlagsImpl.initializeFeatureFlags(Settings.EMPTY);
        assertFalse(featureFlagsImpl.isEnabled(TEST_FEATURE));
    }

    public void testFeatureFlagFromSettings() {
        // init from settings
        featureFlagsImpl.initializeFeatureFlags(Settings.builder().put(TEST_FEATURE, true).build());
        assertTrue(featureFlagsImpl.isEnabled(TEST_FEATURE));
        // overwrite with new settings
        featureFlagsImpl.initializeFeatureFlags(Settings.builder().put(TEST_FEATURE, false).build());
        assertFalse(featureFlagsImpl.isEnabled(TEST_FEATURE));
    }

    public void testNonBooleanFeatureFlag() {
        String javaVersionProperty = "java.version";
        assertNotNull(System.getProperty(javaVersionProperty));
        assertFalse(featureFlagsImpl.isEnabled(javaVersionProperty));
    }

    public void testFeatureFlagsEmptySettings() {
        featureFlagsImpl.initializeFeatureFlags(Settings.EMPTY);
        assertFalse(featureFlagsImpl.isEnabled(TEST_FEATURE));
    }

    public void testFeatureFlagsTestUtilsSetSingleFlag() {
        featureFlagsImpl.set(TEST_FEATURE, false);
        assertFalse(featureFlagsImpl.isEnabled(TEST_FEATURE));
    }

    @SuppressForbidden(reason = "Unit test on isolated feature flag")
    public void testFeatureFlagFromSystemProperty() {
        System.setProperty(TEST_FEATURE, "true");
        featureFlagsImpl.initializeFeatureFlags();
        assertTrue(featureFlagsImpl.isEnabled(TEST_FEATURE));
    }

    @SuppressForbidden(reason = "Unit test on isolated feature flag")
    public void testFeatureFlagSettingOverwritesSystemProperties() {
        System.setProperty(TEST_FEATURE, "true");
        featureFlagsImpl.initializeFeatureFlags(Settings.builder().put(TEST_FEATURE, false).build());
        assertFalse(featureFlagsImpl.isEnabled(TEST_FEATURE));
        System.setProperty(TEST_FEATURE, "true");
        featureFlagsImpl.initializeFeatureFlags();
        assertTrue(featureFlagsImpl.isEnabled(TEST_FEATURE));
        featureFlagsImpl.initializeFeatureFlags(Settings.builder().put(TEST_FEATURE, false).build());
        assertFalse(featureFlagsImpl.isEnabled(TEST_FEATURE));
    }

    @SuppressForbidden(reason = "Unit test on isolated feature flag")
    public void testFeatureDoesNotExist() {
        final String DNE_FF = FEATURE_FLAG_PREFIX + "doesntexist";
        assertFalse(featureFlagsImpl.isEnabled(DNE_FF));
        System.setProperty(DNE_FF, "true");
        featureFlagsImpl.initializeFeatureFlags();
        assertFalse(featureFlagsImpl.isEnabled(DNE_FF));
        featureFlagsImpl.initializeFeatureFlags(Settings.builder().put(DNE_FF, true).build());
        assertFalse(featureFlagsImpl.isEnabled(DNE_FF));
    }

    @SuppressForbidden(reason = "Unit test on isolated feature flag")
    public void testFeatureFlagsSysPropTestUtilsReset() {
        assertFalse(featureFlagsImpl.isEnabled(TEST_FEATURE));
        System.setProperty(TEST_FEATURE, "true");
        featureFlagsImpl.initializeFeatureFlags();
        assertTrue(featureFlagsImpl.isEnabled(TEST_FEATURE));
        featureFlagsImpl.reset();
        assertFalse(featureFlagsImpl.isEnabled(TEST_FEATURE));
    }
}