add testcase

tests/Tests.FeatureManagement/FeatureManagement.cs

@@ -1262,5 +1262,72 @@ public async Task VariantsInvalidScenarios()
             Assert.Equal(FeatureManagementError.InvalidConfigurationSetting, e.Error);
             Assert.Contains(ConfigurationFields.PercentileAllocationFrom, e.Message);
         }
+
+        [Fact]
+        public void VariantBasedInjection()
+        {
+            IConfiguration configuration = new ConfigurationBuilder()
+                .AddJsonFile("appsettings.json")
+                .Build();
+
+            IServiceCollection services = new ServiceCollection();
+
+            services.AddSingleton<IAlgorithm, AlgorithmBeta>();
+            services.AddSingleton<IAlgorithm, AlgorithmSigma>();
+            services.AddSingleton<IAlgorithm>(sp => new AlgorithmOmega("OMEGA"));
+
+            services.AddSingleton(configuration)
+                .AddFeatureManagement()
+                .AddFeatureFilter<TargetingFilter>()
+                .AddVariantServiceProvider<IAlgorithm>(Features.VariantImplementationFeature);
+
+            var targetingContextAccessor = new OnDemandTargetingContextAccessor();
+
+            services.AddSingleton<ITargetingContextAccessor>(targetingContextAccessor);
+
+            ServiceProvider serviceProvider = services.BuildServiceProvider();
+
+            IVariantFeatureManager featureManager = serviceProvider.GetRequiredService<IVariantFeatureManager>();
+
+            IVariantServiceProvider<IAlgorithm> featuredAlgorithm = serviceProvider.GetRequiredService<IVariantServiceProvider<IAlgorithm>>();
+
+            targetingContextAccessor.Current = new TargetingContext
+            {
+                UserId = "Guest"
+            };
+
+            IAlgorithm algorithm = featuredAlgorithm.GetService();
+
+            Assert.Null(algorithm);
+
+            targetingContextAccessor.Current = new TargetingContext
+            {
+                UserId = "UserSigma"
+            };
+
+            algorithm = featuredAlgorithm.GetService();
+
+            Assert.Null(algorithm);
+
+            targetingContextAccessor.Current = new TargetingContext
+            {
+                UserId = "UserBeta"
+            };
+
+            algorithm = featuredAlgorithm.GetService();
+
+            Assert.NotNull(algorithm);
+            Assert.Equal("Beta", algorithm.Style);
+
+            targetingContextAccessor.Current = new TargetingContext
+            {
+                UserId = "UserOmega"
+            };
+
+            algorithm = featuredAlgorithm.GetService();
+
+            Assert.NotNull(algorithm);
+            Assert.Equal("OMEGA", algorithm.Style);
+        }
     }
 }

tests/Tests.FeatureManagement/Features.cs

@@ -30,5 +30,6 @@ static class Features
         public const string VariantFeatureBothConfigurations = "VariantFeatureBothConfigurations";
         public const string VariantFeatureInvalidStatusOverride = "VariantFeatureInvalidStatusOverride";
         public const string VariantFeatureInvalidFromTo = "VariantFeatureInvalidFromTo";
+        public const string VariantImplementationFeature = "VariantImplementationFeature";
     }
 }

tests/Tests.FeatureManagement/VariantServices.cs

@@ -0,0 +1,40 @@
+using Microsoft.FeatureManagement;
+
+namespace Tests.FeatureManagement
+{
+    interface IAlgorithm
+    {
+        public string Style { get; }
+    }
+
+    class AlgorithmBeta : IAlgorithm
+    {
+        public string Style { get; set; }
+
+        public AlgorithmBeta()
+        {
+            Style = "Beta";
+        }
+    }
+
+    class AlgorithmSigma : IAlgorithm
+    {
+        public string Style { get; set; }
+
+        public AlgorithmSigma()
+        {
+            Style = "Sigma";
+        }
+    }
+
+    [VariantServiceAlias("Omega")]
+    class AlgorithmOmega : IAlgorithm
+    {
+        public string Style { get; set; }
+
+        public AlgorithmOmega(string name)
+        {
+            Style = name;
+        }
+    }
+}

tests/Tests.FeatureManagement/appsettings.json

@@ -493,6 +493,54 @@
                     "Name": "On"
                 }
             ]
+        },
+        "VariantImplementationFeature": {
+            "EnabledFor": [
+                {
+                    "Name": "Targeting",
+                    "Parameters": {
+                        "Audience": {
+                            "Users": [
+                                "UserOmega", "UserSigma", "UserBeta"
+                            ]
+                        }
+                    }
+                }
+            ],
+            "Variants": [
+                {
+                    "Name": "AlgorithmBeta"
+                },
+                {
+                    "Name": "Sigma",
+                    "ConfigurationValue": "AlgorithmSigma"
+                },
+                {
+                    "Name": "Omega"
+                }
+            ],
+            "Allocation": {
+                "User": [
+                    {
+                        "Variant": "AlgorithmBeta",
+                        "Users": [
+                            "UserBeta"
+                        ]
+                    },
+                    {
+                        "Variant": "Omega",
+                        "Users": [
+                            "UserOmega"
+                        ]
+                    },
+                    {
+                        "Variant": "Sigma",
+                        "Users": [
+                            "UserSigma"
+                        ]
+                    }
+                ]
+            }
         }
     }
 }