Revert "Merge main to release/v4 (#570)" (#572)

This reverts commit a74d56b.

Author: zhiyuanliang-ms

src/Microsoft.FeatureManagement.AspNetCore/FeatureGatedAsyncActionFilter.cs

@@ -4,73 +4,33 @@
 using Microsoft.AspNetCore.Mvc.Filters;
 using Microsoft.Extensions.DependencyInjection;
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Threading.Tasks;
 
 namespace Microsoft.FeatureManagement
 {
     /// <summary>
-    /// A place holder MVC filter that is used to dynamically activate a filter based on whether a feature (or set of features) is enabled.
+    /// A place holder MVC filter that is used to dynamically activate a filter based on whether a feature is enabled.
     /// </summary>
     /// <typeparam name="T">The filter that will be used instead of this placeholder.</typeparam>
     class FeatureGatedAsyncActionFilter<T> : IAsyncActionFilter where T : IAsyncActionFilter
     {
-        /// <summary>
-        /// Creates a feature gated filter for multiple features with a specified requirement type and ability to negate the evaluation.
-        /// </summary>
-        /// <param name="requirementType">Specifies whether all or any of the provided features should be enabled.</param>
-        /// <param name="negate">Whether to negate the evaluation result.</param>
-        /// <param name="features">The features that control whether the wrapped filter executes.</param>
-        public FeatureGatedAsyncActionFilter(RequirementType requirementType, bool negate, params string[] features)
+        public FeatureGatedAsyncActionFilter(string featureName)
         {
-            if (features == null || features.Length == 0)
+            if (string.IsNullOrEmpty(featureName))
             {
-                throw new ArgumentNullException(nameof(features));
+                throw new ArgumentNullException(nameof(featureName));
             }
 
-            Features = features;
-            RequirementType = requirementType;
-            Negate = negate;
+            FeatureName = featureName;
         }
 
-        /// <summary>
-        /// The set of features that gate the wrapped filter.
-        /// </summary>
-        public IEnumerable<string> Features { get; }
-
-        /// <summary>
-        /// Controls whether any or all features in <see cref="Features"/> should be enabled to allow the wrapped filter to execute.
-        /// </summary>
-        public RequirementType RequirementType { get; }
-
-        /// <summary>
-        /// Negates the evaluation for whether or not the wrapped filter should execute.
-        /// </summary>
-        public bool Negate { get; }
+        public string FeatureName { get; }
 
         public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
         {
-            IFeatureManagerSnapshot featureManager = context.HttpContext.RequestServices.GetRequiredService<IFeatureManagerSnapshot>();
-
-            bool enabled;
-
-            // Enabled state is determined by either 'any' or 'all' features being enabled.
-            if (RequirementType == RequirementType.All)
-            {
-                enabled = await Features.All(async f => await featureManager.IsEnabledAsync(f).ConfigureAwait(false));
-            }
-            else
-            {
-                enabled = await Features.Any(async f => await featureManager.IsEnabledAsync(f).ConfigureAwait(false));
-            }
-
-            if (Negate)
-            {
-                enabled = !enabled;
-            }
+            IFeatureManager featureManager = context.HttpContext.RequestServices.GetRequiredService<IFeatureManagerSnapshot>();
 
-            if (enabled)
+            if (await featureManager.IsEnabledAsync(FeatureName).ConfigureAwait(false))
             {
                 IAsyncActionFilter filter = ActivatorUtilities.CreateInstance<T>(context.HttpContext.RequestServices);
 

src/Microsoft.FeatureManagement.AspNetCore/FilterCollectionExtensions.cs

@@ -16,63 +16,12 @@ public static class FilterCollectionExtensions
         /// <typeparam name="TFilterType">The MVC filter to add and use if the feature is enabled.</typeparam>
         /// <param name="filters">The filter collection to add to.</param>
         /// <param name="feature">The feature that will need to enabled to trigger the execution of the MVC filter.</param>
-        /// <returns>The reference to the added filter metadata.</returns>
+        /// <returns></returns>
         public static IFilterMetadata AddForFeature<TFilterType>(this FilterCollection filters, string feature) where TFilterType : IAsyncActionFilter
         {
-            IFilterMetadata filterMetadata = new FeatureGatedAsyncActionFilter<TFilterType>(RequirementType.Any, false, feature);
+            IFilterMetadata filterMetadata = null;
 
-            filters.Add(filterMetadata);
-
-            return filterMetadata;
-        }
-
-        /// <summary>
-        /// Adds an MVC filter that will only activate during a request if the specified feature is enabled.
-        /// </summary>
-        /// <typeparam name="TFilterType">The MVC filter to add and use if the feature is enabled.</typeparam>
-        /// <param name="filters">The filter collection to add to.</param>
-        /// <param name="features">The features that control whether the MVC filter executes.</param>
-        /// <returns>The reference to the added filter metadata.</returns>
-        public static IFilterMetadata AddForFeature<TFilterType>(this FilterCollection filters, params string[] features) where TFilterType : IAsyncActionFilter
-        {
-            IFilterMetadata filterMetadata = new FeatureGatedAsyncActionFilter<TFilterType>(RequirementType.Any, false, features);
-
-            filters.Add(filterMetadata);
-
-            return filterMetadata;
-        }
-
-        /// <summary>
-        /// Adds an MVC filter that will only activate during a request if the specified features are enabled based on the provided requirement type.
-        /// </summary>
-        /// <typeparam name="TFilterType">The MVC filter to add and use if the features condition is satisfied.</typeparam>
-        /// <param name="filters">The filter collection to add to.</param>
-        /// <param name="requirementType">Specifies whether all or any of the provided features should be enabled.</param>
-        /// <param name="features">The features that control whether the MVC filter executes.</param>
-        /// <returns>The reference to the added filter metadata.</returns>
-        public static IFilterMetadata AddForFeature<TFilterType>(this FilterCollection filters, RequirementType requirementType, params string[] features) where TFilterType : IAsyncActionFilter
-        {
-            IFilterMetadata filterMetadata = new FeatureGatedAsyncActionFilter<TFilterType>(requirementType, false, features);
-
-            filters.Add(filterMetadata);
-
-            return filterMetadata;
-        }
-
-        /// <summary>
-        /// Adds an MVC filter that will only activate during a request if the specified features are enabled based on the provided requirement type and negation flag.
-        /// </summary>
-        /// <typeparam name="TFilterType">The MVC filter to add and use if the features condition is satisfied.</typeparam>
-        /// <param name="filters">The filter collection to add to.</param>
-        /// <param name="requirementType">Specifies whether all or any of the provided features should be enabled.</param>
-        /// <param name="negate">Whether to negate the evaluation result for the provided features set.</param>
-        /// <param name="features">The features that control whether the MVC filter executes.</param>
-        /// <returns>The reference to the added filter metadata.</returns>
-        public static IFilterMetadata AddForFeature<TFilterType>(this FilterCollection filters, RequirementType requirementType, bool negate, params string[] features) where TFilterType : IAsyncActionFilter
-        {
-            IFilterMetadata filterMetadata = new FeatureGatedAsyncActionFilter<TFilterType>(requirementType, negate, features);
-
-            filters.Add(filterMetadata);
+            filters.Add(new FeatureGatedAsyncActionFilter<TFilterType>(feature));
 
             return filterMetadata;
         }

src/Microsoft.FeatureManagement.AspNetCore/Microsoft.FeatureManagement.AspNetCore.csproj

@@ -5,7 +5,7 @@
   <!-- Official Version -->
   <PropertyGroup>
     <MajorVersion>4</MajorVersion>
-    <MinorVersion>4</MinorVersion>
+    <MinorVersion>3</MinorVersion>
     <PatchVersion>0</PatchVersion>
   </PropertyGroup>
 

src/Microsoft.FeatureManagement.Telemetry.ApplicationInsights/Microsoft.FeatureManagement.Telemetry.ApplicationInsights.csproj

@@ -4,7 +4,7 @@
   <!-- Official Version -->
   <PropertyGroup>
     <MajorVersion>4</MajorVersion>
-    <MinorVersion>4</MinorVersion>
+    <MinorVersion>3</MinorVersion>
     <PatchVersion>0</PatchVersion>
   </PropertyGroup>
 

src/Microsoft.FeatureManagement/FeatureFilters/TimeWindowFilter.cs

@@ -37,9 +37,9 @@ public TimeWindowFilter(ILoggerFactory loggerFactory = null)
         public IMemoryCache Cache { get; set; }
 
         /// <summary>
-        /// This property allows the time window filter to use custom <see cref="TimeProvider"/>.
+        /// This property allows the time window filter in our test suite to use simulated time.
         /// </summary>
-        public TimeProvider SystemClock { get; set; }
+        internal TimeProvider SystemClock { get; set; }
 
         /// <summary>
         /// Binds configuration representing filter parameters to <see cref="TimeWindowFilterSettings"/>.

src/Microsoft.FeatureManagement/FeatureManagerSnapshot.cs

@@ -103,7 +103,7 @@ public async ValueTask<Variant> GetVariantAsync(string feature, CancellationToke
 
             //
             // First, check local cache
-            if (_variantCache.ContainsKey(cacheKey))
+            if (_variantCache.ContainsKey(feature))
             {
                 return _variantCache[cacheKey];
             }
@@ -121,7 +121,7 @@ public async ValueTask<Variant> GetVariantAsync(string feature, ITargetingContex
 
             //
             // First, check local cache
-            if (_variantCache.ContainsKey(cacheKey))
+            if (_variantCache.ContainsKey(feature))
             {
                 return _variantCache[cacheKey];
             }

src/Microsoft.FeatureManagement/Microsoft.FeatureManagement.csproj

@@ -5,7 +5,7 @@
   <!-- Official Version -->
   <PropertyGroup>
     <MajorVersion>4</MajorVersion>
-    <MinorVersion>4</MinorVersion>
+    <MinorVersion>3</MinorVersion>
     <PatchVersion>0</PatchVersion>
   </PropertyGroup>
 

src/Microsoft.FeatureManagement/ServiceCollectionExtensions.cs

@@ -175,8 +175,7 @@ private static IFeatureManagementBuilder GetFeatureManagementBuilder(IServiceCol
             builder.AddFeatureFilter<TimeWindowFilter>(sp =>
                 new TimeWindowFilter()
                 {
-                    Cache = sp.GetRequiredService<IMemoryCache>(),
-                    SystemClock = sp.GetService<TimeProvider>() ?? TimeProvider.System,
+                    Cache = sp.GetRequiredService<IMemoryCache>()
                 });
 
             builder.AddFeatureFilter<ContextualTargetingFilter>();

tests/Tests.FeatureManagement.AspNetCore/FeatureManagementAspNetCore.cs

@@ -202,47 +202,6 @@ public async Task GatesRazorPageFeatures()
             Assert.Equal(HttpStatusCode.OK, gateAnyNegateResponse.StatusCode);
         }
 
-        [Fact]
-        public async Task GatesActionFilterFeatures()
-        {
-            IConfiguration config = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build();
-
-            TestServer server = new TestServer(WebHost.CreateDefaultBuilder().ConfigureServices(services =>
-            {
-                services
-                    .AddSingleton(config)
-                    .AddFeatureManagement()
-                    .AddFeatureFilter<TestFilter>();
-
-                services.AddMvcCore(o =>
-                {
-                    DisableEndpointRouting(o);
-                    o.Filters.AddForFeature<MvcFilter>(RequirementType.All, Features.ConditionalFeature, Features.ConditionalFeature2);
-                });
-            }).Configure(app => app.UseMvc()));
-
-            TestFilter filter = (TestFilter)server.Host.Services.GetRequiredService<IEnumerable<IFeatureFilterMetadata>>().First(f => f is TestFilter);
-            HttpClient client = server.CreateClient();
-
-            //
-            // Enable all features
-            filter.Callback = _ => Task.FromResult(true);
-            HttpResponseMessage res = await client.GetAsync("");
-            Assert.True(res.Headers.Contains(nameof(MvcFilter)));
-
-            //
-            // Enable 1/2 features
-            filter.Callback = ctx => Task.FromResult(ctx.FeatureName == Features.ConditionalFeature);
-            res = await client.GetAsync("");
-            Assert.False(res.Headers.Contains(nameof(MvcFilter)));
-
-            //
-            // Enable no
-            filter.Callback = _ => Task.FromResult(false);
-            res = await client.GetAsync("");
-            Assert.False(res.Headers.Contains(nameof(MvcFilter)));
-        }
-
         private static void DisableEndpointRouting(MvcOptions options)
         {
             options.EnableEndpointRouting = false;

tests/Tests.FeatureManagement/FeatureManagementTest.cs

@@ -332,67 +332,6 @@ public async Task ThreadSafeSnapshot()
             }
         }
 
-        [Fact]
-        public async Task ReturnsCachedResultFromSnapshot()
-        {
-            IConfiguration config = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build();
-
-            var services = new ServiceCollection();
-
-            services
-                .AddSingleton(config)
-                .AddFeatureManagement()
-                .AddFeatureFilter<TestFilter>();
-
-            ServiceProvider serviceProvider = services.BuildServiceProvider();
-
-            IVariantFeatureManager featureManager = serviceProvider.GetRequiredService<IVariantFeatureManager>();
-
-            IVariantFeatureManager featureManagerSnapshot = serviceProvider.GetRequiredService<IVariantFeatureManagerSnapshot>();
-
-            IEnumerable<IFeatureFilterMetadata> featureFilters = serviceProvider.GetRequiredService<IEnumerable<IFeatureFilterMetadata>>();
-
-            TestFilter testFeatureFilter = (TestFilter)featureFilters.First(f => f is TestFilter);
-
-            int callCount = 0;
-            bool filterEnabled = true;
-
-            testFeatureFilter.Callback = (evaluationContext) =>
-            {
-                callCount++;
-                return Task.FromResult(filterEnabled);
-            };
-
-            // First evaluation - filter is enabled and should return true
-            bool result1 = await featureManagerSnapshot.IsEnabledAsync(Features.ConditionalFeature);
-            Assert.Equal(1, callCount);
-            Assert.True(result1);
-
-            Variant variant1 = await featureManagerSnapshot.GetVariantAsync(Features.ConditionalFeature);
-            Assert.Equal(2, callCount);
-            Assert.Equal("DefaultWhenEnabled", variant1.Name);
-
-            // "Shut down" the feature filter
-            filterEnabled = false;
-
-            // Second evaluation - should use cached value despite filter being shut down
-            bool result2 = await featureManagerSnapshot.IsEnabledAsync(Features.ConditionalFeature);
-            Assert.Equal(2, callCount);
-            Assert.True(result2);
-
-            Variant variant2 = await featureManagerSnapshot.GetVariantAsync(Features.ConditionalFeature);
-            Assert.Equal(2, callCount);
-            Assert.Equal("DefaultWhenEnabled", variant2.Name);
-
-            bool result3 = await featureManager.IsEnabledAsync(Features.ConditionalFeature);
-            Assert.Equal(3, callCount);
-            Assert.False(result3);
-
-            Variant variant3 = await featureManager.GetVariantAsync(Features.ConditionalFeature);
-            Assert.Equal(4, callCount);
-            Assert.Equal("DefaultWhenDisabled", variant3.Name);
-        }
-
         [Fact]
         public void AddsScopedFeatureManagement()
         {
@@ -584,20 +523,6 @@ public async Task MergesFeatureFlagsFromDifferentConfigurationSources()
             Assert.True(await featureManager8.IsEnabledAsync("FeatureC"));
             Assert.False(await featureManager8.IsEnabledAsync("Feature1"));
             Assert.False(await featureManager8.IsEnabledAsync("Feature2"));
-
-            var configurationManager = new ConfigurationManager();
-            configurationManager
-                .AddJsonFile("appsettings1.json")
-                .AddJsonFile("appsettings2.json");
-
-            var services = new ServiceCollection();
-            services.AddFeatureManagement();
-
-            var featureManager9 = new FeatureManager(new ConfigurationFeatureDefinitionProvider(configurationManager, mergeOptions));
-            Assert.True(await featureManager9.IsEnabledAsync("FeatureA"));
-            Assert.True(await featureManager9.IsEnabledAsync("FeatureB"));
-            Assert.True(await featureManager9.IsEnabledAsync("Feature1"));
-            Assert.False(await featureManager9.IsEnabledAsync("Feature2")); // appsettings2 should override appsettings1
         }
     }