test_feature_manager.py

# -------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for
# license information.
# --------------------------------------------------------------------------
import unittest
import pytest
from featuremanagement import FeatureManager, FeatureFilter


class TestFeatureManager(unittest.TestCase):

    def __init__(self, methodName="runTest"):
        super().__init__(methodName=methodName)
        self.called_telemetry = False

    # method: feature_manager_creation
    def test_empty_feature_manager_creation(self):
        feature_manager = FeatureManager({})
        assert feature_manager is not None
        assert not feature_manager.is_enabled("Alpha")

    # method: feature_manager_creation
    def test_basic_feature_manager_creation(self):
        feature_flags = {
            "feature_management": {
                "feature_flags": [
                    {"id": "Alpha", "description": "", "enabled": "true", "conditions": {"client_filters": []}},
                    {"id": "Beta", "description": "", "enabled": "false", "conditions": {"client_filters": []}},
                ]
            }
        }
        feature_manager = FeatureManager(feature_flags)
        assert feature_manager is not None
        assert feature_manager.is_enabled("Alpha")
        assert not feature_manager.is_enabled("Beta")

    # method: feature_manager_creation
    def test_feature_manager_creation_invalid_feature_filter(self):
        feature_flags = {"feature_management": {"feature_flags": []}}
        with self.assertRaises(ValueError):
            FeatureManager(feature_flags, feature_filters=["invalid_filter"])

    # method: feature_manager_creation
    def test_feature_manager_creation_with_filters(self):
        feature_flags = {
            "feature_management": {
                "feature_flags": [
                    {
                        "id": "Alpha",
                        "description": "",
                        "enabled": "true",
                        "conditions": {"client_filters": [{"name": "AlwaysOn", "parameters": {}}]},
                    },
                    {
                        "id": "Beta",
                        "description": "",
                        "enabled": "false",
                        "conditions": {"client_filters": [{"name": "AlwaysOn", "parameters": {}}]},
                    },
                    {
                        "id": "Gamma",
                        "description": "",
                        "enabled": "True",
                        "conditions": {"client_filters": [{"name": "AlwaysOff", "parameters": {}}]},
                    },
                    {
                        "id": "Delta",
                        "description": "",
                        "enabled": "False",
                        "conditions": {"client_filters": [{"name": "AlwaysOff", "parameters": {}}]},
                    },
                ]
            }
        }
        feature_manager = FeatureManager(feature_flags, feature_filters=[AlwaysOn(), AlwaysOff()])
        assert feature_manager is not None
        assert len(feature_manager._filters) == 4  # pylint: disable=protected-access
        assert feature_manager.is_enabled("Alpha")
        assert not feature_manager.is_enabled("Beta")
        assert not feature_manager.is_enabled("Gamma")
        assert not feature_manager.is_enabled("Delta")
        assert not feature_manager.is_enabled("Epsilon")

    # method: feature_manager_creation
    def test_feature_manager_creation_with_override_default(self):
        feature_manager = FeatureManager({}, feature_filters=[AlwaysOn(), AlwaysOff(), FakeTimeWindowFilter()])
        assert feature_manager is not None

        # The fake time window should override the default one
        assert len(feature_manager._filters) == 4  # pylint: disable=protected-access

    # method: list_feature_flags
    def test_list_feature_flags(self):
        feature_manager = FeatureManager({})
        assert feature_manager is not None
        assert len(feature_manager.list_feature_flag_names()) == 0

        feature_flags = {
            "feature_management": {
                "feature_flags": [
                    {"id": "Alpha", "description": "", "enabled": "true", "conditions": {"client_filters": []}},
                    {"id": "Beta", "description": "", "enabled": "false", "conditions": {"client_filters": []}},
                ]
            }
        }
        feature_manager = FeatureManager(feature_flags)
        assert feature_manager is not None
        assert feature_manager.is_enabled("Alpha")
        assert not feature_manager.is_enabled("Beta")
        assert len(feature_manager.list_feature_flag_names()) == 2

    # method: is_enabled
    def test_unknown_feature_filter(self):
        feature_flags = {
            "feature_management": {
                "feature_flags": [
                    {
                        "id": "Alpha",
                        "description": "",
                        "enabled": "true",
                        "conditions": {"client_filters": [{"name": "UnknownFilter", "parameters": {}}]},
                    },
                ]
            }
        }
        feature_manager = FeatureManager(feature_flags, feature_filters=[AlwaysOn(), AlwaysOff()])
        assert feature_manager is not None
        with pytest.raises(ValueError) as e_info:
            feature_manager.is_enabled("Alpha")
        assert e_info.type == ValueError
        assert e_info.value.args[0] == "Feature flag Alpha has unknown filter UnknownFilter"

    # method: feature_manager_creation
    def test_feature_with_telemetry(self):
        self.called_telemetry = False
        feature_flags = {
            "feature_management": {
                "feature_flags": [
                    {"id": "Alpha", "description": "", "enabled": "true", "telemetry": {"enabled": "true"}},
                ]
            }
        }
        feature_manager = FeatureManager(feature_flags, on_feature_evaluated=self.fake_telemetry_callback)
        assert feature_manager is not None
        assert feature_manager.is_enabled("Alpha")
        assert self.called_telemetry

    def fake_telemetry_callback(self, evaluation_event):
        assert evaluation_event
        self.called_telemetry = True

    # method: duplicate_feature_flag_handling
    def test_duplicate_feature_flags_last_wins(self):
        """Test that when multiple feature flags have the same ID, the last one wins."""
        feature_flags = {
            "feature_management": {
                "feature_flags": [
                    {
                        "id": "DuplicateFlag",
                        "description": "First",
                        "enabled": "true",
                        "conditions": {"client_filters": []},
                    },
                    {
                        "id": "DuplicateFlag",
                        "description": "Second",
                        "enabled": "false",
                        "conditions": {"client_filters": []},
                    },
                    {
                        "id": "DuplicateFlag",
                        "description": "Third",
                        "enabled": "true",
                        "conditions": {"client_filters": []},
                    },
                ]
            }
        }
        feature_manager = FeatureManager(feature_flags)

        # The last flag should win (enabled: true)
        assert feature_manager.is_enabled("DuplicateFlag") is True

        # Should only list unique names
        flag_names = feature_manager.list_feature_flag_names()
        assert "DuplicateFlag" in flag_names
        # Count how many times DuplicateFlag appears in the list
        duplicate_count = flag_names.count("DuplicateFlag")
        assert duplicate_count == 1, f"Expected DuplicateFlag to appear once, but appeared {duplicate_count} times"

    def test_duplicate_feature_flags_last_wins_disabled(self):
        """Test that when multiple feature flags have the same ID, the last one wins even if disabled."""
        feature_flags = {
            "feature_management": {
                "feature_flags": [
                    {
                        "id": "DuplicateFlag",
                        "description": "First",
                        "enabled": "true",
                        "conditions": {"client_filters": []},
                    },
                    {
                        "id": "DuplicateFlag",
                        "description": "Second",
                        "enabled": "true",
                        "conditions": {"client_filters": []},
                    },
                    {
                        "id": "DuplicateFlag",
                        "description": "Third",
                        "enabled": "false",
                        "conditions": {"client_filters": []},
                    },
                ]
            }
        }
        feature_manager = FeatureManager(feature_flags)

        # The last flag should win (enabled: false)
        assert feature_manager.is_enabled("DuplicateFlag") is False

    def test_duplicate_feature_flags_mixed_with_unique(self):
        """Test behavior with a mix of duplicate and unique feature flags."""
        feature_flags = {
            "feature_management": {
                "feature_flags": [
                    {
                        "id": "UniqueFlag1",
                        "description": "First unique",
                        "enabled": "true",
                        "conditions": {"client_filters": []},
                    },
                    {
                        "id": "DuplicateFlag",
                        "description": "First duplicate",
                        "enabled": "false",
                        "conditions": {"client_filters": []},
                    },
                    {
                        "id": "UniqueFlag2",
                        "description": "Second unique",
                        "enabled": "false",
                        "conditions": {"client_filters": []},
                    },
                    {
                        "id": "DuplicateFlag",
                        "description": "Second duplicate",
                        "enabled": "true",
                        "conditions": {"client_filters": []},
                    },
                    {
                        "id": "UniqueFlag3",
                        "description": "Third unique",
                        "enabled": "true",
                        "conditions": {"client_filters": []},
                    },
                ]
            }
        }
        feature_manager = FeatureManager(feature_flags)

        # Test unique flags work as expected
        assert feature_manager.is_enabled("UniqueFlag1") is True
        assert feature_manager.is_enabled("UniqueFlag2") is False
        assert feature_manager.is_enabled("UniqueFlag3") is True

        # Test duplicate flag - last should win (enabled: true)
        assert feature_manager.is_enabled("DuplicateFlag") is True

        # Test list includes all unique names
        flag_names = feature_manager.list_feature_flag_names()
        expected_names = ["UniqueFlag1", "DuplicateFlag", "UniqueFlag2", "UniqueFlag3"]
        assert set(flag_names) == set(expected_names)
        # Ensure each name appears only once
        for name in expected_names:
            assert flag_names.count(name) == 1


class AlwaysOn(FeatureFilter):
    def evaluate(self, context, **kwargs):
        return True


class AlwaysOff(FeatureFilter):
    def evaluate(self, context, **kwargs):
        return False


@FeatureFilter.alias("Microsoft.TimeWindow")
class FakeTimeWindowFilter(FeatureFilter):
    def evaluate(self, context, **kwargs):
        return True