Updated Usercontext tests

optimizely · msohailhussain · Dec 7, 2021 · Sep 24, 2021 · Sep 24, 2021 · Sep 24, 2021
commit d23fcd07ad0635a08af161bb343397a6c8fe7b55
diff --git a/OptimizelySDK.Tests/Assertions.cs b/OptimizelySDK.Tests/Assertions.cs
@@ -18,22 +18,34 @@ public class Assertions
     {
         #region Basic asserts
 
-        public static void AreEquivalent(IEnumerable<string> expected, IEnumerable<string> actual)
+        public static bool HasItems(IEnumerable<object> expected, IEnumerable<object> actual, bool allowNull = true)
         {
+            if (allowNull && expected == null && actual == null)
+                return false;
+
             Assert.AreEqual(expected.Count(), actual.Count());
-            var zipped = expected.Zip(actual, (e, a) =>
+
+            return true;
+        }
+
+        public static void AreEquivalent(IEnumerable<string> expected, IEnumerable<string> actual)
+        {
+            if (HasItems(expected, actual, false))
             {
-                return new
+                var zipped = expected.Zip(actual, (e, a) =>
                 {
-                    Expected = e,
-                    Actual = a
+                    return new
+                    {
+                        Expected = e,
+                        Actual = a
+                    };
+                }).ToList();
+
+                foreach (var z in zipped)
+                {
+                    Assert.AreEqual(z.Expected, z.Actual);
                 };
-            }).ToList();
-
-            foreach (var z in zipped)
-            {
-                Assert.AreEqual(z.Expected, z.Actual);
-            };
+            }
         }
 
         public static void AreEquivalent(Dictionary<string, string> expected, Dictionary<string, string> actual)
@@ -96,6 +108,7 @@ public static void AreEqual(FeatureDecision expected, FeatureDecision actual)
         #region FeatureFlags
         public static void AreEquivalent(Dictionary<string, FeatureFlag> expected, Dictionary<string, FeatureFlag> actual)
         {
+            Assert.AreEqual(expected.Count, actual.Count);
             var zipped = expected.Zip(actual, (e, a) =>
             {
                 return new
@@ -139,6 +152,7 @@ public static void AreEqual(FeatureVariable expected, FeatureVariable actual)
 
         public static void AreEquivalent(Dictionary<string, FeatureVariable> expected, Dictionary<string, FeatureVariable> actual)
         {
+            Assert.AreEqual(expected.Count, actual.Count);
             var zipped = expected.Zip(actual, (e, a) =>
             {
                 return new
@@ -244,22 +258,30 @@ public static void AreEquivalent(IEnumerable<Variation> expected, IEnumerable<Va
         #region FeatureVariableUsage
         public static void AreEquivalent(IEnumerable<FeatureVariableUsage> expected, IEnumerable<FeatureVariableUsage> actual)
         {
-            Assert.AreEqual(expected.Count(), actual.Count());
-            expected.Zip(actual, (e, a) =>
+            if (HasItems(expected, actual))
             {
-                return new
+                expected.Zip(actual, (e, a) =>
                 {
-                    Expected = e,
-                    Actual = a
-                };
-            }).ToList().ForEach((item) =>
-            {
-                AreEqual(item.Expected, item.Actual);
-            });
+                    return new
+                    {
+                        Expected = e,
+                        Actual = a
+                    };
+                }).ToList().ForEach((item) =>
+                {
+                    AreEqual(item.Expected, item.Actual);
+                });
+            }
         }
 
         public static void AreEquivalent(Dictionary<string, FeatureVariableUsage> expected, Dictionary<string, FeatureVariableUsage> actual)
         {
+            if (expected == null && actual == null)
+            {
+                return;
+            }
+
+            Assert.AreEqual(expected.Count(), actual.Count());
             expected.Zip(actual, (e, a) =>
             {
                 return new

diff --git a/OptimizelySDK.Tests/DecisionServiceTest.cs b/OptimizelySDK.Tests/DecisionServiceTest.cs
@@ -379,7 +379,8 @@ public void TestGetVariationUserWithSetForcedVariation()
 
             // confirm normal bucketing occurs before setting the forced variation
             var actualVariation = optlyObject.GetVariation(experimentKey, userId, userAttributes);
-            Assert.IsTrue(TestData.CompareObjects(VariationWithKeyControl, actualVariation));
+            Assertions.AreEqual(VariationWithKeyControl, actualVariation);
+            //Assert.IsTrue(TestData.CompareObjects(VariationWithKeyControl, actualVariation));
 
             // test valid experiment
             Assert.IsTrue(optlyObject.SetForcedVariation(experimentKey, userId, expectedForcedVariationKey), string.Format(@"Set variation to ""{0}"" failed.", expectedForcedVariationKey));

diff --git a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
@@ -186,6 +186,78 @@ public void TestDecide()
             Assert.AreEqual(decision.Reasons.Length, 0);
         }
 
+        [Test]
+        public void SetForcedDecisionSetsValue()
+        {
+            var user = Optimizely.CreateUserContext(UserID);
+
+            var result = user.SetForcedDecision("flag", "variation");
+
+            Assert.IsTrue(result);
+        }
+
+        [Test]
+        public void SetForcedDecisionReturnsFalseAndLogErrorForNullConfig()
+        {
+            var optly = new Optimizely(new FallbackProjectConfigManager(null));
+
+
+            var user = optly.CreateUserContext(UserID);
+            var result = user.SetForcedDecision("flag", "variation");
+
+            Assert.IsFalse(result);
+            //should assert logger is called
+        }
+
+        [Test]
+        public void GetForcedDecisionsReturnsValueWithRuleKey()
+        {
+            var user = Optimizely.CreateUserContext(UserID);
+
+            user.SetForcedDecision("flag", "rule", "variation");
+
+            var result = user.GetForcedDecision("flag", "rule");
+
+            Assert.AreEqual("variation", result);
+        }
+
+        [Test]
+
+        public void GetForcedDecisionReturnsValueWithoutRuleKey()
+        {
+            var user = Optimizely.CreateUserContext(UserID);
+
+            user.SetForcedDecision("flag", "variation");
+
+            var result = user.GetForcedDecision("flag", null);
+
+            Assert.AreEqual("variation", result);
+        }
+
+        [Test]
+        public void FindForcedDecisionReturnsValueWithoutRuleKey()
+        {
+            var user = Optimizely.CreateUserContext(UserID);
+
+            user.SetForcedDecision("flag", "variation");
+
+            var result = user.FindForcedDecision(
10000
"flag", null);
+
+            Assert.AreEqual("variation", result);
+        }
+
+        [Test]
+        public void FindForcedDecisionReturnsValueWithRuleKey()
+        {
+            var user = Optimizely.CreateUserContext(UserID);
+
+            user.SetForcedDecision("flag", "rule", "variation");
+
+            var result = user.FindForcedDecision("flag", "rule");
+
+            Assert.AreEqual("variation", result);
+        }
+
         [Test]
         public void DecideInvalidFlagKey()
         {

diff --git a/OptimizelySDK/Entity/Variation.cs b/OptimizelySDK/Entity/Variation.cs
@@ -35,6 +35,7 @@ public List<FeatureVariableUsage> FeatureVariableUsageInstances
                 // Generating Variable Usage key map.
                 if (_FeatureVariableUsageInstances != null)
                     VariableIdToVariableUsageInstanceMap = ConfigParser<FeatureVariableUsage>.GenerateMap(entities: _FeatureVariableUsageInstances, getKey: v => v.Id.ToString(), clone: true);
+
             }
         }
 

diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
@@ -27,6 +27,26 @@ namespace OptimizelySDK
     /// </summary>
     public class OptimizelyUserContext
     {
+        private class ForcedDecision
+        {
+            private string flagKey;
+            private string ruleKey;
+            private string variationKey;
+
+            public ForcedDecision(string flagKey, string ruleKey, string variationKey)
+            {
+                this.flagKey = flagKey;
+                this.ruleKey = ruleKey;
+                this.variationKey = variationKey;
+            }
+
+            public string FlagKey { get { return flagKey; } set { this.flagKey = value; } }
+
+            public string RuleKey { get { return ruleKey; } set { this.ruleKey = value; } }
+
+            public string VariationKey { get { return variationKey; } set { this.variationKey = value; } }
+        }
+
         private ILogger Logger;
         private IErrorHandler ErrorHandler;
         private object mutex = new object();
@@ -37,6 +57,9 @@ public class OptimizelyUserContext
         // Optimizely object to be used.
         private Optimizely Optimizely;
 
+        private Dictionary<string, Dictionary<string, ForcedDecision>> ForcedDecisionsMap = new Dictionary<string, Dictionary<string, ForcedDecision>>();
+        private Dictionary<string, ForcedDecision> ForcedDecisionsMapWithNoRuleKey = new Dictionary<string, ForcedDecision>();
+
         public OptimizelyUserContext(Optimizely optimizely, string userId, UserAttributes userAttributes, IErrorHandler errorHandler, ILogger logger)
         {
             ErrorHandler = errorHandler;
@@ -189,5 +212,99 @@ public virtual void TrackEvent(string eventName,
         {
             Optimizely.Track(eventName, UserId, Attributes, eventTags);
         }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="flagKey"></param>
+        /// <param name="variationKey"></param>
+        /// <returns></returns>
+
+        public bool SetForcedDecision(string flagKey, string variationKey)
+        {
+            return SetForcedDecision(flagKey, nul
179B
l, variationKey);
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="flagKey"></param>
+        /// <param name="ruleKey"></param>
+        /// <param name="variationKey"></param>
+        /// <returns></returns>
+        public bool SetForcedDecision(string flagKey, string ruleKey, string variationKey)
+        {
+            if (Optimizely.GetOptimizelyConfig() == null)
+            {
+                Logger.Log(LogLevel.ERROR, "Optimizely config is null");
+                return false;
+            }
+
+            if(ruleKey == null)
+            {
+                if (ForcedDecisionsMapWithNoRuleKey.TryGetValue(flagKey, out var value))
+                {
+                    value.VariationKey = variationKey;
+                }
+                else
+                {
+                    ForcedDecisionsMapWithNoRuleKey.Add(flagKey, new ForcedDecision(flagKey, null, variationKey));
+                }
+            }
+            else
+            {
+                Dictionary<string, ForcedDecision> forcedDecision = new Dictionary<string, ForcedDecision>();
+                forcedDecision.Add(ruleKey, new ForcedDecision(flagKey, ruleKey, variationKey));
+                ForcedDecisionsMap.Add(flagKey, forcedDecision);
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="String"></param>
+        /// <param name=""></param>
+        /// <param name="ruleKey"></param>
+        /// <returns></returns>
+        public string GetForcedDecision(string flagKey, string ruleKey)
+        {
+            if (Optimizely.GetOptimizelyConfig() == null)
+            {
+                Logger.Log(LogLevel.ERROR, "Optimizely SDK not ready.");
+                return null;
+            }
+
+            return FindForcedDecision(flagKey, ruleKey);
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="flagKey"></param>
+        /// <param name="ruleKey"></param>
+        /// <returns></returns>
+        public string FindForcedDecision(string flagKey, string ruleKey)
+        {
+            string variationKey = null;
+            if (ruleKey != null)
+            {
+                if (ForcedDecisionsMap.Count > 0 && ForcedDecisionsMap.ContainsKey(flagKey))
+                {
+                    if (ForcedDecisionsMap.TryGetValue(flagKey, out var forcedDecision) && forcedDecision.TryGetValue(ruleKey, out var forcedDecision2))
+                    {
+                        variationKey = forcedDecision2.VariationKey;
+                    }
+                }
+            }
+            else
+            {
+                if (ForcedDecisionsMapWithNoRuleKey.Count > 0 && ForcedDecisionsMapWithNoRuleKey.TryGetValue(flagKey, out var forcedDecision))
+                {
+                    variationKey = forcedDecision.VariationKey;
+                }
+            }
+            return variationKey;
+        }
     }
 }
-Original file line number
+Diff line change
@@ Expand Up @@
                     // Generating Variable Usage key map.
                     if (_FeatureVariableUsageInstances != null)
                         VariableIdToVariableUsageInstanceMap = ConfigParser<FeatureVariableUsage>.GenerateMap(entities: _FeatureVariableUsageInstances, getKey: v => v.Id.ToString(), clone: true);
                 }
             }
@@ Expand Down @@