From e9f3ad350de1fb15d8c12e11afd700fd1b711fe0 Mon Sep 17 00:00:00 2001
From: Dustin Sier <dustin.sier@gmail.com>
Date: Fri, 24 Sep 2021 10:53:04 -0400
Subject: [PATCH 001/130] Updated with new asserts. Created function to make
 map.

---
 OptimizelySDK.Tests/Assertions.cs             | 122 +++++++++++++
 .../OptimizelySDK.Tests.csproj                |   5 +-
 OptimizelySDK.Tests/ProjectConfigTest.cs      | 163 +++++++++++++++---
 OptimizelySDK/Config/DatafileProjectConfig.cs |  38 ++++
 OptimizelySDK/ProjectConfig.cs                |   6 +
 5 files changed, 306 insertions(+), 28 deletions(-)
 create mode 100644 OptimizelySDK.Tests/Assertions.cs

diff --git a/OptimizelySDK.Tests/Assertions.cs b/OptimizelySDK.Tests/Assertions.cs
new file mode 100644
index 00000000..84189c38
--- /dev/null
+++ b/OptimizelySDK.Tests/Assertions.cs
@@ -0,0 +1,122 @@
+using NUnit.Framework;
+using OptimizelySDK.Entity;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace OptimizelySDK.Tests
+{
+    /// <summary>
+    /// Simplifies assertions and provides more insight into which particular piece is failing for a value.
+    /// Especially helpful for Test Driven Development
+    /// </summary>
+    [ExcludeFromCodeCoverage]
+    public class Assertions
+    {
+        #region Variations
+        public static void AreEqual(Variation expected, Variation actual)
+        {
+            Assert.AreEqual(expected.Id, actual.Id);
+            Assert.AreEqual(expected.Key, actual.Key);
+            Assert.AreEqual(expected.FeatureEnabled, actual.FeatureEnabled);
+
+            AreEquivalent(expected.FeatureVariableUsageInstances, actual.FeatureVariableUsageInstances);
+            AreEquivalent(expected.VariableIdToVariableUsageInstanceMap, actual.VariableIdToVariableUsageInstanceMap);
+        }
+
+        public static void AreEquivalent(IEnumerable<KeyValuePair<string, ICollection<Variation>>> expected, IEnumerable<KeyValuePair<string, ICollection<Variation>>> actual)
+        {
+            Assert.AreEqual(expected.Count(), actual.Count());
+
+            var zipped = expected.Zip(actual, (e, a) =>
+            {
+                return new
+                {
+                    Expected = e,
+                    Actual = a
+                };
+            }).ToList();
+
+            foreach(var z in zipped)
+            {
+                AreEquivalent(z.Expected, z.Actual);
+            }
+        }
+
+        public static void AreEquivalent(KeyValuePair<string, ICollection<Variation>> expected, KeyValuePair<string, ICollection<Variation>> actual)
+        {
+            Assert.AreEqual(expected.Key, actual.Key);
+            AreEquivalent(expected.Value, actual.Value);
+        }
+
+
+
+        public static void AreEquivalent(IEnumerable<Variation> expected, IEnumerable<Variation> actual)
+        {
+            Assert.AreEqual(expected.Count(), actual.Count());
+            expected.Zip(actual, (e, a) =>
+            {
+                return new
+                {
+                    Expected = e,
+                    Actual = a
+                };
+            }).ToList().ForEach((item) =>
+            {
+                AreEqual(item.Expected, item.Actual);
+            });
+        }
+
+        #endregion
+
+        #region FeatureVariableUsage
+        public static void AreEquivalent(IEnumerable<FeatureVariableUsage> expected, IEnumerable<FeatureVariableUsage> actual)
+        {
+            Assert.AreEqual(expected.Count(), actual.Count());
+            expected.Zip(actual, (e, a) =>
+            {
+                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)
+        {
+            expected.Zip(actual, (e, a) =>
+            {
+                return new
+                {
+                    Expected = e,
+                    Actual = a
+                };
+            }).ToList().ForEach((item) =>
+            {
+                AreEquivalent(item.Expected, item.Actual);
+            });
+        }
+
+        public static void AreEquivalent(KeyValuePair<string, FeatureVariableUsage> expected, KeyValuePair<string, FeatureVariableUsage> actual)
+        {
+            Assert.AreEqual(expected.Key, actual.Key);
+            AreEqual(expected.Value, actual.Value);
+        }
+
+        public static void AreEqual(FeatureVariableUsage expected, FeatureVariableUsage actual)
+        {
+            Assert.AreEqual(expected.Id, actual.Id);
+            Assert.AreEqual(expected.Value, actual.Value);
+        }
+        #endregion
+
+
+    }
+}
diff --git a/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj b/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj
index d5231738..26b18922 100644
--- a/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj
+++ b/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj
@@ -70,6 +70,7 @@
     <Reference Include="System.Net.Http.WebRequest" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Assertions.cs" />
     <Compile Include="AudienceConditionsTests\ConditionEvaluationTest.cs" />
     <Compile Include="AudienceConditionsTests\ConditionsTest.cs" />
     <Compile Include="ConfigTest\HttpProjectConfigManagerTest.cs" />
@@ -143,9 +144,7 @@
     <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
   </ItemGroup>
   <ItemGroup />
-  <ItemGroup>
-    <Folder Include="Utils\" />
-  </ItemGroup>
+  <ItemGroup />
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/OptimizelySDK.Tests/ProjectConfigTest.cs b/OptimizelySDK.Tests/ProjectConfigTest.cs
index 5e8b5c4b..8f5f9814 100644
--- a/OptimizelySDK.Tests/ProjectConfigTest.cs
+++ b/OptimizelySDK.Tests/ProjectConfigTest.cs
@@ -1,4 +1,4 @@
-/* 
+/*
  * Copyright 2017-2021, Optimizely
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,19 +13,20 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-using System;
-using OptimizelySDK.ErrorHandler;
-using OptimizelySDK.Logger;
+
 using Moq;
-using System.Collections.Generic;
+using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
-using OptimizelySDK.Exceptions;
 using NUnit.Framework;
+using OptimizelySDK.Config;
 using OptimizelySDK.Entity;
-using Newtonsoft.Json;
-using OptimizelySDK.Event.Builder;
+using OptimizelySDK.ErrorHandler;
+using OptimizelySDK.Exceptions;
+using OptimizelySDK.Logger;
 using OptimizelySDK.Utils;
-using OptimizelySDK.Config;
+using System;
+using System.Collections.Generic;
+using System.Linq;
 
 namespace OptimizelySDK.Tests
 {
@@ -61,11 +62,11 @@ public void TestInit()
             Assert.AreEqual("1592310167", Config.AccountId);
             // Check Project ID
             Assert.AreEqual("7720880029", Config.ProjectId);
-            // Check Revision 
+            // Check Revision
             Assert.AreEqual("15", Config.Revision);
-            // Check SDK key 
+            // Check SDK key
             Assert.AreEqual("TestData", Config.SDKKey);
-            // Check Environment key 
+            // Check Environment key
             Assert.AreEqual("Production", Config.EnvironmentKey);
             // Check SendFlagDecision
             Assert.IsTrue(Config.SendFlagDecisions);
@@ -393,7 +394,7 @@ public void TestInit()
             var actualVariationUsage = Config.GetVariationFromKey("test_experiment_multivariate", "Fred");
 
             Assert.IsTrue(TestData.CompareObjects(expectedVariationUsage, actualVariationUsage));
-            
+
             // Check Feature Key map.
             var expectedFeatureKeyMap = new Dictionary<string, FeatureFlag>
             {
@@ -421,6 +422,125 @@ public void TestInit()
             Assert.IsTrue(TestData.CompareObjects(expectedRolloutIdMap, Config.RolloutIdMap));
         }
 
+        [Test]
+        public void TestFlagVariations()
+        {
+            var allVariations = Config?.FlagVariationMap;
+
+            var expectedVariations1 = new List<KeyValuePair<string, ICollection<Variation>>>();
+            var expectedVariationList = new List<Variation>
+            {
+                new Variation
+                {
+                    FeatureEnabled = true, Id = "177771",
+                    Key = "177771",
+                    FeatureVariableUsageInstances = new List<FeatureVariableUsage> { new FeatureVariableUsage { Id = "155556", Value="true" } }
+                },
+                new Variation 
+                { 
+                    FeatureEnabled = true, 
+                    Id = "177773", 
+                    Key = "177773", 
+                    FeatureVariableUsageInstances = new List<FeatureVariableUsage> 
+                    { 
+                        new FeatureVariableUsage 
+                        { 
+                            Id = "155556", 
+                            Value="false" 
+                        } 
+                    } 
+                },
+                new Variation 
+                { 
+                    FeatureEnabled = true, 
+                    Id = "177778", 
+                    Key = "177778", 
+                    FeatureVariableUsageInstances = new List<FeatureVariableUsage> 
+                    { 
+                        new FeatureVariableUsage 
+                        { 
+                            Id = "155556", Value="false" 
+                        } 
+                    } 
+                },
+                new Variation 
+                { 
+                    FeatureEnabled = false, 
+                    Id = "177782", 
+                    Key = "177782", 
+                    FeatureVariableUsageInstances = new List<FeatureVariableUsage> 
+                    { 
+                        new FeatureVariableUsage 
+                        { 
+                            Id = "155556", 
+                            Value="false" 
+                        } 
+                    } 
+                },
+                new Variation 
+                { 
+                    FeatureEnabled = false, 
+                    Id = "188881", 
+                    Key = "188881", 
+                    FeatureVariableUsageInstances = new List<FeatureVariableUsage> 
+                    { 
+                        new FeatureVariableUsage 
+                        { 
+                            Id = "155556", 
+                            Value= "false" 
+                        } 
+                    } 
+                },
+                new Variation 
+                { 
+                    FeatureEnabled = true, 
+                    Id = "177775",
+                    Key = "177775", 
+                    FeatureVariableUsageInstances = new List<FeatureVariableUsage> 
+                    { 
+                        new FeatureVariableUsage 
+                        { 
+                            Id = "155558", 
+                            Value= "cta_4" 
+                        }, 
+                        new FeatureVariableUsage 
+                        { 
+                            Id = "17014990011", 
+                            Value = "{\"int_var\": 4 , \"string_var\": \"cta_4\"}" 
+                        }, 
+                        new FeatureVariableUsage 
+                        { 
+                            Id = "170149900112", 
+                            Value = "{\"int_var\": 5 , \"string_var\": \"cta_5\"}" 
+                        } } },
+                new Variation 
+                { 
+                    FeatureEnabled = true, 
+                    Id = "177780", 
+                    Key = "177780", 
+                    FeatureVariableUsageInstances = new List<FeatureVariableUsage> { } 
+                },
+                new Variation 
+                { 
+                    FeatureEnabled = false, 
+                    Id = "177784", 
+                    Key = "177784", 
+                    FeatureVariableUsageInstances = new List<FeatureVariableUsage> 
+                    { 
+                        new FeatureVariableUsage 
+                        { 
+                            Id = "155558",
+                            Value= "cta_5" 
+                        } 
+                    } 
+                }
+            };
+            expectedVariations1.Add(new KeyValuePair<string, ICollection<Variation>>("boolean_feature", expectedVariationList));
+
+            var variations1 = allVariations.Where(v => v.Key == "boolean_feature");
+
+            Assertions.AreEquivalent(expectedVariations1, variations1);
+        }
 
         [Test]
         public void TestIfSendFlagDecisionKeyIsMissingItShouldReturnFalse()
@@ -446,7 +566,7 @@ public void TestGetGroupValidId()
         {
             var group = Config.GetGroup("7722400015");
             Assert.AreEqual("7722400015", group.Id);
-            Assert.AreEqual("random", group.Policy);            
+            Assert.AreEqual("random", group.Policy);
         }
 
         [Test]
@@ -458,7 +578,7 @@ public void TestGetGroupInvalidId()
             LoggerMock.Verify(l => l.Log(LogLevel.ERROR, @"Group ID ""invalid_id"" is not in datafile."));
 
             ErrorHandlerMock.Verify(e => e.HandleError(
-                It.Is<InvalidGroupException>(ex => ex.Message == "Provided group is not in datafile.")), 
+                It.Is<InvalidGroupException>(ex => ex.Message == "Provided group is not in datafile.")),
                 Times.Once, "Failed");
 
             Assert.IsTrue(TestData.CompareObjects(group, new Entity.Group()));
@@ -514,7 +634,6 @@ public void TestGetEventValidKey()
             Assert.AreEqual("7718020063", ev.Id);
 
             Assert.IsTrue(TestData.CompareObjects(new object[] { "7716830082", "7723330021", "7718750065", "7716830585" }, ev.ExperimentIds));
-
         }
 
         [Test]
@@ -563,7 +682,6 @@ public void TestGetAttributeValidKey()
         [Test]
         public void TestGetAttributeInvalidKey()
         {
-
             var attribute = Config.GetAttribute("invalid_key");
 
             LoggerMock.Verify(l => l.Log(It.IsAny<LogLevel>(), It.IsAny<string>()), Times.Once);
@@ -574,7 +692,7 @@ public void TestGetAttributeInvalidKey()
         }
 
         /// <summary>
-        /// EK = Experiment Key 
+        /// EK = Experiment Key
         /// VK = Variation Key
         /// </summary>
         [Test]
@@ -587,7 +705,7 @@ public void TestGetVariationFromKeyValidEKValidVK()
         }
 
         /// <summary>
-        /// EK = Experiment Key 
+        /// EK = Experiment Key
         /// VK = Variation Key
         /// </summary>
         [Test]
@@ -601,8 +719,6 @@ public void TestGetVariationFromKeyValidEKInvalidVK()
             ErrorHandlerMock.Verify(e => e.HandleError(It.Is<InvalidVariationException>(ex => ex.Message == "Provided variation is not in datafile.")));
 
             Assert.AreEqual(new Entity.Variation(), variation);
-
-
         }
 
         [Test]
@@ -620,7 +736,6 @@ public void TestGetVariationFromKeyInvalidEK()
         [Test]
         public void TestGetVariationFromIdValidEKValidVId()
         {
-
             var variation = Config.GetVariationFromId("test_experiment", "7722370027");
             Assert.AreEqual("control", variation.Key);
             Assert.AreEqual("7722370027", variation.Id);
@@ -629,7 +744,6 @@ public void TestGetVariationFromIdValidEKValidVId()
         [Test]
         public void TestGetVariationFromIdValidEKInvalidVId()
         {
-
             var variation = Config.GetVariationFromId("test_experiment", "invalid_id");
 
             LoggerMock.Verify(l => l.Log(It.IsAny<LogLevel>(), It.IsAny<string>()), Times.Once);
@@ -667,7 +781,6 @@ public void TestProjectConfigDatafileIsSame()
             Assert.AreEqual(config.ToDatafile(), TestData.Datafile);
         }
 
-
         // test set/get forced variation for the following cases:
         //      - valid and invalid user ID
         //      - valid and invalid experiment key
@@ -786,4 +899,4 @@ public void TestIsFeatureExperimentReturnsTrueForExperimentThatBelongsToAFeature
             Assert.True(typedConfig.IsFeatureExperiment(experiment.Id));
         }
     }
-}
+}
\ No newline at end of file
diff --git a/OptimizelySDK/Config/DatafileProjectConfig.cs b/OptimizelySDK/Config/DatafileProjectConfig.cs
index b9bbb1de..2fda13f7 100644
--- a/OptimizelySDK/Config/DatafileProjectConfig.cs
+++ b/OptimizelySDK/Config/DatafileProjectConfig.cs
@@ -20,6 +20,7 @@
 using OptimizelySDK.Logger;
 using OptimizelySDK.Utils;
 using System.Collections.Generic;
+using System.Linq;
 using Attribute = OptimizelySDK.Entity.Attribute;
 
 namespace OptimizelySDK.Config
@@ -194,6 +195,12 @@ private Dictionary<string, Dictionary<string, Variation>> _VariationIdMap
         /// </summary>
         private Dictionary<string, List<string>> ExperimentFeatureMap = new Dictionary<string, List<string>>();
 
+        /// <summary>
+        /// Associated array of flags to experiments
+        /// </summary>
+        
+        private Dictionary<string, ICollection<Variation>> _FlagVariationMap = new Dictionary<string, ICollection<Variation>>();
+        public Dictionary<string, ICollection<Variation>> FlagVariationMap { get { return _FlagVariationMap;  } }
 
         //========================= Interfaces ===========================
 
@@ -277,6 +284,8 @@ private void Initialize()
             _AudienceIdMap = ConfigParser<Audience>.GenerateMap(entities: Audiences, getKey: a => a.Id.ToString(), clone: true);
             _FeatureKeyMap = ConfigParser<FeatureFlag>.GenerateMap(entities: FeatureFlags, getKey: f => f.Key, clone: true);
             _RolloutIdMap = ConfigParser<Rollout>.GenerateMap(entities: Rollouts, getKey: r => r.Id.ToString(), clone: true);
+            _FlagVariationMap = GetFlagVariationMap();
+            
 
             // Overwrite similar items in audience id map with typed audience id map.
             var typedAudienceIdMap = ConfigParser<Audience>.GenerateMap(entities: TypedAudiences, getKey: a => a.Id.ToString(), clone: true);
@@ -355,6 +364,35 @@ private void Initialize()
             }
         }
 
+        private Dictionary<string, ICollection<Variation>> GetFlagVariationMap()
+        {
+            var map = new Dictionary<string, ICollection<Variation>>();
+            var variations = new List<Variation>();
+            var emptyArray = new List<Experiment>();
+
+            foreach (var flag in this.FeatureFlags)
+            {
+                this.RolloutIdMap.TryGetValue(flag.RolloutId, out var rollout);
+
+                var rules = rollout?.Experiments ?? emptyArray;
+
+                foreach(var rule in rules)
+                {
+                    foreach(var variation in rule.Variations)
+                    {
+                        if(!variations.Contains(variation))
+                        {
+                            variations.Add(variation);
+                        }
+                    }
+                }
+                map[flag.Key] = variations;
+            }
+
+            return map;
+        }
+
+
         /// <summary>
         /// Parse datafile string to create ProjectConfig instance.
         /// </summary>
diff --git a/OptimizelySDK/ProjectConfig.cs b/OptimizelySDK/ProjectConfig.cs
index f3bd51da..f85fbe09 100644
--- a/OptimizelySDK/ProjectConfig.cs
+++ b/OptimizelySDK/ProjectConfig.cs
@@ -122,6 +122,12 @@ public interface ProjectConfig
         /// </summary>
         Dictionary<string, Rollout> RolloutIdMap { get; }
 
+
+        /// <summary>
+        /// Associative array of Flag to Variation in the datafile
+        /// </summary>
+        Dictionary<string, ICollection<Variation>> FlagVariationMap { get; }
+
         //========================= Datafile Entities ===========================
 
         /// <summary>

From 482628c86da409adc3551664539d6d69402dc3e1 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Fri, 24 Sep 2021 11:59:30 -0400
Subject: [PATCH 002/130] Updated assertions, changed a few tests

---
 OptimizelySDK.Tests/Assertions.cs        | 68 ++++++++++++++++++++++++
 OptimizelySDK.Tests/ProjectConfigTest.cs |  8 +--
 2 files changed, 73 insertions(+), 3 deletions(-)

diff --git a/OptimizelySDK.Tests/Assertions.cs b/OptimizelySDK.Tests/Assertions.cs
index 84189c38..16b79bf2 100644
--- a/OptimizelySDK.Tests/Assertions.cs
+++ b/OptimizelySDK.Tests/Assertions.cs
@@ -16,6 +16,74 @@ namespace OptimizelySDK.Tests
     [ExcludeFromCodeCoverage]
     public class Assertions
     {
+        #region FeatureFlags
+        public static void AreEquivalent(Dictionary<string, FeatureFlag> expected, Dictionary<string, FeatureFlag> actual)
+        {
+            var zipped = expected.Zip(actual, (e, a) =>
+            {
+                return new
+                {
+                    Expected = e,
+                    Actual = a
+                };
+            }).ToList();
+
+            foreach (var z in zipped)
+            {
+                AreEqual(z.Expected, z.Actual);
+            }
+        }
+
+        public static void AreEqual(KeyValuePair<string, FeatureFlag> expected, KeyValuePair<string, FeatureFlag> actual)
+        {
+            Assert.AreEqual(expected.Key, actual.Key);
+            AreEqual(expected.Value, actual.Value);
+        }
+
+        public static void AreEqual(FeatureFlag expected, FeatureFlag actual)
+        {
+            Assert.AreEqual(expected.Id, actual.Id);
+            Assert.AreEqual(expected.Key, actual.Key);
+            Assert.AreEqual(expected.RolloutId, actual.RolloutId);
+            AreEquivalent(expected.VariableKeyToFeatureVariableMap, actual.VariableKeyToFeatureVariableMap);
+        }
+        #endregion
+
+        #region FeatureVariable
+        public static void AreEqual(FeatureVariable expected, FeatureVariable actual)
+        {
+            Assert.AreEqual(expected.Id, actual.Id);
+            Assert.AreEqual(expected.Key, actual.Key);
+            Assert.AreEqual(expected.DefaultValue, actual.DefaultValue);
+            Assert.AreEqual(expected.Status, actual.Status);
+            Assert.AreEqual(expected.SubType, actual.SubType);
+            Assert.AreEqual(expected.Type, actual.Type);
+        }
+
+        public static void AreEquivalent(Dictionary<string, FeatureVariable> expected, Dictionary<string, FeatureVariable> actual)
+        {
+            var zipped = expected.Zip(actual, (e, a) =>
+            {
+                return new
+                {
+                    Expected = e,
+                    Actual = a
+                };
+            }).ToList();
+
+            foreach (var z in zipped)
+            {
+                AreEquivalent(z.Expected, z.Actual);
+            }
+        }
+
+        public static void AreEquivalent(KeyValuePair<string, FeatureVariable> expected, KeyValuePair<string, FeatureVariable> actual)
+        {
+            Assert.AreEqual(expected.Key, actual.Key);
+            AreEqual(expected.Value, actual.Value);
+        }
+        #endregion
+
         #region Variations
         public static void AreEqual(Variation expected, Variation actual)
         {
diff --git a/OptimizelySDK.Tests/ProjectConfigTest.cs b/OptimizelySDK.Tests/ProjectConfigTest.cs
index 8f5f9814..86629de6 100644
--- a/OptimizelySDK.Tests/ProjectConfigTest.cs
+++ b/OptimizelySDK.Tests/ProjectConfigTest.cs
@@ -93,7 +93,7 @@ public void TestInit()
                 {"etag3",Config.GetExperimentFromKey("etag3") },
                 {"etag4",Config.GetExperimentFromKey("etag4") }
             };
-
+            
             Assert.IsTrue(TestData.CompareObjects(experimentKeyMap, Config.ExperimentKeyMap));
 
             // Check Experiment ID Map
@@ -393,7 +393,8 @@ public void TestInit()
             var expectedVariationUsage = new Variation { Id = "122231", Key = "Fred", FeatureVariableUsageInstances = featureVariableUsageInstance, FeatureEnabled = true };
             var actualVariationUsage = Config.GetVariationFromKey("test_experiment_multivariate", "Fred");
 
-            Assert.IsTrue(TestData.CompareObjects(expectedVariationUsage, actualVariationUsage));
+            Assertions.AreEqual(expectedVariationUsage, actualVariationUsage);
+            //Assert.IsTrue(TestData.CompareObjects(expectedVariationUsage, actualVariationUsage));
 
             // Check Feature Key map.
             var expectedFeatureKeyMap = new Dictionary<string, FeatureFlag>
@@ -410,7 +411,8 @@ public void TestInit()
                 { "unsupported_variabletype", Config.GetFeatureFlagFromKey("unsupported_variabletype") }
             };
 
-            Assert.IsTrue(TestData.CompareObjects(expectedFeatureKeyMap, Config.FeatureKeyMap));
+            Assertions.AreEquivalent(expectedFeatureKeyMap, Config.FeatureKeyMap);
+            //Assert.IsTrue(TestData.CompareObjects(expectedFeatureKeyMap, Config.FeatureKeyMap));
 
             // Check Feature Key map.
             var expectedRolloutIdMap = new Dictionary<string, Rollout>

From 97acb39f081038cc3577ea9834389976464f3539 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Fri, 24 Sep 2021 13:22:41 -0400
Subject: [PATCH 003/130] updated decision service tests to be easier to
 discover issues.

---
 OptimizelySDK.Tests/Assertions.cs          | 125 +++++++++++++++++++++
 OptimizelySDK.Tests/DecisionServiceTest.cs |   3 +-
 OptimizelySDK/Bucketing/DecisionService.cs |  11 +-
 3 files changed, 137 insertions(+), 2 deletions(-)

diff --git a/OptimizelySDK.Tests/Assertions.cs b/OptimizelySDK.Tests/Assertions.cs
index 16b79bf2..4a5dc0d8 100644
--- a/OptimizelySDK.Tests/Assertions.cs
+++ b/OptimizelySDK.Tests/Assertions.cs
@@ -16,6 +16,83 @@ namespace OptimizelySDK.Tests
     [ExcludeFromCodeCoverage]
     public class Assertions
     {
+        #region Basic asserts
+
+        public static void AreEquivalent(IEnumerable<string> expected, IEnumerable<string> actual)
+        {
+            Assert.AreEqual(expected.Count(), actual.Count());
+            var zipped = expected.Zip(actual, (e, a) =>
+            {
+                return new
+                {
+                    Expected = e,
+                    Actual = a
+                };
+            }).ToList();
+
+            foreach (var z in zipped)
+            {
+                Assert.AreEqual(z.Expected, z.Actual);
+            };
+        }
+
+        public static void AreEquivalent(Dictionary<string, string> expected, Dictionary<string, string> actual)
+        {
+            Assert.AreEqual(expected.Count, actual.Count);
+            var zipped = expected.Zip(actual, (e, a) =>
+            {
+                return new
+                {
+                    Expected = e,
+                    Actual = a
+                };
+            }).ToList();
+
+            foreach (var z in zipped)
+            {
+                AreEqual(z.Expected, z.Actual);
+            };
+        }
+
+        public static void AreEqual(KeyValuePair<string, string> expected, KeyValuePair<string, string> actual)
+        {
+            Assert.AreEqual(expected.Key, actual.Key);
+            Assert.AreEqual(expected.Value, actual.Value);
+        }
+        #endregion
+
+        #region Experiment
+        public static void AreEqual(Experiment expected, Experiment actual)
+        {
+            Assert.AreEqual(expected.AudienceConditions, actual.AudienceConditions);
+            Assert.AreEqual(expected.AudienceConditionsList, actual.AudienceConditionsList);
+            Assert.AreEqual(expected.AudienceConditionsString, actual.AudienceConditionsString);
+            AreEquivalent(expected.AudienceIds, actual.AudienceIds);
+            Assert.AreEqual(expected.AudienceIdsList, actual.AudienceIdsList);
+            Assert.AreEqual(expected.AudienceIdsString, actual.AudienceIdsString);
+            AreEquivalent(expected.ForcedVariations, actual.ForcedVariations);
+            Assert.AreEqual(expected.GroupId, actual.GroupId);
+            Assert.AreEqual(expected.GroupPolicy, actual.GroupPolicy);
+            Assert.AreEqual(expected.Id, actual.Id);
+            Assert.AreEqual(expected.IsExperimentRunning, actual.IsExperimentRunning);
+            Assert.AreEqual(expected.IsInMutexGroup, actual.IsInMutexGroup);
+            Assert.AreEqual(expected.Key, actual.Key);
+            Assert.AreEqual(expected.LayerId, actual.LayerId);
+            Assert.AreEqual(expected.Status, actual.Status);
+            AreEquivalent(expected.TrafficAllocation, actual.TrafficAllocation);
+            AreEquivalent(expected.UserIdToKeyVariations, actual.UserIdToKeyVariations);
+            AreEquivalent(expected.VariationIdToVariationMap, actual.VariationIdToVariationMap);
+            AreEquivalent(expected.VariationKeyToVariationMap, actual.VariationKeyToVariationMap);
+            AreEquivalent(expected.Variations, actual.Variations);
+        }
+        #endregion
+        #region FeatureDecision
+        public static void AreEqual(FeatureDecision expected, FeatureDecision actual)
+        {
+            AreEqual(expected.Experiment, actual.Experiment);
+        }
+        #endregion
+
         #region FeatureFlags
         public static void AreEquivalent(Dictionary<string, FeatureFlag> expected, Dictionary<string, FeatureFlag> actual)
         {
@@ -95,6 +172,30 @@ public static void AreEqual(Variation expected, Variation actual)
             AreEquivalent(expected.VariableIdToVariableUsageInstanceMap, actual.VariableIdToVariableUsageInstanceMap);
         }
 
+        public static void AreEquivalent(Dictionary<string, Variation> expected, Dictionary<string, Variation> actual)
+        {
+            Assert.AreEqual(expected.Count, actual.Count);
+            var zipped = expected.Zip(actual, (e, a) =>
+            {
+                return new
+                {
+                    Expected = e,
+                    Actual = a
+                };
+            }).ToList();
+
+            foreach (var z in zipped)
+            {
+                AreEqual(z.Expected, z.Actual);
+            };
+        }
+
+        public static void AreEqual(KeyValuePair<string, Variation> expected, KeyValuePair<string, Variation> actual)
+        {
+            Assert.AreEqual(expected.Key, actual.Key);
+            AreEqual(expected.Value, actual.Value);
+        }
+
         public static void AreEquivalent(IEnumerable<KeyValuePair<string, ICollection<Variation>>> expected, IEnumerable<KeyValuePair<string, ICollection<Variation>>> actual)
         {
             Assert.AreEqual(expected.Count(), actual.Count());
@@ -185,6 +286,30 @@ public static void AreEqual(FeatureVariableUsage expected, FeatureVariableUsage
         }
         #endregion
 
+        #region TrafficAllocation
+        public static void AreEquivalent(IEnumerable<TrafficAllocation> expected, IEnumerable<TrafficAllocation> actual)
+        {
+            Assert.AreEqual(expected.Count(), actual.Count());
+            var zipped = expected.Zip(actual, (e, a) =>
+            {
+                return new
+                {
+                    Expected = e,
+                    Actual = a
+                };
+            }).ToList();
+
+            foreach (var z in zipped)
+            {
+                Assert.AreEqual(z.Expected, z.Actual);
+            };
+        }
 
+        public static void AreEqual(TrafficAllocation expected, TrafficAllocation actual)
+        {
+            Assert.AreEqual(expected.EndOfRange, actual.EndOfRange);
+            Assert.AreEqual(expected.EntityId, actual.EntityId);
+        }
+        #endregion
     }
 }
diff --git a/OptimizelySDK.Tests/DecisionServiceTest.cs b/OptimizelySDK.Tests/DecisionServiceTest.cs
index 41353b7a..a5b2ff06 100644
--- a/OptimizelySDK.Tests/DecisionServiceTest.cs
+++ b/OptimizelySDK.Tests/DecisionServiceTest.cs
@@ -88,6 +88,7 @@ public void TestGetVariationForcedVariationPrecedesAudienceEval()
             Assert.IsTrue(TestData.CompareObjects(actualVariation.ResultObject, expectedVariation));
             BucketerMock.Verify(_ => _.Bucket(It.IsAny<ProjectConfig>(), It.IsAny<Experiment>(), It.IsAny<string>(), It.IsAny<string>()), Times.Never);
         }
+
         [Test]
         public void TestGetVariationLogsErrorWhenUserProfileMapItsNull()
         {
@@ -565,7 +566,7 @@ public void TestGetVariationForFeatureExperimentGivenMutexGroupAndUserIsBucketed
             var featureFlag = ProjectConfig.GetFeatureFlagFromKey("boolean_feature");
             var actualDecision = DecisionServiceMock.Object.GetVariationForFeatureExperiment(featureFlag, "user1", userAttributes, ProjectConfig, new OptimizelyDecideOption[] { });
 
-            Assert.IsTrue(TestData.CompareObjects(expectedDecision, actualDecision.ResultObject));
+            Assertions.AreEqual(expectedDecision, actualDecision.ResultObject);
 
             LoggerMock.Verify(l => l.Log(LogLevel.INFO, "The user \"user1\" is bucketed into experiment \"group_experiment_1\" of feature \"boolean_feature\"."));
         }
diff --git a/OptimizelySDK/Bucketing/DecisionService.cs b/OptimizelySDK/Bucketing/DecisionService.cs
index 46362440..b78578f9 100644
--- a/OptimizelySDK/Bucketing/DecisionService.cs
+++ b/OptimizelySDK/Bucketing/DecisionService.cs
@@ -186,6 +186,15 @@ public virtual Result<Variation> GetVariation(Experiment experiment,
             return Result<Variation>.NullResult(reasons);
         }
 
+        /// <summary>
+        /// Get a Variation of an Experiment from an Experiment Rule
+        /// </summary>
+        /// 
+        public virtual Result<Variation> GetVariationFromExperimentRule(ProjectConfig config, string flagKey, Experiment rule, OptimizelyUserContext userContext, OptimizelyDecideOption[] options)
+        {
+            return new Result<Variation>();
+        }
+
         /// <summary>
         /// Gets the forced variation for the given user and experiment.  
         /// </summary>
@@ -532,7 +541,7 @@ public virtual Result<FeatureDecision> GetVariationForFeatureExperiment(FeatureF
                 if (string.IsNullOrEmpty(experiment.Key))
                     continue;
 
-                var variationResult = GetVariation(experiment, userId, config, filteredAttributes, options);
+                var variationResult = GetVariation(experiment, userId, config, filteredAttributes, options); //GetVariationFromExperimentRule(config, featureFlag.Key, experiment, null, options);
                 reasons += variationResult.DecisionReasons;
 
                 if (!string.IsNullOrEmpty(variationResult.ResultObject?.Id))

From c097e89e4935ce6573eacc09f9ae914df3b27244 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Sun, 26 Sep 2021 18:30:09 -0400
Subject: [PATCH 004/130] Test update

---
 OptimizelySDK.Tests/DecisionServiceTest.cs | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/OptimizelySDK.Tests/DecisionServiceTest.cs b/OptimizelySDK.Tests/DecisionServiceTest.cs
index a5b2ff06..3a5971c2 100644
--- a/OptimizelySDK.Tests/DecisionServiceTest.cs
+++ b/OptimizelySDK.Tests/DecisionServiceTest.cs
@@ -84,8 +84,10 @@ public void TestGetVariationForcedVariationPrecedesAudienceEval()
             var actualVariation = decisionService.GetVariation(experiment, WhitelistedUserId, ProjectConfig, new UserAttributes());
 
             LoggerMock.Verify(l => l.Log(LogLevel.INFO, string.Format("User \"{0}\" is forced in variation \"vtag5\".", WhitelistedUserId)), Times.Once);
+            
             // no attributes provided for a experiment that has an audience
-            Assert.IsTrue(TestData.CompareObjects(actualVariation.ResultObject, expectedVariation));
+            Assertions.AreEqual(expectedVariation, actualVariation.ResultObject);
+            
             BucketerMock.Verify(_ => _.Bucket(It.IsAny<ProjectConfig>(), It.IsAny<Experiment>(), It.IsAny<string>(), It.IsAny<string>()), Times.Never);
         }
 
@@ -214,7 +216,9 @@ public void TestBucketReturnsVariationStoredInUserProfile()
 
             DecisionService decisionService = new DecisionService(BucketerMock.Object, ErrorHandlerMock.Object, UserProfileServiceMock.Object, LoggerMock.Object);
             var actualVariation = decisionService.GetVariation(experiment, UserProfileId, ProjectConfig, new UserAttributes());
-            Assert.IsTrue(TestData.CompareObjects(variation, actualVariation.ResultObject));
+
+            Assertions.AreEqual(variation, actualVariation.ResultObject);
+            
             Assert.AreEqual(actualVariation.DecisionReasons.ToReport(true).Count, 1);
             Assert.AreEqual(actualVariation.DecisionReasons.ToReport(true)[0], "Returning previously activated variation \"vtag1\" of experiment \"etag1\" for user \"userProfileId\" from user profile.");
 
@@ -349,7 +353,10 @@ public void TestGetVariationSavesANewUserProfile()
             DecisionService decisionService = new DecisionService(mockBucketer.Object, ErrorHandlerMock.Object,
                 UserProfileServiceMock.Object, LoggerMock.Object);
 
-            Assert.IsTrue(TestData.CompareObjects(variation, decisionService.GetVariation(experiment, UserProfileId, ProjectConfig, new UserAttributes())));
+            var actualVariation = decisionService.GetVariation(experiment, UserProfileId, ProjectConfig, new UserAttributes());
+
+            Assertions.AreEqual(variation.ResultObject, actualVariation.ResultObject);
+
             UserProfileServiceMock.Verify(_ => _.Save(It.IsAny<Dictionary<string, object>>()), Times.Once);
         }
 
@@ -378,13 +385,14 @@ public void TestGetVariationUserWithSetForcedVariation()
             Assert.IsTrue(optlyObject.SetForcedVariation(experimentKey, userId, expectedForcedVariationKey), string.Format(@"Set variation to ""{0}"" failed.", expectedForcedVariationKey));
 
             var actualForcedVariation = optlyObject.GetVariation(experimentKey, userId, userAttributes);
-            Assert.IsTrue(TestData.CompareObjects(VariationWithKeyVariation, actualForcedVariation));
+
+            Assertions.AreEqual(VariationWithKeyVariation, actualForcedVariation);
 
             // clear forced variation and confirm that normal bucketing occurs
             Assert.IsTrue(optlyObject.SetForcedVariation(experimentKey, userId, null));
 
             actualVariation = optlyObject.GetVariation(experimentKey, userId, userAttributes);
-            Assert.IsTrue(TestData.CompareObjects(VariationWithKeyControl, actualVariation));
+            Assertions.AreEqual(VariationWithKeyControl, actualVariation);
 
             // check that a paused experiment returns null
             Assert.IsTrue(optlyObject.SetForcedVariation(pausedExperimentKey, userId, expectedForcedVariationKey), string.Format(@"Set variation to ""{0}"" failed.", expectedForcedVariationKey));

From d23fcd07ad0635a08af161bb343397a6c8fe7b55 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Tue, 5 Oct 2021 11:15:31 -0400
Subject: [PATCH 005/130] Updated Usercontext tests

---
 OptimizelySDK.Tests/Assertions.cs             |  64 ++++++----
 OptimizelySDK.Tests/DecisionServiceTest.cs    |   3 +-
 .../OptimizelyUserContextTest.cs              |  72 +++++++++++
 OptimizelySDK/Entity/Variation.cs             |   1 +
 OptimizelySDK/OptimizelyUserContext.cs        | 117 ++++++++++++++++++
 5 files changed, 235 insertions(+), 22 deletions(-)

diff --git a/OptimizelySDK.Tests/Assertions.cs b/OptimizelySDK.Tests/Assertions.cs
index 4a5dc0d8..fac8c160 100644
--- 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
index 3a5971c2..c5b29001 100644
--- 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
index 6d9630ca..91bffaaf 100644
--- 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("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
index dbc099e9..4d4bf647 100644
--- 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
index 5c6f97cb..5fd05982 100644
--- 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, null, 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;
+        }
     }
 }

From 3abb3e59e53331c7a861603adc00bae08dbf03ba Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Tue, 5 Oct 2021 11:17:37 -0400
Subject: [PATCH 006/130] Corrected a few missing tests/functionality

---
 .../OptimizelyUserContextTest.cs              | 13 ++++++++
 OptimizelySDK/OptimizelyUserContext.cs        | 33 ++++++++++++++-----
 2 files changed, 37 insertions(+), 9 deletions(-)

diff --git a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
index 91bffaaf..605cd0e8 100644
--- a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
@@ -234,6 +234,19 @@ public void GetForcedDecisionReturnsValueWithoutRuleKey()
             Assert.AreEqual("variation", result);
         }
 
+        [Test]
+
+        public void GetForcedDecisionReturnsValueWithOnlyFlagKey()
+        {
+            var user = Optimizely.CreateUserContext(UserID);
+
+            user.SetForcedDecision("flag", "variation");
+
+            var result = user.GetForcedDecision("flag");
+
+            Assert.AreEqual("variation", result);
+        }
+
         [Test]
         public void FindForcedDecisionReturnsValueWithoutRuleKey()
         {
diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index 5fd05982..c06d9360 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -261,12 +261,27 @@ public bool SetForcedDecision(string flagKey, string ruleKey, string variationKe
         }
 
         /// <summary>
-        /// 
+        /// Finds a forced variation
         /// </summary>
-        /// <param name="String"></param>
-        /// <param name=""></param>
-        /// <param name="ruleKey"></param>
-        /// <returns></returns>
+        /// <param name="flagKey">The flag key</param>
+        /// <returns>The variation key for a forced decision</returns>
+        public string GetForcedDecision(string flagKey)
+        {
+            if (Optimizely.GetOptimizelyConfig() == null)
+            {
+                Logger.Log(LogLevel.ERROR, "Optimizely SDK not ready.");
+                return null;
+            }
+
+            return FindForcedDecision(flagKey, null);
+        }
+
+        /// <summary>
+        /// Finds a forced variation
+        /// </summary>
+        /// <param name="flagKey">The flag key</param>
+        /// <param name="ruleKey">The rule key</param>
+        /// <returns>The variation key for a forced decision</returns>
         public string GetForcedDecision(string flagKey, string ruleKey)
         {
             if (Optimizely.GetOptimizelyConfig() == null)
@@ -279,11 +294,11 @@ public string GetForcedDecision(string flagKey, string ruleKey)
         }
 
         /// <summary>
-        /// 
+        /// Finds a forced variation
         /// </summary>
-        /// <param name="flagKey"></param>
-        /// <param name="ruleKey"></param>
-        /// <returns></returns>
+        /// <param name="flagKey">The flag key</param>
+        /// <param name="ruleKey">The rule key</param>
+        /// <returns>The variation key for a forced decision</returns>
         public string FindForcedDecision(string flagKey, string ruleKey)
         {
             string variationKey = null;

From dd50814eb50dee1efe1f01ada7b3ea6e32d40217 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Tue, 5 Oct 2021 11:31:42 -0400
Subject: [PATCH 007/130] Added more functionality

---
 .../OptimizelyUserContextTest.cs              | 32 +++++++++-
 OptimizelySDK/OptimizelyUserContext.cs        | 60 +++++++++++++++++++
 2 files changed, 91 insertions(+), 1 deletion(-)

diff --git a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
index 605cd0e8..83b67799 100644
--- a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
@@ -197,7 +197,7 @@ public void SetForcedDecisionSetsValue()
         }
 
         [Test]
-        public void SetForcedDecisionReturnsFalseAndLogErrorForNullConfig()
+        public void SetForcedDecisionReturnsFalseForNullConfig()
         {
             var optly = new Optimizely(new FallbackProjectConfigManager(null));
            
@@ -271,6 +271,36 @@ public void FindForcedDecisionReturnsValueWithRuleKey()
             Assert.AreEqual("variation", result);
         }
 
+        [Test]
+        public void RemoveForcedDecisionRemovesDecision()
+        {
+            var user = Optimizely.CreateUserContext(UserID);
+
+            user.SetForcedDecision("flag", "rule", "variation");
+
+            user.RemoveForcedDecision("flag", "rule");
+
+            var result = user.FindForcedDecision("flag", "rule");
+
+            Assert.AreEqual(null, result);
+
+        }
+
+        [Test]
+        public void RemoveForcedDecisionReturnsFalseForNullConfig()
+        {
+            var optly = new Optimizely(new FallbackProjectConfigManager(null));
+
+
+            var user = optly.CreateUserContext(UserID);
+            user.SetForcedDecision("flag", "variation");
+
+            var result = user.RemoveForcedDecision("flag", null);
+
+            Assert.AreEqual(false, result);
+            
+        }
+
         [Test]
         public void DecideInvalidFlagKey()
         {
diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index c06d9360..5b893d3c 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -19,6 +19,7 @@
 using OptimizelySDK.ErrorHandler;
 using OptimizelySDK.Entity;
 using OptimizelySDK.OptimizelyDecisions;
+using System;
 
 namespace OptimizelySDK
 {
@@ -321,5 +322,64 @@ public string FindForcedDecision(string flagKey, string ruleKey)
             }
             return variationKey;
         }
+
+        /**
+    * Remove a forced decision
+    *
+    * @param flagKey The flag key in the forced decision
+    * @return Returns a boolean of true if successful, otherwise false
+    */
+        public bool RemoveForcedDecision(string flagKey)
+        {
+            return RemoveForcedDecision(flagKey, null);
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="flagKey"></param>
+        /// <param name="ruleKey"></param>
+        /// <returns></returns>
+        public bool RemoveForcedDecision(string flagKey, string ruleKey)
+        {
+            if (Optimizely.GetOptimizelyConfig() == null)
+            {
+                Logger.Log(LogLevel.ERROR, "Optimizely SDK not ready.");
+                return false;
+            }
+            if (ruleKey != null)
+            {
+                ForcedDecisionsMap.TryGetValue(flagKey, out var decision);
+                decision.Remove(ruleKey);
+                if (decision.Count == 0)
+                {
+                    ForcedDecisionsMap.Remove(flagKey);
+                }
+                return true;
+            }
+            else
+            {
+                
+                ForcedDecisionsMapWithNoRuleKey.Remove(flagKey);
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <returns></returns>
+        public bool RemoveAllForcedDecisions()
+        {
+            if (Optimizely.GetOptimizelyConfig() == null)
+            {
+                Logger.Log(LogLevel.ERROR, "Optimizely SDK not ready.");
+                return false;
+            }
+            // Clear both maps for with and without ruleKey
+            ForcedDecisionsMap.Clear();
+            ForcedDecisionsMapWithNoRuleKey.Clear();
+            return true;
+        }
     }
 }

From 973f24dc085042773ecd5cabdc40300dbb296661 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Tue, 5 Oct 2021 11:37:54 -0400
Subject: [PATCH 008/130] Added remove all tests

---
 .../OptimizelyUserContextTest.cs              | 36 +++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
index 83b67799..1f430b78 100644
--- a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
@@ -301,6 +301,42 @@ public void RemoveForcedDecisionReturnsFalseForNullConfig()
             
         }
 
+        [Test]
+        public void RemoveAllForcedDecisionsRemovesDecisions()
+        {
+            var user = Optimizely.CreateUserContext(UserID);
+
+            user.SetForcedDecision("flag", "rule", "variation");
+            user.SetForcedDecision("flag2", "rule2", "variation2");
+            user.SetForcedDecision("flag3", "rule3", "variation3");
+
+            user.RemoveAllForcedDecisions();
+
+            var result1 = user.GetForcedDecision("flag", null);
+            Assert.AreEqual(null, result1);
+            
+            var result2 = user.GetForcedDecision("flag2", null);
+            Assert.AreEqual(null, result2);
+
+            var result3 = user.GetForcedDecision("flag3", null);
+            Assert.AreEqual(null, result3);
+        }
+
+        [Test]
+        public void RemoveAllForcedDecisionsReturnsFalseForNullConfig()
+        {
+            var optly = new Optimizely(new FallbackProjectConfigManager(null));
+
+
+            var user = optly.CreateUserContext(UserID);
+            user.SetForcedDecision("flag", "variation");
+
+            var result = user.RemoveAllForcedDecisions();
+
+            Assert.AreEqual(false, result);
+
+        }
+
         [Test]
         public void DecideInvalidFlagKey()
         {

From 474718644bb787f3931ce7b31dd4e2379aee14e7 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Tue, 5 Oct 2021 16:21:17 -0400
Subject: [PATCH 009/130] space removed

---
 OptimizelySDK.Tests/OptimizelyUserContextTest.cs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
index 1f430b78..2b6266d3 100644
--- a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
@@ -334,7 +334,6 @@ public void RemoveAllForcedDecisionsReturnsFalseForNullConfig()
             var result = user.RemoveAllForcedDecisions();
 
             Assert.AreEqual(false, result);
-
         }
 
         [Test]

From 3b3070c0fabf3e36b50e0f933071ab2653dac54c Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Fri, 8 Oct 2021 08:29:56 -0400
Subject: [PATCH 010/130] cleaned up test/fixed test

---
 OptimizelySDK.Tests/Assertions.cs             |  44 +++--
 .../OptimizelyConfigTest.cs                   | 186 ++++++++++++++++--
 OptimizelySDK.Tests/ProjectConfigTest.cs      |   6 +-
 OptimizelySDK/Bucketing/DecisionService.cs    |   9 -
 OptimizelySDK/Config/DatafileProjectConfig.cs |   8 +-
 OptimizelySDK/IOptimizely.cs                  |   8 +
 OptimizelySDK/Optimizely.cs                   |  18 +-
 OptimizelySDK/OptimizelyUserContext.cs        |  81 +++++++-
 OptimizelySDK/OptlyConfig/OptimizelyConfig.cs |  17 ++
 .../OptlyConfig/OptimizelyConfigService.cs    |   7 +
 OptimizelySDK/ProjectConfig.cs                |   2 +-
 11 files changed, 331 insertions(+), 55 deletions(-)

diff --git a/OptimizelySDK.Tests/Assertions.cs b/OptimizelySDK.Tests/Assertions.cs
index fac8c160..c48c86ab 100644
--- a/OptimizelySDK.Tests/Assertions.cs
+++ b/OptimizelySDK.Tests/Assertions.cs
@@ -98,6 +98,7 @@ public static void AreEqual(Experiment expected, Experiment actual)
             AreEquivalent(expected.Variations, actual.Variations);
         }
         #endregion
+
         #region FeatureDecision
         public static void AreEqual(FeatureDecision expected, FeatureDecision actual)
         {
@@ -204,16 +205,27 @@ public static void AreEquivalent(Dictionary<string, Variation> expected, Diction
             };
         }
 
-        public static void AreEqual(KeyValuePair<string, Variation> expected, KeyValuePair<string, Variation> actual)
+        public static void AreEquivalent(List<Dictionary<string, List<Variation>>> expected, List<Dictionary<string, List<Variation>>> actual)
         {
-            Assert.AreEqual(expected.Key, actual.Key);
-            AreEqual(expected.Value, actual.Value);
+            Assert.AreEqual(expected.Count, actual.Count);
+            var zipped = expected.Zip(actual, (e, a) =>
+            {
+                return new
+                {
+                    Expected = e,
+                    Actual = a
+                };
+            }).ToList();
+
+            foreach (var z in zipped)
+            {
+                AreEquivalent(z.Expected, z.Actual);
+            };
         }
 
-        public static void AreEquivalent(IEnumerable<KeyValuePair<string, ICollection<Variation>>> expected, IEnumerable<KeyValuePair<string, ICollection<Variation>>> actual)
+        public static void AreEquivalent(Dictionary<string, List<Variation>> expected, Dictionary<string, List<Variation>> actual)
         {
-            Assert.AreEqual(expected.Count(), actual.Count());
-
+            Assert.AreEqual(expected.Count, actual.Count);
             var zipped = expected.Zip(actual, (e, a) =>
             {
                 return new
@@ -223,19 +235,29 @@ public static void AreEquivalent(IEnumerable<KeyValuePair<string, ICollection<Va
                 };
             }).ToList();
 
-            foreach(var z in zipped)
+            foreach (var z in zipped)
             {
-                AreEquivalent(z.Expected, z.Actual);
-            }
+                AreEqual(z.Expected, z.Actual);
+            };
         }
 
-        public static void AreEquivalent(KeyValuePair<string, ICollection<Variation>> expected, KeyValuePair<string, ICollection<Variation>> actual)
+        public static void AreEqual(KeyValuePair<string, Variation> expected, KeyValuePair<string, Variation> actual)
         {
             Assert.AreEqual(expected.Key, actual.Key);
-            AreEquivalent(expected.Value, actual.Value);
+            AreEqual(expected.Value, actual.Value);
         }
 
+        public static void AreEqual(KeyValuePair<string, List<Variation>> expected, KeyValuePair<string, List<Variation>> actual)
+        {
+            Assert.AreEqual(expected.Key, actual.Key);
+            AreEquivalent(expected.Value, actual.Value);
+        }
 
+        public static void AreEquivalent(KeyValuePair<string, List<Variation>> expected, KeyValuePair<string, List<Variation>> actual)
+        {
+            Assert.AreEqual(expected.Key, actual.Key);
+            AreEquivalent(expected.Value, actual.Value);
+        }
 
         public static void AreEquivalent(IEnumerable<Variation> expected, IEnumerable<Variation> actual)
         {
diff --git a/OptimizelySDK.Tests/OptimizelyConfigTests/OptimizelyConfigTest.cs b/OptimizelySDK.Tests/OptimizelyConfigTests/OptimizelyConfigTest.cs
index b03f6bef..752d2d16 100644
--- a/OptimizelySDK.Tests/OptimizelyConfigTests/OptimizelyConfigTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyConfigTests/OptimizelyConfigTest.cs
@@ -1,4 +1,4 @@
-/* 
+/*
  * Copyright 2020-2021, Optimizely
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -14,23 +14,22 @@
  * limitations under the License.
  */
 
-using System;
 using Moq;
+using Newtonsoft.Json.Linq;
 using NUnit.Framework;
 using OptimizelySDK.Config;
+using OptimizelySDK.Entity;
 using OptimizelySDK.Logger;
 using OptimizelySDK.OptlyConfig;
-using System.Collections.Generic;
-using System.Threading;
 using OptimizelySDK.Tests.UtilsTests;
-using Newtonsoft.Json.Linq;
+using System;
+using System.Collections.Generic;
 
 namespace OptimizelySDK.Tests.OptimizelyConfigTests
 {
     [TestFixture]
     public class OptimizelyConfigTest
     {
-
         private Mock<ILogger> LoggerMock;
 
         [SetUp]
@@ -42,7 +41,7 @@ public void Setup()
 
         #region Test OptimizelyConfigService
 
-        static Type[] ParameterTypes = {
+        private static Type[] ParameterTypes = {
                 typeof(ProjectConfig),
             };
 
@@ -76,10 +75,9 @@ public void TestGetOptimizelyConfigServiceSerializedAudiences()
                 new List<object>() { "not", new JArray() { "and", "3468206642", "3988293898" } },
                 new List<object>() { },
                 new List<object>() { "or", "3468206642", "999999999" },
-
             };
 
-            var expectedAudienceOutputs = new List<string> 
+            var expectedAudienceOutputs = new List<string>
             {
                 "\"exactString\" OR \"substringString\"",
                 "\"exactString\" OR \"substringString\" OR \"exactNumber\"",
@@ -147,7 +145,6 @@ public void TestGetOptimizelyConfigWithDuplicateExperimentKeys()
             var experimentMapFlag2 = optimizelyConfig.FeaturesMap["flag2"].ExperimentsMap; // 9300000007573
             Assert.AreEqual(experimentMapFlag1["targeted_delivery"].Id, "9300000007569");
             Assert.AreEqual(experimentMapFlag2["targeted_delivery"].Id, "9300000007573");
-
         }
 
         [Test]
@@ -158,7 +155,7 @@ public void TestGetOptimizelyConfigWithDuplicateRuleKeys()
             var optimizelyConfig = optimizelyConfigService.GetOptimizelyConfig();
             Assert.AreEqual(optimizelyConfig.ExperimentsMap.Count, 0);
 
-            var rolloutFlag1 = optimizelyConfig.FeaturesMap["flag_1"].DeliveryRules[0]; // 9300000004977, 
+            var rolloutFlag1 = optimizelyConfig.FeaturesMap["flag_1"].DeliveryRules[0]; // 9300000004977,
             var rolloutFlag2 = optimizelyConfig.FeaturesMap["flag_2"].DeliveryRules[0]; // 9300000004979
             var rolloutFlag3 = optimizelyConfig.FeaturesMap["flag_3"].DeliveryRules[0]; // 9300000004981
             Assert.AreEqual(rolloutFlag1.Id, "9300000004977");
@@ -167,7 +164,6 @@ public void TestGetOptimizelyConfigWithDuplicateRuleKeys()
             Assert.AreEqual(rolloutFlag2.Key, "targeted_delivery");
             Assert.AreEqual(rolloutFlag3.Id, "9300000004981");
             Assert.AreEqual(rolloutFlag3.Key, "targeted_delivery");
-
         }
 
         [Test]
@@ -185,6 +181,156 @@ public void TestGetOptimizelyConfigSDKAndEnvironmentKeyDefault()
         public void TestGetOptimizelyConfigService()
         {
             var datafileProjectConfig = DatafileProjectConfig.Create(TestData.TypedAudienceDatafile, new NoOpLogger(), new ErrorHandler.NoOpErrorHandler());
+            var expectedflagVariations = new Dictionary<string, List<Variation>> {
+                {
+                    "feat_no_vars",
+                    new List<Variation> {
+                        new Variation
+                        {
+                            FeatureEnabled = true,
+                            FeatureVariableUsageInstances = new List<FeatureVariableUsage>(),
+                            Key = "11557362669",
+                            Id = "11557362669",
+                            VariableIdToVariableUsageInstanceMap = new Dictionary<string, FeatureVariableUsage>()
+                        },
+                        new Variation
+                        {
+                            FeatureEnabled = false,
+                            FeatureVariableUsageInstances = new List<FeatureVariableUsage>(),
+                            Key = "11475708558",
+                            Id = "11475708558",
+                            VariableIdToVariableUsageInstanceMap = new Dictionary<string, FeatureVariableUsage>()
+                        },
+                        new Variation
+                        {
+                            FeatureEnabled = true,
+                            FeatureVariableUsageInstances = new List<FeatureVariableUsage>(),
+                            Key = "11557362670",
+                            Id = "11557362670",
+                            VariableIdToVariableUsageInstanceMap = new Dictionary<string, FeatureVariableUsage>()
+                        },
+                        new Variation
+                        {
+                            FeatureEnabled = false,
+                            FeatureVariableUsageInstances = new List<FeatureVariableUsage>(),
+                            Key = "11475708559",
+                            Id = "11475708559",
+                            VariableIdToVariableUsageInstanceMap = new Dictionary<string, FeatureVariableUsage>()
+                        }
+                    }
+                },
+                {
+                    "feat_with_var",
+                    new List<Variation> {
+                        new Variation
+                        {
+                            FeatureEnabled = true,
+                            FeatureVariableUsageInstances = new List<FeatureVariableUsage>(),
+                            Key = "11557362669",
+                            Id = "11557362669",
+                            VariableIdToVariableUsageInstanceMap = new Dictionary<string, FeatureVariableUsage>()
+                        },
+                        new Variation
+                        {
+                            FeatureEnabled = false,
+                            FeatureVariableUsageInstances = new List<FeatureVariableUsage>(),
+                            Key = "11475708558",
+                            Id = "11475708558",
+                            VariableIdToVariableUsageInstanceMap = new Dictionary<string, FeatureVariableUsage>()
+                        },
+                        new Variation
+                        {
+                            FeatureEnabled = true,
+                            FeatureVariableUsageInstances = new List<FeatureVariableUsage>(),
+                            Key = "11557362670",
+                            Id = "11557362670",
+                            VariableIdToVariableUsageInstanceMap = new Dictionary<string, FeatureVariableUsage>()
+                        },
+                        new Variation
+                        {
+                            FeatureEnabled = false,
+                            FeatureVariableUsageInstances = new List<FeatureVariableUsage>(),
+                            Key = "11475708559",
+                            Id = "11475708559",
+                            VariableIdToVariableUsageInstanceMap = new Dictionary<string, FeatureVariableUsage>()
+                        }
+                    }
+                },
+                {
+                    "feat2",
+                    new List<Variation> {
+                        new Variation
+                        {
+                            FeatureEnabled = true,
+                            FeatureVariableUsageInstances = new List<FeatureVariableUsage>(),
+                            Key = "11557362669",
+                            Id = "11557362669",
+                            VariableIdToVariableUsageInstanceMap = new Dictionary<string, FeatureVariableUsage>()
+                        },
+                        new Variation
+                        {
+                            FeatureEnabled = false,
+                            FeatureVariableUsageInstances = new List<FeatureVariableUsage>(),
+                            Key = "11475708558",
+                            Id = "11475708558",
+                            VariableIdToVariableUsageInstanceMap = new Dictionary<string, FeatureVariableUsage>()
+                        },
+                        new Variation
+                        {
+                            FeatureEnabled = true,
+                            FeatureVariableUsageInstances = new List<FeatureVariableUsage>(),
+                            Key = "11557362670",
+                            Id = "11557362670",
+                            VariableIdToVariableUsageInstanceMap = new Dictionary<string, FeatureVariableUsage>()
+                        },
+                        new Variation
+                        {
+                            FeatureEnabled = false,
+                            FeatureVariableUsageInstances = new List<FeatureVariableUsage>(),
+                            Key = "11475708559",
+                            Id = "11475708559",
+                            VariableIdToVariableUsageInstanceMap = new Dictionary<string, FeatureVariableUsage>()
+                        }
+                    }
+                },
+                {
+                    "feat2_with_var",
+                    new List<Variation> {
+                        new Variation
+                        {
+                            FeatureEnabled = true,
+                            FeatureVariableUsageInstances = new List<FeatureVariableUsage>(),
+                            Key = "11557362669",
+                            Id = "11557362669",
+                            VariableIdToVariableUsageInstanceMap = new Dictionary<string, FeatureVariableUsage>()
+                        },
+                        new Variation
+                        {
+                            FeatureEnabled = false,
+                            FeatureVariableUsageInstances = new List<FeatureVariableUsage>(),
+                            Key = "11475708558",
+                            Id = "11475708558",
+                            VariableIdToVariableUsageInstanceMap = new Dictionary<string, FeatureVariableUsage>()
+                        },
+                        new Variation
+                        {
+                            FeatureEnabled = true,
+                            FeatureVariableUsageInstances = new List<FeatureVariableUsage>(),
+                            Key = "11557362670",
+                            Id = "11557362670",
+                            VariableIdToVariableUsageInstanceMap = new Dictionary<string, FeatureVariableUsage>()
+                        },
+                        new Variation
+                        {
+                            FeatureEnabled = false,
+                            FeatureVariableUsageInstances = new List<FeatureVariableUsage>(),
+                            Key = "11475708559",
+                            Id = "11475708559",
+                            VariableIdToVariableUsageInstanceMap = new Dictionary<string, FeatureVariableUsage>()
+                        }
+                    }
+                }
+            };
             IDictionary<string, OptimizelyExperiment> experimentsMap = new Dictionary<string, OptimizelyExperiment>
             {
                 {
@@ -275,7 +421,6 @@ public void TestGetOptimizelyConfigService()
                 }
             };
 
-
             var featuresMap = new Dictionary<string, OptimizelyFeature>
             {
                 {
@@ -542,7 +687,7 @@ public void TestGetOptimizelyConfigService()
                     new OptimizelyAudience("3988293898", "substringString", "[\"and\",[\"or\",[\"or\",{\"name\":\"house\",\"type\":\"custom_attribute\",\"match\":\"substring\",\"value\":\"Slytherin\"}]]]"),
                 },
                 events: new OptimizelyEvent[]
-                { 
+                {
                     new OptimizelyEvent()
                     {
                        Id = "594089", Key = "item_bought", ExperimentIds = new string[] { "11564051718", "1323241597" }
@@ -554,13 +699,15 @@ public void TestGetOptimizelyConfigService()
                 },
                 experimentsMap: experimentsMap,
                 featuresMap: featuresMap,
+                flagToVariationMap: expectedflagVariations,
                 datafile: TestData.TypedAudienceDatafile);
+
             Assert.IsTrue(TestData.CompareObjects(optimizelyConfig, expectedOptimizelyConfig));
         }
 
-        #endregion
+        #endregion Test OptimizelyConfigService
 
-            #region OptimizelyConfig entity tests
+        #region OptimizelyConfig entity tests
 
         [Test]
         public void TestOptimizelyConfigEntity()
@@ -572,7 +719,8 @@ public void TestOptimizelyConfigEntity()
                 audiences: new OptimizelyAudience[0],
                 events: new OptimizelyEvent[0],
                 experimentsMap: new Dictionary<string, OptimizelyExperiment>(),
-                featuresMap: new Dictionary<string, OptimizelyFeature>()
+                featuresMap: new Dictionary<string, OptimizelyFeature>(),
+                flagToVariationMap: new Dictionary<string, List<Variation>>()
                 );
             Assert.AreEqual(expectedOptlyFeature.Revision, "123");
             Assert.AreEqual(expectedOptlyFeature.SDKKey, "testSdkKey");
@@ -640,6 +788,6 @@ public void TestOptimizelyVariableEntity()
             Assert.AreEqual(expectedOptlyVariable.Value, "2");
         }
 
-        #endregion
+        #endregion OptimizelyConfig entity tests
     }
-}
+}
\ No newline at end of file
diff --git a/OptimizelySDK.Tests/ProjectConfigTest.cs b/OptimizelySDK.Tests/ProjectConfigTest.cs
index 86629de6..f4a98aa2 100644
--- a/OptimizelySDK.Tests/ProjectConfigTest.cs
+++ b/OptimizelySDK.Tests/ProjectConfigTest.cs
@@ -429,7 +429,7 @@ public void TestFlagVariations()
         {
             var allVariations = Config?.FlagVariationMap;
 
-            var expectedVariations1 = new List<KeyValuePair<string, ICollection<Variation>>>();
+            var expectedVariations1 = new List<Dictionary<string, List<Variation>>>();
             var expectedVariationList = new List<Variation>
             {
                 new Variation
@@ -537,9 +537,9 @@ public void TestFlagVariations()
                     } 
                 }
             };
-            expectedVariations1.Add(new KeyValuePair<string, ICollection<Variation>>("boolean_feature", expectedVariationList));
+            expectedVariations1.Add(new Dictionary<string, List<Variation>> { { "boolean_feature", expectedVariationList } });
 
-            var variations1 = allVariations.Where(v => v.Key == "boolean_feature");
+            var variations1 = allVariations.Where(v => v.Key == "boolean_feature").Select(v => new Dictionary<string, List<Variation>> { { v.Key, v.Value } }).ToList();
 
             Assertions.AreEquivalent(expectedVariations1, variations1);
         }
diff --git a/OptimizelySDK/Bucketing/DecisionService.cs b/OptimizelySDK/Bucketing/DecisionService.cs
index b78578f9..318a8ffa 100644
--- a/OptimizelySDK/Bucketing/DecisionService.cs
+++ b/OptimizelySDK/Bucketing/DecisionService.cs
@@ -186,15 +186,6 @@ public virtual Result<Variation> GetVariation(Experiment experiment,
             return Result<Variation>.NullResult(reasons);
         }
 
-        /// <summary>
-        /// Get a Variation of an Experiment from an Experiment Rule
-        /// </summary>
-        /// 
-        public virtual Result<Variation> GetVariationFromExperimentRule(ProjectConfig config, string flagKey, Experiment rule, OptimizelyUserContext userContext, OptimizelyDecideOption[] options)
-        {
-            return new Result<Variation>();
-        }
-
         /// <summary>
         /// Gets the forced variation for the given user and experiment.  
         /// </summary>
diff --git a/OptimizelySDK/Config/DatafileProjectConfig.cs b/OptimizelySDK/Config/DatafileProjectConfig.cs
index 2fda13f7..cd9251d6 100644
--- a/OptimizelySDK/Config/DatafileProjectConfig.cs
+++ b/OptimizelySDK/Config/DatafileProjectConfig.cs
@@ -199,8 +199,8 @@ private Dictionary<string, Dictionary<string, Variation>> _VariationIdMap
         /// Associated array of flags to experiments
         /// </summary>
         
-        private Dictionary<string, ICollection<Variation>> _FlagVariationMap = new Dictionary<string, ICollection<Variation>>();
-        public Dictionary<string, ICollection<Variation>> FlagVariationMap { get { return _FlagVariationMap;  } }
+        private Dictionary<string, List<Variation>> _FlagVariationMap = new Dictionary<string, List<Variation>>();
+        public Dictionary<string, List<Variation>> FlagVariationMap { get { return _FlagVariationMap;  } }
 
         //========================= Interfaces ===========================
 
@@ -364,9 +364,9 @@ private void Initialize()
             }
         }
 
-        private Dictionary<string, ICollection<Variation>> GetFlagVariationMap()
+        private Dictionary<string, List<Variation>> GetFlagVariationMap()
         {
-            var map = new Dictionary<string, ICollection<Variation>>();
+            var map = new Dictionary<string, List<Variation>>();
             var variations = new List<Variation>();
             var emptyArray = new List<Experiment>();
 
diff --git a/OptimizelySDK/IOptimizely.cs b/OptimizelySDK/IOptimizely.cs
index 836cdb92..d5ca6ca7 100644
--- a/OptimizelySDK/IOptimizely.cs
+++ b/OptimizelySDK/IOptimizely.cs
@@ -139,6 +139,14 @@ public interface IOptimizely
 		/// <returns>List of the feature keys that are enabled for the user.</returns>
 		List<string> GetEnabledFeatures(string userId, UserAttributes userAttributes = null);
 
+		/// <summary>
+		/// Get the variation by flag key
+		/// </summary>
+		/// <param name="flagKey">The flag key</param>
+		/// <param name="variationKey">The variation key</param>
+		/// <returns></returns>
+		Variation GetFlagVariationByKey(string flagKey, string variationKey);
+
 		#endregion
 	}
 }
diff --git a/OptimizelySDK/Optimizely.cs b/OptimizelySDK/Optimizely.cs
index 5aae0da4..e276099c 100644
--- a/OptimizelySDK/Optimizely.cs
+++ b/OptimizelySDK/Optimizely.cs
@@ -1119,7 +1119,7 @@ public OptimizelyConfig GetOptimizelyConfig()
             return new OptimizelyConfigService(config).GetOptimizelyConfig();
         }
 
-#endregion // FeatureFlag APIs
+        #endregion // FeatureFlag APIs
 
         /// <summary>
         /// Validate all string inputs are not null or empty.
@@ -1196,5 +1196,21 @@ public void Dispose()
 
             ProjectConfigManager = null;
         }
+
+        public Variation GetFlagVariationByKey(string flagKey, string variationKey)
+        {
+            Dictionary<string, List<Variation>> flagVariationsMap = new Dictionary<string, List<Variation>>();
+            if (flagVariationsMap.TryGetValue(flagKey, out var variations))
+            {
+                foreach(var variation in variations)
+                {
+                    if (variation.Key.Equals(variationKey))
+                    {
+                        return variation;
+                    }
+                }
+            }
+            return null;
+        }
     }    
 }
diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index 5b893d3c..5fa9913e 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -323,12 +323,11 @@ public string FindForcedDecision(string flagKey, string ruleKey)
             return variationKey;
         }
 
-        /**
-    * Remove a forced decision
-    *
-    * @param flagKey The flag key in the forced decision
-    * @return Returns a boolean of true if successful, otherwise false
-    */
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="flagKey"></param>
+        /// <returns></returns>
         public bool RemoveForcedDecision(string flagKey)
         {
             return RemoveForcedDecision(flagKey, null);
@@ -376,10 +375,78 @@ public bool RemoveAllForcedDecisions()
                 Logger.Log(LogLevel.ERROR, "Optimizely SDK not ready.");
                 return false;
             }
-            // Clear both maps for with and without ruleKey
+            
             ForcedDecisionsMap.Clear();
             ForcedDecisionsMapWithNoRuleKey.Clear();
             return true;
         }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="flagKey"></param>
+        /// <returns></returns>
+        public Result<Variation> FindValidatedForcedDecision(string flagKey)
+        {
+            return FindValidatedForcedDecision(flagKey, null);
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="flagKey"></param>
+        /// <param name="ruleKey"></param>
+        /// <returns></returns>
+        public Result<Variation> FindValidatedForcedDecision(string flagKey, string ruleKey)
+        {
+            DecisionReasons reasons = new DecisionReasons();
+            
+            string variationKey = FindForcedDecision(flagKey, ruleKey);
+            if (variationKey != null)
+            {
+                Variation variation =  new Variation();
+                string strRuleKey = ruleKey ?? "null";
+                string info = string.Empty;
+                if (variation != null)
+                {
+                    info = "Variation " + variationKey + " is mapped to flag: " + flagKey + " and rule: " + strRuleKey + " in the forced decision map.";
+                    Logger.Log(LogLevel.INFO, info);
+                    reasons.AddInfo(info);
+                    return Result<Variation>.NewResult(variation, reasons);
+                }
+                else
+                {
+                    info = "Invalid variation is mapped to flag: " + flagKey + " and rule: " + strRuleKey + " forced decision map.";
+                    Logger.Log(LogLevel.INFO, info);
+                    reasons.AddInfo(info);
+                }
+            }
+
+            return Result<Variation>.NullResult(reasons);
+
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="flagKey"></param>
+        /// <param name="variationKey"></param>
+        /// <returns></returns>
+        public Variation GetFlagVariationByKey(string flagKey, string variationKey)
+        {
+            var flagVariationsMap = Optimizely.GetOptimizelyConfig().FlagToVariationMap;
+            if (flagVariationsMap.TryGetValue(flagKey, out var variations))
+            {
+                foreach (var variation in variations)
+                {
+                    if (variation.Key.Equals(variationKey))
+                    {
+                        return variation;
+                    }
+                }
+            }
+            return null;
+        }
+
     }
 }
diff --git a/OptimizelySDK/OptlyConfig/OptimizelyConfig.cs b/OptimizelySDK/OptlyConfig/OptimizelyConfig.cs
index bf3cd1b2..218800ab 100644
--- a/OptimizelySDK/OptlyConfig/OptimizelyConfig.cs
+++ b/OptimizelySDK/OptlyConfig/OptimizelyConfig.cs
@@ -15,6 +15,7 @@
  */
 
 using Newtonsoft.Json;
+using OptimizelySDK.Entity;
 using System;
 using System.Collections.Generic;
 
@@ -39,6 +40,8 @@ public class OptimizelyConfig
 
         public IDictionary<string, OptimizelyFeature> FeaturesMap { get; private set; }
 
+        public IDictionary<string, List<Variation>> FlagToVariationMap { get; private set; }
+
         private string _datafile;
 
         public OptimizelyConfig(string revision, IDictionary<string, OptimizelyExperiment> experimentsMap, IDictionary<string, OptimizelyFeature> featuresMap, string datafile = null)
@@ -62,6 +65,20 @@ public OptimizelyConfig(string revision, string sdkKey, string environmentKey, O
             _datafile = datafile;
         }
 
+        public OptimizelyConfig(string revision, string sdkKey, string environmentKey, OptimizelyAttribute[] attributes, OptimizelyAudience[] audiences, OptimizelyEvent[] events, IDictionary<string, OptimizelyExperiment> experimentsMap, IDictionary<string, OptimizelyFeature> featuresMap, IDictionary<string, List<Variation>> flagToVariationMap, string datafile = null)
+        {
+            Revision = revision;
+            SDKKey = sdkKey;
+            Attributes = attributes;
+            Audiences = audiences;
+            Events = events;
+            EnvironmentKey = environmentKey;
+            ExperimentsMap = experimentsMap;
+            FeaturesMap = featuresMap;
+            FlagToVariationMap = flagToVariationMap;
+            _datafile = datafile;
+        }
+
         /// <summary>
         /// Get the datafile associated with OptimizelyConfig.
         /// </summary>
diff --git a/OptimizelySDK/OptlyConfig/OptimizelyConfigService.cs b/OptimizelySDK/OptlyConfig/OptimizelyConfigService.cs
index ae7a26e1..e2610a96 100644
--- a/OptimizelySDK/OptlyConfig/OptimizelyConfigService.cs
+++ b/OptimizelySDK/OptlyConfig/OptimizelyConfigService.cs
@@ -46,6 +46,7 @@ public OptimizelyConfigService(ProjectConfig projectConfig)
             
             var featureMap = GetFeaturesMap(projectConfig, experimentsMapById);
             var events = GetEvents(projectConfig);
+            var variationByFlagMap = GetVariationsByFlag(projectConfig);
 
             OptimizelyConfig = new OptimizelyConfig(projectConfig.Revision,
                 projectConfig.SDKKey,
@@ -55,9 +56,15 @@ public OptimizelyConfigService(ProjectConfig projectConfig)
                 events,
                 experimentsKeyMap,
                 featureMap,
+                flagToVariationMap: variationByFlagMap,
                 projectConfig.ToDatafile());
         }
 
+        private Dictionary<string, List<Variation>> GetVariationsByFlag(ProjectConfig projectConfig)
+        {
+            return projectConfig.FlagVariationMap;
+        }
+
         private OptimizelyEvent[] GetEvents(ProjectConfig projectConfig)
         {
             var optimizelyEvents = new List<OptimizelyEvent>();
diff --git a/OptimizelySDK/ProjectConfig.cs b/OptimizelySDK/ProjectConfig.cs
index f85fbe09..954797fd 100644
--- a/OptimizelySDK/ProjectConfig.cs
+++ b/OptimizelySDK/ProjectConfig.cs
@@ -126,7 +126,7 @@ public interface ProjectConfig
         /// <summary>
         /// Associative array of Flag to Variation in the datafile
         /// </summary>
-        Dictionary<string, ICollection<Variation>> FlagVariationMap { get; }
+        Dictionary<string, List<Variation>> FlagVariationMap { get; }
 
         //========================= Datafile Entities ===========================
 

From 68d918e8f64f7c53570dac62865370b965056fcf Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Fri, 8 Oct 2021 09:52:34 -0400
Subject: [PATCH 011/130] Added additional assertions to help with config test

---
 OptimizelySDK.Tests/Assertions.cs             | 242 +++++++++++++++++-
 .../OptimizelyConfigTest.cs                   |   4 +-
 2 files changed, 234 insertions(+), 12 deletions(-)

diff --git a/OptimizelySDK.Tests/Assertions.cs b/OptimizelySDK.Tests/Assertions.cs
index c48c86ab..7fc1d258 100644
--- a/OptimizelySDK.Tests/Assertions.cs
+++ b/OptimizelySDK.Tests/Assertions.cs
@@ -1,5 +1,6 @@
 using NUnit.Framework;
 using OptimizelySDK.Entity;
+using OptimizelySDK.OptlyConfig;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
@@ -22,7 +23,7 @@ public static bool HasItems(IEnumerable<object> expected, IEnumerable<object> ac
         {
             if (allowNull && expected == null && actual == null)
                 return false;
-            
+
             Assert.AreEqual(expected.Count(), actual.Count());
 
             return true;
@@ -71,9 +72,216 @@ public static void AreEqual(KeyValuePair<string, string> expected, KeyValuePair<
             Assert.AreEqual(expected.Key, actual.Key);
             Assert.AreEqual(expected.Value, actual.Value);
         }
-        #endregion
+
+        #endregion Basic asserts
+
+        #region OptimizelyAudience
+
+        private static void AreEquivalent(OptimizelyAudience[] expected, OptimizelyAudience[] actual)
+        {
+            Assert.AreEqual(expected.Count(), actual.Count());
+            var zipped = expected.Zip(actual, (e, a) =>
+            {
+                return new
+                {
+                    Expected = e,
+                    Actual = a
+                };
+            }).ToList();
+
+            foreach (var z in zipped)
+            {
+                AreEqual(z.Expected, z.Actual);
+            };
+        }
+
+        private static void AreEqual(OptimizelyAudience expected, OptimizelyAudience actual)
+        {
+            Assert.AreEqual(expected.Id, actual.Id);
+            Assert.AreEqual(expected.Name, actual.Name);
+            AreEqual(expected.Conditions, actual.Conditions);
+        }
+
+        #endregion OptimizelyAudience
+
+        #region OptimizelyConfig
+
+        public static void AreEqual(OptimizelyConfig expected, OptimizelyConfig actual)
+        {
+            AreEquivalent(expected.Attributes, actual.Attributes);
+            AreEquivalent(expected.Audiences, actual.Audiences);
+            Assert.AreEqual(expected.EnvironmentKey, actual.EnvironmentKey);
+            AreEquivalent(expected.Events, actual.Events);
+            AreEquivalent(expected.ExperimentsMap, actual.ExperimentsMap);
+            AreEquivalent(expected.FeaturesMap, actual.FeaturesMap);
+            AreEquivalent(expected.FlagToVariationMap, actual.FlagToVariationMap);
+            Assert.AreEqual(expected.Revision, actual.Revision);
+            Assert.AreEqual(expected.SDKKey, actual.SDKKey);
+        }
+
+        private static void AreEquivalent(OptimizelyAttribute[] expected, OptimizelyAttribute[] actual)
+        {
+            throw new NotImplementedException();
+        }
+
+        #endregion OptimizelyConfig
+
+        #region OptimizelyEvent
+
+        public static void AreEquivalent(OptimizelyEvent[] expected, OptimizelyEvent[] actual)
+        {
+            Assert.AreEqual(expected.Count(), actual.Count());
+            var zipped = expected.Zip(actual, (e, a) =>
+            {
+                return new
+                {
+                    Expected = e,
+                    Actual = a
+                };
+            }).ToList();
+
+            foreach (var z in zipped)
+            {
+                AreEqual(z.Expected, z.Actual);
+            };
+        }
+
+        private static void AreEqual(OptimizelyEvent expected, OptimizelyEvent actual)
+        {
+            Assert.AreEqual(expected.Id, actual.Id);
+            Assert.AreEqual(expected.Key, actual.Key);
+            AreEquivalent(expected.ExperimentIds, actual.ExperimentIds);
+        }
+
+        #endregion OptimizelyEvent
+
+        #region OptimizelyExperiement
+
+        public static void AreEquivalent(List<OptimizelyExperiment> expected, List<OptimizelyExperiment> actual)
+        {
+            Assert.AreEqual(expected.Count, actual.Count);
+            var zipped = expected.Zip(actual, (e, a) =>
+            {
+                return new
+                {
+                    Expected = e,
+                    Actual = a
+                };
+            }).ToList();
+
+            foreach (var z in zipped)
+            {
+                AreEqual(z.Expected, z.Actual);
+            };
+        }
+
+        public static void AreEqual(OptimizelyExperiment expected, OptimizelyExperiment actual)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static void AreEquivalent(IDictionary<string, OptimizelyExperiment> expected, IDictionary<string, OptimizelyExperiment> actual)
+        {
+            Assert.AreEqual(expected.Count, actual.Count);
+            var zipped = expected.Zip(actual, (e, a) =>
+            {
+                return new
+                {
+                    Expected = e,
+                    Actual = a
+                };
+            }).ToList();
+
+            foreach (var z in zipped)
+            {
+                AreEquivalent(z.Expected, z.Actual);
+            };
+        }
+
+        public static void AreEquivalent(KeyValuePair<string, OptimizelyExperiment> expected, KeyValuePair<string, OptimizelyExperiment> actual)
+        {
+            Assert.AreEqual(expected.Key, actual.Key);
+            AreEqual(expected.Value, actual.Value);
+        }
+
+        #endregion OptimizelyExperiement
+
+        #region OptimizelyFeature
+
+        public static void AreEquivalent(IDictionary<string, OptimizelyFeature> expected, IDictionary<string, OptimizelyFeature> actual)
+        {
+            Assert.AreEqual(expected.Count, actual.Count);
+            var zipped = expected.Zip(actual, (e, a) =>
+            {
+                return new
+                {
+                    Expected = e,
+                    Actual = a
+                };
+            }).ToList();
+
+            foreach (var z in zipped)
+            {
+                AreEquivalent(z.Expected, z.Actual);
+            };
+        }
+
+        public static void AreEquivalent(KeyValuePair<string, OptimizelyFeature> expected, KeyValuePair<string, OptimizelyFeature> actual)
+        {
+            Assert.AreEqual(expected.Key, actual.Key);
+            AreEqual(expected.Value, actual.Value);
+        }
+
+        public static void AreEqual(OptimizelyFeature expected, OptimizelyFeature actual)
+        {
+            AreEquivalent(expected.DeliveryRules, actual.DeliveryRules);
+            AreEquivalent(expected.ExperimentRules, actual.ExperimentRules);
+            AreEquivalent(expected.ExperimentsMap, actual.ExperimentsMap);
+            Assert.AreEqual(expected.Id, actual.Id);
+            Assert.AreEqual(expected.Key, actual.Key);
+            AreEquivalent(expected.VariablesMap, actual.VariablesMap);
+        }
+
+        #endregion OptimizelyFeature
+
+        #region OptimizelyVariable
+
+        public static void AreEquivalent(IDictionary<string, OptimizelyVariable> expected, IDictionary<string, OptimizelyVariable> actual)
+        {
+            Assert.AreEqual(expected.Count, actual.Count);
+            var zipped = expected.Zip(actual, (e, a) =>
+            {
+                return new
+                {
+                    Expected = e,
+                    Actual = a
+                };
+            }).ToList();
+
+            foreach (var z in zipped)
+            {
+                AreEquivalent(z.Expected, z.Actual);
+            };
+        }
+
+        public static void AreEquivalent(KeyValuePair<string, OptimizelyVariable> expected, KeyValuePair<string, OptimizelyVariable> actual)
+        {
+            Assert.AreEqual(expected.Key, actual.Key);
+            AreEqual(expected.Value, actual.Value);
+        }
+
+        public static void AreEqual(OptimizelyVariable expected, OptimizelyVariable actual)
+        {
+            Assert.AreEqual(expected.Id, actual.Id);
+            Assert.AreEqual(expected.Key, actual.Key);
+            Assert.AreEqual(expected.Type, actual.Type);
+            Assert.AreEqual(expected.Value, actual.Value);
+        }
+
+        #endregion OptimizelyVariable
 
         #region Experiment
+
         public static void AreEqual(Experiment expected, Experiment actual)
         {
             Assert.AreEqual(expected.AudienceConditions, actual.AudienceConditions);
@@ -97,16 +305,20 @@ public static void AreEqual(Experiment expected, Experiment actual)
             AreEquivalent(expected.VariationKeyToVariationMap, actual.VariationKeyToVariationMap);
             AreEquivalent(expected.Variations, actual.Variations);
         }
-        #endregion
+
+        #endregion Experiment
 
         #region FeatureDecision
+
         public static void AreEqual(FeatureDecision expected, FeatureDecision actual)
         {
             AreEqual(expected.Experiment, actual.Experiment);
         }
-        #endregion
+
+        #endregion FeatureDecision
 
         #region FeatureFlags
+
         public static void AreEquivalent(Dictionary<string, FeatureFlag> expected, Dictionary<string, FeatureFlag> actual)
         {
             Assert.AreEqual(expected.Count, actual.Count);
@@ -138,9 +350,11 @@ public static void AreEqual(FeatureFlag expected, FeatureFlag actual)
             Assert.AreEqual(expected.RolloutId, actual.RolloutId);
             AreEquivalent(expected.VariableKeyToFeatureVariableMap, actual.VariableKeyToFeatureVariableMap);
         }
-        #endregion
+
+        #endregion FeatureFlags
 
         #region FeatureVariable
+
         public static void AreEqual(FeatureVariable expected, FeatureVariable actual)
         {
             Assert.AreEqual(expected.Id, actual.Id);
@@ -174,9 +388,11 @@ public static void AreEquivalent(KeyValuePair<string, FeatureVariable> expected,
             Assert.AreEqual(expected.Key, actual.Key);
             AreEqual(expected.Value, actual.Value);
         }
-        #endregion
+
+        #endregion FeatureVariable
 
         #region Variations
+
         public static void AreEqual(Variation expected, Variation actual)
         {
             Assert.AreEqual(expected.Id, actual.Id);
@@ -223,7 +439,7 @@ public static void AreEquivalent(List<Dictionary<string, List<Variation>>> expec
             };
         }
 
-        public static void AreEquivalent(Dictionary<string, List<Variation>> expected, Dictionary<string, List<Variation>> actual)
+        public static void AreEquivalent(IDictionary<string, List<Variation>> expected, IDictionary<string, List<Variation>> actual)
         {
             Assert.AreEqual(expected.Count, actual.Count);
             var zipped = expected.Zip(actual, (e, a) =>
@@ -275,9 +491,10 @@ public static void AreEquivalent(IEnumerable<Variation> expected, IEnumerable<Va
             });
         }
 
-        #endregion
+        #endregion Variations
 
         #region FeatureVariableUsage
+
         public static void AreEquivalent(IEnumerable<FeatureVariableUsage> expected, IEnumerable<FeatureVariableUsage> actual)
         {
             if (HasItems(expected, actual))
@@ -328,9 +545,11 @@ public static void AreEqual(FeatureVariableUsage expected, FeatureVariableUsage
             Assert.AreEqual(expected.Id, actual.Id);
             Assert.AreEqual(expected.Value, actual.Value);
         }
-        #endregion
+
+        #endregion FeatureVariableUsage
 
         #region TrafficAllocation
+
         public static void AreEquivalent(IEnumerable<TrafficAllocation> expected, IEnumerable<TrafficAllocation> actual)
         {
             Assert.AreEqual(expected.Count(), actual.Count());
@@ -354,6 +573,7 @@ public static void AreEqual(TrafficAllocation expected, TrafficAllocation actual
             Assert.AreEqual(expected.EndOfRange, actual.EndOfRange);
             Assert.AreEqual(expected.EntityId, actual.EntityId);
         }
-        #endregion
+
+        #endregion TrafficAllocation
     }
-}
+}
\ No newline at end of file
diff --git a/OptimizelySDK.Tests/OptimizelyConfigTests/OptimizelyConfigTest.cs b/OptimizelySDK.Tests/OptimizelyConfigTests/OptimizelyConfigTest.cs
index 752d2d16..62f4d47e 100644
--- a/OptimizelySDK.Tests/OptimizelyConfigTests/OptimizelyConfigTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyConfigTests/OptimizelyConfigTest.cs
@@ -702,7 +702,9 @@ public void TestGetOptimizelyConfigService()
                 flagToVariationMap: expectedflagVariations,
                 datafile: TestData.TypedAudienceDatafile);
 
-            Assert.IsTrue(TestData.CompareObjects(optimizelyConfig, expectedOptimizelyConfig));
+            Assertions.AreEqual(expectedOptimizelyConfig, optimizelyConfig);
+
+            //Assert.IsTrue(TestData.CompareObjects(optimizelyConfig, expectedOptimizelyConfig));
         }
 
         #endregion Test OptimizelyConfigService

From 30a808bf856b754c90bf1c5425e3212abaebf291 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Fri, 8 Oct 2021 09:53:58 -0400
Subject: [PATCH 012/130] Fixed error

---
 OptimizelySDK.Tests/Assertions.cs                               | 2 +-
 .../OptimizelyConfigTests/OptimizelyConfigTest.cs               | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/OptimizelySDK.Tests/Assertions.cs b/OptimizelySDK.Tests/Assertions.cs
index 7fc1d258..3bb0181f 100644
--- a/OptimizelySDK.Tests/Assertions.cs
+++ b/OptimizelySDK.Tests/Assertions.cs
@@ -99,7 +99,7 @@ private static void AreEqual(OptimizelyAudience expected, OptimizelyAudience act
         {
             Assert.AreEqual(expected.Id, actual.Id);
             Assert.AreEqual(expected.Name, actual.Name);
-            AreEqual(expected.Conditions, actual.Conditions);
+            //AreEqual(expected.Conditions, actual.Conditions);
         }
 
         #endregion OptimizelyAudience
diff --git a/OptimizelySDK.Tests/OptimizelyConfigTests/OptimizelyConfigTest.cs b/OptimizelySDK.Tests/OptimizelyConfigTests/OptimizelyConfigTest.cs
index 62f4d47e..a4294760 100644
--- a/OptimizelySDK.Tests/OptimizelyConfigTests/OptimizelyConfigTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyConfigTests/OptimizelyConfigTest.cs
@@ -704,7 +704,7 @@ public void TestGetOptimizelyConfigService()
 
             Assertions.AreEqual(expectedOptimizelyConfig, optimizelyConfig);
 
-            //Assert.IsTrue(TestData.CompareObjects(optimizelyConfig, expectedOptimizelyConfig));
+            Assert.IsTrue(TestData.CompareObjects(optimizelyConfig, expectedOptimizelyConfig));
         }
 
         #endregion Test OptimizelyConfigService

From 14a728892820f0d3911d807fe8eea8c308ee17ab Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Fri, 8 Oct 2021 10:05:27 -0400
Subject: [PATCH 013/130] Additional asserts

---
 OptimizelySDK.Tests/Assertions.cs             | 33 ++++++++++++++++---
 .../OptimizelyConfigTest.cs                   |  2 +-
 2 files changed, 29 insertions(+), 6 deletions(-)

diff --git a/OptimizelySDK.Tests/Assertions.cs b/OptimizelySDK.Tests/Assertions.cs
index 3bb0181f..3197951b 100644
--- a/OptimizelySDK.Tests/Assertions.cs
+++ b/OptimizelySDK.Tests/Assertions.cs
@@ -75,6 +75,34 @@ public static void AreEqual(KeyValuePair<string, string> expected, KeyValuePair<
 
         #endregion Basic asserts
 
+        #region OptimizelyAttribute
+
+        public static void AreEquivalent(OptimizelyAttribute[] expected, OptimizelyAttribute[] actual)
+        {
+            Assert.AreEqual(expected.Count(), actual.Count());
+            var zipped = expected.Zip(actual, (e, a) =>
+            {
+                return new
+                {
+                    Expected = e,
+                    Actual = a
+                };
+            }).ToList();
+
+            foreach (var z in zipped)
+            {
+                AreEqual(z.Expected, z.Actual);
+            };
+        }
+
+        public static void AreEqual(OptimizelyAttribute expected, OptimizelyAttribute actual)
+        {
+            Assert.AreEqual(expected.Id, actual.Id);
+            Assert.AreEqual(expected.Key, actual.Key);
+        }
+
+        #endregion OptimizelyAttribute
+
         #region OptimizelyAudience
 
         private static void AreEquivalent(OptimizelyAudience[] expected, OptimizelyAudience[] actual)
@@ -119,11 +147,6 @@ public static void AreEqual(OptimizelyConfig expected, OptimizelyConfig actual)
             Assert.AreEqual(expected.SDKKey, actual.SDKKey);
         }
 
-        private static void AreEquivalent(OptimizelyAttribute[] expected, OptimizelyAttribute[] actual)
-        {
-            throw new NotImplementedException();
-        }
-
         #endregion OptimizelyConfig
 
         #region OptimizelyEvent
diff --git a/OptimizelySDK.Tests/OptimizelyConfigTests/OptimizelyConfigTest.cs b/OptimizelySDK.Tests/OptimizelyConfigTests/OptimizelyConfigTest.cs
index a4294760..62f4d47e 100644
--- a/OptimizelySDK.Tests/OptimizelyConfigTests/OptimizelyConfigTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyConfigTests/OptimizelyConfigTest.cs
@@ -704,7 +704,7 @@ public void TestGetOptimizelyConfigService()
 
             Assertions.AreEqual(expectedOptimizelyConfig, optimizelyConfig);
 
-            Assert.IsTrue(TestData.CompareObjects(optimizelyConfig, expectedOptimizelyConfig));
+            //Assert.IsTrue(TestData.CompareObjects(optimizelyConfig, expectedOptimizelyConfig));
         }
 
         #endregion Test OptimizelyConfigService

From 8c289b6aac68176a2a42a5c9ee4644d45db8ff32 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Fri, 8 Oct 2021 10:12:53 -0400
Subject: [PATCH 014/130] finished optimizely config assertions

---
 OptimizelySDK.Tests/Assertions.cs                             | 4 +++-
 .../OptimizelyConfigTests/OptimizelyConfigTest.cs             | 2 --
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/OptimizelySDK.Tests/Assertions.cs b/OptimizelySDK.Tests/Assertions.cs
index 3197951b..53466573 100644
--- a/OptimizelySDK.Tests/Assertions.cs
+++ b/OptimizelySDK.Tests/Assertions.cs
@@ -200,7 +200,9 @@ public static void AreEquivalent(List<OptimizelyExperiment> expected, List<Optim
 
         public static void AreEqual(OptimizelyExperiment expected, OptimizelyExperiment actual)
         {
-            throw new NotImplementedException();
+            Assert.AreEqual(expected.Id, actual.Id);
+            Assert.AreEqual(expected.Key, actual.Key);
+            Assert.AreEqual(expected.Audiences, actual.Audiences);
         }
 
         public static void AreEquivalent(IDictionary<string, OptimizelyExperiment> expected, IDictionary<string, OptimizelyExperiment> actual)
diff --git a/OptimizelySDK.Tests/OptimizelyConfigTests/OptimizelyConfigTest.cs b/OptimizelySDK.Tests/OptimizelyConfigTests/OptimizelyConfigTest.cs
index 62f4d47e..44b9dcb8 100644
--- a/OptimizelySDK.Tests/OptimizelyConfigTests/OptimizelyConfigTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyConfigTests/OptimizelyConfigTest.cs
@@ -703,8 +703,6 @@ public void TestGetOptimizelyConfigService()
                 datafile: TestData.TypedAudienceDatafile);
 
             Assertions.AreEqual(expectedOptimizelyConfig, optimizelyConfig);
-
-            //Assert.IsTrue(TestData.CompareObjects(optimizelyConfig, expectedOptimizelyConfig));
         }
 
         #endregion Test OptimizelyConfigService

From 6917f4d953a7a294090a234bd5dd8baf7f010d5f Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Fri, 8 Oct 2021 10:49:37 -0400
Subject: [PATCH 015/130] Updating decision service

---
 OptimizelySDK/Bucketing/DecisionService.cs | 92 +++++++++++-----------
 OptimizelySDK/Optimizely.cs                | 92 +++++++++++-----------
 2 files changed, 95 insertions(+), 89 deletions(-)

diff --git a/OptimizelySDK/Bucketing/DecisionService.cs b/OptimizelySDK/Bucketing/DecisionService.cs
index 318a8ffa..a351d27e 100644
--- a/OptimizelySDK/Bucketing/DecisionService.cs
+++ b/OptimizelySDK/Bucketing/DecisionService.cs
@@ -1,4 +1,4 @@
-/* 
+/*
 * Copyright 2017-2021, Optimizely
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
@@ -26,7 +26,7 @@ namespace OptimizelySDK.Bucketing
 {
     /// <summary>
     /// Optimizely's decision service that determines which variation of an experiment the user will be allocated to.
-    /// The decision service contains all logic around how a user decision is made.  
+    /// The decision service contains all logic around how a user decision is made.
     /// This includes the following:
     /// 1. Checking experiment status
     /// 2. Checking whitelisting
@@ -44,18 +44,17 @@ public class DecisionService
         private UserProfileService UserProfileService;
         private ILogger Logger;
 
-        /// <summary>   
-        /// Associative array of user IDs to an associative array   
-        /// of experiments to variations.This contains all the forced variations    
-        /// set by the user by calling setForcedVariation (it is not the same as the    
-        /// whitelisting forcedVariations data structure in the Experiments class). 
+        /// <summary>
+        /// Associative array of user IDs to an associative array
+        /// of experiments to variations.This contains all the forced variations
+        /// set by the user by calling setForcedVariation (it is not the same as the
+        /// whitelisting forcedVariations data structure in the Experiments class).
         /// </summary>
-    #if NET35
+#if NET35
         private Dictionary<string, Dictionary<string, string>> ForcedVariationMap;
-    #else
+#else
         private System.Collections.Concurrent.ConcurrentDictionary<string, Dictionary<string, string>> ForcedVariationMap;
-    #endif
-
+#endif
 
         /// <summary>
         ///  Initialize a decision service for the Optimizely client.
@@ -70,11 +69,11 @@ public DecisionService(Bucketer bucketer, IErrorHandler errorHandler, UserProfil
             ErrorHandler = errorHandler;
             UserProfileService = userProfileService;
             Logger = logger;
-        #if NET35
+#if NET35
             ForcedVariationMap = new Dictionary<string, Dictionary<string, string>>();
-        #else
+#else
             ForcedVariationMap = new System.Collections.Concurrent.ConcurrentDictionary<string, Dictionary<string, string>>();
-        #endif
+#endif
         }
 
         /// <summary>
@@ -85,11 +84,11 @@ public DecisionService(Bucketer bucketer, IErrorHandler errorHandler, UserProfil
         /// <param name = "filteredAttributes" > The user's attributes. This should be filtered to just attributes in the Datafile.</param>
         /// <returns>The Variation the user is allocated into.</returns>
         public virtual Result<Variation> GetVariation(Experiment experiment,
-            string userId,
+            OptimizelyUserContext user,
             ProjectConfig config,
             UserAttributes filteredAttributes)
         {
-            return GetVariation(experiment, userId, config, filteredAttributes, new OptimizelyDecideOption[] { });
+            return GetVariation(experiment, user, config, filteredAttributes, new OptimizelyDecideOption[] { });
         }
 
         /// <summary>
@@ -100,17 +99,18 @@ public virtual Result<Variation> GetVariation(Experiment experiment,
         /// <param name = "filteredAttributes" > The user's attributes. This should be filtered to just attributes in the Datafile.</param>
         /// <returns>The Variation the user is allocated into.</returns>
         public virtual Result<Variation> GetVariation(Experiment experiment,
-            string userId,
+            OptimizelyUserContext user,
             ProjectConfig config,
             UserAttributes filteredAttributes,
             OptimizelyDecideOption[] options)
         {
             var reasons = new DecisionReasons();
+            var userId = user.GetUserId();
             if (!ExperimentUtils.IsExperimentActive(experiment, Logger))
                 return Result<Variation>.NullResult(reasons);
 
             // check if a forced variation is set
-            var forcedVariationResult = GetForcedVariation(experiment.Key, userId, config);
+            var forcedVariationResult = GetForcedVariation(experiment.Key, user, config);
             reasons += forcedVariationResult.DecisionReasons;
 
             if (forcedVariationResult.ResultObject != null)
@@ -122,7 +122,7 @@ public virtual Result<Variation> GetVariation(Experiment experiment,
             reasons += variationResult.DecisionReasons;
 
             if (variationResult.ResultObject != null)
-            {                
+            {
                 return variationResult.SetReasons(reasons);
             }
             // fetch the user profile map from the user profile service
@@ -133,7 +133,7 @@ public virtual Result<Variation> GetVariation(Experiment experiment,
             {
                 try
                 {
-                    Dictionary<string, object> userProfileMap = UserProfileService.Lookup(userId);
+                    Dictionary<string, object> userProfileMap = UserProfileService.Lookup(user.GetUserId());
                     if (userProfileMap != null && UserProfileUtil.IsValidUserProfileMap(userProfileMap))
                     {
                         userProfile = UserProfileUtil.ConvertMapToUserProfile(userProfileMap);
@@ -173,7 +173,6 @@ public virtual Result<Variation> GetVariation(Experiment experiment,
                     {
                         var bucketerUserProfile = userProfile ?? new UserProfile(userId, new Dictionary<string, Decision>());
                         SaveVariation(experiment, variationResult.ResultObject, bucketerUserProfile);
-
                     }
                     else
                         Logger.Log(LogLevel.INFO, "This decision will not be saved since the UserProfileService is null.");
@@ -181,21 +180,22 @@ public virtual Result<Variation> GetVariation(Experiment experiment,
 
                 return variationResult.SetReasons(reasons);
             }
-            Logger.Log(LogLevel.INFO, reasons.AddInfo($"User \"{userId}\" does not meet conditions to be in experiment \"{experiment.Key}\"."));
+            Logger.Log(LogLevel.INFO, reasons.AddInfo($"User \"{user.GetUserId()}\" does not meet conditions to be in experiment \"{experiment.Key}\"."));
 
             return Result<Variation>.NullResult(reasons);
         }
 
         /// <summary>
-        /// Gets the forced variation for the given user and experiment.  
+        /// Gets the forced variation for the given user and experiment.
         /// </summary>
         /// <param name="experimentKey">The experiment key</param>
         /// <param name="userId">The user ID</param>
         /// <param name="config">Project Config</param>
         /// <returns>Variation entity which the given user and experiment should be forced into.</returns>
-        public Result<Variation> GetForcedVariation(string experimentKey, string userId, ProjectConfig config)
+        public Result<Variation> GetForcedVariation(string experimentKey, OptimizelyUserContext user, ProjectConfig config)
         {
             var reasons = new DecisionReasons();
+            var userId = user.GetUserId();
 
             if (ForcedVariationMap.ContainsKey(userId) == false)
             {
@@ -207,7 +207,7 @@ public Result<Variation> GetForcedVariation(string experimentKey, string userId,
 
             string experimentId = config.GetExperimentFromKey(experimentKey).Id;
 
-            // this case is logged in getExperimentFromKey  
+            // this case is logged in getExperimentFromKey
             if (string.IsNullOrEmpty(experimentId))
                 return Result<Variation>.NullResult(reasons);
 
@@ -227,7 +227,7 @@ public Result<Variation> GetForcedVariation(string experimentKey, string userId,
 
             string variationKey = config.GetVariationFromId(experimentKey, variationId).Key;
 
-            // this case is logged in getVariationFromKey   
+            // this case is logged in getVariationFromKey
             if (string.IsNullOrEmpty(variationKey))
                 return Result<Variation>.NullResult(reasons);
             Logger.Log(LogLevel.DEBUG, reasons.AddInfo($@"Variation ""{variationKey}"" is mapped to experiment ""{experimentKey}"" and user ""{userId}"" in the forced variation map"));
@@ -247,7 +247,7 @@ public Result<Variation> GetForcedVariation(string experimentKey, string userId,
         /// <returns>A boolean value that indicates if the set completed successfully.</returns>
         public bool SetForcedVariation(string experimentKey, string userId, string variationKey, ProjectConfig config)
         {
-            // Empty variation key is considered as invalid.    
+            // Empty variation key is considered as invalid.
             if (variationKey != null && variationKey.Length == 0)
             {
                 Logger.Log(LogLevel.DEBUG, "Variation key is invalid.");
@@ -256,11 +256,11 @@ public bool SetForcedVariation(string experimentKey, string userId, string varia
 
             var experimentId = config.GetExperimentFromKey(experimentKey).Id;
 
-            // this case is logged in getExperimentFromKey  
+            // this case is logged in getExperimentFromKey
             if (string.IsNullOrEmpty(experimentId))
                 return false;
 
-            // clear the forced variation if the variation key is null  
+            // clear the forced variation if the variation key is null
             if (variationKey == null)
             {
                 if (ForcedVariationMap.ContainsKey(userId) && ForcedVariationMap[userId].ContainsKey(experimentId))
@@ -272,15 +272,15 @@ public bool SetForcedVariation(string experimentKey, string userId, string varia
 
             string variationId = config.GetVariationFromKey(experimentKey, variationKey).Id;
 
-            // this case is logged in getVariationFromKey   
+            // this case is logged in getVariationFromKey
             if (string.IsNullOrEmpty(variationId))
                 return false;
 
-            // Add User if not exist.   
+            // Add User if not exist.
             if (ForcedVariationMap.ContainsKey(userId) == false)
                 ForcedVariationMap[userId] = new Dictionary<string, string>();
 
-            // Add/Replace Experiment to Variation ID map.  
+            // Add/Replace Experiment to Variation ID map.
             ForcedVariationMap[userId][experimentId] = variationId;
 
             Logger.Log(LogLevel.DEBUG, $@"Set variation ""{variationId}"" for experiment ""{experimentId}"" and user ""{userId}"" in the forced variation map.");
@@ -394,7 +394,6 @@ public void SaveVariation(Experiment experiment, Variation variation, UserProfil
             {
                 UserProfileService.Save(userProfile.ToMap());
                 Logger.Log(LogLevel.INFO, $"Saved variation \"{variation.Id}\" of experiment \"{experiment.Id}\" for user \"{userProfile.UserId}\".");
-
             }
             catch (Exception exception)
             {
@@ -402,7 +401,7 @@ public void SaveVariation(Experiment experiment, Variation variation, UserProfil
                 ErrorHandler.HandleError(new Exceptions.OptimizelyRuntimeException(exception.Message));
             }
         }
-       
+
         /// <summary>
         /// Try to bucket the user into a rollout rule.
         /// Evaluate the user for rules in priority order by seeing if the user satisfies the audience.
@@ -441,7 +440,8 @@ public virtual Result<FeatureDecision> GetVariationForFeatureRollout(FeatureFlag
                 return Result<FeatureDecision>.NullResult(reasons);
             }
 
-            if (rollout.Experiments == null ||  rollout.Experiments.Count == 0) {
+            if (rollout.Experiments == null || rollout.Experiments.Count == 0)
+            {
                 return Result<FeatureDecision>.NullResult(reasons);
             }
 
@@ -454,7 +454,7 @@ public virtual Result<FeatureDecision> GetVariationForFeatureRollout(FeatureFlag
             // For all rules before the everyone else rule
             for (int i = 0; i < rolloutRulesLength - 1; i++)
             {
-                string loggingKey = (i + 1).ToString(); 
+                string loggingKey = (i + 1).ToString();
                 var rolloutRule = rollout.Experiments[i];
                 var userMeetConditionsResult = ExperimentUtils.DoesUserMeetAudienceConditions(config, rolloutRule, filteredAttributes, LOGGING_KEY_TYPE_RULE, loggingKey, Logger);
                 reasons += userMeetConditionsResult.DecisionReasons;
@@ -507,12 +507,13 @@ public virtual Result<FeatureDecision> GetVariationForFeatureRollout(FeatureFlag
         /// <returns>null if the user is not bucketed into the rollout or if the feature flag was not attached to a rollout.
         /// Otherwise the FeatureDecision entity</returns>
         public virtual Result<FeatureDecision> GetVariationForFeatureExperiment(FeatureFlag featureFlag,
-            string userId,
+            OptimizelyUserContext user,
             UserAttributes filteredAttributes,
             ProjectConfig config,
             OptimizelyDecideOption[] options)
         {
             var reasons = new DecisionReasons();
+            var userId = user.GetUserId();
             if (featureFlag == null)
             {
                 Logger.Log(LogLevel.ERROR, "Invalid feature flag provided.");
@@ -532,7 +533,7 @@ public virtual Result<FeatureDecision> GetVariationForFeatureExperiment(FeatureF
                 if (string.IsNullOrEmpty(experiment.Key))
                     continue;
 
-                var variationResult = GetVariation(experiment, userId, config, filteredAttributes, options); //GetVariationFromExperimentRule(config, featureFlag.Key, experiment, null, options);
+                var variationResult = GetVariation(experiment, user, config, filteredAttributes, options);
                 reasons += variationResult.DecisionReasons;
 
                 if (!string.IsNullOrEmpty(variationResult.ResultObject?.Id))
@@ -552,11 +553,11 @@ public virtual Result<FeatureDecision> GetVariationForFeatureExperiment(FeatureF
         /// <param name = "featureFlag" >The feature flag the user wants to access.</param>
         /// <param name = "userId" >User Identifier</param>
         /// <param name = "filteredAttributes" >The user's attributes. This should be filtered to just attributes in the Datafile.</param>
-        /// <returns>null if the user is not bucketed into any variation or the FeatureDecision entity if the user is 
+        /// <returns>null if the user is not bucketed into any variation or the FeatureDecision entity if the user is
         /// successfully bucketed.</returns>
-        public virtual Result<FeatureDecision> GetVariationForFeature(FeatureFlag featureFlag, string userId, ProjectConfig config, UserAttributes filteredAttributes)
+        public virtual Result<FeatureDecision> GetVariationForFeature(FeatureFlag featureFlag, OptimizelyUserContext user, ProjectConfig config, UserAttributes filteredAttributes)
         {
-            return GetVariationForFeature(featureFlag, userId, config, filteredAttributes, new OptimizelyDecideOption[] { });
+            return GetVariationForFeature(featureFlag, user, config, filteredAttributes, new OptimizelyDecideOption[] { });
         }
 
         /// <summary>
@@ -567,17 +568,18 @@ public virtual Result<FeatureDecision> GetVariationForFeature(FeatureFlag featur
         /// <param name = "filteredAttributes" >The user's attributes. This should be filtered to just attributes in the Datafile.</param>
         /// <param name = "filteredAttributes" >The user's attributes. This should be filtered to just attributes in the Datafile.</param>
         /// <param name = "options" >An array of decision options.</param>
-        /// <returns>null if the user is not bucketed into any variation or the FeatureDecision entity if the user is 
+        /// <returns>null if the user is not bucketed into any variation or the FeatureDecision entity if the user is
         /// successfully bucketed.</returns>
         public virtual Result<FeatureDecision> GetVariationForFeature(FeatureFlag featureFlag,
-            string userId,
+            OptimizelyUserContext user,
             ProjectConfig config,
             UserAttributes filteredAttributes,
             OptimizelyDecideOption[] options)
         {
             var reasons = new DecisionReasons();
+            var userId = user.GetUserId();
             // Check if the feature flag has an experiment and the user is bucketed into that experiment.
-            var decisionResult = GetVariationForFeatureExperiment(featureFlag, userId, filteredAttributes, config, options);
+            var decisionResult = GetVariationForFeatureExperiment(featureFlag, user, filteredAttributes, config, options);
             reasons += decisionResult.DecisionReasons;
 
             if (decisionResult.ResultObject != null)
@@ -627,4 +629,4 @@ private Result<string> GetBucketingId(string userId, UserAttributes filteredAttr
             return Result<string>.NewResult(bucketingId, reasons);
         }
     }
-}
+}
\ No newline at end of file
diff --git a/OptimizelySDK/Optimizely.cs b/OptimizelySDK/Optimizely.cs
index e276099c..b27e0fa4 100644
--- a/OptimizelySDK/Optimizely.cs
+++ b/OptimizelySDK/Optimizely.cs
@@ -1,4 +1,4 @@
-/* 
+/*
  * Copyright 2017-2021, Optimizely
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 using OptimizelySDK.Bucketing;
 using OptimizelySDK.Entity;
 using OptimizelySDK.ErrorHandler;
@@ -39,6 +40,7 @@ namespace OptimizelySDK
 #elif NETSTANDARD1_6
     [Obsolete("Net standard 1.6 SDK support is deprecated, use Net standard 2.0 or above")]
 #endif
+
     public class Optimizely : IOptimizely, IDisposable
     {
         private Bucketer Bucketer;
@@ -67,8 +69,10 @@ public class Optimizely : IOptimizely, IDisposable
         /// It returns true if the ProjectConfig is valid otherwise false.
         /// Also, it may block execution if GetConfig() blocks execution to get ProjectConfig.
         /// </summary>
-        public bool IsValid { 
-            get {
+        public bool IsValid
+        {
+            get
+            {
                 return ProjectConfigManager?.GetConfig() != null;
             }
         }
@@ -126,17 +130,22 @@ public Optimizely(string datafile,
                           EventProcessor eventProcessor = null,
                           OptimizelyDecideOption[] defaultDecideOptions = null)
         {
-            try {
+            try
+            {
                 InitializeComponents(eventDispatcher, logger, errorHandler, userProfileService, null, eventProcessor, defaultDecideOptions);
 
-                if (ValidateInputs(datafile, skipJsonValidation)) {
+                if (ValidateInputs(datafile, skipJsonValidation))
+                {
                     var config = DatafileProjectConfig.Create(datafile, Logger, ErrorHandler);
                     ProjectConfigManager = new FallbackProjectConfigManager(config);
-                } else {
+                }
+                else
+                {
                     Logger.Log(LogLevel.ERROR, "Provided 'datafile' has invalid schema.");
                 }
-
-            } catch (Exception ex) {
+            }
+            catch (Exception ex)
+            {
                 string error = String.Empty;
                 if (ex.GetType() == typeof(ConfigParseException))
                     error = ex.Message;
@@ -219,7 +228,6 @@ private bool ValidatePreconditions(Experiment experiment, string userId, Project
             return true;
         }
 
-
         /// <summary>
         /// Buckets visitor and sends impression event to Optimizely.
         /// </summary>
@@ -278,7 +286,6 @@ private bool ValidateInputs(string datafile, bool skipJsonValidation)
             return skipJsonValidation || Validator.ValidateJSONSchema(datafile);
         }
 
-
         /// <summary>
         /// Sends conversion event to Optimizely.
         /// </summary>
@@ -313,7 +320,6 @@ public void Track(string eventKey, string userId, UserAttributes userAttributes
                 return;
             }
 
-
             if (eventTags != null)
             {
                 eventTags = eventTags.FilterNullValues(Logger);
@@ -331,7 +337,6 @@ public void Track(string eventKey, string userId, UserAttributes userAttributes
             }
         }
 
-
         /// <summary>
         /// Get variation where user will be bucketed
         /// </summary>
@@ -414,7 +419,7 @@ public bool SetForcedVariation(string experimentKey, string userId, string varia
         }
 
         /// <summary>
-        /// Gets the forced variation key for the given user and experiment.  
+        /// Gets the forced variation key for the given user and experiment.
         /// </summary>
         /// <param name="experimentKey">The experiment key</param>
         /// <param name="userId">The user ID</param>
@@ -440,7 +445,7 @@ public Variation GetForcedVariation(string experimentKey, string userId)
             return DecisionService.GetForcedVariation(experimentKey, userId, config).ResultObject;
         }
 
-        #region  FeatureFlag APIs
+        #region FeatureFlag APIs
 
         /// <summary>
         /// Determine whether a feature is enabled.
@@ -456,7 +461,6 @@ public virtual bool IsFeatureEnabled(string featureKey, string userId, UserAttri
 
             if (config == null)
             {
-
                 Logger.Log(LogLevel.ERROR, "Datafile has invalid format. Failing 'IsFeatureEnabled'.");
 
                 return false;
@@ -484,7 +488,6 @@ public virtual bool IsFeatureEnabled(string featureKey, string userId, UserAttri
             var variation = decision?.Variation;
             var decisionSource = decision?.Source ?? FeatureDecision.DECISION_SOURCE_ROLLOUT;
 
-
             if (variation != null)
             {
                 featureEnabled = variation.FeatureEnabled.GetValueOrDefault();
@@ -532,17 +535,16 @@ public virtual bool IsFeatureEnabled(string featureKey, string userId, UserAttri
         /// <param name="userAttributes">The user's attributes</param>
         /// <param name="variableType">Variable type</param>
         /// <returns>string | null Feature variable value</returns>
-        public virtual T GetFeatureVariableValueForType<T>(string featureKey, string variableKey, string userId, 
+        public virtual T GetFeatureVariableValueForType<T>(string featureKey, string variableKey, string userId,
                                                                      UserAttributes userAttributes, string variableType)
         {
-
             var config = ProjectConfigManager?.GetConfig();
-            if (config == null) {
-
+            if (config == null)
+            {
                 Logger.Log(LogLevel.ERROR, $@"Datafile has invalid format. Failing '{FeatureVariable.GetFeatureVariableTypeName(variableType)}'.");
                 return default(T);
             }
-            
+
             var inputValues = new Dictionary<string, string>
             {
                 { USER_ID, userId },
@@ -565,7 +567,7 @@ public virtual T GetFeatureVariableValueForType<T>(string featureKey, string var
                 return default(T);
             }
             else if (featureVariable.Type != variableType)
-            {    
+            {
                 Logger.Log(LogLevel.ERROR,
                     $@"Variable is of type ""{featureVariable.Type}"", but you requested it as type ""{variableType}"".");
                 return default(T);
@@ -711,7 +713,6 @@ public OptimizelyUserContext CreateUserContext(string userId,
             if (!ValidateStringInputs(inputValues))
                 return null;
 
-
             return new OptimizelyUserContext(this, userId, userAttributes, ErrorHandler, Logger);
         }
 
@@ -728,7 +729,6 @@ internal OptimizelyDecision Decide(OptimizelyUserContext user,
                               string key,
                               OptimizelyDecideOption[] options)
         {
-
             var config = ProjectConfigManager?.GetConfig();
             if (config == null)
             {
@@ -741,7 +741,7 @@ internal OptimizelyDecision Decide(OptimizelyUserContext user,
                     DecisionMessage.Reason(DecisionMessage.FLAG_KEY_INVALID, key),
                     ErrorHandler, Logger);
             }
-            
+
             var userId = user?.GetUserId();
 
             var flag = config.GetFeatureFlagFromKey(key);
@@ -772,7 +772,7 @@ internal OptimizelyDecision Decide(OptimizelyUserContext user,
             {
                 featureEnabled = variation.FeatureEnabled.GetValueOrDefault();
             }
-            
+
             if (featureEnabled)
             {
                 Logger.Log(LogLevel.INFO, "Feature \"" + key + "\" is enabled for user \"" + userId + "\"");
@@ -784,7 +784,6 @@ internal OptimizelyDecision Decide(OptimizelyUserContext user,
             var variableMap = new Dictionary<string, object>();
             if (flag?.Variables != null && !allOptions.Contains(OptimizelyDecideOption.EXCLUDE_VARIABLES))
             {
-
                 foreach (var featureVariable in flag?.Variables)
                 {
                     string variableValue = featureVariable.DefaultValue;
@@ -805,7 +804,7 @@ internal OptimizelyDecision Decide(OptimizelyUserContext user,
                     variableMap.Add(featureVariable.Key, typeCastedValue);
                 }
             }
-            
+
             var optimizelyJSON = new OptimizelyJSON(variableMap, ErrorHandler, Logger);
 
             var decisionSource = flagDecisionResult.ResultObject?.Source ?? FeatureDecision.DECISION_SOURCE_ROLLOUT;
@@ -858,7 +857,7 @@ internal Dictionary<string, OptimizelyDecision> DecideAll(OptimizelyUserContext
 
             var allFlags = projectConfig.FeatureFlags;
             var allFlagKeys = allFlags.Select(v => v.Key).ToArray<string>();
-            
+
             return DecideForKeys(user, allFlagKeys, options);
         }
 
@@ -876,7 +875,7 @@ internal Dictionary<string, OptimizelyDecision> DecideForKeys(OptimizelyUserCont
             }
 
             if (keys.Length == 0)
-            { 
+            {
                 return decisionDictionary;
             }
 
@@ -936,7 +935,7 @@ private bool SendImpressionEvent(Experiment experiment, Variation variation, str
             {
                 Logger.Log(LogLevel.ERROR, @"Experiment has ""Launched"" status so not dispatching event during activation.");
             }
-            
+
             var userEvent = UserEventFactory.CreateImpressionEvent(config, experiment, variation, userId, userAttributes, flagKey, ruleType, enabled);
             if (userEvent == null)
             {
@@ -945,7 +944,7 @@ private bool SendImpressionEvent(Experiment experiment, Variation variation, str
             EventProcessor.Process(userEvent);
 
             if (experiment != null)
-            { 
+            {
                 Logger.Log(LogLevel.INFO, $"Activating user {userId} in experiment {experiment.Key}.");
             }
             // Kept For backwards compatibility.
@@ -1022,7 +1021,7 @@ public OptimizelyJSON GetAllFeatureVariables(string featureKey, string userId,
             var featureFlag = config.GetFeatureFlagFromKey(featureKey);
             if (string.IsNullOrEmpty(featureFlag.Key))
             {
-                Logger.Log(LogLevel.INFO, "No feature flag was found for key \""+ featureKey + "\".");
+                Logger.Log(LogLevel.INFO, "No feature flag was found for key \"" + featureKey + "\".");
                 return null;
             }
 
@@ -1039,7 +1038,7 @@ public OptimizelyJSON GetAllFeatureVariables(string featureKey, string userId,
             }
             else
             {
-                Logger.Log(LogLevel.INFO, "User \""+ userId + "\" was not bucketed into any variation for feature flag \""+ featureKey + "\". " +
+                Logger.Log(LogLevel.INFO, "User \"" + userId + "\" was not bucketed into any variation for feature flag \"" + featureKey + "\". " +
                         "The default values are being returned.");
             }
 
@@ -1048,7 +1047,7 @@ public OptimizelyJSON GetAllFeatureVariables(string featureKey, string userId,
                 Logger.Log(LogLevel.INFO, "Feature \"" + featureKey + "\" is enabled for user \"" + userId + "\"");
             }
             else
-            { 
+            {
                 Logger.Log(LogLevel.INFO, "Feature \"" + featureKey + "\" is not enabled for user \"" + userId + "\"");
             }
             var valuesMap = new Dictionary<string, object>();
@@ -1063,9 +1062,9 @@ public OptimizelyJSON GetAllFeatureVariables(string featureKey, string userId,
                         variableValue = featureVariableUsageInstance.Value;
                     }
                 }
-                
+
                 var typeCastedValue = GetTypeCastedVariableValue(variableValue, featureVariable.Type);
-                
+
                 if (typeCastedValue is OptimizelyJSON)
                     typeCastedValue = ((OptimizelyJSON)typeCastedValue).ToDictionary();
 
@@ -1089,7 +1088,7 @@ public OptimizelyJSON GetAllFeatureVariables(string featureKey, string userId,
 
             NotificationCenter.SendNotifications(NotificationCenter.NotificationType.Decision, DecisionNotificationTypes.ALL_FEATURE_VARIABLE, userId,
                 userAttributes ?? new UserAttributes(), decisionInfo);
-            
+
             return new OptimizelyJSON(valuesMap, ErrorHandler, Logger);
         }
 
@@ -1111,7 +1110,7 @@ public OptimizelyConfig GetOptimizelyConfig()
             // This check is needed in case a consumer provides their own ProjectConfigManager which does not implement IOptimizelyConfigManager interface
             if (ProjectConfigManager is IOptimizelyConfigManager)
             {
-                return ((IOptimizelyConfigManager) ProjectConfigManager).GetOptimizelyConfig();
+                return ((IOptimizelyConfigManager)ProjectConfigManager).GetOptimizelyConfig();
             }
 
             Logger.Log(LogLevel.DEBUG, "ProjectConfigManager is not instance of IOptimizelyConfigManager, generating new OptimizelyConfigObject as a fallback");
@@ -1119,7 +1118,7 @@ public OptimizelyConfig GetOptimizelyConfig()
             return new OptimizelyConfigService(config).GetOptimizelyConfig();
         }
 
-        #endregion // FeatureFlag APIs
+        #endregion FeatureFlag APIs
 
         /// <summary>
         /// Validate all string inputs are not null or empty.
@@ -1163,17 +1162,21 @@ private object GetTypeCastedVariableValue(string value, string type)
                     bool.TryParse(value, out bool booleanValue);
                     result = booleanValue;
                     break;
-                case FeatureVariable.DOUBLE_TYPE:                    
+
+                case FeatureVariable.DOUBLE_TYPE:
                     double.TryParse(value, System.Globalization.NumberStyles.Number, System.Globalization.CultureInfo.InvariantCulture, out double doubleValue);
                     result = doubleValue;
                     break;
+
                 case FeatureVariable.INTEGER_TYPE:
                     int.TryParse(value, out int intValue);
                     result = intValue;
                     break;
+
                 case FeatureVariable.STRING_TYPE:
                     result = value;
                     break;
+
                 case FeatureVariable.JSON_TYPE:
                     result = new OptimizelyJSON(value, ErrorHandler, Logger);
                     break;
@@ -1197,12 +1200,13 @@ public void Dispose()
             ProjectConfigManager = null;
         }
 
+        /// <inheritdoc/>
         public Variation GetFlagVariationByKey(string flagKey, string variationKey)
         {
             Dictionary<string, List<Variation>> flagVariationsMap = new Dictionary<string, List<Variation>>();
             if (flagVariationsMap.TryGetValue(flagKey, out var variations))
             {
-                foreach(var variation in variations)
+                foreach (var variation in variations)
                 {
                     if (variation.Key.Equals(variationKey))
                     {
@@ -1212,5 +1216,5 @@ public Variation GetFlagVariationByKey(string flagKey, string variationKey)
             }
             return null;
         }
-    }    
-}
+    }
+}
\ No newline at end of file

From 9723d7aaad3b44de7ab27d2c2a5c79ec8932d9d5 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Fri, 8 Oct 2021 11:27:43 -0400
Subject: [PATCH 016/130] changed tests to use user context correctly

---
 OptimizelySDK.Tests/DecisionServiceTest.cs | 126 +++--
 OptimizelySDK.Tests/OptimizelyTest.cs      | 555 +++++++++++++--------
 OptimizelySDK/Bucketing/DecisionService.cs |   5 +-
 OptimizelySDK/Optimizely.cs                |  11 +-
 4 files changed, 441 insertions(+), 256 deletions(-)

diff --git a/OptimizelySDK.Tests/DecisionServiceTest.cs b/OptimizelySDK.Tests/DecisionServiceTest.cs
index c5b29001..b68ce867 100644
--- a/OptimizelySDK.Tests/DecisionServiceTest.cs
+++ b/OptimizelySDK.Tests/DecisionServiceTest.cs
@@ -14,6 +14,7 @@
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */
+
 using System;
 using System.Collections.Generic;
 using Moq;
@@ -38,6 +39,7 @@ public class DecisionServiceTest
         private Mock<UserProfileService> UserProfileServiceMock;
         private Mock<Bucketer> BucketerMock;
         private Mock<DecisionService> DecisionServiceMock;
+        private Mock<OptimizelyUserContext> OptimizelyUserContextMock;
 
         private ProjectConfig ProjectConfig;
         private Experiment WhitelistedExperiment;
@@ -78,16 +80,18 @@ public void TestGetVariationForcedVariationPrecedesAudienceEval()
             Experiment experiment = ProjectConfig.Experiments[8];
             Variation expectedVariation = experiment.Variations[0];
 
+            OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns(GenericUserId);
             // user excluded without audiences and whitelisting
-            Assert.IsNull(decisionService.GetVariation(experiment, GenericUserId, ProjectConfig, new UserAttributes()).ResultObject);
+            Assert.IsNull(decisionService.GetVariation(experiment, OptimizelyUserContextMock.Object, ProjectConfig, new UserAttributes()).ResultObject);
 
-            var actualVariation = decisionService.GetVariation(experiment, WhitelistedUserId, ProjectConfig, new UserAttributes());
+            OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns(WhitelistedUserId);
+            var actualVariation = decisionService.GetVariation(experiment, OptimizelyUserContextMock.Object, ProjectConfig, new UserAttributes());
 
             LoggerMock.Verify(l => l.Log(LogLevel.INFO, string.Format("User \"{0}\" is forced in variation \"vtag5\".", WhitelistedUserId)), Times.Once);
-            
+
             // no attributes provided for a experiment that has an audience
             Assertions.AreEqual(expectedVariation, actualVariation.ResultObject);
-            
+
             BucketerMock.Verify(_ => _.Bucket(It.IsAny<ProjectConfig>(), It.IsAny<Experiment>(), It.IsAny<string>(), It.IsAny<string>()), Times.Never);
         }
 
@@ -104,15 +108,19 @@ public void TestGetVariationLogsErrorWhenUserProfileMapItsNull()
 
             DecisionService decisionService = new DecisionService(BucketerMock.Object, ErrorHandlerMock.Object, UserProfileServiceMock.Object, LoggerMock.Object);
             var options = new OptimizelyDecideOption[] { OptimizelyDecideOption.INCLUDE_REASONS };
-            var variationResult = decisionService.GetVariation(experiment, GenericUserId, ProjectConfig, new UserAttributes(), options);
+            OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns(GenericUserId);
+
+            var variationResult = decisionService.GetVariation(experiment, OptimizelyUserContextMock.Object, ProjectConfig, new UserAttributes(), options);
             Assert.AreEqual(variationResult.DecisionReasons.ToReport(true)[0], "We were unable to get a user profile map from the UserProfileService.");
             Assert.AreEqual(variationResult.DecisionReasons.ToReport(true)[1], "Audiences for experiment \"etag3\" collectively evaluated to FALSE");
             Assert.AreEqual(variationResult.DecisionReasons.ToReport(true)[2], "User \"genericUserId\" does not meet conditions to be in experiment \"etag3\".");
         }
-        
+
         [Test]
         public void TestGetVariationEvaluatesUserProfileBeforeAudienceTargeting()
         {
+            OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns(GenericUserId);
+
             Experiment experiment = ProjectConfig.Experiments[8];
             Variation variation = experiment.Variations[0];
 
@@ -126,13 +134,15 @@ public void TestGetVariationEvaluatesUserProfileBeforeAudienceTargeting()
 
             DecisionService decisionService = new DecisionService(BucketerMock.Object, ErrorHandlerMock.Object, UserProfileServiceMock.Object, LoggerMock.Object);
 
-            decisionService.GetVariation(experiment, GenericUserId, ProjectConfig, new UserAttributes());
+            decisionService.GetVariation(experiment, OptimizelyUserContextMock.Object, ProjectConfig, new UserAttributes());
 
             LoggerMock.Verify(l => l.Log(LogLevel.INFO, string.Format("User \"{0}\" does not meet conditions to be in experiment \"{1}\".",
                 GenericUserId, experiment.Key)), Times.Once);
 
+            OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns(UserProfileId);
+
             // ensure that a user with a saved user profile, sees the same variation regardless of audience evaluation
-            decisionService.GetVariation(experiment, UserProfileId, ProjectConfig, new UserAttributes());
+            decisionService.GetVariation(experiment, OptimizelyUserContextMock.Object, ProjectConfig, new UserAttributes());
 
             BucketerMock.Verify(_ => _.Bucket(It.IsAny<ProjectConfig>(), It.IsAny<Experiment>(), It.IsAny<string>(), It.IsAny<string>()), Times.Never);
         }
@@ -141,7 +151,9 @@ public void TestGetVariationEvaluatesUserProfileBeforeAudienceTargeting()
         public void TestGetForcedVariationReturnsForcedVariation()
         {
             DecisionService decisionService = new DecisionService(BucketerMock.Object, ErrorHandlerMock.Object, null, LoggerMock.Object);
+            var expectedVariation = decisionService.GetWhitelistedVariation(WhitelistedExperiment, WhitelistedUserId).ResultObject;
 
+            Assertions.AreEqual(WhitelistedVariation, expectedVariation);
             Assert.IsTrue(TestData.CompareObjects(WhitelistedVariation, decisionService.GetWhitelistedVariation(WhitelistedExperiment, WhitelistedUserId).ResultObject));
             LoggerMock.Verify(l => l.Log(LogLevel.INFO, string.Format("User \"{0}\" is forced in variation \"{1}\".",
                 WhitelistedUserId, WhitelistedVariation.Key)), Times.Once);
@@ -171,7 +183,8 @@ public void TestGetForcedVariationWithInvalidVariation()
                 {userId, invalidVariationKey }
             };
 
-            var experiment = new Experiment {
+            var experiment = new Experiment
+            {
                 Id = "1234",
                 Key = "exp_key",
                 Status = "Running",
@@ -213,12 +226,12 @@ public void TestBucketReturnsVariationStoredInUserProfile()
 
             UserProfileServiceMock.Setup(_ => _.Lookup(UserProfileId)).Returns(userProfile.ToMap());
 
-
             DecisionService decisionService = new DecisionService(BucketerMock.Object, ErrorHandlerMock.Object, UserProfileServiceMock.Object, LoggerMock.Object);
-            var actualVariation = decisionService.GetVariation(experiment, UserProfileId, ProjectConfig, new UserAttributes());
+            OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns(UserProfileId);
+            var actualVariation = decisionService.GetVariation(experiment, OptimizelyUserContextMock.Object, ProjectConfig, new UserAttributes());
 
             Assertions.AreEqual(variation, actualVariation.ResultObject);
-            
+
             Assert.AreEqual(actualVariation.DecisionReasons.ToReport(true).Count, 1);
             Assert.AreEqual(actualVariation.DecisionReasons.ToReport(true)[0], "Returning previously activated variation \"vtag1\" of experiment \"etag1\" for user \"userProfileId\" from user profile.");
 
@@ -226,7 +239,6 @@ public void TestBucketReturnsVariationStoredInUserProfile()
                 variation.Key, experiment.Key, UserProfileId)));
 
             //BucketerMock.Verify(_ => _.Bucket(It.IsAny<ProjectConfig>(), It.IsAny<Experiment>(), It.IsAny<string>()), Times.Once);
-
         }
 
         [Test]
@@ -296,7 +308,9 @@ public void TestGetVariationSavesBucketedVariationIntoUserProfile()
 
             DecisionService decisionService = new DecisionService(mockBucketer.Object, ErrorHandlerMock.Object, UserProfileServiceMock.Object, LoggerMock.Object);
 
-            Assert.IsTrue(TestData.CompareObjects(variation.ResultObject, decisionService.GetVariation(experiment, UserProfileId, ProjectConfig, new UserAttributes()).ResultObject));
+            OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns(UserProfileId);
+
+            Assert.IsTrue(TestData.CompareObjects(variation.ResultObject, decisionService.GetVariation(experiment, OptimizelyUserContextMock.Object, ProjectConfig, new UserAttributes()).ResultObject));
 
             LoggerMock.Verify(l => l.Log(LogLevel.INFO, string.Format("Saved variation \"{0}\" of experiment \"{1}\" for user \"{2}\".", variation.ResultObject.Id,
                         experiment.Id, UserProfileId)), Times.Once);
@@ -352,8 +366,9 @@ public void TestGetVariationSavesANewUserProfile()
 
             DecisionService decisionService = new DecisionService(mockBucketer.Object, ErrorHandlerMock.Object,
                 UserProfileServiceMock.Object, LoggerMock.Object);
+            OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns(UserProfileId);
 
-            var actualVariation = decisionService.GetVariation(experiment, UserProfileId, ProjectConfig, new UserAttributes());
+            var actualVariation = decisionService.GetVariation(experiment, OptimizelyUserContextMock.Object, ProjectConfig, new UserAttributes());
 
             Assertions.AreEqual(variation.ResultObject, actualVariation.ResultObject);
 
@@ -500,26 +515,31 @@ public void TestGetVariationWithBucketingId()
         public void TestGetVariationForFeatureExperimentGivenNullExperimentIds()
         {
             var featureFlag = ProjectConfig.GetFeatureFlagFromKey("empty_feature");
-            var decision = DecisionService.GetVariationForFeatureExperiment(featureFlag, GenericUserId, new UserAttributes() { }, ProjectConfig, new OptimizelyDecideOption[]{});
+            OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns(GenericUserId);
+
+            var decision = DecisionService.GetVariationForFeatureExperiment(featureFlag, OptimizelyUserContextMock.Object, new UserAttributes() { }, ProjectConfig, new OptimizelyDecideOption[] { });
 
             Assert.IsNull(decision.ResultObject);
 
             LoggerMock.Verify(l => l.Log(LogLevel.INFO, $"The feature flag \"{featureFlag.Key}\" is not used in any experiments."));
         }
 
-        // Should return null and log when the experiment is not in the datafile 
+        // Should return null and log when the experiment is not in the datafile
         [Test]
         public void TestGetVariationForFeatureExperimentGivenExperimentNotInDataFile()
         {
             var booleanFeature = ProjectConfig.GetFeatureFlagFromKey("boolean_feature");
-            var featureFlag = new FeatureFlag {
+            var featureFlag = new FeatureFlag
+            {
                 Id = booleanFeature.Id,
                 Key = booleanFeature.Key,
                 RolloutId = booleanFeature.RolloutId,
                 ExperimentIds = new List<string> { "29039203" }
             };
 
-            var decision = DecisionService.GetVariationForFeatureExperiment(featureFlag, GenericUserId, new UserAttributes() { }, ProjectConfig, new OptimizelyDecideOption[] { });
+            OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns(GenericUserId);
+
+            var decision = DecisionService.GetVariationForFeatureExperiment(featureFlag, OptimizelyUserContextMock.Object, new UserAttributes() { }, ProjectConfig, new OptimizelyDecideOption[] { });
             Assert.IsNull(decision.ResultObject);
 
             LoggerMock.Verify(l => l.Log(LogLevel.ERROR, "Experiment ID \"29039203\" is not in datafile."));
@@ -531,10 +551,12 @@ public void TestGetVariationForFeatureExperimentGivenNonMutexGroupAndUserNotBuck
         {
             var multiVariateExp = ProjectConfig.GetExperimentFromKey("test_experiment_multivariate");
 
-            DecisionServiceMock.Setup(ds => ds.GetVariation(multiVariateExp, "user1", ProjectConfig, null)).Returns<Variation>(null);
+            OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns("user1");
+
+            DecisionServiceMock.Setup(ds => ds.GetVariation(multiVariateExp, OptimizelyUserContextMock.Object, ProjectConfig, null)).Returns<Variation>(null);
             var featureFlag = ProjectConfig.GetFeatureFlagFromKey("multi_variate_feature");
 
-            var decision = DecisionServiceMock.Object.GetVariationForFeatureExperiment(featureFlag, "user1", new UserAttributes(), ProjectConfig, new OptimizelyDecideOption[] { });
+            var decision = DecisionServiceMock.Object.GetVariationForFeatureExperiment(featureFlag, OptimizelyUserContextMock.Object, new UserAttributes(), ProjectConfig, new OptimizelyDecideOption[] { });
             Assert.IsNull(decision.ResultObject);
 
             LoggerMock.Verify(l => l.Log(LogLevel.INFO, "The user \"user1\" is not bucketed into any of the experiments on the feature \"multi_variate_feature\"."));
@@ -549,11 +571,13 @@ public void TestGetVariationForFeatureExperimentGivenNonMutexGroupAndUserIsBucke
             var expectedDecision = new FeatureDecision(experiment, variation.ResultObject, FeatureDecision.DECISION_SOURCE_FEATURE_TEST);
             var userAttributes = new UserAttributes();
 
+            OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns("user1");
+
             DecisionServiceMock.Setup(ds => ds.GetVariation(ProjectConfig.GetExperimentFromKey("test_experiment_multivariate"),
-                "user1", ProjectConfig, userAttributes, It.IsAny<OptimizelyDecideOption[]> ())).Returns(variation);
+                OptimizelyUserContextMock.Object, ProjectConfig, userAttributes, It.IsAny<OptimizelyDecideOption[]>())).Returns(variation);
 
             var featureFlag = ProjectConfig.GetFeatureFlagFromKey("multi_variate_feature");
-            var decision = DecisionServiceMock.Object.GetVariationForFeatureExperiment(featureFlag, "user1", userAttributes, ProjectConfig, new OptimizelyDecideOption[] { });
+            var decision = DecisionServiceMock.Object.GetVariationForFeatureExperiment(featureFlag, OptimizelyUserContextMock.Object, userAttributes, ProjectConfig, new OptimizelyDecideOption[] { });
 
             Assert.IsTrue(TestData.CompareObjects(expectedDecision, decision.ResultObject));
 
@@ -568,36 +592,38 @@ public void TestGetVariationForFeatureExperimentGivenMutexGroupAndUserIsBucketed
             var variation = Result<Variation>.NewResult(mutexExperiment.Variations[0], DecisionReasons);
             var userAttributes = new UserAttributes();
             var expectedDecision = new FeatureDecision(mutexExperiment, variation.ResultObject, FeatureDecision.DECISION_SOURCE_FEATURE_TEST);
+            OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns("user1");
 
-            DecisionServiceMock.Setup(ds => ds.GetVariation(ProjectConfig.GetExperimentFromKey("group_experiment_1"), "user1", ProjectConfig,
+            DecisionServiceMock.Setup(ds => ds.GetVariation(ProjectConfig.GetExperimentFromKey("group_experiment_1"), OptimizelyUserContextMock.Object, ProjectConfig,
                 userAttributes)).Returns(variation);
 
             var featureFlag = ProjectConfig.GetFeatureFlagFromKey("boolean_feature");
-            var actualDecision = DecisionServiceMock.Object.GetVariationForFeatureExperiment(featureFlag, "user1", userAttributes, ProjectConfig, new OptimizelyDecideOption[] { });
+            var actualDecision = DecisionServiceMock.Object.GetVariationForFeatureExperiment(featureFlag, OptimizelyUserContextMock.Object, userAttributes, ProjectConfig, new OptimizelyDecideOption[] { });
 
             Assertions.AreEqual(expectedDecision, actualDecision.ResultObject);
 
             LoggerMock.Verify(l => l.Log(LogLevel.INFO, "The user \"user1\" is bucketed into experiment \"group_experiment_1\" of feature \"boolean_feature\"."));
         }
 
-        // Should return null and log a message when the user is not bucketed into any of the mutex experiments 
+        // Should return null and log a message when the user is not bucketed into any of the mutex experiments
         [Test]
         public void TestGetVariationForFeatureExperimentGivenMutexGroupAndUserNotBucketed()
         {
             var mutexExperiment = ProjectConfig.GetExperimentFromKey("group_experiment_1");
-            DecisionServiceMock.Setup(ds => ds.GetVariation(It.IsAny<Experiment>(), It.IsAny<string>(), ProjectConfig, It.IsAny<UserAttributes>(), It.IsAny<OptimizelyDecideOption[]>()))
+            OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns("user1");
+
+            DecisionServiceMock.Setup(ds => ds.GetVariation(It.IsAny<Experiment>(), It.IsAny<OptimizelyUserContext>(), ProjectConfig, It.IsAny<UserAttributes>(), It.IsAny<OptimizelyDecideOption[]>()))
                 .Returns(Result<Variation>.NullResult(null));
-                
 
             var featureFlag = ProjectConfig.GetFeatureFlagFromKey("boolean_feature");
-            var actualDecision = DecisionServiceMock.Object.GetVariationForFeatureExperiment(featureFlag, "user1", new UserAttributes(), ProjectConfig, new OptimizelyDecideOption[] { });
+            var actualDecision = DecisionServiceMock.Object.GetVariationForFeatureExperiment(featureFlag, OptimizelyUserContextMock.Object, new UserAttributes(), ProjectConfig, new OptimizelyDecideOption[] { });
 
             Assert.IsNull(actualDecision.ResultObject);
 
             LoggerMock.Verify(l => l.Log(LogLevel.INFO, "The user \"user1\" is not bucketed into any of the experiments on the feature \"boolean_feature\"."));
         }
 
-        #endregion // GetVariationForFeatureExperiment Tests
+        #endregion GetVariationForFeatureExperiment Tests
 
         #region GetVariationForFeatureRollout Tests
 
@@ -633,7 +659,7 @@ public void TestGetVariationForFeatureRolloutWhenRolloutIsNotInDataFile()
                 Variables = featureFlag.Variables
             };
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeatureExperiment(It.IsAny<FeatureFlag>(), It.IsAny<string>(), It.IsAny<UserAttributes>(), ProjectConfig, new OptimizelyDecideOption[] { })).Returns<Variation>(null);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeatureExperiment(It.IsAny<FeatureFlag>(), It.IsAny<OptimizelyUserContext>(), It.IsAny<UserAttributes>(), ProjectConfig, new OptimizelyDecideOption[] { })).Returns<Variation>(null);
 
             var actualDecision = DecisionServiceMock.Object.GetVariationForFeatureRollout(featureFlag, "user1", new UserAttributes(), ProjectConfig);
             Assert.IsNull(actualDecision.ResultObject);
@@ -689,7 +715,7 @@ public void TestGetVariationForFeatureRolloutWhenUserIsNotBucketedInTheTargeting
             Assert.IsTrue(TestData.CompareObjects(expectedDecision, actualDecision.ResultObject));
         }
 
-        // Should log and return null when  the user is not bucketed into the targeting rule 
+        // Should log and return null when  the user is not bucketed into the targeting rule
         // as well as "Everyone Else" rule.
         [Test]
         public void TestGetVariationForFeatureRolloutWhenUserIsNeitherBucketedInTheTargetingRuleNorToEveryoneElseRule()
@@ -804,7 +830,7 @@ public void TestGetVariationForFeatureRolloutCheckAudienceInEveryoneElseRule()
 
             BucketerMock.Setup(bm => bm.Bucket(It.IsAny<ProjectConfig>(), everyoneElseRule, It.IsAny<string>(), WhitelistedUserId)).Returns(variation);
             BucketerMock.Setup(bm => bm.Bucket(It.IsAny<ProjectConfig>(), everyoneElseRule, It.IsAny<string>(), GenericUserId)).Returns(Result<Variation>.NullResult(DecisionReasons));
-            
+
             var decisionService = new DecisionService(BucketerMock.Object, ErrorHandlerMock.Object, null, LoggerMock.Object);
 
             // Returned variation id should be of everyone else rule as it passes audience Id checking.
@@ -829,7 +855,7 @@ public void TestGetVariationForFeatureRolloutCheckAudienceInEveryoneElseRule()
             LoggerMock.Verify(l => l.Log(LogLevel.DEBUG, "User \"genericUserId\" does not meet the conditions for targeting rule \"3\"."), Times.Exactly(1));
         }
 
-        #endregion // GetVariationForFeatureRollout Tests
+        #endregion GetVariationForFeatureRollout Tests
 
         #region GetVariationForFeature Tests
 
@@ -843,14 +869,15 @@ public void TestGetVariationForFeatureWhenTheUserIsBucketedIntoFeatureExperiment
             var variation = expectedExperiment.Variations[0];
             var expectedDecision = Result<FeatureDecision>.NewResult(new FeatureDecision(expectedExperiment, variation, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeatureExperiment(It.IsAny<FeatureFlag>(), It.IsAny<string>(),
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeatureExperiment(It.IsAny<FeatureFlag>(), It.IsAny<OptimizelyUserContext>(),
                 It.IsAny<UserAttributes>(), ProjectConfig, It.IsAny<OptimizelyDecideOption[]>())).Returns(expectedDecision);
+            OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns("user1");
 
-            var actualDecision = DecisionServiceMock.Object.GetVariationForFeature(featureFlag, "user1", ProjectConfig, new UserAttributes());
+            var actualDecision = DecisionServiceMock.Object.GetVariationForFeature(featureFlag, OptimizelyUserContextMock.Object, ProjectConfig, new UserAttributes());
             Assert.IsTrue(TestData.CompareObjects(expectedDecision, actualDecision));
         }
 
-        // Should return the bucketed variation when the user is not bucketed in the feature flag experiment, 
+        // Should return the bucketed variation when the user is not bucketed in the feature flag experiment,
         // but is bucketed into a variation of the feature flag's rollout.
         [Test]
         public void TestGetVariationForFeatureWhenTheUserIsNotBucketedIntoFeatureExperimentAndBucketedToFeatureRollout()
@@ -862,12 +889,13 @@ public void TestGetVariationForFeatureWhenTheUserIsNotBucketedIntoFeatureExperim
             var variation = expectedExperiment.Variations[0];
             var expectedDecision = Result<FeatureDecision>.NewResult(new FeatureDecision(expectedExperiment, variation, FeatureDecision.DECISION_SOURCE_ROLLOUT), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeatureExperiment(It.IsAny<FeatureFlag>(), It.IsAny<string>(),
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeatureExperiment(It.IsAny<FeatureFlag>(), It.IsAny<OptimizelyUserContext>(),
                 It.IsAny<UserAttributes>(), ProjectConfig, It.IsAny<OptimizelyDecideOption[]>())).Returns(Result<FeatureDecision>.NullResult(null));
             DecisionServiceMock.Setup(ds => ds.GetVariationForFeatureRollout(It.IsAny<FeatureFlag>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), ProjectConfig)).Returns(expectedDecision);
+            OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns(UserProfileId);
 
-            var actualDecision = DecisionServiceMock.Object.GetVariationForFeature(featureFlag, "user1", ProjectConfig, new UserAttributes());
+            var actualDecision = DecisionServiceMock.Object.GetVariationForFeature(featureFlag, OptimizelyUserContextMock.Object, ProjectConfig, new UserAttributes());
 
             Assert.IsTrue(TestData.CompareObjects(expectedDecision, actualDecision));
 
@@ -881,16 +909,16 @@ public void TestGetVariationForFeatureWhenTheUserIsNeitherBucketedIntoFeatureExp
             var featureFlag = ProjectConfig.GetFeatureFlagFromKey("string_single_variable_feature");
             var expectedDecision = new FeatureDecision(null, null, FeatureDecision.DECISION_SOURCE_ROLLOUT);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeatureExperiment(It.IsAny<FeatureFlag>(), It.IsAny<string>(), It.IsAny<UserAttributes>(), ProjectConfig, new OptimizelyDecideOption[] { })).Returns(Result<FeatureDecision>.NullResult(null));
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeatureExperiment(It.IsAny<FeatureFlag>(), It.IsAny<OptimizelyUserContext>(), It.IsAny<UserAttributes>(), ProjectConfig, new OptimizelyDecideOption[] { })).Returns(Result<FeatureDecision>.NullResult(null));
             DecisionServiceMock.Setup(ds => ds.GetVariationForFeatureRollout(It.IsAny<FeatureFlag>(), It.IsAny<string>(), It.IsAny<UserAttributes>(), ProjectConfig)).Returns(Result<FeatureDecision>.NullResult(null));
 
-            var actualDecision = DecisionServiceMock.Object.GetVariationForFeature(featureFlag, "user1", ProjectConfig, new UserAttributes());
+            var actualDecision = DecisionServiceMock.Object.GetVariationForFeature(featureFlag, OptimizelyUserContextMock.Object, ProjectConfig, new UserAttributes());
             Assert.IsTrue(TestData.CompareObjects(expectedDecision, actualDecision.ResultObject));
 
             LoggerMock.Verify(l => l.Log(LogLevel.INFO, "The user \"user1\" is not bucketed into a rollout for feature flag \"string_single_variable_feature\"."));
         }
 
-        // Verify that the user is bucketed into the experiment's variation when the user satisfies bucketing and traffic allocation 
+        // Verify that the user is bucketed into the experiment's variation when the user satisfies bucketing and traffic allocation
         // for feature flag experiment and feature flag rollout.
         [Test]
         public void TestGetVariationForFeatureWhenTheUserIsBuckedtedInBothExperimentAndRollout()
@@ -902,9 +930,10 @@ public void TestGetVariationForFeatureWhenTheUserIsBuckedtedInBothExperimentAndR
             var userAttributes = new UserAttributes {
                 { "browser_type", "chrome" }
             };
+            OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns(UserProfileId);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, "user1", ProjectConfig, userAttributes, It.IsAny<OptimizelyDecideOption[]>())).Returns(variation);
-            var actualDecision = DecisionServiceMock.Object.GetVariationForFeatureExperiment(featureFlag, "user1", userAttributes, ProjectConfig, new OptimizelyDecideOption[] { });
+            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, OptimizelyUserContextMock.Object, ProjectConfig, userAttributes, It.IsAny<OptimizelyDecideOption[]>())).Returns(variation);
+            var actualDecision = DecisionServiceMock.Object.GetVariationForFeatureExperiment(featureFlag, OptimizelyUserContextMock.Object, userAttributes, ProjectConfig, new OptimizelyDecideOption[] { });
 
             // The user is bucketed into feature experiment's variation.
             Assert.IsTrue(TestData.CompareObjects(expectedDecision, actualDecision.ResultObject));
@@ -921,16 +950,16 @@ public void TestGetVariationForFeatureWhenTheUserIsBuckedtedInBothExperimentAndR
 
             Assert.IsTrue(TestData.CompareObjects(expectedRolloutDecision, actualRolloutDecision.ResultObject));
 
-            actualDecision = DecisionServiceMock.Object.GetVariationForFeature(featureFlag, "user1", ProjectConfig, userAttributes);
+            actualDecision = DecisionServiceMock.Object.GetVariationForFeature(featureFlag, OptimizelyUserContextMock.Object, ProjectConfig, userAttributes);
 
             // The user is bucketed into feature experiment's variation and not the rollout's variation.
             Assert.IsTrue(TestData.CompareObjects(expectedDecision, actualDecision.ResultObject));
-
         }
 
-        #endregion // GetVariationForFeature Tests
+        #endregion GetVariationForFeature Tests
 
         #region Forced variation Tests
+
         [Test]
         public void TestSetGetForcedVariation()
         {
@@ -1040,7 +1069,6 @@ public void TestGetForcedVariationLogs()
         [Test]
         public void TestSetForcedVariationMultipleSets()
         {
-
             Assert.True(DecisionService.SetForcedVariation("test_experiment", "test_user_1", "variation", Config));
             Assert.AreEqual(DecisionService.GetForcedVariation("test_experiment", "test_user_1", Config).ResultObject.Key, "variation");
 
@@ -1065,6 +1093,6 @@ public void TestSetForcedVariationMultipleSets()
             Assert.AreEqual(DecisionService.GetForcedVariation("group_experiment_1", "test_user_1", Config).ResultObject.Key, "group_exp_1_var_1");
         }
 
-        #endregion // Forced variation Tests
+        #endregion Forced variation Tests
     }
 }
\ No newline at end of file
diff --git a/OptimizelySDK.Tests/OptimizelyTest.cs b/OptimizelySDK.Tests/OptimizelyTest.cs
index 381a1bb3..e73172cf 100644
--- a/OptimizelySDK.Tests/OptimizelyTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyTest.cs
@@ -1,4 +1,4 @@
-/* 
+/*
  * Copyright 2017-2021, Optimizely
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 using System;
 using System.Collections.Generic;
 using Moq;
@@ -44,7 +45,7 @@ public class OptimizelyTest
     {
         private Mock<ILogger> LoggerMock;
         private ProjectConfigManager ConfigManager;
-        private ProjectConfig Config;       
+        private ProjectConfig Config;
         private Mock<IErrorHandler> ErrorHandlerMock;
         private Mock<IEventDispatcher> EventDispatcherMock;
         private Optimizely Optimizely;
@@ -61,13 +62,14 @@ public class OptimizelyTest
         private Optimizely OptimizelyWithTypedAudiences;
         private DecisionReasons DecisionReasons;
 
-        const string FEATUREVARIABLE_BOOLEANTYPE = "boolean";
-        const string FEATUREVARIABLE_INTEGERTYPE = "integer";
-        const string FEATUREVARIABLE_DOUBLETYPE = "double";
-        const string FEATUREVARIABLE_STRINGTYPE = "string";
-        const string FEATUREVARIABLE_JSONTYPE = "json";
+        private const string FEATUREVARIABLE_BOOLEANTYPE = "boolean";
+        private const string FEATUREVARIABLE_INTEGERTYPE = "integer";
+        private const string FEATUREVARIABLE_DOUBLETYPE = "double";
+        private const string FEATUREVARIABLE_STRINGTYPE = "string";
+        private const string FEATUREVARIABLE_JSONTYPE = "json";
 
         #region Test Life Cycle
+
         [SetUp]
         public void Initialize()
         {
@@ -120,14 +122,16 @@ public void Initialize()
         public void Cleanup()
         {
             LoggerMock = null;
-            Config = null;            
+            Config = null;
         }
-        #endregion
-        
+
+        #endregion Test Life Cycle
+
         #region OptimizelyHelper
+
         private class OptimizelyHelper
         {
-            static Type[] ParameterTypes = {
+            private static Type[] ParameterTypes = {
                 typeof(string),
                 typeof(IEventDispatcher),
                 typeof(ILogger),
@@ -186,7 +190,8 @@ public PrivateObject CreatePrivateOptimizely()
                     });
             }
         }
-        #endregion
+
+        #endregion OptimizelyHelper
 
         #region Test UserContext
 
@@ -216,14 +221,13 @@ public void TestCreateUserContextWithoutAttributes()
         [Test]
         public void TestCreateUserContextMultipleAttribute()
         {
-
             var attribute1 = new UserAttributes
                 {
                     { "device_type", "iPhone" },
                     { "location", "San Francisco" }
                 };
             var optlyUserContext1 = Optimizely.CreateUserContext("userId1", attribute1);
-            
+
             var attribute2 = new UserAttributes
                 {
                     { "device_type2", "Samsung" },
@@ -432,9 +436,10 @@ public void TestChangeAttributeDoesNotEffectValues()
             Assert.AreNotEqual(attribute, optlyUserContext.GetAttributes());
         }
 
-        #endregion
+        #endregion Test UserContext
 
         #region Test Validate
+
         [Test]
         public void TestInvalidInstanceLogMessages()
         {
@@ -463,8 +468,8 @@ public void TestInvalidInstanceLogMessages()
             LoggerMock.Verify(log => log.Log(LogLevel.ERROR, "Datafile has invalid format. Failing 'GetFeatureVariableDouble'."), Times.Once);
             LoggerMock.Verify(log => log.Log(LogLevel.ERROR, "Datafile has invalid format. Failing 'GetFeatureVariableInteger'."), Times.Once);
             LoggerMock.Verify(log => log.Log(LogLevel.ERROR, "Datafile has invalid format. Failing 'GetFeatureVariableJSON'."), Times.Once);
-
         }
+
         [Test]
         public void TestValidateInputsInvalidFileJsonValidationNotSkipped()
         {
@@ -572,11 +577,10 @@ public void TestValidatePreconditionsUserNotInForcedVariationInExperiment()
             {
                 { "device_type", "iPhone" },
                 { "location", "San Francisco" }
-
             };
 
             var variation = Optimizely.GetVariation("test_experiment", "test_user", attributes);
-            
+
             LoggerMock.Verify(l => l.Log(LogLevel.DEBUG, "User \"test_user\" is not in the forced variation map."), Times.Once);
             LoggerMock.Verify(l => l.Log(LogLevel.DEBUG, "Assigned bucket [3037] to user [test_user] with bucketing ID [test_user]."), Times.Once);
             LoggerMock.Verify(l => l.Log(LogLevel.INFO, "User [test_user] is in variation [control] of experiment [test_experiment]."), Times.Once);
@@ -614,10 +618,10 @@ public void TestActivateInvalidAttributes()
         [Test]
         public void TestActivateUserInNoVariation()
         {
-            var optly = Helper.CreatePrivateOptimizely();            
+            var optly = Helper.CreatePrivateOptimizely();
+
+            var result = optly.Invoke("Activate", "test_experiment", "not_in_variation_user", OptimizelyHelper.UserAttributes);
 
-            var result = optly.Invoke("Activate", "test_experiment", "not_in_variation_user", OptimizelyHelper.UserAttributes);            
-            
             LoggerMock.Verify(l => l.Log(LogLevel.DEBUG, "Assigned bucket [8495] to user [not_in_variation_user] with bucketing ID [not_in_variation_user]."), Times.Once);
             LoggerMock.Verify(l => l.Log(LogLevel.INFO, "User [not_in_variation_user] is in no variation."), Times.Once);
             LoggerMock.Verify(l => l.Log(LogLevel.INFO, "Not activating user not_in_variation_user."), Times.Once);
@@ -634,13 +638,12 @@ public void TestActivateNoAudienceNoAttributes()
                 { "param2", "val2" }
             };
 
-            
-            var optly = Helper.CreatePrivateOptimizely();            
+            var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("EventProcessor", EventProcessorMock.Object);
 
             var variation = (Variation)optly.Invoke("Activate", "group_experiment_1", "user_1", null);
-            
-            EventProcessorMock.Verify(ep => ep.Process(It.IsAny<ImpressionEvent>()), Times.Once);            
+
+            EventProcessorMock.Verify(ep => ep.Process(It.IsAny<ImpressionEvent>()), Times.Once);
 
             LoggerMock.Verify(l => l.Log(LogLevel.DEBUG, "Assigned bucket [1922] to user [user_1] with bucketing ID [user_1]."), Times.Once);
             LoggerMock.Verify(l => l.Log(LogLevel.INFO, "User [user_1] is in experiment [group_experiment_1] of group [7722400015]."), Times.Once);
@@ -650,16 +653,18 @@ public void TestActivateNoAudienceNoAttributes()
 
             Assert.IsTrue(TestData.CompareObjects(GroupVariation, variation));
         }
-        #endregion
+
+        #endregion Test Validate
 
         #region Test Activate
+
         [Test]
         public void TestActivateAudienceNoAttributes()
         {
-            var optly = Helper.CreatePrivateOptimizely();            
+            var optly = Helper.CreatePrivateOptimizely();
 
             var variationkey = optly.Invoke("Activate", "test_experiment", "test_user", null);
-                        
+
             LoggerMock.Verify(l => l.Log(LogLevel.INFO, "User \"test_user\" does not meet conditions to be in experiment \"test_experiment\"."), Times.Once);
             LoggerMock.Verify(l => l.Log(LogLevel.INFO, "Not activating user test_user."), Times.Once);
 
@@ -669,12 +674,11 @@ public void TestActivateAudienceNoAttributes()
         [Test]
         public void TestActivateWithAttributes()
         {
-           
-            var optly = Helper.CreatePrivateOptimizely();            
+            var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("EventProcessor", EventProcessorMock.Object);
 
             var variation = (Variation)optly.Invoke("Activate", "test_experiment", "test_user", OptimizelyHelper.UserAttributes);
-            
+
             EventProcessorMock.Verify(ep => ep.Process(It.IsAny<ImpressionEvent>()), Times.Once);
 
             LoggerMock.Verify(l => l.Log(LogLevel.DEBUG, "User \"test_user\" is not in the forced variation map."), Times.Once);
@@ -689,10 +693,9 @@ public void TestActivateWithAttributes()
         [Test]
         public void TestActivateWithNullAttributes()
         {
-           
-            var optly = Helper.CreatePrivateOptimizely();            
+            var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("EventProcessor", EventProcessorMock.Object);
-            
+
             var variation = (Variation)optly.Invoke("Activate", "test_experiment", "test_user", OptimizelyHelper.NullUserAttributes);
 
             EventProcessorMock.Verify(ep => ep.Process(It.IsAny<ImpressionEvent>()), Times.Once);
@@ -711,7 +714,7 @@ public void TestActivateExperimentNotRunning()
         {
             var optly = Helper.CreatePrivateOptimizely();
 
-            var variationkey = optly.Invoke("Activate", "paused_experiment", "test_user", null);            
+            var variationkey = optly.Invoke("Activate", "paused_experiment", "test_user", null);
 
             LoggerMock.Verify(l => l.Log(It.IsAny<LogLevel>(), It.IsAny<string>()), Times.Exactly(2));
             LoggerMock.Verify(l => l.Log(LogLevel.INFO, "Experiment \"paused_experiment\" is not running."), Times.Once);
@@ -745,9 +748,11 @@ public void TestActivateWithTypedAttributes()
 
             Assert.IsTrue(TestData.CompareObjects(VariationWithKeyControl, variation));
         }
-        #endregion
+
+        #endregion Test Activate
 
         #region Test GetVariation
+
         [Test]
         public void TestGetVariationInvalidOptimizelyObject()
         {
@@ -773,6 +778,7 @@ public void TestGetVariationInvalidAttributes()
 
             Assert.IsNull(result);
         } */
+
         [Test]
         public void TestGetVariationAudienceMatch()
         {
@@ -783,7 +789,7 @@ public void TestGetVariationAudienceMatch()
             };
 
             var variation = Optimizely.GetVariation("test_experiment", "test_user", attributes);
-            
+
             LoggerMock.Verify(l => l.Log(LogLevel.DEBUG, "Assigned bucket [3037] to user [test_user] with bucketing ID [test_user]."), Times.Once);
             LoggerMock.Verify(l => l.Log(LogLevel.INFO, "User [test_user] is in variation [control] of experiment [test_experiment]."), Times.Once);
             LoggerMock.Verify(l => l.Log(LogLevel.INFO, "This decision will not be saved since the UserProfileService is null."), Times.Once);
@@ -815,9 +821,11 @@ public void TestTrackInvalidOptimizelyObject()
             LoggerMock.Verify(l => l.Log(It.IsAny<LogLevel>(), It.IsAny<string>()), Times.Exactly(2));
             LoggerMock.Verify(l => l.Log(LogLevel.ERROR, "Datafile has invalid format. Failing 'Track'."), Times.Once);
         }
-        #endregion
+
+        #endregion Test GetVariation
 
         #region Test Track
+
         [Test]
         public void TestTrackInvalidAttributes()
         {
@@ -837,22 +845,22 @@ public void TestTrackNoAttributesNoEventValue()
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("EventProcessor", EventProcessorMock.Object);
 
-            optly.Invoke("Track", "purchase", "test_user", null, null);            
-            EventProcessorMock.Verify(processor => processor.Process(It.IsAny<ConversionEvent>()), Times.Once);            
+            optly.Invoke("Track", "purchase", "test_user", null, null);
+            EventProcessorMock.Verify(processor => processor.Process(It.IsAny<ConversionEvent>()), Times.Once);
 
-            LoggerMock.Verify(l => l.Log(LogLevel.INFO, "Tracking event purchase for user test_user."), Times.Once);            
+            LoggerMock.Verify(l => l.Log(LogLevel.INFO, "Tracking event purchase for user test_user."), Times.Once);
         }
 
         [Test]
         public void TestTrackWithAttributesNoEventValue()
         {
-            var optly = Helper.CreatePrivateOptimizely();            
+            var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("EventProcessor", EventProcessorMock.Object);
 
             optly.Invoke("Track", "purchase", "test_user", OptimizelyHelper.UserAttributes, null);
             EventProcessorMock.Verify(ep => ep.Process(It.IsAny<ConversionEvent>()), Times.Once);
 
-            LoggerMock.Verify(l => l.Log(LogLevel.INFO, "Tracking event purchase for user test_user."), Times.Once);            
+            LoggerMock.Verify(l => l.Log(LogLevel.INFO, "Tracking event purchase for user test_user."), Times.Once);
         }
 
         [Test]
@@ -867,16 +875,16 @@ public void TestTrackUnknownEventKey()
         [Test]
         public void TestTrackNoAttributesWithEventValue()
         {
-            var optly = Helper.CreatePrivateOptimizely();            
+            var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("EventProcessor", EventProcessorMock.Object);
-            
+
             optly.Invoke("Track", "purchase", "test_user", null, new EventTags
             {
                 { "revenue", 42 }
             });
             EventProcessorMock.Verify(ep => ep.Process(It.IsAny<ConversionEvent>()), Times.Once);
 
-            LoggerMock.Verify(l => l.Log(LogLevel.INFO, "Tracking event purchase for user test_user."), Times.Once);            
+            LoggerMock.Verify(l => l.Log(LogLevel.INFO, "Tracking event purchase for user test_user."), Times.Once);
         }
 
         [Test]
@@ -890,7 +898,7 @@ public void TestTrackWithAttributesWithEventValue()
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("EventProcessor", EventProcessorMock.Object);
-                        
+
             optly.Invoke("Track", "purchase", "test_user", attributes, new EventTags
             {
                 { "revenue", 42 }
@@ -898,7 +906,7 @@ public void TestTrackWithAttributesWithEventValue()
 
             EventProcessorMock.Verify(ep => ep.Process(It.IsAny<ConversionEvent>()), Times.Once);
 
-            LoggerMock.Verify(l => l.Log(LogLevel.INFO, "Tracking event purchase for user test_user."), Times.Once);            
+            LoggerMock.Verify(l => l.Log(LogLevel.INFO, "Tracking event purchase for user test_user."), Times.Once);
         }
 
         [Test]
@@ -906,7 +914,6 @@ public void TestTrackWithNullAttributesWithNullEventValue()
         {
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("EventProcessor", EventProcessorMock.Object);
-            
 
             optly.Invoke("Track", "purchase", "test_user", OptimizelyHelper.NullUserAttributes, new EventTags
             {
@@ -914,18 +921,20 @@ public void TestTrackWithNullAttributesWithNullEventValue()
                 { "wont_send_null", null}
             });
 
-            EventProcessorMock.Verify(ep => ep.Process(It.IsAny<ConversionEvent>()), Times.Once);            
+            EventProcessorMock.Verify(ep => ep.Process(It.IsAny<ConversionEvent>()), Times.Once);
 
             LoggerMock.Verify(l => l.Log(LogLevel.ERROR, "[EventTags] Null value for key wont_send_null removed and will not be sent to results."));
-            LoggerMock.Verify(l => l.Log(LogLevel.INFO, "Tracking event purchase for user test_user."));            
+            LoggerMock.Verify(l => l.Log(LogLevel.INFO, "Tracking event purchase for user test_user."));
         }
-        #endregion
+
+        #endregion Test Track
 
         #region Test Invalid Dispatch
+
         [Test]
         public void TestInvalidDispatchImpressionEvent()
         {
-            var optly = Helper.CreatePrivateOptimizely();            
+            var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("EventDispatcher", new InvalidEventDispatcher());
 
             var variation = (Variation)optly.Invoke("Activate", "test_experiment", "test_user", OptimizelyHelper.UserAttributes);
@@ -934,7 +943,7 @@ public void TestInvalidDispatchImpressionEvent()
 
             LoggerMock.Verify(l => l.Log(LogLevel.DEBUG, "Assigned bucket [3037] to user [test_user] with bucketing ID [test_user]."), Times.Once);
             LoggerMock.Verify(l => l.Log(LogLevel.INFO, "User [test_user] is in variation [control] of experiment [test_experiment]."), Times.Once);
-            
+
             LoggerMock.Verify(l => l.Log(LogLevel.INFO, "Activating user test_user in experiment test_experiment."), Times.Once);
             // Need to see how error handler can be verified.
             LoggerMock.Verify(l => l.Log(LogLevel.ERROR, It.IsAny<string>()), Times.Once);
@@ -945,22 +954,25 @@ public void TestInvalidDispatchImpressionEvent()
         [Test]
         public void TestInvalidDispatchConversionEvent()
         {
-            var optly = Helper.CreatePrivateOptimizely();            
+            var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("EventDispatcher", new InvalidEventDispatcher());
 
             optly.Invoke("Track", "purchase", "test_user", null, null);
 
             EventDispatcherMock.Verify(dispatcher => dispatcher.DispatchEvent(It.IsAny<LogEvent>()), Times.Once);
 
-            LoggerMock.Verify(l => l.Log(LogLevel.INFO, "Tracking event purchase for user test_user."), Times.Once);            
+            LoggerMock.Verify(l => l.Log(LogLevel.INFO, "Tracking event purchase for user test_user."), Times.Once);
         }
-        #endregion
+
+        #endregion Test Invalid Dispatch
 
         #region Test Misc
+
         /* Start 1 */
+
         public void TestTrackNoAttributesWithInvalidEventValue()
-        {            
-            var optly = Helper.CreatePrivateOptimizely();            
+        {
+            var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("EventDispatcher", new ValidEventDispatcher());
 
             optly.Invoke("Track", "purchase", "test_user", null, new Dictionary<string, object>
@@ -971,17 +983,17 @@ public void TestTrackNoAttributesWithInvalidEventValue()
 
         public void TestTrackNoAttributesWithDeprecatedEventValue()
         {
-            /* Note: This case is not applicable, C# only accepts what the datatype we provide. 
+            /* Note: This case is not applicable, C# only accepts what the datatype we provide.
              * In this case, int value can't be casted implicitly into Dictionary */
-            
-            var optly = Helper.CreatePrivateOptimizely();            
+
+            var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("EventDispatcher", new ValidEventDispatcher());
             optly.Invoke("Track", "purchase", "test_user", null, new Dictionary<string, object>
             {
                 {"revenue", 42 }
             });
         }
-        
+
         [Test]
         public void TestForcedVariationPreceedsWhitelistedVariation()
         {
@@ -1024,7 +1036,6 @@ public void TestForcedVariationPreceedsUserProfile()
             var userId = "testUser3";
             var variationKey = "vtag2";
             var fbVariationKey = "vtag1";
-            
 
             UserProfile userProfile = new UserProfile(userId, new Dictionary<string, Bucketing.Decision>
             {
@@ -1046,13 +1057,13 @@ public void TestForcedVariationPreceedsUserProfile()
 
             var variation2 = optimizely.GetVariation(experimentKey, userId);
             Assert.IsTrue(TestData.CompareObjects(expectedFbVariation, variation2));
-            
+
             //remove forced variation and re-check userprofile
             Assert.IsTrue(optimizely.SetForcedVariation(experimentKey, userId, null));
 
             variationUserProfile = optimizely.GetVariation(experimentKey, userId);
             Assert.IsTrue(TestData.CompareObjects(expectedVariation, variationUserProfile));
-            
+
             LoggerMock.Verify(l => l.Log(LogLevel.DEBUG, "User \"testUser3\" is not in the forced variation map."), Times.Once);
             LoggerMock.Verify(l => l.Log(LogLevel.INFO, "No previously activated variation of experiment \"etag1\" for user \"testUser3\" found in user profile."), Times.Exactly(2));
             LoggerMock.Verify(l => l.Log(LogLevel.DEBUG, "Assigned bucket [4969] to user [testUser3] with bucketing ID [testUser3]."), Times.Exactly(2));
@@ -1181,7 +1192,7 @@ public void TestGetForcedVariation()
             // call getForcedVariation with valid experiment key and valid user ID
             var actualForcedVariation = Optimizely.GetForcedVariation("test_experiment", TestUserId);
             Assert.IsTrue(TestData.CompareObjects(expectedForcedVariation, actualForcedVariation));
-            
+
             // call getForcedVariation with invalid experiment and valid userID
             actualForcedVariation = Optimizely.GetForcedVariation("invalid_experiment", TestUserId);
             Assert.Null(actualForcedVariation);
@@ -1197,7 +1208,7 @@ public void TestGetForcedVariation()
             actualForcedVariation = Optimizely.GetForcedVariation("paused_experiment", "test_user2");
 
             Assert.IsTrue(TestData.CompareObjects(expectedForcedVariation2, actualForcedVariation));
-            
+
             // confirm that the second setForcedVariation call did not invalidate the first call to that method
             actualForcedVariation = Optimizely.GetForcedVariation("test_experiment", TestUserId);
 
@@ -1220,7 +1231,7 @@ public void TestGetForcedVariationWithInvalidExperimentKey()
             var userId = "test_user";
             var experimentKey = "test_experiment";
             Optimizely.SetForcedVariation(experimentKey, userId, "test_variation");
-            
+
             Assert.Null(Optimizely.GetForcedVariation("test_experiment", userId));
             Assert.Null(Optimizely.GetForcedVariation("", userId));
             Assert.Null(Optimizely.GetForcedVariation(null, userId));
@@ -1284,7 +1295,7 @@ public void TestGetVariationWhitelistedUserAfterSetForcedVariation()
             var experimentId = "7716830082";
             var variationKey = "variation";
             var variationId = "7721010009";
-            
+
             Assert.True(Optimizely.SetForcedVariation(experimentKey, userId, variationKey), "Set variation for paused experiment should have passed.");
             var variation = Optimizely.GetVariation(experimentKey, userId);
 
@@ -1312,12 +1323,12 @@ public void TestActivateNoAudienceNoAttributesAfterSetForcedVariation()
             Experiment experiment = new Experiment();
             experiment.Key = "group_experiment_1";
 
-            var optly = Helper.CreatePrivateOptimizely();            
+            var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("ProjectConfigManager", ConfigManager);
 
             // Set forced variation
             Assert.True((bool)optly.Invoke("SetForcedVariation", experimentKey, userId, variationKey), "Set variation for paused experiment should have failed.");
-            
+
             // Activate
             var variation = (Variation)optly.Invoke("Activate", "group_experiment_1", "user_1", null);
 
@@ -1348,7 +1359,7 @@ public void TestTrackNoAttributesNoEventValueAfterSetForcedVariation()
                 { "param1", "val1" }
             };
 
-            var optly = Helper.CreatePrivateOptimizely();            
+            var optly = Helper.CreatePrivateOptimizely();
 
             // Set forced variation
             Assert.True((bool)optly.Invoke("SetForcedVariation", experimentKey, userId, variationKey), "Set variation for paused experiment should have failed.");
@@ -1356,9 +1367,9 @@ public void TestTrackNoAttributesNoEventValueAfterSetForcedVariation()
             // Track
             optly.Invoke("Track", "purchase", "test_user", null, null);
             EventDispatcherMock.Verify(dispatcher => dispatcher.DispatchEvent(It.IsAny<LogEvent>()), Times.Once);
-            
+
             LoggerMock.Verify(l => l.Log(LogLevel.DEBUG, string.Format(@"Set variation ""{0}"" for experiment ""{1}"" and user ""{2}"" in the forced variation map.", variationId, experimentId, userId)), Times.Once);
-            LoggerMock.Verify(l => l.Log(LogLevel.INFO, "Tracking event purchase for user test_user."), Times.Once);            
+            LoggerMock.Verify(l => l.Log(LogLevel.INFO, "Tracking event purchase for user test_user."), Times.Once);
         }
 
         [Test]
@@ -1401,7 +1412,7 @@ public void TestGetVariationBucketingIdAttribute()
             Assert.Null(actualVariation, string.Format("Invalid variation key \"{0}\" for getVariation with bucketing ID \"{1}\".", actualVariation?.Key, testBucketingIdControl));
         }
 
-        #endregion
+        #endregion Test Misc
 
         #region Test GetFeatureVariable<Type> methods
 
@@ -1426,7 +1437,7 @@ public void TestGetFeatureVariableBooleanReturnsCorrectValue()
             OptimizelyMock.Setup(om => om.GetFeatureVariableValueForType<string>(It.IsAny<string>(), variableKeyNonBoolean, It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), featureVariableType)).Returns("non_boolean_value");
             Assert.Null(OptimizelyMock.Object.GetFeatureVariableBoolean(featureKey, variableKeyNonBoolean, TestUserId, null));
-            
+
             OptimizelyMock.Setup(om => om.GetFeatureVariableValueForType<bool?>(It.IsAny<string>(), variableKeyNull, It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), featureVariableType)).Returns<bool?>(null);
             Assert.Null(OptimizelyMock.Object.GetFeatureVariableBoolean(featureKey, variableKeyNull, TestUserId, null));
@@ -1441,10 +1452,10 @@ public void TestGetFeatureVariableDoubleFRCulture()
             var optimizely = new Optimizely(fallbackConfigManager);
 
             var doubleValue = optimizely.GetFeatureVariableDouble("double_single_variable_feature", "double_variable", "testUser1");
-            
+
             Assert.AreEqual(doubleValue, 14.99);
 
-            SetCulture("fr-FR");            
+            SetCulture("fr-FR");
             var doubleValueFR = optimizely.GetFeatureVariableDouble("double_single_variable_feature", "double_variable", "testUser1");
             Assert.AreEqual(doubleValueFR, 14.99);
         }
@@ -1520,7 +1531,7 @@ public void TestGetFeatureVariableJSONFRCulture()
             Assert.AreEqual(optimizelyJsonValue.GetValue<long>("int_var"), 1);
             Assert.AreEqual(optimizelyJsonValue.GetValue<bool>("boolean_key"), false);
             Assert.IsTrue(TestData.CompareObjects(optimizelyJsonValue.GetValue<object>(""), expectedDict));
-            
+
             SetCulture("fr-FR");
             var optimizelyJsonValueFR = optimizely.GetFeatureVariableJSON("string_single_variable_feature", "json_var", "testUser1");
 
@@ -1551,7 +1562,7 @@ public void TestGetFeatureVariableDoubleReturnsCorrectValue()
             OptimizelyMock.Setup(om => om.GetFeatureVariableValueForType<string>(It.IsAny<string>(), variableKeyNonDouble, It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), featureVariableType)).Returns("non_double_value");
             Assert.Null(OptimizelyMock.Object.GetFeatureVariableDouble(featureKey, variableKeyNonDouble, TestUserId, null));
-            
+
             OptimizelyMock.Setup(om => om.GetFeatureVariableValueForType<double?>(It.IsAny<string>(), variableKeyNull, It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), featureVariableType)).Returns<double?>(null);
             Assert.Null(OptimizelyMock.Object.GetFeatureVariableDouble(featureKey, variableKeyNull, TestUserId, null));
@@ -1569,11 +1580,11 @@ public void TestGetFeatureVariableIntegerReturnsCorrectValue()
             OptimizelyMock.Setup(om => om.GetFeatureVariableValueForType<int?>(It.IsAny<string>(), variableKeyInt, It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), featureVariableType)).Returns(100);
             Assert.AreEqual(100, OptimizelyMock.Object.GetFeatureVariableInteger(featureKey, variableKeyInt, TestUserId, null));
-            
+
             OptimizelyMock.Setup(om => om.GetFeatureVariableValueForType<string>(It.IsAny<string>(), variableNonInt, It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), featureVariableType)).Returns("non_integer_value");
             Assert.Null(OptimizelyMock.Object.GetFeatureVariableInteger(featureKey, variableNonInt, TestUserId, null));
-            
+
             OptimizelyMock.Setup(om => om.GetFeatureVariableValueForType<int?>(It.IsAny<string>(), variableKeyNull, It.IsAny<string>(),
                                                                                It.IsAny<UserAttributes>(), featureVariableType)).Returns<string>(null);
             Assert.Null(OptimizelyMock.Object.GetFeatureVariableInteger(featureKey, variableKeyNull, TestUserId, null));
@@ -1643,7 +1654,7 @@ public void TestGetFeatureVariableJSONReturnsCorrectValueWhenInitializedUsingDic
             var expectedIntegerDict = new Dictionary<string, object>() { { "integer", 123 } };
             var expectedDoubleDict = new Dictionary<string, object>() { { "double", 123.28 } };
             var expectedBooleanDict = new Dictionary<string, object>() { { "boolean", true } };
-            
+
             OptimizelyMock.Setup(om => om.GetFeatureVariableValueForType<OptimizelyJSON>(It.IsAny<string>(), variableKeyString, It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), featureVariableType)).Returns(new OptimizelyJSON(expectedStringDict, ErrorHandlerMock.Object, LoggerMock.Object));
             Assert.IsTrue(TestData.CompareObjects(expectedStringDict, OptimizelyMock.Object.GetFeatureVariableJSON(featureKey, variableKeyString, TestUserId, null).ToDictionary()));
@@ -1681,9 +1692,11 @@ public void TestGetFeatureVariableDoubleReturnsRightValueWhenUserBuckedIntoFeatu
             var experiment = Config.GetExperimentFromKey("test_experiment_double_feature");
             var variation = Config.GetVariationFromKey("test_experiment_double_feature", "control");
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, null)).Returns(decision);
-            
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
             optly.SetFieldOrProperty("ProjectConfigManager", ConfigManager);
@@ -1711,8 +1724,11 @@ public void TestGetFeatureVariableIntegerReturnsRightValueWhenUserBuckedIntoFeat
                { "location", "San Francisco" }
             };
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, userAttributes)).Returns(decision);
-            
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, userAttributes)).Returns(decision);
+
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
             optly.SetFieldOrProperty("ProjectConfigManager", ConfigManager);
@@ -1734,8 +1750,11 @@ public void TestGetFeatureVariableDoubleReturnsDefaultValueWhenUserBuckedIntoFea
             var variation = Config.GetVariationFromKey("test_experiment_double_feature", "variation");
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, null)).Returns(decision);
-            
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
+
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
             optly.SetFieldOrProperty("ProjectConfigManager", ConfigManager);
@@ -1763,8 +1782,11 @@ public void TestGetFeatureVariableIntegerReturnsDefaultValueWhenUserBuckedIntoFe
                { "location", "San Francisco" }
             };
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, userAttributes)).Returns(decision);
-            
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, userAttributes)).Returns(decision);
+
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
             optly.SetFieldOrProperty("ProjectConfigManager", ConfigManager);
@@ -1786,8 +1808,11 @@ public void TestGetFeatureVariableBooleanReturnsRightValueWhenUserBuckedIntoRoll
             var variation = Config.GetVariationFromKey(experiment.Key, "177771");
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_ROLLOUT), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, null)).Returns(decision);
-            
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
+
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
             optly.SetFieldOrProperty("ProjectConfigManager", ConfigManager);
@@ -1815,7 +1840,10 @@ public void TestGetFeatureVariableJSONReturnsRightValueWhenUserBucketIntoRollout
                { "location", "San Francisco" }
             };
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, userAttributes)).Returns(decision);
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, userAttributes)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
 
@@ -1847,7 +1875,10 @@ public void TestGetFeatureVariableJSONReturnsRightValueWhenUserBucketIntoRollout
                { "location", "San Francisco" }
             };
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, userAttributes)).Returns(decision);
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, userAttributes)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
 
@@ -1878,13 +1909,16 @@ public void TestGetFeatureVariableStringReturnsRightValueWhenUserBuckedIntoRollo
                { "location", "San Francisco" }
             };
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, userAttributes)).Returns(decision);
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, userAttributes)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
 
             optly.SetFieldOrProperty("ProjectConfigManager", ConfigManager);
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
-            
+
             var variableValue = (string)optly.Invoke("GetFeatureVariableString", featureKey, variableKey, TestUserId, userAttributes);
             Assert.AreEqual(expectedValue, variableValue);
 
@@ -1902,8 +1936,11 @@ public void TestGetFeatureVariableBooleanReturnsDefaultValueWhenUserBuckedIntoRo
             var variation = Config.GetVariationFromKey(experiment.Key, "177782");
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_ROLLOUT), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, null)).Returns(decision);
-            
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
+
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
             optly.SetFieldOrProperty("ProjectConfigManager", ConfigManager);
@@ -1929,8 +1966,11 @@ public void TestGetFeatureVariableStringReturnsDefaultValueWhenUserBuckedIntoRol
                { "location", "San Francisco" }
             };
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, userAttributes)).Returns(decision);
-            
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, userAttributes)).Returns(decision);
+
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("ProjectConfigManager", ConfigManager);
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
@@ -1950,7 +1990,10 @@ public void TestGetFeatureVariableDoubleReturnsDefaultValueWhenUserNotBuckedInto
             var expectedValue = 14.99;
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(null, null, FeatureDecision.DECISION_SOURCE_ROLLOUT), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, null)).Returns(decision);
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
@@ -1964,7 +2007,7 @@ public void TestGetFeatureVariableDoubleReturnsDefaultValueWhenUserNotBuckedInto
 
         #endregion Feature Toggle Tests
 
-        #endregion // Test GetFeatureVariable<Type> TypeCasting
+        #endregion Test GetFeatureVariable<Type> methods
 
         #region Test GetFeatureVariableValueForType method
 
@@ -2005,7 +2048,7 @@ public void TestGetFeatureVariableValueForTypeGivenFeatureKeyOrVariableKeyNotFou
             Assert.IsNull(Optimizely.GetFeatureVariableValueForType<bool?>("double_single_variable_feature", variableKey, TestUserId, null, variableType));
 
             LoggerMock.Verify(l => l.Log(LogLevel.ERROR, $@"Feature key ""{featureKey}"" is not in datafile."));
-            LoggerMock.Verify(l => l.Log(LogLevel.ERROR, 
+            LoggerMock.Verify(l => l.Log(LogLevel.ERROR,
                 $@"No feature variable was found for key ""{variableKey}"" in feature flag ""double_single_variable_feature""."));
         }
 
@@ -2039,10 +2082,10 @@ public void TestUnsupportedVariableType()
         {
             var featureVariableStringRandomType = Optimizely.GetFeatureVariableString("", "any_key", TestUserId);
             Assert.IsNull(featureVariableStringRandomType);
-            
+
             // This is to test that only json subtype is parsing and all other will subtype will be stringify
             var featureVariableStringRegexSubType = Optimizely.GetFeatureVariableString("unsupported_variabletype", "string_regex_key", TestUserId);
-            Assert.AreEqual(featureVariableStringRegexSubType, "^\\d+(\\.\\d+)?");            
+            Assert.AreEqual(featureVariableStringRegexSubType, "^\\d+(\\.\\d+)?");
         }
 
         // Should return default value and log message when feature is not enabled for the user.
@@ -2059,7 +2102,10 @@ public void TestGetFeatureVariableValueForTypeGivenFeatureFlagIsNotEnabledForUse
 
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, null)).Returns(decision);
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
 
@@ -2073,7 +2119,7 @@ public void TestGetFeatureVariableValueForTypeGivenFeatureFlagIsNotEnabledForUse
                 $@"Feature ""{featureKey}"" is not enabled for user {TestUserId}. Returning the default variable value ""{variableValue}""."));
         }
 
-        // Should return default value and log message when feature is enabled for the user 
+        // Should return default value and log message when feature is enabled for the user
         // but variable usage does not get found for the variation.
         [Test]
         public void TestGetFeatureVariableValueForTypeGivenFeatureFlagIsEnabledForUserAndVaribaleNotInVariation()
@@ -2087,8 +2133,11 @@ public void TestGetFeatureVariableValueForTypeGivenFeatureFlagIsEnabledForUserAn
             var variableType = "double";
             var expectedValue = 14.99;
 
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
             // Mock GetVariationForFeature method to return variation of different feature.
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, null)).Returns(expectedDecision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(expectedDecision);
 
             var optly = Helper.CreatePrivateOptimizely();
 
@@ -2116,7 +2165,10 @@ public void TestGetFeatureVariableValueForTypeGivenFeatureFlagIsEnabledForUserAn
             var variation = Config.GetVariationFromKey("test_experiment_double_feature", "control");
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, null)).Returns(decision);
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
 
@@ -2137,12 +2189,15 @@ public void TestGetFeatureVariableValueForTypeWithRolloutRule()
             var featureFlag = Config.GetFeatureFlagFromKey(featureKey);
             var variableKey = "boolean_variable";
             //experimentid - 177772
-            var experiment = Config.Rollouts[0].Experiments[1]; 
+            var experiment = Config.Rollouts[0].Experiments[1];
             var variation = Config.GetVariationFromId(experiment.Key, "177773");
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_ROLLOUT), DecisionReasons);
             var expectedVariableValue = false;
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, null)).Returns(decision);
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
 
@@ -2157,7 +2212,7 @@ public void TestGetFeatureVariableValueForTypeWithRolloutRule()
             Assert.AreEqual(expectedVariableValue, actualVariableValue);
         }
 
-        #endregion // Test GetFeatureVariableValueForType method
+        #endregion Test GetFeatureVariableValueForType method
 
         #region Test IsFeatureEnabled method
 
@@ -2169,7 +2224,7 @@ public void TestIsFeatureEnabledGivenNullOrEmptyArguments()
 
             Assert.IsFalse(Optimizely.IsFeatureEnabled(featureKey, null, null));
             Assert.IsFalse(Optimizely.IsFeatureEnabled(featureKey, "", null));
-                   
+
             Assert.IsFalse(Optimizely.IsFeatureEnabled(null, TestUserId, null));
             Assert.IsFalse(Optimizely.IsFeatureEnabled("", TestUserId, null));
 
@@ -2183,7 +2238,7 @@ public void TestIsFeatureEnabledGivenFeatureFlagNotFound()
         {
             var featureKey = "feature_not_found";
             Assert.IsFalse(Optimizely.IsFeatureEnabled(featureKey, TestUserId, null));
-            
+
             LoggerMock.Verify(l => l.Log(LogLevel.ERROR, $@"Feature key ""{featureKey}"" is not in datafile."));
         }
 
@@ -2217,7 +2272,10 @@ public void TestIsFeatureEnabledGivenFeatureFlagIsNotEnabledForUser()
             var variation = Config.GetVariationFromKey("test_experiment_double_feature", "variation");
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, null)).Returns(decision);
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
@@ -2230,7 +2288,7 @@ public void TestIsFeatureEnabledGivenFeatureFlagIsNotEnabledForUser()
                 $@"Feature flag ""{featureKey}"" is not enabled for user ""{TestUserId}""."));
         }
 
-        // Should return true but does not send an impression event when feature is enabled for the user 
+        // Should return true but does not send an impression event when feature is enabled for the user
         // but user does not get experimented.
         [Test]
         public void TestIsFeatureEnabledGivenFeatureFlagIsEnabledAndUserIsNotBeingExperimented()
@@ -2242,7 +2300,10 @@ public void TestIsFeatureEnabledGivenFeatureFlagIsEnabledAndUserIsNotBeingExperi
             var featureFlag = Config.GetFeatureFlagFromKey(featureKey);
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_ROLLOUT), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, null)).Returns(decision);
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
@@ -2259,7 +2320,7 @@ public void TestIsFeatureEnabledGivenFeatureFlagIsEnabledAndUserIsNotBeingExperi
                 $@"Feature flag ""{featureKey}"" is enabled for user ""{TestUserId}""."));
         }
 
-        // Should return true and send an impression event when feature is enabled for the user 
+        // Should return true and send an impression event when feature is enabled for the user
         // and user is being experimented.
         [Test]
         public void TestIsFeatureEnabledGivenFeatureFlagIsEnabledAndUserIsBeingExperimented()
@@ -2270,7 +2331,10 @@ public void TestIsFeatureEnabledGivenFeatureFlagIsEnabledAndUserIsBeingExperimen
             var featureFlag = Config.GetFeatureFlagFromKey(featureKey);
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, null)).Returns(decision);
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
@@ -2287,7 +2351,7 @@ public void TestIsFeatureEnabledGivenFeatureFlagIsEnabledAndUserIsBeingExperimen
                 $@"Feature flag ""{featureKey}"" is enabled for user ""{TestUserId}""."));
         }
 
-        // Should return false and send an impression event when feature is enabled for the user 
+        // Should return false and send an impression event when feature is enabled for the user
         // and user is being experimented.
         [Test]
         public void TestIsFeatureEnabledGivenFeatureFlagIsNotEnabledAndUserIsBeingExperimented()
@@ -2298,7 +2362,10 @@ public void TestIsFeatureEnabledGivenFeatureFlagIsNotEnabledAndUserIsBeingExperi
             var featureFlag = Config.GetFeatureFlagFromKey(featureKey);
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, null)).Returns(decision);
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
@@ -2350,8 +2417,14 @@ public void TestIsFeatureEnabledWithFeatureEnabledPropertyGivenFeatureExperiment
             var decisionTrue = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, featureEnabledTrue, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
             var decisionFalse = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, featureEnabledFalse, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, null)).Returns(decisionTrue);
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, userId, Config, null)).Returns(decisionFalse);
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decisionTrue);
+
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(userId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decisionFalse);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
@@ -2373,7 +2446,10 @@ public void TestIsFeatureEnabledWithFeatureEnabledPropertyGivenRolloutRule()
             // Verify that IsFeatureEnabled returns true when user is bucketed into the rollout rule's variation.
             Assert.True(Optimizely.IsFeatureEnabled("boolean_single_variable_feature", TestUserId));
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, null)).Returns<FeatureDecision>(null);
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns<FeatureDecision>(null);
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
 
@@ -2382,7 +2458,7 @@ public void TestIsFeatureEnabledWithFeatureEnabledPropertyGivenRolloutRule()
             Assert.False(result);
         }
 
-        #endregion // Test IsFeatureEnabled method
+        #endregion Test IsFeatureEnabled method
 
         #region Test NotificationCenter
 
@@ -2414,7 +2490,7 @@ public void TestActivateListener(UserAttributes userAttributes)
             var variation = Result<Variation>.NewResult(Config.GetVariationFromKey(experimentKey, variationKey), DecisionReasons);
             var featureFlag = Config.GetFeatureFlagFromKey(featureKey);
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation.ResultObject, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
-            
+
             // Mocking objects.
             NotificationCallbackMock.Setup(nc => nc.TestActivateCallback(It.IsAny<Experiment>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), It.IsAny<Variation>(), It.IsAny<LogEvent>()));
@@ -2422,18 +2498,21 @@ public void TestActivateListener(UserAttributes userAttributes)
                 It.IsAny<UserAttributes>(), It.IsAny<Variation>(), It.IsAny<LogEvent>()));
             NotificationCallbackMock.Setup(nc => nc.TestTrackCallback(It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), It.IsAny<EventTags>(), It.IsAny<LogEvent>()));
-            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, TestUserId, It.IsAny<ProjectConfig>(), userAttributes)).Returns(variation);
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, It.IsAny<ProjectConfig>(), userAttributes)).Returns(decision);
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, mockUserContext.Object, It.IsAny<ProjectConfig>(), userAttributes)).Returns(variation);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, It.IsAny<ProjectConfig>(), userAttributes)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
             var optStronglyTyped = optly.GetObject() as Optimizely;
 
             // Adding notification listeners.
             var notificationType = NotificationCenter.NotificationType.Activate;
-            optStronglyTyped. NotificationCenter.AddNotification(notificationType, NotificationCallbackMock.Object.TestActivateCallback);
+            optStronglyTyped.NotificationCenter.AddNotification(notificationType, NotificationCallbackMock.Object.TestActivateCallback);
             optStronglyTyped.NotificationCenter.AddNotification(notificationType, NotificationCallbackMock.Object.TestAnotherActivateCallback);
-                        
-            optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);            
+
+            optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
 
             // Calling Activate and IsFeatureEnabled.
             optly.Invoke("Activate", experimentKey, TestUserId, userAttributes);
@@ -2501,14 +2580,18 @@ public void TestTrackListener(UserAttributes userAttributes, EventTags eventTags
                 It.IsAny<UserAttributes>(), It.IsAny<EventTags>(), It.IsAny<LogEvent>()));
             NotificationCallbackMock.Setup(nc => nc.TestAnotherTrackCallback(It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), It.IsAny<EventTags>(), It.IsAny<LogEvent>()));
-            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, TestUserId, Config, userAttributes)).Returns(variation);
-            
+
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, mockUserContext.Object, Config, userAttributes)).Returns(variation);
+
             // Adding notification listeners.
             var notificationType = NotificationCenter.NotificationType.Track;
             optStronglyTyped.NotificationCenter.AddNotification(notificationType, NotificationCallbackMock.Object.TestTrackCallback);
             optStronglyTyped.NotificationCenter.AddNotification(notificationType, NotificationCallbackMock.Object.TestAnotherTrackCallback);
-            
-            optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);            
+
+            optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
 
             // Calling Track.
             optly.Invoke("Track", eventKey, TestUserId, userAttributes, eventTags);
@@ -2538,7 +2621,11 @@ public void TestActivateSendsDecisionNotificationWithActualVariationKey()
             // Mocking objects.
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), It.IsAny<Dictionary<string, object>>()));
-            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, TestUserId, Config, userAttributes)).Returns(variation);
+
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, mockUserContext.Object, Config, userAttributes)).Returns(variation);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("ProjectConfigManager", ConfigManager);
@@ -2574,15 +2661,19 @@ public void TestActivateSendsDecisionNotificationWithVariationKeyAndTypeFeatureT
             // Mocking objects.
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), It.IsAny<Dictionary<string, object>>()));
-            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, TestUserId, Config, userAttributes)).Returns(variation);
+
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, mockUserContext.Object, Config, userAttributes)).Returns(variation);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("ProjectConfigManager", ConfigManager);
             var optStronglyTyped = optly.GetObject() as Optimizely;
-            
+
             optStronglyTyped.NotificationCenter.AddNotification(NotificationCenter.NotificationType.Decision, NotificationCallbackMock.Object.TestDecisionCallback);
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
-            
+
             optly.Invoke("Activate", experimentKey, TestUserId, userAttributes);
             var decisionInfo = new Dictionary<string, object>
             {
@@ -2598,11 +2689,14 @@ public void TestActivateSendsDecisionNotificationWithNullVariationKey()
         {
             var experimentKey = "test_experiment";
             var experiment = Config.GetExperimentFromKey(experimentKey);
-            
+
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), It.IsAny<Dictionary<string, object>>()));
-            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, TestUserId, It.IsAny<ProjectConfig>(), null)).Returns(Result<Variation>.NullResult(null));
-            //DecisionServiceMock.Setup(ds => ds.GetVariation(It.IsAny<Experiment>(), It.IsAny<string>(), It.IsAny<ProjectConfig>(), It.IsAny<UserAttributes>())).Returns(Result<Variation>.NullResult(null));
+
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, mockUserContext.Object, It.IsAny<ProjectConfig>(), null)).Returns(Result<Variation>.NullResult(null));
 
             var optly = Helper.CreatePrivateOptimizely();
             var optStronglyTyped = optly.GetObject() as Optimizely;
@@ -2637,7 +2731,11 @@ public void TestGetVariationSendsDecisionNotificationWithActualVariationKey()
             // Mocking objects.
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), It.IsAny<Dictionary<string, object>>()));
-            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, TestUserId, Config, userAttributes)).Returns(variation);
+
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, mockUserContext.Object, Config, userAttributes)).Returns(variation);
 
             var optly = Helper.CreatePrivateOptimizely();
 
@@ -2674,7 +2772,11 @@ public void TestGetVariationSendsDecisionNotificationWithVariationKeyAndTypeFeat
             // Mocking objects.
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), It.IsAny<Dictionary<string, object>>()));
-            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, TestUserId, Config, userAttributes)).Returns(variation);
+
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, mockUserContext.Object, Config, userAttributes)).Returns(variation);
 
             var optly = Helper.CreatePrivateOptimizely();
             var optStronglyTyped = optly.GetObject() as Optimizely;
@@ -2701,7 +2803,11 @@ public void TestGetVariationSendsDecisionNotificationWithNullVariationKey()
 
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), It.IsAny<Dictionary<string, object>>()));
-            DecisionServiceMock.Setup(ds => ds.GetVariation(It.IsAny<Experiment>(), It.IsAny<string>(), It.IsAny<ProjectConfig>(), It.IsAny<UserAttributes>())).Returns(Result<Variation>.NullResult(null));
+
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariation(It.IsAny<Experiment>(), mockUserContext.Object, It.IsAny<ProjectConfig>(), It.IsAny<UserAttributes>())).Returns(Result<Variation>.NullResult(null));
             //DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, TestUserId, Config, null)).Returns(Result<Variation>.NullResult(null));
 
             var optly = Helper.CreatePrivateOptimizely();
@@ -2719,6 +2825,7 @@ public void TestGetVariationSendsDecisionNotificationWithNullVariationKey()
 
             NotificationCallbackMock.Verify(nc => nc.TestDecisionCallback(DecisionNotificationTypes.AB_TEST, TestUserId, new UserAttributes(), decisionInfo), Times.Once);
         }
+
         public void TestIsFeatureEnabledSendsDecisionNotificationWithFeatureEnabledTrueForFeatureExperiment()
         {
             var featureKey = "double_single_variable_feature";
@@ -2727,10 +2834,16 @@ public void TestIsFeatureEnabledSendsDecisionNotificationWithFeatureEnabledTrueF
             var featureFlag = Config.GetFeatureFlagFromKey(featureKey);
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation.ResultObject, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, null)).Returns(decision);
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), It.IsAny<Dictionary<string, object>>()));
-            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, TestUserId, ConfigManager.GetConfig(), null)).Returns(variation);
+
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, mockUserContext.Object, ConfigManager.GetConfig(), null)).Returns(variation);
 
             var optly = Helper.CreatePrivateOptimizely();
             var optStronglyTyped = optly.GetObject() as Optimizely;
@@ -2761,11 +2874,15 @@ public void TestIsFeatureEnabledSendsDecisionNotificationWithFeatureEnabledFalse
             var variation = Result<Variation>.NewResult(Config.GetVariationFromKey("test_experiment_double_feature", "variation"), DecisionReasons);
             var featureFlag = Config.GetFeatureFlagFromKey(featureKey);
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation.ResultObject, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
-            
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, null)).Returns(decision);
+
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), It.IsAny<Dictionary<string, object>>()));
-            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, TestUserId, Config, null)).Returns(variation);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, mockUserContext.Object, Config, null)).Returns(variation);
 
             var optly = Helper.CreatePrivateOptimizely();
             var optStronglyTyped = optly.GetObject() as Optimizely;
@@ -2776,7 +2893,7 @@ public void TestIsFeatureEnabledSendsDecisionNotificationWithFeatureEnabledFalse
 
             bool result = (bool)optly.Invoke("IsFeatureEnabled", featureKey, TestUserId, null);
             Assert.False(result);
-            
+
             var decisionInfo = new Dictionary<string, object>
             {
                 { "featureKey", featureKey },
@@ -2807,7 +2924,10 @@ public void TestIsFeatureEnabledSendsDecisionNotificationWithFeatureEnabledTrueF
             var featureFlag = Config.GetFeatureFlagFromKey(featureKey);
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_ROLLOUT), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, userAttributes)).Returns(decision);
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, userAttributes)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), It.IsAny<Dictionary<string, object>>()));
 
@@ -2846,7 +2966,10 @@ public void TestIsFeatureEnabledSendsDecisionNotificationWithFeatureEnabledFalse
             var featureFlag = Config.GetFeatureFlagFromKey(featureKey);
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_ROLLOUT), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, userAttributes)).Returns(decision);
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, userAttributes)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), It.IsAny<Dictionary<string, object>>()));
 
@@ -2878,7 +3001,10 @@ public void TestIsFeatureEnabledSendsDecisionNotificationWithFeatureEnabledFalse
             var featureFlag = Config.GetFeatureFlagFromKey(featureKey);
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(null, null, FeatureDecision.DECISION_SOURCE_ROLLOUT), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, null)).Returns(decision);
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), It.IsAny<Dictionary<string, object>>()));
 
@@ -3018,7 +3144,10 @@ public void TestGetFeatureVariableDoubleSendsNotificationWhenUserBuckedIntoFeatu
             var variation = Config.GetVariationFromKey("test_experiment_double_feature", "control");
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, null)).Returns(decision);
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<UserAttributes>(),
                 It.IsAny<Dictionary<string, object>>()));
 
@@ -3072,7 +3201,10 @@ public void TestGetFeatureVariableJsonSendsNotificationWhenUserBuckedIntoFeature
                { "location", "San Francisco" }
             };
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, userAttributes)).Returns(decision);
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, userAttributes)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<UserAttributes>(),
                 It.IsAny<Dictionary<string, object>>()));
 
@@ -3117,7 +3249,10 @@ public void TestGetFeatureVariableIntegerSendsNotificationWhenUserBuckedIntoFeat
                { "location", "San Francisco" }
             };
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, userAttributes)).Returns(decision);
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, userAttributes)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<UserAttributes>(),
                 It.IsAny<Dictionary<string, object>>()));
 
@@ -3161,7 +3296,10 @@ public void TestGetFeatureVariableDoubleSendsNotificationWhenUserBuckedIntoFeatu
             var variation = Config.GetVariationFromKey("test_experiment_double_feature", "variation");
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, null)).Returns(decision);
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<UserAttributes>(),
                 It.IsAny<Dictionary<string, object>>()));
 
@@ -3210,7 +3348,10 @@ public void TestGetFeatureVariableIntegerSendsNotificationWhenUserBuckedIntoFeat
                { "location", "San Francisco" }
             };
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, userAttributes)).Returns(decision);
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, userAttributes)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<UserAttributes>(),
                 It.IsAny<Dictionary<string, object>>()));
 
@@ -3253,7 +3394,10 @@ public void TestGetFeatureVariableBooleanSendsNotificationWhenUserBuckedIntoRoll
             var variation = Config.GetVariationFromKey(experiment.Key, "177771");
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_ROLLOUT), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, null)).Returns(decision);
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<UserAttributes>(),
                 It.IsAny<Dictionary<string, object>>()));
 
@@ -3297,7 +3441,10 @@ public void TestGetFeatureVariableStringSendsNotificationWhenUserBuckedIntoRollo
                { "location", "San Francisco" }
             };
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, userAttributes)).Returns(decision);
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, userAttributes)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<UserAttributes>(),
                 It.IsAny<Dictionary<string, object>>()));
 
@@ -3336,7 +3483,10 @@ public void TestGetFeatureVariableBooleanSendsNotificationWhenUserBuckedIntoRoll
             var variation = Config.GetVariationFromKey(experiment.Key, "177782");
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_ROLLOUT), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, null)).Returns(decision);
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<UserAttributes>(),
                 It.IsAny<Dictionary<string, object>>()));
 
@@ -3380,7 +3530,10 @@ public void TestGetFeatureVariableStringSendsNotificationWhenUserBuckedIntoRollo
                { "location", "San Francisco" }
             };
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, userAttributes)).Returns(decision);
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, userAttributes)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<UserAttributes>(),
                 It.IsAny<Dictionary<string, object>>()));
 
@@ -3416,7 +3569,10 @@ public void TestGetFeatureVariableDoubleSendsNotificationWhenUserNotBuckedIntoBo
             var expectedValue = 14.99;
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(null, null, FeatureDecision.DECISION_SOURCE_ROLLOUT), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, null)).Returns(decision);
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<UserAttributes>(),
                 It.IsAny<Dictionary<string, object>>()));
 
@@ -3473,7 +3629,10 @@ public void TestGetAllFeatureVariablesSendsNotificationWhenUserBucketIntoRollout
                { "location", "San Francisco" }
             };
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, userAttributes)).Returns(decision);
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, userAttributes)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<UserAttributes>(),
                 It.IsAny<Dictionary<string, object>>()));
 
@@ -3499,7 +3658,7 @@ public void TestGetAllFeatureVariablesSendsNotificationWhenUserBucketIntoRollout
             NotificationCallbackMock.Verify(nc => nc.TestDecisionCallback(DecisionNotificationTypes.ALL_FEATURE_VARIABLE, TestUserId, userAttributes, It.Is<Dictionary<string, object>>(info => TestData.CompareObjects(info, decisionInfo))), Times.Once);
         }
 
-        #endregion // Decision Listener
+        #endregion Decision Listener
 
         #region Test GetAllFeatureVariables
 
@@ -3534,7 +3693,7 @@ public void TestGetAllFeatureVariablesReturnsNullScenarios()
 
             LoggerMock.Verify(log => log.Log(LogLevel.INFO, "No feature flag was found for key \"" + featureKey + "\"."), Times.Once);
 
-            // Null Optimizely config 
+            // Null Optimizely config
             var invalidOptly = new Optimizely("Random datafile", null, LoggerMock.Object);
 
             var result4 = invalidOptly.GetAllFeatureVariables("validFeatureKey", TestUserId, userAttributes);
@@ -3561,7 +3720,10 @@ public void TestGetAllFeatureVariablesRollout()
 
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, null, FeatureDecision.DECISION_SOURCE_ROLLOUT), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, TestUserId, Config, userAttributes)).Returns(decision);
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
+
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, userAttributes)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
@@ -3593,8 +3755,10 @@ public void TestGetAllFeatureVariablesSourceFeatureTest()
                         "The default values are being returned."), Times.Never);
         }
 
-        #endregion
+        #endregion Test GetAllFeatureVariables
+
         #region DFM Notification
+
         [Test]
         public void TestDFMNotificationWhenProjectConfigIsUpdated()
         {
@@ -3605,7 +3769,6 @@ public void TestDFMNotificationWhenProjectConfigIsUpdated()
             NotificationCenter notificationCenter = new NotificationCenter();
             NotificationCallbackMock.Setup(notification => notification.TestConfigUpdateCallback());
 
-
             var httpManager = new HttpProjectConfigManager.Builder()
                                                           .WithSdkKey("QBw9gFM8oTn7ogY9ANCC1z")
                                                           .WithLogger(LoggerMock.Object)
@@ -3621,7 +3784,7 @@ public void TestDFMNotificationWhenProjectConfigIsUpdated()
 
             // wait till 10 seconds max, to avoid stale state in worst case.
             httpManager.OnReady().Wait(10000);
-            
+
             t.Wait();
             NotificationCallbackMock.Verify(nc => nc.TestConfigUpdateCallback(), Times.Once);
             httpManager.Dispose();
@@ -3630,7 +3793,7 @@ public void TestDFMNotificationWhenProjectConfigIsUpdated()
         [Test]
         public void TestDFMWhenDatafileProvidedDoesNotNotifyWithoutStart()
         {
-            var httpClientMock = new Mock<HttpProjectConfigManager.HttpClient>();            
+            var httpClientMock = new Mock<HttpProjectConfigManager.HttpClient>();
             TestHttpProjectConfigManagerUtil.SetClientFieldValue(httpClientMock.Object);
 
             var httpManager = new HttpProjectConfigManager.Builder()
@@ -3638,10 +3801,9 @@ public void TestDFMWhenDatafileProvidedDoesNotNotifyWithoutStart()
                 .WithDatafile(TestData.Datafile)
                 .WithLogger(LoggerMock.Object)
                 .WithPollingInterval(TimeSpan.FromMilliseconds(1000))
-                .WithBlockingTimeoutPeriod(TimeSpan.FromMilliseconds(500))                
+                .WithBlockingTimeoutPeriod(TimeSpan.FromMilliseconds(500))
                 .Build();
 
-
             var optimizely = new Optimizely(httpManager);
             optimizely.NotificationCenter.AddNotification(NotificationCenter.NotificationType.OptimizelyConfigUpdate, NotificationCallbackMock.Object.TestConfigUpdateCallback);
 
@@ -3652,11 +3814,9 @@ public void TestDFMWhenDatafileProvidedDoesNotNotifyWithoutStart()
             httpManager.Dispose();
         }
 
+        #endregion DFM Notification
 
-
-        #endregion // DFM Notification
-
-        #endregion // Test NotificationCenter
+        #endregion Test NotificationCenter
 
         #region Test GetEnabledFeatures
 
@@ -3666,9 +3826,8 @@ public void TestGetEnabledFeaturesWithInvalidDatafile()
             var optly = new Optimizely("Random datafile", null, LoggerMock.Object);
 
             Assert.IsEmpty(optly.GetEnabledFeatures("some_user", null));
-            
-            LoggerMock.Verify(l => l.Log(LogLevel.ERROR, "Datafile has invalid format. Failing 'GetEnabledFeatures'."), Times.Once);
 
+            LoggerMock.Verify(l => l.Log(LogLevel.ERROR, "Datafile has invalid format. Failing 'GetEnabledFeatures'."), Times.Once);
         }
 
         [Test]
@@ -3687,7 +3846,7 @@ public void TestGetEnabledFeaturesWithNoFeatureEnabledForUser()
         [Test]
         public void TestGetEnabledFeaturesWithSomeFeaturesEnabledForUser()
         {
-            string[] enabledFeatures = 
+            string[] enabledFeatures =
             {
                 "boolean_feature",
                 "double_single_variable_feature",
@@ -3708,19 +3867,19 @@ public void TestGetEnabledFeaturesWithSomeFeaturesEnabledForUser()
                 { "location", "San Francisco" }
             };
 
-            OptimizelyMock.Setup(om => om.IsFeatureEnabled(It.IsIn<string>(enabledFeatures), TestUserId, 
+            OptimizelyMock.Setup(om => om.IsFeatureEnabled(It.IsIn<string>(enabledFeatures), TestUserId,
                 It.IsAny<UserAttributes>())).Returns(true);
             OptimizelyMock.Setup(om => om.IsFeatureEnabled(It.IsIn<string>(notEnabledFeatures), TestUserId,
                 It.IsAny<UserAttributes>())).Returns(false);
 
             var actualFeaturesList = OptimizelyMock.Object.GetEnabledFeatures(TestUserId, userAttributes);
-            
+
             // Verify that the returned feature list contains only enabledFeatures.
             CollectionAssert.AreEquivalent(enabledFeatures, actualFeaturesList);
             Array.ForEach(notEnabledFeatures, nef => CollectionAssert.DoesNotContain(actualFeaturesList, nef));
         }
 
-        #endregion // Test GetEnabledFeatures
+        #endregion Test GetEnabledFeatures
 
         #region Test ValidateStringInputs
 
@@ -3805,7 +3964,7 @@ public void TestTrackValidateInputValues()
             LoggerMock.Verify(l => l.Log(LogLevel.ERROR, "Provided Event Key is in invalid format."), Times.Once);
         }
 
-        #endregion // Test ValidateStringInputs
+        #endregion Test ValidateStringInputs
 
         #region Test Audience Match Types
 
@@ -3917,7 +4076,7 @@ public void TestGetFeatureVariableStringReturnDefaultVariableValueWithTypedAudie
             Assert.AreEqual(variableValue, "x");
         }
 
-        #endregion // Test Audience Match Types
+        #endregion Test Audience Match Types
 
         #region Test Audience Combinations
 
@@ -4029,14 +4188,14 @@ public void TestGetFeatureVariableIntegerReturnsVariableValueWithComplexAudience
         [Test]
         public void TestGetFeatureVariableIntegerReturnsDefaultValueWithComplexAudienceConditions()
         {
-            var userAttributes = new UserAttributes {};
+            var userAttributes = new UserAttributes { };
 
             // Should be excluded - no audiences match with no attributes.
             var value = OptimizelyWithTypedAudiences.GetFeatureVariableInteger("feat2_with_var", "z", "user1", userAttributes);
             Assert.AreEqual(10, value);
         }
 
-        #endregion // Test Audience Combinations
+        #endregion Test Audience Combinations
 
         #region Disposable Optimizely
 
@@ -4047,7 +4206,7 @@ public void TestOptimizelyDisposeAlsoDisposedConfigManager()
                                                           .WithSdkKey("QBw9gFM8oTn7ogY9ANCC1z")
                                                           .WithLogger(LoggerMock.Object)
                                                           .WithPollingInterval(TimeSpan.FromMilliseconds(5000))
-                                                          .WithBlockingTimeoutPeriod(TimeSpan.FromMilliseconds(500))                                                          
+                                                          .WithBlockingTimeoutPeriod(TimeSpan.FromMilliseconds(500))
                                                           .Build();
             var optimizely = new Optimizely(httpManager);
             optimizely.Dispose();
@@ -4077,7 +4236,7 @@ public void TestAfterDisposeAPIsNoLongerValid()
             var httpManager = new HttpProjectConfigManager.Builder()
                                                           .WithSdkKey("QBw9gFM8oTn7ogY9ANCC1z")
                                                           .WithDatafile(TestData.Datafile)
-                                                          .WithLogger(LoggerMock.Object)                                                          
+                                                          .WithLogger(LoggerMock.Object)
                                                           .WithPollingInterval(TimeSpan.FromMilliseconds(50000))
                                                           .WithBlockingTimeoutPeriod(TimeSpan.FromMilliseconds(500))
                                                           .Build(true);
@@ -4121,10 +4280,9 @@ public void TestAfterDisposeAPIsShouldNotCrash()
             Assert.IsNull(optimizely.GetFeatureVariableString(string.Empty, string.Empty, string.Empty));
             Assert.IsNull(optimizely.GetFeatureVariableDouble(string.Empty, string.Empty, string.Empty));
             Assert.IsNull(optimizely.GetFeatureVariableInteger(string.Empty, string.Empty, string.Empty));
-
         }
 
-        #endregion
+        #endregion Disposable Optimizely
 
         #region Test GetOptimizelyConfig
 
@@ -4145,16 +4303,17 @@ public void TestGetOptimizelyConfigDatafile()
             Assert.AreEqual(optimizelyConfig.GetDatafile(), TestData.Datafile);
         }
 
-        #endregion
-
+        #endregion Test GetOptimizelyConfig
 
         #region Test Culture
+
         public static void SetCulture(string culture)
         {
             var ci1 = new CultureInfo(culture);
             Thread.CurrentThread.CurrentCulture = ci1;
             Thread.CurrentThread.CurrentUICulture = ci1;
         }
-        #endregion
+
+        #endregion Test Culture
     }
-}
+}
\ No newline at end of file
diff --git a/OptimizelySDK/Bucketing/DecisionService.cs b/OptimizelySDK/Bucketing/DecisionService.cs
index a351d27e..001d0270 100644
--- a/OptimizelySDK/Bucketing/DecisionService.cs
+++ b/OptimizelySDK/Bucketing/DecisionService.cs
@@ -110,7 +110,7 @@ public virtual Result<Variation> GetVariation(Experiment experiment,
                 return Result<Variation>.NullResult(reasons);
 
             // check if a forced variation is set
-            var forcedVariationResult = GetForcedVariation(experiment.Key, user, config);
+            var forcedVariationResult = GetForcedVariation(experiment.Key, userId, config);
             reasons += forcedVariationResult.DecisionReasons;
 
             if (forcedVariationResult.ResultObject != null)
@@ -192,10 +192,9 @@ public virtual Result<Variation> GetVariation(Experiment experiment,
         /// <param name="userId">The user ID</param>
         /// <param name="config">Project Config</param>
         /// <returns>Variation entity which the given user and experiment should be forced into.</returns>
-        public Result<Variation> GetForcedVariation(string experimentKey, OptimizelyUserContext user, ProjectConfig config)
+        public Result<Variation> GetForcedVariation(string experimentKey, string userId, ProjectConfig config)
         {
             var reasons = new DecisionReasons();
-            var userId = user.GetUserId();
 
             if (ForcedVariationMap.ContainsKey(userId) == false)
             {
diff --git a/OptimizelySDK/Optimizely.cs b/OptimizelySDK/Optimizely.cs
index b27e0fa4..40c7c224 100644
--- a/OptimizelySDK/Optimizely.cs
+++ b/OptimizelySDK/Optimizely.cs
@@ -379,7 +379,7 @@ private Variation GetVariation(string experimentKey, string userId, ProjectConfi
             if (experiment.Key == null)
                 return null;
 
-            var variation = DecisionService.GetVariation(experiment, userId, config, userAttributes).ResultObject;
+            var variation = DecisionService.GetVariation(experiment, CreateUserContext(userId, userAttributes), config, userAttributes).ResultObject;
             var decisionInfo = new Dictionary<string, object>
             {
                 { "experimentKey", experimentKey },
@@ -427,7 +427,6 @@ public bool SetForcedVariation(string experimentKey, string userId, string varia
         public Variation GetForcedVariation(string experimentKey, string userId)
         {
             var config = ProjectConfigManager?.GetConfig();
-
             if (config == null)
             {
                 return null;
@@ -484,7 +483,7 @@ public virtual bool IsFeatureEnabled(string featureKey, string userId, UserAttri
 
             bool featureEnabled = false;
             var sourceInfo = new Dictionary<string, string>();
-            var decision = DecisionService.GetVariationForFeature(featureFlag, userId, config, userAttributes).ResultObject;
+            var decision = DecisionService.GetVariationForFeature(featureFlag, CreateUserContext(userId, userAttributes), config, userAttributes).ResultObject;
             var variation = decision?.Variation;
             var decisionSource = decision?.Source ?? FeatureDecision.DECISION_SOURCE_ROLLOUT;
 
@@ -575,7 +574,7 @@ public virtual T GetFeatureVariableValueForType<T>(string featureKey, string var
 
             var featureEnabled = false;
             var variableValue = featureVariable.DefaultValue;
-            var decision = DecisionService.GetVariationForFeature(featureFlag, userId, config, userAttributes).ResultObject;
+            var decision = DecisionService.GetVariationForFeature(featureFlag, CreateUserContext(userId, userAttributes), config, userAttributes).ResultObject;
 
             if (decision?.Variation != null)
             {
@@ -759,7 +758,7 @@ internal OptimizelyDecision Decide(OptimizelyUserContext user,
 
             var flagDecisionResult = DecisionService.GetVariationForFeature(
                 flag,
-                userId,
+                user,
                 config,
                 userAttributes,
                 allOptions);
@@ -1029,7 +1028,7 @@ public OptimizelyJSON GetAllFeatureVariables(string featureKey, string userId,
                 return null;
 
             var featureEnabled = false;
-            var decisionResult = DecisionService.GetVariationForFeature(featureFlag, userId, config, userAttributes);
+            var decisionResult = DecisionService.GetVariationForFeature(featureFlag, CreateUserContext(userId, userAttributes), config, userAttributes);
             var variation = decisionResult.ResultObject?.Variation;
 
             if (variation != null)

From 86a099bc68ba864b3a6b87bc5e324eb0cf7a54ae Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Fri, 8 Oct 2021 13:04:12 -0400
Subject: [PATCH 017/130] spacing issues

---
 OptimizelySDK.Tests/OptimizelyTest.cs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/OptimizelySDK.Tests/OptimizelyTest.cs b/OptimizelySDK.Tests/OptimizelyTest.cs
index e73172cf..2cc18e5d 100644
--- a/OptimizelySDK.Tests/OptimizelyTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyTest.cs
@@ -2498,6 +2498,7 @@ public void TestActivateListener(UserAttributes userAttributes)
                 It.IsAny<UserAttributes>(), It.IsAny<Variation>(), It.IsAny<LogEvent>()));
             NotificationCallbackMock.Setup(nc => nc.TestTrackCallback(It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), It.IsAny<EventTags>(), It.IsAny<LogEvent>()));
+
             Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
             mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
 

From d5583d79bbea02eee4ea1648f97ae4fb90ea475d Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Fri, 8 Oct 2021 15:54:51 -0400
Subject: [PATCH 018/130] Additional changes to try and have a working ctor

---
 OptimizelySDK.Tests/DecisionServiceTest.cs | 4 +++-
 OptimizelySDK.Tests/OptimizelyTest.cs      | 2 +-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/OptimizelySDK.Tests/DecisionServiceTest.cs b/OptimizelySDK.Tests/DecisionServiceTest.cs
index b68ce867..3d188136 100644
--- a/OptimizelySDK.Tests/DecisionServiceTest.cs
+++ b/OptimizelySDK.Tests/DecisionServiceTest.cs
@@ -58,7 +58,6 @@ public void SetUp()
             ErrorHandlerMock = new Mock<IErrorHandler>();
             UserProfileServiceMock = new Mock<UserProfileService>();
             BucketerMock = new Mock<Bucketer>(LoggerMock.Object);
-
             ProjectConfig = DatafileProjectConfig.Create(TestData.Datafile, LoggerMock.Object, ErrorHandlerMock.Object);
             WhitelistedExperiment = ProjectConfig.ExperimentIdMap["224"];
             WhitelistedVariation = WhitelistedExperiment.VariationKeyToVariationMap["vtag5"];
@@ -80,6 +79,8 @@ public void TestGetVariationForcedVariationPrecedesAudienceEval()
             Experiment experiment = ProjectConfig.Experiments[8];
             Variation expectedVariation = experiment.Variations[0];
 
+            var optlyObject = new Optimizely(TestData.Datafile, new ValidEventDispatcher(), LoggerMock.Object);
+            OptimizelyUserContextMock = new Mock<OptimizelyUserContext>(optlyObject, WhitelistedUserId, new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object);
             OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns(GenericUserId);
             // user excluded without audiences and whitelisting
             Assert.IsNull(decisionService.GetVariation(experiment, OptimizelyUserContextMock.Object, ProjectConfig, new UserAttributes()).ResultObject);
@@ -227,6 +228,7 @@ public void TestBucketReturnsVariationStoredInUserProfile()
             UserProfileServiceMock.Setup(_ => _.Lookup(UserProfileId)).Returns(userProfile.ToMap());
 
             DecisionService decisionService = new DecisionService(BucketerMock.Object, ErrorHandlerMock.Object, UserProfileServiceMock.Object, LoggerMock.Object);
+
             OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns(UserProfileId);
             var actualVariation = decisionService.GetVariation(experiment, OptimizelyUserContextMock.Object, ProjectConfig, new UserAttributes());
 
diff --git a/OptimizelySDK.Tests/OptimizelyTest.cs b/OptimizelySDK.Tests/OptimizelyTest.cs
index 2cc18e5d..3744ee51 100644
--- a/OptimizelySDK.Tests/OptimizelyTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyTest.cs
@@ -2499,7 +2499,7 @@ public void TestActivateListener(UserAttributes userAttributes)
             NotificationCallbackMock.Setup(nc => nc.TestTrackCallback(It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), It.IsAny<EventTags>(), It.IsAny<LogEvent>()));
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>(OptimizelyMock.Object, TestUserId, userAttributes, ErrorHandlerMock.Object, LoggerMock.Object);
             mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
 
             DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, mockUserContext.Object, It.IsAny<ProjectConfig>(), userAttributes)).Returns(variation);

From b7b8fb713a9b4dd51cb23e1e3e3c21c709b5f48a Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Mon, 11 Oct 2021 11:41:13 -0400
Subject: [PATCH 019/130] Fixes for test issues

---
 OptimizelySDK.Tests/DecisionServiceTest.cs |  12 +-
 OptimizelySDK.Tests/OptimizelyTest.cs      | 263 ++++++---------------
 2 files changed, 79 insertions(+), 196 deletions(-)

diff --git a/OptimizelySDK.Tests/DecisionServiceTest.cs b/OptimizelySDK.Tests/DecisionServiceTest.cs
index 3d188136..42e08737 100644
--- a/OptimizelySDK.Tests/DecisionServiceTest.cs
+++ b/OptimizelySDK.Tests/DecisionServiceTest.cs
@@ -120,6 +120,8 @@ public void TestGetVariationLogsErrorWhenUserProfileMapItsNull()
         [Test]
         public void TestGetVariationEvaluatesUserProfileBeforeAudienceTargeting()
         {
+            var optlyObject = new Optimizely(TestData.Datafile, new ValidEventDispatcher(), LoggerMock.Object);
+            OptimizelyUserContextMock = new Mock<OptimizelyUserContext>(optlyObject, WhitelistedUserId, new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object);
             OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns(GenericUserId);
 
             Experiment experiment = ProjectConfig.Experiments[8];
@@ -157,7 +159,7 @@ public void TestGetForcedVariationReturnsForcedVariation()
             Assertions.AreEqual(WhitelistedVariation, expectedVariation);
             Assert.IsTrue(TestData.CompareObjects(WhitelistedVariation, decisionService.GetWhitelistedVariation(WhitelistedExperiment, WhitelistedUserId).ResultObject));
             LoggerMock.Verify(l => l.Log(LogLevel.INFO, string.Format("User \"{0}\" is forced in variation \"{1}\".",
-                WhitelistedUserId, WhitelistedVariation.Key)), Times.Once);
+                WhitelistedUserId, WhitelistedVariation.Key)), Times.Exactly(2));
 
             BucketerMock.Verify(_ => _.Bucket(It.IsAny<ProjectConfig>(), It.IsAny<Experiment>(), It.IsAny<string>(), It.IsAny<string>()), Times.Never);
         }
@@ -229,7 +231,10 @@ public void TestBucketReturnsVariationStoredInUserProfile()
 
             DecisionService decisionService = new DecisionService(BucketerMock.Object, ErrorHandlerMock.Object, UserProfileServiceMock.Object, LoggerMock.Object);
 
+            var optlyObject = new Optimizely(TestData.Datafile, new ValidEventDispatcher(), LoggerMock.Object);
+            OptimizelyUserContextMock = new Mock<OptimizelyUserContext>(optlyObject, WhitelistedUserId, new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object);
             OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns(UserProfileId);
+
             var actualVariation = decisionService.GetVariation(experiment, OptimizelyUserContextMock.Object, ProjectConfig, new UserAttributes());
 
             Assertions.AreEqual(variation, actualVariation.ResultObject);
@@ -895,13 +900,16 @@ public void TestGetVariationForFeatureWhenTheUserIsNotBucketedIntoFeatureExperim
                 It.IsAny<UserAttributes>(), ProjectConfig, It.IsAny<OptimizelyDecideOption[]>())).Returns(Result<FeatureDecision>.NullResult(null));
             DecisionServiceMock.Setup(ds => ds.GetVariationForFeatureRollout(It.IsAny<FeatureFlag>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), ProjectConfig)).Returns(expectedDecision);
+
+            var optlyObject = new Optimizely(TestData.Datafile, new ValidEventDispatcher(), LoggerMock.Object);
+            OptimizelyUserContextMock = new Mock<OptimizelyUserContext>(optlyObject, WhitelistedUserId, new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object);
             OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns(UserProfileId);
 
             var actualDecision = DecisionServiceMock.Object.GetVariationForFeature(featureFlag, OptimizelyUserContextMock.Object, ProjectConfig, new UserAttributes());
 
             Assert.IsTrue(TestData.CompareObjects(expectedDecision, actualDecision));
 
-            LoggerMock.Verify(l => l.Log(LogLevel.INFO, "The user \"user1\" is bucketed into a rollout for feature flag \"string_single_variable_feature\"."));
+            LoggerMock.Verify(l => l.Log(LogLevel.INFO, "The user \"userProfileId\" is bucketed into a rollout for feature flag \"string_single_variable_feature\"."));
         }
 
         // Should return null when the user neither gets bucketed into feature experiment nor in feature rollout.
diff --git a/OptimizelySDK.Tests/OptimizelyTest.cs b/OptimizelySDK.Tests/OptimizelyTest.cs
index 3744ee51..a8928172 100644
--- a/OptimizelySDK.Tests/OptimizelyTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyTest.cs
@@ -1692,10 +1692,8 @@ public void TestGetFeatureVariableDoubleReturnsRightValueWhenUserBuckedIntoFeatu
             var experiment = Config.GetExperimentFromKey("test_experiment_double_feature");
             var variation = Config.GetVariationFromKey("test_experiment_double_feature", "control");
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
@@ -1724,10 +1722,7 @@ public void TestGetFeatureVariableIntegerReturnsRightValueWhenUserBuckedIntoFeat
                { "location", "San Francisco" }
             };
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, userAttributes)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
@@ -1750,10 +1745,7 @@ public void TestGetFeatureVariableDoubleReturnsDefaultValueWhenUserBuckedIntoFea
             var variation = Config.GetVariationFromKey("test_experiment_double_feature", "variation");
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
@@ -1782,10 +1774,7 @@ public void TestGetFeatureVariableIntegerReturnsDefaultValueWhenUserBuckedIntoFe
                { "location", "San Francisco" }
             };
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, userAttributes)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
@@ -1808,10 +1797,7 @@ public void TestGetFeatureVariableBooleanReturnsRightValueWhenUserBuckedIntoRoll
             var variation = Config.GetVariationFromKey(experiment.Key, "177771");
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_ROLLOUT), DecisionReasons);
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
@@ -1840,10 +1826,7 @@ public void TestGetFeatureVariableJSONReturnsRightValueWhenUserBucketIntoRollout
                { "location", "San Francisco" }
             };
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, userAttributes)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
 
@@ -1875,10 +1858,7 @@ public void TestGetFeatureVariableJSONReturnsRightValueWhenUserBucketIntoRollout
                { "location", "San Francisco" }
             };
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, userAttributes)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
 
@@ -1909,10 +1889,7 @@ public void TestGetFeatureVariableStringReturnsRightValueWhenUserBuckedIntoRollo
                { "location", "San Francisco" }
             };
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, userAttributes)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
 
@@ -1936,10 +1913,7 @@ public void TestGetFeatureVariableBooleanReturnsDefaultValueWhenUserBuckedIntoRo
             var variation = Config.GetVariationFromKey(experiment.Key, "177782");
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_ROLLOUT), DecisionReasons);
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
@@ -1966,10 +1940,7 @@ public void TestGetFeatureVariableStringReturnsDefaultValueWhenUserBuckedIntoRol
                { "location", "San Francisco" }
             };
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, userAttributes)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("ProjectConfigManager", ConfigManager);
@@ -1990,10 +1961,7 @@ public void TestGetFeatureVariableDoubleReturnsDefaultValueWhenUserNotBuckedInto
             var expectedValue = 14.99;
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(null, null, FeatureDecision.DECISION_SOURCE_ROLLOUT), DecisionReasons);
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
@@ -2102,10 +2070,7 @@ public void TestGetFeatureVariableValueForTypeGivenFeatureFlagIsNotEnabledForUse
 
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
 
@@ -2133,11 +2098,8 @@ public void TestGetFeatureVariableValueForTypeGivenFeatureFlagIsEnabledForUserAn
             var variableType = "double";
             var expectedValue = 14.99;
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
             // Mock GetVariationForFeature method to return variation of different feature.
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(expectedDecision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(expectedDecision);
 
             var optly = Helper.CreatePrivateOptimizely();
 
@@ -2165,10 +2127,7 @@ public void TestGetFeatureVariableValueForTypeGivenFeatureFlagIsEnabledForUserAn
             var variation = Config.GetVariationFromKey("test_experiment_double_feature", "control");
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
 
@@ -2194,10 +2153,7 @@ public void TestGetFeatureVariableValueForTypeWithRolloutRule()
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_ROLLOUT), DecisionReasons);
             var expectedVariableValue = false;
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
 
@@ -2272,10 +2228,7 @@ public void TestIsFeatureEnabledGivenFeatureFlagIsNotEnabledForUser()
             var variation = Config.GetVariationFromKey("test_experiment_double_feature", "variation");
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
@@ -2300,10 +2253,7 @@ public void TestIsFeatureEnabledGivenFeatureFlagIsEnabledAndUserIsNotBeingExperi
             var featureFlag = Config.GetFeatureFlagFromKey(featureKey);
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_ROLLOUT), DecisionReasons);
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
@@ -2331,10 +2281,7 @@ public void TestIsFeatureEnabledGivenFeatureFlagIsEnabledAndUserIsBeingExperimen
             var featureFlag = Config.GetFeatureFlagFromKey(featureKey);
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
@@ -2362,10 +2309,7 @@ public void TestIsFeatureEnabledGivenFeatureFlagIsNotEnabledAndUserIsBeingExperi
             var featureFlag = Config.GetFeatureFlagFromKey(featureKey);
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
@@ -2417,14 +2361,9 @@ public void TestIsFeatureEnabledWithFeatureEnabledPropertyGivenFeatureExperiment
             var decisionTrue = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, featureEnabledTrue, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
             var decisionFalse = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, featureEnabledFalse, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decisionTrue);
-
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(userId);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decisionTrue);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decisionFalse);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decisionFalse);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
@@ -2446,10 +2385,7 @@ public void TestIsFeatureEnabledWithFeatureEnabledPropertyGivenRolloutRule()
             // Verify that IsFeatureEnabled returns true when user is bucketed into the rollout rule's variation.
             Assert.True(Optimizely.IsFeatureEnabled("boolean_single_variable_feature", TestUserId));
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns<FeatureDecision>(null);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns<FeatureDecision>(null);
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
 
@@ -2502,8 +2438,8 @@ public void TestActivateListener(UserAttributes userAttributes)
             Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>(OptimizelyMock.Object, TestUserId, userAttributes, ErrorHandlerMock.Object, LoggerMock.Object);
             mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, mockUserContext.Object, It.IsAny<ProjectConfig>(), userAttributes)).Returns(variation);
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, It.IsAny<ProjectConfig>(), userAttributes)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, It.IsAny<OptimizelyUserContext>(), It.IsAny<ProjectConfig>(), userAttributes)).Returns(variation);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), It.IsAny<ProjectConfig>(), userAttributes)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
             var optStronglyTyped = optly.GetObject() as Optimizely;
@@ -2582,10 +2518,10 @@ public void TestTrackListener(UserAttributes userAttributes, EventTags eventTags
             NotificationCallbackMock.Setup(nc => nc.TestAnotherTrackCallback(It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), It.IsAny<EventTags>(), It.IsAny<LogEvent>()));
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>(Optimizely, TestUserId, new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object);
             mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, mockUserContext.Object, Config, userAttributes)).Returns(variation);
+            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(variation);
 
             // Adding notification listeners.
             var notificationType = NotificationCenter.NotificationType.Track;
@@ -2623,10 +2559,7 @@ public void TestActivateSendsDecisionNotificationWithActualVariationKey()
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), It.IsAny<Dictionary<string, object>>()));
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, mockUserContext.Object, Config, userAttributes)).Returns(variation);
+            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(variation);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("ProjectConfigManager", ConfigManager);
@@ -2663,10 +2596,7 @@ public void TestActivateSendsDecisionNotificationWithVariationKeyAndTypeFeatureT
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), It.IsAny<Dictionary<string, object>>()));
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, mockUserContext.Object, Config, userAttributes)).Returns(variation);
+            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(variation);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("ProjectConfigManager", ConfigManager);
@@ -2691,16 +2621,13 @@ public void TestActivateSendsDecisionNotificationWithNullVariationKey()
             var experimentKey = "test_experiment";
             var experiment = Config.GetExperimentFromKey(experimentKey);
 
+            var optly = Helper.CreatePrivateOptimizely();
+            var optStronglyTyped = optly.GetObject() as Optimizely;
+
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), It.IsAny<Dictionary<string, object>>()));
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, mockUserContext.Object, It.IsAny<ProjectConfig>(), null)).Returns(Result<Variation>.NullResult(null));
-
-            var optly = Helper.CreatePrivateOptimizely();
-            var optStronglyTyped = optly.GetObject() as Optimizely;
+            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, It.IsAny<OptimizelyUserContext>(), It.IsAny<ProjectConfig>(), null)).Returns(Result<Variation>.NullResult(null));
 
             optStronglyTyped.NotificationCenter.AddNotification(NotificationCenter.NotificationType.Decision, NotificationCallbackMock.Object.TestDecisionCallback);
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
@@ -2729,19 +2656,19 @@ public void TestGetVariationSendsDecisionNotificationWithActualVariationKey()
                { "location", "San Francisco" }
             };
 
+            var optly = Helper.CreatePrivateOptimizely();
+
+            optly.SetFieldOrProperty("ProjectConfigManager", ConfigManager);
+            var optStronglyTyped = optly.GetObject() as Optimizely;
+
             // Mocking objects.
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), It.IsAny<Dictionary<string, object>>()));
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>(optStronglyTyped, TestUserId, new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object);
             mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, mockUserContext.Object, Config, userAttributes)).Returns(variation);
-
-            var optly = Helper.CreatePrivateOptimizely();
-
-            optly.SetFieldOrProperty("ProjectConfigManager", ConfigManager);
-            var optStronglyTyped = optly.GetObject() as Optimizely;
+            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(variation);
 
             optStronglyTyped.NotificationCenter.AddNotification(NotificationCenter.NotificationType.Decision, NotificationCallbackMock.Object.TestDecisionCallback);
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
@@ -2770,17 +2697,17 @@ public void TestGetVariationSendsDecisionNotificationWithVariationKeyAndTypeFeat
                { "location", "San Francisco" }
             };
 
+            var optly = Helper.CreatePrivateOptimizely();
+            var optStronglyTyped = optly.GetObject() as Optimizely;
+
             // Mocking objects.
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), It.IsAny<Dictionary<string, object>>()));
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>(optStronglyTyped, TestUserId, new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object);
             mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, mockUserContext.Object, Config, userAttributes)).Returns(variation);
-
-            var optly = Helper.CreatePrivateOptimizely();
-            var optStronglyTyped = optly.GetObject() as Optimizely;
+            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(variation);
 
             optStronglyTyped.NotificationCenter.AddNotification(NotificationCenter.NotificationType.Decision, NotificationCallbackMock.Object.TestDecisionCallback);
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
@@ -2802,18 +2729,19 @@ public void TestGetVariationSendsDecisionNotificationWithNullVariationKey()
             var experimentKey = "test_experiment";
             var experiment = Config.GetExperimentFromKey(experimentKey);
 
+            var optly = Helper.CreatePrivateOptimizely();
+            var optStronglyTyped = optly.GetObject() as Optimizely;
+
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), It.IsAny<Dictionary<string, object>>()));
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
+            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>(optStronglyTyped, TestUserId, new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object);
+
             mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariation(It.IsAny<Experiment>(), mockUserContext.Object, It.IsAny<ProjectConfig>(), It.IsAny<UserAttributes>())).Returns(Result<Variation>.NullResult(null));
+            DecisionServiceMock.Setup(ds => ds.GetVariation(It.IsAny<Experiment>(), It.IsAny<OptimizelyUserContext>(), It.IsAny<ProjectConfig>(), It.IsAny<UserAttributes>())).Returns(Result<Variation>.NullResult(null));
             //DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, TestUserId, Config, null)).Returns(Result<Variation>.NullResult(null));
 
-            var optly = Helper.CreatePrivateOptimizely();
-            var optStronglyTyped = optly.GetObject() as Optimizely;
-
             optStronglyTyped.NotificationCenter.AddNotification(NotificationCenter.NotificationType.Decision, NotificationCallbackMock.Object.TestDecisionCallback);
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
 
@@ -2835,16 +2763,11 @@ public void TestIsFeatureEnabledSendsDecisionNotificationWithFeatureEnabledTrueF
             var featureFlag = Config.GetFeatureFlagFromKey(featureKey);
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation.ResultObject, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), It.IsAny<Dictionary<string, object>>()));
 
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, mockUserContext.Object, ConfigManager.GetConfig(), null)).Returns(variation);
+            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, It.IsAny<OptimizelyUserContext>(), ConfigManager.GetConfig(), null)).Returns(variation);
 
             var optly = Helper.CreatePrivateOptimizely();
             var optStronglyTyped = optly.GetObject() as Optimizely;
@@ -2876,14 +2799,11 @@ public void TestIsFeatureEnabledSendsDecisionNotificationWithFeatureEnabledFalse
             var featureFlag = Config.GetFeatureFlagFromKey(featureKey);
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation.ResultObject, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), It.IsAny<Dictionary<string, object>>()));
 
-            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, mockUserContext.Object, Config, null)).Returns(variation);
+            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(variation);
 
             var optly = Helper.CreatePrivateOptimizely();
             var optStronglyTyped = optly.GetObject() as Optimizely;
@@ -2925,10 +2845,7 @@ public void TestIsFeatureEnabledSendsDecisionNotificationWithFeatureEnabledTrueF
             var featureFlag = Config.GetFeatureFlagFromKey(featureKey);
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_ROLLOUT), DecisionReasons);
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, userAttributes)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), It.IsAny<Dictionary<string, object>>()));
 
@@ -2967,10 +2884,7 @@ public void TestIsFeatureEnabledSendsDecisionNotificationWithFeatureEnabledFalse
             var featureFlag = Config.GetFeatureFlagFromKey(featureKey);
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_ROLLOUT), DecisionReasons);
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, userAttributes)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), It.IsAny<Dictionary<string, object>>()));
 
@@ -3002,10 +2916,7 @@ public void TestIsFeatureEnabledSendsDecisionNotificationWithFeatureEnabledFalse
             var featureFlag = Config.GetFeatureFlagFromKey(featureKey);
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(null, null, FeatureDecision.DECISION_SOURCE_ROLLOUT), DecisionReasons);
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), It.IsAny<Dictionary<string, object>>()));
 
@@ -3145,10 +3056,7 @@ public void TestGetFeatureVariableDoubleSendsNotificationWhenUserBuckedIntoFeatu
             var variation = Config.GetVariationFromKey("test_experiment_double_feature", "control");
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<UserAttributes>(),
                 It.IsAny<Dictionary<string, object>>()));
 
@@ -3202,10 +3110,7 @@ public void TestGetFeatureVariableJsonSendsNotificationWhenUserBuckedIntoFeature
                { "location", "San Francisco" }
             };
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, userAttributes)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<UserAttributes>(),
                 It.IsAny<Dictionary<string, object>>()));
 
@@ -3250,10 +3155,7 @@ public void TestGetFeatureVariableIntegerSendsNotificationWhenUserBuckedIntoFeat
                { "location", "San Francisco" }
             };
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, userAttributes)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<UserAttributes>(),
                 It.IsAny<Dictionary<string, object>>()));
 
@@ -3297,10 +3199,7 @@ public void TestGetFeatureVariableDoubleSendsNotificationWhenUserBuckedIntoFeatu
             var variation = Config.GetVariationFromKey("test_experiment_double_feature", "variation");
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<UserAttributes>(),
                 It.IsAny<Dictionary<string, object>>()));
 
@@ -3349,10 +3248,7 @@ public void TestGetFeatureVariableIntegerSendsNotificationWhenUserBuckedIntoFeat
                { "location", "San Francisco" }
             };
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, userAttributes)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<UserAttributes>(),
                 It.IsAny<Dictionary<string, object>>()));
 
@@ -3395,10 +3291,7 @@ public void TestGetFeatureVariableBooleanSendsNotificationWhenUserBuckedIntoRoll
             var variation = Config.GetVariationFromKey(experiment.Key, "177771");
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_ROLLOUT), DecisionReasons);
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<UserAttributes>(),
                 It.IsAny<Dictionary<string, object>>()));
 
@@ -3442,10 +3335,7 @@ public void TestGetFeatureVariableStringSendsNotificationWhenUserBuckedIntoRollo
                { "location", "San Francisco" }
             };
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, userAttributes)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<UserAttributes>(),
                 It.IsAny<Dictionary<string, object>>()));
 
@@ -3484,10 +3374,7 @@ public void TestGetFeatureVariableBooleanSendsNotificationWhenUserBuckedIntoRoll
             var variation = Config.GetVariationFromKey(experiment.Key, "177782");
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_ROLLOUT), DecisionReasons);
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<UserAttributes>(),
                 It.IsAny<Dictionary<string, object>>()));
 
@@ -3531,10 +3418,7 @@ public void TestGetFeatureVariableStringSendsNotificationWhenUserBuckedIntoRollo
                { "location", "San Francisco" }
             };
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, userAttributes)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<UserAttributes>(),
                 It.IsAny<Dictionary<string, object>>()));
 
@@ -3570,10 +3454,7 @@ public void TestGetFeatureVariableDoubleSendsNotificationWhenUserNotBuckedIntoBo
             var expectedValue = 14.99;
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(null, null, FeatureDecision.DECISION_SOURCE_ROLLOUT), DecisionReasons);
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<UserAttributes>(),
                 It.IsAny<Dictionary<string, object>>()));
 
@@ -3630,10 +3511,7 @@ public void TestGetAllFeatureVariablesSendsNotificationWhenUserBucketIntoRollout
                { "location", "San Francisco" }
             };
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, userAttributes)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<UserAttributes>(),
                 It.IsAny<Dictionary<string, object>>()));
 
@@ -3721,10 +3599,7 @@ public void TestGetAllFeatureVariablesRollout()
 
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, null, FeatureDecision.DECISION_SOURCE_ROLLOUT), DecisionReasons);
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>();
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, mockUserContext.Object, Config, userAttributes)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);

From a46516e69be27af38b6620babbc530bd804444a0 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Mon, 11 Oct 2021 12:47:20 -0400
Subject: [PATCH 020/130] Updated comments and removed unused function

---
 OptimizelySDK/OptimizelyUserContext.cs | 89 ++++++++++----------------
 1 file changed, 34 insertions(+), 55 deletions(-)

diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index 5fa9913e..1ab492bb 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -1,4 +1,4 @@
-/* 
+/*
  * Copyright 2020-2021, Optimizely
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -51,10 +51,13 @@ public ForcedDecision(string flagKey, string ruleKey, string variationKey)
         private ILogger Logger;
         private IErrorHandler ErrorHandler;
         private object mutex = new object();
+
         // userID for Optimizely user context
         private string UserId;
+
         // user attributes for Optimizely user context.
         private UserAttributes Attributes;
+
         // Optimizely object to be used.
         private Optimizely Optimizely;
 
@@ -97,7 +100,8 @@ public virtual string GetUserId()
         public UserAttributes GetAttributes()
         {
             UserAttributes copiedAttributes = null;
-            lock(mutex) {
+            lock (mutex)
+            {
                 copiedAttributes = new UserAttributes(Attributes);
             }
 
@@ -208,17 +212,17 @@ public virtual void TrackEvent(string eventName)
         /// </summary>
         /// <param name="eventName">The event name.</param>
         /// <param name="eventTags">A map of event tag names to event tag values.</param>
-        public virtual void TrackEvent(string eventName, 
+        public virtual void TrackEvent(string eventName,
             EventTags eventTags)
         {
             Optimizely.Track(eventName, UserId, Attributes, eventTags);
         }
 
         /// <summary>
-        /// 
+        /// Set a forced decision.
         /// </summary>
-        /// <param name="flagKey"></param>
-        /// <param name="variationKey"></param>
+        /// <param name="flagKey">The flag key.</param>
+        /// <param name="variationKey">The variation key.</param>
         /// <returns></returns>
 
         public bool SetForcedDecision(string flagKey, string variationKey)
@@ -227,11 +231,11 @@ public bool SetForcedDecision(string flagKey, string variationKey)
         }
 
         /// <summary>
-        /// 
+        /// Set a forced decision.
         /// </summary>
-        /// <param name="flagKey"></param>
-        /// <param name="ruleKey"></param>
-        /// <param name="variationKey"></param>
+        /// <param name="flagKey">The flag key.</param>
+        /// <param name="ruleKey">The rule key.</param>
+        /// <param name="variationKey">The variation key.</param>
         /// <returns></returns>
         public bool SetForcedDecision(string flagKey, string ruleKey, string variationKey)
         {
@@ -241,7 +245,7 @@ public bool SetForcedDecision(string flagKey, string ruleKey, string variationKe
                 return false;
             }
 
-            if(ruleKey == null)
+            if (ruleKey == null)
             {
                 if (ForcedDecisionsMapWithNoRuleKey.TryGetValue(flagKey, out var value))
                 {
@@ -324,21 +328,21 @@ public string FindForcedDecision(string flagKey, string ruleKey)
         }
 
         /// <summary>
-        /// 
+        /// Removes a forced decision.
         /// </summary>
-        /// <param name="flagKey"></param>
-        /// <returns></returns>
+        /// <param name="flagKey">The flag key.</param>
+        /// <returns>Whether the item was removed.</returns>
         public bool RemoveForcedDecision(string flagKey)
         {
             return RemoveForcedDecision(flagKey, null);
         }
 
         /// <summary>
-        /// 
+        /// Removes a forced decision.
         /// </summary>
-        /// <param name="flagKey"></param>
+        /// <param name="flagKey">The flag key.</param>
         /// <param name="ruleKey"></param>
-        /// <returns></returns>
+        /// <returns>Whether the item was removed.</returns>
         public bool RemoveForcedDecision(string flagKey, string ruleKey)
         {
             if (Optimizely.GetOptimizelyConfig() == null)
@@ -358,16 +362,15 @@ public bool RemoveForcedDecision(string flagKey, string ruleKey)
             }
             else
             {
-                
                 ForcedDecisionsMapWithNoRuleKey.Remove(flagKey);
                 return true;
             }
         }
 
         /// <summary>
-        /// 
+        /// Removes all forced decisions.
         /// </summary>
-        /// <returns></returns>
+        /// <returns>Whether the clear was successful.</returns>
         public bool RemoveAllForcedDecisions()
         {
             if (Optimizely.GetOptimizelyConfig() == null)
@@ -375,36 +378,36 @@ public bool RemoveAllForcedDecisions()
                 Logger.Log(LogLevel.ERROR, "Optimizely SDK not ready.");
                 return false;
             }
-            
+
             ForcedDecisionsMap.Clear();
             ForcedDecisionsMapWithNoRuleKey.Clear();
             return true;
         }
 
         /// <summary>
-        /// 
+        /// Finds a validated forced decision.
         /// </summary>
-        /// <param name="flagKey"></param>
-        /// <returns></returns>
+        /// <param name="flagKey">The flag key.</param>
+        /// <returns>A result with the variation.</returns>
         public Result<Variation> FindValidatedForcedDecision(string flagKey)
         {
             return FindValidatedForcedDecision(flagKey, null);
         }
 
         /// <summary>
-        /// 
+        /// Finds a validated forced decision.
         /// </summary>
-        /// <param name="flagKey"></param>
-        /// <param name="ruleKey"></param>
-        /// <returns></returns>
+        /// <param name="flagKey">The flag key.</param>
+        /// <param name="ruleKey">The rule key.</param>
+        /// <returns>A result with the variation</returns>
         public Result<Variation> FindValidatedForcedDecision(string flagKey, string ruleKey)
         {
             DecisionReasons reasons = new DecisionReasons();
-            
+
             string variationKey = FindForcedDecision(flagKey, ruleKey);
             if (variationKey != null)
             {
-                Variation variation =  new Variation();
+                Variation variation = new Variation();
                 string strRuleKey = ruleKey ?? "null";
                 string info = string.Empty;
                 if (variation != null)
@@ -423,30 +426,6 @@ public Result<Variation> FindValidatedForcedDecision(string flagKey, string rule
             }
 
             return Result<Variation>.NullResult(reasons);
-
         }
-
-        /// <summary>
-        /// 
-        /// </summary>
-        /// <param name="flagKey"></param>
-        /// <param name="variationKey"></param>
-        /// <returns></returns>
-        public Variation GetFlagVariationByKey(string flagKey, string variationKey)
-        {
-            var flagVariationsMap = Optimizely.GetOptimizelyConfig().FlagToVariationMap;
-            if (flagVariationsMap.TryGetValue(flagKey, out var variations))
-            {
-                foreach (var variation in variations)
-                {
-                    if (variation.Key.Equals(variationKey))
-                    {
-                        return variation;
-                    }
-                }
-            }
-            return null;
-        }
-
     }
-}
+}
\ No newline at end of file

From b62c54762a80c775771820b68f5c32093d1a9bf3 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Wed, 13 Oct 2021 08:15:16 -0400
Subject: [PATCH 021/130] Renamed arguments

---
 .../OptimizelyUserContextTest.cs              | 67 +++++++++----------
 1 file changed, 31 insertions(+), 36 deletions(-)

diff --git a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
index 2b6266d3..1d88f114 100644
--- a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
@@ -37,7 +37,7 @@ namespace OptimizelySDK.Tests
     [TestFixture]
     public class OptimizelyUserContextTest
     {
-        string UserID = "testUserID";
+        private string UserID = "testUserID";
         private Optimizely Optimizely;
         private Mock<ILogger> LoggerMock;
         private Mock<IErrorHandler> ErrorHandlerMock;
@@ -153,7 +153,6 @@ public void SetAttributeToOverrideAttribute()
         {
             OptimizelyUserContext user = new OptimizelyUserContext(Optimizely, UserID, null, ErrorHandlerMock.Object, LoggerMock.Object);
 
-
             Assert.AreEqual(user.GetOptimizely(), Optimizely);
             Assert.AreEqual(user.GetUserId(), UserID);
 
@@ -200,7 +199,6 @@ public void SetForcedDecisionSetsValue()
         public void SetForcedDecisionReturnsFalseForNullConfig()
         {
             var optly = new Optimizely(new FallbackProjectConfigManager(null));
-           
 
             var user = optly.CreateUserContext(UserID);
             var result = user.SetForcedDecision("flag", "variation");
@@ -214,35 +212,33 @@ public void GetForcedDecisionsReturnsValueWithRuleKey()
         {
             var user = Optimizely.CreateUserContext(UserID);
 
-            user.SetForcedDecision("flag", "rule", "variation");
+            user.SetForcedDecision("flagKey", "ruleKey", "variation");
 
-            var result = user.GetForcedDecision("flag", "rule");
+            var result = user.GetForcedDecision("flagKey", "ruleKey");
 
             Assert.AreEqual("variation", result);
         }
 
         [Test]
-
         public void GetForcedDecisionReturnsValueWithoutRuleKey()
         {
             var user = Optimizely.CreateUserContext(UserID);
 
-            user.SetForcedDecision("flag", "variation");
+            user.SetForcedDecision("flagKey", "variation");
 
-            var result = user.GetForcedDecision("flag", null);
+            var result = user.GetForcedDecision("flagKey", null);
 
             Assert.AreEqual("variation", result);
         }
 
         [Test]
-
         public void GetForcedDecisionReturnsValueWithOnlyFlagKey()
         {
             var user = Optimizely.CreateUserContext(UserID);
 
-            user.SetForcedDecision("flag", "variation");
+            user.SetForcedDecision("flagKey", "variation");
 
-            var result = user.GetForcedDecision("flag");
+            var result = user.GetForcedDecision("flagKey");
 
             Assert.AreEqual("variation", result);
         }
@@ -252,9 +248,9 @@ public void FindForcedDecisionReturnsValueWithoutRuleKey()
         {
             var user = Optimizely.CreateUserContext(UserID);
 
-            user.SetForcedDecision("flag", "variation");
+            user.SetForcedDecision("flagKey", "variation");
 
-            var result = user.FindForcedDecision("flag", null);
+            var result = user.FindForcedDecision("flagKey", null);
 
             Assert.AreEqual("variation", result);
         }
@@ -264,9 +260,9 @@ public void FindForcedDecisionReturnsValueWithRuleKey()
         {
             var user = Optimizely.CreateUserContext(UserID);
 
-            user.SetForcedDecision("flag", "rule", "variation");
+            user.SetForcedDecision("flagKey", "rule", "variation");
 
-            var result = user.FindForcedDecision("flag", "rule");
+            var result = user.FindForcedDecision("flagKey", "rule");
 
             Assert.AreEqual("variation", result);
         }
@@ -276,14 +272,13 @@ public void RemoveForcedDecisionRemovesDecision()
         {
             var user = Optimizely.CreateUserContext(UserID);
 
-            user.SetForcedDecision("flag", "rule", "variation");
+            user.SetForcedDecision("flagKey", "ruleKey", "variation");
 
-            user.RemoveForcedDecision("flag", "rule");
+            user.RemoveForcedDecision("flagKey", "ruleKey");
 
-            var result = user.FindForcedDecision("flag", "rule");
+            var result = user.FindForcedDecision("flagKey", "ruleKey");
 
             Assert.AreEqual(null, result);
-
         }
 
         [Test]
@@ -291,14 +286,12 @@ public void RemoveForcedDecisionReturnsFalseForNullConfig()
         {
             var optly = new Optimizely(new FallbackProjectConfigManager(null));
 
-
             var user = optly.CreateUserContext(UserID);
             user.SetForcedDecision("flag", "variation");
 
             var result = user.RemoveForcedDecision("flag", null);
 
             Assert.AreEqual(false, result);
-            
         }
 
         [Test]
@@ -314,7 +307,7 @@ public void RemoveAllForcedDecisionsRemovesDecisions()
 
             var result1 = user.GetForcedDecision("flag", null);
             Assert.AreEqual(null, result1);
-            
+
             var result2 = user.GetForcedDecision("flag2", null);
             Assert.AreEqual(null, result2);
 
@@ -327,7 +320,6 @@ public void RemoveAllForcedDecisionsReturnsFalseForNullConfig()
         {
             var optly = new Optimizely(new FallbackProjectConfigManager(null));
 
-
             var user = optly.CreateUserContext(UserID);
             user.SetForcedDecision("flag", "variation");
 
@@ -372,7 +364,8 @@ public void DecideWhenConfigIsNull()
 
             Assert.IsTrue(TestData.CompareObjects(decision, decisionExpected));
         }
-        #endregion
+
+        #endregion decide
 
         #region decideAll
 
@@ -585,7 +578,7 @@ public void DecideAllAllFlags()
             user,
             new string[0]);
             Assert.IsTrue(TestData.CompareObjects(decisions[flagKey9], expDecision9));
-            
+
             OptimizelyDecision expDecision10 = new OptimizelyDecision(
             null,
             false,
@@ -719,7 +712,7 @@ public void DecideIncludeReasonsDecideOptions()
             Assert.AreEqual(decision.Reasons[0], DecisionMessage.Reason(DecisionMessage.FLAG_KEY_INVALID, flagKey));
 
             var decideOptions = new OptimizelyDecideOption[] { OptimizelyDecideOption.INCLUDE_REASONS };
-            
+
             decision = user.Decide(flagKey, decideOptions);
             Assert.True(decision.Reasons.Length == 1);
             Assert.AreEqual(decision.Reasons[0], DecisionMessage.Reason(DecisionMessage.FLAG_KEY_INVALID, flagKey));
@@ -818,7 +811,7 @@ public void TestDecisionNotification()
                 { "reasons", reasons },
                 { "decisionEventDispatched", true },
             };
-         
+
             var userAttributes = new UserAttributes
             {
                { "browser_type", "chrome" }
@@ -832,8 +825,8 @@ public void TestDecisionNotification()
 
             user.Decide(flagKey);
             NotificationCallbackMock.Verify(nc => nc.TestDecisionCallback(DecisionNotificationTypes.FLAG, UserID, userAttributes, It.Is<Dictionary<string, object>>(info =>
-               TestData.CompareObjects(info, decisionInfo))), 
-               Times.Once); 
+               TestData.CompareObjects(info, decisionInfo))),
+               Times.Once);
         }
 
         [Test]
@@ -848,7 +841,6 @@ public void TestDecideOptionsByPassUPS()
             var fbVariationId = "122237";
             var fbVariationKey = "variation";
 
-
             var userProfile = new UserProfile(userId, new Dictionary<string, Decision>
             {
                 { experimentId, new Decision(fbVariationId)}
@@ -859,9 +851,9 @@ public void TestDecideOptionsByPassUPS()
             var optimizely = new Optimizely(TestData.Datafile, EventDispatcherMock.Object, LoggerMock.Object, ErrorHandlerMock.Object, userProfileServiceMock.Object);
 
             var user = optimizely.CreateUserContext(userId);
-            
+
             var projectConfig = DatafileProjectConfig.Create(TestData.Datafile, LoggerMock.Object, ErrorHandlerMock.Object);
-            
+
             var variationUserProfile = user.Decide(flagKey);
             Assert.AreEqual(fbVariationKey, variationUserProfile.VariationKey);
 
@@ -888,9 +880,11 @@ public void TestDecideOptionsByPassUPSNeverCallsSaveVariation()
 
             Assert.AreEqual(variationKey, variationUserProfile.VariationKey);
         }
-        #endregion
+
+        #endregion decideAll
 
         #region TrackEvent
+
         [Test]
         public void TestTrackEventWithAudienceConditions()
         {
@@ -913,7 +907,7 @@ public void TestTrackEventWithAudienceConditions()
         public void TrackEventEmptyAttributesWithEventTags()
         {
             var OptimizelyWithTypedAudiences = new Optimizely(TestData.TypedAudienceDatafile, EventDispatcherMock.Object, LoggerMock.Object, ErrorHandlerMock.Object);
-            
+
             var user = OptimizelyWithTypedAudiences.CreateUserContext(UserID);
 
             // Should be excluded as exact match boolean audience with id '3468206643' does not match so the overall conditions fail.
@@ -925,6 +919,7 @@ public void TrackEventEmptyAttributesWithEventTags()
 
             EventDispatcherMock.Verify(dispatcher => dispatcher.DispatchEvent(It.IsAny<LogEvent>()), Times.Once);
         }
-        #endregion
+
+        #endregion TrackEvent
     }
-}
+}
\ No newline at end of file

From 7df6dd01093e5d365ea50565c0e7e3b72c5dd95d Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Wed, 13 Oct 2021 08:15:59 -0400
Subject: [PATCH 022/130] Additional updates

---
 .../OptimizelyUserContextTest.cs               | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
index 1d88f114..2f725b8e 100644
--- a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
@@ -287,9 +287,9 @@ public void RemoveForcedDecisionReturnsFalseForNullConfig()
             var optly = new Optimizely(new FallbackProjectConfigManager(null));
 
             var user = optly.CreateUserContext(UserID);
-            user.SetForcedDecision("flag", "variation");
+            user.SetForcedDecision("flagKey", "variation");
 
-            var result = user.RemoveForcedDecision("flag", null);
+            var result = user.RemoveForcedDecision("flagKey", null);
 
             Assert.AreEqual(false, result);
         }
@@ -299,19 +299,19 @@ public void RemoveAllForcedDecisionsRemovesDecisions()
         {
             var user = Optimizely.CreateUserContext(UserID);
 
-            user.SetForcedDecision("flag", "rule", "variation");
-            user.SetForcedDecision("flag2", "rule2", "variation2");
-            user.SetForcedDecision("flag3", "rule3", "variation3");
+            user.SetForcedDecision("flagKey", "ruleKey", "variation");
+            user.SetForcedDecision("flagKey2", "ruleKey2", "variation2");
+            user.SetForcedDecision("flagKey3", "ruleKey3", "variation3");
 
             user.RemoveAllForcedDecisions();
 
-            var result1 = user.GetForcedDecision("flag", null);
+            var result1 = user.GetForcedDecision("flagKey", null);
             Assert.AreEqual(null, result1);
 
-            var result2 = user.GetForcedDecision("flag2", null);
+            var result2 = user.GetForcedDecision("flagKey2", null);
             Assert.AreEqual(null, result2);
 
-            var result3 = user.GetForcedDecision("flag3", null);
+            var result3 = user.GetForcedDecision("flagKey3", null);
             Assert.AreEqual(null, result3);
         }
 
@@ -321,7 +321,7 @@ public void RemoveAllForcedDecisionsReturnsFalseForNullConfig()
             var optly = new Optimizely(new FallbackProjectConfigManager(null));
 
             var user = optly.CreateUserContext(UserID);
-            user.SetForcedDecision("flag", "variation");
+            user.SetForcedDecision("flagKey", "variation");
 
             var result = user.RemoveAllForcedDecisions();
 

From d1e8e68369d3907a15fdd1820d28e9573a8cc057 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Thu, 14 Oct 2021 11:00:09 -0400
Subject: [PATCH 023/130] Removed unnecessary config info

---
 OptimizelySDK.Tests/Assertions.cs             |  1 -
 .../OptimizelyConfigTest.cs                   |  4 +--
 OptimizelySDK/OptlyConfig/OptimizelyConfig.cs | 26 ++++---------------
 .../OptlyConfig/OptimizelyConfigService.cs    | 26 ++++++++-----------
 4 files changed, 17 insertions(+), 40 deletions(-)

diff --git a/OptimizelySDK.Tests/Assertions.cs b/OptimizelySDK.Tests/Assertions.cs
index 53466573..9e09a6dc 100644
--- a/OptimizelySDK.Tests/Assertions.cs
+++ b/OptimizelySDK.Tests/Assertions.cs
@@ -142,7 +142,6 @@ public static void AreEqual(OptimizelyConfig expected, OptimizelyConfig actual)
             AreEquivalent(expected.Events, actual.Events);
             AreEquivalent(expected.ExperimentsMap, actual.ExperimentsMap);
             AreEquivalent(expected.FeaturesMap, actual.FeaturesMap);
-            AreEquivalent(expected.FlagToVariationMap, actual.FlagToVariationMap);
             Assert.AreEqual(expected.Revision, actual.Revision);
             Assert.AreEqual(expected.SDKKey, actual.SDKKey);
         }
diff --git a/OptimizelySDK.Tests/OptimizelyConfigTests/OptimizelyConfigTest.cs b/OptimizelySDK.Tests/OptimizelyConfigTests/OptimizelyConfigTest.cs
index 44b9dcb8..a64b90dc 100644
--- a/OptimizelySDK.Tests/OptimizelyConfigTests/OptimizelyConfigTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyConfigTests/OptimizelyConfigTest.cs
@@ -699,7 +699,6 @@ public void TestGetOptimizelyConfigService()
                 },
                 experimentsMap: experimentsMap,
                 featuresMap: featuresMap,
-                flagToVariationMap: expectedflagVariations,
                 datafile: TestData.TypedAudienceDatafile);
 
             Assertions.AreEqual(expectedOptimizelyConfig, optimizelyConfig);
@@ -719,8 +718,7 @@ public void TestOptimizelyConfigEntity()
                 audiences: new OptimizelyAudience[0],
                 events: new OptimizelyEvent[0],
                 experimentsMap: new Dictionary<string, OptimizelyExperiment>(),
-                featuresMap: new Dictionary<string, OptimizelyFeature>(),
-                flagToVariationMap: new Dictionary<string, List<Variation>>()
+                featuresMap: new Dictionary<string, OptimizelyFeature>()
                 );
             Assert.AreEqual(expectedOptlyFeature.Revision, "123");
             Assert.AreEqual(expectedOptlyFeature.SDKKey, "testSdkKey");
diff --git a/OptimizelySDK/OptlyConfig/OptimizelyConfig.cs b/OptimizelySDK/OptlyConfig/OptimizelyConfig.cs
index 218800ab..f16521ab 100644
--- a/OptimizelySDK/OptlyConfig/OptimizelyConfig.cs
+++ b/OptimizelySDK/OptlyConfig/OptimizelyConfig.cs
@@ -1,4 +1,4 @@
-/* 
+/*
  * Copyright 2019-2021, Optimizely
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -32,16 +32,14 @@ public class OptimizelyConfig
 
         /// <summary>
         /// This experimentsMap is for experiments of legacy projects only.
-        /// For flag projects, experiment keys are not guaranteed to be unique 
-        /// across multiple flags, so this map may not include all experiments 
+        /// For flag projects, experiment keys are not guaranteed to be unique
+        /// across multiple flags, so this map may not include all experiments
         /// when keys conflict.
-        /// </summary> 
+        /// </summary>
         public IDictionary<string, OptimizelyExperiment> ExperimentsMap { get; private set; }
 
         public IDictionary<string, OptimizelyFeature> FeaturesMap { get; private set; }
 
-        public IDictionary<string, List<Variation>> FlagToVariationMap { get; private set; }
-
         private string _datafile;
 
         public OptimizelyConfig(string revision, IDictionary<string, OptimizelyExperiment> experimentsMap, IDictionary<string, OptimizelyFeature> featuresMap, string datafile = null)
@@ -65,20 +63,6 @@ public OptimizelyConfig(string revision, string sdkKey, string environmentKey, O
             _datafile = datafile;
         }
 
-        public OptimizelyConfig(string revision, string sdkKey, string environmentKey, OptimizelyAttribute[] attributes, OptimizelyAudience[] audiences, OptimizelyEvent[] events, IDictionary<string, OptimizelyExperiment> experimentsMap, IDictionary<string, OptimizelyFeature> featuresMap, IDictionary<string, List<Variation>> flagToVariationMap, string datafile = null)
-        {
-            Revision = revision;
-            SDKKey = sdkKey;
-            Attributes = attributes;
-            Audiences = audiences;
-            Events = events;
-            EnvironmentKey = environmentKey;
-            ExperimentsMap = experimentsMap;
-            FeaturesMap = featuresMap;
-            FlagToVariationMap = flagToVariationMap;
-            _datafile = datafile;
-        }
-
         /// <summary>
         /// Get the datafile associated with OptimizelyConfig.
         /// </summary>
@@ -88,4 +72,4 @@ public string GetDatafile()
             return _datafile;
         }
     }
-}
+}
\ No newline at end of file
diff --git a/OptimizelySDK/OptlyConfig/OptimizelyConfigService.cs b/OptimizelySDK/OptlyConfig/OptimizelyConfigService.cs
index e2610a96..21b49be7 100644
--- a/OptimizelySDK/OptlyConfig/OptimizelyConfigService.cs
+++ b/OptimizelySDK/OptlyConfig/OptimizelyConfigService.cs
@@ -1,4 +1,4 @@
-/* 
+/*
  * Copyright 2019-2021, Optimizely
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -30,7 +30,6 @@ public class OptimizelyConfigService
         private OptimizelyConfig OptimizelyConfig;
 
         private IDictionary<string, List<FeatureVariable>> featureIdVariablesMap;
-        
 
         public OptimizelyConfigService(ProjectConfig projectConfig)
         {
@@ -43,7 +42,7 @@ public OptimizelyConfigService(ProjectConfig projectConfig)
             var audiences = GetAudiences(projectConfig);
             var experimentsMapById = GetExperimentsMapById(projectConfig);
             var experimentsKeyMap = GetExperimentsKeyMap(experimentsMapById);
-            
+
             var featureMap = GetFeaturesMap(projectConfig, experimentsMapById);
             var events = GetEvents(projectConfig);
             var variationByFlagMap = GetVariationsByFlag(projectConfig);
@@ -56,7 +55,6 @@ public OptimizelyConfigService(ProjectConfig projectConfig)
                 events,
                 experimentsKeyMap,
                 featureMap,
-                flagToVariationMap: variationByFlagMap,
                 projectConfig.ToDatafile());
         }
 
@@ -89,7 +87,7 @@ private OptimizelyAudience[] GetAudiences(ProjectConfig projectConfig)
                 && !typedAudienceIds.Contains(aud.Id));
             var optimizelyAudience = filteredAudiencesArr.Select(aud => new OptimizelyAudience(aud.Id, aud.Name, aud.Conditions));
 
-            optimizelyAudience = optimizelyAudience.Concat(typedAudiences).OrderBy( aud => aud.Name);
+            optimizelyAudience = optimizelyAudience.Concat(typedAudiences).OrderBy(aud => aud.Name);
 
             return optimizelyAudience.ToArray<OptimizelyAudience>();
         }
@@ -117,7 +115,8 @@ private IDictionary<string, OptimizelyExperiment> GetExperimentsKeyMap(IDictiona
         {
             var experimentKeyMaps = new Dictionary<string, OptimizelyExperiment>();
 
-            foreach(var experiment in experimentsMapById.Values) {
+            foreach (var experiment in experimentsMapById.Values)
+            {
                 experimentKeyMaps[experiment.Key] = experiment;
             }
             return experimentKeyMaps;
@@ -183,7 +182,7 @@ private IDictionary<string, OptimizelyVariation> GetVariationsMap(IEnumerable<Va
         }
 
         /// <summary>
-        /// Make map of featureVariable which are associated with given feature experiment 
+        /// Make map of featureVariable which are associated with given feature experiment
         /// </summary>
         /// <param name="variableIdMap">Map containing variable ID as key and Object of featureVariable</param>
         /// <param name="featureId">feature Id of featureExperiment</param>
@@ -197,7 +196,7 @@ private IDictionary<string, OptimizelyVariable> MergeFeatureVariables(
            bool isFeatureEnabled)
         {
             var variablesMap = new Dictionary<string, OptimizelyVariable>();
-            
+
             if (!string.IsNullOrEmpty(featureId))
             {
                 variablesMap = featureIdVariablesMap[featureId]?.Select(f => new OptimizelyVariable(f.Id,
@@ -231,9 +230,8 @@ private IDictionary<string, OptimizelyFeature> GetFeaturesMap(ProjectConfig proj
         {
             var FeaturesMap = new Dictionary<string, OptimizelyFeature>();
 
-            foreach (var featureFlag in projectConfig.FeatureFlags)   
+            foreach (var featureFlag in projectConfig.FeatureFlags)
             {
-
                 var experimentRules = featureFlag.ExperimentIds.Select(experimentId => experimentsMapById[experimentId]).ToList();
 
                 var featureVariableMap = featureFlag.Variables.Select(v => (OptimizelyVariable)v).ToDictionary(k => k.Key, v => v) ?? new Dictionary<string, OptimizelyVariable>();
@@ -255,7 +253,6 @@ private IDictionary<string, OptimizelyFeature> GetFeaturesMap(ProjectConfig proj
             return FeaturesMap;
         }
 
-
         #region Helper Methods for creating id value maps
 
         /// <summary>
@@ -286,7 +283,7 @@ private string GetExperimentAudiences(Experiment experiment, ProjectConfig proje
             return GetSerializedAudiences(s, projectConfig.AudienceIdMap);
         }
 
-        readonly string[] AUDIENCE_CONDITIONS = { "and", "or", "not" };
+        private readonly string[] AUDIENCE_CONDITIONS = { "and", "or", "not" };
 
         /// <summary>
         /// Converts list of audience conditions to serialized audiences used in experiment
@@ -403,12 +400,11 @@ private IDictionary<string, FeatureVariable> GetVariableIdMap(ProjectConfig proj
             return featureVariablesIdMap ?? new Dictionary<string, FeatureVariable>();
         }
 
-        #endregion
+        #endregion Helper Methods for creating id value maps
 
         public OptimizelyConfig GetOptimizelyConfig()
         {
             return OptimizelyConfig;
         }
-
     }
-}
+}
\ No newline at end of file

From 965c6bfeb6e4097e70e18f4e5cb0af5eb9ef85e6 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Fri, 15 Oct 2021 11:01:39 -0400
Subject: [PATCH 024/130] removed commented out code

---
 OptimizelySDK.Tests/DecisionServiceTest.cs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/OptimizelySDK.Tests/DecisionServiceTest.cs b/OptimizelySDK.Tests/DecisionServiceTest.cs
index 42e08737..cdcd8807 100644
--- a/OptimizelySDK.Tests/DecisionServiceTest.cs
+++ b/OptimizelySDK.Tests/DecisionServiceTest.cs
@@ -402,7 +402,6 @@ public void TestGetVariationUserWithSetForcedVariation()
             // confirm normal bucketing occurs before setting the forced variation
             var actualVariation = optlyObject.GetVariation(experimentKey, userId, userAttributes);
             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));

From 63e86b79570ba24fa89c8afdaf8c4d7d2ebc40a2 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Fri, 15 Oct 2021 12:01:21 -0400
Subject: [PATCH 025/130] added new lines to end of file

---
 OptimizelySDK.Tests/Assertions.cs             |   2 +-
 OptimizelySDK.Tests/DecisionServiceTest.cs    |  13 +-
 .../OptimizelyConfigTest.cs                   |   2 +-
 OptimizelySDK.Tests/OptimizelyTest.cs         |   2 +-
 .../OptimizelyUserContextTest.cs              |   2 +-
 OptimizelySDK.Tests/ProjectConfigTest.cs      | 192 ++++++-------
 OptimizelySDK/Bucketing/DecisionService.cs    |   2 +-
 OptimizelySDK/Config/DatafileProjectConfig.cs |  52 ++--
 OptimizelySDK/Entity/Variation.cs             |   6 +-
 OptimizelySDK/IOptimizely.cs                  | 263 +++++++++---------
 OptimizelySDK/Optimizely.cs                   |   2 +-
 OptimizelySDK/OptimizelyUserContext.cs        |   2 +-
 OptimizelySDK/OptlyConfig/OptimizelyConfig.cs |   2 +-
 .../OptlyConfig/OptimizelyConfigService.cs    |   2 +-
 OptimizelySDK/ProjectConfig.cs                |  17 +-
 15 files changed, 279 insertions(+), 282 deletions(-)

diff --git a/OptimizelySDK.Tests/Assertions.cs b/OptimizelySDK.Tests/Assertions.cs
index 9e09a6dc..eab0cbe4 100644
--- a/OptimizelySDK.Tests/Assertions.cs
+++ b/OptimizelySDK.Tests/Assertions.cs
@@ -600,4 +600,4 @@ public static void AreEqual(TrafficAllocation expected, TrafficAllocation actual
 
         #endregion TrafficAllocation
     }
-}
\ No newline at end of file
+}
diff --git a/OptimizelySDK.Tests/DecisionServiceTest.cs b/OptimizelySDK.Tests/DecisionServiceTest.cs
index cdcd8807..6c2ba204 100644
--- a/OptimizelySDK.Tests/DecisionServiceTest.cs
+++ b/OptimizelySDK.Tests/DecisionServiceTest.cs
@@ -15,17 +15,16 @@
  *    limitations under the License.
  */
 
-using System;
-using System.Collections.Generic;
 using Moq;
-using OptimizelySDK.Logger;
-using OptimizelySDK.ErrorHandler;
-using OptimizelySDK.Entity;
 using NUnit.Framework;
 using OptimizelySDK.Bucketing;
-using OptimizelySDK.Utils;
 using OptimizelySDK.Config;
+using OptimizelySDK.Entity;
+using OptimizelySDK.ErrorHandler;
+using OptimizelySDK.Logger;
 using OptimizelySDK.OptimizelyDecisions;
+using OptimizelySDK.Utils;
+using System.Collections.Generic;
 
 namespace OptimizelySDK.Tests
 {
@@ -1104,4 +1103,4 @@ public void TestSetForcedVariationMultipleSets()
 
         #endregion Forced variation Tests
     }
-}
\ No newline at end of file
+}
diff --git a/OptimizelySDK.Tests/OptimizelyConfigTests/OptimizelyConfigTest.cs b/OptimizelySDK.Tests/OptimizelyConfigTests/OptimizelyConfigTest.cs
index a64b90dc..db1d634c 100644
--- a/OptimizelySDK.Tests/OptimizelyConfigTests/OptimizelyConfigTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyConfigTests/OptimizelyConfigTest.cs
@@ -788,4 +788,4 @@ public void TestOptimizelyVariableEntity()
 
         #endregion OptimizelyConfig entity tests
     }
-}
\ No newline at end of file
+}
diff --git a/OptimizelySDK.Tests/OptimizelyTest.cs b/OptimizelySDK.Tests/OptimizelyTest.cs
index a8928172..3aa9cbd8 100644
--- a/OptimizelySDK.Tests/OptimizelyTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyTest.cs
@@ -4192,4 +4192,4 @@ public static void SetCulture(string culture)
 
         #endregion Test Culture
     }
-}
\ No newline at end of file
+}
diff --git a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
index 2f725b8e..3f6a9305 100644
--- a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
@@ -922,4 +922,4 @@ public void TrackEventEmptyAttributesWithEventTags()
 
         #endregion TrackEvent
     }
-}
\ No newline at end of file
+}
diff --git a/OptimizelySDK.Tests/ProjectConfigTest.cs b/OptimizelySDK.Tests/ProjectConfigTest.cs
index f4a98aa2..31819bd1 100644
--- a/OptimizelySDK.Tests/ProjectConfigTest.cs
+++ b/OptimizelySDK.Tests/ProjectConfigTest.cs
@@ -93,7 +93,7 @@ public void TestInit()
                 {"etag3",Config.GetExperimentFromKey("etag3") },
                 {"etag4",Config.GetExperimentFromKey("etag4") }
             };
-            
+
             Assert.IsTrue(TestData.CompareObjects(experimentKeyMap, Config.ExperimentKeyMap));
 
             // Check Experiment ID Map
@@ -438,103 +438,103 @@ public void TestFlagVariations()
                     Key = "177771",
                     FeatureVariableUsageInstances = new List<FeatureVariableUsage> { new FeatureVariableUsage { Id = "155556", Value="true" } }
                 },
-                new Variation 
-                { 
-                    FeatureEnabled = true, 
-                    Id = "177773", 
-                    Key = "177773", 
-                    FeatureVariableUsageInstances = new List<FeatureVariableUsage> 
-                    { 
-                        new FeatureVariableUsage 
-                        { 
-                            Id = "155556", 
-                            Value="false" 
-                        } 
-                    } 
-                },
-                new Variation 
-                { 
-                    FeatureEnabled = true, 
-                    Id = "177778", 
-                    Key = "177778", 
-                    FeatureVariableUsageInstances = new List<FeatureVariableUsage> 
-                    { 
-                        new FeatureVariableUsage 
-                        { 
-                            Id = "155556", Value="false" 
-                        } 
-                    } 
-                },
-                new Variation 
-                { 
-                    FeatureEnabled = false, 
-                    Id = "177782", 
-                    Key = "177782", 
-                    FeatureVariableUsageInstances = new List<FeatureVariableUsage> 
-                    { 
-                        new FeatureVariableUsage 
-                        { 
-                            Id = "155556", 
-                            Value="false" 
-                        } 
-                    } 
-                },
-                new Variation 
-                { 
-                    FeatureEnabled = false, 
-                    Id = "188881", 
-                    Key = "188881", 
-                    FeatureVariableUsageInstances = new List<FeatureVariableUsage> 
-                    { 
-                        new FeatureVariableUsage 
-                        { 
-                            Id = "155556", 
-                            Value= "false" 
-                        } 
-                    } 
-                },
-                new Variation 
-                { 
-                    FeatureEnabled = true, 
+                new Variation
+                {
+                    FeatureEnabled = true,
+                    Id = "177773",
+                    Key = "177773",
+                    FeatureVariableUsageInstances = new List<FeatureVariableUsage>
+                    {
+                        new FeatureVariableUsage
+                        {
+                            Id = "155556",
+                            Value="false"
+                        }
+                    }
+                },
+                new Variation
+                {
+                    FeatureEnabled = true,
+                    Id = "177778",
+                    Key = "177778",
+                    FeatureVariableUsageInstances = new List<FeatureVariableUsage>
+                    {
+                        new FeatureVariableUsage
+                        {
+                            Id = "155556", Value="false"
+                        }
+                    }
+                },
+                new Variation
+                {
+                    FeatureEnabled = false,
+                    Id = "177782",
+                    Key = "177782",
+                    FeatureVariableUsageInstances = new List<FeatureVariableUsage>
+                    {
+                        new FeatureVariableUsage
+                        {
+                            Id = "155556",
+                            Value="false"
+                        }
+                    }
+                },
+                new Variation
+                {
+                    FeatureEnabled = false,
+                    Id = "188881",
+                    Key = "188881",
+                    FeatureVariableUsageInstances = new List<FeatureVariableUsage>
+                    {
+                        new FeatureVariableUsage
+                        {
+                            Id = "155556",
+                            Value= "false"
+                        }
+                    }
+                },
+                new Variation
+                {
+                    FeatureEnabled = true,
                     Id = "177775",
-                    Key = "177775", 
-                    FeatureVariableUsageInstances = new List<FeatureVariableUsage> 
-                    { 
-                        new FeatureVariableUsage 
-                        { 
-                            Id = "155558", 
-                            Value= "cta_4" 
-                        }, 
-                        new FeatureVariableUsage 
-                        { 
-                            Id = "17014990011", 
-                            Value = "{\"int_var\": 4 , \"string_var\": \"cta_4\"}" 
-                        }, 
-                        new FeatureVariableUsage 
-                        { 
-                            Id = "170149900112", 
-                            Value = "{\"int_var\": 5 , \"string_var\": \"cta_5\"}" 
+                    Key = "177775",
+                    FeatureVariableUsageInstances = new List<FeatureVariableUsage>
+                    {
+                        new FeatureVariableUsage
+                        {
+                            Id = "155558",
+                            Value= "cta_4"
+                        },
+                        new FeatureVariableUsage
+                        {
+                            Id = "17014990011",
+                            Value = "{\"int_var\": 4 , \"string_var\": \"cta_4\"}"
+                        },
+                        new FeatureVariableUsage
+                        {
+                            Id = "170149900112",
+                            Value = "{\"int_var\": 5 , \"string_var\": \"cta_5\"}"
                         } } },
-                new Variation 
-                { 
-                    FeatureEnabled = true, 
-                    Id = "177780", 
-                    Key = "177780", 
-                    FeatureVariableUsageInstances = new List<FeatureVariableUsage> { } 
-                },
-                new Variation 
-                { 
-                    FeatureEnabled = false, 
-                    Id = "177784", 
-                    Key = "177784", 
-                    FeatureVariableUsageInstances = new List<FeatureVariableUsage> 
-                    { 
-                        new FeatureVariableUsage 
-                        { 
+                new Variation
+                {
+                    FeatureEnabled = true,
+                    Id = "177780",
+                    Key = "177780",
+                    FeatureVariableUsageInstances = new List<FeatureVariableUsage> { }
+                },
+                new Variation
+                {
+                    FeatureEnabled = false,
+                    Id = "177784",
+                    Key = "177784",
+                    FeatureVariableUsageInstances = new List<FeatureVariableUsage>
+                    {
+                        new FeatureVariableUsage
+                        {
                             Id = "155558",
-                            Value= "cta_5" 
-                        } 
-                    } 
+                            Value= "cta_5"
+                        }
+                    }
                 }
             };
             expectedVariations1.Add(new Dictionary<string, List<Variation>> { { "boolean_feature", expectedVariationList } });
@@ -901,4 +901,4 @@ public void TestIsFeatureExperimentReturnsTrueForExperimentThatBelongsToAFeature
             Assert.True(typedConfig.IsFeatureExperiment(experiment.Id));
         }
     }
-}
\ No newline at end of file
+}
diff --git a/OptimizelySDK/Bucketing/DecisionService.cs b/OptimizelySDK/Bucketing/DecisionService.cs
index 001d0270..dc60a5aa 100644
--- a/OptimizelySDK/Bucketing/DecisionService.cs
+++ b/OptimizelySDK/Bucketing/DecisionService.cs
@@ -628,4 +628,4 @@ private Result<string> GetBucketingId(string userId, UserAttributes filteredAttr
             return Result<string>.NewResult(bucketingId, reasons);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/OptimizelySDK/Config/DatafileProjectConfig.cs b/OptimizelySDK/Config/DatafileProjectConfig.cs
index cd9251d6..a739437c 100644
--- a/OptimizelySDK/Config/DatafileProjectConfig.cs
+++ b/OptimizelySDK/Config/DatafileProjectConfig.cs
@@ -1,4 +1,4 @@
-/* 
+/*
  * Copyright 2019-2021, Optimizely
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 using Newtonsoft.Json;
 using OptimizelySDK.Entity;
 using OptimizelySDK.ErrorHandler;
@@ -52,19 +53,16 @@ public enum OPTLYSDKVersion
         /// </summary>
         public string Version { get; set; }
 
-
         /// <summary>
         /// Account ID of the account using the SDK.
         /// </summary>
         public string AccountId { get; set; }
 
-
         /// <summary>
         /// Project ID of the Full Stack project.
         /// </summary>
         public string ProjectId { get; set; }
 
-
         /// <summary>
         /// Revision of the datafile.
         /// </summary>
@@ -84,7 +82,7 @@ public enum OPTLYSDKVersion
         /// SendFlagDecisions determines whether impressions events are sent for ALL decision types.
         /// </summary>
         public bool SendFlagDecisions { get; set; }
-        
+
         /// <summary>
         /// Allow Anonymize IP by truncating the last block of visitors' IP address.
         /// </summary>
@@ -109,24 +107,28 @@ public enum OPTLYSDKVersion
             OPTLYSDKVersion.V4
         };
 
-
         //========================= Mappings ===========================
 
         /// <summary>
         /// Associative array of group ID to Group(s) in the datafile
         /// </summary>
         private Dictionary<string, Group> _GroupIdMap;
+
         public Dictionary<string, Group> GroupIdMap { get { return _GroupIdMap; } }
+
         /// <summary>
         /// Associative array of experiment key to Experiment(s) in the datafile
         /// </summary>
         private Dictionary<string, Experiment> _ExperimentKeyMap;
+
         public Dictionary<string, Experiment> ExperimentKeyMap { get { return _ExperimentKeyMap; } }
+
         /// <summary>
         /// Associative array of experiment ID to Experiment(s) in the datafile
         /// </summary>
         private Dictionary<string, Experiment> _ExperimentIdMap
             = new Dictionary<string, Experiment>();
+
         public Dictionary<string, Experiment> ExperimentIdMap { get { return _ExperimentIdMap; } }
 
         /// <summary>
@@ -134,6 +136,7 @@ private Dictionary<string, Experiment> _ExperimentIdMap
         /// </summary>
         private Dictionary<string, Dictionary<string, Variation>> _VariationKeyMap
             = new Dictionary<string, Dictionary<string, Variation>>();
+
         public Dictionary<string, Dictionary<string, Variation>> VariationKeyMap { get { return _VariationKeyMap; } }
 
         /// <summary>
@@ -141,6 +144,7 @@ private Dictionary<string, Dictionary<string, Variation>> _VariationKeyMap
         /// </summary>
         private Dictionary<string, Dictionary<string, Variation>> _VariationKeyMapByExperimentId
             = new Dictionary<string, Dictionary<string, Variation>>();
+
         public Dictionary<string, Dictionary<string, Variation>> VariationKeyMapByExperimentId { get { return _VariationKeyMapByExperimentId; } }
 
         /// <summary>
@@ -148,45 +152,50 @@ private Dictionary<string, Dictionary<string, Variation>> _VariationKeyMapByExpe
         /// </summary>
         private Dictionary<string, Dictionary<string, Variation>> _VariationIdMapByExperimentId
             = new Dictionary<string, Dictionary<string, Variation>>();
-        public Dictionary<string, Dictionary<string, Variation>> VariationKeyIdByExperimentId { get { return _VariationIdMapByExperimentId; } }
 
+        public Dictionary<string, Dictionary<string, Variation>> VariationKeyIdByExperimentId { get { return _VariationIdMapByExperimentId; } }
 
         /// <summary>
         /// Associative array of experiment key to associative array of variation ID to variations
         /// </summary>
         private Dictionary<string, Dictionary<string, Variation>> _VariationIdMap
             = new Dictionary<string, Dictionary<string, Variation>>();
+
         public Dictionary<string, Dictionary<string, Variation>> VariationIdMap { get { return _VariationIdMap; } }
 
         /// <summary>
         /// Associative array of event key to Event(s) in the datafile
         /// </summary>
         private Dictionary<string, Entity.Event> _EventKeyMap;
+
         public Dictionary<string, Entity.Event> EventKeyMap { get { return _EventKeyMap; } }
 
         /// <summary>
         /// Associative array of attribute key to Attribute(s) in the datafile
         /// </summary>
         private Dictionary<string, Attribute> _AttributeKeyMap;
+
         public Dictionary<string, Attribute> AttributeKeyMap { get { return _AttributeKeyMap; } }
 
         /// <summary>
         /// Associative array of audience ID to Audience(s) in the datafile
         /// </summary>
         private Dictionary<string, Audience> _AudienceIdMap;
-        public Dictionary<string, Audience> AudienceIdMap { get { return _AudienceIdMap; } }
 
+        public Dictionary<string, Audience> AudienceIdMap { get { return _AudienceIdMap; } }
 
         /// <summary>
         /// Associative array of Feature Key to Feature(s) in the datafile
         /// </summary>
         private Dictionary<string, FeatureFlag> _FeatureKeyMap;
+
         public Dictionary<string, FeatureFlag> FeatureKeyMap { get { return _FeatureKeyMap; } }
 
         /// <summary>
         /// Associative array of Rollout ID to Rollout(s) in the datafile
         /// </summary>
         private Dictionary<string, Rollout> _RolloutIdMap;
+
         public Dictionary<string, Rollout> RolloutIdMap { get { return _RolloutIdMap; } }
 
         /// <summary>
@@ -198,9 +207,9 @@ private Dictionary<string, Dictionary<string, Variation>> _VariationIdMap
         /// <summary>
         /// Associated array of flags to experiments
         /// </summary>
-        
+
         private Dictionary<string, List<Variation>> _FlagVariationMap = new Dictionary<string, List<Variation>>();
-        public Dictionary<string, List<Variation>> FlagVariationMap { get { return _FlagVariationMap;  } }
+        public Dictionary<string, List<Variation>> FlagVariationMap { get { return _FlagVariationMap; } }
 
         //========================= Interfaces ===========================
 
@@ -214,7 +223,6 @@ private Dictionary<string, Dictionary<string, Variation>> _VariationIdMap
         /// </summary>
         public IErrorHandler ErrorHandler { get; set; }
 
-
         //========================= Datafile Entities ===========================
 
         /// <summary>
@@ -227,7 +235,6 @@ private Dictionary<string, Dictionary<string, Variation>> _VariationIdMap
         /// </summary>
         public Experiment[] Experiments { get; set; }
 
-
         /// <summary>
         /// Associative list of events.
         /// </summary>
@@ -260,7 +267,6 @@ private Dictionary<string, Dictionary<string, Variation>> _VariationIdMap
 
         //========================= Initialization ===========================
 
-
         /// <summary>
         /// Initialize the arrays and mappings
         /// This can't be done in the constructor because the object is created via serialization
@@ -285,7 +291,6 @@ private void Initialize()
             _FeatureKeyMap = ConfigParser<FeatureFlag>.GenerateMap(entities: FeatureFlags, getKey: f => f.Key, clone: true);
             _RolloutIdMap = ConfigParser<Rollout>.GenerateMap(entities: Rollouts, getKey: r => r.Id.ToString(), clone: true);
             _FlagVariationMap = GetFlagVariationMap();
-            
 
             // Overwrite similar items in audience id map with typed audience id map.
             var typedAudienceIdMap = ConfigParser<Audience>.GenerateMap(entities: TypedAudiences, getKey: a => a.Id.ToString(), clone: true);
@@ -315,7 +320,7 @@ private void Initialize()
                 _VariationKeyMapByExperimentId[experiment.Id] = new Dictionary<string, Variation>();
 
                 _ExperimentKeyMap[experiment.Key] = experiment;
-                
+
                 if (experiment.Variations != null)
                 {
                     foreach (Variation variation in experiment.Variations)
@@ -376,11 +381,11 @@ private Dictionary<string, List<Variation>> GetFlagVariationMap()
 
                 var rules = rollout?.Experiments ?? emptyArray;
 
-                foreach(var rule in rules)
+                foreach (var rule in rules)
                 {
-                    foreach(var variation in rule.Variations)
+                    foreach (var variation in rule.Variations)
                     {
-                        if(!variations.Contains(variation))
+                        if (!variations.Contains(variation))
                         {
                             variations.Add(variation);
                         }
@@ -392,7 +397,6 @@ private Dictionary<string, List<Variation>> GetFlagVariationMap()
             return map;
         }
 
-
         /// <summary>
         /// Parse datafile string to create ProjectConfig instance.
         /// </summary>
@@ -532,7 +536,7 @@ public Attribute GetAttribute(string attributeKey)
         /// </summary>
         /// <param name="experimentKey">key for Experiment</param>
         /// <param name="variationKey">key for Variation</param>
-        /// <returns>Variation Entity corresponding to the provided experiment key and variation key or a dummy 
+        /// <returns>Variation Entity corresponding to the provided experiment key and variation key or a dummy
         /// entity if keys are invalid</returns>
         public Variation GetVariationFromKey(string experimentKey, string variationKey)
         {
@@ -546,13 +550,12 @@ public Variation GetVariationFromKey(string experimentKey, string variationKey)
             return new Variation();
         }
 
-
         /// <summary>
         /// Get the Variation from the keys
         /// </summary>
         /// <param name="experimentId">Id for Experiment</param>
         /// <param name="variationKey">key for Variation</param>
-        /// <returns>Variation Entity corresponding to the provided experiment key and variation key or a dummy 
+        /// <returns>Variation Entity corresponding to the provided experiment key and variation key or a dummy
         /// entity if keys are invalid</returns>
         public Variation GetVariationFromKeyByExperimentId(string experimentId, string variationKey)
         {
@@ -571,7 +574,7 @@ public Variation GetVariationFromKeyByExperimentId(string experimentId, string v
         /// </summary>
         /// <param name="experimentKey">key for Experiment</param>
         /// <param name="variationId">ID for Variation</param>
-        /// <returns>Variation Entity corresponding to the provided experiment key and variation ID or a dummy 
+        /// <returns>Variation Entity corresponding to the provided experiment key and variation ID or a dummy
         /// entity if key or ID is invalid</returns>
         public Variation GetVariationFromId(string experimentKey, string variationId)
         {
@@ -590,7 +593,7 @@ public Variation GetVariationFromId(string experimentKey, string variationId)
         /// </summary>
         /// <param name="experimentId">ID for Experiment</param>
         /// <param name="variationId">ID for Variation</param>
-        /// <returns>Variation Entity corresponding to the provided experiment key and variation ID or a dummy 
+        /// <returns>Variation Entity corresponding to the provided experiment key and variation ID or a dummy
         /// entity if experiment ID or variation ID is invalid</returns>
         public Variation GetVariationFromIdByExperimentId(string experimentId, string variationId)
         {
@@ -643,7 +646,6 @@ public Rollout GetRolloutFromId(string rolloutId)
         /// <returns>Attribute ID corresponding to the provided attribute key. Attribute key if it is a reserved attribute</returns>
         public string GetAttributeId(string attributeKey)
         {
-
             var hasReservedPrefix = attributeKey.StartsWith(RESERVED_ATTRIBUTE_PREFIX);
 
             if (_AttributeKeyMap.ContainsKey(attributeKey))
diff --git a/OptimizelySDK/Entity/Variation.cs b/OptimizelySDK/Entity/Variation.cs
index 4d4bf647..2083794e 100644
--- a/OptimizelySDK/Entity/Variation.cs
+++ b/OptimizelySDK/Entity/Variation.cs
@@ -1,4 +1,4 @@
-/* 
+/*
  * Copyright 2017, Optimizely
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 using OptimizelySDK.Utils;
 using System.Collections.Generic;
 
@@ -21,6 +22,7 @@ namespace OptimizelySDK.Entity
     public class Variation : IdKeyEntity
     {
         private List<FeatureVariableUsage> _FeatureVariableUsageInstances;
+
         [Newtonsoft.Json.JsonProperty("variables")]
         public List<FeatureVariableUsage> FeatureVariableUsageInstances
         {
@@ -35,7 +37,6 @@ 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);
-                
             }
         }
 
@@ -52,6 +53,7 @@ public FeatureVariableUsage GetFeatureVariableUsageFromId(string variableId)
         }
 
         public bool? FeatureEnabled { get; set; }
+
         public bool IsFeatureEnabled
         {
             get
diff --git a/OptimizelySDK/IOptimizely.cs b/OptimizelySDK/IOptimizely.cs
index d5ca6ca7..46edda13 100644
--- a/OptimizelySDK/IOptimizely.cs
+++ b/OptimizelySDK/IOptimizely.cs
@@ -13,140 +13,141 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 using OptimizelySDK.Entity;
 using System.Collections.Generic;
 
 namespace OptimizelySDK
 {
-	public interface IOptimizely
-	{
-		/// <summary>
-		/// Returns true if the IOptimizely instance was initialized with a valid datafile
-		/// </summary>
-		bool IsValid { get; }
-
-		/// <summary>
-		/// Buckets visitor and sends impression event to Optimizely.
-		/// </summary>
-		/// <param name="experimentKey">experimentKey string Key identifying the experiment</param>
-		/// <param name="userId">string ID for user</param>
-		/// <param name="userAttributes">associative array of Attributes for the user</param>
-		/// <returns>null|Variation Representing variation</returns>
-		Variation Activate(string experimentKey, string userId, UserAttributes userAttributes = null);
-
-		/// <summary>
-		/// Create a context of the user for which decision APIs will be called.
-		/// A user context will be created successfully even when the SDK is not fully configured yet.
-		/// </summary>
-		/// <param name="userId">The user ID to be used for bucketing.</param>
-		/// <param name="userAttributes">The user's attributes</param>
-		/// <returns>OptimizelyUserContext | An OptimizelyUserContext associated with this OptimizelyClient.</returns>
-		OptimizelyUserContext CreateUserContext(string userId, UserAttributes userAttributes = null);
-
-		/// <summary>
-		/// Sends conversion event to Optimizely.
-		/// </summary>
-		/// <param name="eventKey">Event key representing the event which needs to be recorded</param>
-		/// <param name="userId">ID for user</param>
-		/// <param name="userAttributes">Attributes of the user</param>
-		/// <param name="eventTags">eventTags array Hash representing metadata associated with the event.</param>
-		void Track(string eventKey, string userId, UserAttributes userAttributes = null, EventTags eventTags = null);
-
-		/// <summary>
-		/// Get variation where user will be bucketed
-		/// </summary>
-		/// <param name="experimentKey">experimentKey string Key identifying the experiment</param>
-		/// <param name="userId">ID for the user</param>
-		/// <param name="userAttributes">Attributes for the users</param>
-		/// <returns>null|Variation Representing variation</returns>
-		Variation GetVariation(string experimentKey, string userId, UserAttributes userAttributes = null);
-
-		/// <summary>
-		/// Force a user into a variation for a given experiment.
-		/// </summary>
-		/// <param name="experimentKey">The experiment key</param>
-		/// <param name="userId">The user ID</param>
-		/// <param name="variationKey">The variation key specifies the variation which the user will be forced into.
-		/// If null, then clear the existing experiment-to-variation mapping.</param>
-		/// <returns>A boolean value that indicates if the set completed successfully.</returns>
-		bool SetForcedVariation(string experimentKey, string userId, string variationKey);
-
-		/// <summary>
-		/// Gets the forced variation key for the given user and experiment.  
-		/// </summary>
-		/// <param name="experimentKey">The experiment key</param>
-		/// <param name="userId">The user ID</param>
-		/// <returns>null|string The variation key.</returns>
-		Variation GetForcedVariation(string experimentKey, string userId);
-
-		#region  FeatureFlag APIs
-
-		/// <summary>
-		/// Determine whether a feature is enabled.
-		/// Send an impression event if the user is bucketed into an experiment using the feature.
-		/// </summary>
-		/// <param name="featureKey">The feature key</param>
-		/// <param name="userId">The user ID</param>
-		/// <param name="userAttributes">The user's attributes.</param>
-		/// <returns>True if feature is enabled, false or null otherwise</returns>
-		bool IsFeatureEnabled(string featureKey, string userId, UserAttributes userAttributes = null);
-
-		/// <summary>
-		/// Gets boolean feature variable value.
-		/// </summary>
-		/// <param name="featureKey">The feature flag key</param>
-		/// <param name="variableKey">The variable key</param>
-		/// <param name="userId">The user ID</param>
-		/// <param name="userAttributes">The user's attributes</param>
-		/// <returns>bool | Feature variable value or null</returns>
-		bool? GetFeatureVariableBoolean(string featureKey, string variableKey, string userId, UserAttributes userAttributes = null);
-
-		/// <summary>
-		/// Gets double feature variable value.
-		/// </summary>
-		/// <param name="featureKey">The feature flag key</param>
-		/// <param name="variableKey">The variable key</param>
-		/// <param name="userId">The user ID</param>
-		/// <param name="userAttributes">The user's attributes</param>
-		/// <returns>double | Feature variable value or null</returns>
-		double? GetFeatureVariableDouble(string featureKey, string variableKey, string userId, UserAttributes userAttributes = null);
-
-		/// <summary>
-		/// Gets integer feature variable value.
-		/// </summary>
-		/// <param name="featureKey">The feature flag key</param>
-		/// <param name="variableKey">The variable key</param>
-		/// <param name="userId">The user ID</param>
-		/// <param name="userAttributes">The user's attributes</param>
-		/// <returns>int | Feature variable value or null</returns>
-		int? GetFeatureVariableInteger(string featureKey, string variableKey, string userId, UserAttributes userAttributes = null);
-
-		/// <summary>
-		/// Gets string feature variable value.
-		/// </summary>
-		/// <param name="featureKey">The feature flag key</param>
-		/// <param name="variableKey">The variable key</param>
-		/// <param name="userId">The user ID</param>
-		/// <param name="userAttributes">The user's attributes</param>
-		/// <returns>string | Feature variable value or null</returns>
-		string GetFeatureVariableString(string featureKey, string variableKey, string userId, UserAttributes userAttributes = null);
-
-		/// <summary>
-		/// Get the list of features that are enabled for the user.
-		/// </summary>
-		/// <param name="userId">The user Id</param>
-		/// <param name="userAttributes">The user's attributes</param>
-		/// <returns>List of the feature keys that are enabled for the user.</returns>
-		List<string> GetEnabledFeatures(string userId, UserAttributes userAttributes = null);
-
-		/// <summary>
-		/// Get the variation by flag key
-		/// </summary>
-		/// <param name="flagKey">The flag key</param>
-		/// <param name="variationKey">The variation key</param>
-		/// <returns></returns>
-		Variation GetFlagVariationByKey(string flagKey, string variationKey);
-
-		#endregion
-	}
+    public interface IOptimizely
+    {
+        /// <summary>
+        /// Returns true if the IOptimizely instance was initialized with a valid datafile
+        /// </summary>
+        bool IsValid { get; }
+
+        /// <summary>
+        /// Buckets visitor and sends impression event to Optimizely.
+        /// </summary>
+        /// <param name="experimentKey">experimentKey string Key identifying the experiment</param>
+        /// <param name="userId">string ID for user</param>
+        /// <param name="userAttributes">associative array of Attributes for the user</param>
+        /// <returns>null|Variation Representing variation</returns>
+        Variation Activate(string experimentKey, string userId, UserAttributes userAttributes = null);
+
+        /// <summary>
+        /// Create a context of the user for which decision APIs will be called.
+        /// A user context will be created successfully even when the SDK is not fully configured yet.
+        /// </summary>
+        /// <param name="userId">The user ID to be used for bucketing.</param>
+        /// <param name="userAttributes">The user's attributes</param>
+        /// <returns>OptimizelyUserContext | An OptimizelyUserContext associated with this OptimizelyClient.</returns>
+        OptimizelyUserContext CreateUserContext(string userId, UserAttributes userAttributes = null);
+
+        /// <summary>
+        /// Sends conversion event to Optimizely.
+        /// </summary>
+        /// <param name="eventKey">Event key representing the event which needs to be recorded</param>
+        /// <param name="userId">ID for user</param>
+        /// <param name="userAttributes">Attributes of the user</param>
+        /// <param name="eventTags">eventTags array Hash representing metadata associated with the event.</param>
+        void Track(string eventKey, string userId, UserAttributes userAttributes = null, EventTags eventTags = null);
+
+        /// <summary>
+        /// Get variation where user will be bucketed
+        /// </summary>
+        /// <param name="experimentKey">experimentKey string Key identifying the experiment</param>
+        /// <param name="userId">ID for the user</param>
+        /// <param name="userAttributes">Attributes for the users</param>
+        /// <returns>null|Variation Representing variation</returns>
+        Variation GetVariation(string experimentKey, string userId, UserAttributes userAttributes = null);
+
+        /// <summary>
+        /// Force a user into a variation for a given experiment.
+        /// </summary>
+        /// <param name="experimentKey">The experiment key</param>
+        /// <param name="userId">The user ID</param>
+        /// <param name="variationKey">The variation key specifies the variation which the user will be forced into.
+        /// If null, then clear the existing experiment-to-variation mapping.</param>
+        /// <returns>A boolean value that indicates if the set completed successfully.</returns>
+        bool SetForcedVariation(string experimentKey, string userId, string variationKey);
+
+        /// <summary>
+        /// Gets the forced variation key for the given user and experiment.
+        /// </summary>
+        /// <param name="experimentKey">The experiment key</param>
+        /// <param name="userId">The user ID</param>
+        /// <returns>null|string The variation key.</returns>
+        Variation GetForcedVariation(string experimentKey, string userId);
+
+        #region FeatureFlag APIs
+
+        /// <summary>
+        /// Determine whether a feature is enabled.
+        /// Send an impression event if the user is bucketed into an experiment using the feature.
+        /// </summary>
+        /// <param name="featureKey">The feature key</param>
+        /// <param name="userId">The user ID</param>
+        /// <param name="userAttributes">The user's attributes.</param>
+        /// <returns>True if feature is enabled, false or null otherwise</returns>
+        bool IsFeatureEnabled(string featureKey, string userId, UserAttributes userAttributes = null);
+
+        /// <summary>
+        /// Gets boolean feature variable value.
+        /// </summary>
+        /// <param name="featureKey">The feature flag key</param>
+        /// <param name="variableKey">The variable key</param>
+        /// <param name="userId">The user ID</param>
+        /// <param name="userAttributes">The user's attributes</param>
+        /// <returns>bool | Feature variable value or null</returns>
+        bool? GetFeatureVariableBoolean(string featureKey, string variableKey, string userId, UserAttributes userAttributes = null);
+
+        /// <summary>
+        /// Gets double feature variable value.
+        /// </summary>
+        /// <param name="featureKey">The feature flag key</param>
+        /// <param name="variableKey">The variable key</param>
+        /// <param name="userId">The user ID</param>
+        /// <param name="userAttributes">The user's attributes</param>
+        /// <returns>double | Feature variable value or null</returns>
+        double? GetFeatureVariableDouble(string featureKey, string variableKey, string userId, UserAttributes userAttributes = null);
+
+        /// <summary>
+        /// Gets integer feature variable value.
+        /// </summary>
+        /// <param name="featureKey">The feature flag key</param>
+        /// <param name="variableKey">The variable key</param>
+        /// <param name="userId">The user ID</param>
+        /// <param name="userAttributes">The user's attributes</param>
+        /// <returns>int | Feature variable value or null</returns>
+        int? GetFeatureVariableInteger(string featureKey, string variableKey, string userId, UserAttributes userAttributes = null);
+
+        /// <summary>
+        /// Gets string feature variable value.
+        /// </summary>
+        /// <param name="featureKey">The feature flag key</param>
+        /// <param name="variableKey">The variable key</param>
+        /// <param name="userId">The user ID</param>
+        /// <param name="userAttributes">The user's attributes</param>
+        /// <returns>string | Feature variable value or null</returns>
+        string GetFeatureVariableString(string featureKey, string variableKey, string userId, UserAttributes userAttributes = null);
+
+        /// <summary>
+        /// Get the list of features that are enabled for the user.
+        /// </summary>
+        /// <param name="userId">The user Id</param>
+        /// <param name="userAttributes">The user's attributes</param>
+        /// <returns>List of the feature keys that are enabled for the user.</returns>
+        List<string> GetEnabledFeatures(string userId, UserAttributes userAttributes = null);
+
+        /// <summary>
+        /// Get the variation by flag key
+        /// </summary>
+        /// <param name="flagKey">The flag key</param>
+        /// <param name="variationKey">The variation key</param>
+        /// <returns></returns>
+        Variation GetFlagVariationByKey(string flagKey, string variationKey);
+
+        #endregion FeatureFlag APIs
+    }
 }
diff --git a/OptimizelySDK/Optimizely.cs b/OptimizelySDK/Optimizely.cs
index 40c7c224..c425f8f7 100644
--- a/OptimizelySDK/Optimizely.cs
+++ b/OptimizelySDK/Optimizely.cs
@@ -1216,4 +1216,4 @@ public Variation GetFlagVariationByKey(string flagKey, string variationKey)
             return null;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index 1ab492bb..01c08f45 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -428,4 +428,4 @@ public Result<Variation> FindValidatedForcedDecision(string flagKey, string rule
             return Result<Variation>.NullResult(reasons);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/OptimizelySDK/OptlyConfig/OptimizelyConfig.cs b/OptimizelySDK/OptlyConfig/OptimizelyConfig.cs
index f16521ab..1981af03 100644
--- a/OptimizelySDK/OptlyConfig/OptimizelyConfig.cs
+++ b/OptimizelySDK/OptlyConfig/OptimizelyConfig.cs
@@ -72,4 +72,4 @@ public string GetDatafile()
             return _datafile;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/OptimizelySDK/OptlyConfig/OptimizelyConfigService.cs b/OptimizelySDK/OptlyConfig/OptimizelyConfigService.cs
index 21b49be7..1b837580 100644
--- a/OptimizelySDK/OptlyConfig/OptimizelyConfigService.cs
+++ b/OptimizelySDK/OptlyConfig/OptimizelyConfigService.cs
@@ -407,4 +407,4 @@ public OptimizelyConfig GetOptimizelyConfig()
             return OptimizelyConfig;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/OptimizelySDK/ProjectConfig.cs b/OptimizelySDK/ProjectConfig.cs
index 954797fd..f7d11f68 100644
--- a/OptimizelySDK/ProjectConfig.cs
+++ b/OptimizelySDK/ProjectConfig.cs
@@ -1,4 +1,4 @@
-/* 
+/*
  * Copyright 2019-2021, Optimizely
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -26,19 +26,16 @@ public interface ProjectConfig
         /// </summary>
         string Version { get; set; }
 
-
         /// <summary>
         /// Account ID of the account using the SDK.
         /// </summary>
         string AccountId { get; set; }
 
-
         /// <summary>
         /// Project ID of the Full Stack project.
         /// </summary>
         string ProjectId { get; set; }
 
-
         /// <summary>
         /// Revision of the datafile.
         /// </summary>
@@ -69,7 +66,6 @@ public interface ProjectConfig
         /// </summary>
         bool? BotFiltering { get; set; }
 
-
         //========================= Mappings ===========================
 
         /// <summary>
@@ -122,7 +118,6 @@ public interface ProjectConfig
         /// </summary>
         Dictionary<string, Rollout> RolloutIdMap { get; }
 
-
         /// <summary>
         /// Associative array of Flag to Variation in the datafile
         /// </summary>
@@ -140,7 +135,6 @@ public interface ProjectConfig
         /// </summary>
         Experiment[] Experiments { get; set; }
 
-
         /// <summary>
         /// Associative list of events.
         /// </summary>
@@ -220,7 +214,7 @@ public interface ProjectConfig
         /// </summary>
         /// <param name="experimentKey">key for Experiment</param>
         /// <param name="variationKey">key for Variation</param>
-        /// <returns>Variation Entity corresponding to the provided experiment key and variation key or a dummy 
+        /// <returns>Variation Entity corresponding to the provided experiment key and variation key or a dummy
         /// entity if keys are invalid</returns>
         Variation GetVariationFromKey(string experimentKey, string variationKey);
 
@@ -229,7 +223,7 @@ public interface ProjectConfig
         /// </summary>
         /// <param name="experimentId">ID for Experiment</param>
         /// <param name="variationKey">key for Variation</param>
-        /// <returns>Variation Entity corresponding to the provided experiment key and variation key or a dummy 
+        /// <returns>Variation Entity corresponding to the provided experiment key and variation key or a dummy
         /// entity if keys are invalid</returns>
         Variation GetVariationFromKeyByExperimentId(string experimentId, string variationKey);
 
@@ -238,7 +232,7 @@ public interface ProjectConfig
         /// </summary>
         /// <param name="experimentKey">key for Experiment</param>
         /// <param name="variationId">ID for Variation</param>
-        /// <returns>Variation Entity corresponding to the provided experiment key and variation ID or a dummy 
+        /// <returns>Variation Entity corresponding to the provided experiment key and variation ID or a dummy
         /// entity if key or ID is invalid</returns>
         Variation GetVariationFromId(string experimentKey, string variationId);
 
@@ -247,7 +241,7 @@ public interface ProjectConfig
         /// </summary>
         /// <param name="experimentId">ID for Experiment</param>
         /// <param name="variationId">ID for Variation</param>
-        /// <returns>Variation Entity corresponding to the provided experiment key and variation ID or a dummy 
+        /// <returns>Variation Entity corresponding to the provided experiment key and variation ID or a dummy
         /// entity if key or ID is invalid</returns>
         Variation GetVariationFromIdByExperimentId(string experimentId, string variationId);
 
@@ -290,6 +284,5 @@ public interface ProjectConfig
         /// Returns the datafile corresponding to ProjectConfig
         /// </summary>
         string ToDatafile();
-
     }
 }

From 44229f01a226da87b1907dd8b0a8c7153ba6e313 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Sun, 17 Oct 2021 10:50:03 -0400
Subject: [PATCH 026/130] updates from feedback

---
 OptimizelySDK/Config/DatafileProjectConfig.cs | 29 +++++++++++++++----
 1 file changed, 23 insertions(+), 6 deletions(-)

diff --git a/OptimizelySDK/Config/DatafileProjectConfig.cs b/OptimizelySDK/Config/DatafileProjectConfig.cs
index a739437c..20169296 100644
--- a/OptimizelySDK/Config/DatafileProjectConfig.cs
+++ b/OptimizelySDK/Config/DatafileProjectConfig.cs
@@ -373,15 +373,10 @@ private Dictionary<string, List<Variation>> GetFlagVariationMap()
         {
             var map = new Dictionary<string, List<Variation>>();
             var variations = new List<Variation>();
-            var emptyArray = new List<Experiment>();
 
             foreach (var flag in this.FeatureFlags)
             {
-                this.RolloutIdMap.TryGetValue(flag.RolloutId, out var rollout);
-
-                var rules = rollout?.Experiments ?? emptyArray;
-
-                foreach (var rule in rules)
+                foreach (var rule in GetAllRulesForFlag(flag))
                 {
                     foreach (var variation in rule.Variations)
                     {
@@ -397,6 +392,28 @@ private Dictionary<string, List<Variation>> GetFlagVariationMap()
             return map;
         }
 
+        private List<Experiment> GetAllRulesForFlag(FeatureFlag flag)
+        {
+            var rules = new List<Experiment>();
+
+            RolloutIdMap.TryGetValue(flag.RolloutId, out var rollout);
+
+            foreach (var expId in flag.ExperimentIds)
+            {
+                if (ExperimentIdMap.TryGetValue(expId, out var rule))
+                {
+                    rules.Add(rule);
+                }
+            }
+
+            if (rollout != null)
+            {
+                rules.AddRange(rollout.Experiments);
+            }
+
+            return rules;
+        }
+
         /// <summary>
         /// Parse datafile string to create ProjectConfig instance.
         /// </summary>

From 99c1769e5ebc6f18263e34e6ea4d4026ea66ccef Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Sun, 17 Oct 2021 11:11:43 -0400
Subject: [PATCH 027/130] Updates for tests, still failing/WIP

---
 OptimizelySDK.Tests/DecisionServiceTest.cs | 12 ++--
 OptimizelySDK.Tests/OptimizelyTest.cs      | 80 +++++++++++-----------
 OptimizelySDK/Bucketing/DecisionService.cs |  4 +-
 OptimizelySDK/Optimizely.cs                |  6 +-
 4 files changed, 53 insertions(+), 49 deletions(-)

diff --git a/OptimizelySDK.Tests/DecisionServiceTest.cs b/OptimizelySDK.Tests/DecisionServiceTest.cs
index 6c2ba204..2df1cf24 100644
--- a/OptimizelySDK.Tests/DecisionServiceTest.cs
+++ b/OptimizelySDK.Tests/DecisionServiceTest.cs
@@ -878,7 +878,7 @@ public void TestGetVariationForFeatureWhenTheUserIsBucketedIntoFeatureExperiment
                 It.IsAny<UserAttributes>(), ProjectConfig, It.IsAny<OptimizelyDecideOption[]>())).Returns(expectedDecision);
             OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns("user1");
 
-            var actualDecision = DecisionServiceMock.Object.GetVariationForFeature(featureFlag, OptimizelyUserContextMock.Object, ProjectConfig, new UserAttributes());
+            var actualDecision = DecisionServiceMock.Object.GetVariationForFeature(featureFlag, OptimizelyUserContextMock.Object, ProjectConfig);
             Assert.IsTrue(TestData.CompareObjects(expectedDecision, actualDecision));
         }
 
@@ -903,7 +903,7 @@ public void TestGetVariationForFeatureWhenTheUserIsNotBucketedIntoFeatureExperim
             OptimizelyUserContextMock = new Mock<OptimizelyUserContext>(optlyObject, WhitelistedUserId, new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object);
             OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns(UserProfileId);
 
-            var actualDecision = DecisionServiceMock.Object.GetVariationForFeature(featureFlag, OptimizelyUserContextMock.Object, ProjectConfig, new UserAttributes());
+            var actualDecision = DecisionServiceMock.Object.GetVariationForFeature(featureFlag, OptimizelyUserContextMock.Object, ProjectConfig);
 
             Assert.IsTrue(TestData.CompareObjects(expectedDecision, actualDecision));
 
@@ -920,7 +920,7 @@ public void TestGetVariationForFeatureWhenTheUserIsNeitherBucketedIntoFeatureExp
             DecisionServiceMock.Setup(ds => ds.GetVariationForFeatureExperiment(It.IsAny<FeatureFlag>(), It.IsAny<OptimizelyUserContext>(), It.IsAny<UserAttributes>(), ProjectConfig, new OptimizelyDecideOption[] { })).Returns(Result<FeatureDecision>.NullResult(null));
             DecisionServiceMock.Setup(ds => ds.GetVariationForFeatureRollout(It.IsAny<FeatureFlag>(), It.IsAny<string>(), It.IsAny<UserAttributes>(), ProjectConfig)).Returns(Result<FeatureDecision>.NullResult(null));
 
-            var actualDecision = DecisionServiceMock.Object.GetVariationForFeature(featureFlag, OptimizelyUserContextMock.Object, ProjectConfig, new UserAttributes());
+            var actualDecision = DecisionServiceMock.Object.GetVariationForFeature(featureFlag, OptimizelyUserContextMock.Object, ProjectConfig);
             Assert.IsTrue(TestData.CompareObjects(expectedDecision, actualDecision.ResultObject));
 
             LoggerMock.Verify(l => l.Log(LogLevel.INFO, "The user \"user1\" is not bucketed into a rollout for feature flag \"string_single_variable_feature\"."));
@@ -938,6 +938,10 @@ public void TestGetVariationForFeatureWhenTheUserIsBuckedtedInBothExperimentAndR
             var userAttributes = new UserAttributes {
                 { "browser_type", "chrome" }
             };
+
+            var optlyObject = new Optimizely(TestData.Datafile, new ValidEventDispatcher(), LoggerMock.Object);
+
+            OptimizelyUserContextMock = new Mock<OptimizelyUserContext>(optlyObject, WhitelistedUserId, userAttributes, ErrorHandlerMock.Object, LoggerMock.Object);
             OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns(UserProfileId);
 
             DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, OptimizelyUserContextMock.Object, ProjectConfig, userAttributes, It.IsAny<OptimizelyDecideOption[]>())).Returns(variation);
@@ -958,7 +962,7 @@ public void TestGetVariationForFeatureWhenTheUserIsBuckedtedInBothExperimentAndR
 
             Assert.IsTrue(TestData.CompareObjects(expectedRolloutDecision, actualRolloutDecision.ResultObject));
 
-            actualDecision = DecisionServiceMock.Object.GetVariationForFeature(featureFlag, OptimizelyUserContextMock.Object, ProjectConfig, userAttributes);
+            actualDecision = DecisionServiceMock.Object.GetVariationForFeature(featureFlag, OptimizelyUserContextMock.Object, ProjectConfig);
 
             // The user is bucketed into feature experiment's variation and not the rollout's variation.
             Assert.IsTrue(TestData.CompareObjects(expectedDecision, actualDecision.ResultObject));
diff --git a/OptimizelySDK.Tests/OptimizelyTest.cs b/OptimizelySDK.Tests/OptimizelyTest.cs
index 3aa9cbd8..3e9f0483 100644
--- a/OptimizelySDK.Tests/OptimizelyTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyTest.cs
@@ -1693,7 +1693,7 @@ public void TestGetFeatureVariableDoubleReturnsRightValueWhenUserBuckedIntoFeatu
             var variation = Config.GetVariationFromKey("test_experiment_double_feature", "control");
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
@@ -1722,7 +1722,7 @@ public void TestGetFeatureVariableIntegerReturnsRightValueWhenUserBuckedIntoFeat
                { "location", "San Francisco" }
             };
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
@@ -1745,7 +1745,7 @@ public void TestGetFeatureVariableDoubleReturnsDefaultValueWhenUserBuckedIntoFea
             var variation = Config.GetVariationFromKey("test_experiment_double_feature", "variation");
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
@@ -1774,7 +1774,7 @@ public void TestGetFeatureVariableIntegerReturnsDefaultValueWhenUserBuckedIntoFe
                { "location", "San Francisco" }
             };
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
@@ -1797,7 +1797,7 @@ public void TestGetFeatureVariableBooleanReturnsRightValueWhenUserBuckedIntoRoll
             var variation = Config.GetVariationFromKey(experiment.Key, "177771");
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_ROLLOUT), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
@@ -1826,7 +1826,7 @@ public void TestGetFeatureVariableJSONReturnsRightValueWhenUserBucketIntoRollout
                { "location", "San Francisco" }
             };
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
 
@@ -1858,7 +1858,7 @@ public void TestGetFeatureVariableJSONReturnsRightValueWhenUserBucketIntoRollout
                { "location", "San Francisco" }
             };
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
 
@@ -1889,7 +1889,7 @@ public void TestGetFeatureVariableStringReturnsRightValueWhenUserBuckedIntoRollo
                { "location", "San Francisco" }
             };
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
 
@@ -1913,7 +1913,7 @@ public void TestGetFeatureVariableBooleanReturnsDefaultValueWhenUserBuckedIntoRo
             var variation = Config.GetVariationFromKey(experiment.Key, "177782");
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_ROLLOUT), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
@@ -1940,7 +1940,7 @@ public void TestGetFeatureVariableStringReturnsDefaultValueWhenUserBuckedIntoRol
                { "location", "San Francisco" }
             };
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("ProjectConfigManager", ConfigManager);
@@ -1961,7 +1961,7 @@ public void TestGetFeatureVariableDoubleReturnsDefaultValueWhenUserNotBuckedInto
             var expectedValue = 14.99;
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(null, null, FeatureDecision.DECISION_SOURCE_ROLLOUT), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
@@ -2070,7 +2070,7 @@ public void TestGetFeatureVariableValueForTypeGivenFeatureFlagIsNotEnabledForUse
 
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
 
@@ -2099,7 +2099,7 @@ public void TestGetFeatureVariableValueForTypeGivenFeatureFlagIsEnabledForUserAn
             var expectedValue = 14.99;
 
             // Mock GetVariationForFeature method to return variation of different feature.
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(expectedDecision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(expectedDecision);
 
             var optly = Helper.CreatePrivateOptimizely();
 
@@ -2127,7 +2127,7 @@ public void TestGetFeatureVariableValueForTypeGivenFeatureFlagIsEnabledForUserAn
             var variation = Config.GetVariationFromKey("test_experiment_double_feature", "control");
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
 
@@ -2153,7 +2153,7 @@ public void TestGetFeatureVariableValueForTypeWithRolloutRule()
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_ROLLOUT), DecisionReasons);
             var expectedVariableValue = false;
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
 
@@ -2228,7 +2228,7 @@ public void TestIsFeatureEnabledGivenFeatureFlagIsNotEnabledForUser()
             var variation = Config.GetVariationFromKey("test_experiment_double_feature", "variation");
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
@@ -2253,7 +2253,7 @@ public void TestIsFeatureEnabledGivenFeatureFlagIsEnabledAndUserIsNotBeingExperi
             var featureFlag = Config.GetFeatureFlagFromKey(featureKey);
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_ROLLOUT), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
@@ -2281,7 +2281,7 @@ public void TestIsFeatureEnabledGivenFeatureFlagIsEnabledAndUserIsBeingExperimen
             var featureFlag = Config.GetFeatureFlagFromKey(featureKey);
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
@@ -2309,7 +2309,7 @@ public void TestIsFeatureEnabledGivenFeatureFlagIsNotEnabledAndUserIsBeingExperi
             var featureFlag = Config.GetFeatureFlagFromKey(featureKey);
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
@@ -2361,9 +2361,9 @@ public void TestIsFeatureEnabledWithFeatureEnabledPropertyGivenFeatureExperiment
             var decisionTrue = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, featureEnabledTrue, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
             var decisionFalse = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, featureEnabledFalse, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decisionTrue);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(decisionTrue);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decisionFalse);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(decisionFalse);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
@@ -2385,7 +2385,7 @@ public void TestIsFeatureEnabledWithFeatureEnabledPropertyGivenRolloutRule()
             // Verify that IsFeatureEnabled returns true when user is bucketed into the rollout rule's variation.
             Assert.True(Optimizely.IsFeatureEnabled("boolean_single_variable_feature", TestUserId));
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns<FeatureDecision>(null);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns<FeatureDecision>(null);
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
 
@@ -2439,7 +2439,7 @@ public void TestActivateListener(UserAttributes userAttributes)
             mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
 
             DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, It.IsAny<OptimizelyUserContext>(), It.IsAny<ProjectConfig>(), userAttributes)).Returns(variation);
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), It.IsAny<ProjectConfig>(), userAttributes)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), It.IsAny<ProjectConfig>())).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
             var optStronglyTyped = optly.GetObject() as Optimizely;
@@ -2763,7 +2763,7 @@ public void TestIsFeatureEnabledSendsDecisionNotificationWithFeatureEnabledTrueF
             var featureFlag = Config.GetFeatureFlagFromKey(featureKey);
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation.ResultObject, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), It.IsAny<Dictionary<string, object>>()));
 
@@ -2799,7 +2799,7 @@ public void TestIsFeatureEnabledSendsDecisionNotificationWithFeatureEnabledFalse
             var featureFlag = Config.GetFeatureFlagFromKey(featureKey);
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation.ResultObject, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), It.IsAny<Dictionary<string, object>>()));
 
@@ -2845,7 +2845,7 @@ public void TestIsFeatureEnabledSendsDecisionNotificationWithFeatureEnabledTrueF
             var featureFlag = Config.GetFeatureFlagFromKey(featureKey);
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_ROLLOUT), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), It.IsAny<Dictionary<string, object>>()));
 
@@ -2884,7 +2884,7 @@ public void TestIsFeatureEnabledSendsDecisionNotificationWithFeatureEnabledFalse
             var featureFlag = Config.GetFeatureFlagFromKey(featureKey);
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_ROLLOUT), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), It.IsAny<Dictionary<string, object>>()));
 
@@ -2916,7 +2916,7 @@ public void TestIsFeatureEnabledSendsDecisionNotificationWithFeatureEnabledFalse
             var featureFlag = Config.GetFeatureFlagFromKey(featureKey);
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(null, null, FeatureDecision.DECISION_SOURCE_ROLLOUT), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), It.IsAny<Dictionary<string, object>>()));
 
@@ -3056,7 +3056,7 @@ public void TestGetFeatureVariableDoubleSendsNotificationWhenUserBuckedIntoFeatu
             var variation = Config.GetVariationFromKey("test_experiment_double_feature", "control");
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<UserAttributes>(),
                 It.IsAny<Dictionary<string, object>>()));
 
@@ -3110,7 +3110,7 @@ public void TestGetFeatureVariableJsonSendsNotificationWhenUserBuckedIntoFeature
                { "location", "San Francisco" }
             };
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<UserAttributes>(),
                 It.IsAny<Dictionary<string, object>>()));
 
@@ -3155,7 +3155,7 @@ public void TestGetFeatureVariableIntegerSendsNotificationWhenUserBuckedIntoFeat
                { "location", "San Francisco" }
             };
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<UserAttributes>(),
                 It.IsAny<Dictionary<string, object>>()));
 
@@ -3199,7 +3199,7 @@ public void TestGetFeatureVariableDoubleSendsNotificationWhenUserBuckedIntoFeatu
             var variation = Config.GetVariationFromKey("test_experiment_double_feature", "variation");
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<UserAttributes>(),
                 It.IsAny<Dictionary<string, object>>()));
 
@@ -3248,7 +3248,7 @@ public void TestGetFeatureVariableIntegerSendsNotificationWhenUserBuckedIntoFeat
                { "location", "San Francisco" }
             };
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<UserAttributes>(),
                 It.IsAny<Dictionary<string, object>>()));
 
@@ -3291,7 +3291,7 @@ public void TestGetFeatureVariableBooleanSendsNotificationWhenUserBuckedIntoRoll
             var variation = Config.GetVariationFromKey(experiment.Key, "177771");
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_ROLLOUT), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<UserAttributes>(),
                 It.IsAny<Dictionary<string, object>>()));
 
@@ -3335,7 +3335,7 @@ public void TestGetFeatureVariableStringSendsNotificationWhenUserBuckedIntoRollo
                { "location", "San Francisco" }
             };
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<UserAttributes>(),
                 It.IsAny<Dictionary<string, object>>()));
 
@@ -3374,7 +3374,7 @@ public void TestGetFeatureVariableBooleanSendsNotificationWhenUserBuckedIntoRoll
             var variation = Config.GetVariationFromKey(experiment.Key, "177782");
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variation, FeatureDecision.DECISION_SOURCE_ROLLOUT), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<UserAttributes>(),
                 It.IsAny<Dictionary<string, object>>()));
 
@@ -3418,7 +3418,7 @@ public void TestGetFeatureVariableStringSendsNotificationWhenUserBuckedIntoRollo
                { "location", "San Francisco" }
             };
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<UserAttributes>(),
                 It.IsAny<Dictionary<string, object>>()));
 
@@ -3454,7 +3454,7 @@ public void TestGetFeatureVariableDoubleSendsNotificationWhenUserNotBuckedIntoBo
             var expectedValue = 14.99;
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(null, null, FeatureDecision.DECISION_SOURCE_ROLLOUT), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, null)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<UserAttributes>(),
                 It.IsAny<Dictionary<string, object>>()));
 
@@ -3511,7 +3511,7 @@ public void TestGetAllFeatureVariablesSendsNotificationWhenUserBucketIntoRollout
                { "location", "San Francisco" }
             };
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(decision);
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<UserAttributes>(),
                 It.IsAny<Dictionary<string, object>>()));
 
@@ -3599,7 +3599,7 @@ public void TestGetAllFeatureVariablesRollout()
 
             var decision = Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, null, FeatureDecision.DECISION_SOURCE_ROLLOUT), DecisionReasons);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(decision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), Config)).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
diff --git a/OptimizelySDK/Bucketing/DecisionService.cs b/OptimizelySDK/Bucketing/DecisionService.cs
index dc60a5aa..bb4d2278 100644
--- a/OptimizelySDK/Bucketing/DecisionService.cs
+++ b/OptimizelySDK/Bucketing/DecisionService.cs
@@ -554,9 +554,9 @@ public virtual Result<FeatureDecision> GetVariationForFeatureExperiment(FeatureF
         /// <param name = "filteredAttributes" >The user's attributes. This should be filtered to just attributes in the Datafile.</param>
         /// <returns>null if the user is not bucketed into any variation or the FeatureDecision entity if the user is
         /// successfully bucketed.</returns>
-        public virtual Result<FeatureDecision> GetVariationForFeature(FeatureFlag featureFlag, OptimizelyUserContext user, ProjectConfig config, UserAttributes filteredAttributes)
+        public virtual Result<FeatureDecision> GetVariationForFeature(FeatureFlag featureFlag, OptimizelyUserContext user, ProjectConfig config)
         {
-            return GetVariationForFeature(featureFlag, user, config, filteredAttributes, new OptimizelyDecideOption[] { });
+            return GetVariationForFeature(featureFlag, user, config, user.GetAttributes(), new OptimizelyDecideOption[] { });
         }
 
         /// <summary>
diff --git a/OptimizelySDK/Optimizely.cs b/OptimizelySDK/Optimizely.cs
index c425f8f7..8c45393b 100644
--- a/OptimizelySDK/Optimizely.cs
+++ b/OptimizelySDK/Optimizely.cs
@@ -483,7 +483,7 @@ public virtual bool IsFeatureEnabled(string featureKey, string userId, UserAttri
 
             bool featureEnabled = false;
             var sourceInfo = new Dictionary<string, string>();
-            var decision = DecisionService.GetVariationForFeature(featureFlag, CreateUserContext(userId, userAttributes), config, userAttributes).ResultObject;
+            var decision = DecisionService.GetVariationForFeature(featureFlag, CreateUserContext(userId, userAttributes), config).ResultObject;
             var variation = decision?.Variation;
             var decisionSource = decision?.Source ?? FeatureDecision.DECISION_SOURCE_ROLLOUT;
 
@@ -574,7 +574,7 @@ public virtual T GetFeatureVariableValueForType<T>(string featureKey, string var
 
             var featureEnabled = false;
             var variableValue = featureVariable.DefaultValue;
-            var decision = DecisionService.GetVariationForFeature(featureFlag, CreateUserContext(userId, userAttributes), config, userAttributes).ResultObject;
+            var decision = DecisionService.GetVariationForFeature(featureFlag, CreateUserContext(userId, userAttributes), config).ResultObject;
 
             if (decision?.Variation != null)
             {
@@ -1028,7 +1028,7 @@ public OptimizelyJSON GetAllFeatureVariables(string featureKey, string userId,
                 return null;
 
             var featureEnabled = false;
-            var decisionResult = DecisionService.GetVariationForFeature(featureFlag, CreateUserContext(userId, userAttributes), config, userAttributes);
+            var decisionResult = DecisionService.GetVariationForFeature(featureFlag, CreateUserContext(userId, userAttributes), config);
             var variation = decisionResult.ResultObject?.Variation;
 
             if (variation != null)

From 77626e0a3c5dd5472760174a14609eacfa1bdc03 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Sun, 17 Oct 2021 11:48:51 -0400
Subject: [PATCH 028/130] Updated test for new way of handling flagmap

---
 OptimizelySDK.Tests/ProjectConfigTest.cs | 148 ++++++++++++++++++++++-
 1 file changed, 143 insertions(+), 5 deletions(-)

diff --git a/OptimizelySDK.Tests/ProjectConfigTest.cs b/OptimizelySDK.Tests/ProjectConfigTest.cs
index 31819bd1..7afca2c4 100644
--- a/OptimizelySDK.Tests/ProjectConfigTest.cs
+++ b/OptimizelySDK.Tests/ProjectConfigTest.cs
@@ -394,7 +394,6 @@ public void TestInit()
             var actualVariationUsage = Config.GetVariationFromKey("test_experiment_multivariate", "Fred");
 
             Assertions.AreEqual(expectedVariationUsage, actualVariationUsage);
-            //Assert.IsTrue(TestData.CompareObjects(expectedVariationUsage, actualVariationUsage));
 
             // Check Feature Key map.
             var expectedFeatureKeyMap = new Dictionary<string, FeatureFlag>
@@ -412,7 +411,6 @@ public void TestInit()
             };
 
             Assertions.AreEquivalent(expectedFeatureKeyMap, Config.FeatureKeyMap);
-            //Assert.IsTrue(TestData.CompareObjects(expectedFeatureKeyMap, Config.FeatureKeyMap));
 
             // Check Feature Key map.
             var expectedRolloutIdMap = new Dictionary<string, Rollout>
@@ -432,6 +430,34 @@ public void TestFlagVariations()
             var expectedVariations1 = new List<Dictionary<string, List<Variation>>>();
             var expectedVariationList = new List<Variation>
             {
+                new Variation
+                {
+                    FeatureEnabled = true,
+                    Id = "122239",
+                    Key = "control",
+                    FeatureVariableUsageInstances = new List<FeatureVariableUsage> { new FeatureVariableUsage { Id = "155551", Value="42.42" } }
+                },
+                new Variation
+                {
+                    FeatureEnabled = false,
+                    Id = "122240",
+                    Key = "variation",
+                    FeatureVariableUsageInstances = new List<FeatureVariableUsage> { new FeatureVariableUsage { Id = "155551", Value="13.37" } }
+                },
+                new Variation
+                {
+                    FeatureEnabled = false,
+                    Id = "122242",
+                    Key = "control",
+                    FeatureVariableUsageInstances = new List<FeatureVariableUsage> { new FeatureVariableUsage { Id = "155553", Value="42" } }
+                },
+                new Variation
+                {
+                    FeatureEnabled = true,
+                    Id = "122243",
+                    Key = "variation",
+                    FeatureVariableUsageInstances = new List<FeatureVariableUsage> { new FeatureVariableUsage { Id = "155553", Value="13" } }
+                },
                 new Variation
                 {
                     FeatureEnabled = true, Id = "177771",
@@ -494,6 +520,39 @@ public void TestFlagVariations()
                     }
                 },
                 new Variation
+                {
+                    FeatureEnabled = true,
+                    Id = "122236",
+                    Key = "control",
+                    FeatureVariableUsageInstances = new List<FeatureVariableUsage>
+                    {
+                        new FeatureVariableUsage
+                        {
+                            Id = "155558",
+                            Value= "cta_1"
+                        },
+                        new FeatureVariableUsage
+                        {
+                            Id = "17014990011",
+                            Value = "{\"int_var\": 1, \"boolean_key\": false}"
+                        }
+                    }
+                },
+                new Variation
+                {
+                    FeatureEnabled = true,
+                    Id = "122237",
+                    Key = "variation",
+                    FeatureVariableUsageInstances = new List<FeatureVariableUsage>
+                    {
+                        new FeatureVariableUsage
+                        {
+                            Id = "155558",
+                            Value= "cta_2"
+                        },
+                    }
+                },
+                new Variation
                 {
                     FeatureEnabled = true,
                     Id = "177775",
@@ -508,13 +567,15 @@ public void TestFlagVariations()
                         new FeatureVariableUsage
                         {
                             Id = "17014990011",
-                            Value = "{\"int_var\": 4 , \"string_var\": \"cta_4\"}"
+                            Value= "{\"int_var\": 4 , \"string_var\": \"cta_4\"}"
                         },
                         new FeatureVariableUsage
                         {
                             Id = "170149900112",
-                            Value = "{\"int_var\": 5 , \"string_var\": \"cta_5\"}"
-                        } } },
+                            Value= "{\"int_var\": 5 , \"string_var\": \"cta_5\"}"
+                        }
+                    }
+                },
                 new Variation
                 {
                     FeatureEnabled = true,
@@ -535,12 +596,89 @@ public void TestFlagVariations()
                             Value= "cta_5"
                         }
                     }
+                },
+                new Variation
+                {
+                    FeatureEnabled = true,
+                    Id = "122231",
+                    Key = "Fred",
+                    FeatureVariableUsageInstances = new List<FeatureVariableUsage>
+                    {
+                        new FeatureVariableUsage
+                        {
+                            Id = "155560",
+                            Value = "F"
+                        },
+                        new FeatureVariableUsage
+                        {
+                            Id = "155561",
+                            Value = "red"
+                        }
+                    }
+                },
+                new Variation
+                {
+                    FeatureEnabled = false,
+                    Id = "122232",
+                    Key = "Feorge",
+                    FeatureVariableUsageInstances = new List<FeatureVariableUsage>
+                    {
+                        new FeatureVariableUsage
+                        {
+                            Id = "155560",
+                            Value = "F"
+                        },
+                        new FeatureVariableUsage
+                        {
+                            Id = "155561",
+                            Value = "eorge"
+                        }
+                    }
+                },
+                new Variation
+                {
+                    FeatureEnabled = null,
+                    Id = "122233",
+                    Key = "Gred",
+                    FeatureVariableUsageInstances = new List<FeatureVariableUsage>
+                    {
+                        new FeatureVariableUsage
+                        {
+                            Id = "155560",
+                            Value = "G"
+                        },
+                        new FeatureVariableUsage
+                        {
+                            Id = "155561",
+                            Value = "red"
+                        }
+                    }
+                },
+                new Variation
+                {
+                    FeatureEnabled = true,
+                    Id = "122234",
+                    Key = "George",
+                    FeatureVariableUsageInstances = new List<FeatureVariableUsage>
+                    {
+                        new FeatureVariableUsage
+                        {
+                            Id = "155560",
+                            Value = "G"
+                        },
+                        new FeatureVariableUsage
+                        {
+                            Id = "155561",
+                            Value = "eorge"
+                        }
+                    }
                 }
             };
             expectedVariations1.Add(new Dictionary<string, List<Variation>> { { "boolean_feature", expectedVariationList } });
 
             var variations1 = allVariations.Where(v => v.Key == "boolean_feature").Select(v => new Dictionary<string, List<Variation>> { { v.Key, v.Value } }).ToList();
 
+            TestData.CompareObjects(expectedVariations1, variations1);
             Assertions.AreEquivalent(expectedVariations1, variations1);
         }
 

From 5287e54965bb396700fd565166c984afd3d54fe9 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Mon, 18 Oct 2021 08:46:51 -0400
Subject: [PATCH 029/130] Added null check and added test, removed unnecessary
 check for null in two places

---
 OptimizelySDK.Tests/OptimizelyUserContextTest.cs | 10 ++++++++++
 OptimizelySDK/OptimizelyUserContext.cs           | 12 ++++++------
 2 files changed, 16 insertions(+), 6 deletions(-)

diff --git a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
index 3f6a9305..6496ea6c 100644
--- a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
@@ -207,6 +207,16 @@ public void SetForcedDecisionReturnsFalseForNullConfig()
             //should assert logger is called
         }
 
+        [Test]
+        public void GetForcedDecisionReturnsNullWithNullFlagKey()
+        {
+            var user = Optimizely.CreateUserContext(UserID);
+
+            var result = user.GetForcedDecision(null);
+
+            Assert.IsNull(result);
+        }
+
         [Test]
         public void GetForcedDecisionsReturnsValueWithRuleKey()
         {
diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index 01c08f45..625ef83d 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -272,12 +272,6 @@ public bool SetForcedDecision(string flagKey, string ruleKey, string variationKe
         /// <returns>The variation key for a forced decision</returns>
         public string GetForcedDecision(string flagKey)
         {
-            if (Optimizely.GetOptimizelyConfig() == null)
-            {
-                Logger.Log(LogLevel.ERROR, "Optimizely SDK not ready.");
-                return null;
-            }
-
             return FindForcedDecision(flagKey, null);
         }
 
@@ -289,6 +283,12 @@ public string GetForcedDecision(string flagKey)
         /// <returns>The variation key for a forced decision</returns>
         public string GetForcedDecision(string flagKey, string ruleKey)
         {
+            if (string.IsNullOrEmpty(flagKey))
+            {
+                Logger.Log(LogLevel.ERROR, "flagkey cannot be null");
+                return null;
+            }
+
             if (Optimizely.GetOptimizelyConfig() == null)
             {
                 Logger.Log(LogLevel.ERROR, "Optimizely SDK not ready.");

From 147773ee9ff0b8cba50ba8b62cd946c35b4975f5 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Mon, 18 Oct 2021 08:48:15 -0400
Subject: [PATCH 030/130] Updated comments

---
 OptimizelySDK/OptimizelyUserContext.cs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index 625ef83d..8bbed04c 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -266,17 +266,17 @@ public bool SetForcedDecision(string flagKey, string ruleKey, string variationKe
         }
 
         /// <summary>
-        /// Finds a forced variation
+        /// Gets a forced variation
         /// </summary>
         /// <param name="flagKey">The flag key</param>
         /// <returns>The variation key for a forced decision</returns>
         public string GetForcedDecision(string flagKey)
         {
-            return FindForcedDecision(flagKey, null);
+            return GetForcedDecision(flagKey, null);
         }
 
         /// <summary>
-        /// Finds a forced variation
+        /// Gets a forced variation
         /// </summary>
         /// <param name="flagKey">The flag key</param>
         /// <param name="ruleKey">The rule key</param>

From d418ea2dbeee56cd58c3e5a1aa6e83bcff191338 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Mon, 18 Oct 2021 08:49:20 -0400
Subject: [PATCH 031/130] Changed to warn, since its not technically an error

---
 OptimizelySDK/OptimizelyUserContext.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index 8bbed04c..db6684cf 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -285,7 +285,7 @@ public string GetForcedDecision(string flagKey, string ruleKey)
         {
             if (string.IsNullOrEmpty(flagKey))
             {
-                Logger.Log(LogLevel.ERROR, "flagkey cannot be null");
+                Logger.Log(LogLevel.WARN, "flagkey cannot be null");
                 return null;
             }
 

From 13ca784d12115af72cd0ab5aed0bf7d8415f6c2d Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Mon, 18 Oct 2021 08:51:04 -0400
Subject: [PATCH 032/130] Refactored to be clearer where the issues can crop up

---
 OptimizelySDK/OptimizelyUserContext.cs | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index db6684cf..7b19c915 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -283,18 +283,6 @@ public string GetForcedDecision(string flagKey)
         /// <returns>The variation key for a forced decision</returns>
         public string GetForcedDecision(string flagKey, string ruleKey)
         {
-            if (string.IsNullOrEmpty(flagKey))
-            {
-                Logger.Log(LogLevel.WARN, "flagkey cannot be null");
-                return null;
-            }
-
-            if (Optimizely.GetOptimizelyConfig() == null)
-            {
-                Logger.Log(LogLevel.ERROR, "Optimizely SDK not ready.");
-                return null;
-            }
-
             return FindForcedDecision(flagKey, ruleKey);
         }
 
@@ -306,6 +294,18 @@ public string GetForcedDecision(string flagKey, string ruleKey)
         /// <returns>The variation key for a forced decision</returns>
         public string FindForcedDecision(string flagKey, string ruleKey)
         {
+            if (Optimizely.GetOptimizelyConfig() == null)
+            {
+                Logger.Log(LogLevel.ERROR, "Optimizely SDK not ready.");
+                return null;
+            }
+
+            if (string.IsNullOrEmpty(flagKey))
+            {
+                Logger.Log(LogLevel.WARN, "flagkey cannot be null");
+                return null;
+            }
+
             string variationKey = null;
             if (ruleKey != null)
             {

From aefdf348d79c7c435eeb237785549fc3febd9790 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Mon, 18 Oct 2021 08:54:10 -0400
Subject: [PATCH 033/130] Another null check.

---
 OptimizelySDK.Tests/OptimizelyUserContextTest.cs | 8 ++++++++
 OptimizelySDK/OptimizelyUserContext.cs           | 6 ++++++
 2 files changed, 14 insertions(+)

diff --git a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
index 6496ea6c..c2db6b80 100644
--- a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
@@ -277,6 +277,14 @@ public void FindForcedDecisionReturnsValueWithRuleKey()
             Assert.AreEqual("variation", result);
         }
 
+        [Test]
+        public void RemoveForcedDecisionReturnsFalseForNullFlagKey()
+        {
+            var user = Optimizely.CreateUserContext(UserID);
+
+            Assert.IsFalse(user.RemoveForcedDecision(null));
+        }
+
         [Test]
         public void RemoveForcedDecisionRemovesDecision()
         {
diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index 7b19c915..45776c88 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -345,6 +345,12 @@ public bool RemoveForcedDecision(string flagKey)
         /// <returns>Whether the item was removed.</returns>
         public bool RemoveForcedDecision(string flagKey, string ruleKey)
         {
+            if (string.IsNullOrEmpty(flagKey))
+            {
+                Logger.Log(LogLevel.WARN, "flagKey cannot be null");
+                return false;
+            }
+
             if (Optimizely.GetOptimizelyConfig() == null)
             {
                 Logger.Log(LogLevel.ERROR, "Optimizely SDK not ready.");

From 58d40bfc098387c49459a0626571fb29945ef0b7 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Mon, 18 Oct 2021 09:21:37 -0400
Subject: [PATCH 034/130] Added tests for unused publics

---
 OptimizelySDK.Tests/Assertions.cs             | 20 +++++++++++++++++++
 .../OptimizelyUserContextTest.cs              | 15 ++++++++++++++
 2 files changed, 35 insertions(+)

diff --git a/OptimizelySDK.Tests/Assertions.cs b/OptimizelySDK.Tests/Assertions.cs
index eab0cbe4..e0b6246d 100644
--- a/OptimizelySDK.Tests/Assertions.cs
+++ b/OptimizelySDK.Tests/Assertions.cs
@@ -1,5 +1,6 @@
 using NUnit.Framework;
 using OptimizelySDK.Entity;
+using OptimizelySDK.OptimizelyDecisions;
 using OptimizelySDK.OptlyConfig;
 using System;
 using System.Collections.Generic;
@@ -599,5 +600,24 @@ public static void AreEqual(TrafficAllocation expected, TrafficAllocation actual
         }
 
         #endregion TrafficAllocation
+
+        #region DecisionReasons
+
+        public static void AreEqual(DecisionReasons expected, DecisionReasons actual)
+        {
+            AreEquivalent(expected.ToReport(), actual.ToReport());
+        }
+
+        #endregion DecisionReasons
+
+        #region Result T
+
+        public static void AreEqual(Result<Variation> expected, Result<Variation> actual)
+        {
+            AreEqual(expected.DecisionReasons, actual.DecisionReasons);
+            AreEqual(expected.ResultObject, actual.ResultObject);
+        }
+
+        #endregion Result T
     }
 }
diff --git a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
index c2db6b80..df8d2ded 100644
--- a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
@@ -277,6 +277,21 @@ public void FindForcedDecisionReturnsValueWithRuleKey()
             Assert.AreEqual("variation", result);
         }
 
+        [Test]
+        public void FindValidatedForcedDecisionReturnsCorrectDecision()
+        {
+            var decisionReasons = new DecisionReasons();
+            decisionReasons.AddInfo("{0}", "Variation variation is mapped to flag: flagKey and rule: rule in the forced decision map.");
+            var expectedResult = Result<Variation>.NewResult(new Variation { }, decisionReasons);
+            var user = Optimizely.CreateUserContext(UserID);
+
+            user.SetForcedDecision("flagKey", "rule", "variation");
+
+            var result = user.FindValidatedForcedDecision("flagKey", "rule");
+
+            Assertions.AreEqual(expectedResult, result);
+        }
+
         [Test]
         public void RemoveForcedDecisionReturnsFalseForNullFlagKey()
         {

From 484dc2192b791ae9ad9616f3419129a6ec760644 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Mon, 18 Oct 2021 10:07:37 -0400
Subject: [PATCH 035/130] Updated optimizely to correctly use the right object

---
 OptimizelySDK/Optimizely.cs | 43 ++++++++++++++++++++++++-------------
 1 file changed, 28 insertions(+), 15 deletions(-)

diff --git a/OptimizelySDK/Optimizely.cs b/OptimizelySDK/Optimizely.cs
index 8c45393b..78a47cb3 100644
--- a/OptimizelySDK/Optimizely.cs
+++ b/OptimizelySDK/Optimizely.cs
@@ -729,10 +729,12 @@ internal OptimizelyDecision Decide(OptimizelyUserContext user,
                               OptimizelyDecideOption[] options)
         {
             var config = ProjectConfigManager?.GetConfig();
+
             if (config == null)
             {
                 return OptimizelyDecision.NewErrorDecision(key, user, DecisionMessage.SDK_NOT_READY, ErrorHandler, Logger);
             }
+
             if (key == null)
             {
                 return OptimizelyDecision.NewErrorDecision(key,
@@ -741,8 +743,6 @@ internal OptimizelyDecision Decide(OptimizelyUserContext user,
                     ErrorHandler, Logger);
             }
 
-            var userId = user?.GetUserId();
-
             var flag = config.GetFeatureFlagFromKey(key);
             if (string.IsNullOrEmpty(flag.Key))
             {
@@ -752,20 +752,34 @@ internal OptimizelyDecision Decide(OptimizelyUserContext user,
                     ErrorHandler, Logger);
             }
 
+            var userId = user?.GetUserId();
             var userAttributes = user.GetAttributes();
             var decisionEventDispatched = false;
             var allOptions = GetAllOptions(options);
+            var decisionReasons = new DecisionReasons();
+            FeatureDecision decision = null;
 
-            var flagDecisionResult = DecisionService.GetVariationForFeature(
-                flag,
-                user,
-                config,
-                userAttributes,
-                allOptions);
+            var forcedDecisionVariation = user.FindValidatedForcedDecision(flag.Key, null);
+            if (forcedDecisionVariation?.ResultObject != null)
+            {
+                decision = new FeatureDecision(null, forcedDecisionVariation.ResultObject, FeatureDecision.DECISION_SOURCE_FEATURE_TEST);
+                decisionReasons = forcedDecisionVariation.DecisionReasons;
+            }
+            else
+            {
+                var flagDecisionResult = DecisionService.GetVariationForFeature(
+                    flag,
+                    user,
+                    config,
+                    userAttributes,
+                    allOptions
+                );
+                decisionReasons = flagDecisionResult.DecisionReasons;
+                decision = flagDecisionResult.ResultObject;
+            }
 
             var featureEnabled = false;
-
-            var variation = flagDecisionResult.ResultObject?.Variation;
+            var variation = decision?.Variation;
 
             if (variation != null)
             {
@@ -806,17 +820,16 @@ internal OptimizelyDecision Decide(OptimizelyUserContext user,
 
             var optimizelyJSON = new OptimizelyJSON(variableMap, ErrorHandler, Logger);
 
-            var decisionSource = flagDecisionResult.ResultObject?.Source ?? FeatureDecision.DECISION_SOURCE_ROLLOUT;
+            var decisionSource = decision?.Source ?? FeatureDecision.DECISION_SOURCE_ROLLOUT;
             if (!allOptions.Contains(OptimizelyDecideOption.DISABLE_DECISION_EVENT))
             {
-                decisionEventDispatched = SendImpressionEvent(flagDecisionResult.ResultObject?.Experiment, variation, userId, userAttributes, config, key, decisionSource, featureEnabled);
+                decisionEventDispatched = SendImpressionEvent(decision?.Experiment, variation, userId, userAttributes, config, key, decisionSource, featureEnabled);
             }
-            var decisionReasons = flagDecisionResult.DecisionReasons;
             var reasonsToReport = decisionReasons.ToReport(allOptions.Contains(OptimizelyDecideOption.INCLUDE_REASONS)).ToArray();
-            var variationKey = flagDecisionResult.ResultObject?.Variation?.Key;
+            var variationKey = decision?.Variation?.Key;
 
             // TODO: add ruleKey values when available later. use a copy of experimentKey until then.
-            var ruleKey = flagDecisionResult.ResultObject?.Experiment?.Key;
+            var ruleKey = decision?.Experiment?.Key;
 
             var decisionInfo = new Dictionary<string, object>
             {

From 7d420c44a27aa62f670674a7a56ddcdedf67c1ef Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Mon, 18 Oct 2021 15:19:02 -0400
Subject: [PATCH 036/130] Added copyright

---
 OptimizelySDK.Tests/Assertions.cs              | 18 +++++++++++++++++-
 .../OptimizelyUserContextTest.cs               |  5 +++++
 2 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/OptimizelySDK.Tests/Assertions.cs b/OptimizelySDK.Tests/Assertions.cs
index e0b6246d..ebe269a1 100644
--- a/OptimizelySDK.Tests/Assertions.cs
+++ b/OptimizelySDK.Tests/Assertions.cs
@@ -1,4 +1,20 @@
-using NUnit.Framework;
+/*
+ * Copyright 2017, 2019-2021, Optimizely
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using NUnit.Framework;
 using OptimizelySDK.Entity;
 using OptimizelySDK.OptimizelyDecisions;
 using OptimizelySDK.OptlyConfig;
diff --git a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
index df8d2ded..8808df24 100644
--- a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
@@ -185,6 +185,11 @@ public void TestDecide()
             Assert.AreEqual(decision.Reasons.Length, 0);
         }
 
+        //[Test]
+        //public void TestDecideForcedDecision()
+        //{
+        //}
+
         [Test]
         public void SetForcedDecisionSetsValue()
         {

From e89f4a02cd4952a0e3263e4884e0ea21ce149ae6 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Tue, 19 Oct 2021 11:01:21 -0400
Subject: [PATCH 037/130] Updated tests, removed unnecessary call

---
 .../OptimizelyUserContextTest.cs              | 37 +++++--------------
 OptimizelySDK/OptimizelyUserContext.cs        | 13 +------
 2 files changed, 11 insertions(+), 39 deletions(-)

diff --git a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
index 8808df24..0dbe8079 100644
--- a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
@@ -185,11 +185,6 @@ public void TestDecide()
             Assert.AreEqual(decision.Reasons.Length, 0);
         }
 
-        //[Test]
-        //public void TestDecideForcedDecision()
-        //{
-        //}
-
         [Test]
         public void SetForcedDecisionSetsValue()
         {
@@ -201,7 +196,7 @@ public void SetForcedDecisionSetsValue()
         }
 
         [Test]
-        public void SetForcedDecisionReturnsFalseForNullConfig()
+        public void TestSetForcedDecisionReturnsFalseForNullConfig()
         {
             var optly = new Optimizely(new FallbackProjectConfigManager(null));
 
@@ -209,11 +204,11 @@ public void SetForcedDecisionReturnsFalseForNullConfig()
             var result = user.SetForcedDecision("flag", "variation");
 
             Assert.IsFalse(result);
-            //should assert logger is called
+            //TODO: should assert logger is called
         }
 
         [Test]
-        public void GetForcedDecisionReturnsNullWithNullFlagKey()
+        public void TestGetForcedDecisionReturnsNullWithNullFlagKey()
         {
             var user = Optimizely.CreateUserContext(UserID);
 
@@ -223,7 +218,7 @@ public void GetForcedDecisionReturnsNullWithNullFlagKey()
         }
 
         [Test]
-        public void GetForcedDecisionsReturnsValueWithRuleKey()
+        public void TestGetForcedDecisionsReturnsValueWithRuleKey()
         {
             var user = Optimizely.CreateUserContext(UserID);
 
@@ -235,7 +230,7 @@ public void GetForcedDecisionsReturnsValueWithRuleKey()
         }
 
         [Test]
-        public void GetForcedDecisionReturnsValueWithoutRuleKey()
+        public void TestGetForcedDecisionReturnsValueWithoutRuleKey()
         {
             var user = Optimizely.CreateUserContext(UserID);
 
@@ -247,7 +242,7 @@ public void GetForcedDecisionReturnsValueWithoutRuleKey()
         }
 
         [Test]
-        public void GetForcedDecisionReturnsValueWithOnlyFlagKey()
+        public void TestGetForcedDecisionReturnsValueWithOnlyFlagKey()
         {
             var user = Optimizely.CreateUserContext(UserID);
 
@@ -259,31 +254,19 @@ public void GetForcedDecisionReturnsValueWithOnlyFlagKey()
         }
 
         [Test]
-        public void FindForcedDecisionReturnsValueWithoutRuleKey()
-        {
-            var user = Optimizely.CreateUserContext(UserID);
-
-            user.SetForcedDecision("flagKey", "variation");
-
-            var result = user.FindForcedDecision("flagKey", null);
-
-            Assert.AreEqual("variation", result);
-        }
-
-        [Test]
-        public void FindForcedDecisionReturnsValueWithRuleKey()
+        public void TestGetForcedDecisionReturnsValueWithRuleKey()
         {
             var user = Optimizely.CreateUserContext(UserID);
 
             user.SetForcedDecision("flagKey", "rule", "variation");
 
-            var result = user.FindForcedDecision("flagKey", "rule");
+            var result = user.GetForcedDecision("flagKey", "rule");
 
             Assert.AreEqual("variation", result);
         }
 
         [Test]
-        public void FindValidatedForcedDecisionReturnsCorrectDecision()
+        public void TestFindValidatedForcedDecisionReturnsCorrectDecision()
         {
             var decisionReasons = new DecisionReasons();
             decisionReasons.AddInfo("{0}", "Variation variation is mapped to flag: flagKey and rule: rule in the forced decision map.");
@@ -314,7 +297,7 @@ public void RemoveForcedDecisionRemovesDecision()
 
             user.RemoveForcedDecision("flagKey", "ruleKey");
 
-            var result = user.FindForcedDecision("flagKey", "ruleKey");
+            var result = user.GetForcedDecision("flagKey", "ruleKey");
 
             Assert.AreEqual(null, result);
         }
diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index 45776c88..29485bd9 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -282,17 +282,6 @@ public string GetForcedDecision(string flagKey)
         /// <param name="ruleKey">The rule key</param>
         /// <returns>The variation key for a forced decision</returns>
         public string GetForcedDecision(string flagKey, string ruleKey)
-        {
-            return FindForcedDecision(flagKey, ruleKey);
-        }
-
-        /// <summary>
-        /// Finds a forced variation
-        /// </summary>
-        /// <param name="flagKey">The flag key</param>
-        /// <param name="ruleKey">The rule key</param>
-        /// <returns>The variation key for a forced decision</returns>
-        public string FindForcedDecision(string flagKey, string ruleKey)
         {
             if (Optimizely.GetOptimizelyConfig() == null)
             {
@@ -410,7 +399,7 @@ public Result<Variation> FindValidatedForcedDecision(string flagKey, string rule
         {
             DecisionReasons reasons = new DecisionReasons();
 
-            string variationKey = FindForcedDecision(flagKey, ruleKey);
+            string variationKey = GetForcedDecision(flagKey, ruleKey);
             if (variationKey != null)
             {
                 Variation variation = new Variation();

From ac5fd974ef6f25517f988a8df5694004279fedbe Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Thu, 21 Oct 2021 03:13:55 -0400
Subject: [PATCH 038/130] removed redundant calls

---
 OptimizelySDK/OptimizelyUserContext.cs | 36 +++-----------------------
 1 file changed, 3 insertions(+), 33 deletions(-)

diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index 29485bd9..49f3b647 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -265,23 +265,13 @@ public bool SetForcedDecision(string flagKey, string ruleKey, string variationKe
             return true;
         }
 
-        /// <summary>
-        /// Gets a forced variation
-        /// </summary>
-        /// <param name="flagKey">The flag key</param>
-        /// <returns>The variation key for a forced decision</returns>
-        public string GetForcedDecision(string flagKey)
-        {
-            return GetForcedDecision(flagKey, null);
-        }
-
         /// <summary>
         /// Gets a forced variation
         /// </summary>
         /// <param name="flagKey">The flag key</param>
         /// <param name="ruleKey">The rule key</param>
         /// <returns>The variation key for a forced decision</returns>
-        public string GetForcedDecision(string flagKey, string ruleKey)
+        public string GetForcedDecision(string flagKey, string ruleKey = null)
         {
             if (Optimizely.GetOptimizelyConfig() == null)
             {
@@ -316,23 +306,13 @@ public string GetForcedDecision(string flagKey, string ruleKey)
             return variationKey;
         }
 
-        /// <summary>
-        /// Removes a forced decision.
-        /// </summary>
-        /// <param name="flagKey">The flag key.</param>
-        /// <returns>Whether the item was removed.</returns>
-        public bool RemoveForcedDecision(string flagKey)
-        {
-            return RemoveForcedDecision(flagKey, null);
-        }
-
         /// <summary>
         /// Removes a forced decision.
         /// </summary>
         /// <param name="flagKey">The flag key.</param>
         /// <param name="ruleKey"></param>
         /// <returns>Whether the item was removed.</returns>
-        public bool RemoveForcedDecision(string flagKey, string ruleKey)
+        public bool RemoveForcedDecision(string flagKey, string ruleKey = null)
         {
             if (string.IsNullOrEmpty(flagKey))
             {
@@ -379,23 +359,13 @@ public bool RemoveAllForcedDecisions()
             return true;
         }
 
-        /// <summary>
-        /// Finds a validated forced decision.
-        /// </summary>
-        /// <param name="flagKey">The flag key.</param>
-        /// <returns>A result with the variation.</returns>
-        public Result<Variation> FindValidatedForcedDecision(string flagKey)
-        {
-            return FindValidatedForcedDecision(flagKey, null);
-        }
-
         /// <summary>
         /// Finds a validated forced decision.
         /// </summary>
         /// <param name="flagKey">The flag key.</param>
         /// <param name="ruleKey">The rule key.</param>
         /// <returns>A result with the variation</returns>
-        public Result<Variation> FindValidatedForcedDecision(string flagKey, string ruleKey)
+        public Result<Variation> FindValidatedForcedDecision(string flagKey, string ruleKey = null)
         {
             DecisionReasons reasons = new DecisionReasons();
 

From 7570f484ac1cbfc60e672fca703d74b16a9294cf Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Thu, 21 Oct 2021 07:31:40 -0400
Subject: [PATCH 039/130] const update

---
 OptimizelySDK.Tests/OptimizelyUserContextTest.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
index 0dbe8079..3444f6c3 100644
--- a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
@@ -37,7 +37,7 @@ namespace OptimizelySDK.Tests
     [TestFixture]
     public class OptimizelyUserContextTest
     {
-        private string UserID = "testUserID";
+        const string UserID = "testUserID";
         private Optimizely Optimizely;
         private Mock<ILogger> LoggerMock;
         private Mock<IErrorHandler> ErrorHandlerMock;

From a01050b75f16310418ec1e9a2f9a95488273e8ff Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Thu, 21 Oct 2021 07:34:44 -0400
Subject: [PATCH 040/130] Changed to IsValid for areas that make sense.

---
 OptimizelySDK/OptimizelyUserContext.cs | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index 49f3b647..4d26981a 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -239,13 +239,19 @@ public bool SetForcedDecision(string flagKey, string variationKey)
         /// <returns></returns>
         public bool SetForcedDecision(string flagKey, string ruleKey, string variationKey)
         {
-            if (Optimizely.GetOptimizelyConfig() == null)
+            if (!Optimizely.IsValid)
             {
                 Logger.Log(LogLevel.ERROR, "Optimizely config is null");
                 return false;
             }
 
-            if (ruleKey == null)
+            if (ruleKey != null)
+            {
+                Dictionary<string, ForcedDecision> forcedDecision = new Dictionary<string, ForcedDecision>();
+                forcedDecision.Add(ruleKey, new ForcedDecision(flagKey, ruleKey, variationKey));
+                ForcedDecisionsMap.Add(flagKey, forcedDecision);
+            }
+            else
             {
                 if (ForcedDecisionsMapWithNoRuleKey.TryGetValue(flagKey, out var value))
                 {
@@ -256,12 +262,6 @@ public bool SetForcedDecision(string flagKey, string ruleKey, string variationKe
                     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;
         }
 
@@ -273,7 +273,7 @@ public bool SetForcedDecision(string flagKey, string ruleKey, string variationKe
         /// <returns>The variation key for a forced decision</returns>
         public string GetForcedDecision(string flagKey, string ruleKey = null)
         {
-            if (Optimizely.GetOptimizelyConfig() == null)
+            if (!Optimizely.IsValid)
             {
                 Logger.Log(LogLevel.ERROR, "Optimizely SDK not ready.");
                 return null;
@@ -320,7 +320,7 @@ public bool RemoveForcedDecision(string flagKey, string ruleKey = null)
                 return false;
             }
 
-            if (Optimizely.GetOptimizelyConfig() == null)
+            if (Optimizely.IsValid)
             {
                 Logger.Log(LogLevel.ERROR, "Optimizely SDK not ready.");
                 return false;

From 9efc42ac500e99f645e15564f1247aab017f838c Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Thu, 21 Oct 2021 07:37:49 -0400
Subject: [PATCH 041/130] More IsValid changes

---
 OptimizelySDK/OptimizelyUserContext.cs | 24 +++++++-----------------
 1 file changed, 7 insertions(+), 17 deletions(-)

diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index 4d26981a..50a08e37 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -245,23 +245,12 @@ public bool SetForcedDecision(string flagKey, string ruleKey, string variationKe
                 return false;
             }
 
-            if (ruleKey != null)
-            {
-                Dictionary<string, ForcedDecision> forcedDecision = new Dictionary<string, ForcedDecision>();
-                forcedDecision.Add(ruleKey, new ForcedDecision(flagKey, ruleKey, variationKey));
-                ForcedDecisionsMap.Add(flagKey, forcedDecision);
-            }
-            else
-            {
-                if (ForcedDecisionsMapWithNoRuleKey.TryGetValue(flagKey, out var value))
+            ForcedDecisionsMap[flagKey] = new Dictionary<string, ForcedDecision> {
                 {
-                    value.VariationKey = variationKey;
+                    flagKey, new ForcedDecision(flagKey, ruleKey ?? null, variationKey)
                 }
-                else
-                {
-                    ForcedDecisionsMapWithNoRuleKey.Add(flagKey, new ForcedDecision(flagKey, null, variationKey));
-                }
-            }
+            };
+
             return true;
         }
 
@@ -320,11 +309,12 @@ public bool RemoveForcedDecision(string flagKey, string ruleKey = null)
                 return false;
             }
 
-            if (Optimizely.IsValid)
+            if (!Optimizely.IsValid)
             {
                 Logger.Log(LogLevel.ERROR, "Optimizely SDK not ready.");
                 return false;
             }
+
             if (ruleKey != null)
             {
                 ForcedDecisionsMap.TryGetValue(flagKey, out var decision);
@@ -348,7 +338,7 @@ public bool RemoveForcedDecision(string flagKey, string ruleKey = null)
         /// <returns>Whether the clear was successful.</returns>
         public bool RemoveAllForcedDecisions()
         {
-            if (Optimizely.GetOptimizelyConfig() == null)
+            if (!Optimizely.IsValid)
             {
                 Logger.Log(LogLevel.ERROR, "Optimizely SDK not ready.");
                 return false;

From 9da8ee5550dde1154cf1ee14522d64de2ac54bd9 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Thu, 21 Oct 2021 07:40:47 -0400
Subject: [PATCH 042/130] Unintended up date.

---
 OptimizelySDK/OptimizelyUserContext.cs | 18 +++++++++++++++---
 1 file changed, 15 insertions(+), 3 deletions(-)

diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index 50a08e37..0563a74d 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -245,11 +245,23 @@ public bool SetForcedDecision(string flagKey, string ruleKey, string variationKe
                 return false;
             }
 
-            ForcedDecisionsMap[flagKey] = new Dictionary<string, ForcedDecision> {
+            if (ruleKey != null)
+            {
+                Dictionary<string, ForcedDecision> forcedDecision = new Dictionary<string, ForcedDecision>();
+                forcedDecision.Add(ruleKey, new ForcedDecision(flagKey, ruleKey, variationKey));
+                ForcedDecisionsMap.Add(flagKey, forcedDecision);
+            }
+            else
+            {
+                if (ForcedDecisionsMapWithNoRuleKey.TryGetValue(flagKey, out var value))
                 {
-                    flagKey, new ForcedDecision(flagKey, ruleKey ?? null, variationKey)
+                    value.VariationKey = variationKey;
                 }
-            };
+                else
+                {
+                    ForcedDecisionsMapWithNoRuleKey.Add(flagKey, new ForcedDecision(flagKey, null, variationKey));
+                }
+            }
 
             return true;
         }

From 4783824f409b8138644a7522a9e8e6a9a3851a46 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Thu, 21 Oct 2021 07:47:12 -0400
Subject: [PATCH 043/130] Additional changes for str.format

---
 OptimizelySDK/OptimizelyUserContext.cs | 23 ++++++-----------------
 1 file changed, 6 insertions(+), 17 deletions(-)

diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index 0563a74d..5dac3ac3 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -287,23 +287,12 @@ public string GetForcedDecision(string flagKey, string ruleKey = null)
             }
 
             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 (ForcedDecisionsMap.TryGetValue(flagKey, out var forcedDecisionMap) && forcedDecisionMap.TryGetValue(ruleKey, out var forcedDecision))
             {
-                if (ForcedDecisionsMapWithNoRuleKey.Count > 0 && ForcedDecisionsMapWithNoRuleKey.TryGetValue(flagKey, out var forcedDecision))
-                {
-                    variationKey = forcedDecision.VariationKey;
-                }
+                variationKey = forcedDecision.VariationKey;
             }
+
             return variationKey;
         }
 
@@ -379,14 +368,14 @@ public Result<Variation> FindValidatedForcedDecision(string flagKey, string rule
                 string info = string.Empty;
                 if (variation != null)
                 {
-                    info = "Variation " + variationKey + " is mapped to flag: " + flagKey + " and rule: " + strRuleKey + " in the forced decision map.";
+                    info = string.Format("Variation {0} is mapped to flag: {1} and rule: {2} in the forced decision map.", variationKey, flagKey, strRuleKey;
                     Logger.Log(LogLevel.INFO, info);
                     reasons.AddInfo(info);
                     return Result<Variation>.NewResult(variation, reasons);
                 }
                 else
                 {
-                    info = "Invalid variation is mapped to flag: " + flagKey + " and rule: " + strRuleKey + " forced decision map.";
+                    info = string.Format("Invalid variation is mapped to flag: {0} and rule: {1} forced decision map.", flagKey, strRuleKey);
                     Logger.Log(LogLevel.INFO, info);
                     reasons.AddInfo(info);
                 }

From 8fa31988e8903b1499696097e75948325b772d14 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Thu, 21 Oct 2021 07:52:55 -0400
Subject: [PATCH 044/130] Removed second collection for no rule key

---
 OptimizelySDK/OptimizelyUserContext.cs | 48 ++++++++++++--------------
 1 file changed, 22 insertions(+), 26 deletions(-)

diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index 5dac3ac3..863a2cdf 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -62,7 +62,6 @@ public ForcedDecision(string flagKey, string ruleKey, string variationKey)
         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)
         {
@@ -245,23 +244,11 @@ public bool SetForcedDecision(string flagKey, string ruleKey, string variationKe
                 return false;
             }
 
-            if (ruleKey != null)
-            {
-                Dictionary<string, ForcedDecision> forcedDecision = new Dictionary<string, ForcedDecision>();
-                forcedDecision.Add(ruleKey, new ForcedDecision(flagKey, ruleKey, variationKey));
-                ForcedDecisionsMap.Add(flagKey, forcedDecision);
-            }
-            else
-            {
-                if (ForcedDecisionsMapWithNoRuleKey.TryGetValue(flagKey, out var value))
-                {
-                    value.VariationKey = variationKey;
-                }
-                else
+            ForcedDecisionsMap[flagKey] = new Dictionary<string, ForcedDecision> {
                 {
-                    ForcedDecisionsMapWithNoRuleKey.Add(flagKey, new ForcedDecision(flagKey, null, variationKey));
+                    flagKey, new ForcedDecision(flagKey, ruleKey ?? "hardcoded-key", variationKey)
                 }
-            }
+            };
 
             return true;
         }
@@ -316,21 +303,31 @@ public bool RemoveForcedDecision(string flagKey, string ruleKey = null)
                 return false;
             }
 
-            if (ruleKey != null)
+            if (ForcedDecisionsMap.TryGetValue(flagKey, out var decision))
             {
-                ForcedDecisionsMap.TryGetValue(flagKey, out var decision);
                 decision.Remove(ruleKey);
                 if (decision.Count == 0)
                 {
                     ForcedDecisionsMap.Remove(flagKey);
                 }
-                return true;
-            }
-            else
-            {
-                ForcedDecisionsMapWithNoRuleKey.Remove(flagKey);
-                return true;
             }
+            return true;
+
+            //if (ruleKey != null)
+            //{
+            //    ForcedDecisionsMap.TryGetValue(flagKey, out var decision);
+            //    decision.Remove(ruleKey);
+            //    if (decision.Count == 0)
+            //    {
+            //        ForcedDecisionsMap.Remove(flagKey);
+            //    }
+            //    return true;
+            //}
+            //else
+            //{
+            //    ForcedDecisionsMapWithNoRuleKey.Remove(flagKey);
+            //    return true;
+            //}
         }
 
         /// <summary>
@@ -346,7 +343,6 @@ public bool RemoveAllForcedDecisions()
             }
 
             ForcedDecisionsMap.Clear();
-            ForcedDecisionsMapWithNoRuleKey.Clear();
             return true;
         }
 
@@ -368,7 +364,7 @@ public Result<Variation> FindValidatedForcedDecision(string flagKey, string rule
                 string info = string.Empty;
                 if (variation != null)
                 {
-                    info = string.Format("Variation {0} is mapped to flag: {1} and rule: {2} in the forced decision map.", variationKey, flagKey, strRuleKey;
+                    info = string.Format("Variation {0} is mapped to flag: {1} and rule: {2} in the forced decision map.", variationKey, flagKey, strRuleKey);
                     Logger.Log(LogLevel.INFO, info);
                     reasons.AddInfo(info);
                     return Result<Variation>.NewResult(variation, reasons);

From 5eb9922fc89e4c49097873b27ff0ad3523e5ef2f Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Thu, 21 Oct 2021 07:57:29 -0400
Subject: [PATCH 045/130] WIP replacement for having two collections

---
 OptimizelySDK/OptimizelyUserContext.cs | 18 +-----------------
 1 file changed, 1 insertion(+), 17 deletions(-)

diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index 863a2cdf..6a4712e6 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -246,7 +246,7 @@ public bool SetForcedDecision(string flagKey, string ruleKey, string variationKe
 
             ForcedDecisionsMap[flagKey] = new Dictionary<string, ForcedDecision> {
                 {
-                    flagKey, new ForcedDecision(flagKey, ruleKey ?? "hardcoded-key", variationKey)
+                    flagKey, new ForcedDecision(flagKey, ruleKey, variationKey)
                 }
             };
 
@@ -312,22 +312,6 @@ public bool RemoveForcedDecision(string flagKey, string ruleKey = null)
                 }
             }
             return true;
-
-            //if (ruleKey != null)
-            //{
-            //    ForcedDecisionsMap.TryGetValue(flagKey, out var decision);
-            //    decision.Remove(ruleKey);
-            //    if (decision.Count == 0)
-            //    {
-            //        ForcedDecisionsMap.Remove(flagKey);
-            //    }
-            //    return true;
-            //}
-            //else
-            //{
-            //    ForcedDecisionsMapWithNoRuleKey.Remove(flagKey);
-            //    return true;
-            //}
         }
 
         /// <summary>

From 03815127078c504d929535fd89d0c3fa89acffa3 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Thu, 21 Oct 2021 07:58:12 -0400
Subject: [PATCH 046/130] Removed redundant assignment

---
 OptimizelySDK/OptimizelyUserContext.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index 6a4712e6..b49e0f86 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -345,7 +345,7 @@ public Result<Variation> FindValidatedForcedDecision(string flagKey, string rule
             {
                 Variation variation = new Variation();
                 string strRuleKey = ruleKey ?? "null";
-                string info = string.Empty;
+                string info;
                 if (variation != null)
                 {
                     info = string.Format("Variation {0} is mapped to flag: {1} and rule: {2} in the forced decision map.", variationKey, flagKey, strRuleKey);

From 874157eca1363051e8c9e444ded76d2421ec4236 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Thu, 21 Oct 2021 08:28:48 -0400
Subject: [PATCH 047/130] Updated with single collection

---
 OptimizelySDK/OptimizelyUserContext.cs | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index b49e0f86..0b76c467 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -48,6 +48,8 @@ public ForcedDecision(string flagKey, string ruleKey, string variationKey)
             public string VariationKey { get { return variationKey; } set { this.variationKey = value; } }
         }
 
+        private const string nullRuleKey = "HardCodedNullRuleKey";
+
         private ILogger Logger;
         private IErrorHandler ErrorHandler;
         private object mutex = new object();
@@ -246,7 +248,7 @@ public bool SetForcedDecision(string flagKey, string ruleKey, string variationKe
 
             ForcedDecisionsMap[flagKey] = new Dictionary<string, ForcedDecision> {
                 {
-                    flagKey, new ForcedDecision(flagKey, ruleKey, variationKey)
+                    ruleKey ?? nullRuleKey, new ForcedDecision(flagKey, ruleKey, variationKey)
                 }
             };
 
@@ -275,9 +277,12 @@ public string GetForcedDecision(string flagKey, string ruleKey = null)
 
             string variationKey = null;
 
-            if (ForcedDecisionsMap.TryGetValue(flagKey, out var forcedDecisionMap) && forcedDecisionMap.TryGetValue(ruleKey, out var forcedDecision))
+            if (ForcedDecisionsMap.TryGetValue(flagKey, out var forcedDecisionMap))
             {
-                variationKey = forcedDecision.VariationKey;
+                if (forcedDecisionMap.TryGetValue(ruleKey ?? nullRuleKey, out var forcedDecision))
+                {
+                    variationKey = forcedDecision.VariationKey;
+                }
             }
 
             return variationKey;

From f3ec5fba3c8092d134f8da1a36305228a5eaf0c3 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Fri, 22 Oct 2021 06:27:48 -0400
Subject: [PATCH 048/130] Prepend with Test to new test method names

---
 OptimizelySDK.Tests/OptimizelyUserContextTest.cs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
index 3444f6c3..eaa307a8 100644
--- a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
@@ -186,7 +186,7 @@ public void TestDecide()
         }
 
         [Test]
-        public void SetForcedDecisionSetsValue()
+        public void TestSetForcedDecisionSetsValue()
         {
             var user = Optimizely.CreateUserContext(UserID);
 
@@ -281,7 +281,7 @@ public void TestFindValidatedForcedDecisionReturnsCorrectDecision()
         }
 
         [Test]
-        public void RemoveForcedDecisionReturnsFalseForNullFlagKey()
+        public void TestRemoveForcedDecisionReturnsFalseForNullFlagKey()
         {
             var user = Optimizely.CreateUserContext(UserID);
 
@@ -289,7 +289,7 @@ public void RemoveForcedDecisionReturnsFalseForNullFlagKey()
         }
 
         [Test]
-        public void RemoveForcedDecisionRemovesDecision()
+        public void TestRemoveForcedDecisionRemovesDecision()
         {
             var user = Optimizely.CreateUserContext(UserID);
 
@@ -303,7 +303,7 @@ public void RemoveForcedDecisionRemovesDecision()
         }
 
         [Test]
-        public void RemoveForcedDecisionReturnsFalseForNullConfig()
+        public void TestRemoveForcedDecisionReturnsFalseForNullConfig()
         {
             var optly = new Optimizely(new FallbackProjectConfigManager(null));
 
@@ -316,7 +316,7 @@ public void RemoveForcedDecisionReturnsFalseForNullConfig()
         }
 
         [Test]
-        public void RemoveAllForcedDecisionsRemovesDecisions()
+        public void TestRemoveAllForcedDecisionsRemovesDecisions()
         {
             var user = Optimizely.CreateUserContext(UserID);
 
@@ -337,7 +337,7 @@ public void RemoveAllForcedDecisionsRemovesDecisions()
         }
 
         [Test]
-        public void RemoveAllForcedDecisionsReturnsFalseForNullConfig()
+        public void TestRemoveAllForcedDecisionsReturnsFalseForNullConfig()
         {
             var optly = new Optimizely(new FallbackProjectConfigManager(null));
 

From a139aa9e735ddf21cdb1313aaae171ce37cc89f4 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Fri, 22 Oct 2021 06:30:27 -0400
Subject: [PATCH 049/130] Added documentation

---
 OptimizelySDK/Config/DatafileProjectConfig.cs | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/OptimizelySDK/Config/DatafileProjectConfig.cs b/OptimizelySDK/Config/DatafileProjectConfig.cs
index 20169296..77701e1b 100644
--- a/OptimizelySDK/Config/DatafileProjectConfig.cs
+++ b/OptimizelySDK/Config/DatafileProjectConfig.cs
@@ -369,6 +369,10 @@ private void Initialize()
             }
         }
 
+        /// <summary>
+        /// Get the Flag variation map to use
+        /// </summary>
+        /// <returns>A map of flag key to variations</returns>
         private Dictionary<string, List<Variation>> GetFlagVariationMap()
         {
             var map = new Dictionary<string, List<Variation>>();
@@ -392,6 +396,11 @@ private Dictionary<string, List<Variation>> GetFlagVariationMap()
             return map;
         }
 
+        /// <summary>
+        /// Retrieves all the rules for a given feature flag
+        /// </summary>
+        /// <param name="flag">Feature flag to use</param>
+        /// <returns>A list of experiments</returns>
         private List<Experiment> GetAllRulesForFlag(FeatureFlag flag)
         {
             var rules = new List<Experiment>();

From ba19e3052b4d26f745c7617dbcc4c13fa84a808c Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Mon, 25 Oct 2021 08:42:26 -0400
Subject: [PATCH 050/130] added lock to set/get

---
 OptimizelySDK/OptimizelyUserContext.cs | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index 0b76c467..d895bab0 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -246,11 +246,14 @@ public bool SetForcedDecision(string flagKey, string ruleKey, string variationKe
                 return false;
             }
 
-            ForcedDecisionsMap[flagKey] = new Dictionary<string, ForcedDecision> {
+            lock (mutex)
+            {
+                ForcedDecisionsMap[flagKey] = new Dictionary<string, ForcedDecision> {
                 {
                     ruleKey ?? nullRuleKey, new ForcedDecision(flagKey, ruleKey, variationKey)
                 }
-            };
+                };
+            }
 
             return true;
         }
@@ -277,14 +280,16 @@ public string GetForcedDecision(string flagKey, string ruleKey = null)
 
             string variationKey = null;
 
-            if (ForcedDecisionsMap.TryGetValue(flagKey, out var forcedDecisionMap))
+            lock (mutex)
             {
-                if (forcedDecisionMap.TryGetValue(ruleKey ?? nullRuleKey, out var forcedDecision))
+                if (ForcedDecisionsMap.TryGetValue(flagKey, out var forcedDecisionMap))
                 {
-                    variationKey = forcedDecision.VariationKey;
+                    if (forcedDecisionMap.TryGetValue(ruleKey ?? nullRuleKey, out var forcedDecision))
+                    {
+                        variationKey = forcedDecision.VariationKey;
+                    }
                 }
             }
-
             return variationKey;
         }
 

From 9e4409dc5d1686d34b9ec17f24997629fb53779e Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Mon, 25 Oct 2021 12:02:09 -0400
Subject: [PATCH 051/130] added to copy

---
 OptimizelySDK/OptimizelyUserContext.cs | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index d895bab0..b6a8ef38 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -28,13 +28,13 @@ namespace OptimizelySDK
     /// </summary>
     public class OptimizelyUserContext
     {
-        private class ForcedDecision
+        public class OptimizelyForcedDecision
         {
             private string flagKey;
             private string ruleKey;
             private string variationKey;
 
-            public ForcedDecision(string flagKey, string ruleKey, string variationKey)
+            public OptimizelyForcedDecision(string flagKey, string ruleKey, string variationKey)
             {
                 this.flagKey = flagKey;
                 this.ruleKey = ruleKey;
@@ -63,7 +63,7 @@ public ForcedDecision(string flagKey, string ruleKey, string variationKey)
         // Optimizely object to be used.
         private Optimizely Optimizely;
 
-        private Dictionary<string, Dictionary<string, ForcedDecision>> ForcedDecisionsMap = new Dictionary<string, Dictionary<string, ForcedDecision>>();
+        private Dictionary<string, Dictionary<string, OptimizelyForcedDecision>> ForcedDecisionsMap { get; set; }
 
         public OptimizelyUserContext(Optimizely optimizely, string userId, UserAttributes userAttributes, IErrorHandler errorHandler, ILogger logger)
         {
@@ -74,7 +74,17 @@ public OptimizelyUserContext(Optimizely optimizely, string userId, UserAttribute
             UserId = userId;
         }
 
-        private OptimizelyUserContext Copy() => new OptimizelyUserContext(Optimizely, UserId, GetAttributes(), ErrorHandler, Logger);
+        public OptimizelyUserContext(Optimizely optimizely, string userId, UserAttributes userAttributes, Dictionary<string, Dictionary<string, OptimizelyForcedDecision>> forcedDecisions, IErrorHandler errorHandler, ILogger logger)
+        {
+            ErrorHandler = errorHandler;
+            Logger = logger;
+            Optimizely = optimizely;
+            Attributes = userAttributes ?? new UserAttributes();
+            ForcedDecisionsMap = forcedDecisions ?? new Dictionary<string, Dictionary<string, OptimizelyForcedDecision>>();
+            UserId = userId;
+        }
+
+        private OptimizelyUserContext Copy() => new OptimizelyUserContext(Optimizely, UserId, GetAttributes(), ForcedDecisionsMap, ErrorHandler, Logger);
 
         /// <summary>
         /// Returns Optimizely instance associated with the UserContext.

From 044ad4a7b8cf40393f7cd2d530970f134481f0e3 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Mon, 25 Oct 2021 12:19:17 -0400
Subject: [PATCH 052/130] rename failure

---
 OptimizelySDK/OptimizelyUserContext.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index b6a8ef38..c0973252 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -258,9 +258,9 @@ public bool SetForcedDecision(string flagKey, string ruleKey, string variationKe
 
             lock (mutex)
             {
-                ForcedDecisionsMap[flagKey] = new Dictionary<string, ForcedDecision> {
+                ForcedDecisionsMap[flagKey] = new Dictionary<string, OptimizelyForcedDecision> {
                 {
-                    ruleKey ?? nullRuleKey, new ForcedDecision(flagKey, ruleKey, variationKey)
+                    ruleKey ?? nullRuleKey, new OptimizelyForcedDecision(flagKey, ruleKey, variationKey)
                 }
                 };
             }

From a073b795bfb1f8d1277ab9c3702be3d7ae82d406 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Mon, 25 Oct 2021 15:20:44 -0400
Subject: [PATCH 053/130] update to pass unit tests correctly

---
 OptimizelySDK.Tests/OptimizelyUserContextTest.cs | 2 +-
 OptimizelySDK/OptimizelyUserContext.cs           | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
index eaa307a8..8de854fb 100644
--- a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
@@ -220,7 +220,7 @@ public void TestGetForcedDecisionReturnsNullWithNullFlagKey()
         [Test]
         public void TestGetForcedDecisionsReturnsValueWithRuleKey()
         {
-            var user = Optimizely.CreateUserContext(UserID);
+            OptimizelyUserContext user = new OptimizelyUserContext(Optimizely, UserID, null, null, ErrorHandlerMock.Object, LoggerMock.Object);
 
             user.SetForcedDecision("flagKey", "ruleKey", "variation");
 
diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index c0973252..a360d72c 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -71,6 +71,7 @@ public OptimizelyUserContext(Optimizely optimizely, string userId, UserAttribute
             Logger = logger;
             Optimizely = optimizely;
             Attributes = userAttributes ?? new UserAttributes();
+            ForcedDecisionsMap = new Dictionary<string, Dictionary<string, OptimizelyForcedDecision>>();
             UserId = userId;
         }
 

From a401aa994314029de55a53a659937d000eea97ee Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Mon, 25 Oct 2021 15:21:17 -0400
Subject: [PATCH 054/130] updated tests

---
 OptimizelySDK.Tests/OptimizelyUserContextTest.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
index 8de854fb..eaa307a8 100644
--- a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
@@ -220,7 +220,7 @@ public void TestGetForcedDecisionReturnsNullWithNullFlagKey()
         [Test]
         public void TestGetForcedDecisionsReturnsValueWithRuleKey()
         {
-            OptimizelyUserContext user = new OptimizelyUserContext(Optimizely, UserID, null, null, ErrorHandlerMock.Object, LoggerMock.Object);
+            var user = Optimizely.CreateUserContext(UserID);
 
             user.SetForcedDecision("flagKey", "ruleKey", "variation");
 

From 1106c446b12afc9c29a04f349a9659c27a847a26 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Wed, 27 Oct 2021 09:02:31 -0400
Subject: [PATCH 055/130] refactored a bit to start

---
 .../OptimizelyDecisionContext.cs              |  37 ++++
 .../OptimizelyForcedDecision.cs               |  19 ++
 .../OptimizelySDK.Net35.csproj                | 208 +++++++++---------
 .../OptimizelyDecisionContext.cs              |  37 ++++
 .../OptimizelyForcedDecision.cs               |  20 ++
 .../OptimizelySDK.Net40.csproj                | 182 +++++++--------
 .../OptimizelyDecisionContext.cs              |  37 ++++
 .../OptimizelyForcedDecision.cs               |  20 ++
 .../OptimizelyDecisionContext.cs              |  37 ++++
 .../OptimizelyForcedDecision.cs               |  20 ++
 OptimizelySDK/OptimizelyDecisionContext.cs    |  37 ++++
 OptimizelySDK/OptimizelyForcedDecision.cs     |  20 ++
 OptimizelySDK/OptimizelySDK.csproj            |   2 +
 OptimizelySDK/OptimizelyUserContext.cs        |  29 +--
 14 files changed, 488 insertions(+), 217 deletions(-)
 create mode 100644 OptimizelySDK.Net35/OptimizelyDecisionContext.cs
 create mode 100644 OptimizelySDK.Net35/OptimizelyForcedDecision.cs
 create mode 100644 OptimizelySDK.Net40/OptimizelyDecisionContext.cs
 create mode 100644 OptimizelySDK.Net40/OptimizelyForcedDecision.cs
 create mode 100644 OptimizelySDK.NetStandard16/OptimizelyDecisionContext.cs
 create mode 100644 OptimizelySDK.NetStandard16/OptimizelyForcedDecision.cs
 create mode 100644 OptimizelySDK.NetStandard20/OptimizelyDecisionContext.cs
 create mode 100644 OptimizelySDK.NetStandard20/OptimizelyForcedDecision.cs
 create mode 100644 OptimizelySDK/OptimizelyDecisionContext.cs
 create mode 100644 OptimizelySDK/OptimizelyForcedDecision.cs

diff --git a/OptimizelySDK.Net35/OptimizelyDecisionContext.cs b/OptimizelySDK.Net35/OptimizelyDecisionContext.cs
new file mode 100644
index 00000000..ffce1940
--- /dev/null
+++ b/OptimizelySDK.Net35/OptimizelyDecisionContext.cs
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2020-2021, Optimizely
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace OptimizelySDK
+{
+    public class OptimizelyDecisionContext
+    {
+        public const string OPTI_NULL_RULE_KEY = "$opt-null-rule-key";
+        private string flagKey;
+        private string ruleKey;
+
+        public OptimizelyDecisionContext(string flagKey, string ruleKey, string variationKey)
+        {
+            this.flagKey = flagKey;
+            this.ruleKey = ruleKey;
+        }
+
+        public string FlagKey { get { return flagKey; } set { this.flagKey = value; } }
+
+        public string RuleKey { get { return ruleKey; } set { this.ruleKey = value; } }
+
+        public string GetDecisionKey { get { return string.Format("{0}-{1}", flagKey, ruleKey ?? OPTI_NULL_RULE_KEY); } }
+    }
+}
diff --git a/OptimizelySDK.Net35/OptimizelyForcedDecision.cs b/OptimizelySDK.Net35/OptimizelyForcedDecision.cs
new file mode 100644
index 00000000..c24d2e9d
--- /dev/null
+++ b/OptimizelySDK.Net35/OptimizelyForcedDecision.cs
@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace OptimizelySDK
+{
+    public class OptimizelyForcedDecision
+    {
+        private string variationKey;
+
+        public OptimizelyForcedDecision(string variationKey)
+        {
+            this.variationKey = variationKey;
+        }
+
+        public string VariationKey { get { return variationKey; } }
+    }
+}
diff --git a/OptimizelySDK.Net35/OptimizelySDK.Net35.csproj b/OptimizelySDK.Net35/OptimizelySDK.Net35.csproj
index 8dc64e4e..266e3943 100644
--- a/OptimizelySDK.Net35/OptimizelySDK.Net35.csproj
+++ b/OptimizelySDK.Net35/OptimizelySDK.Net35.csproj
@@ -46,28 +46,28 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
-	<Compile Include="..\OptimizelySDK\AudienceConditions\AndCondition.cs">
+    <Compile Include="..\OptimizelySDK\AudienceConditions\AndCondition.cs">
       <Link>AudienceConditions\AndCondition.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\AudienceConditions\AudienceIdCondition.cs">
+    <Compile Include="..\OptimizelySDK\AudienceConditions\AudienceIdCondition.cs">
       <Link>AudienceConditions\AudienceIdCondition.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\AudienceConditions\BaseCondition.cs">
+    <Compile Include="..\OptimizelySDK\AudienceConditions\BaseCondition.cs">
       <Link>AudienceConditions\BaseCondition.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\AudienceConditions\SemanticVersion.cs">
+    <Compile Include="..\OptimizelySDK\AudienceConditions\SemanticVersion.cs">
       <Link>AudienceConditions\SemanticVersion.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\AudienceConditions\EmptyCondition.cs">
+    <Compile Include="..\OptimizelySDK\AudienceConditions\EmptyCondition.cs">
       <Link>AudienceConditions\EmptyCondition.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\AudienceConditions\ICondition.cs">
+    <Compile Include="..\OptimizelySDK\AudienceConditions\ICondition.cs">
       <Link>AudienceConditions\ICondition.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\AudienceConditions\NotCondition.cs">
+    <Compile Include="..\OptimizelySDK\AudienceConditions\NotCondition.cs">
       <Link>AudienceConditions\NotCondition.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\AudienceConditions\OrCondition.cs">
+    <Compile Include="..\OptimizelySDK\AudienceConditions\OrCondition.cs">
       <Link>AudienceConditions\OrCondition.cs</Link>
     </Compile>
     <Compile Include="..\OptimizelySDK\Entity\Attribute.cs">
@@ -100,7 +100,7 @@
     <Compile Include="..\OptimizelySDK\Entity\IdKeyEntity.cs">
       <Link>Entity\IdKeyEntity.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\OptimizelyJSON.cs">
+    <Compile Include="..\OptimizelySDK\OptimizelyJSON.cs">
       <Link>OptimizelyJSON.cs</Link>
     </Compile>
     <Compile Include="..\OptimizelySDK\Entity\TrafficAllocation.cs">
@@ -139,7 +139,7 @@
     <Compile Include="..\OptimizelySDK\Event\LogEvent.cs">
       <Link>Event\LogEvent.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\Event\ForwardingEventProcessor.cs">
+    <Compile Include="..\OptimizelySDK\Event\ForwardingEventProcessor.cs">
       <Link>Event\ForwardingEventProcessor.cs</Link>
     </Compile>
     <Compile Include="..\OptimizelySDK\Exceptions\OptimizelyException.cs">
@@ -178,21 +178,23 @@
     <Compile Include="..\OptimizelySDK\Utils\ControlAttributes.cs">
       <Link>Utils\ControlAttributes.cs</Link>
     </Compile>
-	  <Compile Include="..\OptimizelySDK\Utils\ExceptionExtensions.cs">
+    <Compile Include="..\OptimizelySDK\Utils\ExceptionExtensions.cs">
       <Link>Utils\ExceptionExtensions.cs</Link>
     </Compile>
-	  <Compile Include="..\OptimizelySDK\Utils\ConditionParser.cs">
+    <Compile Include="..\OptimizelySDK\Utils\ConditionParser.cs">
       <Link>Utils\ConditionParser.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\Utils\AttributeMatchTypes.cs">
+    <Compile Include="..\OptimizelySDK\Utils\AttributeMatchTypes.cs">
       <Link>Utils\AttributeMatchTypes.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\Utils\DecisionInfoTypes.cs">
+    <Compile Include="..\OptimizelySDK\Utils\DecisionInfoTypes.cs">
       <Link>Utils\DecisionInfoTypes.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\Utils\DateTimeUtils.cs">
+    <Compile Include="..\OptimizelySDK\Utils\DateTimeUtils.cs">
       <Link>Utils\DateTimeUtils.cs</Link>
     </Compile>
+    <Compile Include="OptimizelyDecisionContext.cs" />
+    <Compile Include="OptimizelyForcedDecision.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="..\OptimizelySDK\Bucketing\Bucketer.cs">
       <Link>Bucketing\Bucketer.cs</Link>
@@ -227,108 +229,108 @@
     <Compile Include="..\OptimizelySDK\Entity\Rollout.cs">
       <Link>Entity\Rollout</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\ProjectConfig.cs">
+    <Compile Include="..\OptimizelySDK\ProjectConfig.cs">
       <Link>ProjectConfig</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\Config\DatafileProjectConfig.cs">
+    <Compile Include="..\OptimizelySDK\Config\DatafileProjectConfig.cs">
       <Link>Config\DatafileProjectConfig</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\Config\ProjectConfigManager.cs">
+    <Compile Include="..\OptimizelySDK\Config\ProjectConfigManager.cs">
       <Link>Config\ProjectConfigManager</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\Config\FallbackProjectConfigManager.cs">
-	  <Link>Config\FallbackProjectConfigManager.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\Event\Entity\ConversionEvent.cs">
-	  <Link>Event\Entity\ConversionEvent.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\Event\Entity\Decision.cs">
-	  <Link>Event\Entity\Decision.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\Event\Entity\EventBatch.cs">
-	  <Link>Event\Entity\EventBatch.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\Event\Entity\EventContext.cs">
-	  <Link>Event\Entity\EventContext.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\Event\Entity\ImpressionEvent.cs">
-	  <Link>Event\Entity\ImpressionEvent.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\Event\Entity\Snapshot.cs">
-	  <Link>Event\Entity\Snapshot.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\Event\Entity\SnapshotEvent.cs">
-	  <Link>Event\Entity\SnapshotEvent.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\Event\Entity\UserEvent.cs">
-	  <Link>Event\Entity\UserEvent.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\Event\Entity\Visitor.cs">
-	  <Link>Event\Entity\Visitor.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\Event\Entity\DecisionMetadata.cs">
-	  <Link>Event\Entity\DecisionMetadata.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\Event\Entity\VisitorAttribute.cs">
-	  <Link>Event\Entity\VisitorAttribute.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\Event\EventFactory.cs">
-	  <Link>Event\EventFactory.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\Event\UserEventFactory.cs">
-	  <Link>Event\UserEventFactory.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\Event\EventProcessor.cs">
-	  <Link>Event\EventProcessor.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyConfig.cs">
-	  <Link>OptlyConfig\OptimizelyConfig.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyAttribute.cs">
-	  <Link>OptlyConfig\OptimizelyAttribute.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyEvent.cs">
-	  <Link>OptlyConfig\OptimizelyEvent.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyExperiment.cs">
-	  <Link>OptlyConfig\OptimizelyExperiment.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyAudience.cs">
-	  <Link>OptlyConfig\OptimizelyAudience.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyFeature.cs">
-	  <Link>OptlyConfig\OptimizelyFeature.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyVariable.cs">
-	  <Link>OptlyConfig\OptimizelyVariable.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyVariation.cs">
-	  <Link>OptlyConfig\OptimizelyVariation.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyConfigService.cs">
-	  <Link>OptlyConfig\OptimizelyConfigService.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\OptlyConfig\IOptimizelyConfigManager.cs">
-	  <Link>OptlyConfig\IOptimizelyConfigManager.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\OptimizelyDecisions\DecisionMessage.cs">
+    <Compile Include="..\OptimizelySDK\Config\FallbackProjectConfigManager.cs">
+      <Link>Config\FallbackProjectConfigManager.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\Event\Entity\ConversionEvent.cs">
+      <Link>Event\Entity\ConversionEvent.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\Event\Entity\Decision.cs">
+      <Link>Event\Entity\Decision.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\Event\Entity\EventBatch.cs">
+      <Link>Event\Entity\EventBatch.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\Event\Entity\EventContext.cs">
+      <Link>Event\Entity\EventContext.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\Event\Entity\ImpressionEvent.cs">
+      <Link>Event\Entity\ImpressionEvent.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\Event\Entity\Snapshot.cs">
+      <Link>Event\Entity\Snapshot.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\Event\Entity\SnapshotEvent.cs">
+      <Link>Event\Entity\SnapshotEvent.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\Event\Entity\UserEvent.cs">
+      <Link>Event\Entity\UserEvent.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\Event\Entity\Visitor.cs">
+      <Link>Event\Entity\Visitor.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\Event\Entity\DecisionMetadata.cs">
+      <Link>Event\Entity\DecisionMetadata.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\Event\Entity\VisitorAttribute.cs">
+      <Link>Event\Entity\VisitorAttribute.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\Event\EventFactory.cs">
+      <Link>Event\EventFactory.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\Event\UserEventFactory.cs">
+      <Link>Event\UserEventFactory.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\Event\EventProcessor.cs">
+      <Link>Event\EventProcessor.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyConfig.cs">
+      <Link>OptlyConfig\OptimizelyConfig.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyAttribute.cs">
+      <Link>OptlyConfig\OptimizelyAttribute.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyEvent.cs">
+      <Link>OptlyConfig\OptimizelyEvent.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyExperiment.cs">
+      <Link>OptlyConfig\OptimizelyExperiment.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyAudience.cs">
+      <Link>OptlyConfig\OptimizelyAudience.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyFeature.cs">
+      <Link>OptlyConfig\OptimizelyFeature.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyVariable.cs">
+      <Link>OptlyConfig\OptimizelyVariable.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyVariation.cs">
+      <Link>OptlyConfig\OptimizelyVariation.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyConfigService.cs">
+      <Link>OptlyConfig\OptimizelyConfigService.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\OptlyConfig\IOptimizelyConfigManager.cs">
+      <Link>OptlyConfig\IOptimizelyConfigManager.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\OptimizelyDecisions\DecisionMessage.cs">
       <Link>OptimizelyDecisions\DecisionMessage.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\OptimizelyDecisions\OptimizelyDecideOption.cs">
+    <Compile Include="..\OptimizelySDK\OptimizelyDecisions\OptimizelyDecideOption.cs">
       <Link>OptimizelyDecisions\OptimizelyDecideOption.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\OptimizelyDecisions\OptimizelyDecision.cs">
+    <Compile Include="..\OptimizelySDK\OptimizelyDecisions\OptimizelyDecision.cs">
       <Link>OptimizelyDecisions\OptimizelyDecision.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\OptimizelyUserContext.cs">
+    <Compile Include="..\OptimizelySDK\OptimizelyUserContext.cs">
       <Link>OptimizelyUserContext.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\Entity\Result.cs">
-	  <Link>Entity\Result.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\OptimizelyDecisions\DecisionReasons.cs">
-	  <Link>OptimizelyDecisions\DecisionReasons.cs</Link>
-	</Compile>
+    <Compile Include="..\OptimizelySDK\Entity\Result.cs">
+      <Link>Entity\Result.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\OptimizelyDecisions\DecisionReasons.cs">
+      <Link>OptimizelyDecisions\DecisionReasons.cs</Link>
+    </Compile>
   </ItemGroup>
   <ItemGroup>
     <None Include="..\OptimizelySDK\Utils\schema.json">
diff --git a/OptimizelySDK.Net40/OptimizelyDecisionContext.cs b/OptimizelySDK.Net40/OptimizelyDecisionContext.cs
new file mode 100644
index 00000000..ffce1940
--- /dev/null
+++ b/OptimizelySDK.Net40/OptimizelyDecisionContext.cs
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2020-2021, Optimizely
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace OptimizelySDK
+{
+    public class OptimizelyDecisionContext
+    {
+        public const string OPTI_NULL_RULE_KEY = "$opt-null-rule-key";
+        private string flagKey;
+        private string ruleKey;
+
+        public OptimizelyDecisionContext(string flagKey, string ruleKey, string variationKey)
+        {
+            this.flagKey = flagKey;
+            this.ruleKey = ruleKey;
+        }
+
+        public string FlagKey { get { return flagKey; } set { this.flagKey = value; } }
+
+        public string RuleKey { get { return ruleKey; } set { this.ruleKey = value; } }
+
+        public string GetDecisionKey { get { return string.Format("{0}-{1}", flagKey, ruleKey ?? OPTI_NULL_RULE_KEY); } }
+    }
+}
diff --git a/OptimizelySDK.Net40/OptimizelyForcedDecision.cs b/OptimizelySDK.Net40/OptimizelyForcedDecision.cs
new file mode 100644
index 00000000..c1dff205
--- /dev/null
+++ b/OptimizelySDK.Net40/OptimizelyForcedDecision.cs
@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace OptimizelySDK
+{
+    public class OptimizelyForcedDecision
+    {
+        private string variationKey;
+
+        public OptimizelyForcedDecision(string variationKey)
+        {
+            this.variationKey = variationKey;
+        }
+
+        public string VariationKey { get { return variationKey; } }
+    }
+}
diff --git a/OptimizelySDK.Net40/OptimizelySDK.Net40.csproj b/OptimizelySDK.Net40/OptimizelySDK.Net40.csproj
index e5c64c6c..a280aec6 100644
--- a/OptimizelySDK.Net40/OptimizelySDK.Net40.csproj
+++ b/OptimizelySDK.Net40/OptimizelySDK.Net40.csproj
@@ -48,28 +48,28 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
-	<Compile Include="..\OptimizelySDK\AudienceConditions\AndCondition.cs">
+    <Compile Include="..\OptimizelySDK\AudienceConditions\AndCondition.cs">
       <Link>AudienceConditions\AndCondition.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\AudienceConditions\AudienceIdCondition.cs">
+    <Compile Include="..\OptimizelySDK\AudienceConditions\AudienceIdCondition.cs">
       <Link>AudienceConditions\AudienceIdCondition.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\AudienceConditions\BaseCondition.cs">
+    <Compile Include="..\OptimizelySDK\AudienceConditions\BaseCondition.cs">
       <Link>AudienceConditions\BaseCondition.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\AudienceConditions\SemanticVersion.cs">
+    <Compile Include="..\OptimizelySDK\AudienceConditions\SemanticVersion.cs">
       <Link>AudienceConditions\SemanticVersion.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\AudienceConditions\EmptyCondition.cs">
+    <Compile Include="..\OptimizelySDK\AudienceConditions\EmptyCondition.cs">
       <Link>AudienceConditions\EmptyCondition.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\AudienceConditions\ICondition.cs">
+    <Compile Include="..\OptimizelySDK\AudienceConditions\ICondition.cs">
       <Link>AudienceConditions\ICondition.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\AudienceConditions\NotCondition.cs">
+    <Compile Include="..\OptimizelySDK\AudienceConditions\NotCondition.cs">
       <Link>AudienceConditions\NotCondition.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\AudienceConditions\OrCondition.cs">
+    <Compile Include="..\OptimizelySDK\AudienceConditions\OrCondition.cs">
       <Link>AudienceConditions\OrCondition.cs</Link>
     </Compile>
     <Compile Include="..\OptimizelySDK\Entity\Attribute.cs">
@@ -102,7 +102,7 @@
     <Compile Include="..\OptimizelySDK\Entity\IdKeyEntity.cs">
       <Link>Entity\IdKeyEntity.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\OptimizelyJSON.cs">
+    <Compile Include="..\OptimizelySDK\OptimizelyJSON.cs">
       <Link>OptimizelyJSON.cs</Link>
     </Compile>
     <Compile Include="..\OptimizelySDK\Entity\TrafficAllocation.cs">
@@ -165,7 +165,7 @@
     <Compile Include="..\OptimizelySDK\Utils\ConfigParser.cs">
       <Link>Utils\ConfigParser.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\Utils\ConditionParser.cs">
+    <Compile Include="..\OptimizelySDK\Utils\ConditionParser.cs">
       <Link>Utils\ConditionParser.cs</Link>
     </Compile>
     <Compile Include="..\OptimizelySDK\Utils\EventTagUtils.cs">
@@ -180,18 +180,20 @@
     <Compile Include="..\OptimizelySDK\Utils\ControlAttributes.cs">
       <Link>Utils\ControlAttributes.cs</Link>
     </Compile>
- 	  <Compile Include="..\OptimizelySDK\Utils\ExceptionExtensions.cs">
+    <Compile Include="..\OptimizelySDK\Utils\ExceptionExtensions.cs">
       <Link>Utils\ExceptionExtensions.cs</Link>
     </Compile>
- 	  <Compile Include="..\OptimizelySDK\Utils\AttributeMatchTypes.cs">
+    <Compile Include="..\OptimizelySDK\Utils\AttributeMatchTypes.cs">
       <Link>Utils\AttributeMatchTypes.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\Utils\DecisionInfoTypes.cs">
+    <Compile Include="..\OptimizelySDK\Utils\DecisionInfoTypes.cs">
       <Link>Utils\DecisionInfoTypes.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\Utils\DateTimeUtils.cs">
+    <Compile Include="..\OptimizelySDK\Utils\DateTimeUtils.cs">
       <Link>Utils\DateTimeUtils.cs</Link>
     </Compile>
+    <Compile Include="OptimizelyDecisionContext.cs" />
+    <Compile Include="OptimizelyForcedDecision.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="..\OptimizelySDK\Bucketing\Bucketer.cs">
       <Link>Bucketing\Bucketer.cs</Link>
@@ -226,126 +228,126 @@
     <Compile Include="..\OptimizelySDK\Entity\Rollout.cs">
       <Link>Entity\Rollout</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\ProjectConfig.cs">
+    <Compile Include="..\OptimizelySDK\ProjectConfig.cs">
       <Link>ProjectConfig</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\Config\DatafileProjectConfig.cs">
+    <Compile Include="..\OptimizelySDK\Config\DatafileProjectConfig.cs">
       <Link>Config\DatafileProjectConfig</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\Config\ProjectConfigManager.cs">
+    <Compile Include="..\OptimizelySDK\Config\ProjectConfigManager.cs">
       <Link>Config\ProjectConfigManager</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\Config\PollingProjectConfigManager.cs">
+    <Compile Include="..\OptimizelySDK\Config\PollingProjectConfigManager.cs">
       <Link>Config\PollingProjectConfigManager</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\ClientConfigHandler.cs">
+    <Compile Include="..\OptimizelySDK\ClientConfigHandler.cs">
       <Link>ClientConfigHandler</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\Config\HttpProjectConfigManager.cs">
+    <Compile Include="..\OptimizelySDK\Config\HttpProjectConfigManager.cs">
       <Link>Config\HttpProjectConfigManager</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\Config\FallbackProjectConfigManager.cs">
-	  <Link>Config\FallbackProjectConfigManager.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\OptimizelyFactory.cs">
-	  <Link>OptimizelyFactory.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\Event\Entity\ConversionEvent.cs">
-	  <Link>Event\Entity\ConversionEvent.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\Event\Entity\Decision.cs">
-	  <Link>Event\Entity\Decision.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\Event\Entity\EventBatch.cs">
-	  <Link>Event\Entity\EventBatch.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\Event\Entity\EventContext.cs">
-	  <Link>Event\Entity\EventContext.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\Event\Entity\ImpressionEvent.cs">
-	  <Link>Event\Entity\ImpressionEvent.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\Event\Entity\Snapshot.cs">
-	  <Link>Event\Entity\Snapshot.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\Event\Entity\SnapshotEvent.cs">
-	  <Link>Event\Entity\SnapshotEvent.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\Event\Entity\UserEvent.cs">
-	  <Link>Event\Entity\UserEvent.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\Event\Entity\Visitor.cs">
-	  <Link>Event\Entity\Visitor.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\Event\Entity\VisitorAttribute.cs">
-	  <Link>Event\Entity\VisitorAttribute.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\Event\Entity\DecisionMetadata.cs">
-	  <Link>Event\Entity\DecisionMetadata.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\Event\EventFactory.cs">
-	  <Link>Event\EventFactory.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\Event\UserEventFactory.cs">
-	  <Link>Event\UserEventFactory.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\Event\BatchEventProcessor.cs">
-	  <Link>Event\BatchEventProcessor.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\Event\EventProcessor.cs">
-	  <Link>Event\EventProcessor.cs</Link>
-	</Compile>
-	<Compile Include="..\OptimizelySDK\Event\ForwardingEventProcessor.cs">
+    <Compile Include="..\OptimizelySDK\Config\FallbackProjectConfigManager.cs">
+      <Link>Config\FallbackProjectConfigManager.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\OptimizelyFactory.cs">
+      <Link>OptimizelyFactory.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\Event\Entity\ConversionEvent.cs">
+      <Link>Event\Entity\ConversionEvent.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\Event\Entity\Decision.cs">
+      <Link>Event\Entity\Decision.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\Event\Entity\EventBatch.cs">
+      <Link>Event\Entity\EventBatch.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\Event\Entity\EventContext.cs">
+      <Link>Event\Entity\EventContext.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\Event\Entity\ImpressionEvent.cs">
+      <Link>Event\Entity\ImpressionEvent.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\Event\Entity\Snapshot.cs">
+      <Link>Event\Entity\Snapshot.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\Event\Entity\SnapshotEvent.cs">
+      <Link>Event\Entity\SnapshotEvent.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\Event\Entity\UserEvent.cs">
+      <Link>Event\Entity\UserEvent.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\Event\Entity\Visitor.cs">
+      <Link>Event\Entity\Visitor.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\Event\Entity\VisitorAttribute.cs">
+      <Link>Event\Entity\VisitorAttribute.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\Event\Entity\DecisionMetadata.cs">
+      <Link>Event\Entity\DecisionMetadata.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\Event\EventFactory.cs">
+      <Link>Event\EventFactory.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\Event\UserEventFactory.cs">
+      <Link>Event\UserEventFactory.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\Event\BatchEventProcessor.cs">
+      <Link>Event\BatchEventProcessor.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\Event\EventProcessor.cs">
+      <Link>Event\EventProcessor.cs</Link>
+    </Compile>
+    <Compile Include="..\OptimizelySDK\Event\ForwardingEventProcessor.cs">
       <Link>Event\ForwardingEventProcessor.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyConfig.cs">
+    <Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyConfig.cs">
       <Link>OptlyConfig\OptimizelyConfig.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyAttribute.cs">
+    <Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyAttribute.cs">
       <Link>OptlyConfig\OptimizelyAttribute.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyEvent.cs">
+    <Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyEvent.cs">
       <Link>OptlyConfig\OptimizelyEvent.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyExperiment.cs">
+    <Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyExperiment.cs">
       <Link>OptlyConfig\OptimizelyExperiment.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyFeature.cs">
+    <Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyFeature.cs">
       <Link>OptlyConfig\OptimizelyFeature.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyVariable.cs">
+    <Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyVariable.cs">
       <Link>OptlyConfig\OptimizelyVariable.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyVariation.cs">
+    <Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyVariation.cs">
       <Link>OptlyConfig\OptimizelyVariation.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyAudience.cs">
+    <Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyAudience.cs">
       <Link>OptlyConfig\OptimizelyAudience.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyConfigService.cs">
+    <Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyConfigService.cs">
       <Link>OptlyConfig\OptimizelyConfigService.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\OptlyConfig\IOptimizelyConfigManager.cs">
+    <Compile Include="..\OptimizelySDK\OptlyConfig\IOptimizelyConfigManager.cs">
       <Link>OptlyConfig\IOptimizelyConfigManager.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\OptimizelyDecisions\DecisionMessage.cs">
+    <Compile Include="..\OptimizelySDK\OptimizelyDecisions\DecisionMessage.cs">
       <Link>OptimizelyDecisions\DecisionMessage.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\OptimizelyDecisions\DecisionReasons.cs">
+    <Compile Include="..\OptimizelySDK\OptimizelyDecisions\DecisionReasons.cs">
       <Link>OptimizelyDecisions\DecisionReasons.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\OptimizelyDecisions\OptimizelyDecideOption.cs">
+    <Compile Include="..\OptimizelySDK\OptimizelyDecisions\OptimizelyDecideOption.cs">
       <Link>OptimizelyDecisions\OptimizelyDecideOption.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\OptimizelyDecisions\OptimizelyDecision.cs">
+    <Compile Include="..\OptimizelySDK\OptimizelyDecisions\OptimizelyDecision.cs">
       <Link>OptimizelyDecisions\OptimizelyDecision.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\OptimizelyUserContext.cs">
+    <Compile Include="..\OptimizelySDK\OptimizelyUserContext.cs">
       <Link>OptimizelyUserContext.cs</Link>
     </Compile>
-	<Compile Include="..\OptimizelySDK\Entity\Result.cs">
-	  <Link>Entity\Result.cs</Link>
-	</Compile>
+    <Compile Include="..\OptimizelySDK\Entity\Result.cs">
+      <Link>Entity\Result.cs</Link>
+    </Compile>
   </ItemGroup>
   <ItemGroup>
     <None Include="..\OptimizelySDK\Utils\schema.json">
diff --git a/OptimizelySDK.NetStandard16/OptimizelyDecisionContext.cs b/OptimizelySDK.NetStandard16/OptimizelyDecisionContext.cs
new file mode 100644
index 00000000..ffce1940
--- /dev/null
+++ b/OptimizelySDK.NetStandard16/OptimizelyDecisionContext.cs
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2020-2021, Optimizely
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace OptimizelySDK
+{
+    public class OptimizelyDecisionContext
+    {
+        public const string OPTI_NULL_RULE_KEY = "$opt-null-rule-key";
+        private string flagKey;
+        private string ruleKey;
+
+        public OptimizelyDecisionContext(string flagKey, string ruleKey, string variationKey)
+        {
+            this.flagKey = flagKey;
+            this.ruleKey = ruleKey;
+        }
+
+        public string FlagKey { get { return flagKey; } set { this.flagKey = value; } }
+
+        public string RuleKey { get { return ruleKey; } set { this.ruleKey = value; } }
+
+        public string GetDecisionKey { get { return string.Format("{0}-{1}", flagKey, ruleKey ?? OPTI_NULL_RULE_KEY); } }
+    }
+}
diff --git a/OptimizelySDK.NetStandard16/OptimizelyForcedDecision.cs b/OptimizelySDK.NetStandard16/OptimizelyForcedDecision.cs
new file mode 100644
index 00000000..c1dff205
--- /dev/null
+++ b/OptimizelySDK.NetStandard16/OptimizelyForcedDecision.cs
@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace OptimizelySDK
+{
+    public class OptimizelyForcedDecision
+    {
+        private string variationKey;
+
+        public OptimizelyForcedDecision(string variationKey)
+        {
+            this.variationKey = variationKey;
+        }
+
+        public string VariationKey { get { return variationKey; } }
+    }
+}
diff --git a/OptimizelySDK.NetStandard20/OptimizelyDecisionContext.cs b/OptimizelySDK.NetStandard20/OptimizelyDecisionContext.cs
new file mode 100644
index 00000000..ffce1940
--- /dev/null
+++ b/OptimizelySDK.NetStandard20/OptimizelyDecisionContext.cs
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2020-2021, Optimizely
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace OptimizelySDK
+{
+    public class OptimizelyDecisionContext
+    {
+        public const string OPTI_NULL_RULE_KEY = "$opt-null-rule-key";
+        private string flagKey;
+        private string ruleKey;
+
+        public OptimizelyDecisionContext(string flagKey, string ruleKey, string variationKey)
+        {
+            this.flagKey = flagKey;
+            this.ruleKey = ruleKey;
+        }
+
+        public string FlagKey { get { return flagKey; } set { this.flagKey = value; } }
+
+        public string RuleKey { get { return ruleKey; } set { this.ruleKey = value; } }
+
+        public string GetDecisionKey { get { return string.Format("{0}-{1}", flagKey, ruleKey ?? OPTI_NULL_RULE_KEY); } }
+    }
+}
diff --git a/OptimizelySDK.NetStandard20/OptimizelyForcedDecision.cs b/OptimizelySDK.NetStandard20/OptimizelyForcedDecision.cs
new file mode 100644
index 00000000..c1dff205
--- /dev/null
+++ b/OptimizelySDK.NetStandard20/OptimizelyForcedDecision.cs
@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace OptimizelySDK
+{
+    public class OptimizelyForcedDecision
+    {
+        private string variationKey;
+
+        public OptimizelyForcedDecision(string variationKey)
+        {
+            this.variationKey = variationKey;
+        }
+
+        public string VariationKey { get { return variationKey; } }
+    }
+}
diff --git a/OptimizelySDK/OptimizelyDecisionContext.cs b/OptimizelySDK/OptimizelyDecisionContext.cs
new file mode 100644
index 00000000..ffce1940
--- /dev/null
+++ b/OptimizelySDK/OptimizelyDecisionContext.cs
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2020-2021, Optimizely
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace OptimizelySDK
+{
+    public class OptimizelyDecisionContext
+    {
+        public const string OPTI_NULL_RULE_KEY = "$opt-null-rule-key";
+        private string flagKey;
+        private string ruleKey;
+
+        public OptimizelyDecisionContext(string flagKey, string ruleKey, string variationKey)
+        {
+            this.flagKey = flagKey;
+            this.ruleKey = ruleKey;
+        }
+
+        public string FlagKey { get { return flagKey; } set { this.flagKey = value; } }
+
+        public string RuleKey { get { return ruleKey; } set { this.ruleKey = value; } }
+
+        public string GetDecisionKey { get { return string.Format("{0}-{1}", flagKey, ruleKey ?? OPTI_NULL_RULE_KEY); } }
+    }
+}
diff --git a/OptimizelySDK/OptimizelyForcedDecision.cs b/OptimizelySDK/OptimizelyForcedDecision.cs
new file mode 100644
index 00000000..c1dff205
--- /dev/null
+++ b/OptimizelySDK/OptimizelyForcedDecision.cs
@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace OptimizelySDK
+{
+    public class OptimizelyForcedDecision
+    {
+        private string variationKey;
+
+        public OptimizelyForcedDecision(string variationKey)
+        {
+            this.variationKey = variationKey;
+        }
+
+        public string VariationKey { get { return variationKey; } }
+    }
+}
diff --git a/OptimizelySDK/OptimizelySDK.csproj b/OptimizelySDK/OptimizelySDK.csproj
index 50f8b137..e151529a 100644
--- a/OptimizelySDK/OptimizelySDK.csproj
+++ b/OptimizelySDK/OptimizelySDK.csproj
@@ -91,6 +91,7 @@
     <Compile Include="OptimizelyDecisions\DecisionReasons.cs" />
     <Compile Include="OptimizelyDecisions\OptimizelyDecideOption.cs" />
     <Compile Include="OptimizelyDecisions\OptimizelyDecision.cs" />
+    <Compile Include="OptimizelyForcedDecision.cs" />
     <Compile Include="OptimizelyUserContext.cs" />
     <Compile Include="OptimizelyJSON.cs" />
     <Compile Include="Entity\Rollout.cs" />
@@ -120,6 +121,7 @@
     <Compile Include="Notifications\NotificationCenter.cs" />
     <Compile Include="Optimizely.cs" />
     <Compile Include="Bucketing\UserProfile.cs" />
+    <Compile Include="OptimizelyDecisionContext.cs" />
     <Compile Include="OptlyConfig\IOptimizelyConfigManager.cs" />
     <Compile Include="OptlyConfig\OptimizelyEvent.cs" />
     <Compile Include="OptlyConfig\OptimizelyAttribute.cs" />
diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index a360d72c..f7b2a073 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -26,28 +26,8 @@ namespace OptimizelySDK
     /// <summary>
     /// OptimizelyUserContext defines user contexts that the SDK will use to make decisions for
     /// </summary>
-    public class OptimizelyUserContext
+    public partial class OptimizelyUserContext
     {
-        public class OptimizelyForcedDecision
-        {
-            private string flagKey;
-            private string ruleKey;
-            private string variationKey;
-
-            public OptimizelyForcedDecision(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 const string nullRuleKey = "HardCodedNullRuleKey";
 
         private ILogger Logger;
@@ -259,10 +239,11 @@ public bool SetForcedDecision(string flagKey, string ruleKey, string variationKe
 
             lock (mutex)
             {
-                ForcedDecisionsMap[flagKey] = new Dictionary<string, OptimizelyForcedDecision> {
+                ForcedDecisionsMap[flagKey] = new Dictionary<string, OptimizelyForcedDecision>
                 {
-                    ruleKey ?? nullRuleKey, new OptimizelyForcedDecision(flagKey, ruleKey, variationKey)
-                }
+                    {
+                        ruleKey ?? nullRuleKey, new OptimizelyForcedDecision(variationKey)
+                    }
                 };
             }
 

From 692ee26ad1fe8d65257dd417971574e41fa29e6d Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Wed, 27 Oct 2021 09:42:42 -0400
Subject: [PATCH 056/130] added copyright language

---
 .../OptimizelyUserContextTest.cs              | 91 ++++++++++++-------
 OptimizelySDK/Optimizely.cs                   |  3 +-
 OptimizelySDK/OptimizelyDecisionContext.cs    | 10 +-
 OptimizelySDK/OptimizelyForcedDecision.cs     | 20 +++-
 OptimizelySDK/OptimizelyUserContext.cs        | 48 ++++------
 5 files changed, 99 insertions(+), 73 deletions(-)

diff --git a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
index eaa307a8..6067874a 100644
--- a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
@@ -189,8 +189,9 @@ public void TestDecide()
         public void TestSetForcedDecisionSetsValue()
         {
             var user = Optimizely.CreateUserContext(UserID);
-
-            var result = user.SetForcedDecision("flag", "variation");
+            var context = new OptimizelyDecisionContext("flag", null);
+            var decision = new OptimizelyForcedDecision("variationKey");
+            var result = user.SetForcedDecision(context, decision);
 
             Assert.IsTrue(result);
         }
@@ -201,7 +202,10 @@ public void TestSetForcedDecisionReturnsFalseForNullConfig()
             var optly = new Optimizely(new FallbackProjectConfigManager(null));
 
             var user = optly.CreateUserContext(UserID);
-            var result = user.SetForcedDecision("flag", "variation");
+
+            var context = new OptimizelyDecisionContext("flag", null);
+            var decision = new OptimizelyForcedDecision("variationKey");
+            var result = user.SetForcedDecision(context, decision);
 
             Assert.IsFalse(result);
             //TODO: should assert logger is called
@@ -221,10 +225,11 @@ public void TestGetForcedDecisionReturnsNullWithNullFlagKey()
         public void TestGetForcedDecisionsReturnsValueWithRuleKey()
         {
             var user = Optimizely.CreateUserContext(UserID);
+            var context = new OptimizelyDecisionContext("flagKey", "ruleKey");
+            var decision = new OptimizelyForcedDecision("variation");
+            user.SetForcedDecision(context, decision);
 
-            user.SetForcedDecision("flagKey", "ruleKey", "variation");
-
-            var result = user.GetForcedDecision("flagKey", "ruleKey");
+            var result = user.GetForcedDecision(context);
 
             Assert.AreEqual("variation", result);
         }
@@ -233,36 +238,39 @@ public void TestGetForcedDecisionsReturnsValueWithRuleKey()
         public void TestGetForcedDecisionReturnsValueWithoutRuleKey()
         {
             var user = Optimizely.CreateUserContext(UserID);
+            var context = new OptimizelyDecisionContext("flagKey", null);
+            var decision = new OptimizelyForcedDecision("variationKey");
+            user.SetForcedDecision(context, decision);
 
-            user.SetForcedDecision("flagKey", "variation");
-
-            var result = user.GetForcedDecision("flagKey", null);
+            var result = user.GetForcedDecision(context);
 
-            Assert.AreEqual("variation", result);
+            Assert.AreEqual("variationKey", result);
         }
 
         [Test]
         public void TestGetForcedDecisionReturnsValueWithOnlyFlagKey()
         {
             var user = Optimizely.CreateUserContext(UserID);
+            var context = new OptimizelyDecisionContext("flagKey", null);
+            var decision = new OptimizelyForcedDecision("variationKey");
+            user.SetForcedDecision(context, decision);
 
-            user.SetForcedDecision("flagKey", "variation");
-
-            var result = user.GetForcedDecision("flagKey");
+            var result = user.GetForcedDecision(context);
 
-            Assert.AreEqual("variation", result);
+            Assert.AreEqual("variationKey", result);
         }
 
         [Test]
         public void TestGetForcedDecisionReturnsValueWithRuleKey()
         {
             var user = Optimizely.CreateUserContext(UserID);
+            var context = new OptimizelyDecisionContext("flagKey", "ruleKey");
+            var decision = new OptimizelyForcedDecision("variationKey");
+            user.SetForcedDecision(context, decision);
 
-            user.SetForcedDecision("flagKey", "rule", "variation");
+            var result = user.GetForcedDecision(context);
 
-            var result = user.GetForcedDecision("flagKey", "rule");
-
-            Assert.AreEqual("variation", result);
+            Assert.AreEqual("variationKey", result);
         }
 
         [Test]
@@ -273,9 +281,11 @@ public void TestFindValidatedForcedDecisionReturnsCorrectDecision()
             var expectedResult = Result<Variation>.NewResult(new Variation { }, decisionReasons);
             var user = Optimizely.CreateUserContext(UserID);
 
-            user.SetForcedDecision("flagKey", "rule", "variation");
+            var context = new OptimizelyDecisionContext("flagKey", "ruleKey");
+            var decision = new OptimizelyForcedDecision("variationKey");
+            user.SetForcedDecision(context, decision);
 
-            var result = user.FindValidatedForcedDecision("flagKey", "rule");
+            var result = user.FindValidatedForcedDecision(context);
 
             Assertions.AreEqual(expectedResult, result);
         }
@@ -292,12 +302,15 @@ public void TestRemoveForcedDecisionReturnsFalseForNullFlagKey()
         public void TestRemoveForcedDecisionRemovesDecision()
         {
             var user = Optimizely.CreateUserContext(UserID);
+            var context = new OptimizelyDecisionContext("flagKey", "ruleKey");
+            var decision = new OptimizelyForcedDecision("variationKey");
+            var setResult = user.SetForcedDecision(context, decision);
 
-            user.SetForcedDecision("flagKey", "ruleKey", "variation");
+            Assert.IsTrue(setResult);
 
-            user.RemoveForcedDecision("flagKey", "ruleKey");
+            user.RemoveForcedDecision(context);
 
-            var result = user.GetForcedDecision("flagKey", "ruleKey");
+            var result = user.GetForcedDecision(context);
 
             Assert.AreEqual(null, result);
         }
@@ -308,9 +321,12 @@ public void TestRemoveForcedDecisionReturnsFalseForNullConfig()
             var optly = new Optimizely(new FallbackProjectConfigManager(null));
 
             var user = optly.CreateUserContext(UserID);
-            user.SetForcedDecision("flagKey", "variation");
 
-            var result = user.RemoveForcedDecision("flagKey", null);
+            var context = new OptimizelyDecisionContext("flagKey", null);
+            var decision = new OptimizelyForcedDecision("variationKey");
+            var setResult = user.SetForcedDecision(context, decision);
+
+            var result = user.RemoveForcedDecision(context);
 
             Assert.AreEqual(false, result);
         }
@@ -320,19 +336,27 @@ public void TestRemoveAllForcedDecisionsRemovesDecisions()
         {
             var user = Optimizely.CreateUserContext(UserID);
 
-            user.SetForcedDecision("flagKey", "ruleKey", "variation");
-            user.SetForcedDecision("flagKey2", "ruleKey2", "variation2");
-            user.SetForcedDecision("flagKey3", "ruleKey3", "variation3");
+            var context1 = new OptimizelyDecisionContext("flagKey", "ruleKey1");
+            var context2 = new OptimizelyDecisionContext("flagKey2", "ruleKey2");
+            var context3 = new OptimizelyDecisionContext("flagKey3", "ruleKey3");
+
+            var decision1 = new OptimizelyForcedDecision("variation");
+            var decision2 = new OptimizelyForcedDecision("variation2");
+            var decision3 = new OptimizelyForcedDecision("variation3");
+
+            user.SetForcedDecision(context1, decision1);
+            user.SetForcedDecision(context2, decision2);
+            user.SetForcedDecision(context3, decision3);
 
             user.RemoveAllForcedDecisions();
 
-            var result1 = user.GetForcedDecision("flagKey", null);
+            var result1 = user.GetForcedDecision(context1);
             Assert.AreEqual(null, result1);
 
-            var result2 = user.GetForcedDecision("flagKey2", null);
+            var result2 = user.GetForcedDecision(context2);
             Assert.AreEqual(null, result2);
 
-            var result3 = user.GetForcedDecision("flagKey3", null);
+            var result3 = user.GetForcedDecision(context3);
             Assert.AreEqual(null, result3);
         }
 
@@ -342,7 +366,10 @@ public void TestRemoveAllForcedDecisionsReturnsFalseForNullConfig()
             var optly = new Optimizely(new FallbackProjectConfigManager(null));
 
             var user = optly.CreateUserContext(UserID);
-            user.SetForcedDecision("flagKey", "variation");
+
+            var context = new OptimizelyDecisionContext("flagKey");
+            var decision = new OptimizelyForcedDecision("variation");
+            user.SetForcedDecision(context, decision);
 
             var result = user.RemoveAllForcedDecisions();
 
diff --git a/OptimizelySDK/Optimizely.cs b/OptimizelySDK/Optimizely.cs
index 78a47cb3..e455ed7d 100644
--- a/OptimizelySDK/Optimizely.cs
+++ b/OptimizelySDK/Optimizely.cs
@@ -759,7 +759,8 @@ internal OptimizelyDecision Decide(OptimizelyUserContext user,
             var decisionReasons = new DecisionReasons();
             FeatureDecision decision = null;
 
-            var forcedDecisionVariation = user.FindValidatedForcedDecision(flag.Key, null);
+            var decisionContext = new OptimizelyDecisionContext(flag.Key);
+            var forcedDecisionVariation = user.FindValidatedForcedDecision(decisionContext);
             if (forcedDecisionVariation?.ResultObject != null)
             {
                 decision = new FeatureDecision(null, forcedDecisionVariation.ResultObject, FeatureDecision.DECISION_SOURCE_FEATURE_TEST);
diff --git a/OptimizelySDK/OptimizelyDecisionContext.cs b/OptimizelySDK/OptimizelyDecisionContext.cs
index ffce1940..2e74cc15 100644
--- a/OptimizelySDK/OptimizelyDecisionContext.cs
+++ b/OptimizelySDK/OptimizelyDecisionContext.cs
@@ -21,17 +21,19 @@ public class OptimizelyDecisionContext
         public const string OPTI_NULL_RULE_KEY = "$opt-null-rule-key";
         private string flagKey;
         private string ruleKey;
+        private string decisionKey;
 
-        public OptimizelyDecisionContext(string flagKey, string ruleKey, string variationKey)
+        public OptimizelyDecisionContext(string flagKey, string ruleKey = null)
         {
             this.flagKey = flagKey;
             this.ruleKey = ruleKey;
+            this.decisionKey = string.Format("{0}-{1}", flagKey, ruleKey ?? OPTI_NULL_RULE_KEY);
         }
 
-        public string FlagKey { get { return flagKey; } set { this.flagKey = value; } }
+        public string FlagKey { get { return flagKey; } }
 
-        public string RuleKey { get { return ruleKey; } set { this.ruleKey = value; } }
+        public string RuleKey { get { return ruleKey; } }
 
-        public string GetDecisionKey { get { return string.Format("{0}-{1}", flagKey, ruleKey ?? OPTI_NULL_RULE_KEY); } }
+        public string GetDecisionKey { get { return decisionKey; } }
     }
 }
diff --git a/OptimizelySDK/OptimizelyForcedDecision.cs b/OptimizelySDK/OptimizelyForcedDecision.cs
index c1dff205..db5f1850 100644
--- a/OptimizelySDK/OptimizelyForcedDecision.cs
+++ b/OptimizelySDK/OptimizelyForcedDecision.cs
@@ -1,8 +1,18 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+/*
+ * Copyright 2020-2021, Optimizely
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 namespace OptimizelySDK
 {
diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index f7b2a073..50b972ce 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -28,8 +28,6 @@ namespace OptimizelySDK
     /// </summary>
     public partial class OptimizelyUserContext
     {
-        private const string nullRuleKey = "HardCodedNullRuleKey";
-
         private ILogger Logger;
         private IErrorHandler ErrorHandler;
         private object mutex = new object();
@@ -210,18 +208,6 @@ public virtual void TrackEvent(string eventName,
             Optimizely.Track(eventName, UserId, Attributes, eventTags);
         }
 
-        /// <summary>
-        /// Set a forced decision.
-        /// </summary>
-        /// <param name="flagKey">The flag key.</param>
-        /// <param name="variationKey">The variation key.</param>
-        /// <returns></returns>
-
-        public bool SetForcedDecision(string flagKey, string variationKey)
-        {
-            return SetForcedDecision(flagKey, null, variationKey);
-        }
-
         /// <summary>
         /// Set a forced decision.
         /// </summary>
@@ -229,7 +215,7 @@ public bool SetForcedDecision(string flagKey, string variationKey)
         /// <param name="ruleKey">The rule key.</param>
         /// <param name="variationKey">The variation key.</param>
         /// <returns></returns>
-        public bool SetForcedDecision(string flagKey, string ruleKey, string variationKey)
+        public bool SetForcedDecision(OptimizelyDecisionContext context, OptimizelyForcedDecision decision)
         {
             if (!Optimizely.IsValid)
             {
@@ -239,10 +225,10 @@ public bool SetForcedDecision(string flagKey, string ruleKey, string variationKe
 
             lock (mutex)
             {
-                ForcedDecisionsMap[flagKey] = new Dictionary<string, OptimizelyForcedDecision>
+                ForcedDecisionsMap[context.FlagKey] = new Dictionary<string, OptimizelyForcedDecision>
                 {
                     {
-                        ruleKey ?? nullRuleKey, new OptimizelyForcedDecision(variationKey)
+                        context.RuleKey ?? OptimizelyDecisionContext.OPTI_NULL_RULE_KEY, new OptimizelyForcedDecision(decision.VariationKey)
                     }
                 };
             }
@@ -256,7 +242,7 @@ public bool SetForcedDecision(string flagKey, string ruleKey, string variationKe
         /// <param name="flagKey">The flag key</param>
         /// <param name="ruleKey">The rule key</param>
         /// <returns>The variation key for a forced decision</returns>
-        public string GetForcedDecision(string flagKey, string ruleKey = null)
+        public string GetForcedDecision(OptimizelyDecisionContext context)
         {
             if (!Optimizely.IsValid)
             {
@@ -264,7 +250,7 @@ public string GetForcedDecision(string flagKey, string ruleKey = null)
                 return null;
             }
 
-            if (string.IsNullOrEmpty(flagKey))
+            if (context == null || string.IsNullOrEmpty(context.FlagKey))
             {
                 Logger.Log(LogLevel.WARN, "flagkey cannot be null");
                 return null;
@@ -274,9 +260,9 @@ public string GetForcedDecision(string flagKey, string ruleKey = null)
 
             lock (mutex)
             {
-                if (ForcedDecisionsMap.TryGetValue(flagKey, out var forcedDecisionMap))
+                if (ForcedDecisionsMap.TryGetValue(context.FlagKey, out var forcedDecisionMap))
                 {
-                    if (forcedDecisionMap.TryGetValue(ruleKey ?? nullRuleKey, out var forcedDecision))
+                    if (forcedDecisionMap.TryGetValue(context.RuleKey ?? OptimizelyDecisionContext.OPTI_NULL_RULE_KEY, out var forcedDecision))
                     {
                         variationKey = forcedDecision.VariationKey;
                     }
@@ -291,9 +277,9 @@ public string GetForcedDecision(string flagKey, string ruleKey = null)
         /// <param name="flagKey">The flag key.</param>
         /// <param name="ruleKey"></param>
         /// <returns>Whether the item was removed.</returns>
-        public bool RemoveForcedDecision(string flagKey, string ruleKey = null)
+        public bool RemoveForcedDecision(OptimizelyDecisionContext context)
         {
-            if (string.IsNullOrEmpty(flagKey))
+            if (context == null || string.IsNullOrEmpty(context.FlagKey))
             {
                 Logger.Log(LogLevel.WARN, "flagKey cannot be null");
                 return false;
@@ -305,12 +291,12 @@ public bool RemoveForcedDecision(string flagKey, string ruleKey = null)
                 return false;
             }
 
-            if (ForcedDecisionsMap.TryGetValue(flagKey, out var decision))
+            if (ForcedDecisionsMap.TryGetValue(context.FlagKey, out var decision))
             {
-                decision.Remove(ruleKey);
+                decision.Remove(context.RuleKey);
                 if (decision.Count == 0)
                 {
-                    ForcedDecisionsMap.Remove(flagKey);
+                    ForcedDecisionsMap.Remove(context.FlagKey);
                 }
             }
             return true;
@@ -338,26 +324,26 @@ public bool RemoveAllForcedDecisions()
         /// <param name="flagKey">The flag key.</param>
         /// <param name="ruleKey">The rule key.</param>
         /// <returns>A result with the variation</returns>
-        public Result<Variation> FindValidatedForcedDecision(string flagKey, string ruleKey = null)
+        public Result<Variation> FindValidatedForcedDecision(OptimizelyDecisionContext context)
         {
             DecisionReasons reasons = new DecisionReasons();
 
-            string variationKey = GetForcedDecision(flagKey, ruleKey);
+            string variationKey = GetForcedDecision(context);
             if (variationKey != null)
             {
                 Variation variation = new Variation();
-                string strRuleKey = ruleKey ?? "null";
+                string strRuleKey = context.RuleKey ?? OptimizelyDecisionContext.OPTI_NULL_RULE_KEY;
                 string info;
                 if (variation != null)
                 {
-                    info = string.Format("Variation {0} is mapped to flag: {1} and rule: {2} in the forced decision map.", variationKey, flagKey, strRuleKey);
+                    info = string.Format("Variation {0} is mapped to flag: {1} and rule: {2} in the forced decision map.", variationKey, context.FlagKey, strRuleKey);
                     Logger.Log(LogLevel.INFO, info);
                     reasons.AddInfo(info);
                     return Result<Variation>.NewResult(variation, reasons);
                 }
                 else
                 {
-                    info = string.Format("Invalid variation is mapped to flag: {0} and rule: {1} forced decision map.", flagKey, strRuleKey);
+                    info = string.Format("Invalid variation is mapped to flag: {0} and rule: {1} forced decision map.", context.FlagKey, strRuleKey);
                     Logger.Log(LogLevel.INFO, info);
                     reasons.AddInfo(info);
                 }

From cbbe452464e2d64f97a450a151e23f88e3e2de25 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Tue, 2 Nov 2021 12:17:32 -0400
Subject: [PATCH 057/130] changed error messages to be consistent

---
 OptimizelySDK/OptimizelyUserContext.cs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index 50b972ce..0ba0c589 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -219,7 +219,7 @@ public bool SetForcedDecision(OptimizelyDecisionContext context, OptimizelyForce
         {
             if (!Optimizely.IsValid)
             {
-                Logger.Log(LogLevel.ERROR, "Optimizely config is null");
+                Logger.Log(LogLevel.ERROR, DecisionMessage.SDK_NOT_READY);
                 return false;
             }
 
@@ -246,13 +246,13 @@ public string GetForcedDecision(OptimizelyDecisionContext context)
         {
             if (!Optimizely.IsValid)
             {
-                Logger.Log(LogLevel.ERROR, "Optimizely SDK not ready.");
+                Logger.Log(LogLevel.ERROR, DecisionMessage.SDK_NOT_READY);
                 return null;
             }
 
             if (context == null || string.IsNullOrEmpty(context.FlagKey))
             {
-                Logger.Log(LogLevel.WARN, "flagkey cannot be null");
+                Logger.Log(LogLevel.WARN, "flagKey cannot be null");
                 return null;
             }
 
@@ -287,7 +287,7 @@ public bool RemoveForcedDecision(OptimizelyDecisionContext context)
 
             if (!Optimizely.IsValid)
             {
-                Logger.Log(LogLevel.ERROR, "Optimizely SDK not ready.");
+                Logger.Log(LogLevel.ERROR, DecisionMessage.SDK_NOT_READY);
                 return false;
             }
 
@@ -310,7 +310,7 @@ public bool RemoveAllForcedDecisions()
         {
             if (!Optimizely.IsValid)
             {
-                Logger.Log(LogLevel.ERROR, "Optimizely SDK not ready.");
+                Logger.Log(LogLevel.ERROR, DecisionMessage.SDK_NOT_READY);
                 return false;
             }
 

From 19eb3da168efaa13942dcd61370187620083560d Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Tue, 2 Nov 2021 12:31:50 -0400
Subject: [PATCH 058/130] Updated additional project files

---
 OptimizelySDK.Net35/OptimizelyDecisionContext.cs       | 10 ++++++----
 OptimizelySDK.Net40/OptimizelyDecisionContext.cs       | 10 ++++++----
 .../OptimizelyDecisionContext.cs                       | 10 ++++++----
 .../OptimizelyDecisionContext.cs                       | 10 ++++++----
 OptimizelySDK/OptlyConfig/OptimizelyConfigService.cs   |  6 ------
 5 files changed, 24 insertions(+), 22 deletions(-)

diff --git a/OptimizelySDK.Net35/OptimizelyDecisionContext.cs b/OptimizelySDK.Net35/OptimizelyDecisionContext.cs
index ffce1940..2e74cc15 100644
--- a/OptimizelySDK.Net35/OptimizelyDecisionContext.cs
+++ b/OptimizelySDK.Net35/OptimizelyDecisionContext.cs
@@ -21,17 +21,19 @@ public class OptimizelyDecisionContext
         public const string OPTI_NULL_RULE_KEY = "$opt-null-rule-key";
         private string flagKey;
         private string ruleKey;
+        private string decisionKey;
 
-        public OptimizelyDecisionContext(string flagKey, string ruleKey, string variationKey)
+        public OptimizelyDecisionContext(string flagKey, string ruleKey = null)
         {
             this.flagKey = flagKey;
             this.ruleKey = ruleKey;
+            this.decisionKey = string.Format("{0}-{1}", flagKey, ruleKey ?? OPTI_NULL_RULE_KEY);
         }
 
-        public string FlagKey { get { return flagKey; } set { this.flagKey = value; } }
+        public string FlagKey { get { return flagKey; } }
 
-        public string RuleKey { get { return ruleKey; } set { this.ruleKey = value; } }
+        public string RuleKey { get { return ruleKey; } }
 
-        public string GetDecisionKey { get { return string.Format("{0}-{1}", flagKey, ruleKey ?? OPTI_NULL_RULE_KEY); } }
+        public string GetDecisionKey { get { return decisionKey; } }
     }
 }
diff --git a/OptimizelySDK.Net40/OptimizelyDecisionContext.cs b/OptimizelySDK.Net40/OptimizelyDecisionContext.cs
index ffce1940..2e74cc15 100644
--- a/OptimizelySDK.Net40/OptimizelyDecisionContext.cs
+++ b/OptimizelySDK.Net40/OptimizelyDecisionContext.cs
@@ -21,17 +21,19 @@ public class OptimizelyDecisionContext
         public const string OPTI_NULL_RULE_KEY = "$opt-null-rule-key";
         private string flagKey;
         private string ruleKey;
+        private string decisionKey;
 
-        public OptimizelyDecisionContext(string flagKey, string ruleKey, string variationKey)
+        public OptimizelyDecisionContext(string flagKey, string ruleKey = null)
         {
             this.flagKey = flagKey;
             this.ruleKey = ruleKey;
+            this.decisionKey = string.Format("{0}-{1}", flagKey, ruleKey ?? OPTI_NULL_RULE_KEY);
         }
 
-        public string FlagKey { get { return flagKey; } set { this.flagKey = value; } }
+        public string FlagKey { get { return flagKey; } }
 
-        public string RuleKey { get { return ruleKey; } set { this.ruleKey = value; } }
+        public string RuleKey { get { return ruleKey; } }
 
-        public string GetDecisionKey { get { return string.Format("{0}-{1}", flagKey, ruleKey ?? OPTI_NULL_RULE_KEY); } }
+        public string GetDecisionKey { get { return decisionKey; } }
     }
 }
diff --git a/OptimizelySDK.NetStandard16/OptimizelyDecisionContext.cs b/OptimizelySDK.NetStandard16/OptimizelyDecisionContext.cs
index ffce1940..2e74cc15 100644
--- a/OptimizelySDK.NetStandard16/OptimizelyDecisionContext.cs
+++ b/OptimizelySDK.NetStandard16/OptimizelyDecisionContext.cs
@@ -21,17 +21,19 @@ public class OptimizelyDecisionContext
         public const string OPTI_NULL_RULE_KEY = "$opt-null-rule-key";
         private string flagKey;
         private string ruleKey;
+        private string decisionKey;
 
-        public OptimizelyDecisionContext(string flagKey, string ruleKey, string variationKey)
+        public OptimizelyDecisionContext(string flagKey, string ruleKey = null)
         {
             this.flagKey = flagKey;
             this.ruleKey = ruleKey;
+            this.decisionKey = string.Format("{0}-{1}", flagKey, ruleKey ?? OPTI_NULL_RULE_KEY);
         }
 
-        public string FlagKey { get { return flagKey; } set { this.flagKey = value; } }
+        public string FlagKey { get { return flagKey; } }
 
-        public string RuleKey { get { return ruleKey; } set { this.ruleKey = value; } }
+        public string RuleKey { get { return ruleKey; } }
 
-        public string GetDecisionKey { get { return string.Format("{0}-{1}", flagKey, ruleKey ?? OPTI_NULL_RULE_KEY); } }
+        public string GetDecisionKey { get { return decisionKey; } }
     }
 }
diff --git a/OptimizelySDK.NetStandard20/OptimizelyDecisionContext.cs b/OptimizelySDK.NetStandard20/OptimizelyDecisionContext.cs
index ffce1940..2e74cc15 100644
--- a/OptimizelySDK.NetStandard20/OptimizelyDecisionContext.cs
+++ b/OptimizelySDK.NetStandard20/OptimizelyDecisionContext.cs
@@ -21,17 +21,19 @@ public class OptimizelyDecisionContext
         public const string OPTI_NULL_RULE_KEY = "$opt-null-rule-key";
         private string flagKey;
         private string ruleKey;
+        private string decisionKey;
 
-        public OptimizelyDecisionContext(string flagKey, string ruleKey, string variationKey)
+        public OptimizelyDecisionContext(string flagKey, string ruleKey = null)
         {
             this.flagKey = flagKey;
             this.ruleKey = ruleKey;
+            this.decisionKey = string.Format("{0}-{1}", flagKey, ruleKey ?? OPTI_NULL_RULE_KEY);
         }
 
-        public string FlagKey { get { return flagKey; } set { this.flagKey = value; } }
+        public string FlagKey { get { return flagKey; } }
 
-        public string RuleKey { get { return ruleKey; } set { this.ruleKey = value; } }
+        public string RuleKey { get { return ruleKey; } }
 
-        public string GetDecisionKey { get { return string.Format("{0}-{1}", flagKey, ruleKey ?? OPTI_NULL_RULE_KEY); } }
+        public string GetDecisionKey { get { return decisionKey; } }
     }
 }
diff --git a/OptimizelySDK/OptlyConfig/OptimizelyConfigService.cs b/OptimizelySDK/OptlyConfig/OptimizelyConfigService.cs
index 1b837580..3f65afdd 100644
--- a/OptimizelySDK/OptlyConfig/OptimizelyConfigService.cs
+++ b/OptimizelySDK/OptlyConfig/OptimizelyConfigService.cs
@@ -45,7 +45,6 @@ public OptimizelyConfigService(ProjectConfig projectConfig)
 
             var featureMap = GetFeaturesMap(projectConfig, experimentsMapById);
             var events = GetEvents(projectConfig);
-            var variationByFlagMap = GetVariationsByFlag(projectConfig);
 
             OptimizelyConfig = new OptimizelyConfig(projectConfig.Revision,
                 projectConfig.SDKKey,
@@ -58,11 +57,6 @@ public OptimizelyConfigService(ProjectConfig projectConfig)
                 projectConfig.ToDatafile());
         }
 
-        private Dictionary<string, List<Variation>> GetVariationsByFlag(ProjectConfig projectConfig)
-        {
-            return projectConfig.FlagVariationMap;
-        }
-
         private OptimizelyEvent[] GetEvents(ProjectConfig projectConfig)
         {
             var optimizelyEvents = new List<OptimizelyEvent>();

From e72faee5f13081ff2ad7c5b4259da462dd91df2b Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Tue, 2 Nov 2021 20:23:01 -0400
Subject: [PATCH 059/130] Added checks for GetDecisionKey in tests

---
 .../OptimizelyUserContextTest.cs              | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
index 6067874a..19b7dd71 100644
--- a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
@@ -185,6 +185,19 @@ public void TestDecide()
             Assert.AreEqual(decision.Reasons.Length, 0);
         }
 
+        [Test]
+        public void TestForcedDecisionReturnsCorrectGetDecisionKey()
+        {
+            var user = Optimizely.CreateUserContext(UserID);
+            var context = new OptimizelyDecisionContext("flag", null);
+
+            Assert.AreEqual(context.GetDecisionKey, "flag-$opt-null-rule-key");
+
+            context = new OptimizelyDecisionContext("flag", "ruleKey");
+
+            Assert.AreEqual(context.GetDecisionKey, "flag-ruleKey");
+        }
+
         [Test]
         public void TestSetForcedDecisionSetsValue()
         {
@@ -196,6 +209,23 @@ public void TestSetForcedDecisionSetsValue()
             Assert.IsTrue(result);
         }
 
+        [Test]
+        public void Random()
+        {
+            var user = Optimizely.CreateUserContext(UserID);
+            var context = new OptimizelyDecisionContext("flag2", "");
+
+            var decision = new OptimizelyForcedDecision("variation2");
+
+            var result = user.SetForcedDecision(context, decision);
+
+            Assert.IsTrue(result);
+
+            var test = user.GetForcedDecision(context);
+
+            Assert.AreEqual("variation2", test);
+        }
+
         [Test]
         public void TestSetForcedDecisionReturnsFalseForNullConfig()
         {

From 97b52a9d73c9da5bf29f88307962ce1d8e7f7e69 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Tue, 2 Nov 2021 20:46:12 -0400
Subject: [PATCH 060/130] Added test for additional logging info

---
 OptimizelySDK.Tests/Assertions.cs                |  9 ++++++---
 OptimizelySDK.Tests/OptimizelyUserContextTest.cs | 15 +++++++++++++++
 2 files changed, 21 insertions(+), 3 deletions(-)

diff --git a/OptimizelySDK.Tests/Assertions.cs b/OptimizelySDK.Tests/Assertions.cs
index ebe269a1..4675c770 100644
--- a/OptimizelySDK.Tests/Assertions.cs
+++ b/OptimizelySDK.Tests/Assertions.cs
@@ -631,9 +631,12 @@ public static void AreEqual(DecisionReasons expected, DecisionReasons actual)
         public static void AreEqual(Result<Variation> expected, Result<Variation> actual)
         {
             AreEqual(expected.DecisionReasons, actual.DecisionReasons);
-            AreEqual(expected.ResultObject, actual.ResultObject);
-        }
+            if (expected.ResultObject != null && actual.ResultObject != null)
+            {
+                AreEqual(expected.ResultObject, actual.ResultObject);
+            }
 
-        #endregion Result T
+            #endregion Result T
+        }
     }
 }
diff --git a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
index 19b7dd71..cdb233af 100644
--- a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
@@ -320,6 +320,21 @@ public void TestFindValidatedForcedDecisionReturnsCorrectDecision()
             Assertions.AreEqual(expectedResult, result);
         }
 
+        [Test]
+        public void TestFindValidatedForcedDecisionReturnsCorrectDecisionWithNullVariation()
+        {
+            var decisionReasons = new DecisionReasons();
+            decisionReasons.AddInfo("{0}", "Invalid variation is mapped to flag: flagKey and rule: rule forced decision map.");
+            var expectedResult = Result<Variation>.NullResult(decisionReasons);
+            var user = Optimizely.CreateUserContext(UserID);
+
+            var context = new OptimizelyDecisionContext("flagKey", "ruleKey");
+
+            var result = user.FindValidatedForcedDecision(context);
+
+            Assertions.AreEqual(expectedResult, result);
+        }
+
         [Test]
         public void TestRemoveForcedDecisionReturnsFalseForNullFlagKey()
         {

From 7b76612c17f4420a3cf7bad0cd17446bb84bb11b Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Tue, 2 Nov 2021 20:48:25 -0400
Subject: [PATCH 061/130] Added additional config check

---
 .../OptimizelyUserContextTest.cs                | 17 +++++++----------
 1 file changed, 7 insertions(+), 10 deletions(-)

diff --git a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
index cdb233af..1c316d1e 100644
--- a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
@@ -210,20 +210,17 @@ public void TestSetForcedDecisionSetsValue()
         }
 
         [Test]
-        public void Random()
+        public void TestGetForcedDecisionReturnsNullIfInvalidConfig()
         {
-            var user = Optimizely.CreateUserContext(UserID);
-            var context = new OptimizelyDecisionContext("flag2", "");
-
-            var decision = new OptimizelyForcedDecision("variation2");
-
-            var result = user.SetForcedDecision(context, decision);
+            var optly = new Optimizely(new FallbackProjectConfigManager(null));
 
-            Assert.IsTrue(result);
+            var user = optly.CreateUserContext(UserID);
 
-            var test = user.GetForcedDecision(context);
+            var context = new OptimizelyDecisionContext("flag", null);
+            var decision = new OptimizelyForcedDecision("variationKey");
+            var result = user.GetForcedDecision(context);
 
-            Assert.AreEqual("variation2", test);
+            Assert.IsNull(result);
         }
 
         [Test]

From 5288bb1a2e2d1a707a61798720d018e136227b32 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Tue, 2 Nov 2021 21:17:26 -0400
Subject: [PATCH 062/130] Removed unnecessary code

---
 OptimizelySDK/IOptimizely.cs |  8 --------
 OptimizelySDK/Optimizely.cs  | 17 -----------------
 2 files changed, 25 deletions(-)

diff --git a/OptimizelySDK/IOptimizely.cs b/OptimizelySDK/IOptimizely.cs
index 46edda13..24ba3755 100644
--- a/OptimizelySDK/IOptimizely.cs
+++ b/OptimizelySDK/IOptimizely.cs
@@ -140,14 +140,6 @@ public interface IOptimizely
         /// <returns>List of the feature keys that are enabled for the user.</returns>
         List<string> GetEnabledFeatures(string userId, UserAttributes userAttributes = null);
 
-        /// <summary>
-        /// Get the variation by flag key
-        /// </summary>
-        /// <param name="flagKey">The flag key</param>
-        /// <param name="variationKey">The variation key</param>
-        /// <returns></returns>
-        Variation GetFlagVariationByKey(string flagKey, string variationKey);
-
         #endregion FeatureFlag APIs
     }
 }
diff --git a/OptimizelySDK/Optimizely.cs b/OptimizelySDK/Optimizely.cs
index e455ed7d..869d9b33 100644
--- a/OptimizelySDK/Optimizely.cs
+++ b/OptimizelySDK/Optimizely.cs
@@ -1212,22 +1212,5 @@ public void Dispose()
 
             ProjectConfigManager = null;
         }
-
-        /// <inheritdoc/>
-        public Variation GetFlagVariationByKey(string flagKey, string variationKey)
-        {
-            Dictionary<string, List<Variation>> flagVariationsMap = new Dictionary<string, List<Variation>>();
-            if (flagVariationsMap.TryGetValue(flagKey, out var variations))
-            {
-                foreach (var variation in variations)
-                {
-                    if (variation.Key.Equals(variationKey))
-                    {
-                        return variation;
-                    }
-                }
-            }
-            return null;
-        }
     }
 }

From 43237732b0db5c388ec638f9d49de8fbe3e3145c Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Wed, 3 Nov 2021 09:03:23 -0400
Subject: [PATCH 063/130] Fix for null experiment in decide all

---
 OptimizelySDK/Event/UserEventFactory.cs | 15 ++++++---------
 1 file changed, 6 insertions(+), 9 deletions(-)

diff --git a/OptimizelySDK/Event/UserEventFactory.cs b/OptimizelySDK/Event/UserEventFactory.cs
index 339c8e68..23dff1fa 100644
--- a/OptimizelySDK/Event/UserEventFactory.cs
+++ b/OptimizelySDK/Event/UserEventFactory.cs
@@ -76,15 +76,15 @@ public static ImpressionEvent CreateImpressionEvent(ProjectConfig projectConfig,
             .WithProjectId(projectConfig.ProjectId)
             .WithAccountId(projectConfig.AccountId)
             .WithAnonymizeIP(projectConfig.AnonymizeIP)
-            .WithRevision(projectConfig.Revision)                
+            .WithRevision(projectConfig.Revision)
             .Build();
 
-            var variationKey = ""; 
-            var ruleKey = "";   
+            var variationKey = "";
+            var ruleKey = "";
             if (variation != null)
             {
                 variationKey = variation.Key;
-                ruleKey = activatedExperiment.Key;
+                ruleKey = activatedExperiment != null ? activatedExperiment.Key : "";
             }
             var metadata = new DecisionMetadata(flagKey, ruleKey, ruleType, variationKey, enabled);
 
@@ -97,7 +97,6 @@ public static ImpressionEvent CreateImpressionEvent(ProjectConfig projectConfig,
                 .WithVariation(variation)
                 .WithVisitorAttributes(EventFactory.BuildAttributeList(userAttributes, projectConfig))
                 .Build();
-            
         }
 
         /// <summary>
@@ -109,14 +108,12 @@ public static ImpressionEvent CreateImpressionEvent(ProjectConfig projectConfig,
         /// <param name="userAttributes">The user's attributes</param>
         /// <param name="eventTags">Array Hash representing metadata associated with the event.</param>
         /// <returns>ConversionEvent instance</returns>
-        public static ConversionEvent CreateConversionEvent(ProjectConfig projectConfig,                                                            
+        public static ConversionEvent CreateConversionEvent(ProjectConfig projectConfig,
                                                             string eventKey,
                                                             string userId,
                                                             UserAttributes userAttributes,
                                                             EventTags eventTags)
         {
-            
-
             var eventContext = new EventContext.Builder()
                     .WithProjectId(projectConfig.ProjectId)
                     .WithAccountId(projectConfig.AccountId)
@@ -131,7 +128,7 @@ public static ConversionEvent CreateConversionEvent(ProjectConfig projectConfig,
                 .WithEvent(projectConfig.GetEvent(eventKey))
                 .WithUserId(userId)
                 .WithVisitorAttributes(EventFactory.BuildAttributeList(userAttributes, projectConfig))
-                .Build();            
+                .Build();
         }
     }
 }

From 86f8ea57692512338b20154bb9e03792eed68c47 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Wed, 3 Nov 2021 14:06:45 -0400
Subject: [PATCH 064/130] fix rule key being non-null

---
 .gitignore                                     | 1 +
 OptimizelySDK.Tests/OptimizelySDK.Tests.csproj | 1 +
 OptimizelySDK/Optimizely.cs                    | 2 +-
 3 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index c4d97504..28373588 100644
--- a/.gitignore
+++ b/.gitignore
@@ -244,3 +244,4 @@ ModelManifest.xml
 OptimizelySDK.Package/nuget.exe
 OptimizelySDK.Package/content
 OptimizelySDK.Package/lib
+/OptimizelySDK.Tests/fsc.json
diff --git a/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj b/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj
index 26b18922..a30ec700 100644
--- a/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj
+++ b/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj
@@ -136,6 +136,7 @@
     </ProjectReference>
   </ItemGroup>
   <ItemGroup>
+    <None Include="fsc.json" />
     <None Include="packages.config" />
     <EmbeddedResource Include="unsupported_version_datafile.json" />
     <EmbeddedResource Include="typed_audience_datafile.json" />
diff --git a/OptimizelySDK/Optimizely.cs b/OptimizelySDK/Optimizely.cs
index 869d9b33..d34735d3 100644
--- a/OptimizelySDK/Optimizely.cs
+++ b/OptimizelySDK/Optimizely.cs
@@ -830,7 +830,7 @@ internal OptimizelyDecision Decide(OptimizelyUserContext user,
             var variationKey = decision?.Variation?.Key;
 
             // TODO: add ruleKey values when available later. use a copy of experimentKey until then.
-            var ruleKey = decision?.Experiment?.Key;
+            var ruleKey = decision?.Experiment != null ? decision?.Experiment?.Key : null;
 
             var decisionInfo = new Dictionary<string, object>
             {

From 8240f6e0613437730b31ac19b88acb873ab12fe4 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Wed, 3 Nov 2021 15:02:49 -0400
Subject: [PATCH 065/130] Corrected copying hte files instead of referencing
 them in the proj.

Cleaning this up should be a huge todo. No reason to have all these projects.
---
 .../OptimizelyDecisionContext.cs              | 39 -------------------
 .../OptimizelyForcedDecision.cs               | 19 ---------
 .../OptimizelySDK.Net35.csproj                |  8 +++-
 .../OptimizelyDecisionContext.cs              | 39 -------------------
 .../OptimizelyForcedDecision.cs               | 20 ----------
 .../OptimizelySDK.Net40.csproj                |  6 +++
 .../OptimizelyDecisionContext.cs              | 39 -------------------
 .../OptimizelyForcedDecision.cs               | 20 ----------
 .../OptimizelySDK.NetStandard16.csproj        |  6 +++
 .../OptimizelyDecisionContext.cs              | 39 -------------------
 .../OptimizelyForcedDecision.cs               | 20 ----------
 .../OptimizelySDK.NetStandard20.csproj        |  6 +++
 12 files changed, 24 insertions(+), 237 deletions(-)
 delete mode 100644 OptimizelySDK.Net35/OptimizelyDecisionContext.cs
 delete mode 100644 OptimizelySDK.Net35/OptimizelyForcedDecision.cs
 delete mode 100644 OptimizelySDK.Net40/OptimizelyDecisionContext.cs
 delete mode 100644 OptimizelySDK.Net40/OptimizelyForcedDecision.cs
 delete mode 100644 OptimizelySDK.NetStandard16/OptimizelyDecisionContext.cs
 delete mode 100644 OptimizelySDK.NetStandard16/OptimizelyForcedDecision.cs
 delete mode 100644 OptimizelySDK.NetStandard20/OptimizelyDecisionContext.cs
 delete mode 100644 OptimizelySDK.NetStandard20/OptimizelyForcedDecision.cs

diff --git a/OptimizelySDK.Net35/OptimizelyDecisionContext.cs b/OptimizelySDK.Net35/OptimizelyDecisionContext.cs
deleted file mode 100644
index 2e74cc15..00000000
--- a/OptimizelySDK.Net35/OptimizelyDecisionContext.cs
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright 2020-2021, Optimizely
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-namespace OptimizelySDK
-{
-    public class OptimizelyDecisionContext
-    {
-        public const string OPTI_NULL_RULE_KEY = "$opt-null-rule-key";
-        private string flagKey;
-        private string ruleKey;
-        private string decisionKey;
-
-        public OptimizelyDecisionContext(string flagKey, string ruleKey = null)
-        {
-            this.flagKey = flagKey;
-            this.ruleKey = ruleKey;
-            this.decisionKey = string.Format("{0}-{1}", flagKey, ruleKey ?? OPTI_NULL_RULE_KEY);
-        }
-
-        public string FlagKey { get { return flagKey; } }
-
-        public string RuleKey { get { return ruleKey; } }
-
-        public string GetDecisionKey { get { return decisionKey; } }
-    }
-}
diff --git a/OptimizelySDK.Net35/OptimizelyForcedDecision.cs b/OptimizelySDK.Net35/OptimizelyForcedDecision.cs
deleted file mode 100644
index c24d2e9d..00000000
--- a/OptimizelySDK.Net35/OptimizelyForcedDecision.cs
+++ /dev/null
@@ -1,19 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-namespace OptimizelySDK
-{
-    public class OptimizelyForcedDecision
-    {
-        private string variationKey;
-
-        public OptimizelyForcedDecision(string variationKey)
-        {
-            this.variationKey = variationKey;
-        }
-
-        public string VariationKey { get { return variationKey; } }
-    }
-}
diff --git a/OptimizelySDK.Net35/OptimizelySDK.Net35.csproj b/OptimizelySDK.Net35/OptimizelySDK.Net35.csproj
index 266e3943..af6251e9 100644
--- a/OptimizelySDK.Net35/OptimizelySDK.Net35.csproj
+++ b/OptimizelySDK.Net35/OptimizelySDK.Net35.csproj
@@ -193,8 +193,6 @@
     <Compile Include="..\OptimizelySDK\Utils\DateTimeUtils.cs">
       <Link>Utils\DateTimeUtils.cs</Link>
     </Compile>
-    <Compile Include="OptimizelyDecisionContext.cs" />
-    <Compile Include="OptimizelyForcedDecision.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="..\OptimizelySDK\Bucketing\Bucketer.cs">
       <Link>Bucketing\Bucketer.cs</Link>
@@ -321,6 +319,12 @@
     </Compile>
     <Compile Include="..\OptimizelySDK\OptimizelyDecisions\OptimizelyDecision.cs">
       <Link>OptimizelyDecisions\OptimizelyDecision.cs</Link>
+    </Compile>
+	<Compile Include="..\OptimizelySDK\OptimizelyDecisionContext.cs">
+      <Link>OptimizelyDecisionContext.cs</Link>
+    </Compile>
+	<Compile Include="..\OptimizelySDK\OptimizelyForcedDecision.cs">
+      <Link>OptimizelyForcedDecision.cs</Link>
     </Compile>
     <Compile Include="..\OptimizelySDK\OptimizelyUserContext.cs">
       <Link>OptimizelyUserContext.cs</Link>
diff --git a/OptimizelySDK.Net40/OptimizelyDecisionContext.cs b/OptimizelySDK.Net40/OptimizelyDecisionContext.cs
deleted file mode 100644
index 2e74cc15..00000000
--- a/OptimizelySDK.Net40/OptimizelyDecisionContext.cs
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright 2020-2021, Optimizely
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-namespace OptimizelySDK
-{
-    public class OptimizelyDecisionContext
-    {
-        public const string OPTI_NULL_RULE_KEY = "$opt-null-rule-key";
-        private string flagKey;
-        private string ruleKey;
-        private string decisionKey;
-
-        public OptimizelyDecisionContext(string flagKey, string ruleKey = null)
-        {
-            this.flagKey = flagKey;
-            this.ruleKey = ruleKey;
-            this.decisionKey = string.Format("{0}-{1}", flagKey, ruleKey ?? OPTI_NULL_RULE_KEY);
-        }
-
-        public string FlagKey { get { return flagKey; } }
-
-        public string RuleKey { get { return ruleKey; } }
-
-        public string GetDecisionKey { get { return decisionKey; } }
-    }
-}
diff --git a/OptimizelySDK.Net40/OptimizelyForcedDecision.cs b/OptimizelySDK.Net40/OptimizelyForcedDecision.cs
deleted file mode 100644
index c1dff205..00000000
--- a/OptimizelySDK.Net40/OptimizelyForcedDecision.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace OptimizelySDK
-{
-    public class OptimizelyForcedDecision
-    {
-        private string variationKey;
-
-        public OptimizelyForcedDecision(string variationKey)
-        {
-            this.variationKey = variationKey;
-        }
-
-        public string VariationKey { get { return variationKey; } }
-    }
-}
diff --git a/OptimizelySDK.Net40/OptimizelySDK.Net40.csproj b/OptimizelySDK.Net40/OptimizelySDK.Net40.csproj
index a280aec6..3889bb46 100644
--- a/OptimizelySDK.Net40/OptimizelySDK.Net40.csproj
+++ b/OptimizelySDK.Net40/OptimizelySDK.Net40.csproj
@@ -344,6 +344,12 @@
     </Compile>
     <Compile Include="..\OptimizelySDK\OptimizelyUserContext.cs">
       <Link>OptimizelyUserContext.cs</Link>
+    </Compile>
+	<Compile Include="..\OptimizelySDK\OptimizelyDecisionContext.cs">
+      <Link>OptimizelyDecisionContext.cs</Link>
+    </Compile>
+	<Compile Include="..\OptimizelySDK\OptimizelyForcedDecision.cs">
+      <Link>OptimizelyForcedDecision.cs</Link>
     </Compile>
     <Compile Include="..\OptimizelySDK\Entity\Result.cs">
       <Link>Entity\Result.cs</Link>
diff --git a/OptimizelySDK.NetStandard16/OptimizelyDecisionContext.cs b/OptimizelySDK.NetStandard16/OptimizelyDecisionContext.cs
deleted file mode 100644
index 2e74cc15..00000000
--- a/OptimizelySDK.NetStandard16/OptimizelyDecisionContext.cs
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright 2020-2021, Optimizely
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-namespace OptimizelySDK
-{
-    public class OptimizelyDecisionContext
-    {
-        public const string OPTI_NULL_RULE_KEY = "$opt-null-rule-key";
-        private string flagKey;
-        private string ruleKey;
-        private string decisionKey;
-
-        public OptimizelyDecisionContext(string flagKey, string ruleKey = null)
-        {
-            this.flagKey = flagKey;
-            this.ruleKey = ruleKey;
-            this.decisionKey = string.Format("{0}-{1}", flagKey, ruleKey ?? OPTI_NULL_RULE_KEY);
-        }
-
-        public string FlagKey { get { return flagKey; } }
-
-        public string RuleKey { get { return ruleKey; } }
-
-        public string GetDecisionKey { get { return decisionKey; } }
-    }
-}
diff --git a/OptimizelySDK.NetStandard16/OptimizelyForcedDecision.cs b/OptimizelySDK.NetStandard16/OptimizelyForcedDecision.cs
deleted file mode 100644
index c1dff205..00000000
--- a/OptimizelySDK.NetStandard16/OptimizelyForcedDecision.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace OptimizelySDK
-{
-    public class OptimizelyForcedDecision
-    {
-        private string variationKey;
-
-        public OptimizelyForcedDecision(string variationKey)
-        {
-            this.variationKey = variationKey;
-        }
-
-        public string VariationKey { get { return variationKey; } }
-    }
-}
diff --git a/OptimizelySDK.NetStandard16/OptimizelySDK.NetStandard16.csproj b/OptimizelySDK.NetStandard16/OptimizelySDK.NetStandard16.csproj
index 7d5e7c81..edc1683d 100644
--- a/OptimizelySDK.NetStandard16/OptimizelySDK.NetStandard16.csproj
+++ b/OptimizelySDK.NetStandard16/OptimizelySDK.NetStandard16.csproj
@@ -97,6 +97,12 @@
 		<Compile Include="..\OptimizelySDK\OptimizelyDecisions\OptimizelyDecision.cs" />
 		<Compile Include="..\OptimizelySDK\OptimizelyUserContext.cs" />
 		<Compile Include="..\OptimizelySDK\Config\FallbackProjectConfigManager.cs">
+		<Compile Include="..\OptimizelySDK\OptimizelyDecisionContext.cs">
+			<Link>OptimizelyDecisionContext.cs</Link>
+		</Compile>
+		<Compile Include="..\OptimizelySDK\OptimizelyForcedDecision.cs">
+		  <Link>OptimizelyForcedDecision.cs</Link>
+		</Compile>
 		  <Link>AtomicProjectConfigManager.cs</Link>
 		</Compile>
 		<Compile Include="..\OptimizelySDK\OptimizelyFactory.cs">
diff --git a/OptimizelySDK.NetStandard20/OptimizelyDecisionContext.cs b/OptimizelySDK.NetStandard20/OptimizelyDecisionContext.cs
deleted file mode 100644
index 2e74cc15..00000000
--- a/OptimizelySDK.NetStandard20/OptimizelyDecisionContext.cs
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright 2020-2021, Optimizely
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-namespace OptimizelySDK
-{
-    public class OptimizelyDecisionContext
-    {
-        public const string OPTI_NULL_RULE_KEY = "$opt-null-rule-key";
-        private string flagKey;
-        private string ruleKey;
-        private string decisionKey;
-
-        public OptimizelyDecisionContext(string flagKey, string ruleKey = null)
-        {
-            this.flagKey = flagKey;
-            this.ruleKey = ruleKey;
-            this.decisionKey = string.Format("{0}-{1}", flagKey, ruleKey ?? OPTI_NULL_RULE_KEY);
-        }
-
-        public string FlagKey { get { return flagKey; } }
-
-        public string RuleKey { get { return ruleKey; } }
-
-        public string GetDecisionKey { get { return decisionKey; } }
-    }
-}
diff --git a/OptimizelySDK.NetStandard20/OptimizelyForcedDecision.cs b/OptimizelySDK.NetStandard20/OptimizelyForcedDecision.cs
deleted file mode 100644
index c1dff205..00000000
--- a/OptimizelySDK.NetStandard20/OptimizelyForcedDecision.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace OptimizelySDK
-{
-    public class OptimizelyForcedDecision
-    {
-        private string variationKey;
-
-        public OptimizelyForcedDecision(string variationKey)
-        {
-            this.variationKey = variationKey;
-        }
-
-        public string VariationKey { get { return variationKey; } }
-    }
-}
diff --git a/OptimizelySDK.NetStandard20/OptimizelySDK.NetStandard20.csproj b/OptimizelySDK.NetStandard20/OptimizelySDK.NetStandard20.csproj
index b43a21cb..bbf3bb1c 100644
--- a/OptimizelySDK.NetStandard20/OptimizelySDK.NetStandard20.csproj
+++ b/OptimizelySDK.NetStandard20/OptimizelySDK.NetStandard20.csproj
@@ -304,6 +304,12 @@
 	<Compile Include="..\OptimizelySDK\OptimizelyUserContext.cs">
       <Link>OptimizelyUserContext.cs</Link>
     </Compile>
+	<Compile Include="..\OptimizelySDK\OptimizelyDecisionContext.cs">
+		<Link>OptimizelyDecisionContext.cs</Link>
+	</Compile>
+	<Compile Include="..\OptimizelySDK\OptimizelyForcedDecision.cs">
+	  <Link>OptimizelyForcedDecision.cs</Link>
+	</Compile>
 	<Compile Include="..\OptimizelySDK\Entity\Result.cs">
 	  <Link>Entity\Result.cs</Link>
 	</Compile>

From 82a8d93e8b731c0353a670a0856a0a1bd7f98463 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Thu, 4 Nov 2021 14:47:54 -0400
Subject: [PATCH 066/130] A few changes to help with deciding

---
 OptimizelySDK/Config/DatafileProjectConfig.cs | 21 +++++++++++++++
 OptimizelySDK/Optimizely.cs                   |  2 +-
 OptimizelySDK/OptimizelyUserContext.cs        | 27 +++++++++----------
 OptimizelySDK/ProjectConfig.cs                |  8 ++++++
 4 files changed, 43 insertions(+), 15 deletions(-)

diff --git a/OptimizelySDK/Config/DatafileProjectConfig.cs b/OptimizelySDK/Config/DatafileProjectConfig.cs
index 77701e1b..16603903 100644
--- a/OptimizelySDK/Config/DatafileProjectConfig.cs
+++ b/OptimizelySDK/Config/DatafileProjectConfig.cs
@@ -649,6 +649,27 @@ public FeatureFlag GetFeatureFlagFromKey(string featureKey)
             return new FeatureFlag();
         }
 
+        /// <summary>
+        /// Gets the variation associated with an experiment or rollout for a given feature flag key
+        /// </summary>
+        /// <param name="flagKey">feature flag key</param>
+        /// <param name="variationKey">variation key</param>
+        /// <returns></returns>
+        public Variation GetFlagVariationByKey(string flagKey, string variationKey)
+        {
+            if (_FlagVariationMap.TryGetValue(flagKey, out var variations))
+            {
+                foreach (var variation in variations)
+                {
+                    if (variation.Key.Equals(flagKey))
+                    {
+                        return variation;
+                    }
+                }
+            }
+            return null;
+        }
+
         /// <summary>
         /// Get the rollout from the ID
         /// </summary>
diff --git a/OptimizelySDK/Optimizely.cs b/OptimizelySDK/Optimizely.cs
index d34735d3..289dbdf1 100644
--- a/OptimizelySDK/Optimizely.cs
+++ b/OptimizelySDK/Optimizely.cs
@@ -761,7 +761,7 @@ internal OptimizelyDecision Decide(OptimizelyUserContext user,
 
             var decisionContext = new OptimizelyDecisionContext(flag.Key);
             var forcedDecisionVariation = user.FindValidatedForcedDecision(decisionContext);
-            if (forcedDecisionVariation?.ResultObject != null)
+            if (forcedDecisionVariation != null)
             {
                 decision = new FeatureDecision(null, forcedDecisionVariation.ResultObject, FeatureDecision.DECISION_SOURCE_FEATURE_TEST);
                 decisionReasons = forcedDecisionVariation.DecisionReasons;
diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index 0ba0c589..62f65292 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -329,27 +329,26 @@ public Result<Variation> FindValidatedForcedDecision(OptimizelyDecisionContext c
             DecisionReasons reasons = new DecisionReasons();
 
             string variationKey = GetForcedDecision(context);
+            Variation variation = null;
             if (variationKey != null)
             {
-                Variation variation = new Variation();
                 string strRuleKey = context.RuleKey ?? OptimizelyDecisionContext.OPTI_NULL_RULE_KEY;
-                string info;
-                if (variation != null)
+                if (!string.IsNullOrEmpty(variationKey))
                 {
-                    info = string.Format("Variation {0} is mapped to flag: {1} and rule: {2} in the forced decision map.", variationKey, context.FlagKey, strRuleKey);
-                    Logger.Log(LogLevel.INFO, info);
-                    reasons.AddInfo(info);
-                    return Result<Variation>.NewResult(variation, reasons);
-                }
-                else
-                {
-                    info = string.Format("Invalid variation is mapped to flag: {0} and rule: {1} forced decision map.", context.FlagKey, strRuleKey);
-                    Logger.Log(LogLevel.INFO, info);
-                    reasons.AddInfo(info);
+                    variation = Optimizely.ProjectConfigManager.GetConfig().GetFlagVariationByKey(context.FlagKey, variationKey);
+                    if (variation != null)
+                    {
+                        reasons.AddInfo("Decided by forced decision.");
+                        reasons.AddInfo("Variation {0} is mapped to {1} and user {2} in the forced decision map", variationKey, strRuleKey, this.UserId);
+                    }
+                    else
+                    {
+                        reasons.AddInfo("Invalid variation is mapped to {0} and user {1} in the forced decision map.", strRuleKey, this.UserId);
+                    }
                 }
             }
 
-            return Result<Variation>.NullResult(reasons);
+            return Result<Variation>.NewResult(variation, reasons);
         }
     }
 }
diff --git a/OptimizelySDK/ProjectConfig.cs b/OptimizelySDK/ProjectConfig.cs
index f7d11f68..675d1dd5 100644
--- a/OptimizelySDK/ProjectConfig.cs
+++ b/OptimizelySDK/ProjectConfig.cs
@@ -252,6 +252,14 @@ public interface ProjectConfig
         /// <returns>Feature Flag Entity corresponding to the key or a dummy entity if key is invalid</returns>
         FeatureFlag GetFeatureFlagFromKey(string featureKey);
 
+        /// <summary>
+        /// Gets the variation associated with an experiment or rollout for a given feature flag key
+        /// </summary>
+        /// <param name="flagKey">feature flag key</param>
+        /// <param name="variationKey">variation key</param>
+        /// <returns></returns>
+        Variation GetFlagVariationByKey(string flagKey, string variationKey);
+
         /// <summary>
         /// Get the rollout from the ID
         /// </summary>

From 87a1fc3720a18a2fe4cd368f913c602cf340069d Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Thu, 4 Nov 2021 15:40:37 -0400
Subject: [PATCH 067/130] Corrected incorrect nulls

---
 OptimizelySDK/Optimizely.cs            | 2 +-
 OptimizelySDK/OptimizelyUserContext.cs | 3 +--
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/OptimizelySDK/Optimizely.cs b/OptimizelySDK/Optimizely.cs
index 289dbdf1..d34735d3 100644
--- a/OptimizelySDK/Optimizely.cs
+++ b/OptimizelySDK/Optimizely.cs
@@ -761,7 +761,7 @@ internal OptimizelyDecision Decide(OptimizelyUserContext user,
 
             var decisionContext = new OptimizelyDecisionContext(flag.Key);
             var forcedDecisionVariation = user.FindValidatedForcedDecision(decisionContext);
-            if (forcedDecisionVariation != null)
+            if (forcedDecisionVariation?.ResultObject != null)
             {
                 decision = new FeatureDecision(null, forcedDecisionVariation.ResultObject, FeatureDecision.DECISION_SOURCE_FEATURE_TEST);
                 decisionReasons = forcedDecisionVariation.DecisionReasons;
diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index 62f65292..26eb0c92 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -347,8 +347,7 @@ public Result<Variation> FindValidatedForcedDecision(OptimizelyDecisionContext c
                     }
                 }
             }
-
-            return Result<Variation>.NewResult(variation, reasons);
+            return Result<Variation>.NewResult(null, reasons);
         }
     }
 }

From af396951d8a82008505ddb888cf618f5818abc83 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Thu, 4 Nov 2021 16:06:21 -0400
Subject: [PATCH 068/130] another update. Missed variation vs flag

---
 .../OptimizelyUserContextTest.cs              | 21 +++++++++++++++++++
 OptimizelySDK/Config/DatafileProjectConfig.cs |  2 +-
 OptimizelySDK/OptimizelyUserContext.cs        |  2 +-
 3 files changed, 23 insertions(+), 2 deletions(-)

diff --git a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
index 1c316d1e..64499c04 100644
--- a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
@@ -198,6 +198,27 @@ public void TestForcedDecisionReturnsCorrectGetDecisionKey()
             Assert.AreEqual(context.GetDecisionKey, "flag-ruleKey");
         }
 
+        [Test]
+        public void RemoveMe()
+        {
+            var datafile = "";
+            using (System.IO.StreamReader reader = new System.IO.StreamReader(@"C:\Users\Dustin\dev\csharp\csharp-sdk\OptimizelySDK.Tests\fsc.json"))
+                datafile = reader.ReadToEnd();
+
+            Optimizely = new Optimizely(datafile, EventDispatcherMock.Object, LoggerMock.Object, ErrorHandlerMock.Object);
+            var user = Optimizely.CreateUserContext("test_user_1");
+            var context = new OptimizelyDecisionContext("flag_1", null);
+            var context2 = new OptimizelyDecisionContext("flag_2", "ruleKey");
+            var decision = new OptimizelyForcedDecision("exp_variation_1");
+            var decision2 = new OptimizelyForcedDecision("exp_variation_2");
+
+            user.SetForcedDecision(context, decision);
+            user.SetForcedDecision(context2, decision2);
+
+            var result = user.DecideAll();
+            var str1 = Newtonsoft.Json.JsonConvert.SerializeObject(result);
+        }
+
         [Test]
         public void TestSetForcedDecisionSetsValue()
         {
diff --git a/OptimizelySDK/Config/DatafileProjectConfig.cs b/OptimizelySDK/Config/DatafileProjectConfig.cs
index 16603903..890a4c4f 100644
--- a/OptimizelySDK/Config/DatafileProjectConfig.cs
+++ b/OptimizelySDK/Config/DatafileProjectConfig.cs
@@ -661,7 +661,7 @@ public Variation GetFlagVariationByKey(string flagKey, string variationKey)
             {
                 foreach (var variation in variations)
                 {
-                    if (variation.Key.Equals(flagKey))
+                    if (variation.Key.Equals(variationKey))
                     {
                         return variation;
                     }
diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index 26eb0c92..188b9d17 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -347,7 +347,7 @@ public Result<Variation> FindValidatedForcedDecision(OptimizelyDecisionContext c
                     }
                 }
             }
-            return Result<Variation>.NewResult(null, reasons);
+            return Result<Variation>.NullResult(reasons);
         }
     }
 }

From 2500dd7bf96a1932bad6398a3b4607bb76001a7d Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Thu, 4 Nov 2021 16:11:36 -0400
Subject: [PATCH 069/130] additional fsc things

---
 .../OptimizelyUserContextTest.cs              | 21 -------------------
 OptimizelySDK/OptimizelyUserContext.cs        |  1 +
 2 files changed, 1 insertion(+), 21 deletions(-)

diff --git a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
index 64499c04..1c316d1e 100644
--- a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
@@ -198,27 +198,6 @@ public void TestForcedDecisionReturnsCorrectGetDecisionKey()
             Assert.AreEqual(context.GetDecisionKey, "flag-ruleKey");
         }
 
-        [Test]
-        public void RemoveMe()
-        {
-            var datafile = "";
-            using (System.IO.StreamReader reader = new System.IO.StreamReader(@"C:\Users\Dustin\dev\csharp\csharp-sdk\OptimizelySDK.Tests\fsc.json"))
-                datafile = reader.ReadToEnd();
-
-            Optimizely = new Optimizely(datafile, EventDispatcherMock.Object, LoggerMock.Object, ErrorHandlerMock.Object);
-            var user = Optimizely.CreateUserContext("test_user_1");
-            var context = new OptimizelyDecisionContext("flag_1", null);
-            var context2 = new OptimizelyDecisionContext("flag_2", "ruleKey");
-            var decision = new OptimizelyForcedDecision("exp_variation_1");
-            var decision2 = new OptimizelyForcedDecision("exp_variation_2");
-
-            user.SetForcedDecision(context, decision);
-            user.SetForcedDecision(context2, decision2);
-
-            var result = user.DecideAll();
-            var str1 = Newtonsoft.Json.JsonConvert.SerializeObject(result);
-        }
-
         [Test]
         public void TestSetForcedDecisionSetsValue()
         {
diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index 188b9d17..b7fcba3d 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -340,6 +340,7 @@ public Result<Variation> FindValidatedForcedDecision(OptimizelyDecisionContext c
                     {
                         reasons.AddInfo("Decided by forced decision.");
                         reasons.AddInfo("Variation {0} is mapped to {1} and user {2} in the forced decision map", variationKey, strRuleKey, this.UserId);
+                        return Result<Variation>.NewResult(variation, reasons);
                     }
                     else
                     {

From 8b32b39a81432f36362616d02f0c6b5d7d287e4e Mon Sep 17 00:00:00 2001
From: Dustin Sier <Dustin.Sier@episerver.com>
Date: Thu, 4 Nov 2021 17:37:09 -0400
Subject: [PATCH 070/130] Added additional property

---
 .../OptimizelySDK.NetStandard16.csproj        | 292 +++++++++---------
 1 file changed, 143 insertions(+), 149 deletions(-)

diff --git a/OptimizelySDK.NetStandard16/OptimizelySDK.NetStandard16.csproj b/OptimizelySDK.NetStandard16/OptimizelySDK.NetStandard16.csproj
index edc1683d..d2ca8243 100644
--- a/OptimizelySDK.NetStandard16/OptimizelySDK.NetStandard16.csproj
+++ b/OptimizelySDK.NetStandard16/OptimizelySDK.NetStandard16.csproj
@@ -1,158 +1,152 @@
 <Project Sdk="Microsoft.NET.Sdk">
-
-    <PropertyGroup>
-        <TargetFramework>netstandard1.6</TargetFramework>
-        <ReleaseVersion>1.2.1</ReleaseVersion>
-        <AssemblyOriginatorKeyFile>..\keypair.snk</AssemblyOriginatorKeyFile>
-        <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
-    </PropertyGroup>
-
-    <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-    </PropertyGroup>
+  <PropertyGroup>
+      <TargetFramework>netstandard1.6</TargetFramework>
+      <ReleaseVersion>1.2.1</ReleaseVersion>
+      <AssemblyOriginatorKeyFile>..\keypair.snk</AssemblyOriginatorKeyFile>
+      <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+  </PropertyGroup>
 	<PropertyGroup>
     	<DefineConstants>;$(DefineConstants);<NETSTANDARD1_6>NetStandardIdentifier</NETSTANDARD1_6>
     	</DefineConstants>
 	</PropertyGroup>
     <ItemGroup>
-		<Compile Include="..\OptimizelySDK\AudienceConditions\AndCondition.cs" />
-		<Compile Include="..\OptimizelySDK\AudienceConditions\AudienceIdCondition.cs" />
-		<Compile Include="..\OptimizelySDK\AudienceConditions\BaseCondition.cs" />
-		<Compile Include="..\OptimizelySDK\AudienceConditions\SemanticVersion.cs" />
-		<Compile Include="..\OptimizelySDK\AudienceConditions\EmptyCondition.cs" />
-		<Compile Include="..\OptimizelySDK\AudienceConditions\ICondition.cs" />
-		<Compile Include="..\OptimizelySDK\AudienceConditions\NotCondition.cs" />
-		<Compile Include="..\OptimizelySDK\AudienceConditions\OrCondition.cs" />
-		<Compile Include="..\OptimizelySDK\Entity\Attribute.cs" />
-        <Compile Include="..\OptimizelySDK\Entity\Audience.cs" />
-        <Compile Include="..\OptimizelySDK\Entity\Entity.cs" />
-        <Compile Include="..\OptimizelySDK\Entity\Event.cs" />
-        <Compile Include="..\OptimizelySDK\Entity\EventTags.cs" />
-        <Compile Include="..\OptimizelySDK\Entity\Experiment.cs" />
-		<Compile Include="..\OptimizelySDK\Entity\FeatureDecision.cs" />
-        <Compile Include="..\OptimizelySDK\Entity\ForcedVariation.cs" />
-        <Compile Include="..\OptimizelySDK\Entity\Group.cs" />
-        <Compile Include="..\OptimizelySDK\Entity\IdKeyEntity.cs" />
-        <Compile Include="..\OptimizelySDK\OptimizelyJSON.cs" />
-        <Compile Include="..\OptimizelySDK\Entity\TrafficAllocation.cs" />
-        <Compile Include="..\OptimizelySDK\Entity\UserAttributes.cs" />
-        <Compile Include="..\OptimizelySDK\Entity\Variation.cs" />
-		<Compile Include="..\OptimizelySDK\Entity\FeatureVariableUsage.cs" />
-		<Compile Include="..\OptimizelySDK\Entity\FeatureFlag.cs" />
-		<Compile Include="..\OptimizelySDK\Entity\FeatureVariable.cs" />
-		<Compile Include="..\OptimizelySDK\Entity\Rollout.cs" />
-        <Compile Include="..\OptimizelySDK\ErrorHandler\DefaultErrorHandler.cs" />
-        <Compile Include="..\OptimizelySDK\ErrorHandler\IErrorHandler.cs" />
-        <Compile Include="..\OptimizelySDK\ErrorHandler\NoOpErrorHandler.cs" />
-        <Compile Include="..\OptimizelySDK\Event\Builder\EventBuilder.cs" />
-        <Compile Include="..\OptimizelySDK\Event\Builder\Params.cs" />
-        <Compile Include="..\OptimizelySDK\Event\Dispatcher\DefaultEventDispatcher.cs" />
-        <Compile Include="..\OptimizelySDK\Event\Dispatcher\WebRequestEventDispatcher35.cs" />
-        <Compile Include="..\OptimizelySDK\Event\Dispatcher\HttpClientEventDispatcher45.cs" />
-        <Compile Include="..\OptimizelySDK\Event\Dispatcher\IEventDispatcher.cs" />
-        <Compile Include="..\OptimizelySDK\Event\LogEvent.cs" />
-		<Compile Include="..\OptimizelySDK\Event\ForwardingEventProcessor.cs" />
-        <Compile Include="..\OptimizelySDK\Exceptions\OptimizelyException.cs" />
-        <Compile Include="..\OptimizelySDK\IOptimizely.cs" />
-        <Compile Include="..\OptimizelySDK\Logger\DefaultLogger.cs" />
-        <Compile Include="..\OptimizelySDK\Logger\ILogger.cs" />
-        <Compile Include="..\OptimizelySDK\Logger\NoOpLogger.cs" />
-		<Compile Include="..\OptimizelySDK\Notifications\NotificationCenter.cs" />
-        <Compile Include="..\OptimizelySDK\Optimizely.cs" />
-        <Compile Include="..\OptimizelySDK\Utils\EventTagUtils.cs" />
-        <Compile Include="..\OptimizelySDK\Utils\Validator.cs" />
-        <Compile Include=".\Properties\AssemblyInfo.cs" />
-        <Compile Include="..\OptimizelySDK\Utils\ConfigParser.cs" />
-        <Compile Include="..\OptimizelySDK\Utils\Schema.cs" />
-		<Compile Include="..\OptimizelySDK\Utils\ControlAttributes.cs" />
-		<Compile Include="..\OptimizelySDK\Utils\ExceptionExtensions.cs" />
-		<Compile Include="..\OptimizelySDK\Utils\ExperimentUtils.cs" />
-		<Compile Include="..\OptimizelySDK\Utils\ConditionParser.cs" />
-		<Compile Include="..\OptimizelySDK\Utils\AttributeMatchTypes.cs" />
-		<Compile Include="..\OptimizelySDK\Utils\DecisionInfoTypes.cs" />
-		<Compile Include="..\OptimizelySDK\Utils\DateTimeUtils.cs" />
-        <Compile Include="..\OptimizelySDK\Bucketing\Bucketer.cs" />
-        <Compile Include="..\OptimizelySDK\Bucketing\Decision.cs" />
-        <Compile Include="..\OptimizelySDK\Bucketing\DecisionService.cs" />
-        <Compile Include="..\OptimizelySDK\Bucketing\UserProfile.cs" />
-        <Compile Include="..\OptimizelySDK\Bucketing\UserProfileService.cs" />
-        <Compile Include="..\OptimizelySDK\Bucketing\UserProfileUtil.cs" />
-		<Compile Include="..\OptimizelySDK\ProjectConfig.cs" />
-		<Compile Include="..\OptimizelySDK\Config\DatafileProjectConfig.cs" />
-		<Compile Include="..\OptimizelySDK\Config\ProjectConfigManager.cs" />
-		<Compile Include="..\OptimizelySDK\Config\PollingProjectConfigManager.cs" />
-		<Compile Include="..\OptimizelySDK\Config\HttpProjectConfigManager.cs" />
-		<Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyConfig.cs" />
-		<Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyAttribute.cs" />
-		<Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyEvent.cs" />
-		<Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyExperiment.cs" />
-		<Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyFeature.cs" />
-		<Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyVariable.cs" />
-		<Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyVariation.cs" />
-		<Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyAudience.cs" />
-		<Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyConfigService.cs" />
-		<Compile Include="..\OptimizelySDK\OptlyConfig\IOptimizelyConfigManager.cs" />
-		<Compile Include="..\OptimizelySDK\OptimizelyDecisions\DecisionMessage.cs" />
-		<Compile Include="..\OptimizelySDK\OptimizelyDecisions\DecisionReasons.cs" />
-		<Compile Include="..\OptimizelySDK\OptimizelyDecisions\OptimizelyDecideOption.cs" />
-		<Compile Include="..\OptimizelySDK\OptimizelyDecisions\OptimizelyDecision.cs" />
-		<Compile Include="..\OptimizelySDK\OptimizelyUserContext.cs" />
-		<Compile Include="..\OptimizelySDK\Config\FallbackProjectConfigManager.cs">
-		<Compile Include="..\OptimizelySDK\OptimizelyDecisionContext.cs">
-			<Link>OptimizelyDecisionContext.cs</Link>
-		</Compile>
-		<Compile Include="..\OptimizelySDK\OptimizelyForcedDecision.cs">
-		  <Link>OptimizelyForcedDecision.cs</Link>
-		</Compile>
-		  <Link>AtomicProjectConfigManager.cs</Link>
-		</Compile>
-		<Compile Include="..\OptimizelySDK\OptimizelyFactory.cs">
-		  <Link>OptimizelyFactory.cs</Link>
-		</Compile>
-		<Compile Include="..\OptimizelySDK\Event\Entity\ConversionEvent.cs">
-		  <Link>ConversionEvent.cs</Link>
-		</Compile>
-		<Compile Include="..\OptimizelySDK\Event\Entity\EventBatch.cs">
-		  <Link>EventBatch.cs</Link>
-		</Compile>
-		<Compile Include="..\OptimizelySDK\Event\Entity\EventContext.cs">
-		  <Link>EventContext.cs</Link>
-		</Compile>
-		<Compile Include="..\OptimizelySDK\Event\Entity\ImpressionEvent.cs">
-		  <Link>ImpressionEvent.cs</Link>
-		</Compile>
-		<Compile Include="..\OptimizelySDK\Event\Entity\Snapshot.cs">
-		  <Link>Snapshot.cs</Link>
-		</Compile>
-		<Compile Include="..\OptimizelySDK\Event\Entity\SnapshotEvent.cs">
-		  <Link>SnapshotEvent.cs</Link>
-		</Compile>
-		<Compile Include="..\OptimizelySDK\Event\Entity\UserEvent.cs">
-		  <Link>UserEvent.cs</Link>
-		</Compile>
-		<Compile Include="..\OptimizelySDK\Event\Entity\Visitor.cs">
-		  <Link>Visitor.cs</Link>
-		</Compile>
-		<Compile Include="..\OptimizelySDK\Event\Entity\VisitorAttribute.cs">
-		  <Link>VisitorAttribute.cs</Link>
-		</Compile>
-		<Compile Include="..\OptimizelySDK\Event\Entity\DecisionMetadata.cs">
-		  <Link>DecisionMetadata.cs</Link>
-		</Compile>
-		<Compile Include="..\OptimizelySDK\Event\Entity\Decision.cs">
-		  <Link>DecisionEvent.cs</Link>
-		</Compile>
-		<Compile Include="..\OptimizelySDK\Event\EventFactory.cs">
-		  <Link>EventFactory.cs</Link>
-		</Compile>
-		<Compile Include="..\OptimizelySDK\Event\UserEventFactory.cs">
-		  <Link>UserEventFactory.cs</Link>
-		</Compile>
-		<Compile Include="..\OptimizelySDK\Event\EventProcessor.cs">
-		  <Link>EventProcessor.cs</Link>
-		</Compile>
-		<Compile Include="..\OptimizelySDK\Entity\Result.cs">
-		  <Link>Result.cs</Link>
-		</Compile>
+			<Compile Include="..\OptimizelySDK\AudienceConditions\AndCondition.cs" />
+			<Compile Include="..\OptimizelySDK\AudienceConditions\AudienceIdCondition.cs" />
+			<Compile Include="..\OptimizelySDK\AudienceConditions\BaseCondition.cs" />
+			<Compile Include="..\OptimizelySDK\AudienceConditions\SemanticVersion.cs" />
+			<Compile Include="..\OptimizelySDK\AudienceConditions\EmptyCondition.cs" />
+			<Compile Include="..\OptimizelySDK\AudienceConditions\ICondition.cs" />
+			<Compile Include="..\OptimizelySDK\AudienceConditions\NotCondition.cs" />
+			<Compile Include="..\OptimizelySDK\AudienceConditions\OrCondition.cs" />
+			<Compile Include="..\OptimizelySDK\Entity\Attribute.cs" />
+			<Compile Include="..\OptimizelySDK\Entity\Audience.cs" />
+			<Compile Include="..\OptimizelySDK\Entity\Entity.cs" />
+			<Compile Include="..\OptimizelySDK\Entity\Event.cs" />
+			<Compile Include="..\OptimizelySDK\Entity\EventTags.cs" />
+			<Compile Include="..\OptimizelySDK\Entity\Experiment.cs" />
+			<Compile Include="..\OptimizelySDK\Entity\FeatureDecision.cs" />
+			<Compile Include="..\OptimizelySDK\Entity\ForcedVariation.cs" />
+			<Compile Include="..\OptimizelySDK\Entity\Group.cs" />
+			<Compile Include="..\OptimizelySDK\Entity\IdKeyEntity.cs" />
+			<Compile Include="..\OptimizelySDK\OptimizelyJSON.cs" />
+			<Compile Include="..\OptimizelySDK\Entity\TrafficAllocation.cs" />
+			<Compile Include="..\OptimizelySDK\Entity\UserAttributes.cs" />
+			<Compile Include="..\OptimizelySDK\Entity\Variation.cs" />
+			<Compile Include="..\OptimizelySDK\Entity\FeatureVariableUsage.cs" />
+			<Compile Include="..\OptimizelySDK\Entity\FeatureFlag.cs" />
+			<Compile Include="..\OptimizelySDK\Entity\FeatureVariable.cs" />
+			<Compile Include="..\OptimizelySDK\Entity\Rollout.cs" />
+			<Compile Include="..\OptimizelySDK\ErrorHandler\DefaultErrorHandler.cs" />
+			<Compile Include="..\OptimizelySDK\ErrorHandler\IErrorHandler.cs" />
+			<Compile Include="..\OptimizelySDK\ErrorHandler\NoOpErrorHandler.cs" />
+			<Compile Include="..\OptimizelySDK\Event\Builder\EventBuilder.cs" />
+			<Compile Include="..\OptimizelySDK\Event\Builder\Params.cs" />
+			<Compile Include="..\OptimizelySDK\Event\Dispatcher\DefaultEventDispatcher.cs" />
+			<Compile Include="..\OptimizelySDK\Event\Dispatcher\WebRequestEventDispatcher35.cs" />
+			<Compile Include="..\OptimizelySDK\Event\Dispatcher\HttpClientEventDispatcher45.cs" />
+			<Compile Include="..\OptimizelySDK\Event\Dispatcher\IEventDispatcher.cs" />
+			<Compile Include="..\OptimizelySDK\Event\LogEvent.cs" />
+			<Compile Include="..\OptimizelySDK\Event\ForwardingEventProcessor.cs" />
+			<Compile Include="..\OptimizelySDK\Exceptions\OptimizelyException.cs" />
+			<Compile Include="..\OptimizelySDK\IOptimizely.cs" />
+			<Compile Include="..\OptimizelySDK\Logger\DefaultLogger.cs" />
+			<Compile Include="..\OptimizelySDK\Logger\ILogger.cs" />
+			<Compile Include="..\OptimizelySDK\Logger\NoOpLogger.cs" />
+			<Compile Include="..\OptimizelySDK\Notifications\NotificationCenter.cs" />
+			<Compile Include="..\OptimizelySDK\Optimizely.cs" />
+			<Compile Include="..\OptimizelySDK\Utils\EventTagUtils.cs" />
+			<Compile Include="..\OptimizelySDK\Utils\Validator.cs" />
+			<Compile Include=".\Properties\AssemblyInfo.cs" />
+			<Compile Include="..\OptimizelySDK\Utils\ConfigParser.cs" />
+			<Compile Include="..\OptimizelySDK\Utils\Schema.cs" />
+			<Compile Include="..\OptimizelySDK\Utils\ControlAttributes.cs" />
+			<Compile Include="..\OptimizelySDK\Utils\ExceptionExtensions.cs" />
+			<Compile Include="..\OptimizelySDK\Utils\ExperimentUtils.cs" />
+			<Compile Include="..\OptimizelySDK\Utils\ConditionParser.cs" />
+			<Compile Include="..\OptimizelySDK\Utils\AttributeMatchTypes.cs" />
+			<Compile Include="..\OptimizelySDK\Utils\DecisionInfoTypes.cs" />
+			<Compile Include="..\OptimizelySDK\Utils\DateTimeUtils.cs" />
+			<Compile Include="..\OptimizelySDK\Bucketing\Bucketer.cs" />
+			<Compile Include="..\OptimizelySDK\Bucketing\Decision.cs" />
+			<Compile Include="..\OptimizelySDK\Bucketing\DecisionService.cs" />
+			<Compile Include="..\OptimizelySDK\Bucketing\UserProfile.cs" />
+			<Compile Include="..\OptimizelySDK\Bucketing\UserProfileService.cs" />
+			<Compile Include="..\OptimizelySDK\Bucketing\UserProfileUtil.cs" />
+			<Compile Include="..\OptimizelySDK\ProjectConfig.cs" />
+			<Compile Include="..\OptimizelySDK\Config\DatafileProjectConfig.cs" />
+			<Compile Include="..\OptimizelySDK\Config\ProjectConfigManager.cs" />
+			<Compile Include="..\OptimizelySDK\Config\PollingProjectConfigManager.cs" />
+			<Compile Include="..\OptimizelySDK\Config\HttpProjectConfigManager.cs" />
+			<Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyConfig.cs" />
+			<Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyAttribute.cs" />
+			<Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyEvent.cs" />
+			<Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyExperiment.cs" />
+			<Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyFeature.cs" />
+			<Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyVariable.cs" />
+			<Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyVariation.cs" />
+			<Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyAudience.cs" />
+			<Compile Include="..\OptimizelySDK\OptlyConfig\OptimizelyConfigService.cs" />
+			<Compile Include="..\OptimizelySDK\OptlyConfig\IOptimizelyConfigManager.cs" />
+			<Compile Include="..\OptimizelySDK\OptimizelyDecisions\DecisionMessage.cs" />
+			<Compile Include="..\OptimizelySDK\OptimizelyDecisions\DecisionReasons.cs" />
+			<Compile Include="..\OptimizelySDK\OptimizelyDecisions\OptimizelyDecideOption.cs" />
+			<Compile Include="..\OptimizelySDK\OptimizelyDecisions\OptimizelyDecision.cs" />
+			<Compile Include="..\OptimizelySDK\OptimizelyUserContext.cs" />
+			<Compile Include="..\OptimizelySDK\Config\FallbackProjectConfigManager.cs" />
+			<Compile Include="..\OptimizelySDK\OptimizelyDecisionContext.cs" />
+			<Compile Include="..\OptimizelySDK\OptimizelyForcedDecision.cs">
+				<Link>OptimizelyForcedDecision.cs</Link>
+			</Compile>
+			<Compile Include="..\OptimizelySDK\OptimizelyFactory.cs">
+				<Link>OptimizelyFactory.cs</Link>
+			</Compile>
+			<Compile Include="..\OptimizelySDK\Event\Entity\ConversionEvent.cs">
+				<Link>ConversionEvent.cs</Link>
+			</Compile>
+			<Compile Include="..\OptimizelySDK\Event\Entity\EventBatch.cs">
+				<Link>EventBatch.cs</Link>
+			</Compile>
+			<Compile Include="..\OptimizelySDK\Event\Entity\EventContext.cs">
+				<Link>EventContext.cs</Link>
+			</Compile>
+			<Compile Include="..\OptimizelySDK\Event\Entity\ImpressionEvent.cs">
+				<Link>ImpressionEvent.cs</Link>
+			</Compile>
+			<Compile Include="..\OptimizelySDK\Event\Entity\Snapshot.cs">
+				<Link>Snapshot.cs</Link>
+			</Compile>
+			<Compile Include="..\OptimizelySDK\Event\Entity\SnapshotEvent.cs">
+				<Link>SnapshotEvent.cs</Link>
+			</Compile>
+			<Compile Include="..\OptimizelySDK\Event\Entity\UserEvent.cs">
+				<Link>UserEvent.cs</Link>
+			</Compile>
+			<Compile Include="..\OptimizelySDK\Event\Entity\Visitor.cs">
+				<Link>Visitor.cs</Link>
+			</Compile>
+			<Compile Include="..\OptimizelySDK\Event\Entity\VisitorAttribute.cs">
+				<Link>VisitorAttribute.cs</Link>
+			</Compile>
+			<Compile Include="..\OptimizelySDK\Event\Entity\DecisionMetadata.cs">
+				<Link>DecisionMetadata.cs</Link>
+			</Compile>
+			<Compile Include="..\OptimizelySDK\Event\Entity\Decision.cs">
+				<Link>DecisionEvent.cs</Link>
+			</Compile>
+			<Compile Include="..\OptimizelySDK\Event\EventFactory.cs">
+				<Link>EventFactory.cs</Link>
+			</Compile>
+			<Compile Include="..\OptimizelySDK\Event\UserEventFactory.cs">
+				<Link>UserEventFactory.cs</Link>
+			</Compile>
+			<Compile Include="..\OptimizelySDK\Event\EventProcessor.cs">
+				<Link>EventProcessor.cs</Link>
+			</Compile>
+			<Compile Include="..\OptimizelySDK\Entity\Result.cs">
+				<Link>Result.cs</Link>
+			</Compile>
     </ItemGroup>
     <ItemGroup>
         <EmbeddedResource Include="..\OptimizelySDK\Utils\schema.json">

From b209680095f750eeda2dfd868497a4f0c8a68d39 Mon Sep 17 00:00:00 2001
From: Dustin Sier <Dustin.Sier@episerver.com>
Date: Thu, 4 Nov 2021 17:38:26 -0400
Subject: [PATCH 071/130] Removed file

---
 OptimizelySDK.Tests/OptimizelySDK.Tests.csproj | 1 -
 1 file changed, 1 deletion(-)

diff --git a/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj b/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj
index a30ec700..26b18922 100644
--- a/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj
+++ b/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj
@@ -136,7 +136,6 @@
     </ProjectReference>
   </ItemGroup>
   <ItemGroup>
-    <None Include="fsc.json" />
     <None Include="packages.config" />
     <EmbeddedResource Include="unsupported_version_datafile.json" />
     <EmbeddedResource Include="typed_audience_datafile.json" />

From 758f5d0b3456da52c01bebb763e5f68764cedd7e Mon Sep 17 00:00:00 2001
From: Dustin Sier <Dustin.Sier@episerver.com>
Date: Thu, 4 Nov 2021 17:52:55 -0400
Subject: [PATCH 072/130] Fixed project issues

---
 OptimizelySDK.Net40/OptimizelySDK.Net40.csproj | 2 --
 1 file changed, 2 deletions(-)

diff --git a/OptimizelySDK.Net40/OptimizelySDK.Net40.csproj b/OptimizelySDK.Net40/OptimizelySDK.Net40.csproj
index 3889bb46..67c0d250 100644
--- a/OptimizelySDK.Net40/OptimizelySDK.Net40.csproj
+++ b/OptimizelySDK.Net40/OptimizelySDK.Net40.csproj
@@ -192,8 +192,6 @@
     <Compile Include="..\OptimizelySDK\Utils\DateTimeUtils.cs">
       <Link>Utils\DateTimeUtils.cs</Link>
     </Compile>
-    <Compile Include="OptimizelyDecisionContext.cs" />
-    <Compile Include="OptimizelyForcedDecision.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="..\OptimizelySDK\Bucketing\Bucketer.cs">
       <Link>Bucketing\Bucketer.cs</Link>

From 01a90cabc28ccbced343854930989bcb4f33d661 Mon Sep 17 00:00:00 2001
From: Dustin Sier <Dustin.Sier@episerver.com>
Date: Thu, 4 Nov 2021 18:30:05 -0400
Subject: [PATCH 073/130] Updated to account for correct null rulekey

---
 OptimizelySDK/OptimizelyUserContext.cs | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index b7fcba3d..f0add3d1 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -293,13 +293,17 @@ public bool RemoveForcedDecision(OptimizelyDecisionContext context)
 
             if (ForcedDecisionsMap.TryGetValue(context.FlagKey, out var decision))
             {
-                decision.Remove(context.RuleKey);
-                if (decision.Count == 0)
+                if (!string.IsNullOrEmpty(context.RuleKey))
                 {
-                    ForcedDecisionsMap.Remove(context.FlagKey);
+                    decision.Remove(context.RuleKey);
+                    if (decision.Count == 0)
+                    {
+                        ForcedDecisionsMap.Remove(context.FlagKey);
+                        return true;
+                    }
                 }
             }
-            return true;
+            return false;
         }
 
         /// <summary>

From 7ea219e8344f77ca2816a24466d9d07b7e629474 Mon Sep 17 00:00:00 2001
From: Dustin Sier <Dustin.Sier@episerver.com>
Date: Thu, 4 Nov 2021 18:55:17 -0400
Subject: [PATCH 074/130] Update for handling null rule key correctly

---
 OptimizelySDK/OptimizelyUserContext.cs | 19 ++++++++++++-------
 1 file changed, 12 insertions(+), 7 deletions(-)

diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index f0add3d1..2c39188d 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -292,15 +292,20 @@ public bool RemoveForcedDecision(OptimizelyDecisionContext context)
             }
 
             if (ForcedDecisionsMap.TryGetValue(context.FlagKey, out var decision))
-            {
-                if (!string.IsNullOrEmpty(context.RuleKey))
+            { 
+                if(context.RuleKey == null)
+                {
+                    decision.Remove(OptimizelyDecisionContext.OPTI_NULL_RULE_KEY);
+                }
+                else if(decision.ContainsKey(context?.RuleKey))
                 {
                     decision.Remove(context.RuleKey);
-                    if (decision.Count == 0)
-                    {
-                        ForcedDecisionsMap.Remove(context.FlagKey);
-                        return true;
-                    }
+                }
+
+                if (decision.Count == 0)
+                {
+                    ForcedDecisionsMap.Remove(context.FlagKey);
+                    return true;
                 }
             }
             return false;

From 9e17cd856fc48811b4e8e81346877a46e4d466a5 Mon Sep 17 00:00:00 2001
From: Dustin Sier <Dustin.Sier@episerver.com>
Date: Thu, 4 Nov 2021 19:00:24 -0400
Subject: [PATCH 075/130] Updated message

---
 OptimizelySDK/OptimizelyUserContext.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index 2c39188d..43a05f1c 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -348,7 +348,7 @@ public Result<Variation> FindValidatedForcedDecision(OptimizelyDecisionContext c
                     if (variation != null)
                     {
                         reasons.AddInfo("Decided by forced decision.");
-                        reasons.AddInfo("Variation {0} is mapped to {1} and user {2} in the forced decision map", variationKey, strRuleKey, this.UserId);
+                        reasons.AddInfo("Variation ({0}) is mapped to ({1}) and user ({2}) in the forced decision map", variationKey, strRuleKey, this.UserId);
                         return Result<Variation>.NewResult(variation, reasons);
                     }
                     else

From 03002e242f246dc3a472dc0b3139825bbdccd98c Mon Sep 17 00:00:00 2001
From: Dustin Sier <Dustin.Sier@episerver.com>
Date: Thu, 4 Nov 2021 19:17:16 -0400
Subject: [PATCH 076/130] Updated message again

---
 OptimizelySDK/OptimizelyUserContext.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index 43a05f1c..1e64e696 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -348,12 +348,12 @@ public Result<Variation> FindValidatedForcedDecision(OptimizelyDecisionContext c
                     if (variation != null)
                     {
                         reasons.AddInfo("Decided by forced decision.");
-                        reasons.AddInfo("Variation ({0}) is mapped to ({1}) and user ({2}) in the forced decision map", variationKey, strRuleKey, this.UserId);
+                        reasons.AddInfo("Variation ({0}) is mapped to ({1}) and user ({2}) in the forced decision map", variationKey, context.FlagKey, this.UserId);
                         return Result<Variation>.NewResult(variation, reasons);
                     }
                     else
                     {
-                        reasons.AddInfo("Invalid variation is mapped to {0} and user {1} in the forced decision map.", strRuleKey, this.UserId);
+                        reasons.AddInfo("Invalid variation is mapped to {0} and user {1} in the forced decision map.", context.FlagKey, this.UserId);
                     }
                 }
             }

From f4e348b5e0cd067c3dc150b15bf5eb2ec54078cb Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Thu, 4 Nov 2021 20:03:38 -0400
Subject: [PATCH 077/130] Fixed not checking for _just_ null on flagkey because
 empty is fine.

---
 OptimizelySDK/OptimizelyUserContext.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index b7fcba3d..7d9e4d5b 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -250,7 +250,7 @@ public string GetForcedDecision(OptimizelyDecisionContext context)
                 return null;
             }
 
-            if (context == null || string.IsNullOrEmpty(context.FlagKey))
+            if (context == null || context.FlagKey == null)
             {
                 Logger.Log(LogLevel.WARN, "flagKey cannot be null");
                 return null;
@@ -279,7 +279,7 @@ public string GetForcedDecision(OptimizelyDecisionContext context)
         /// <returns>Whether the item was removed.</returns>
         public bool RemoveForcedDecision(OptimizelyDecisionContext context)
         {
-            if (context == null || string.IsNullOrEmpty(context.FlagKey))
+            if (context == null || context.FlagKey == null)
             {
                 Logger.Log(LogLevel.WARN, "flagKey cannot be null");
                 return false;

From a061f72e3f350c1a8a485081ca8d6093c66faa7a Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Thu, 4 Nov 2021 21:05:41 -0400
Subject: [PATCH 078/130] fixed refactor after changes to forced decision

---
 OptimizelySDK.Tests/Assertions.cs          |  9 ++++
 OptimizelySDK/OptimizelyDecisionContext.cs |  2 +-
 OptimizelySDK/OptimizelyUserContext.cs     | 54 ++++++++--------------
 3 files changed, 30 insertions(+), 35 deletions(-)

diff --git a/OptimizelySDK.Tests/Assertions.cs b/OptimizelySDK.Tests/Assertions.cs
index 4675c770..38bc7d1c 100644
--- a/OptimizelySDK.Tests/Assertions.cs
+++ b/OptimizelySDK.Tests/Assertions.cs
@@ -92,6 +92,15 @@ public static void AreEqual(KeyValuePair<string, string> expected, KeyValuePair<
 
         #endregion Basic asserts
 
+        #region
+
+        public static void AreEqual(OptimizelyForcedDecision expected, OptimizelyForcedDecision actual)
+        {
+            Assert.AreEqual(expected.VariationKey, actual.VariationKey);
+        }
+
+        #endregion
+
         #region OptimizelyAttribute
 
         public static void AreEquivalent(OptimizelyAttribute[] expected, OptimizelyAttribute[] actual)
diff --git a/OptimizelySDK/OptimizelyDecisionContext.cs b/OptimizelySDK/OptimizelyDecisionContext.cs
index 2e74cc15..73edd150 100644
--- a/OptimizelySDK/OptimizelyDecisionContext.cs
+++ b/OptimizelySDK/OptimizelyDecisionContext.cs
@@ -34,6 +34,6 @@ public OptimizelyDecisionContext(string flagKey, string ruleKey = null)
 
         public string RuleKey { get { return ruleKey; } }
 
-        public string GetDecisionKey { get { return decisionKey; } }
+        public string DecisionKey { get { return decisionKey; } }
     }
 }
diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index 7d9e4d5b..a8ca1b8b 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -41,7 +41,7 @@ public partial class OptimizelyUserContext
         // Optimizely object to be used.
         private Optimizely Optimizely;
 
-        private Dictionary<string, Dictionary<string, OptimizelyForcedDecision>> ForcedDecisionsMap { get; set; }
+        private Dictionary<string, OptimizelyForcedDecision> ForcedDecisionsMap { get; set; }
 
         public OptimizelyUserContext(Optimizely optimizely, string userId, UserAttributes userAttributes, IErrorHandler errorHandler, ILogger logger)
         {
@@ -49,17 +49,17 @@ public OptimizelyUserContext(Optimizely optimizely, string userId, UserAttribute
             Logger = logger;
             Optimizely = optimizely;
             Attributes = userAttributes ?? new UserAttributes();
-            ForcedDecisionsMap = new Dictionary<string, Dictionary<string, OptimizelyForcedDecision>>();
+            ForcedDecisionsMap = new Dictionary<string, OptimizelyForcedDecision>();
             UserId = userId;
         }
 
-        public OptimizelyUserContext(Optimizely optimizely, string userId, UserAttributes userAttributes, Dictionary<string, Dictionary<string, OptimizelyForcedDecision>> forcedDecisions, IErrorHandler errorHandler, ILogger logger)
+        public OptimizelyUserContext(Optimizely optimizely, string userId, UserAttributes userAttributes, Dictionary<string, OptimizelyForcedDecision> forcedDecisions, IErrorHandler errorHandler, ILogger logger)
         {
             ErrorHandler = errorHandler;
             Logger = logger;
             Optimizely = optimizely;
             Attributes = userAttributes ?? new UserAttributes();
-            ForcedDecisionsMap = forcedDecisions ?? new Dictionary<string, Dictionary<string, OptimizelyForcedDecision>>();
+            ForcedDecisionsMap = forcedDecisions ?? new Dictionary<string, OptimizelyForcedDecision>();
             UserId = userId;
         }
 
@@ -225,12 +225,7 @@ public bool SetForcedDecision(OptimizelyDecisionContext context, OptimizelyForce
 
             lock (mutex)
             {
-                ForcedDecisionsMap[context.FlagKey] = new Dictionary<string, OptimizelyForcedDecision>
-                {
-                    {
-                        context.RuleKey ?? OptimizelyDecisionContext.OPTI_NULL_RULE_KEY, new OptimizelyForcedDecision(decision.VariationKey)
-                    }
-                };
+                ForcedDecisionsMap.Add(context.DecisionKey, decision);
             }
 
             return true;
@@ -242,7 +237,7 @@ public bool SetForcedDecision(OptimizelyDecisionContext context, OptimizelyForce
         /// <param name="flagKey">The flag key</param>
         /// <param name="ruleKey">The rule key</param>
         /// <returns>The variation key for a forced decision</returns>
-        public string GetForcedDecision(OptimizelyDecisionContext context)
+        public OptimizelyForcedDecision GetForcedDecision(OptimizelyDecisionContext context)
         {
             if (!Optimizely.IsValid)
             {
@@ -256,19 +251,18 @@ public string GetForcedDecision(OptimizelyDecisionContext context)
                 return null;
             }
 
-            string variationKey = null;
+            if (ForcedDecisionsMap.Count == 0)
+            {
+                return null;
+            }
+
+            OptimizelyForcedDecision decision = null;
 
             lock (mutex)
             {
-                if (ForcedDecisionsMap.TryGetValue(context.FlagKey, out var forcedDecisionMap))
-                {
-                    if (forcedDecisionMap.TryGetValue(context.RuleKey ?? OptimizelyDecisionContext.OPTI_NULL_RULE_KEY, out var forcedDecision))
-                    {
-                        variationKey = forcedDecision.VariationKey;
-                    }
-                }
+                ForcedDecisionsMap.TryGetValue(context.DecisionKey, out decision);
             }
-            return variationKey;
+            return decision;
         }
 
         /// <summary>
@@ -291,15 +285,7 @@ public bool RemoveForcedDecision(OptimizelyDecisionContext context)
                 return false;
             }
 
-            if (ForcedDecisionsMap.TryGetValue(context.FlagKey, out var decision))
-            {
-                decision.Remove(context.RuleKey);
-                if (decision.Count == 0)
-                {
-                    ForcedDecisionsMap.Remove(context.FlagKey);
-                }
-            }
-            return true;
+            return ForcedDecisionsMap.Remove(context.DecisionKey);
         }
 
         /// <summary>
@@ -327,15 +313,15 @@ public bool RemoveAllForcedDecisions()
         public Result<Variation> FindValidatedForcedDecision(OptimizelyDecisionContext context)
         {
             DecisionReasons reasons = new DecisionReasons();
+            var forcedDecision = GetForcedDecision(context);
+            string strRuleKey = context.RuleKey ?? OptimizelyDecisionContext.OPTI_NULL_RULE_KEY;
 
-            string variationKey = GetForcedDecision(context);
             Variation variation = null;
-            if (variationKey != null)
+            if (forcedDecision != null)
             {
-                string strRuleKey = context.RuleKey ?? OptimizelyDecisionContext.OPTI_NULL_RULE_KEY;
-                if (!string.IsNullOrEmpty(variationKey))
+                if (forcedDecision != null)
                 {
-                    variation = Optimizely.ProjectConfigManager.GetConfig().GetFlagVariationByKey(context.FlagKey, variationKey);
+                    var variationKey = forcedDecision.VariationKey;
                     if (variation != null)
                     {
                         reasons.AddInfo("Decided by forced decision.");

From 4427c9f4f86707508922b071bd1f1411634d4355 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Thu, 4 Nov 2021 21:05:49 -0400
Subject: [PATCH 079/130] fixed unit tests

---
 OptimizelySDK.Tests/OptimizelyUserContextTest.cs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
index 1c316d1e..5141a41f 100644
--- a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
@@ -191,11 +191,11 @@ public void TestForcedDecisionReturnsCorrectGetDecisionKey()
             var user = Optimizely.CreateUserContext(UserID);
             var context = new OptimizelyDecisionContext("flag", null);
 
-            Assert.AreEqual(context.GetDecisionKey, "flag-$opt-null-rule-key");
+            Assert.AreEqual(context.DecisionKey, "flag-$opt-null-rule-key");
 
             context = new OptimizelyDecisionContext("flag", "ruleKey");
 
-            Assert.AreEqual(context.GetDecisionKey, "flag-ruleKey");
+            Assert.AreEqual(context.DecisionKey, "flag-ruleKey");
         }
 
         [Test]
@@ -258,7 +258,7 @@ public void TestGetForcedDecisionsReturnsValueWithRuleKey()
 
             var result = user.GetForcedDecision(context);
 
-            Assert.AreEqual("variation", result);
+            Assertions.AreEqual(decision, result);
         }
 
         [Test]
@@ -271,7 +271,7 @@ public void TestGetForcedDecisionReturnsValueWithoutRuleKey()
 
             var result = user.GetForcedDecision(context);
 
-            Assert.AreEqual("variationKey", result);
+            Assertions.AreEqual(decision, result);
         }
 
         [Test]
@@ -284,7 +284,7 @@ public void TestGetForcedDecisionReturnsValueWithOnlyFlagKey()
 
             var result = user.GetForcedDecision(context);
 
-            Assert.AreEqual("variationKey", result);
+            Assertions.AreEqual(decision, result);
         }
 
         [Test]
@@ -297,7 +297,7 @@ public void TestGetForcedDecisionReturnsValueWithRuleKey()
 
             var result = user.GetForcedDecision(context);
 
-            Assert.AreEqual("variationKey", result);
+            Assertions.AreEqual(decision, result);
         }
 
         [Test]

From 6793b0b58ad1dec964fbc672c2123b8867b710aa Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Thu, 4 Nov 2021 22:13:34 -0400
Subject: [PATCH 080/130] additonal cleanup after refactor

---
 OptimizelySDK/Optimizely.cs            | 23 +++++++++++++++++++++--
 OptimizelySDK/OptimizelyUserContext.cs | 24 +++++++++++-------------
 2 files changed, 32 insertions(+), 15 deletions(-)

diff --git a/OptimizelySDK/Optimizely.cs b/OptimizelySDK/Optimizely.cs
index d34735d3..75a515ad 100644
--- a/OptimizelySDK/Optimizely.cs
+++ b/OptimizelySDK/Optimizely.cs
@@ -444,6 +444,25 @@ public Variation GetForcedVariation(string experimentKey, string userId)
             return DecisionService.GetForcedVariation(experimentKey, userId, config).ResultObject;
         }
 
+        public Variation GetFlagVariationByKey(string flagKey, string variationKey)
+        {
+            var flagVariationMap = ProjectConfigManager?.GetConfig().FlagVariationMap;
+            if (flagVariationMap.ContainsKey(flagKey) == true)
+            {
+                flagVariationMap.TryGetValue(flagKey, out var variations);
+
+                foreach (var variation in variations)
+                {
+                    if (variation.Key.Equals(variationKey))
+                    {
+                        return variation;
+                    }
+                }
+            }
+
+            return null;
+        }
+
         #region FeatureFlag APIs
 
         /// <summary>
@@ -744,7 +763,7 @@ internal OptimizelyDecision Decide(OptimizelyUserContext user,
             }
 
             var flag = config.GetFeatureFlagFromKey(key);
-            if (string.IsNullOrEmpty(flag.Key))
+            if (flag.Key == null)
             {
                 return OptimizelyDecision.NewErrorDecision(key,
                     user,
@@ -761,7 +780,7 @@ internal OptimizelyDecision Decide(OptimizelyUserContext user,
 
             var decisionContext = new OptimizelyDecisionContext(flag.Key);
             var forcedDecisionVariation = user.FindValidatedForcedDecision(decisionContext);
-            if (forcedDecisionVariation?.ResultObject != null)
+            if (forcedDecisionVariation != null)
             {
                 decision = new FeatureDecision(null, forcedDecisionVariation.ResultObject, FeatureDecision.DECISION_SOURCE_FEATURE_TEST);
                 decisionReasons = forcedDecisionVariation.DecisionReasons;
diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index d5db3108..6e9642f7 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -319,22 +319,20 @@ public Result<Variation> FindValidatedForcedDecision(OptimizelyDecisionContext c
             Variation variation = null;
             if (forcedDecision != null)
             {
-                if (forcedDecision != null)
+                var variationKey = forcedDecision.VariationKey;
+                variation = Optimizely.GetFlagVariationByKey(context.FlagKey, variationKey);
+                if (variation != null)
                 {
-                    var variationKey = forcedDecision.VariationKey;
-                    if (variation != null)
-                    {
-                        reasons.AddInfo("Decided by forced decision.");
-                        reasons.AddInfo("Variation ({0}) is mapped to ({1}) and user ({2}) in the forced decision map", variationKey, context.FlagKey, this.UserId);
-                        return Result<Variation>.NewResult(variation, reasons);
-                    }
-                    else
-                    {
-                        reasons.AddInfo("Invalid variation is mapped to {0} and user {1} in the forced decision map.", context.FlagKey, this.UserId);
-                    }
+                    reasons.AddInfo("Decided by forced decision.");
+                    reasons.AddInfo("Variation ({0}) is mapped to ({1}) and user ({2}) in the forced decision map", variationKey, context.FlagKey, this.UserId);
+                    return Result<Variation>.NewResult(variation, reasons);
+                }
+                else
+                {
+                    reasons.AddInfo("Invalid variation is mapped to {0} and user {1} in the forced decision map.", context.FlagKey, this.UserId);
                 }
             }
-            return Result<Variation>.NullResult(reasons);
+            return Result<Variation>.NewResult(null, reasons);
         }
     }
 }

From 0211a2d89b0f3ae9b5244902231d09de254adab1 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Fri, 5 Nov 2021 11:45:41 -0400
Subject: [PATCH 081/130] Updates to try and clean this up to handle nulls
 correctly across the board.

---
 .gitignore                                    |   1 +
 OptimizelySDK.Tests/Assertions.cs             |  71 ++++++++++++
 .../OptimizelyUserContextTest.cs              | 105 ++++++++++++++++++
 OptimizelySDK/Optimizely.cs                   |   2 +-
 OptimizelySDK/OptimizelyUserContext.cs        |   2 +-
 5 files changed, 179 insertions(+), 2 deletions(-)

diff --git a/.gitignore b/.gitignore
index 28373588..666f0e93 100644
--- a/.gitignore
+++ b/.gitignore
@@ -245,3 +245,4 @@ OptimizelySDK.Package/nuget.exe
 OptimizelySDK.Package/content
 OptimizelySDK.Package/lib
 /OptimizelySDK.Tests/fsc.json
+/datafiles
diff --git a/OptimizelySDK.Tests/Assertions.cs b/OptimizelySDK.Tests/Assertions.cs
index 38bc7d1c..cce343fb 100644
--- a/OptimizelySDK.Tests/Assertions.cs
+++ b/OptimizelySDK.Tests/Assertions.cs
@@ -90,6 +90,12 @@ public static void AreEqual(KeyValuePair<string, string> expected, KeyValuePair<
             Assert.AreEqual(expected.Value, actual.Value);
         }
 
+        private static void AreEquivalent(KeyValuePair<string, object> expected, KeyValuePair<string, object> actual)
+        {
+            Assert.AreEqual(expected.Key, actual.Key);
+            Assert.AreEqual(expected.Value, actual.Value);
+        }
+
         #endregion Basic asserts
 
         #region
@@ -174,6 +180,34 @@ public static void AreEqual(OptimizelyConfig expected, OptimizelyConfig actual)
 
         #endregion OptimizelyConfig
 
+        #region OptimizelyUserContext
+
+        private static void AreEqual(OptimizelyUserContext expected, OptimizelyUserContext actual)
+        {
+            Assert.AreEqual(expected.GetUserId(), actual.GetUserId());
+            AreEquivalent(expected.GetAttributes(), actual.GetAttributes());
+        }
+
+        private static void AreEquivalent(UserAttributes expected, UserAttributes actual)
+        {
+            Assert.AreEqual(expected.Count, actual.Count);
+            var zipped = expected.Zip(actual, (e, a) =>
+            {
+                return new
+                {
+                    Expected = e,
+                    Actual = a
+                };
+            }).ToList();
+
+            foreach (var z in zipped)
+            {
+                AreEquivalent(z.Expected, z.Actual);
+            };
+        }
+
+        #endregion
+
         #region OptimizelyEvent
 
         public static void AreEquivalent(OptimizelyEvent[] expected, OptimizelyEvent[] actual)
@@ -203,6 +237,43 @@ private static void AreEqual(OptimizelyEvent expected, OptimizelyEvent actual)
 
         #endregion OptimizelyEvent
 
+        #region OptimizelyDecision
+
+        public static void AreEqual(OptimizelyDecision expected, OptimizelyDecision actual)
+        {
+            Assert.AreEqual(expected.Enabled, actual.Enabled);
+            Assert.AreEqual(expected.FlagKey, actual.FlagKey);
+            AreEquivalent(expected.Reasons, actual.Reasons);
+            Assert.AreEqual(expected.RuleKey, actual.RuleKey);
+            AreEqual(expected.UserContext, actual.UserContext);
+        }
+
+        public static void AreEquivalent(IDictionary<string, OptimizelyDecision> expected, IDictionary<string, OptimizelyDecision> actual)
+        {
+            Assert.AreEqual(expected.Count, actual.Count);
+            var zipped = expected.Zip(actual, (e, a) =>
+            {
+                return new
+                {
+                    Expected = e,
+                    Actual = a
+                };
+            }).ToList();
+
+            foreach (var z in zipped)
+            {
+                AreEquivalent(z.Expected, z.Actual);
+            };
+        }
+
+        public static void AreEquivalent(KeyValuePair<string, OptimizelyDecision> expected, KeyValuePair<string, OptimizelyDecision> actual)
+        {
+            Assert.AreEqual(expected.Key, actual.Key);
+            AreEqual(expected.Value, actual.Value);
+        }
+
+        #endregion
+
         #region OptimizelyExperiement
 
         public static void AreEquivalent(List<OptimizelyExperiment> expected, List<OptimizelyExperiment> actual)
diff --git a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
index 5141a41f..7d1deff3 100644
--- a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
@@ -317,6 +317,111 @@ public void TestFindValidatedForcedDecisionReturnsCorrectDecision()
             Assertions.AreEqual(expectedResult, result);
         }
 
+        [Test]
+        public void TestSetForcedDecisionIsCalledTwiceWithMultipleFlagKeys()
+        {
+            var datafile = "";
+            using (System.IO.StreamReader reader = new System.IO.StreamReader(@"C:\Users\Dustin\dev\csharp\csharp-sdk\datafiles\flags_with_rollouts.json"))
+                datafile = reader.ReadToEnd();
+
+            var expected = new Dictionary<string, OptimizelyDecision>
+            {
+                { "flag_1", new OptimizelyDecision("variation_1", true, null, null, "flag_1", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
+                { "flag_2", new OptimizelyDecision("variation_2", true, null, null, "flag_2", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
+                { "flag_3", new OptimizelyDecision(null, true, null, "flag_3_targeted_delivery", "flag_3", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
+                { "flag_4", new OptimizelyDecision(null, true, null, "experiment_flag_4", "flag_4", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
+            };
+
+            Optimizely = new Optimizely(datafile, EventDispatcherMock.Object, LoggerMock.Object, ErrorHandlerMock.Object);
+            var user = Optimizely.CreateUserContext("test_user_1");
+            var context = new OptimizelyDecisionContext("flag_1");
+            var decision = new OptimizelyForcedDecision("variation_1");
+
+            var context2 = new OptimizelyDecisionContext("flag_2");
+            var decision2 = new OptimizelyForcedDecision("variation_2");
+
+            user.SetForcedDecision(context, decision);
+            user.SetForcedDecision(context2, decision2);
+
+            var result = user.DecideAll();
+
+            Assertions.AreEquivalent(expected, result);
+        }
+
+        [Test]
+        public void TestRemoveForcedDecisionsCalledBeforeDecideAll()
+        {
+            var datafile = "";
+            using (System.IO.StreamReader reader = new System.IO.StreamReader(@"C:\Users\Dustin\dev\csharp\csharp-sdk\datafiles\flags_with_rollouts.json"))
+                datafile = reader.ReadToEnd();
+
+            var expected = new Dictionary<string, OptimizelyDecision>
+            {
+                { "flag_1", new OptimizelyDecision("exp_variation_1", true, null, "experiment_1_flag_1", "flag_1", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
+                { "flag_2", new OptimizelyDecision("exp_variation_2", true, null, null, "flag_2", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
+                { "flag_3", new OptimizelyDecision("variation_1", true, null, "flag_3_targeted_delivery", "flag_3", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
+                { "flag_4", new OptimizelyDecision("exp_variation_1", true, null, "experiment_flag_4", "flag_4", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
+            };
+
+            Optimizely = new Optimizely(datafile, EventDispatcherMock.Object, LoggerMock.Object, ErrorHandlerMock.Object);
+
+            var user = Optimizely.CreateUserContext("test_user_1");
+
+            var context = new OptimizelyDecisionContext("flag_1");
+            var decision = new OptimizelyForcedDecision("variation_1");
+
+            var context2 = new OptimizelyDecisionContext("flag_2");
+            var decision2 = new OptimizelyForcedDecision("variation_2");
+
+            user.SetForcedDecision(context, decision);
+            user.SetForcedDecision(context2, decision2);
+
+            var remove = user.RemoveForcedDecision(context);
+
+            Assert.IsTrue(remove);
+
+            var actual = user.DecideAll();
+
+            Assertions.AreEquivalent(expected, actual);
+        }
+
+        [Test]
+        public void TestRemoveAllForcedDecisionsBeforeDecideAll()
+        {
+            var datafile = "";
+            using (System.IO.StreamReader reader = new System.IO.StreamReader(@"C:\Users\Dustin\dev\csharp\csharp-sdk\datafiles\flags_with_rollouts.json"))
+                datafile = reader.ReadToEnd();
+
+            var expected = new Dictionary<string, OptimizelyDecision>
+            {
+                { "flag_1", new OptimizelyDecision("exp_variation_1", true, null, "experiment_1_flag_1", "flag_1", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
+                { "flag_2", new OptimizelyDecision("exp_variation_1", true, null, "experiment_1_flag_2", "flag_2", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
+                { "flag_3", new OptimizelyDecision("variation_1", true, null, "flag_3_targeted_delivery", "flag_3", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
+                { "flag_4", new OptimizelyDecision("exp_variation_1", true, null, "experiment_flag_4", "flag_4", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
+            };
+
+            Optimizely = new Optimizely(datafile, EventDispatcherMock.Object, LoggerMock.Object, ErrorHandlerMock.Object);
+
+            var user = Optimizely.CreateUserContext("test_user_1");
+
+            var context = new OptimizelyDecisionContext("flag_1");
+            var decision = new OptimizelyForcedDecision("variation_1");
+
+            var context2 = new OptimizelyDecisionContext("flag_2");
+            var decision2 = new OptimizelyForcedDecision("variation_2");
+
+            user.SetForcedDecision(context, decision);
+            user.SetForcedDecision(context2, decision2);
+
+            var remove = user.RemoveAllForcedDecisions();
+
+            Assert.IsTrue(remove);
+
+            var actual = user.DecideAll();
+
+            Assertions.AreEquivalent(expected, actual);
+        }
+
         [Test]
         public void TestFindValidatedForcedDecisionReturnsCorrectDecisionWithNullVariation()
         {
diff --git a/OptimizelySDK/Optimizely.cs b/OptimizelySDK/Optimizely.cs
index 75a515ad..0a2cc9e4 100644
--- a/OptimizelySDK/Optimizely.cs
+++ b/OptimizelySDK/Optimizely.cs
@@ -849,7 +849,7 @@ internal OptimizelyDecision Decide(OptimizelyUserContext user,
             var variationKey = decision?.Variation?.Key;
 
             // TODO: add ruleKey values when available later. use a copy of experimentKey until then.
-            var ruleKey = decision?.Experiment != null ? decision?.Experiment?.Key : null;
+            var ruleKey = decision != null ? decision?.Experiment?.Key : null;
 
             var decisionInfo = new Dictionary<string, object>
             {
diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index 6e9642f7..effd0525 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -332,7 +332,7 @@ public Result<Variation> FindValidatedForcedDecision(OptimizelyDecisionContext c
                     reasons.AddInfo("Invalid variation is mapped to {0} and user {1} in the forced decision map.", context.FlagKey, this.UserId);
                 }
             }
-            return Result<Variation>.NewResult(null, reasons);
+            return null;
         }
     }
 }

From 5ff593e6752d760a62c45088433bc287febb2904 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Fri, 5 Nov 2021 11:47:00 -0400
Subject: [PATCH 082/130] Removed unnecessary tests

---
 .../OptimizelyUserContextTest.cs              | 105 ------------------
 1 file changed, 105 deletions(-)

diff --git a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
index 7d1deff3..5141a41f 100644
--- a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
@@ -317,111 +317,6 @@ public void TestFindValidatedForcedDecisionReturnsCorrectDecision()
             Assertions.AreEqual(expectedResult, result);
         }
 
-        [Test]
-        public void TestSetForcedDecisionIsCalledTwiceWithMultipleFlagKeys()
-        {
-            var datafile = "";
-            using (System.IO.StreamReader reader = new System.IO.StreamReader(@"C:\Users\Dustin\dev\csharp\csharp-sdk\datafiles\flags_with_rollouts.json"))
-                datafile = reader.ReadToEnd();
-
-            var expected = new Dictionary<string, OptimizelyDecision>
-            {
-                { "flag_1", new OptimizelyDecision("variation_1", true, null, null, "flag_1", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
-                { "flag_2", new OptimizelyDecision("variation_2", true, null, null, "flag_2", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
-                { "flag_3", new OptimizelyDecision(null, true, null, "flag_3_targeted_delivery", "flag_3", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
-                { "flag_4", new OptimizelyDecision(null, true, null, "experiment_flag_4", "flag_4", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
-            };
-
-            Optimizely = new Optimizely(datafile, EventDispatcherMock.Object, LoggerMock.Object, ErrorHandlerMock.Object);
-            var user = Optimizely.CreateUserContext("test_user_1");
-            var context = new OptimizelyDecisionContext("flag_1");
-            var decision = new OptimizelyForcedDecision("variation_1");
-
-            var context2 = new OptimizelyDecisionContext("flag_2");
-            var decision2 = new OptimizelyForcedDecision("variation_2");
-
-            user.SetForcedDecision(context, decision);
-            user.SetForcedDecision(context2, decision2);
-
-            var result = user.DecideAll();
-
-            Assertions.AreEquivalent(expected, result);
-        }
-
-        [Test]
-        public void TestRemoveForcedDecisionsCalledBeforeDecideAll()
-        {
-            var datafile = "";
-            using (System.IO.StreamReader reader = new System.IO.StreamReader(@"C:\Users\Dustin\dev\csharp\csharp-sdk\datafiles\flags_with_rollouts.json"))
-                datafile = reader.ReadToEnd();
-
-            var expected = new Dictionary<string, OptimizelyDecision>
-            {
-                { "flag_1", new OptimizelyDecision("exp_variation_1", true, null, "experiment_1_flag_1", "flag_1", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
-                { "flag_2", new OptimizelyDecision("exp_variation_2", true, null, null, "flag_2", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
-                { "flag_3", new OptimizelyDecision("variation_1", true, null, "flag_3_targeted_delivery", "flag_3", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
-                { "flag_4", new OptimizelyDecision("exp_variation_1", true, null, "experiment_flag_4", "flag_4", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
-            };
-
-            Optimizely = new Optimizely(datafile, EventDispatcherMock.Object, LoggerMock.Object, ErrorHandlerMock.Object);
-
-            var user = Optimizely.CreateUserContext("test_user_1");
-
-            var context = new OptimizelyDecisionContext("flag_1");
-            var decision = new OptimizelyForcedDecision("variation_1");
-
-            var context2 = new OptimizelyDecisionContext("flag_2");
-            var decision2 = new OptimizelyForcedDecision("variation_2");
-
-            user.SetForcedDecision(context, decision);
-            user.SetForcedDecision(context2, decision2);
-
-            var remove = user.RemoveForcedDecision(context);
-
-            Assert.IsTrue(remove);
-
-            var actual = user.DecideAll();
-
-            Assertions.AreEquivalent(expected, actual);
-        }
-
-        [Test]
-        public void TestRemoveAllForcedDecisionsBeforeDecideAll()
-        {
-            var datafile = "";
-            using (System.IO.StreamReader reader = new System.IO.StreamReader(@"C:\Users\Dustin\dev\csharp\csharp-sdk\datafiles\flags_with_rollouts.json"))
-                datafile = reader.ReadToEnd();
-
-            var expected = new Dictionary<string, OptimizelyDecision>
-            {
-                { "flag_1", new OptimizelyDecision("exp_variation_1", true, null, "experiment_1_flag_1", "flag_1", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
-                { "flag_2", new OptimizelyDecision("exp_variation_1", true, null, "experiment_1_flag_2", "flag_2", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
-                { "flag_3", new OptimizelyDecision("variation_1", true, null, "flag_3_targeted_delivery", "flag_3", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
-                { "flag_4", new OptimizelyDecision("exp_variation_1", true, null, "experiment_flag_4", "flag_4", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
-            };
-
-            Optimizely = new Optimizely(datafile, EventDispatcherMock.Object, LoggerMock.Object, ErrorHandlerMock.Object);
-
-            var user = Optimizely.CreateUserContext("test_user_1");
-
-            var context = new OptimizelyDecisionContext("flag_1");
-            var decision = new OptimizelyForcedDecision("variation_1");
-
-            var context2 = new OptimizelyDecisionContext("flag_2");
-            var decision2 = new OptimizelyForcedDecision("variation_2");
-
-            user.SetForcedDecision(context, decision);
-            user.SetForcedDecision(context2, decision2);
-
-            var remove = user.RemoveAllForcedDecisions();
-
-            Assert.IsTrue(remove);
-
-            var actual = user.DecideAll();
-
-            Assertions.AreEquivalent(expected, actual);
-        }
-
         [Test]
         public void TestFindValidatedForcedDecisionReturnsCorrectDecisionWithNullVariation()
         {

From 8ef2a93bf38a2b430e6e6a1ad09d21604b786085 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Fri, 5 Nov 2021 12:08:16 -0400
Subject: [PATCH 083/130] Removed redundant test

---
 .../OptimizelyUserContextTest.cs              | 19 +------------------
 1 file changed, 1 insertion(+), 18 deletions(-)

diff --git a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
index 5141a41f..6c4a51cf 100644
--- a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
@@ -300,23 +300,6 @@ public void TestGetForcedDecisionReturnsValueWithRuleKey()
             Assertions.AreEqual(decision, result);
         }
 
-        [Test]
-        public void TestFindValidatedForcedDecisionReturnsCorrectDecision()
-        {
-            var decisionReasons = new DecisionReasons();
-            decisionReasons.AddInfo("{0}", "Variation variation is mapped to flag: flagKey and rule: rule in the forced decision map.");
-            var expectedResult = Result<Variation>.NewResult(new Variation { }, decisionReasons);
-            var user = Optimizely.CreateUserContext(UserID);
-
-            var context = new OptimizelyDecisionContext("flagKey", "ruleKey");
-            var decision = new OptimizelyForcedDecision("variationKey");
-            user.SetForcedDecision(context, decision);
-
-            var result = user.FindValidatedForcedDecision(context);
-
-            Assertions.AreEqual(expectedResult, result);
-        }
-
         [Test]
         public void TestFindValidatedForcedDecisionReturnsCorrectDecisionWithNullVariation()
         {
@@ -329,7 +312,7 @@ public void TestFindValidatedForcedDecisionReturnsCorrectDecisionWithNullVariati
 
             var result = user.FindValidatedForcedDecision(context);
 
-            Assertions.AreEqual(expectedResult, result);
+            Assert.IsNull(result);
         }
 
         [Test]

From 85ca51ddf585940f6a4634c2a276c33c8e3dea3c Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Fri, 5 Nov 2021 12:32:29 -0400
Subject: [PATCH 084/130] Changed to return nullresult iinstead of null, like
 other places

---
 OptimizelySDK/Optimizely.cs            | 2 +-
 OptimizelySDK/OptimizelyUserContext.cs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/OptimizelySDK/Optimizely.cs b/OptimizelySDK/Optimizely.cs
index 0a2cc9e4..615cc4b2 100644
--- a/OptimizelySDK/Optimizely.cs
+++ b/OptimizelySDK/Optimizely.cs
@@ -780,7 +780,7 @@ internal OptimizelyDecision Decide(OptimizelyUserContext user,
 
             var decisionContext = new OptimizelyDecisionContext(flag.Key);
             var forcedDecisionVariation = user.FindValidatedForcedDecision(decisionContext);
-            if (forcedDecisionVariation != null)
+            if (forcedDecisionVariation.ResultObject != Result<Variation>.NullResult(null).ResultObject)
             {
                 decision = new FeatureDecision(null, forcedDecisionVariation.ResultObject, FeatureDecision.DECISION_SOURCE_FEATURE_TEST);
                 decisionReasons = forcedDecisionVariation.DecisionReasons;
diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index effd0525..bc213634 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -332,7 +332,7 @@ public Result<Variation> FindValidatedForcedDecision(OptimizelyDecisionContext c
                     reasons.AddInfo("Invalid variation is mapped to {0} and user {1} in the forced decision map.", context.FlagKey, this.UserId);
                 }
             }
-            return null;
+            return Result<Variation>.NullResult(reasons);
         }
     }
 }

From 5edcc181cc6b259cf802ee1bffa92bcc230827be Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Fri, 5 Nov 2021 12:34:20 -0400
Subject: [PATCH 085/130] updated test

---
 OptimizelySDK.Tests/OptimizelyUserContextTest.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
index 6c4a51cf..31079d37 100644
--- a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
@@ -312,7 +312,7 @@ public void TestFindValidatedForcedDecisionReturnsCorrectDecisionWithNullVariati
 
             var result = user.FindValidatedForcedDecision(context);
 
-            Assert.IsNull(result);
+            Assertions.AreEqual(expectedResult, result);
         }
 
         [Test]

From a18f774c811b25ebc871d8d281c83d590c577807 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Fri, 5 Nov 2021 12:56:15 -0400
Subject: [PATCH 086/130] removed unneded list

---
 OptimizelySDK/OptimizelyUserContext.cs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index bc213634..db6be1f3 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -300,7 +300,10 @@ public bool RemoveAllForcedDecisions()
                 return false;
             }
 
-            ForcedDecisionsMap.Clear();
+            lock (mutex)
+            {
+                ForcedDecisionsMap.Clear();
+            }
             return true;
         }
 

From c9db119ada5b4ad0b59a53f07977a6a9592f6d3d Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Fri, 5 Nov 2021 13:01:52 -0400
Subject: [PATCH 087/130] check for null on eventbuilder

---
 OptimizelySDK/Event/Builder/EventBuilder.cs | 31 +++++++++++----------
 1 file changed, 16 insertions(+), 15 deletions(-)

diff --git a/OptimizelySDK/Event/Builder/EventBuilder.cs b/OptimizelySDK/Event/Builder/EventBuilder.cs
index 0f0b41b8..08f4920e 100644
--- a/OptimizelySDK/Event/Builder/EventBuilder.cs
+++ b/OptimizelySDK/Event/Builder/EventBuilder.cs
@@ -1,4 +1,4 @@
-/* 
+/*
  * Copyright 2017-2019, Optimizely
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 using OptimizelySDK.Bucketing;
 using OptimizelySDK.Entity;
 using OptimizelySDK.Logger;
@@ -92,9 +93,10 @@ private Dictionary<string, object> GetCommonParams(ProjectConfig config, string
 
             //Omit attribute values that are not supported by the log endpoint.
             foreach (var validUserAttribute in userAttributes.Where(attribute => Validator.IsUserAttributeValid(attribute)))
-            {                
+            {
                 var attributeId = config.GetAttributeId(validUserAttribute.Key);
-                if (!string.IsNullOrEmpty(attributeId)) {
+                if (!string.IsNullOrEmpty(attributeId))
+                {
                     userFeatures.Add(new Dictionary<string, object>
                     {
                         { "entity_id", attributeId },
@@ -123,25 +125,23 @@ private Dictionary<string, object> GetCommonParams(ProjectConfig config, string
 
         private Dictionary<string, object> GetImpressionParams(Experiment experiment, string variationId)
         {
-
             var impressionEvent = new Dictionary<string, object>();
 
             var decisions = new object[]
             {
                     new Dictionary<string, object>
                     {
-                        { Params.CAMPAIGN_ID,   experiment.LayerId },
-                        { Params.EXPERIMENT_ID, experiment.Id },
+                        { Params.CAMPAIGN_ID,   experiment != null ? experiment.LayerId : null },
+                        { Params.EXPERIMENT_ID, experiment != null ? experiment.Id : null },
                         { Params.VARIATION_ID,  variationId }
                     }
             };
 
-
             var events = new object[]
             {
                     new Dictionary<string, object>
                     {
-                        { "entity_id", experiment.LayerId },
+                        { "entity_id", experiment != null ? experiment.LayerId : null },
                         { "timestamp", DateTimeUtils.SecondsSince1970*1000 },
                         { "key", ACTIVATE_EVENT_KEY },
                         { "uuid", Guid.NewGuid() }
@@ -156,7 +156,6 @@ private Dictionary<string, object> GetImpressionParams(Experiment experiment, st
 
         private List<object> GetConversionParams(ProjectConfig config, string eventKey, string userId, Dictionary<string, object> eventTags)
         {
-
             var conversionEventParams = new List<object>();
             var snapshot = new Dictionary<string, object>();
 
@@ -168,16 +167,19 @@ private List<object> GetConversionParams(ProjectConfig config, string eventKey,
                         { "key", eventKey }
                     };
 
-            if (eventTags != null) {
+            if (eventTags != null)
+            {
                 var revenue = EventTagUtils.GetRevenueValue(eventTags, Logger);
 
-                if (revenue != null) {
+                if (revenue != null)
+                {
                     eventDict[EventTagUtils.REVENUE_EVENT_METRIC_NAME] = revenue;
                 }
 
                 var eventVallue = EventTagUtils.GetNumericValue(eventTags, Logger);
 
-                if (eventVallue != null) {
+                if (eventVallue != null)
+                {
                     eventDict[EventTagUtils.VALUE_EVENT_METRIC_NAME] = eventVallue;
                 }
 
@@ -198,7 +200,8 @@ private Dictionary<string, object> GetImpressionOrConversionParamsWithCommonPara
         {
             var visitors = commonParams[Params.VISITORS] as object[];
 
-            if (visitors.Length > 0) {
+            if (visitors.Length > 0)
+            {
                 var visitor = visitors[0] as Dictionary<string, object>;
                 visitor["snapshots"] = conversionOrImpressionOnlyParams;
             }
@@ -218,7 +221,6 @@ private Dictionary<string, object> GetImpressionOrConversionParamsWithCommonPara
         public virtual LogEvent CreateImpressionEvent(ProjectConfig config, Experiment experiment, string variationId,
             string userId, UserAttributes userAttributes)
         {
-
             var commonParams = GetCommonParams(config, userId, userAttributes ?? new UserAttributes());
             var impressionOnlyParams = GetImpressionParams(experiment, variationId);
 
@@ -227,7 +229,6 @@ public virtual LogEvent CreateImpressionEvent(ProjectConfig config, Experiment e
             return new LogEvent(IMPRESSION_ENDPOINT, impressionParams, HTTP_VERB, HTTP_HEADERS);
         }
 
-
         /// <summary>
         /// Create conversion event to be sent to the logging endpoint.
         /// </summary>

From c9acbdb31603556073338a28b6a62746d1b58f1b Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Mon, 8 Nov 2021 08:32:02 -0500
Subject: [PATCH 088/130] Removed unnecessary piece of test

---
 .../OptimizelyConfigTest.cs                   | 150 ------------------
 1 file changed, 150 deletions(-)

diff --git a/OptimizelySDK.Tests/OptimizelyConfigTests/OptimizelyConfigTest.cs b/OptimizelySDK.Tests/OptimizelyConfigTests/OptimizelyConfigTest.cs
index db1d634c..007ee360 100644
--- a/OptimizelySDK.Tests/OptimizelyConfigTests/OptimizelyConfigTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyConfigTests/OptimizelyConfigTest.cs
@@ -181,156 +181,6 @@ public void TestGetOptimizelyConfigSDKAndEnvironmentKeyDefault()
         public void TestGetOptimizelyConfigService()
         {
             var datafileProjectConfig = DatafileProjectConfig.Create(TestData.TypedAudienceDatafile, new NoOpLogger(), new ErrorHandler.NoOpErrorHandler());
-            var expectedflagVariations = new Dictionary<string, List<Variation>> {
-                {
-                    "feat_no_vars",
-                    new List<Variation> {
-                        new Variation
-                        {
-                            FeatureEnabled = true,
-                            FeatureVariableUsageInstances = new List<FeatureVariableUsage>(),
-                            Key = "11557362669",
-                            Id = "11557362669",
-                            VariableIdToVariableUsageInstanceMap = new Dictionary<string, FeatureVariableUsage>()
-                        },
-                        new Variation
-                        {
-                            FeatureEnabled = false,
-                            FeatureVariableUsageInstances = new List<FeatureVariableUsage>(),
-                            Key = "11475708558",
-                            Id = "11475708558",
-                            VariableIdToVariableUsageInstanceMap = new Dictionary<string, FeatureVariableUsage>()
-                        },
-                        new Variation
-                        {
-                            FeatureEnabled = true,
-                            FeatureVariableUsageInstances = new List<FeatureVariableUsage>(),
-                            Key = "11557362670",
-                            Id = "11557362670",
-                            VariableIdToVariableUsageInstanceMap = new Dictionary<string, FeatureVariableUsage>()
-                        },
-                        new Variation
-                        {
-                            FeatureEnabled = false,
-                            FeatureVariableUsageInstances = new List<FeatureVariableUsage>(),
-                            Key = "11475708559",
-                            Id = "11475708559",
-                            VariableIdToVariableUsageInstanceMap = new Dictionary<string, FeatureVariableUsage>()
-                        }
-                    }
-                },
-                {
-                    "feat_with_var",
-                    new List<Variation> {
-                        new Variation
-                        {
-                            FeatureEnabled = true,
-                            FeatureVariableUsageInstances = new List<FeatureVariableUsage>(),
-                            Key = "11557362669",
-                            Id = "11557362669",
-                            VariableIdToVariableUsageInstanceMap = new Dictionary<string, FeatureVariableUsage>()
-                        },
-                        new Variation
-                        {
-                            FeatureEnabled = false,
-                            FeatureVariableUsageInstances = new List<FeatureVariableUsage>(),
-                            Key = "11475708558",
-                            Id = "11475708558",
-                            VariableIdToVariableUsageInstanceMap = new Dictionary<string, FeatureVariableUsage>()
-                        },
-                        new Variation
-                        {
-                            FeatureEnabled = true,
-                            FeatureVariableUsageInstances = new List<FeatureVariableUsage>(),
-                            Key = "11557362670",
-                            Id = "11557362670",
-                            VariableIdToVariableUsageInstanceMap = new Dictionary<string, FeatureVariableUsage>()
-                        },
-                        new Variation
-                        {
-                            FeatureEnabled = false,
-                            FeatureVariableUsageInstances = new List<FeatureVariableUsage>(),
-                            Key = "11475708559",
-                            Id = "11475708559",
-                            VariableIdToVariableUsageInstanceMap = new Dictionary<string, FeatureVariableUsage>()
-                        }
-                    }
-                },
-                {
-                    "feat2",
-                    new List<Variation> {
-                        new Variation
-                        {
-                            FeatureEnabled = true,
-                            FeatureVariableUsageInstances = new List<FeatureVariableUsage>(),
-                            Key = "11557362669",
-                            Id = "11557362669",
-                            VariableIdToVariableUsageInstanceMap = new Dictionary<string, FeatureVariableUsage>()
-                        },
-                        new Variation
-                        {
-                            FeatureEnabled = false,
-                            FeatureVariableUsageInstances = new List<FeatureVariableUsage>(),
-                            Key = "11475708558",
-                            Id = "11475708558",
-                            VariableIdToVariableUsageInstanceMap = new Dictionary<string, FeatureVariableUsage>()
-                        },
-                        new Variation
-                        {
-                            FeatureEnabled = true,
-                            FeatureVariableUsageInstances = new List<FeatureVariableUsage>(),
-                            Key = "11557362670",
-                            Id = "11557362670",
-                            VariableIdToVariableUsageInstanceMap = new Dictionary<string, FeatureVariableUsage>()
-                        },
-                        new Variation
-                        {
-                            FeatureEnabled = false,
-                            FeatureVariableUsageInstances = new List<FeatureVariableUsage>(),
-                            Key = "11475708559",
-                            Id = "11475708559",
-                            VariableIdToVariableUsageInstanceMap = new Dictionary<string, FeatureVariableUsage>()
-                        }
-                    }
-                },
-                {
-                    "feat2_with_var",
-                    new List<Variation> {
-                        new Variation
-                        {
-                            FeatureEnabled = true,
-                            FeatureVariableUsageInstances = new List<FeatureVariableUsage>(),
-                            Key = "11557362669",
-                            Id = "11557362669",
-                            VariableIdToVariableUsageInstanceMap = new Dictionary<string, FeatureVariableUsage>()
-                        },
-                        new Variation
-                        {
-                            FeatureEnabled = false,
-                            FeatureVariableUsageInstances = new List<FeatureVariableUsage>(),
-                            Key = "11475708558",
-                            Id = "11475708558",
-                            VariableIdToVariableUsageInstanceMap = new Dictionary<string, FeatureVariableUsage>()
-                        },
-                        new Variation
-                        {
-                            FeatureEnabled = true,
-                            FeatureVariableUsageInstances = new List<FeatureVariableUsage>(),
-                            Key = "11557362670",
-                            Id = "11557362670",
-                            VariableIdToVariableUsageInstanceMap = new Dictionary<string, FeatureVariableUsage>()
-                        },
-                        new Variation
-                        {
-                            FeatureEnabled = false,
-                            FeatureVariableUsageInstances = new List<FeatureVariableUsage>(),
-                            Key = "11475708559",
-                            Id = "11475708559",
-                            VariableIdToVariableUsageInstanceMap = new Dictionary<string, FeatureVariableUsage>()
-                        }
-                    }
-                }
-            };
             IDictionary<string, OptimizelyExperiment> experimentsMap = new Dictionary<string, OptimizelyExperiment>
             {
                 {

From 964bba5890e940e420c0db879e9f8393ee7bdc82 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Mon, 8 Nov 2021 10:17:45 -0500
Subject: [PATCH 089/130] Added assertion to help with local FSC testing. Fixed
 logic in decisions.

---
 OptimizelySDK.Tests/Assertions.cs          |  7 ++++++-
 OptimizelySDK/Bucketing/DecisionService.cs |  2 +-
 OptimizelySDK/Optimizely.cs                | 17 +++++++++--------
 3 files changed, 16 insertions(+), 10 deletions(-)

diff --git a/OptimizelySDK.Tests/Assertions.cs b/OptimizelySDK.Tests/Assertions.cs
index cce343fb..ee741f71 100644
--- a/OptimizelySDK.Tests/Assertions.cs
+++ b/OptimizelySDK.Tests/Assertions.cs
@@ -90,6 +90,11 @@ public static void AreEqual(KeyValuePair<string, string> expected, KeyValuePair<
             Assert.AreEqual(expected.Value, actual.Value);
         }
 
+        public static void AreEqual(OptimizelyJSON expected, OptimizelyJSON actual)
+        {
+            Assert.AreEqual(expected.ToString(), actual.ToString());
+        }
+
         private static void AreEquivalent(KeyValuePair<string, object> expected, KeyValuePair<string, object> actual)
         {
             Assert.AreEqual(expected.Key, actual.Key);
@@ -182,7 +187,7 @@ public static void AreEqual(OptimizelyConfig expected, OptimizelyConfig actual)
 
         #region OptimizelyUserContext
 
-        private static void AreEqual(OptimizelyUserContext expected, OptimizelyUserContext actual)
+        public static void AreEqual(OptimizelyUserContext expected, OptimizelyUserContext actual)
         {
             Assert.AreEqual(expected.GetUserId(), actual.GetUserId());
             AreEquivalent(expected.GetAttributes(), actual.GetAttributes());
diff --git a/OptimizelySDK/Bucketing/DecisionService.cs b/OptimizelySDK/Bucketing/DecisionService.cs
index bb4d2278..a897040a 100644
--- a/OptimizelySDK/Bucketing/DecisionService.cs
+++ b/OptimizelySDK/Bucketing/DecisionService.cs
@@ -543,7 +543,7 @@ public virtual Result<FeatureDecision> GetVariationForFeatureExperiment(FeatureF
             }
 
             Logger.Log(LogLevel.INFO, reasons.AddInfo($"The user \"{userId}\" is not bucketed into any of the experiments on the feature \"{featureFlag.Key}\"."));
-            return Result<FeatureDecision>.NewResult(null, reasons);
+            return Result<FeatureDecision>.NullResult(reasons);
         }
 
         /// <summary>
diff --git a/OptimizelySDK/Optimizely.cs b/OptimizelySDK/Optimizely.cs
index 615cc4b2..edd1122b 100644
--- a/OptimizelySDK/Optimizely.cs
+++ b/OptimizelySDK/Optimizely.cs
@@ -780,10 +780,11 @@ internal OptimizelyDecision Decide(OptimizelyUserContext user,
 
             var decisionContext = new OptimizelyDecisionContext(flag.Key);
             var forcedDecisionVariation = user.FindValidatedForcedDecision(decisionContext);
+            decisionReasons += forcedDecisionVariation.DecisionReasons;
+
             if (forcedDecisionVariation.ResultObject != Result<Variation>.NullResult(null).ResultObject)
             {
                 decision = new FeatureDecision(null, forcedDecisionVariation.ResultObject, FeatureDecision.DECISION_SOURCE_FEATURE_TEST);
-                decisionReasons = forcedDecisionVariation.DecisionReasons;
             }
             else
             {
@@ -794,16 +795,15 @@ internal OptimizelyDecision Decide(OptimizelyUserContext user,
                     userAttributes,
                     allOptions
                 );
-                decisionReasons = flagDecisionResult.DecisionReasons;
+                decisionReasons += flagDecisionResult.DecisionReasons;
                 decision = flagDecisionResult.ResultObject;
             }
 
             var featureEnabled = false;
-            var variation = decision?.Variation;
 
-            if (variation != null)
+            if (decision?.Variation != null)
             {
-                featureEnabled = variation.FeatureEnabled.GetValueOrDefault();
+                featureEnabled = decision.Variation.FeatureEnabled.GetValueOrDefault();
             }
 
             if (featureEnabled)
@@ -814,6 +814,7 @@ internal OptimizelyDecision Decide(OptimizelyUserContext user,
             {
                 Logger.Log(LogLevel.INFO, "Feature \"" + key + "\" is not enabled for user \"" + userId + "\"");
             }
+
             var variableMap = new Dictionary<string, object>();
             if (flag?.Variables != null && !allOptions.Contains(OptimizelyDecideOption.EXCLUDE_VARIABLES))
             {
@@ -822,7 +823,7 @@ internal OptimizelyDecision Decide(OptimizelyUserContext user,
                     string variableValue = featureVariable.DefaultValue;
                     if (featureEnabled)
                     {
-                        var featureVariableUsageInstance = variation.GetFeatureVariableUsageFromId(featureVariable.Id);
+                        var featureVariableUsageInstance = decision?.Variation.GetFeatureVariableUsageFromId(featureVariable.Id);
                         if (featureVariableUsageInstance != null)
                         {
                             variableValue = featureVariableUsageInstance.Value;
@@ -843,13 +844,13 @@ internal OptimizelyDecision Decide(OptimizelyUserContext user,
             var decisionSource = decision?.Source ?? FeatureDecision.DECISION_SOURCE_ROLLOUT;
             if (!allOptions.Contains(OptimizelyDecideOption.DISABLE_DECISION_EVENT))
             {
-                decisionEventDispatched = SendImpressionEvent(decision?.Experiment, variation, userId, userAttributes, config, key, decisionSource, featureEnabled);
+                decisionEventDispatched = SendImpressionEvent(decision?.Experiment, decision?.Variation, userId, userAttributes, config, key, decisionSource, featureEnabled);
             }
             var reasonsToReport = decisionReasons.ToReport(allOptions.Contains(OptimizelyDecideOption.INCLUDE_REASONS)).ToArray();
             var variationKey = decision?.Variation?.Key;
 
             // TODO: add ruleKey values when available later. use a copy of experimentKey until then.
-            var ruleKey = decision != null ? decision?.Experiment?.Key : null;
+            var ruleKey = decision != null && decision.Experiment != null ? decision?.Experiment?.Key : null;
 
             var decisionInfo = new Dictionary<string, object>
             {

From d78a22bc3a27b8f9258ef4991bbcd1c0c8502857 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Mon, 8 Nov 2021 11:12:58 -0500
Subject: [PATCH 090/130] Fixed content of message

---
 .../OptimizelyUserContextTest.cs              | 235 ++++++++++++++++++
 OptimizelySDK/OptimizelyUserContext.cs        |   2 +-
 2 files changed, 236 insertions(+), 1 deletion(-)

diff --git a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
index 31079d37..8fa07f53 100644
--- a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
@@ -994,5 +994,240 @@ public void TrackEventEmptyAttributesWithEventTags()
         }
 
         #endregion TrackEvent
+
+        //[Test]
+        //public void TestSetForcedDecisionIsCalledTwiceWithMultipleFlagKeys()
+        //{
+        //    var datafile = "";
+        //    using (System.IO.StreamReader reader = new System.IO.StreamReader(@"C:\Users\Dustin\dev\csharp\csharp-sdk\datafiles\flags_with_rollouts.json"))
+        //        datafile = reader.ReadToEnd();
+
+        //    var expected = new Dictionary<string, OptimizelyDecision>
+        //    {
+        //        { "flag_1", new OptimizelyDecision("variation_1", true, null, null, "flag_1", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
+        //        { "flag_2", new OptimizelyDecision("variation_2", true, null, null, "flag_2", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
+        //        { "flag_3", new OptimizelyDecision(null, true, null, "flag_3_targeted_delivery", "flag_3", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
+        //        { "flag_4", new OptimizelyDecision(null, true, null, "experiment_flag_4", "flag_4", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
+        //    };
+
+        //    Optimizely = new Optimizely(datafile, EventDispatcherMock.Object, LoggerMock.Object, ErrorHandlerMock.Object);
+        //    var user = Optimizely.CreateUserContext("test_user_1");
+        //    var context = new OptimizelyDecisionContext("flag_1");
+        //    var decision = new OptimizelyForcedDecision("variation_1");
+
+        //    var context2 = new OptimizelyDecisionContext("flag_2");
+        //    var decision2 = new OptimizelyForcedDecision("variation_2");
+
+        //    user.SetForcedDecision(context, decision);
+        //    user.SetForcedDecision(context2, decision2);
+
+        //    var result = user.DecideAll();
+
+        //    Assertions.AreEquivalent(expected, result);
+        //}
+
+        [Test]
+        public void TestSetForcedDecisionIsCalledTwiceWithMultipleFlagKeys()
+        {
+            var datafile = "";
+            using (System.IO.StreamReader reader = new System.IO.StreamReader(@"C:\Users\Dustin\dev\csharp\csharp-sdk\datafiles\flags_with_rollouts.json"))
+                datafile = reader.ReadToEnd();
+
+            var variableMap = new Dictionary<string, object>();
+            var optimizelyJSONUsingMap = new OptimizelyJSON(variableMap, ErrorHandlerMock.Object, LoggerMock.Object);
+
+            var expected = new Dictionary<string, OptimizelyDecision>
+            {
+                { "flag_1", new OptimizelyDecision("exp_variation_1", true, optimizelyJSONUsingMap, null, "flag_1", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
+                { "flag_2", new OptimizelyDecision("exp_variation_2", true, optimizelyJSONUsingMap, null, "flag_2", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
+                { "flag_3", new OptimizelyDecision("variation_1", true, null, "flag_3_targeted_delivery", "flag_3", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
+                { "flag_4", new OptimizelyDecision("exp_variation_1", true, null, "experiment_flag_4", "flag_4", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
+            };
+
+            Optimizely = new Optimizely(datafile, EventDispatcherMock.Object, LoggerMock.Object, ErrorHandlerMock.Object);
+            var user = Optimizely.CreateUserContext("test_user_1");
+            var context = new OptimizelyDecisionContext("flag_1");
+            var decision = new OptimizelyForcedDecision("exp_variation_1");
+
+            var context2 = new OptimizelyDecisionContext("flag_2");
+            var decision2 = new OptimizelyForcedDecision("exp_variation_2");
+
+            user.SetForcedDecision(context, decision);
+            user.SetForcedDecision(context2, decision2);
+
+            var result = user.DecideAll();
+
+            Assertions.AreEquivalent(expected, result);
+        }
+
+        [Test]
+        public void TestRemoveForcedDecisionsCalledBeforeDecideAll()
+        {
+            var datafile = "";
+            using (System.IO.StreamReader reader = new System.IO.StreamReader(@"C:\Users\Dustin\dev\csharp\csharp-sdk\datafiles\flags_with_rollouts.json"))
+                datafile = reader.ReadToEnd();
+
+            var expected = new Dictionary<string, OptimizelyDecision>
+            {
+                { "flag_1", new OptimizelyDecision("variation_1", true, null, "experiment_1_flag_1", "flag_1", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
+                { "flag_2", new OptimizelyDecision("variation_2", true, null, null, "flag_2", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
+                { "flag_3", new OptimizelyDecision("variation_1", true, null, "flag_3_targeted_delivery", "flag_3", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
+                { "flag_4", new OptimizelyDecision("exp_variation_1", true, null, "experiment_flag_4", "flag_4", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
+            };
+
+            Optimizely = new Optimizely(datafile, EventDispatcherMock.Object, LoggerMock.Object, ErrorHandlerMock.Object);
+
+            var user = Optimizely.CreateUserContext("test_user_1");
+
+            var context = new OptimizelyDecisionContext("flag_1");
+            var decision = new OptimizelyForcedDecision("variation_1");
+
+            var context2 = new OptimizelyDecisionContext("flag_2");
+            var decision2 = new OptimizelyForcedDecision("variation_2");
+
+            user.SetForcedDecision(context, decision);
+            user.SetForcedDecision(context2, decision2);
+
+            var remove = user.RemoveForcedDecision(context);
+
+            Assert.IsTrue(remove);
+
+            var actual = user.DecideAll();
+
+            Assertions.AreEquivalent(expected, actual);
+        }
+
+        [Test]
+        public void TestSetForcedDecisionisCalledTwiceWithMultipleFlagKeys()
+        {
+            var datafile = "";
+            using (System.IO.StreamReader reader = new System.IO.StreamReader(@"C:\Users\Dustin\dev\csharp\csharp-sdk\datafiles\flags_with_rollouts.json"))
+                datafile = reader.ReadToEnd();
+
+            var expected = new Dictionary<string, OptimizelyDecision>
+            {
+                { "flag_1", new OptimizelyDecision("variation_1", true, null, null, "flag_1", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
+                { "flag_2", new OptimizelyDecision("variation_2", true, null, null, "flag_2", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
+            };
+
+            Optimizely = new Optimizely(datafile, EventDispatcherMock.Object, LoggerMock.Object, ErrorHandlerMock.Object);
+
+            var user = Optimizely.CreateUserContext("test_user_1");
+
+            var context = new OptimizelyDecisionContext("flag_1");
+            var decision = new OptimizelyForcedDecision("variation_1");
+
+            var context2 = new OptimizelyDecisionContext("flag_2");
+            var decision2 = new OptimizelyForcedDecision("variation_2");
+
+            user.SetForcedDecision(context, decision);
+            user.SetForcedDecision(context2, decision2);
+
+            var actual = user.DecideForKeys(new string[] { "flag_1", "flag_2" });
+
+            Assertions.AreEquivalent(expected, actual);
+        }
+
+        [Test]
+        public void TestRemoveForcedDecisionsCalledBeforeDecide()
+        {
+            var datafile = "";
+            using (System.IO.StreamReader reader = new System.IO.StreamReader(@"C:\Users\Dustin\dev\csharp\csharp-sdk\datafiles\flags_with_rollouts.json"))
+                datafile = reader.ReadToEnd();
+
+            var expected = new Dictionary<string, OptimizelyDecision>
+            {
+                { "flag_1", new OptimizelyDecision("exp_variation_1", true, null, "experiment_1_flag_1", "flag_1", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
+                { "flag_2", new OptimizelyDecision("variation_2", true, null, null, "flag_2", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
+            };
+
+            Optimizely = new Optimizely(datafile, EventDispatcherMock.Object, LoggerMock.Object, ErrorHandlerMock.Object);
+
+            var user = Optimizely.CreateUserContext("test_user_1");
+
+            var context = new OptimizelyDecisionContext("flag_1");
+            var decision = new OptimizelyForcedDecision("variation_1");
+
+            var context2 = new OptimizelyDecisionContext("flag_2");
+            var decision2 = new OptimizelyForcedDecision("variation_2");
+
+            user.SetForcedDecision(context, decision);
+            user.SetForcedDecision(context2, decision2);
+
+            var remove = user.RemoveForcedDecision(context);
+
+            Assert.IsTrue(remove);
+
+            var actual = user.DecideForKeys(new string[] { "flag_1", "flag_2" });
+
+            Assertions.AreEquivalent(expected, actual);
+        }
+
+        [Test]
+        public void TestRemoveAllForcedDecisionsBeforeDecideAll()
+        {
+            var datafile = "";
+            using (System.IO.StreamReader reader = new System.IO.StreamReader(@"C:\Users\Dustin\dev\csharp\csharp-sdk\datafiles\flags_with_rollouts.json"))
+                datafile = reader.ReadToEnd();
+
+            var expected = new Dictionary<string, OptimizelyDecision>
+            {
+                { "flag_1", new OptimizelyDecision("exp_variation_1", true, null, "experiment_1_flag_1", "flag_1", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
+                { "flag_2", new OptimizelyDecision("exp_variation_1", true, null, "experiment_1_flag_2", "flag_2", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
+                { "flag_3", new OptimizelyDecision("variation_1", true, null, "flag_3_targeted_delivery", "flag_3", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
+                { "flag_4", new OptimizelyDecision("exp_variation_1", true, null, "experiment_flag_4", "flag_4", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
+            };
+
+            Optimizely = new Optimizely(datafile, EventDispatcherMock.Object, LoggerMock.Object, ErrorHandlerMock.Object);
+
+            var user = Optimizely.CreateUserContext("test_user_1");
+
+            var context = new OptimizelyDecisionContext("flag_1");
+            var decision = new OptimizelyForcedDecision("variation_1");
+
+            var context2 = new OptimizelyDecisionContext("flag_2");
+            var decision2 = new OptimizelyForcedDecision("variation_2");
+
+            user.SetForcedDecision(context, decision);
+            user.SetForcedDecision(context2, decision2);
+
+            var remove = user.RemoveAllForcedDecisions();
+
+            Assert.IsTrue(remove);
+
+            var actual = user.DecideAll();
+
+            Assertions.AreEquivalent(expected, actual);
+        }
+
+        [Test]
+        public void TestEvaluateDecideAfterCallingSetForcedDecision()
+        {
+            var datafile = "";
+            using (System.IO.StreamReader reader = new System.IO.StreamReader(@"C:\Users\Dustin\dev\csharp\csharp-sdk\datafiles\flags_with_rollouts.json"))
+                datafile = reader.ReadToEnd();
+
+            var decision1 = new OptimizelyDecision("exp_variation_1", true, null, "experiment_1_flag_1", "flag_1", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]);
+            var decision2 = new OptimizelyDecision("exp_variation_1", true, null, "experiment_1_flag_1", "flag_1", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[] { "Variation (variation_1) is mapped to flag (flag_1) and user (test_user_1) in the forced decision map." });
+
+            Optimizely = new Optimizely(datafile, EventDispatcherMock.Object, LoggerMock.Object, ErrorHandlerMock.Object);
+
+            var user = Optimizely.CreateUserContext("test_user_1");
+
+            var result1 = user.Decide("flag_1");
+
+            Assertions.AreEqual(decision1, result1);
+
+            var context = new OptimizelyDecisionContext("flag_1");
+            var forcedDecision = new OptimizelyForcedDecision("variation_1");
+
+            var forcedDecisionSet = user.SetForcedDecision(context, forcedDecision);
+
+            Assert.IsTrue(forcedDecisionSet);
+
+            var result2 = user.Decide("flag_1");
+
+            Assertions.AreEqual(decision2, result2);
+        }
     }
 }
diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index db6be1f3..92ca5776 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -327,7 +327,7 @@ public Result<Variation> FindValidatedForcedDecision(OptimizelyDecisionContext c
                 if (variation != null)
                 {
                     reasons.AddInfo("Decided by forced decision.");
-                    reasons.AddInfo("Variation ({0}) is mapped to ({1}) and user ({2}) in the forced decision map", variationKey, context.FlagKey, this.UserId);
+                    reasons.AddInfo("Variation ({0}) is mapped to flag ({1}) and user ({2}) in the forced decision map", variationKey, context.FlagKey, this.UserId);
                     return Result<Variation>.NewResult(variation, reasons);
                 }
                 else

From 3bd099106d50dd968fc7fda27d391cd8b29c47d7 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Mon, 8 Nov 2021 11:25:00 -0500
Subject: [PATCH 091/130] Removed conditional toReport

---
 OptimizelySDK/Optimizely.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/OptimizelySDK/Optimizely.cs b/OptimizelySDK/Optimizely.cs
index edd1122b..eebf6143 100644
--- a/OptimizelySDK/Optimizely.cs
+++ b/OptimizelySDK/Optimizely.cs
@@ -846,7 +846,7 @@ internal OptimizelyDecision Decide(OptimizelyUserContext user,
             {
                 decisionEventDispatched = SendImpressionEvent(decision?.Experiment, decision?.Variation, userId, userAttributes, config, key, decisionSource, featureEnabled);
             }
-            var reasonsToReport = decisionReasons.ToReport(allOptions.Contains(OptimizelyDecideOption.INCLUDE_REASONS)).ToArray();
+            var reasonsToReport = decisionReasons.ToReport().ToArray();
             var variationKey = decision?.Variation?.Key;
 
             // TODO: add ruleKey values when available later. use a copy of experimentKey until then.

From b685bbd7bdf2b04c7f7c88e781fbf6112dfcbf04 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Mon, 8 Nov 2021 11:38:22 -0500
Subject: [PATCH 092/130] removed local fsc test help

---
 .../OptimizelyUserContextTest.cs              | 235 ------------------
 1 file changed, 235 deletions(-)

diff --git a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
index 8fa07f53..31079d37 100644
--- a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
@@ -994,240 +994,5 @@ public void TrackEventEmptyAttributesWithEventTags()
         }
 
         #endregion TrackEvent
-
-        //[Test]
-        //public void TestSetForcedDecisionIsCalledTwiceWithMultipleFlagKeys()
-        //{
-        //    var datafile = "";
-        //    using (System.IO.StreamReader reader = new System.IO.StreamReader(@"C:\Users\Dustin\dev\csharp\csharp-sdk\datafiles\flags_with_rollouts.json"))
-        //        datafile = reader.ReadToEnd();
-
-        //    var expected = new Dictionary<string, OptimizelyDecision>
-        //    {
-        //        { "flag_1", new OptimizelyDecision("variation_1", true, null, null, "flag_1", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
-        //        { "flag_2", new OptimizelyDecision("variation_2", true, null, null, "flag_2", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
-        //        { "flag_3", new OptimizelyDecision(null, true, null, "flag_3_targeted_delivery", "flag_3", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
-        //        { "flag_4", new OptimizelyDecision(null, true, null, "experiment_flag_4", "flag_4", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
-        //    };
-
-        //    Optimizely = new Optimizely(datafile, EventDispatcherMock.Object, LoggerMock.Object, ErrorHandlerMock.Object);
-        //    var user = Optimizely.CreateUserContext("test_user_1");
-        //    var context = new OptimizelyDecisionContext("flag_1");
-        //    var decision = new OptimizelyForcedDecision("variation_1");
-
-        //    var context2 = new OptimizelyDecisionContext("flag_2");
-        //    var decision2 = new OptimizelyForcedDecision("variation_2");
-
-        //    user.SetForcedDecision(context, decision);
-        //    user.SetForcedDecision(context2, decision2);
-
-        //    var result = user.DecideAll();
-
-        //    Assertions.AreEquivalent(expected, result);
-        //}
-
-        [Test]
-        public void TestSetForcedDecisionIsCalledTwiceWithMultipleFlagKeys()
-        {
-            var datafile = "";
-            using (System.IO.StreamReader reader = new System.IO.StreamReader(@"C:\Users\Dustin\dev\csharp\csharp-sdk\datafiles\flags_with_rollouts.json"))
-                datafile = reader.ReadToEnd();
-
-            var variableMap = new Dictionary<string, object>();
-            var optimizelyJSONUsingMap = new OptimizelyJSON(variableMap, ErrorHandlerMock.Object, LoggerMock.Object);
-
-            var expected = new Dictionary<string, OptimizelyDecision>
-            {
-                { "flag_1", new OptimizelyDecision("exp_variation_1", true, optimizelyJSONUsingMap, null, "flag_1", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
-                { "flag_2", new OptimizelyDecision("exp_variation_2", true, optimizelyJSONUsingMap, null, "flag_2", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
-                { "flag_3", new OptimizelyDecision("variation_1", true, null, "flag_3_targeted_delivery", "flag_3", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
-                { "flag_4", new OptimizelyDecision("exp_variation_1", true, null, "experiment_flag_4", "flag_4", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
-            };
-
-            Optimizely = new Optimizely(datafile, EventDispatcherMock.Object, LoggerMock.Object, ErrorHandlerMock.Object);
-            var user = Optimizely.CreateUserContext("test_user_1");
-            var context = new OptimizelyDecisionContext("flag_1");
-            var decision = new OptimizelyForcedDecision("exp_variation_1");
-
-            var context2 = new OptimizelyDecisionContext("flag_2");
-            var decision2 = new OptimizelyForcedDecision("exp_variation_2");
-
-            user.SetForcedDecision(context, decision);
-            user.SetForcedDecision(context2, decision2);
-
-            var result = user.DecideAll();
-
-            Assertions.AreEquivalent(expected, result);
-        }
-
-        [Test]
-        public void TestRemoveForcedDecisionsCalledBeforeDecideAll()
-        {
-            var datafile = "";
-            using (System.IO.StreamReader reader = new System.IO.StreamReader(@"C:\Users\Dustin\dev\csharp\csharp-sdk\datafiles\flags_with_rollouts.json"))
-                datafile = reader.ReadToEnd();
-
-            var expected = new Dictionary<string, OptimizelyDecision>
-            {
-                { "flag_1", new OptimizelyDecision("variation_1", true, null, "experiment_1_flag_1", "flag_1", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
-                { "flag_2", new OptimizelyDecision("variation_2", true, null, null, "flag_2", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
-                { "flag_3", new OptimizelyDecision("variation_1", true, null, "flag_3_targeted_delivery", "flag_3", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
-                { "flag_4", new OptimizelyDecision("exp_variation_1", true, null, "experiment_flag_4", "flag_4", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
-            };
-
-            Optimizely = new Optimizely(datafile, EventDispatcherMock.Object, LoggerMock.Object, ErrorHandlerMock.Object);
-
-            var user = Optimizely.CreateUserContext("test_user_1");
-
-            var context = new OptimizelyDecisionContext("flag_1");
-            var decision = new OptimizelyForcedDecision("variation_1");
-
-            var context2 = new OptimizelyDecisionContext("flag_2");
-            var decision2 = new OptimizelyForcedDecision("variation_2");
-
-            user.SetForcedDecision(context, decision);
-            user.SetForcedDecision(context2, decision2);
-
-            var remove = user.RemoveForcedDecision(context);
-
-            Assert.IsTrue(remove);
-
-            var actual = user.DecideAll();
-
-            Assertions.AreEquivalent(expected, actual);
-        }
-
-        [Test]
-        public void TestSetForcedDecisionisCalledTwiceWithMultipleFlagKeys()
-        {
-            var datafile = "";
-            using (System.IO.StreamReader reader = new System.IO.StreamReader(@"C:\Users\Dustin\dev\csharp\csharp-sdk\datafiles\flags_with_rollouts.json"))
-                datafile = reader.ReadToEnd();
-
-            var expected = new Dictionary<string, OptimizelyDecision>
-            {
-                { "flag_1", new OptimizelyDecision("variation_1", true, null, null, "flag_1", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
-                { "flag_2", new OptimizelyDecision("variation_2", true, null, null, "flag_2", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
-            };
-
-            Optimizely = new Optimizely(datafile, EventDispatcherMock.Object, LoggerMock.Object, ErrorHandlerMock.Object);
-
-            var user = Optimizely.CreateUserContext("test_user_1");
-
-            var context = new OptimizelyDecisionContext("flag_1");
-            var decision = new OptimizelyForcedDecision("variation_1");
-
-            var context2 = new OptimizelyDecisionContext("flag_2");
-            var decision2 = new OptimizelyForcedDecision("variation_2");
-
-            user.SetForcedDecision(context, decision);
-            user.SetForcedDecision(context2, decision2);
-
-            var actual = user.DecideForKeys(new string[] { "flag_1", "flag_2" });
-
-            Assertions.AreEquivalent(expected, actual);
-        }
-
-        [Test]
-        public void TestRemoveForcedDecisionsCalledBeforeDecide()
-        {
-            var datafile = "";
-            using (System.IO.StreamReader reader = new System.IO.StreamReader(@"C:\Users\Dustin\dev\csharp\csharp-sdk\datafiles\flags_with_rollouts.json"))
-                datafile = reader.ReadToEnd();
-
-            var expected = new Dictionary<string, OptimizelyDecision>
-            {
-                { "flag_1", new OptimizelyDecision("exp_variation_1", true, null, "experiment_1_flag_1", "flag_1", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
-                { "flag_2", new OptimizelyDecision("variation_2", true, null, null, "flag_2", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
-            };
-
-            Optimizely = new Optimizely(datafile, EventDispatcherMock.Object, LoggerMock.Object, ErrorHandlerMock.Object);
-
-            var user = Optimizely.CreateUserContext("test_user_1");
-
-            var context = new OptimizelyDecisionContext("flag_1");
-            var decision = new OptimizelyForcedDecision("variation_1");
-
-            var context2 = new OptimizelyDecisionContext("flag_2");
-            var decision2 = new OptimizelyForcedDecision("variation_2");
-
-            user.SetForcedDecision(context, decision);
-            user.SetForcedDecision(context2, decision2);
-
-            var remove = user.RemoveForcedDecision(context);
-
-            Assert.IsTrue(remove);
-
-            var actual = user.DecideForKeys(new string[] { "flag_1", "flag_2" });
-
-            Assertions.AreEquivalent(expected, actual);
-        }
-
-        [Test]
-        public void TestRemoveAllForcedDecisionsBeforeDecideAll()
-        {
-            var datafile = "";
-            using (System.IO.StreamReader reader = new System.IO.StreamReader(@"C:\Users\Dustin\dev\csharp\csharp-sdk\datafiles\flags_with_rollouts.json"))
-                datafile = reader.ReadToEnd();
-
-            var expected = new Dictionary<string, OptimizelyDecision>
-            {
-                { "flag_1", new OptimizelyDecision("exp_variation_1", true, null, "experiment_1_flag_1", "flag_1", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
-                { "flag_2", new OptimizelyDecision("exp_variation_1", true, null, "experiment_1_flag_2", "flag_2", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
-                { "flag_3", new OptimizelyDecision("variation_1", true, null, "flag_3_targeted_delivery", "flag_3", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
-                { "flag_4", new OptimizelyDecision("exp_variation_1", true, null, "experiment_flag_4", "flag_4", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]) },
-            };
-
-            Optimizely = new Optimizely(datafile, EventDispatcherMock.Object, LoggerMock.Object, ErrorHandlerMock.Object);
-
-            var user = Optimizely.CreateUserContext("test_user_1");
-
-            var context = new OptimizelyDecisionContext("flag_1");
-            var decision = new OptimizelyForcedDecision("variation_1");
-
-            var context2 = new OptimizelyDecisionContext("flag_2");
-            var decision2 = new OptimizelyForcedDecision("variation_2");
-
-            user.SetForcedDecision(context, decision);
-            user.SetForcedDecision(context2, decision2);
-
-            var remove = user.RemoveAllForcedDecisions();
-
-            Assert.IsTrue(remove);
-
-            var actual = user.DecideAll();
-
-            Assertions.AreEquivalent(expected, actual);
-        }
-
-        [Test]
-        public void TestEvaluateDecideAfterCallingSetForcedDecision()
-        {
-            var datafile = "";
-            using (System.IO.StreamReader reader = new System.IO.StreamReader(@"C:\Users\Dustin\dev\csharp\csharp-sdk\datafiles\flags_with_rollouts.json"))
-                datafile = reader.ReadToEnd();
-
-            var decision1 = new OptimizelyDecision("exp_variation_1", true, null, "experiment_1_flag_1", "flag_1", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[0]);
-            var decision2 = new OptimizelyDecision("exp_variation_1", true, null, "experiment_1_flag_1", "flag_1", new OptimizelyUserContext(Optimizely, "test_user_1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object), new string[] { "Variation (variation_1) is mapped to flag (flag_1) and user (test_user_1) in the forced decision map." });
-
-            Optimizely = new Optimizely(datafile, EventDispatcherMock.Object, LoggerMock.Object, ErrorHandlerMock.Object);
-
-            var user = Optimizely.CreateUserContext("test_user_1");
-
-            var result1 = user.Decide("flag_1");
-
-            Assertions.AreEqual(decision1, result1);
-
-            var context = new OptimizelyDecisionContext("flag_1");
-            var forcedDecision = new OptimizelyForcedDecision("variation_1");
-
-            var forcedDecisionSet = user.SetForcedDecision(context, forcedDecision);
-
-            Assert.IsTrue(forcedDecisionSet);
-
-            var result2 = user.Decide("flag_1");
-
-            Assertions.AreEqual(decision2, result2);
-        }
     }
 }

From 87fe232da3d9454c40e9dad40a8a4407d3fe5d7d Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Mon, 8 Nov 2021 11:58:19 -0500
Subject: [PATCH 093/130] Added reasons being returned

---
 OptimizelySDK/Optimizely.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/OptimizelySDK/Optimizely.cs b/OptimizelySDK/Optimizely.cs
index eebf6143..a313048b 100644
--- a/OptimizelySDK/Optimizely.cs
+++ b/OptimizelySDK/Optimizely.cs
@@ -846,7 +846,7 @@ internal OptimizelyDecision Decide(OptimizelyUserContext user,
             {
                 decisionEventDispatched = SendImpressionEvent(decision?.Experiment, decision?.Variation, userId, userAttributes, config, key, decisionSource, featureEnabled);
             }
-            var reasonsToReport = decisionReasons.ToReport().ToArray();
+            var reasonsToReport = decisionReasons.ToReport(true).ToArray();
             var variationKey = decision?.Variation?.Key;
 
             // TODO: add ruleKey values when available later. use a copy of experimentKey until then.

From 059fafddc043bde659fd938448f6ac1cb65caec0 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Mon, 8 Nov 2021 12:21:57 -0500
Subject: [PATCH 094/130] Added a "true" for now

---
 OptimizelySDK/Optimizely.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/OptimizelySDK/Optimizely.cs b/OptimizelySDK/Optimizely.cs
index a313048b..edd1122b 100644
--- a/OptimizelySDK/Optimizely.cs
+++ b/OptimizelySDK/Optimizely.cs
@@ -846,7 +846,7 @@ internal OptimizelyDecision Decide(OptimizelyUserContext user,
             {
                 decisionEventDispatched = SendImpressionEvent(decision?.Experiment, decision?.Variation, userId, userAttributes, config, key, decisionSource, featureEnabled);
             }
-            var reasonsToReport = decisionReasons.ToReport(true).ToArray();
+            var reasonsToReport = decisionReasons.ToReport(allOptions.Contains(OptimizelyDecideOption.INCLUDE_REASONS)).ToArray();
             var variationKey = decision?.Variation?.Key;
 
             // TODO: add ruleKey values when available later. use a copy of experimentKey until then.

From 80abfa342ed252e596ef627b1f6450cc8b7a37b5 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Mon, 8 Nov 2021 12:57:36 -0500
Subject: [PATCH 095/130] Added period to match string

---
 OptimizelySDK/OptimizelyUserContext.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index 92ca5776..73a8079a 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -327,7 +327,7 @@ public Result<Variation> FindValidatedForcedDecision(OptimizelyDecisionContext c
                 if (variation != null)
                 {
                     reasons.AddInfo("Decided by forced decision.");
-                    reasons.AddInfo("Variation ({0}) is mapped to flag ({1}) and user ({2}) in the forced decision map", variationKey, context.FlagKey, this.UserId);
+                    reasons.AddInfo("Variation ({0}) is mapped to flag ({1}) and user ({2}) in the forced decision map.", variationKey, context.FlagKey, this.UserId);
                     return Result<Variation>.NewResult(variation, reasons);
                 }
                 else

From 9c87d718431d0aa9b4baf8c8a9601351914f250a Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Mon, 8 Nov 2021 13:39:35 -0500
Subject: [PATCH 096/130] cleaned up decision key

---
 OptimizelySDK/OptimizelyDecisionContext.cs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/OptimizelySDK/OptimizelyDecisionContext.cs b/OptimizelySDK/OptimizelyDecisionContext.cs
index 73edd150..5ffa992e 100644
--- a/OptimizelySDK/OptimizelyDecisionContext.cs
+++ b/OptimizelySDK/OptimizelyDecisionContext.cs
@@ -19,6 +19,7 @@ namespace OptimizelySDK
     public class OptimizelyDecisionContext
     {
         public const string OPTI_NULL_RULE_KEY = "$opt-null-rule-key";
+        public const string OPTI_KEY_DIVIDER = "-$opt$-";
         private string flagKey;
         private string ruleKey;
         private string decisionKey;
@@ -27,7 +28,7 @@ public OptimizelyDecisionContext(string flagKey, string ruleKey = null)
         {
             this.flagKey = flagKey;
             this.ruleKey = ruleKey;
-            this.decisionKey = string.Format("{0}-{1}", flagKey, ruleKey ?? OPTI_NULL_RULE_KEY);
+            this.decisionKey = string.Format("{0}{1}{2}", flagKey, OPTI_KEY_DIVIDER, ruleKey ?? OPTI_NULL_RULE_KEY);
         }
 
         public string FlagKey { get { return flagKey; } }

From f0f8ee86f17bdca8a5cb8e49238680525bfafcb8 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Mon, 8 Nov 2021 15:08:57 -0500
Subject: [PATCH 097/130] Updated message and tests for forced decision via
 experiment

---
 OptimizelySDK/Bucketing/DecisionService.cs | 24 +++++++++++++++++++++-
 OptimizelySDK/OptimizelyUserContext.cs     |  2 +-
 2 files changed, 24 insertions(+), 2 deletions(-)

diff --git a/OptimizelySDK/Bucketing/DecisionService.cs b/OptimizelySDK/Bucketing/DecisionService.cs
index a897040a..a72184eb 100644
--- a/OptimizelySDK/Bucketing/DecisionService.cs
+++ b/OptimizelySDK/Bucketing/DecisionService.cs
@@ -532,7 +532,7 @@ public virtual Result<FeatureDecision> GetVariationForFeatureExperiment(FeatureF
                 if (string.IsNullOrEmpty(experiment.Key))
                     continue;
 
-                var variationResult = GetVariation(experiment, user, config, filteredAttributes, options);
+                var variationResult = GetVariationFromExperiment(config, featureFlag.Key, experiment, user, options);
                 reasons += variationResult.DecisionReasons;
 
                 if (!string.IsNullOrEmpty(variationResult.ResultObject?.Id))
@@ -546,6 +546,28 @@ public virtual Result<FeatureDecision> GetVariationForFeatureExperiment(FeatureF
             return Result<FeatureDecision>.NullResult(reasons);
         }
 
+        private Result<Variation> GetVariationFromExperiment(ProjectConfig config, string flagKey, Experiment experiment, OptimizelyUserContext user, OptimizelyDecideOption[] options)
+        {
+            var reasons = new DecisionReasons();
+
+            var ruleKey = experiment != null ? experiment.Key : null;
+
+            var decisionContext = new OptimizelyDecisionContext(flagKey, ruleKey);
+            var response = user.FindValidatedForcedDecision(decisionContext);
+
+            reasons += response.DecisionReasons;
+
+            if (response.ResultObject != null)
+            {
+                return Result<Variation>.NewResult(response.ResultObject, reasons);
+            }
+
+            var decisionResponse = GetVariation(experiment, user, config, user.GetAttributes());
+            reasons += decisionResponse.DecisionReasons;
+
+            return Result<Variation>.NewResult(decisionResponse.ResultObject, reasons);
+        }
+
         /// <summary>
         /// Get the variation the user is bucketed into for the FeatureFlag
         /// </summary>
diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index 73a8079a..1f9b4625 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -332,7 +332,7 @@ public Result<Variation> FindValidatedForcedDecision(OptimizelyDecisionContext c
                 }
                 else
                 {
-                    reasons.AddInfo("Invalid variation is mapped to {0} and user {1} in the forced decision map.", context.FlagKey, this.UserId);
+                    reasons.AddInfo("Invalid variation is mapped to flag ({0}) and user ({1}) in the forced decision map.", context.FlagKey, this.UserId);
                 }
             }
             return Result<Variation>.NullResult(reasons);

From 9afc59ab7d494eb718d7c73efcfa111892ea39e8 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Mon, 8 Nov 2021 15:23:06 -0500
Subject: [PATCH 098/130] Fixed key comparison test

---
 OptimizelySDK.Tests/OptimizelyUserContextTest.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
index 31079d37..0c694eda 100644
--- a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
@@ -191,11 +191,11 @@ public void TestForcedDecisionReturnsCorrectGetDecisionKey()
             var user = Optimizely.CreateUserContext(UserID);
             var context = new OptimizelyDecisionContext("flag", null);
 
-            Assert.AreEqual(context.DecisionKey, "flag-$opt-null-rule-key");
+            Assert.AreEqual("flag-$opt$-$opt-null-rule-key", context.DecisionKey);
 
             context = new OptimizelyDecisionContext("flag", "ruleKey");
 
-            Assert.AreEqual(context.DecisionKey, "flag-ruleKey");
+            Assert.AreEqual("flag-$opt$-ruleKey", context.DecisionKey);
         }
 
         [Test]

From e4c190c2233339a5f5647e2659407f218045f756 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Wed, 10 Nov 2021 08:15:45 -0500
Subject: [PATCH 099/130] Added missing chunk from decision service

---
 OptimizelySDK/Bucketing/DecisionService.cs | 54 +++++++++++++++++-----
 1 file changed, 43 insertions(+), 11 deletions(-)

diff --git a/OptimizelySDK/Bucketing/DecisionService.cs b/OptimizelySDK/Bucketing/DecisionService.cs
index a72184eb..9c72d9fe 100644
--- a/OptimizelySDK/Bucketing/DecisionService.cs
+++ b/OptimizelySDK/Bucketing/DecisionService.cs
@@ -16,6 +16,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using OptimizelySDK.Entity;
 using OptimizelySDK.ErrorHandler;
 using OptimizelySDK.Logger;
@@ -532,7 +533,7 @@ public virtual Result<FeatureDecision> GetVariationForFeatureExperiment(FeatureF
                 if (string.IsNullOrEmpty(experiment.Key))
                     continue;
 
-                var variationResult = GetVariationFromExperiment(config, featureFlag.Key, experiment, user, options);
+                var variationResult = GetVariationFromExperiment(config, featureFlag, experiment, user, options);
                 reasons += variationResult.DecisionReasons;
 
                 if (!string.IsNullOrEmpty(variationResult.ResultObject?.Id))
@@ -546,26 +547,57 @@ public virtual Result<FeatureDecision> GetVariationForFeatureExperiment(FeatureF
             return Result<FeatureDecision>.NullResult(reasons);
         }
 
-        private Result<Variation> GetVariationFromExperiment(ProjectConfig config, string flagKey, Experiment experiment, OptimizelyUserContext user, OptimizelyDecideOption[] options)
+        private Result<Variation> GetVariationFromExperiment(ProjectConfig config, FeatureFlag flag, Experiment experiment, OptimizelyUserContext user, OptimizelyDecideOption[] options)
+        {
+            var reasons = new DecisionReasons();
+
+            if (flag.ExperimentIds.Any())
+            {
+                foreach (var expId in flag.ExperimentIds)
+                {
+                    config.ExperimentIdMap.TryGetValue(expId, out var exp);
+
+                    var decisionVariation = GetVariationFromExperimentRule(config, flag.Key, experiment, user, options);
+                }
+                var ruleKey = experiment != null ? experiment.Key : null;
+
+                var decisionContext = new OptimizelyDecisionContext(flag.Key, ruleKey);
+                var response = user.FindValidatedForcedDecision(decisionContext);
+
+                reasons += response.DecisionReasons;
+
+                if (response.ResultObject != null)
+                {
+                    return Result<Variation>.NewResult(response.ResultObject, reasons);
+                }
+
+                var decisionResponse = GetVariation(experiment, user, config, user.GetAttributes());
+                reasons += decisionResponse.DecisionReasons;
+            }
+
+            return Result<Variation>.NullResult(reasons);
+        }
+
+        private object GetVariationFromExperimentRule(ProjectConfig config, string key, Experiment experiment, OptimizelyUserContext user, OptimizelyDecideOption[] options)
         {
             var reasons = new DecisionReasons();
 
             var ruleKey = experiment != null ? experiment.Key : null;
 
-            var decisionContext = new OptimizelyDecisionContext(flagKey, ruleKey);
-            var response = user.FindValidatedForcedDecision(decisionContext);
+            var decisionContext = new OptimizelyDecisionContext(key, ruleKey);
+
+            var forcedDecisionResponse = user.FindValidatedForcedDecision(decisionContext);
 
-            reasons += response.DecisionReasons;
+            reasons += forcedDecisionResponse.DecisionReasons;
 
-            if (response.ResultObject != null)
+            var variation = forcedDecisionResponse?.ResultObject;
+
+            if (variation != null)
             {
-                return Result<Variation>.NewResult(response.ResultObject, reasons);
+                return Result<Variation>.NewResult(variation, reasons);
             }
 
-            var decisionResponse = GetVariation(experiment, user, config, user.GetAttributes());
-            reasons += decisionResponse.DecisionReasons;
-
-            return Result<Variation>.NewResult(decisionResponse.ResultObject, reasons);
+            return GetVariation(experiment, user, config, user.GetAttributes());
         }
 
         /// <summary>

From 07b69f27d29fd2723f9fb0b735181f641f5310cc Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Wed, 10 Nov 2021 09:56:54 -0500
Subject: [PATCH 100/130] decision service cleanup and tests

---
 OptimizelySDK.Tests/DecisionServiceTest.cs | 17 ++++-
 OptimizelySDK/Bucketing/DecisionService.cs | 74 +++++++++++-----------
 2 files changed, 52 insertions(+), 39 deletions(-)

diff --git a/OptimizelySDK.Tests/DecisionServiceTest.cs b/OptimizelySDK.Tests/DecisionServiceTest.cs
index 2df1cf24..a3f15760 100644
--- a/OptimizelySDK.Tests/DecisionServiceTest.cs
+++ b/OptimizelySDK.Tests/DecisionServiceTest.cs
@@ -576,6 +576,10 @@ public void TestGetVariationForFeatureExperimentGivenNonMutexGroupAndUserIsBucke
             var expectedDecision = new FeatureDecision(experiment, variation.ResultObject, FeatureDecision.DECISION_SOURCE_FEATURE_TEST);
             var userAttributes = new UserAttributes();
 
+            var optlyObject = new Optimizely(TestData.Datafile, new ValidEventDispatcher(), LoggerMock.Object);
+
+            OptimizelyUserContextMock = new Mock<OptimizelyUserContext>(optlyObject, WhitelistedUserId, new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object);
+
             OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns("user1");
 
             DecisionServiceMock.Setup(ds => ds.GetVariation(ProjectConfig.GetExperimentFromKey("test_experiment_multivariate"),
@@ -597,6 +601,10 @@ public void TestGetVariationForFeatureExperimentGivenMutexGroupAndUserIsBucketed
             var variation = Result<Variation>.NewResult(mutexExperiment.Variations[0], DecisionReasons);
             var userAttributes = new UserAttributes();
             var expectedDecision = new FeatureDecision(mutexExperiment, variation.ResultObject, FeatureDecision.DECISION_SOURCE_FEATURE_TEST);
+
+            var optlyObject = new Optimizely(TestData.Datafile, new ValidEventDispatcher(), LoggerMock.Object);
+
+            OptimizelyUserContextMock = new Mock<OptimizelyUserContext>(optlyObject, WhitelistedUserId, new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object);
             OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns("user1");
 
             DecisionServiceMock.Setup(ds => ds.GetVariation(ProjectConfig.GetExperimentFromKey("group_experiment_1"), OptimizelyUserContextMock.Object, ProjectConfig,
@@ -915,15 +923,18 @@ public void TestGetVariationForFeatureWhenTheUserIsNotBucketedIntoFeatureExperim
         public void TestGetVariationForFeatureWhenTheUserIsNeitherBucketedIntoFeatureExperimentNorToFeatureRollout()
         {
             var featureFlag = ProjectConfig.GetFeatureFlagFromKey("string_single_variable_feature");
-            var expectedDecision = new FeatureDecision(null, null, FeatureDecision.DECISION_SOURCE_ROLLOUT);
 
             DecisionServiceMock.Setup(ds => ds.GetVariationForFeatureExperiment(It.IsAny<FeatureFlag>(), It.IsAny<OptimizelyUserContext>(), It.IsAny<UserAttributes>(), ProjectConfig, new OptimizelyDecideOption[] { })).Returns(Result<FeatureDecision>.NullResult(null));
             DecisionServiceMock.Setup(ds => ds.GetVariationForFeatureRollout(It.IsAny<FeatureFlag>(), It.IsAny<string>(), It.IsAny<UserAttributes>(), ProjectConfig)).Returns(Result<FeatureDecision>.NullResult(null));
 
+            var optlyObject = new Optimizely(TestData.Datafile, new ValidEventDispatcher(), LoggerMock.Object);
+            OptimizelyUserContextMock = new Mock<OptimizelyUserContext>(optlyObject, WhitelistedUserId, new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object);
+            OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns(UserProfileId);
+
             var actualDecision = DecisionServiceMock.Object.GetVariationForFeature(featureFlag, OptimizelyUserContextMock.Object, ProjectConfig);
-            Assert.IsTrue(TestData.CompareObjects(expectedDecision, actualDecision.ResultObject));
+            Assert.IsNull(actualDecision.ResultObject);
 
-            LoggerMock.Verify(l => l.Log(LogLevel.INFO, "The user \"user1\" is not bucketed into a rollout for feature flag \"string_single_variable_feature\"."));
+            LoggerMock.Verify(l => l.Log(LogLevel.INFO, "The user \"userProfileId\" is not bucketed into a rollout for feature flag \"string_single_variable_feature\"."));
         }
 
         // Verify that the user is bucketed into the experiment's variation when the user satisfies bucketing and traffic allocation
diff --git a/OptimizelySDK/Bucketing/DecisionService.cs b/OptimizelySDK/Bucketing/DecisionService.cs
index 9c72d9fe..28c1d97a 100644
--- a/OptimizelySDK/Bucketing/DecisionService.cs
+++ b/OptimizelySDK/Bucketing/DecisionService.cs
@@ -111,21 +111,23 @@ public virtual Result<Variation> GetVariation(Experiment experiment,
                 return Result<Variation>.NullResult(reasons);
 
             // check if a forced variation is set
-            var forcedVariationResult = GetForcedVariation(experiment.Key, userId, config);
-            reasons += forcedVariationResult.DecisionReasons;
+            var decisionVariation = GetForcedVariation(experiment.Key, userId, config);
+            reasons += decisionVariation.DecisionReasons;
+            var variation = decisionVariation?.ResultObject;
 
-            if (forcedVariationResult.ResultObject != null)
+            if (variation == null)
             {
-                return forcedVariationResult.SetReasons(reasons);
-            }
+                decisionVariation = GetWhitelistedVariation(experiment, user.GetUserId());
+                reasons += decisionVariation?.DecisionReasons;
 
-            var variationResult = GetWhitelistedVariation(experiment, userId);
-            reasons += variationResult.DecisionReasons;
+                variation = decisionVariation?.ResultObject;
+            }
 
-            if (variationResult.ResultObject != null)
+            if (variation != null)
             {
-                return variationResult.SetReasons(reasons);
+                return decisionVariation;
             }
+
             // fetch the user profile map from the user profile service
             var ignoreUPS = Array.Exists(options, option => option == OptimizelyDecideOption.IGNORE_USER_PROFILE_SERVICE);
 
@@ -138,9 +140,9 @@ public virtual Result<Variation> GetVariation(Experiment experiment,
                     if (userProfileMap != null && UserProfileUtil.IsValidUserProfileMap(userProfileMap))
                     {
                         userProfile = UserProfileUtil.ConvertMapToUserProfile(userProfileMap);
-                        variationResult = GetStoredVariation(experiment, userProfile, config);
-                        reasons += variationResult.DecisionReasons;
-                        if (variationResult.ResultObject != null) return variationResult.SetReasons(reasons);
+                        decisionVariation = GetStoredVariation(experiment, userProfile, config);
+                        reasons += decisionVariation?.DecisionReasons;
+                        if (decisionVariation?.ResultObject != null) return decisionVariation?.SetReasons(reasons);
                     }
                     else if (userProfileMap == null)
                     {
@@ -165,21 +167,21 @@ public virtual Result<Variation> GetVariation(Experiment experiment,
                 var bucketingIdResult = GetBucketingId(userId, filteredAttributes);
                 reasons += bucketingIdResult.DecisionReasons;
 
-                variationResult = Bucketer.Bucket(config, experiment, bucketingIdResult.ResultObject, userId);
-                reasons += variationResult.DecisionReasons;
+                decisionVariation = Bucketer.Bucket(config, experiment, bucketingIdResult.ResultObject, userId);
+                reasons += decisionVariation?.DecisionReasons;
 
-                if (variationResult.ResultObject?.Key != null)
+                if (decisionVariation?.ResultObject?.Key != null)
                 {
                     if (UserProfileService != null && !ignoreUPS)
                     {
                         var bucketerUserProfile = userProfile ?? new UserProfile(userId, new Dictionary<string, Decision>());
-                        SaveVariation(experiment, variationResult.ResultObject, bucketerUserProfile);
+                        SaveVariation(experiment, decisionVariation?.ResultObject, bucketerUserProfile);
                     }
                     else
                         Logger.Log(LogLevel.INFO, "This decision will not be saved since the UserProfileService is null.");
                 }
 
-                return variationResult.SetReasons(reasons);
+                return decisionVariation?.SetReasons(reasons);
             }
             Logger.Log(LogLevel.INFO, reasons.AddInfo($"User \"{user.GetUserId()}\" does not meet conditions to be in experiment \"{experiment.Key}\"."));
 
@@ -495,7 +497,7 @@ public virtual Result<FeatureDecision> GetVariationForFeatureRollout(FeatureFlag
                 Logger.Log(LogLevel.DEBUG, $"User \"{userId}\" does not meet the conditions to be in rollout rule for audience \"{audience.Name}\".");
             }
 
-            return Result<FeatureDecision>.NewResult(null, reasons);
+            return Result<FeatureDecision>.NullResult(reasons);
         }
 
         /// <summary>
@@ -536,10 +538,10 @@ public virtual Result<FeatureDecision> GetVariationForFeatureExperiment(FeatureF
                 var variationResult = GetVariationFromExperiment(config, featureFlag, experiment, user, options);
                 reasons += variationResult.DecisionReasons;
 
-                if (!string.IsNullOrEmpty(variationResult.ResultObject?.Id))
+                if (variationResult?.ResultObject?.Experiment != null && variationResult?.ResultObject?.Variation?.Id != null)
                 {
                     Logger.Log(LogLevel.INFO, reasons.AddInfo($"The user \"{userId}\" is bucketed into experiment \"{experiment.Key}\" of feature \"{featureFlag.Key}\"."));
-                    return Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variationResult.ResultObject, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), reasons);
+                    return Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variationResult.ResultObject.Variation, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), reasons);
                 }
             }
 
@@ -547,7 +549,7 @@ public virtual Result<FeatureDecision> GetVariationForFeatureExperiment(FeatureF
             return Result<FeatureDecision>.NullResult(reasons);
         }
 
-        private Result<Variation> GetVariationFromExperiment(ProjectConfig config, FeatureFlag flag, Experiment experiment, OptimizelyUserContext user, OptimizelyDecideOption[] options)
+        private Result<FeatureDecision> GetVariationFromExperiment(ProjectConfig config, FeatureFlag flag, Experiment experiment, OptimizelyUserContext user, OptimizelyDecideOption[] options)
         {
             var reasons = new DecisionReasons();
 
@@ -558,27 +560,23 @@ private Result<Variation> GetVariationFromExperiment(ProjectConfig config, Featu
                     config.ExperimentIdMap.TryGetValue(expId, out var exp);
 
                     var decisionVariation = GetVariationFromExperimentRule(config, flag.Key, experiment, user, options);
-                }
-                var ruleKey = experiment != null ? experiment.Key : null;
+                    reasons += decisionVariation?.DecisionReasons;
 
-                var decisionContext = new OptimizelyDecisionContext(flag.Key, ruleKey);
-                var response = user.FindValidatedForcedDecision(decisionContext);
+                    var variation = decisionVariation?.ResultObject;
 
-                reasons += response.DecisionReasons;
+                    if (variation != null)
+                    {
+                        var featureDecision = new FeatureDecision(exp, variation, FeatureDecision.DECISION_SOURCE_FEATURE_TEST);
 
-                if (response.ResultObject != null)
-                {
-                    return Result<Variation>.NewResult(response.ResultObject, reasons);
+                        return Result<FeatureDecision>.NewResult(featureDecision, reasons);
+                    }
                 }
-
-                var decisionResponse = GetVariation(experiment, user, config, user.GetAttributes());
-                reasons += decisionResponse.DecisionReasons;
             }
 
-            return Result<Variation>.NullResult(reasons);
+            return Result<FeatureDecision>.NullResult(reasons);
         }
 
-        private object GetVariationFromExperimentRule(ProjectConfig config, string key, Experiment experiment, OptimizelyUserContext user, OptimizelyDecideOption[] options)
+        private Result<Variation> GetVariationFromExperimentRule(ProjectConfig config, string key, Experiment experiment, OptimizelyUserContext user, OptimizelyDecideOption[] options)
         {
             var reasons = new DecisionReasons();
 
@@ -597,7 +595,11 @@ private object GetVariationFromExperimentRule(ProjectConfig config, string key,
                 return Result<Variation>.NewResult(variation, reasons);
             }
 
-            return GetVariation(experiment, user, config, user.GetAttributes());
+            var decisionResponse = GetVariation(experiment, user, config, user.GetAttributes(), options);
+
+            reasons += decisionResponse?.DecisionReasons;
+
+            return Result<Variation>.NewResult(decisionResponse?.ResultObject, reasons);
         }
 
         /// <summary>
@@ -651,7 +653,7 @@ public virtual Result<FeatureDecision> GetVariationForFeature(FeatureFlag featur
             }
 
             Logger.Log(LogLevel.INFO, reasons.AddInfo($"The user \"{userId}\" is not bucketed into a rollout for feature flag \"{featureFlag.Key}\"."));
-            return Result<FeatureDecision>.NewResult(new FeatureDecision(null, null, FeatureDecision.DECISION_SOURCE_ROLLOUT), reasons);
+            return Result<FeatureDecision>.NullResult(reasons);
         }
 
         /// <summary>

From 9e427fabcd234974b70abd9c8a8ab9d71627b275 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Wed, 10 Nov 2021 09:58:02 -0500
Subject: [PATCH 101/130] cleanup

---
 OptimizelySDK/Optimizely.cs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/OptimizelySDK/Optimizely.cs b/OptimizelySDK/Optimizely.cs
index edd1122b..144fd082 100644
--- a/OptimizelySDK/Optimizely.cs
+++ b/OptimizelySDK/Optimizely.cs
@@ -378,7 +378,6 @@ private Variation GetVariation(string experimentKey, string userId, ProjectConfi
             Experiment experiment = config.GetExperimentFromKey(experimentKey);
             if (experiment.Key == null)
                 return null;
-
             var variation = DecisionService.GetVariation(experiment, CreateUserContext(userId, userAttributes), config, userAttributes).ResultObject;
             var decisionInfo = new Dictionary<string, object>
             {
@@ -782,7 +781,7 @@ internal OptimizelyDecision Decide(OptimizelyUserContext user,
             var forcedDecisionVariation = user.FindValidatedForcedDecision(decisionContext);
             decisionReasons += forcedDecisionVariation.DecisionReasons;
 
-            if (forcedDecisionVariation.ResultObject != Result<Variation>.NullResult(null).ResultObject)
+            if (forcedDecisionVariation.ResultObject != null)
             {
                 decision = new FeatureDecision(null, forcedDecisionVariation.ResultObject, FeatureDecision.DECISION_SOURCE_FEATURE_TEST);
             }

From 1a3aab3fcde5af2a0c1704b6441f7f53cf896b61 Mon Sep 17 00:00:00 2001
From: muhammadnoman <muhammadnoman@folio3.com>
Date: Fri, 12 Nov 2021 17:11:54 +0500
Subject: [PATCH 102/130] Added fixed of forced decisions

---
 OptimizelySDK.Tests/DecisionServiceTest.cs  |  64 ++++++----
 OptimizelySDK/Bucketing/DecisionService.cs  | 130 ++++++++++++--------
 OptimizelySDK/Entity/Result.cs              |   5 +
 OptimizelySDK/Event/Builder/EventBuilder.cs |   2 +-
 OptimizelySDK/Event/EventFactory.cs         |   2 +-
 OptimizelySDK/OptimizelyUserContext.cs      |  11 +-
 6 files changed, 133 insertions(+), 81 deletions(-)

diff --git a/OptimizelySDK.Tests/DecisionServiceTest.cs b/OptimizelySDK.Tests/DecisionServiceTest.cs
index a3f15760..3071ce9b 100644
--- a/OptimizelySDK.Tests/DecisionServiceTest.cs
+++ b/OptimizelySDK.Tests/DecisionServiceTest.cs
@@ -651,10 +651,11 @@ public void TestGetVariationForFeatureRolloutWhenNoRuleInRollouts()
             var rollout = projectConfig.GetRolloutFromId(featureFlag.RolloutId);
 
             Assert.AreEqual(rollout.Experiments.Count, 0);
-
+            var optlyObject = new Optimizely(TestData.Datafile, new ValidEventDispatcher(), LoggerMock.Object);
+            var optimizelyUserContext = new OptimizelyUserContext(optlyObject, "userId1", null, ErrorHandlerMock.Object, LoggerMock.Object);
             var decisionService = new DecisionService(new Bucketer(new NoOpLogger()), new NoOpErrorHandler(), null, new NoOpLogger());
 
-            var variation = decisionService.GetVariationForFeatureRollout(featureFlag, "userId1", null, projectConfig);
+            var variation = decisionService.GetVariationForFeatureRollout(featureFlag, optimizelyUserContext, projectConfig);
 
             Assert.IsNull(variation.ResultObject);
         }
@@ -662,6 +663,7 @@ public void TestGetVariationForFeatureRolloutWhenNoRuleInRollouts()
         [Test]
         public void TestGetVariationForFeatureRolloutWhenRolloutIsNotInDataFile()
         {
+
             var featureFlag = ProjectConfig.GetFeatureFlagFromKey("boolean_feature");
             var invalidRolloutFeature = new FeatureFlag
             {
@@ -673,8 +675,9 @@ public void TestGetVariationForFeatureRolloutWhenRolloutIsNotInDataFile()
             };
 
             DecisionServiceMock.Setup(ds => ds.GetVariationForFeatureExperiment(It.IsAny<FeatureFlag>(), It.IsAny<OptimizelyUserContext>(), It.IsAny<UserAttributes>(), ProjectConfig, new OptimizelyDecideOption[] { })).Returns<Variation>(null);
-
-            var actualDecision = DecisionServiceMock.Object.GetVariationForFeatureRollout(featureFlag, "user1", new UserAttributes(), ProjectConfig);
+            var optlyObject = new Optimizely(TestData.Datafile, new ValidEventDispatcher(), LoggerMock.Object);
+            var optimizelyUserContext = new OptimizelyUserContext(optlyObject, "user1", new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object);
+            var actualDecision = DecisionServiceMock.Object.GetVariationForFeatureRollout(featureFlag, optimizelyUserContext, ProjectConfig);
             Assert.IsNull(actualDecision.ResultObject);
 
             LoggerMock.Verify(l => l.Log(LogLevel.INFO, "The feature flag \"boolean_feature\" is not used in a rollout."));
@@ -699,7 +702,10 @@ public void TestGetVariationForFeatureRolloutWhenUserIsBucketedInTheTargetingRul
                 It.IsAny<string>())).Returns(variation);
             var decisionService = new DecisionService(BucketerMock.Object, ErrorHandlerMock.Object, null, LoggerMock.Object);
 
-            var actualDecision = decisionService.GetVariationForFeatureRollout(featureFlag, "user_1", userAttributes, ProjectConfig);
+            var optlyObject = new Optimizely(TestData.Datafile, new ValidEventDispatcher(), LoggerMock.Object);
+            var optimizelyUserContext = new OptimizelyUserContext(optlyObject, "user_1", userAttributes, ErrorHandlerMock.Object, LoggerMock.Object);
+
+            var actualDecision = decisionService.GetVariationForFeatureRollout(featureFlag, optimizelyUserContext, ProjectConfig);
             Assert.IsTrue(TestData.CompareObjects(expectedDecision, actualDecision.ResultObject));
         }
 
@@ -724,7 +730,9 @@ public void TestGetVariationForFeatureRolloutWhenUserIsNotBucketedInTheTargeting
             BucketerMock.Setup(bm => bm.Bucket(It.IsAny<ProjectConfig>(), everyoneElseRule, It.IsAny<string>(), It.IsAny<string>())).Returns(variation);
             var decisionService = new DecisionService(BucketerMock.Object, ErrorHandlerMock.Object, null, LoggerMock.Object);
 
-            var actualDecision = decisionService.GetVariationForFeatureRollout(featureFlag, "user_1", userAttributes, ProjectConfig);
+            var optlyObject = new Optimizely(TestData.Datafile, new ValidEventDispatcher(), LoggerMock.Object);
+            var optimizelyUserContext = new OptimizelyUserContext(optlyObject, "user_1", userAttributes, ErrorHandlerMock.Object, LoggerMock.Object);
+            var actualDecision = decisionService.GetVariationForFeatureRollout(featureFlag, optimizelyUserContext, ProjectConfig);
             Assert.IsTrue(TestData.CompareObjects(expectedDecision, actualDecision.ResultObject));
         }
 
@@ -743,7 +751,9 @@ public void TestGetVariationForFeatureRolloutWhenUserIsNeitherBucketedInTheTarge
             BucketerMock.Setup(bm => bm.Bucket(It.IsAny<ProjectConfig>(), It.IsAny<Experiment>(), It.IsAny<string>(), It.IsAny<string>())).Returns(Result<Variation>.NullResult(null));
             var decisionService = new DecisionService(BucketerMock.Object, ErrorHandlerMock.Object, null, LoggerMock.Object);
 
-            var actualDecision = decisionService.GetVariationForFeatureRollout(featureFlag, "user_1", userAttributes, ProjectConfig);
+            var optlyObject = new Optimizely(TestData.Datafile, new ValidEventDispatcher(), LoggerMock.Object);
+            var optimizelyUserContext = new OptimizelyUserContext(optlyObject, "user_1", userAttributes, ErrorHandlerMock.Object, LoggerMock.Object);
+            var actualDecision = decisionService.GetVariationForFeatureRollout(featureFlag, optimizelyUserContext, ProjectConfig);
             Assert.IsNull(actualDecision.ResultObject);
         }
 
@@ -766,7 +776,9 @@ public void TestGetVariationForFeatureRolloutWhenUserDoesNotQualifyForAnyTargeti
             var decisionService = new DecisionService(BucketerMock.Object, ErrorHandlerMock.Object, null, LoggerMock.Object);
 
             // Provide null attributes so that user does not qualify for audience.
-            var actualDecision = decisionService.GetVariationForFeatureRollout(featureFlag, "user_1", null, ProjectConfig);
+            var optlyObject = new Optimizely(TestData.Datafile, new ValidEventDispatcher(), LoggerMock.Object);
+            var optimizelyUserContext = new OptimizelyUserContext(optlyObject, "user_1", null, ErrorHandlerMock.Object, LoggerMock.Object);
+            var actualDecision = decisionService.GetVariationForFeatureRollout(featureFlag, optimizelyUserContext, ProjectConfig);
 
             Assert.IsTrue(TestData.CompareObjects(expectedDecision, actualDecision.ResultObject));
 
@@ -792,21 +804,24 @@ public void TestGetVariationForFeatureRolloutAudienceAndTrafficeAllocationCheck(
             var decisionService = new DecisionService(mockBucketer.Object, ErrorHandlerMock.Object, null, LoggerMock.Object);
 
             // Calling with audience iPhone users in San Francisco.
-            var actualDecision = decisionService.GetVariationForFeatureRollout(featureFlag, GenericUserId, new UserAttributes
+            var optlyObject = new Optimizely(TestData.Datafile, new ValidEventDispatcher(), LoggerMock.Object);
+            var optimizelyUserContext = new OptimizelyUserContext(optlyObject, GenericUserId, new UserAttributes
             {
                 { "device_type", "iPhone" },
                 { "location", "San Francisco" }
-            }, ProjectConfig);
+            }, ErrorHandlerMock.Object, LoggerMock.Object);
+            var actualDecision = decisionService.GetVariationForFeatureRollout(featureFlag, optimizelyUserContext, ProjectConfig);
 
             // Returned variation id should be '177773' because of audience 'iPhone users in San Francisco'.
             var expectedDecision = new FeatureDecision(expWithAudienceiPhoneUsers, varWithAudienceiPhoneUsers, FeatureDecision.DECISION_SOURCE_ROLLOUT);
             Assert.IsTrue(TestData.CompareObjects(expectedDecision, actualDecision.ResultObject));
 
             // Calling with audience Chrome users.
-            actualDecision = decisionService.GetVariationForFeatureRollout(featureFlag, GenericUserId, new UserAttributes
+            var optimizelyUserContext2 = new OptimizelyUserContext(optlyObject, GenericUserId, new UserAttributes
             {
                 { "browser_type", "chrome" }
-            }, ProjectConfig);
+            }, ErrorHandlerMock.Object, LoggerMock.Object);
+            actualDecision = decisionService.GetVariationForFeatureRollout(featureFlag, optimizelyUserContext2, ProjectConfig);
 
             // Returned variation id should be '177771' because of audience 'Chrome users'.
             expectedDecision = new FeatureDecision(expWithAudienceChromeUsers, varWithAudienceChromeUsers, FeatureDecision.DECISION_SOURCE_ROLLOUT);
@@ -814,7 +829,8 @@ public void TestGetVariationForFeatureRolloutAudienceAndTrafficeAllocationCheck(
 
             // Calling with no audience.
             mockBucketer.Setup(bm => bm.GenerateBucketValue(It.IsAny<string>())).Returns(8000);
-            actualDecision = decisionService.GetVariationForFeatureRollout(featureFlag, GenericUserId, new UserAttributes(), ProjectConfig);
+            var optimizelyUserContext3 = new OptimizelyUserContext(optlyObject, GenericUserId, new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object);
+            actualDecision = decisionService.GetVariationForFeatureRollout(featureFlag, optimizelyUserContext3, ProjectConfig);
 
             // Returned variation id should be of everyone else rule because of no audience.
             expectedDecision = new FeatureDecision(expWithNoAudience, varWithNoAudience, FeatureDecision.DECISION_SOURCE_ROLLOUT);
@@ -822,10 +838,11 @@ public void TestGetVariationForFeatureRolloutAudienceAndTrafficeAllocationCheck(
 
             // Calling with audience 'Chrome users' and traffice allocation '9500'.
             mockBucketer.Setup(bm => bm.GenerateBucketValue(It.IsAny<string>())).Returns(9500);
-            actualDecision = decisionService.GetVariationForFeatureRollout(featureFlag, GenericUserId, new UserAttributes
+            var optimizelyUserContext4 = new OptimizelyUserContext(optlyObject, GenericUserId, new UserAttributes
             {
                 { "browser_type", "chrome" }
-            }, ProjectConfig);
+            }, ErrorHandlerMock.Object, LoggerMock.Object);
+            actualDecision = decisionService.GetVariationForFeatureRollout(featureFlag, optimizelyUserContext4, ProjectConfig);
 
             // Returned decision entity should be null because bucket value exceeds traffic allocation of everyone else rule.
             Assert.Null(actualDecision.ResultObject);
@@ -845,20 +862,23 @@ public void TestGetVariationForFeatureRolloutCheckAudienceInEveryoneElseRule()
             BucketerMock.Setup(bm => bm.Bucket(It.IsAny<ProjectConfig>(), everyoneElseRule, It.IsAny<string>(), GenericUserId)).Returns(Result<Variation>.NullResult(DecisionReasons));
 
             var decisionService = new DecisionService(BucketerMock.Object, ErrorHandlerMock.Object, null, LoggerMock.Object);
+            var optlyObject = new Optimizely(TestData.Datafile, new ValidEventDispatcher(), LoggerMock.Object);
 
             // Returned variation id should be of everyone else rule as it passes audience Id checking.
-            var actualDecision = decisionService.GetVariationForFeatureRollout(featureFlag, WhitelistedUserId, null, ProjectConfig);
+            var optimizelyUserContext = new OptimizelyUserContext(optlyObject, WhitelistedUserId, null, ErrorHandlerMock.Object, LoggerMock.Object);
+            var actualDecision = decisionService.GetVariationForFeatureRollout(featureFlag, optimizelyUserContext, ProjectConfig);
             Assert.True(TestData.CompareObjects(expectedDecision, actualDecision.ResultObject));
 
             // Returned variation id should be null.
-            actualDecision = decisionService.GetVariationForFeatureRollout(featureFlag, GenericUserId, null, ProjectConfig);
+            var optimizelyUserContext2 = new OptimizelyUserContext(optlyObject, GenericUserId, null, ErrorHandlerMock.Object, LoggerMock.Object);
+            actualDecision = decisionService.GetVariationForFeatureRollout(featureFlag, optimizelyUserContext2, ProjectConfig);
             Assert.Null(actualDecision.ResultObject);
 
             // Returned variation id should be null as it fails audience Id checking.
             everyoneElseRule.AudienceIds = new string[] { ProjectConfig.Audiences[0].Id };
 
             BucketerMock.Setup(bm => bm.Bucket(It.IsAny<ProjectConfig>(), It.IsAny<Experiment>(), It.IsAny<string>(), GenericUserId)).Returns(Result<Variation>.NullResult(DecisionReasons));
-            actualDecision = decisionService.GetVariationForFeatureRollout(featureFlag, GenericUserId, null, ProjectConfig) ?? Result<FeatureDecision>.NullResult(DecisionReasons);
+            actualDecision = decisionService.GetVariationForFeatureRollout(featureFlag, optimizelyUserContext2, ProjectConfig) ?? Result<FeatureDecision>.NullResult(DecisionReasons);
             Assert.Null(actualDecision.ResultObject);
 
             LoggerMock.Verify(l => l.Log(LogLevel.DEBUG, "User \"testUser1\" does not meet the conditions for targeting rule \"1\"."), Times.Once);
@@ -904,8 +924,8 @@ public void TestGetVariationForFeatureWhenTheUserIsNotBucketedIntoFeatureExperim
 
             DecisionServiceMock.Setup(ds => ds.GetVariationForFeatureExperiment(It.IsAny<FeatureFlag>(), It.IsAny<OptimizelyUserContext>(),
                 It.IsAny<UserAttributes>(), ProjectConfig, It.IsAny<OptimizelyDecideOption[]>())).Returns(Result<FeatureDecision>.NullResult(null));
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeatureRollout(It.IsAny<FeatureFlag>(), It.IsAny<string>(),
-                It.IsAny<UserAttributes>(), ProjectConfig)).Returns(expectedDecision);
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeatureRollout(It.IsAny<FeatureFlag>(), It.IsAny<OptimizelyUserContext>(),
+                ProjectConfig)).Returns(expectedDecision);
 
             var optlyObject = new Optimizely(TestData.Datafile, new ValidEventDispatcher(), LoggerMock.Object);
             OptimizelyUserContextMock = new Mock<OptimizelyUserContext>(optlyObject, WhitelistedUserId, new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object);
@@ -925,7 +945,7 @@ public void TestGetVariationForFeatureWhenTheUserIsNeitherBucketedIntoFeatureExp
             var featureFlag = ProjectConfig.GetFeatureFlagFromKey("string_single_variable_feature");
 
             DecisionServiceMock.Setup(ds => ds.GetVariationForFeatureExperiment(It.IsAny<FeatureFlag>(), It.IsAny<OptimizelyUserContext>(), It.IsAny<UserAttributes>(), ProjectConfig, new OptimizelyDecideOption[] { })).Returns(Result<FeatureDecision>.NullResult(null));
-            DecisionServiceMock.Setup(ds => ds.GetVariationForFeatureRollout(It.IsAny<FeatureFlag>(), It.IsAny<string>(), It.IsAny<UserAttributes>(), ProjectConfig)).Returns(Result<FeatureDecision>.NullResult(null));
+            DecisionServiceMock.Setup(ds => ds.GetVariationForFeatureRollout(It.IsAny<FeatureFlag>(), It.IsAny<OptimizelyUserContext>(), ProjectConfig)).Returns(Result<FeatureDecision>.NullResult(null));
 
             var optlyObject = new Optimizely(TestData.Datafile, new ValidEventDispatcher(), LoggerMock.Object);
             OptimizelyUserContextMock = new Mock<OptimizelyUserContext>(optlyObject, WhitelistedUserId, new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object);
@@ -967,7 +987,7 @@ public void TestGetVariationForFeatureWhenTheUserIsBuckedtedInBothExperimentAndR
             var expectedRolloutDecision = new FeatureDecision(rolloutExperiment, rolloutVariation.ResultObject, FeatureDecision.DECISION_SOURCE_ROLLOUT);
 
             BucketerMock.Setup(bm => bm.Bucket(ProjectConfig, rolloutExperiment, It.IsAny<string>(), It.IsAny<string>())).Returns(rolloutVariation);
-            var actualRolloutDecision = DecisionServiceMock.Object.GetVariationForFeatureRollout(featureFlag, "user1", userAttributes, ProjectConfig);
+            var actualRolloutDecision = DecisionServiceMock.Object.GetVariationForFeatureRollout(featureFlag, OptimizelyUserContextMock.Object, ProjectConfig);
 
             // The user is bucketed into feature rollout's variation.
 
diff --git a/OptimizelySDK/Bucketing/DecisionService.cs b/OptimizelySDK/Bucketing/DecisionService.cs
index 28c1d97a..c8607310 100644
--- a/OptimizelySDK/Bucketing/DecisionService.cs
+++ b/OptimizelySDK/Bucketing/DecisionService.cs
@@ -416,8 +416,7 @@ public void SaveVariation(Experiment experiment, Variation variation, UserProfil
         /// <returns>null if the user is not bucketed into the rollout or if the feature flag was not attached to a rollout.
         /// otherwise the FeatureDecision entity</returns>
         public virtual Result<FeatureDecision> GetVariationForFeatureRollout(FeatureFlag featureFlag,
-            string userId,
-            UserAttributes filteredAttributes,
+            OptimizelyUserContext user,
             ProjectConfig config)
         {
             var reasons = new DecisionReasons();
@@ -442,64 +441,32 @@ public virtual Result<FeatureDecision> GetVariationForFeatureRollout(FeatureFlag
                 return Result<FeatureDecision>.NullResult(reasons);
             }
 
-            if (rollout.Experiments == null || rollout.Experiments.Count == 0)
-            {
-                return Result<FeatureDecision>.NullResult(reasons);
-            }
-
-            Result<Variation> variationResult = null;
             var rolloutRulesLength = rollout.Experiments.Count;
+            var rolloutRules = rollout.Experiments;
 
-            // Get Bucketing ID from user attributes.
-            var bucketingIdResult = GetBucketingId(userId, filteredAttributes);
-            reasons += bucketingIdResult.DecisionReasons;
-            // For all rules before the everyone else rule
-            for (int i = 0; i < rolloutRulesLength - 1; i++)
-            {
-                string loggingKey = (i + 1).ToString();
-                var rolloutRule = rollout.Experiments[i];
-                var userMeetConditionsResult = ExperimentUtils.DoesUserMeetAudienceConditions(config, rolloutRule, filteredAttributes, LOGGING_KEY_TYPE_RULE, loggingKey, Logger);
-                reasons += userMeetConditionsResult.DecisionReasons;
-                if (userMeetConditionsResult.ResultObject)
-                {
-                    variationResult = Bucketer.Bucket(config, rolloutRule, bucketingIdResult.ResultObject, userId);
-                    reasons += variationResult?.DecisionReasons;
-                    if (string.IsNullOrEmpty(variationResult.ResultObject?.Id))
-                    {
-                        break;
-                    }
-                    return Result<FeatureDecision>.NewResult(new FeatureDecision(rolloutRule, variationResult.ResultObject, FeatureDecision.DECISION_SOURCE_ROLLOUT), reasons);
-                }
-                else
-                {
-                    Logger.Log(LogLevel.DEBUG, $"User \"{userId}\" does not meet the conditions for targeting rule \"{loggingKey}\".");
-                }
+            if (rolloutRules == null || rolloutRulesLength == 0)
+            {
+                return Result<FeatureDecision>.NullResult(reasons);
             }
 
-            // Get the last rule which is everyone else rule.
-            var everyoneElseRolloutRule = rollout.Experiments[rolloutRulesLength - 1];
-            var userMeetConditionsResultEveryoneElse = ExperimentUtils.DoesUserMeetAudienceConditions(config, everyoneElseRolloutRule, filteredAttributes, LOGGING_KEY_TYPE_RULE, "Everyone Else", Logger);
-            reasons += userMeetConditionsResultEveryoneElse.DecisionReasons;
-            if (userMeetConditionsResultEveryoneElse.ResultObject)
+            var index = 0;
+            while (index < rolloutRulesLength)
             {
-                variationResult = Bucketer.Bucket(config, everyoneElseRolloutRule, bucketingIdResult.ResultObject, userId);
-                reasons += variationResult?.DecisionReasons;
+                var decisionResult = GetVariationFromDeliveryRule(config, featureFlag.Key, rolloutRules, index, user);
+                reasons += decisionResult.DecisionReasons;
 
-                if (!string.IsNullOrEmpty(variationResult?.ResultObject?.Id))
+                if (decisionResult.ResultObject?.Variation != null)
                 {
-                    Logger.Log(LogLevel.DEBUG, $"User \"{userId}\" meets conditions for targeting rule \"Everyone Else\".");
-                    return Result<FeatureDecision>.NewResult(new FeatureDecision(everyoneElseRolloutRule, variationResult.ResultObject, FeatureDecision.DECISION_SOURCE_ROLLOUT), reasons);
+                    return Result<FeatureDecision>.NewResult(new FeatureDecision(rolloutRules[index], decisionResult.ResultObject.Variation, FeatureDecision.DECISION_SOURCE_ROLLOUT), reasons);
                 }
-            }
-            else
-            {
-                var audience = config.GetAudience(everyoneElseRolloutRule.AudienceIds[0]);
-                Logger.Log(LogLevel.DEBUG, $"User \"{userId}\" does not meet the conditions to be in rollout rule for audience \"{audience.Name}\".");
-            }
 
+                // the last rule is special for "Everyone Else"
+                index = decisionResult.SkipToEveryoneElse ? (rolloutRulesLength - 1) : (index + 1);
+            }
             return Result<FeatureDecision>.NullResult(reasons);
         }
 
+
         /// <summary>
         /// Get the variation if the user is bucketed for one of the experiments on this feature flag.
         /// </summary>
@@ -549,6 +516,8 @@ public virtual Result<FeatureDecision> GetVariationForFeatureExperiment(FeatureF
             return Result<FeatureDecision>.NullResult(reasons);
         }
 
+        
+
         private Result<FeatureDecision> GetVariationFromExperiment(ProjectConfig config, FeatureFlag flag, Experiment experiment, OptimizelyUserContext user, OptimizelyDecideOption[] options)
         {
             var reasons = new DecisionReasons();
@@ -576,6 +545,65 @@ private Result<FeatureDecision> GetVariationFromExperiment(ProjectConfig config,
             return Result<FeatureDecision>.NullResult(reasons);
         }
 
+        private Result<FeatureDecision> GetVariationFromDeliveryRule(ProjectConfig config, string key, List<Experiment> rules, int ruleIndex, OptimizelyUserContext user)
+        {
+            var reasons = new DecisionReasons();
+
+            bool skipToEveryoneElse = false;
+
+            //Check forced decision first
+            var rule = rules[ruleIndex];
+            var decisionContext = new OptimizelyDecisionContext(key, rule.Key);
+            var forcedDecisionResponse = user.FindValidatedForcedDecision(decisionContext);
+
+            reasons += forcedDecisionResponse.DecisionReasons;
+            if (forcedDecisionResponse.ResultObject != null)
+            {
+                return Result<FeatureDecision>.NewResult(new FeatureDecision(rule, forcedDecisionResponse.ResultObject, null), skipToEveryoneElse, reasons);
+            }
+
+            // Regular decision
+            var userId = user.GetUserId();
+            var attributes = user.GetAttributes();
+
+            // Get Bucketing ID from user attributes.
+            var bucketingIdResult = GetBucketingId(userId, attributes);
+            reasons += bucketingIdResult.DecisionReasons;
+
+            var everyoneElse = ruleIndex == rules.Count - 1;
+
+            var loggingKey = everyoneElse ? "Everyone Else" : ruleIndex + 1 + "";
+
+            Result<Variation> bucketedVariation = null;
+
+            // Evaluate if user meets the audience condition of this rollout rule
+            var doesUserMeetAudienceConditionsResult = ExperimentUtils.DoesUserMeetAudienceConditions(config, rule, attributes, LOGGING_KEY_TYPE_EXPERIMENT, rule.Key, Logger);
+            reasons += doesUserMeetAudienceConditionsResult.DecisionReasons;
+            if (doesUserMeetAudienceConditionsResult.ResultObject)
+            {
+                Logger.Log(LogLevel.INFO, reasons.AddInfo($"User \"{userId}\" meets condition for targeting rule \"{loggingKey}\"."));
+
+                bucketedVariation = Bucketer.Bucket(config, rule, bucketingIdResult.ResultObject, userId);
+                reasons += bucketedVariation?.DecisionReasons;
+
+                if (bucketedVariation?.ResultObject?.Key != null)
+                {
+                    Logger.Log(LogLevel.INFO, reasons.AddInfo($"User \"{userId}\" is in the traffic group of targeting rule \"{loggingKey}\"."));
+                }
+                else if (!everyoneElse)
+                {
+                    //skip this loggng for everyoneElse rule since this has a message not for everyoneElse
+                    Logger.Log(LogLevel.INFO, reasons.AddInfo($"User \"{userId}\" is not in the traffic group for targeting rule \"{loggingKey}\". Checking EveryoneElse rule now."));
+                    skipToEveryoneElse = true;
+                }
+            }
+            else
+            {
+                Logger.Log(LogLevel.DEBUG, reasons.AddInfo($"User \"{userId}\" does not meet conditions for targeting rule \"{loggingKey}\"."));
+            }
+
+            return Result<FeatureDecision>.NewResult(new FeatureDecision(rule, bucketedVariation?.ResultObject, null), skipToEveryoneElse, reasons);
+        }
         private Result<Variation> GetVariationFromExperimentRule(ProjectConfig config, string key, Experiment experiment, OptimizelyUserContext user, OptimizelyDecideOption[] options)
         {
             var reasons = new DecisionReasons();
@@ -643,16 +671,16 @@ public virtual Result<FeatureDecision> GetVariationForFeature(FeatureFlag featur
             }
 
             // Check if the feature flag has rollout and the the user is bucketed into one of its rules.
-            decisionResult = GetVariationForFeatureRollout(featureFlag, userId, filteredAttributes, config);
+            decisionResult = GetVariationForFeatureRollout(featureFlag, user, config);
             reasons += decisionResult.DecisionReasons;
 
             if (decisionResult.ResultObject != null)
             {
-                Logger.Log(LogLevel.INFO, reasons.AddInfo($"The user \"{userId}\" is bucketed into a rollout for feature flag \"{featureFlag.Key}\"."));
+                Logger.Log(LogLevel.INFO, reasons.AddInfo($"User \"{userId}\" is bucketed into a rollout for feature flag \"{featureFlag.Key}\"."));
                 return Result<FeatureDecision>.NewResult(decisionResult.ResultObject, reasons);
             }
 
-            Logger.Log(LogLevel.INFO, reasons.AddInfo($"The user \"{userId}\" is not bucketed into a rollout for feature flag \"{featureFlag.Key}\"."));
+            Logger.Log(LogLevel.INFO, reasons.AddInfo($"User \"{userId}\" is not bucketed into a rollout for feature flag \"{featureFlag.Key}\"."));
             return Result<FeatureDecision>.NullResult(reasons);
         }
 
diff --git a/OptimizelySDK/Entity/Result.cs b/OptimizelySDK/Entity/Result.cs
index 17a63133..04a30d6c 100644
--- a/OptimizelySDK/Entity/Result.cs
+++ b/OptimizelySDK/Entity/Result.cs
@@ -21,7 +21,12 @@ public class Result<T>
     {
         public T ResultObject;
         public DecisionReasons DecisionReasons;
+        public bool SkipToEveryoneElse;
 
+        public static Result<T> NewResult(T resultObject, bool skipToEveryoneElse, DecisionReasons decisionReasons)
+        {
+            return new Result<T> { DecisionReasons = decisionReasons, ResultObject = resultObject, SkipToEveryoneElse = skipToEveryoneElse };
+        }
         public static Result<T> NewResult(T resultObject, DecisionReasons decisionReasons)
         {
             return new Result<T> { DecisionReasons = decisionReasons, ResultObject = resultObject };
diff --git a/OptimizelySDK/Event/Builder/EventBuilder.cs b/OptimizelySDK/Event/Builder/EventBuilder.cs
index 08f4920e..67ec1179 100644
--- a/OptimizelySDK/Event/Builder/EventBuilder.cs
+++ b/OptimizelySDK/Event/Builder/EventBuilder.cs
@@ -132,7 +132,7 @@ private Dictionary<string, object> GetImpressionParams(Experiment experiment, st
                     new Dictionary<string, object>
                     {
                         { Params.CAMPAIGN_ID,   experiment != null ? experiment.LayerId : null },
-                        { Params.EXPERIMENT_ID, experiment != null ? experiment.Id : null },
+                        { Params.EXPERIMENT_ID, experiment != null ? experiment.Id : "" },
                         { Params.VARIATION_ID,  variationId }
                     }
             };
diff --git a/OptimizelySDK/Event/EventFactory.cs b/OptimizelySDK/Event/EventFactory.cs
index 63482a8b..7979303f 100644
--- a/OptimizelySDK/Event/EventFactory.cs
+++ b/OptimizelySDK/Event/EventFactory.cs
@@ -114,7 +114,7 @@ private static Visitor CreateVisitor(ImpressionEvent impressionEvent) {
             var eventContext = impressionEvent.Context;
 
             Decision decision = new Decision(impressionEvent.Experiment?.LayerId,
-                impressionEvent.Experiment?.Id,
+                impressionEvent.Experiment?.Id ??"",
                 impressionEvent.Variation?.Id,
                 impressionEvent.Metadata);
 
diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index 1f9b4625..ba39a86c 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -225,7 +225,7 @@ public bool SetForcedDecision(OptimizelyDecisionContext context, OptimizelyForce
 
             lock (mutex)
             {
-                ForcedDecisionsMap.Add(context.DecisionKey, decision);
+                ForcedDecisionsMap[context.DecisionKey] = decision;
             }
 
             return true;
@@ -317,22 +317,21 @@ public Result<Variation> FindValidatedForcedDecision(OptimizelyDecisionContext c
         {
             DecisionReasons reasons = new DecisionReasons();
             var forcedDecision = GetForcedDecision(context);
-            string strRuleKey = context.RuleKey ?? OptimizelyDecisionContext.OPTI_NULL_RULE_KEY;
 
-            Variation variation = null;
             if (forcedDecision != null)
             {
+                var loggingKey = context.RuleKey != null ? "flag (" + context.FlagKey + "), rule (" + context.RuleKey + ")" : "flag (" + context.FlagKey + ")";
                 var variationKey = forcedDecision.VariationKey;
-                variation = Optimizely.GetFlagVariationByKey(context.FlagKey, variationKey);
+                var variation = Optimizely.GetFlagVariationByKey(context.FlagKey, variationKey);
                 if (variation != null)
                 {
                     reasons.AddInfo("Decided by forced decision.");
-                    reasons.AddInfo("Variation ({0}) is mapped to flag ({1}) and user ({2}) in the forced decision map.", variationKey, context.FlagKey, this.UserId);
+                    reasons.AddInfo("Variation ({0}) is mapped to {1} and user ({2}) in the forced decision map.", variationKey, loggingKey, UserId);
                     return Result<Variation>.NewResult(variation, reasons);
                 }
                 else
                 {
-                    reasons.AddInfo("Invalid variation is mapped to flag ({0}) and user ({1}) in the forced decision map.", context.FlagKey, this.UserId);
+                    reasons.AddInfo("Invalid variation is mapped to {0} and user ({1}) in the forced decision map.", loggingKey, UserId);
                 }
             }
             return Result<Variation>.NullResult(reasons);

From 3bd0bb04bb3ad5448a287d7ebb6ffcdf13339bed Mon Sep 17 00:00:00 2001
From: muhammadnoman <muhammadnoman@folio3.com>
Date: Fri, 12 Nov 2021 21:06:25 +0500
Subject: [PATCH 103/130] fixed decision service

---
 OptimizelySDK.Tests/DecisionServiceTest.cs |  2 +-
 OptimizelySDK/Bucketing/DecisionService.cs | 10 +++++-----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/OptimizelySDK.Tests/DecisionServiceTest.cs b/OptimizelySDK.Tests/DecisionServiceTest.cs
index 3071ce9b..fd2521dc 100644
--- a/OptimizelySDK.Tests/DecisionServiceTest.cs
+++ b/OptimizelySDK.Tests/DecisionServiceTest.cs
@@ -845,7 +845,7 @@ public void TestGetVariationForFeatureRolloutAudienceAndTrafficeAllocationCheck(
             actualDecision = decisionService.GetVariationForFeatureRollout(featureFlag, optimizelyUserContext4, ProjectConfig);
 
             // Returned decision entity should be null because bucket value exceeds traffic allocation of everyone else rule.
-            Assert.Null(actualDecision.ResultObject);
+            Assert.Null(actualDecision.ResultObject?.Variation?.Key);
         }
 
         [Test]
diff --git a/OptimizelySDK/Bucketing/DecisionService.cs b/OptimizelySDK/Bucketing/DecisionService.cs
index c8607310..feef3ab6 100644
--- a/OptimizelySDK/Bucketing/DecisionService.cs
+++ b/OptimizelySDK/Bucketing/DecisionService.cs
@@ -455,7 +455,7 @@ public virtual Result<FeatureDecision> GetVariationForFeatureRollout(FeatureFlag
                 var decisionResult = GetVariationFromDeliveryRule(config, featureFlag.Key, rolloutRules, index, user);
                 reasons += decisionResult.DecisionReasons;
 
-                if (decisionResult.ResultObject?.Variation != null)
+                if (decisionResult.ResultObject?.Variation?.Key != null)
                 {
                     return Result<FeatureDecision>.NewResult(new FeatureDecision(rolloutRules[index], decisionResult.ResultObject.Variation, FeatureDecision.DECISION_SOURCE_ROLLOUT), reasons);
                 }
@@ -577,7 +577,7 @@ private Result<FeatureDecision> GetVariationFromDeliveryRule(ProjectConfig confi
             Result<Variation> bucketedVariation = null;
 
             // Evaluate if user meets the audience condition of this rollout rule
-            var doesUserMeetAudienceConditionsResult = ExperimentUtils.DoesUserMeetAudienceConditions(config, rule, attributes, LOGGING_KEY_TYPE_EXPERIMENT, rule.Key, Logger);
+            var doesUserMeetAudienceConditionsResult = ExperimentUtils.DoesUserMeetAudienceConditions(config, rule, attributes, LOGGING_KEY_TYPE_RULE, rule.Key, Logger);
             reasons += doesUserMeetAudienceConditionsResult.DecisionReasons;
             if (doesUserMeetAudienceConditionsResult.ResultObject)
             {
@@ -599,7 +599,7 @@ private Result<FeatureDecision> GetVariationFromDeliveryRule(ProjectConfig confi
             }
             else
             {
-                Logger.Log(LogLevel.DEBUG, reasons.AddInfo($"User \"{userId}\" does not meet conditions for targeting rule \"{loggingKey}\"."));
+                Logger.Log(LogLevel.DEBUG, reasons.AddInfo($"User \"{userId}\" does not meet the conditions for targeting rule \"{loggingKey}\"."));
             }
 
             return Result<FeatureDecision>.NewResult(new FeatureDecision(rule, bucketedVariation?.ResultObject, null), skipToEveryoneElse, reasons);
@@ -676,11 +676,11 @@ public virtual Result<FeatureDecision> GetVariationForFeature(FeatureFlag featur
 
             if (decisionResult.ResultObject != null)
             {
-                Logger.Log(LogLevel.INFO, reasons.AddInfo($"User \"{userId}\" is bucketed into a rollout for feature flag \"{featureFlag.Key}\"."));
+                Logger.Log(LogLevel.INFO, reasons.AddInfo($"The user \"{userId}\" is bucketed into a rollout for feature flag \"{featureFlag.Key}\"."));
                 return Result<FeatureDecision>.NewResult(decisionResult.ResultObject, reasons);
             }
 
-            Logger.Log(LogLevel.INFO, reasons.AddInfo($"User \"{userId}\" is not bucketed into a rollout for feature flag \"{featureFlag.Key}\"."));
+            Logger.Log(LogLevel.INFO, reasons.AddInfo($"The user \"{userId}\" is not bucketed into a rollout for feature flag \"{featureFlag.Key}\"."));
             return Result<FeatureDecision>.NullResult(reasons);
         }
 

From ba225f978af5523f7b46dbbc771fb6f59c4a0f31 Mon Sep 17 00:00:00 2001
From: muhammadnoman <muhammadnoman@folio3.com>
Date: Fri, 12 Nov 2021 21:09:06 +0500
Subject: [PATCH 104/130] test fixed

---
 OptimizelySDK.Tests/EventTests/EventFactoryTest.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/OptimizelySDK.Tests/EventTests/EventFactoryTest.cs b/OptimizelySDK.Tests/EventTests/EventFactoryTest.cs
index c39facb6..da7733a8 100644
--- a/OptimizelySDK.Tests/EventTests/EventFactoryTest.cs
+++ b/OptimizelySDK.Tests/EventTests/EventFactoryTest.cs
@@ -511,7 +511,7 @@ public void TestCreateImpressionEventRemovesInvalidAttributesFromPayloadRollout(
                                                 new Dictionary<string, object>
                                                 {
                                                     {"campaign_id", null },
-                                                    {"experiment_id", null },
+                                                    {"experiment_id", "" },
                                                     {"variation_id", null },
                                                     { "metadata", new Dictionary<string, object> {
                                                             { "rule_type", "rollout" },

From 6f563bb70b97e96a5e36e2db3f895a58bf29aa21 Mon Sep 17 00:00:00 2001
From: muhammadnoman <muhammadnoman@folio3.com>
Date: Tue, 16 Nov 2021 21:49:40 +0500
Subject: [PATCH 105/130] Fixed Group experiments were not added in experiment
 id list fixed getFlagVariationsMap function to pick right variation of right
 featureFlag

---
 OptimizelySDK.Tests/ProjectConfigTest.cs      | 239 +-----------------
 OptimizelySDK/Config/DatafileProjectConfig.cs |  19 +-
 2 files changed, 22 insertions(+), 236 deletions(-)

diff --git a/OptimizelySDK.Tests/ProjectConfigTest.cs b/OptimizelySDK.Tests/ProjectConfigTest.cs
index 7afca2c4..455bbc55 100644
--- a/OptimizelySDK.Tests/ProjectConfigTest.cs
+++ b/OptimizelySDK.Tests/ProjectConfigTest.cs
@@ -433,245 +433,30 @@ public void TestFlagVariations()
                 new Variation
                 {
                     FeatureEnabled = true,
-                    Id = "122239",
-                    Key = "control",
-                    FeatureVariableUsageInstances = new List<FeatureVariableUsage> { new FeatureVariableUsage { Id = "155551", Value="42.42" } }
-                },
-                new Variation
-                {
-                    FeatureEnabled = false,
-                    Id = "122240",
-                    Key = "variation",
-                    FeatureVariableUsageInstances = new List<FeatureVariableUsage> { new FeatureVariableUsage { Id = "155551", Value="13.37" } }
-                },
-                new Variation
-                {
-                    FeatureEnabled = false,
-                    Id = "122242",
-                    Key = "control",
-                    FeatureVariableUsageInstances = new List<FeatureVariableUsage> { new FeatureVariableUsage { Id = "155553", Value="42" } }
-                },
-                new Variation
-                {
-                    FeatureEnabled = true,
-                    Id = "122243",
-                    Key = "variation",
-                    FeatureVariableUsageInstances = new List<FeatureVariableUsage> { new FeatureVariableUsage { Id = "155553", Value="13" } }
-                },
-                new Variation
-                {
-                    FeatureEnabled = true, Id = "177771",
-                    Key = "177771",
-                    FeatureVariableUsageInstances = new List<FeatureVariableUsage> { new FeatureVariableUsage { Id = "155556", Value="true" } }
-                },
-                new Variation
-                {
-                    FeatureEnabled = true,
-                    Id = "177773",
-                    Key = "177773",
-                    FeatureVariableUsageInstances = new List<FeatureVariableUsage>
-                    {
-                        new FeatureVariableUsage
-                        {
-                            Id = "155556",
-                            Value="false"
-                        }
-                    }
-                },
-                new Variation
-                {
-                    FeatureEnabled = true,
-                    Id = "177778",
-                    Key = "177778",
-                    FeatureVariableUsageInstances = new List<FeatureVariableUsage>
-                    {
-                        new FeatureVariableUsage
-                        {
-                            Id = "155556", Value="false"
-                        }
-                    }
-                },
-                new Variation
-                {
-                    FeatureEnabled = false,
-                    Id = "177782",
-                    Key = "177782",
-                    FeatureVariableUsageInstances = new List<FeatureVariableUsage>
-                    {
-                        new FeatureVariableUsage
-                        {
-                            Id = "155556",
-                            Value="false"
-                        }
-                    }
-                },
-                new Variation
-                {
-                    FeatureEnabled = false,
-                    Id = "188881",
-                    Key = "188881",
-                    FeatureVariableUsageInstances = new List<FeatureVariableUsage>
-                    {
-                        new FeatureVariableUsage
-                        {
-                            Id = "155556",
-                            Value= "false"
-                        }
-                    }
-                },
-                new Variation
-                {
-                    FeatureEnabled = true,
-                    Id = "122236",
-                    Key = "control",
-                    FeatureVariableUsageInstances = new List<FeatureVariableUsage>
-                    {
-                        new FeatureVariableUsage
-                        {
-                            Id = "155558",
-                            Value= "cta_1"
-                        },
-                        new FeatureVariableUsage
-                        {
-                            Id = "17014990011",
-                            Value = "{\"int_var\": 1, \"boolean_key\": false}"
-                        }
-                    }
+                    Id = "7722260071",
+                    Key = "group_exp_1_var_1",
+                    FeatureVariableUsageInstances = new List<FeatureVariableUsage> { new FeatureVariableUsage { Id = "155563", Value= "groupie_1_v1" } }
                 },
                 new Variation
                 {
                     FeatureEnabled = true,
-                    Id = "122237",
-                    Key = "variation",
-                    FeatureVariableUsageInstances = new List<FeatureVariableUsage>
-                    {
-                        new FeatureVariableUsage
-                        {
-                            Id = "155558",
-                            Value= "cta_2"
-                        },
-                    }
-                },
-                new Variation
-                {
-                    FeatureEnabled = true,
-                    Id = "177775",
-                    Key = "177775",
-                    FeatureVariableUsageInstances = new List<FeatureVariableUsage>
-                    {
-                        new FeatureVariableUsage
-                        {
-                            Id = "155558",
-                            Value= "cta_4"
-                        },
-                        new FeatureVariableUsage
-                        {
-                            Id = "17014990011",
-                            Value= "{\"int_var\": 4 , \"string_var\": \"cta_4\"}"
-                        },
-                        new FeatureVariableUsage
-                        {
-                            Id = "170149900112",
-                            Value= "{\"int_var\": 5 , \"string_var\": \"cta_5\"}"
-                        }
-                    }
-                },
-                new Variation
-                {
-                    FeatureEnabled = true,
-                    Id = "177780",
-                    Key = "177780",
-                    FeatureVariableUsageInstances = new List<FeatureVariableUsage> { }
+                    Id = "7722360022",
+                    Key = "group_exp_1_var_2",
+                    FeatureVariableUsageInstances = new List<FeatureVariableUsage> { new FeatureVariableUsage { Id = "155563", Value= "groupie_1_v2" } }
                 },
                 new Variation
                 {
                     FeatureEnabled = false,
-                    Id = "177784",
-                    Key = "177784",
-                    FeatureVariableUsageInstances = new List<FeatureVariableUsage>
-                    {
-                        new FeatureVariableUsage
-                        {
-                            Id = "155558",
-                            Value= "cta_5"
-                        }
-                    }
-                },
-                new Variation
-                {
-                    FeatureEnabled = true,
-                    Id = "122231",
-                    Key = "Fred",
-                    FeatureVariableUsageInstances = new List<FeatureVariableUsage>
-                    {
-                        new FeatureVariableUsage
-                        {
-                            Id = "155560",
-                            Value = "F"
-                        },
-                        new FeatureVariableUsage
-                        {
-                            Id = "155561",
-                            Value = "red"
-                        }
-                    }
+                    Id = "7713030086",
+                    Key = "group_exp_2_var_1",
+                    FeatureVariableUsageInstances = new List<FeatureVariableUsage> { new FeatureVariableUsage { Id = "155563", Value= "groupie_2_v1" } }
                 },
                 new Variation
                 {
                     FeatureEnabled = false,
-                    Id = "122232",
-                    Key = "Feorge",
-                    FeatureVariableUsageInstances = new List<FeatureVariableUsage>
-                    {
-                        new FeatureVariableUsage
-                        {
-                            Id = "155560",
-                            Value = "F"
-                        },
-                        new FeatureVariableUsage
-                        {
-                            Id = "155561",
-                            Value = "eorge"
-                        }
-                    }
-                },
-                new Variation
-                {
-                    FeatureEnabled = null,
-                    Id = "122233",
-                    Key = "Gred",
-                    FeatureVariableUsageInstances = new List<FeatureVariableUsage>
-                    {
-                        new FeatureVariableUsage
-                        {
-                            Id = "155560",
-                            Value = "G"
-                        },
-                        new FeatureVariableUsage
-                        {
-                            Id = "155561",
-                            Value = "red"
-                        }
-                    }
-                },
-                new Variation
-                {
-                    FeatureEnabled = true,
-                    Id = "122234",
-                    Key = "George",
-                    FeatureVariableUsageInstances = new List<FeatureVariableUsage>
-                    {
-                        new FeatureVariableUsage
-                        {
-                            Id = "155560",
-                            Value = "G"
-                        },
-                        new FeatureVariableUsage
-                        {
-                            Id = "155561",
-                            Value = "eorge"
-                        }
-                    }
+                    Id = "7725250007",
+                    Key = "group_exp_2_var_2",
+                    FeatureVariableUsageInstances = new List<FeatureVariableUsage> { new FeatureVariableUsage { Id = "155563", Value= "groupie_2_v2" } }
                 }
             };
             expectedVariations1.Add(new Dictionary<string, List<Variation>> { { "boolean_feature", expectedVariationList } });
diff --git a/OptimizelySDK/Config/DatafileProjectConfig.cs b/OptimizelySDK/Config/DatafileProjectConfig.cs
index 890a4c4f..d879e6cf 100644
--- a/OptimizelySDK/Config/DatafileProjectConfig.cs
+++ b/OptimizelySDK/Config/DatafileProjectConfig.cs
@@ -290,7 +290,6 @@ private void Initialize()
             _AudienceIdMap = ConfigParser<Audience>.GenerateMap(entities: Audiences, getKey: a => a.Id.ToString(), clone: true);
             _FeatureKeyMap = ConfigParser<FeatureFlag>.GenerateMap(entities: FeatureFlags, getKey: f => f.Key, clone: true);
             _RolloutIdMap = ConfigParser<Rollout>.GenerateMap(entities: Rollouts, getKey: r => r.Id.ToString(), clone: true);
-            _FlagVariationMap = GetFlagVariationMap();
 
             // Overwrite similar items in audience id map with typed audience id map.
             var typedAudienceIdMap = ConfigParser<Audience>.GenerateMap(entities: TypedAudiences, getKey: a => a.Id.ToString(), clone: true);
@@ -367,6 +366,7 @@ private void Initialize()
                         ExperimentFeatureMap[experimentId] = new List<string> { feature.Id };
                 }
             }
+            _FlagVariationMap = GetFlagVariationMap();
         }
 
         /// <summary>
@@ -375,25 +375,26 @@ private void Initialize()
         /// <returns>A map of flag key to variations</returns>
         private Dictionary<string, List<Variation>> GetFlagVariationMap()
         {
-            var map = new Dictionary<string, List<Variation>>();
-            var variations = new List<Variation>();
+            var variationsDict = new Dictionary<string, List<Variation>>();
 
-            foreach (var flag in this.FeatureFlags)
+            foreach (var flag in FeatureFlags)
             {
+                var variationIdToVariationsDict = new Dictionary<string, Variation>();
+
                 foreach (var rule in GetAllRulesForFlag(flag))
                 {
                     foreach (var variation in rule.Variations)
                     {
-                        if (!variations.Contains(variation))
+                        if (!variationIdToVariationsDict.ContainsKey(variation.Id))
                         {
-                            variations.Add(variation);
+                            variationIdToVariationsDict.Add(variation.Id, variation);
                         }
                     }
                 }
-                map[flag.Key] = variations;
+                // Grab all the variations from the flag experiments and rollouts and add to flagVariationsMap
+                variationsDict[flag.Key] = variationIdToVariationsDict.Values.ToList<Variation>();
             }
-
-            return map;
+            return variationsDict;
         }
 
         /// <summary>

From c7312ec4261b392ee4ecb5999f90b2291a5b0f25 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Fri, 19 Nov 2021 13:40:01 -0500
Subject: [PATCH 106/130] updated git ignore, included additiona assertions

---
 .gitignore                        | 3 +--
 OptimizelySDK.Tests/Assertions.cs | 1 +
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.gitignore b/.gitignore
index 666f0e93..bf807ea3 100644
--- a/.gitignore
+++ b/.gitignore
@@ -244,5 +244,4 @@ ModelManifest.xml
 OptimizelySDK.Package/nuget.exe
 OptimizelySDK.Package/content
 OptimizelySDK.Package/lib
-/OptimizelySDK.Tests/fsc.json
-/datafiles
+
diff --git a/OptimizelySDK.Tests/Assertions.cs b/OptimizelySDK.Tests/Assertions.cs
index ee741f71..3f95e42b 100644
--- a/OptimizelySDK.Tests/Assertions.cs
+++ b/OptimizelySDK.Tests/Assertions.cs
@@ -251,6 +251,7 @@ public static void AreEqual(OptimizelyDecision expected, OptimizelyDecision actu
             AreEquivalent(expected.Reasons, actual.Reasons);
             Assert.AreEqual(expected.RuleKey, actual.RuleKey);
             AreEqual(expected.UserContext, actual.UserContext);
+            Assert.AreEqual(expected.VariationKey, actual.VariationKey);
         }
 
         public static void AreEquivalent(IDictionary<string, OptimizelyDecision> expected, IDictionary<string, OptimizelyDecision> actual)

From 0db66fd473ad6a8255ee04a6c58d768ba837e9b3 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Fri, 19 Nov 2021 13:44:24 -0500
Subject: [PATCH 107/130] rename variationKey to include _

---
 OptimizelySDK.Tests/OptimizelySDK.Tests.csproj | 3 +++
 OptimizelySDK/OptimizelyForcedDecision.cs      | 6 +++---
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj b/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj
index 26b18922..0c110a95 100644
--- a/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj
+++ b/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj
@@ -135,6 +135,9 @@
       <Name>OptimizelySDK</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+	<Folder Include="Utils\" />
+  </ItemGroup>
   <ItemGroup>
     <None Include="packages.config" />
     <EmbeddedResource Include="unsupported_version_datafile.json" />
diff --git a/OptimizelySDK/OptimizelyForcedDecision.cs b/OptimizelySDK/OptimizelyForcedDecision.cs
index db5f1850..49b45dde 100644
--- a/OptimizelySDK/OptimizelyForcedDecision.cs
+++ b/OptimizelySDK/OptimizelyForcedDecision.cs
@@ -18,13 +18,13 @@ namespace OptimizelySDK
 {
     public class OptimizelyForcedDecision
     {
-        private string variationKey;
+        private string _variationKey;
 
         public OptimizelyForcedDecision(string variationKey)
         {
-            this.variationKey = variationKey;
+            this._variationKey = variationKey;
         }
 
-        public string VariationKey { get { return variationKey; } }
+        public string VariationKey { get { return _variationKey; } }
     }
 }

From 8bce7277aab89eb5e5353c45711bdf5baa5953ae Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Fri, 19 Nov 2021 13:44:56 -0500
Subject: [PATCH 108/130] Removed partial that...shouldn't have been in there

---
 OptimizelySDK/OptimizelyUserContext.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index ba39a86c..7ef49293 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -26,7 +26,7 @@ namespace OptimizelySDK
     /// <summary>
     /// OptimizelyUserContext defines user contexts that the SDK will use to make decisions for
     /// </summary>
-    public partial class OptimizelyUserContext
+    public class OptimizelyUserContext
     {
         private ILogger Logger;
         private IErrorHandler ErrorHandler;

From 69a2f5115d6d08abf4e371c70b48568c8ca38168 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Fri, 19 Nov 2021 13:46:52 -0500
Subject: [PATCH 109/130] removed unnecessary usings

---
 OptimizelySDK/OptlyConfig/OptimizelyConfig.cs | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/OptimizelySDK/OptlyConfig/OptimizelyConfig.cs b/OptimizelySDK/OptlyConfig/OptimizelyConfig.cs
index 1981af03..7b682898 100644
--- a/OptimizelySDK/OptlyConfig/OptimizelyConfig.cs
+++ b/OptimizelySDK/OptlyConfig/OptimizelyConfig.cs
@@ -14,9 +14,6 @@
  * limitations under the License.
  */
 
-using Newtonsoft.Json;
-using OptimizelySDK.Entity;
-using System;
 using System.Collections.Generic;
 
 namespace OptimizelySDK.OptlyConfig

From 10eaf224fb4d3857ed7979eb843d043d4ce8ff51 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Tue, 23 Nov 2021 07:59:33 -0500
Subject: [PATCH 110/130] Renamed file

---
 ...nfigManagerTest.cs => AtomicProjectConfigManagerTest.cs} | 0
 OptimizelySDK.Tests/OptimizelySDK.Tests.csproj              | 6 ++----
 2 files changed, 2 insertions(+), 4 deletions(-)
 rename OptimizelySDK.Tests/ConfigTest/{FallbackProjectConfigManagerTest.cs => AtomicProjectConfigManagerTest.cs} (100%)

diff --git a/OptimizelySDK.Tests/ConfigTest/FallbackProjectConfigManagerTest.cs b/OptimizelySDK.Tests/ConfigTest/AtomicProjectConfigManagerTest.cs
similarity index 100%
rename from OptimizelySDK.Tests/ConfigTest/FallbackProjectConfigManagerTest.cs
rename to OptimizelySDK.Tests/ConfigTest/AtomicProjectConfigManagerTest.cs
diff --git a/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj b/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj
index 0c110a95..231e256b 100644
--- a/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj
+++ b/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj
@@ -75,7 +75,7 @@
     <Compile Include="AudienceConditionsTests\ConditionsTest.cs" />
     <Compile Include="ConfigTest\HttpProjectConfigManagerTest.cs" />
     <Compile Include="ConfigTest\PollingProjectConfigManagerTest.cs" />
-    <Compile Include="ConfigTest\FallbackProjectConfigManagerTest.cs" />
+    <Compile Include="ConfigTest\AtomicProjectConfigManagerTest.cs" />
     <Compile Include="DecisionServiceTest.cs" />
     <Compile Include="DefaultErrorHandlerTest.cs" />
     <Compile Include="EventTests\EventProcessorProps.cs" />
@@ -135,9 +135,7 @@
       <Name>OptimizelySDK</Name>
     </ProjectReference>
   </ItemGroup>
-  <ItemGroup>
-	<Folder Include="Utils\" />
-  </ItemGroup>
+  <ItemGroup />
   <ItemGroup>
     <None Include="packages.config" />
     <EmbeddedResource Include="unsupported_version_datafile.json" />

From f608a706266ccc6d8285d1e0bf479ac73b72f853 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Tue, 23 Nov 2021 08:00:55 -0500
Subject: [PATCH 111/130] changed to string.empty

---
 OptimizelySDK.Tests/EventTests/EventFactoryTest.cs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/OptimizelySDK.Tests/EventTests/EventFactoryTest.cs b/OptimizelySDK.Tests/EventTests/EventFactoryTest.cs
index da7733a8..b17cff2c 100644
--- a/OptimizelySDK.Tests/EventTests/EventFactoryTest.cs
+++ b/OptimizelySDK.Tests/EventTests/EventFactoryTest.cs
@@ -511,13 +511,13 @@ public void TestCreateImpressionEventRemovesInvalidAttributesFromPayloadRollout(
                                                 new Dictionary<string, object>
                                                 {
                                                     {"campaign_id", null },
-                                                    {"experiment_id", "" },
+                                                    {"experiment_id", string.Empty },
                                                     {"variation_id", null },
                                                     { "metadata", new Dictionary<string, object> {
                                                             { "rule_type", "rollout" },
-                                                            { "rule_key", "" },
+                                                            { "rule_key", string.Empty },
                                                             { "flag_key", "test_feature" },
-                                                            { "variation_key", "" },
+                                                            { "variation_key", string.Empty },
                                                             { "enabled", false }
                                                         }
                                                     }

From d5c621b1640dad6c31df8b492a28a74114c85b18 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Mon, 29 Nov 2021 09:00:50 -0500
Subject: [PATCH 112/130] Update to remove null error

---
 OptimizelySDK/Config/DatafileProjectConfig.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/OptimizelySDK/Config/DatafileProjectConfig.cs b/OptimizelySDK/Config/DatafileProjectConfig.cs
index d879e6cf..5f28fa71 100644
--- a/OptimizelySDK/Config/DatafileProjectConfig.cs
+++ b/OptimizelySDK/Config/DatafileProjectConfig.cs
@@ -662,7 +662,7 @@ public Variation GetFlagVariationByKey(string flagKey, string variationKey)
             {
                 foreach (var variation in variations)
                 {
-                    if (variation.Key.Equals(variationKey))
+                    if (variation.Key == variationKey)
                     {
                         return variation;
                     }

From 5511a91049411cc1cc903ac215d9513f815ff3b5 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Mon, 29 Nov 2021 09:02:17 -0500
Subject: [PATCH 113/130] change to just experiement?.layerid

---
 OptimizelySDK/Event/Builder/EventBuilder.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/OptimizelySDK/Event/Builder/EventBuilder.cs b/OptimizelySDK/Event/Builder/EventBuilder.cs
index 67ec1179..1976668e 100644
--- a/OptimizelySDK/Event/Builder/EventBuilder.cs
+++ b/OptimizelySDK/Event/Builder/EventBuilder.cs
@@ -131,7 +131,7 @@ private Dictionary<string, object> GetImpressionParams(Experiment experiment, st
             {
                     new Dictionary<string, object>
                     {
-                        { Params.CAMPAIGN_ID,   experiment != null ? experiment.LayerId : null },
+                        { Params.CAMPAIGN_ID,   experiment?.LayerId },
                         { Params.EXPERIMENT_ID, experiment != null ? experiment.Id : "" },
                         { Params.VARIATION_ID,  variationId }
                     }

From 375d7489172c2ea97989007ae1fecb4086f9d374 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Mon, 29 Nov 2021 09:02:51 -0500
Subject: [PATCH 114/130] changed to experiment?.id

---
 OptimizelySDK/Event/Builder/EventBuilder.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/OptimizelySDK/Event/Builder/EventBuilder.cs b/OptimizelySDK/Event/Builder/EventBuilder.cs
index 1976668e..b7790468 100644
--- a/OptimizelySDK/Event/Builder/EventBuilder.cs
+++ b/OptimizelySDK/Event/Builder/EventBuilder.cs
@@ -132,7 +132,7 @@ private Dictionary<string, object> GetImpressionParams(Experiment experiment, st
                     new Dictionary<string, object>
                     {
                         { Params.CAMPAIGN_ID,   experiment?.LayerId },
-                        { Params.EXPERIMENT_ID, experiment != null ? experiment.Id : "" },
+                        { Params.EXPERIMENT_ID, experiment?.Id},
                         { Params.VARIATION_ID,  variationId }
                     }
             };

From 5be1a050801b84288e58da6e8e425db5f89c0ca4 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Mon, 29 Nov 2021 09:03:17 -0500
Subject: [PATCH 115/130] additional change

---
 OptimizelySDK/Event/Builder/EventBuilder.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/OptimizelySDK/Event/Builder/EventBuilder.cs b/OptimizelySDK/Event/Builder/EventBuilder.cs
index b7790468..b55ad836 100644
--- a/OptimizelySDK/Event/Builder/EventBuilder.cs
+++ b/OptimizelySDK/Event/Builder/EventBuilder.cs
@@ -141,7 +141,7 @@ private Dictionary<string, object> GetImpressionParams(Experiment experiment, st
             {
                     new Dictionary<string, object>
                     {
-                        { "entity_id", experiment != null ? experiment.LayerId : null },
+                        { "entity_id", experiment?.LayerId },
                         { "timestamp", DateTimeUtils.SecondsSince1970*1000 },
                         { "key", ACTIVATE_EVENT_KEY },
                         { "uuid", Guid.NewGuid() }

From 48b15ef23bb2db4abfd66fc3a8fd51cac4630c09 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Mon, 29 Nov 2021 09:03:38 -0500
Subject: [PATCH 116/130] rename

---
 OptimizelySDK/Event/Builder/EventBuilder.cs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/OptimizelySDK/Event/Builder/EventBuilder.cs b/OptimizelySDK/Event/Builder/EventBuilder.cs
index b55ad836..613a9edc 100644
--- a/OptimizelySDK/Event/Builder/EventBuilder.cs
+++ b/OptimizelySDK/Event/Builder/EventBuilder.cs
@@ -176,11 +176,11 @@ private List<object> GetConversionParams(ProjectConfig config, string eventKey,
                     eventDict[EventTagUtils.REVENUE_EVENT_METRIC_NAME] = revenue;
                 }
 
-                var eventVallue = EventTagUtils.GetNumericValue(eventTags, Logger);
+                var eventValue = EventTagUtils.GetNumericValue(eventTags, Logger);
 
-                if (eventVallue != null)
+                if (eventValue != null)
                 {
-                    eventDict[EventTagUtils.VALUE_EVENT_METRIC_NAME] = eventVallue;
+                    eventDict[EventTagUtils.VALUE_EVENT_METRIC_NAME] = eventValue;
                 }
 
                 if (eventTags.Any())

From 4bca717b0f7f31f52829275c5eb20a8944662914 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Mon, 29 Nov 2021 09:04:34 -0500
Subject: [PATCH 117/130] changedto string.empty

---
 OptimizelySDK/Event/EventFactory.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/OptimizelySDK/Event/EventFactory.cs b/OptimizelySDK/Event/EventFactory.cs
index 7979303f..eb7d2b28 100644
--- a/OptimizelySDK/Event/EventFactory.cs
+++ b/OptimizelySDK/Event/EventFactory.cs
@@ -114,7 +114,7 @@ private static Visitor CreateVisitor(ImpressionEvent impressionEvent) {
             var eventContext = impressionEvent.Context;
 
             Decision decision = new Decision(impressionEvent.Experiment?.LayerId,
-                impressionEvent.Experiment?.Id ??"",
+                impressionEvent.Experiment?.Id ?? string.Empty,
                 impressionEvent.Variation?.Id,
                 impressionEvent.Metadata);
 

From 0b669eb5646381786566a9e1d32783b21095d173 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Mon, 29 Nov 2021 09:05:23 -0500
Subject: [PATCH 118/130] Updated to handle null

---
 OptimizelySDK/Event/UserEventFactory.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/OptimizelySDK/Event/UserEventFactory.cs b/OptimizelySDK/Event/UserEventFactory.cs
index 23dff1fa..b56abbbd 100644
--- a/OptimizelySDK/Event/UserEventFactory.cs
+++ b/OptimizelySDK/Event/UserEventFactory.cs
@@ -84,7 +84,7 @@ public static ImpressionEvent CreateImpressionEvent(ProjectConfig projectConfig,
             if (variation != null)
             {
                 variationKey = variation.Key;
-                ruleKey = activatedExperiment != null ? activatedExperiment.Key : "";
+                ruleKey = activatedExperiment?.Key ?? string.Empty;
             }
             var metadata = new DecisionMetadata(flagKey, ruleKey, ruleType, variationKey, enabled);
 

From 6478ed6d7f1aa0cdc6ffef396a97a578e78cad9e Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Mon, 29 Nov 2021 09:05:56 -0500
Subject: [PATCH 119/130] copyright fix

---
 OptimizelySDK/OptimizelyDecisionContext.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/OptimizelySDK/OptimizelyDecisionContext.cs b/OptimizelySDK/OptimizelyDecisionContext.cs
index 5ffa992e..fafec889 100644
--- a/OptimizelySDK/OptimizelyDecisionContext.cs
+++ b/OptimizelySDK/OptimizelyDecisionContext.cs
@@ -1,5 +1,5 @@
 /*
- * Copyright 2020-2021, Optimizely
+ * Copyright 2021, Optimizely
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

From d359a0f8a018945a171437236feeda185eb260ac Mon Sep 17 00:00:00 2001
From: mnoman09 <Muhammadnoman@folio3.com>
Date: Fri, 3 Dec 2021 04:14:41 +0500
Subject: [PATCH 120/130] Refact: Refactored Forced decision (#287)

* Refactored and resolved comments given on PR

* some suggested code.

* unit test fixes.

* typo fix

* Removed getVariationFromExperiment as it was extra loop fixed some bugs and other minor issue due to which tests were failing

* Added forcedDecisionStore class

* more refactoring.

* refactored Code

* refactored and removed commented code

* Added forcedDecisionStoreTests

* conditional copy.

* Fixed soure rollout issue

* comment fixed.

Co-authored-by: Sohail Hussain <mirza.sohailhussain@gmail.com>
---
 .../OptimizelySDK.Net35.csproj                |   3 +
 .../OptimizelySDK.Net40.csproj                |   3 +
 .../OptimizelySDK.NetStandard16.csproj        |   1 +
 .../OptimizelySDK.NetStandard20.csproj        |   3 +
 ...cs => FallbackProjectConfigManagerTest.cs} |   0
 OptimizelySDK.Tests/DecisionServiceTest.cs    |  29 ++-
 .../ForcedDecisionsStoreTest.cs               | 123 ++++++++++
 .../OptimizelySDK.Tests.csproj                |   3 +-
 OptimizelySDK.Tests/OptimizelyTest.cs         |  22 +-
 .../OptimizelyUserContextTest.cs              |  15 +-
 OptimizelySDK.Tests/ProjectConfigTest.cs      |  69 +++---
 OptimizelySDK/Bucketing/DecisionService.cs    | 215 +++++++-----------
 OptimizelySDK/Config/DatafileProjectConfig.cs |  94 +++-----
 OptimizelySDK/Entity/Result.cs                |   5 -
 OptimizelySDK/Event/Builder/EventBuilder.cs   |   2 +-
 OptimizelySDK/ForcedDecisionsStore.cs         |  94 ++++++++
 OptimizelySDK/Optimizely.cs                   |  27 +--
 OptimizelySDK/OptimizelyDecisionContext.cs    |  18 +-
 OptimizelySDK/OptimizelySDK.csproj            |   1 +
 OptimizelySDK/OptimizelyUserContext.cs        |  76 ++++---
 OptimizelySDK/ProjectConfig.cs                |   4 +-
 21 files changed, 471 insertions(+), 336 deletions(-)
 rename OptimizelySDK.Tests/ConfigTest/{AtomicProjectConfigManagerTest.cs => FallbackProjectConfigManagerTest.cs} (100%)
 create mode 100644 OptimizelySDK.Tests/ForcedDecisionsStoreTest.cs
 create mode 100644 OptimizelySDK/ForcedDecisionsStore.cs

diff --git a/OptimizelySDK.Net35/OptimizelySDK.Net35.csproj b/OptimizelySDK.Net35/OptimizelySDK.Net35.csproj
index af6251e9..9d3d441d 100644
--- a/OptimizelySDK.Net35/OptimizelySDK.Net35.csproj
+++ b/OptimizelySDK.Net35/OptimizelySDK.Net35.csproj
@@ -322,6 +322,9 @@
     </Compile>
 	<Compile Include="..\OptimizelySDK\OptimizelyDecisionContext.cs">
       <Link>OptimizelyDecisionContext.cs</Link>
+    </Compile>
+	<Compile Include="..\OptimizelySDK\ForcedDecisionsStore.cs">
+      <Link>ForcedDecisionsStore.cs</Link>
     </Compile>
 	<Compile Include="..\OptimizelySDK\OptimizelyForcedDecision.cs">
       <Link>OptimizelyForcedDecision.cs</Link>
diff --git a/OptimizelySDK.Net40/OptimizelySDK.Net40.csproj b/OptimizelySDK.Net40/OptimizelySDK.Net40.csproj
index 67c0d250..3dfdfbc9 100644
--- a/OptimizelySDK.Net40/OptimizelySDK.Net40.csproj
+++ b/OptimizelySDK.Net40/OptimizelySDK.Net40.csproj
@@ -345,6 +345,9 @@
     </Compile>
 	<Compile Include="..\OptimizelySDK\OptimizelyDecisionContext.cs">
       <Link>OptimizelyDecisionContext.cs</Link>
+    </Compile>
+	<Compile Include="..\OptimizelySDK\ForcedDecisionsStore.cs">
+      <Link>ForcedDecisionsStore.cs</Link>
     </Compile>
 	<Compile Include="..\OptimizelySDK\OptimizelyForcedDecision.cs">
       <Link>OptimizelyForcedDecision.cs</Link>
diff --git a/OptimizelySDK.NetStandard16/OptimizelySDK.NetStandard16.csproj b/OptimizelySDK.NetStandard16/OptimizelySDK.NetStandard16.csproj
index d2ca8243..740e5d4d 100644
--- a/OptimizelySDK.NetStandard16/OptimizelySDK.NetStandard16.csproj
+++ b/OptimizelySDK.NetStandard16/OptimizelySDK.NetStandard16.csproj
@@ -96,6 +96,7 @@
 			<Compile Include="..\OptimizelySDK\OptimizelyUserContext.cs" />
 			<Compile Include="..\OptimizelySDK\Config\FallbackProjectConfigManager.cs" />
 			<Compile Include="..\OptimizelySDK\OptimizelyDecisionContext.cs" />
+			<Compile Include="..\OptimizelySDK\ForcedDecisionsStore.cs" />
 			<Compile Include="..\OptimizelySDK\OptimizelyForcedDecision.cs">
 				<Link>OptimizelyForcedDecision.cs</Link>
 			</Compile>
diff --git a/OptimizelySDK.NetStandard20/OptimizelySDK.NetStandard20.csproj b/OptimizelySDK.NetStandard20/OptimizelySDK.NetStandard20.csproj
index bbf3bb1c..0202fe84 100644
--- a/OptimizelySDK.NetStandard20/OptimizelySDK.NetStandard20.csproj
+++ b/OptimizelySDK.NetStandard20/OptimizelySDK.NetStandard20.csproj
@@ -307,6 +307,9 @@
 	<Compile Include="..\OptimizelySDK\OptimizelyDecisionContext.cs">
 		<Link>OptimizelyDecisionContext.cs</Link>
 	</Compile>
+	<Compile Include="..\OptimizelySDK\ForcedDecisionsStore.cs">
+		<Link>ForcedDecisionsStore.cs</Link>
+	</Compile>
 	<Compile Include="..\OptimizelySDK\OptimizelyForcedDecision.cs">
 	  <Link>OptimizelyForcedDecision.cs</Link>
 	</Compile>
diff --git a/OptimizelySDK.Tests/ConfigTest/AtomicProjectConfigManagerTest.cs b/OptimizelySDK.Tests/ConfigTest/FallbackProjectConfigManagerTest.cs
similarity index 100%
rename from OptimizelySDK.Tests/ConfigTest/AtomicProjectConfigManagerTest.cs
rename to OptimizelySDK.Tests/ConfigTest/FallbackProjectConfigManagerTest.cs
diff --git a/OptimizelySDK.Tests/DecisionServiceTest.cs b/OptimizelySDK.Tests/DecisionServiceTest.cs
index fd2521dc..f746ac3f 100644
--- a/OptimizelySDK.Tests/DecisionServiceTest.cs
+++ b/OptimizelySDK.Tests/DecisionServiceTest.cs
@@ -82,10 +82,10 @@ public void TestGetVariationForcedVariationPrecedesAudienceEval()
             OptimizelyUserContextMock = new Mock<OptimizelyUserContext>(optlyObject, WhitelistedUserId, new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object);
             OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns(GenericUserId);
             // user excluded without audiences and whitelisting
-            Assert.IsNull(decisionService.GetVariation(experiment, OptimizelyUserContextMock.Object, ProjectConfig, new UserAttributes()).ResultObject);
+            Assert.IsNull(decisionService.GetVariation(experiment, OptimizelyUserContextMock.Object, ProjectConfig).ResultObject);
 
             OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns(WhitelistedUserId);
-            var actualVariation = decisionService.GetVariation(experiment, OptimizelyUserContextMock.Object, ProjectConfig, new UserAttributes());
+            var actualVariation = decisionService.GetVariation(experiment, OptimizelyUserContextMock.Object, ProjectConfig);
 
             LoggerMock.Verify(l => l.Log(LogLevel.INFO, string.Format("User \"{0}\" is forced in variation \"vtag5\".", WhitelistedUserId)), Times.Once);
 
@@ -110,7 +110,7 @@ public void TestGetVariationLogsErrorWhenUserProfileMapItsNull()
             var options = new OptimizelyDecideOption[] { OptimizelyDecideOption.INCLUDE_REASONS };
             OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns(GenericUserId);
 
-            var variationResult = decisionService.GetVariation(experiment, OptimizelyUserContextMock.Object, ProjectConfig, new UserAttributes(), options);
+            var variationResult = decisionService.GetVariation(experiment, OptimizelyUserContextMock.Object, ProjectConfig, options);
             Assert.AreEqual(variationResult.DecisionReasons.ToReport(true)[0], "We were unable to get a user profile map from the UserProfileService.");
             Assert.AreEqual(variationResult.DecisionReasons.ToReport(true)[1], "Audiences for experiment \"etag3\" collectively evaluated to FALSE");
             Assert.AreEqual(variationResult.DecisionReasons.ToReport(true)[2], "User \"genericUserId\" does not meet conditions to be in experiment \"etag3\".");
@@ -136,7 +136,7 @@ public void TestGetVariationEvaluatesUserProfileBeforeAudienceTargeting()
 
             DecisionService decisionService = new DecisionService(BucketerMock.Object, ErrorHandlerMock.Object, UserProfileServiceMock.Object, LoggerMock.Object);
 
-            decisionService.GetVariation(experiment, OptimizelyUserContextMock.Object, ProjectConfig, new UserAttributes());
+            decisionService.GetVariation(experiment, OptimizelyUserContextMock.Object, ProjectConfig);
 
             LoggerMock.Verify(l => l.Log(LogLevel.INFO, string.Format("User \"{0}\" does not meet conditions to be in experiment \"{1}\".",
                 GenericUserId, experiment.Key)), Times.Once);
@@ -144,7 +144,7 @@ public void TestGetVariationEvaluatesUserProfileBeforeAudienceTargeting()
             OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns(UserProfileId);
 
             // ensure that a user with a saved user profile, sees the same variation regardless of audience evaluation
-            decisionService.GetVariation(experiment, OptimizelyUserContextMock.Object, ProjectConfig, new UserAttributes());
+            decisionService.GetVariation(experiment, OptimizelyUserContextMock.Object, ProjectConfig);
 
             BucketerMock.Verify(_ => _.Bucket(It.IsAny<ProjectConfig>(), It.IsAny<Experiment>(), It.IsAny<string>(), It.IsAny<string>()), Times.Never);
         }
@@ -234,7 +234,7 @@ public void TestBucketReturnsVariationStoredInUserProfile()
             OptimizelyUserContextMock = new Mock<OptimizelyUserContext>(optlyObject, WhitelistedUserId, new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object);
             OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns(UserProfileId);
 
-            var actualVariation = decisionService.GetVariation(experiment, OptimizelyUserContextMock.Object, ProjectConfig, new UserAttributes());
+            var actualVariation = decisionService.GetVariation(experiment, OptimizelyUserContextMock.Object, ProjectConfig);
 
             Assertions.AreEqual(variation, actualVariation.ResultObject);
 
@@ -316,7 +316,7 @@ public void TestGetVariationSavesBucketedVariationIntoUserProfile()
 
             OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns(UserProfileId);
 
-            Assert.IsTrue(TestData.CompareObjects(variation.ResultObject, decisionService.GetVariation(experiment, OptimizelyUserContextMock.Object, ProjectConfig, new UserAttributes()).ResultObject));
+            Assert.IsTrue(TestData.CompareObjects(variation.ResultObject, decisionService.GetVariation(experiment, OptimizelyUserContextMock.Object, ProjectConfig).ResultObject));
 
             LoggerMock.Verify(l => l.Log(LogLevel.INFO, string.Format("Saved variation \"{0}\" of experiment \"{1}\" for user \"{2}\".", variation.ResultObject.Id,
                         experiment.Id, UserProfileId)), Times.Once);
@@ -374,7 +374,7 @@ public void TestGetVariationSavesANewUserProfile()
                 UserProfileServiceMock.Object, LoggerMock.Object);
             OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns(UserProfileId);
 
-            var actualVariation = decisionService.GetVariation(experiment, OptimizelyUserContextMock.Object, ProjectConfig, new UserAttributes());
+            var actualVariation = decisionService.GetVariation(experiment, OptimizelyUserContextMock.Object, ProjectConfig);
 
             Assertions.AreEqual(variation.ResultObject, actualVariation.ResultObject);
 
@@ -578,12 +578,12 @@ public void TestGetVariationForFeatureExperimentGivenNonMutexGroupAndUserIsBucke
 
             var optlyObject = new Optimizely(TestData.Datafile, new ValidEventDispatcher(), LoggerMock.Object);
 
-            OptimizelyUserContextMock = new Mock<OptimizelyUserContext>(optlyObject, WhitelistedUserId, new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object);
+            OptimizelyUserContextMock = new Mock<OptimizelyUserContext>(optlyObject, WhitelistedUserId, userAttributes, ErrorHandlerMock.Object, LoggerMock.Object);
 
             OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns("user1");
 
             DecisionServiceMock.Setup(ds => ds.GetVariation(ProjectConfig.GetExperimentFromKey("test_experiment_multivariate"),
-                OptimizelyUserContextMock.Object, ProjectConfig, userAttributes, It.IsAny<OptimizelyDecideOption[]>())).Returns(variation);
+                OptimizelyUserContextMock.Object, ProjectConfig, It.IsAny<OptimizelyDecideOption[]>())).Returns(variation);
 
             var featureFlag = ProjectConfig.GetFeatureFlagFromKey("multi_variate_feature");
             var decision = DecisionServiceMock.Object.GetVariationForFeatureExperiment(featureFlag, OptimizelyUserContextMock.Object, userAttributes, ProjectConfig, new OptimizelyDecideOption[] { });
@@ -604,11 +604,10 @@ public void TestGetVariationForFeatureExperimentGivenMutexGroupAndUserIsBucketed
 
             var optlyObject = new Optimizely(TestData.Datafile, new ValidEventDispatcher(), LoggerMock.Object);
 
-            OptimizelyUserContextMock = new Mock<OptimizelyUserContext>(optlyObject, WhitelistedUserId, new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object);
+            OptimizelyUserContextMock = new Mock<OptimizelyUserContext>(optlyObject, WhitelistedUserId, userAttributes, ErrorHandlerMock.Object, LoggerMock.Object);
             OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns("user1");
 
-            DecisionServiceMock.Setup(ds => ds.GetVariation(ProjectConfig.GetExperimentFromKey("group_experiment_1"), OptimizelyUserContextMock.Object, ProjectConfig,
-                userAttributes)).Returns(variation);
+            DecisionServiceMock.Setup(ds => ds.GetVariation(ProjectConfig.GetExperimentFromKey("group_experiment_1"), OptimizelyUserContextMock.Object, ProjectConfig)).Returns(variation);
 
             var featureFlag = ProjectConfig.GetFeatureFlagFromKey("boolean_feature");
             var actualDecision = DecisionServiceMock.Object.GetVariationForFeatureExperiment(featureFlag, OptimizelyUserContextMock.Object, userAttributes, ProjectConfig, new OptimizelyDecideOption[] { });
@@ -625,7 +624,7 @@ public void TestGetVariationForFeatureExperimentGivenMutexGroupAndUserNotBuckete
             var mutexExperiment = ProjectConfig.GetExperimentFromKey("group_experiment_1");
             OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns("user1");
 
-            DecisionServiceMock.Setup(ds => ds.GetVariation(It.IsAny<Experiment>(), It.IsAny<OptimizelyUserContext>(), ProjectConfig, It.IsAny<UserAttributes>(), It.IsAny<OptimizelyDecideOption[]>()))
+            DecisionServiceMock.Setup(ds => ds.GetVariation(It.IsAny<Experiment>(), It.IsAny<OptimizelyUserContext>(), ProjectConfig, It.IsAny<OptimizelyDecideOption[]>()))
                 .Returns(Result<Variation>.NullResult(null));
 
             var featureFlag = ProjectConfig.GetFeatureFlagFromKey("boolean_feature");
@@ -975,7 +974,7 @@ public void TestGetVariationForFeatureWhenTheUserIsBuckedtedInBothExperimentAndR
             OptimizelyUserContextMock = new Mock<OptimizelyUserContext>(optlyObject, WhitelistedUserId, userAttributes, ErrorHandlerMock.Object, LoggerMock.Object);
             OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns(UserProfileId);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, OptimizelyUserContextMock.Object, ProjectConfig, userAttributes, It.IsAny<OptimizelyDecideOption[]>())).Returns(variation);
+            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, OptimizelyUserContextMock.Object, ProjectConfig, It.IsAny<OptimizelyDecideOption[]>())).Returns(variation);
             var actualDecision = DecisionServiceMock.Object.GetVariationForFeatureExperiment(featureFlag, OptimizelyUserContextMock.Object, userAttributes, ProjectConfig, new OptimizelyDecideOption[] { });
 
             // The user is bucketed into feature experiment's variation.
diff --git a/OptimizelySDK.Tests/ForcedDecisionsStoreTest.cs b/OptimizelySDK.Tests/ForcedDecisionsStoreTest.cs
new file mode 100644
index 00000000..6cf2dfc8
--- /dev/null
+++ b/OptimizelySDK.Tests/ForcedDecisionsStoreTest.cs
@@ -0,0 +1,123 @@
+/**
+ *
+ *    Copyright 2021, Optimizely and contributors
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+using NUnit.Framework;
+
+namespace OptimizelySDK.Tests
+{
+    [TestFixture]
+    public class ForcedDecisionsStoreTest
+    {
+        [Test]
+        public void ForcedDecisionStoreGetSetForcedDecisionWithBothRuleAndFlagKey()
+        {
+            var expectedForcedDecision1 = new OptimizelyForcedDecision("sample_variation_key");
+            var expectedForcedDecision2 = new OptimizelyForcedDecision("sample_variation_key_2");
+            var context1 = new OptimizelyDecisionContext("flag_key", "rule_key");
+            var context2 = new OptimizelyDecisionContext("flag_key", "rule_key1");
+            var forcedDecisionStore = new ForcedDecisionsStore();
+            forcedDecisionStore[context1] = expectedForcedDecision1;
+            forcedDecisionStore[context2] = expectedForcedDecision2;
+
+            Assert.AreEqual(forcedDecisionStore.Count, 2);
+            Assert.AreEqual(forcedDecisionStore[context1].VariationKey, expectedForcedDecision1.VariationKey);
+            Assert.AreEqual(forcedDecisionStore[context2].VariationKey, expectedForcedDecision2.VariationKey);
+        }
+
+        [Test]
+        public void ForcedDecisionStoreNullFlagKeyForcedDecisionContext()
+        {
+            var expectedForcedDecision = new OptimizelyForcedDecision("sample_variation_key");
+            var context = new OptimizelyDecisionContext(null, "rule_key");
+            var forcedDecisionStore = new ForcedDecisionsStore();
+            forcedDecisionStore[context] = expectedForcedDecision;
+
+            Assert.AreEqual(forcedDecisionStore.Count, 0);
+        }
+
+        [Test]
+        public void ForcedDecisionStoreNullContextForcedDecisionContext()
+        {
+            var expectedForcedDecision = new OptimizelyForcedDecision("sample_variation_key");
+            OptimizelyDecisionContext context = null;
+            var forcedDecisionStore = new ForcedDecisionsStore();
+            forcedDecisionStore[context] = expectedForcedDecision;
+
+            Assert.AreEqual(forcedDecisionStore.Count, 0);
+        }
+
+        [Test]
+        public void ForcedDecisionStoreGetForcedDecisionWithBothRuleAndFlagKey()
+        {
+            var expectedForcedDecision1 = new OptimizelyForcedDecision("sample_variation_key");
+            var context1 = new OptimizelyDecisionContext("flag_key", "rule_key");
+            var NullFlagKeyContext = new OptimizelyDecisionContext(null, "rule_key");
+            var forcedDecisionStore = new ForcedDecisionsStore();
+            forcedDecisionStore[context1] = expectedForcedDecision1;
+
+            Assert.AreEqual(forcedDecisionStore.Count, 1);
+            Assert.AreEqual(forcedDecisionStore[context1].VariationKey, expectedForcedDecision1.VariationKey);
+            Assert.IsNull(forcedDecisionStore[NullFlagKeyContext]);
+        }
+
+        [Test]
+        public void ForcedDecisionStoreRemoveForcedDecisionTrue()
+        {
+            var expectedForcedDecision1 = new OptimizelyForcedDecision("sample_variation_key");
+            var expectedForcedDecision2 = new OptimizelyForcedDecision("sample_variation_key_2");
+            var context1 = new OptimizelyDecisionContext("flag_key", "rule_key");
+            var context2 = new OptimizelyDecisionContext("flag_key", "rule_key1");
+            var forcedDecisionStore = new ForcedDecisionsStore();
+            forcedDecisionStore[context1] = expectedForcedDecision1;
+            forcedDecisionStore[context2] = expectedForcedDecision2;
+
+            Assert.AreEqual(forcedDecisionStore.Count, 2);
+            Assert.IsTrue(forcedDecisionStore.Remove(context2));
+            Assert.AreEqual(forcedDecisionStore.Count, 1);
+            Assert.AreEqual(forcedDecisionStore[context1].VariationKey, expectedForcedDecision1.VariationKey);
+            Assert.IsNull(forcedDecisionStore[context2]);
+        }
+
+        [Test]
+        public void ForcedDecisionStoreRemoveForcedDecisionContextRuleKeyNotMatched()
+        {
+            var expectedForcedDecision = new OptimizelyForcedDecision("sample_variation_key");
+            var contextNotMatched = new OptimizelyDecisionContext("flag_key", "");
+            var context = new OptimizelyDecisionContext("flag_key", "rule_key");
+            var forcedDecisionStore = new ForcedDecisionsStore();
+            forcedDecisionStore[context] = expectedForcedDecision;
+
+            Assert.AreEqual(forcedDecisionStore.Count, 1);
+            Assert.IsFalse(forcedDecisionStore.Remove(contextNotMatched));
+            Assert.AreEqual(forcedDecisionStore.Count, 1);
+        }
+
+        [Test]
+        public void ForcedDecisionStoreRemoveAllForcedDecisionContext()
+        {
+            var expectedForcedDecision = new OptimizelyForcedDecision("sample_variation_key");
+            var context = new OptimizelyDecisionContext("flag_key", "rule_key");
+            var forcedDecisionStore = new ForcedDecisionsStore();
+            forcedDecisionStore[context] = expectedForcedDecision;
+
+            Assert.AreEqual(forcedDecisionStore.Count, 1);
+            forcedDecisionStore.RemoveAll();
+            Assert.AreEqual(forcedDecisionStore.Count, 0);
+        }
+
+    }
+}
diff --git a/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj b/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj
index 231e256b..2a776bcb 100644
--- a/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj
+++ b/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj
@@ -75,7 +75,7 @@
     <Compile Include="AudienceConditionsTests\ConditionsTest.cs" />
     <Compile Include="ConfigTest\HttpProjectConfigManagerTest.cs" />
     <Compile Include="ConfigTest\PollingProjectConfigManagerTest.cs" />
-    <Compile Include="ConfigTest\AtomicProjectConfigManagerTest.cs" />
+    <Compile Include="ConfigTest\FallbackProjectConfigManagerTest.cs" />
     <Compile Include="DecisionServiceTest.cs" />
     <Compile Include="DefaultErrorHandlerTest.cs" />
     <Compile Include="EventTests\EventProcessorProps.cs" />
@@ -93,6 +93,7 @@
     <Compile Include="NotificationTests\NotificationCenterTests.cs" />
     <Compile Include="ClientConfigHandlerTest.cs" />
     <Compile Include="OptimizelyTest.cs" />
+    <Compile Include="ForcedDecisionsStoreTest.cs" />
     <Compile Include="OptimizelyUserContextTest.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="TestBucketer.cs" />
diff --git a/OptimizelySDK.Tests/OptimizelyTest.cs b/OptimizelySDK.Tests/OptimizelyTest.cs
index 3e9f0483..05e50bc9 100644
--- a/OptimizelySDK.Tests/OptimizelyTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyTest.cs
@@ -2438,7 +2438,7 @@ public void TestActivateListener(UserAttributes userAttributes)
             Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>(OptimizelyMock.Object, TestUserId, userAttributes, ErrorHandlerMock.Object, LoggerMock.Object);
             mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, It.IsAny<OptimizelyUserContext>(), It.IsAny<ProjectConfig>(), userAttributes)).Returns(variation);
+            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, It.IsAny<OptimizelyUserContext>(), It.IsAny<ProjectConfig>())).Returns(variation);
             DecisionServiceMock.Setup(ds => ds.GetVariationForFeature(featureFlag, It.IsAny<OptimizelyUserContext>(), It.IsAny<ProjectConfig>())).Returns(decision);
 
             var optly = Helper.CreatePrivateOptimizely();
@@ -2452,8 +2452,8 @@ public void TestActivateListener(UserAttributes userAttributes)
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
 
             // Calling Activate and IsFeatureEnabled.
-            optly.Invoke("Activate", experimentKey, TestUserId, userAttributes);
-            optly.Invoke("IsFeatureEnabled", featureKey, TestUserId, userAttributes);
+            optStronglyTyped.Activate(experimentKey, TestUserId, userAttributes);
+            optStronglyTyped.IsFeatureEnabled(featureKey, TestUserId, userAttributes);
 
             // Verify that all the registered callbacks are called once for both Activate and IsFeatureEnabled.
             EventDispatcherMock.Verify(dispatcher => dispatcher.DispatchEvent(It.IsAny<LogEvent>()), Times.Exactly(2));
@@ -2521,7 +2521,7 @@ public void TestTrackListener(UserAttributes userAttributes, EventTags eventTags
             Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>(Optimizely, TestUserId, new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object);
             mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(variation);
+            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, It.IsAny<OptimizelyUserContext>(), Config)).Returns(variation);
 
             // Adding notification listeners.
             var notificationType = NotificationCenter.NotificationType.Track;
@@ -2559,7 +2559,7 @@ public void TestActivateSendsDecisionNotificationWithActualVariationKey()
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), It.IsAny<Dictionary<string, object>>()));
 
-            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(variation);
+            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, It.IsAny<OptimizelyUserContext>(), Config)).Returns(variation);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("ProjectConfigManager", ConfigManager);
@@ -2596,7 +2596,7 @@ public void TestActivateSendsDecisionNotificationWithVariationKeyAndTypeFeatureT
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), It.IsAny<Dictionary<string, object>>()));
 
-            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(variation);
+            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, It.IsAny<OptimizelyUserContext>(), Config)).Returns(variation);
 
             var optly = Helper.CreatePrivateOptimizely();
             optly.SetFieldOrProperty("ProjectConfigManager", ConfigManager);
@@ -2668,7 +2668,7 @@ public void TestGetVariationSendsDecisionNotificationWithActualVariationKey()
             Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>(optStronglyTyped, TestUserId, new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object);
             mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(variation);
+            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, It.IsAny<OptimizelyUserContext>(), Config)).Returns(variation);
 
             optStronglyTyped.NotificationCenter.AddNotification(NotificationCenter.NotificationType.Decision, NotificationCallbackMock.Object.TestDecisionCallback);
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
@@ -2707,7 +2707,7 @@ public void TestGetVariationSendsDecisionNotificationWithVariationKeyAndTypeFeat
             Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>(optStronglyTyped, TestUserId, new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object);
             mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
 
-            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, It.IsAny<OptimizelyUserContext>(), Config, userAttributes)).Returns(variation);
+            DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, It.IsAny<OptimizelyUserContext>(), Config)).Returns(variation);
 
             optStronglyTyped.NotificationCenter.AddNotification(NotificationCenter.NotificationType.Decision, NotificationCallbackMock.Object.TestDecisionCallback);
             optly.SetFieldOrProperty("DecisionService", DecisionServiceMock.Object);
@@ -2735,11 +2735,7 @@ public void TestGetVariationSendsDecisionNotificationWithNullVariationKey()
             NotificationCallbackMock.Setup(nc => nc.TestDecisionCallback(It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), It.IsAny<Dictionary<string, object>>()));
 
-            Mock<OptimizelyUserContext> mockUserContext = new Mock<OptimizelyUserContext>(optStronglyTyped, TestUserId, new UserAttributes(), ErrorHandlerMock.Object, LoggerMock.Object);
-
-            mockUserContext.Setup(ouc => ouc.GetUserId()).Returns(TestUserId);
-
-            DecisionServiceMock.Setup(ds => ds.GetVariation(It.IsAny<Experiment>(), It.IsAny<OptimizelyUserContext>(), It.IsAny<ProjectConfig>(), It.IsAny<UserAttributes>())).Returns(Result<Variation>.NullResult(null));
+            DecisionServiceMock.Setup(ds => ds.GetVariation(It.IsAny<Experiment>(), It.IsAny<OptimizelyUserContext>(), It.IsAny<ProjectConfig>())).Returns(Result<Variation>.NullResult(null));
             //DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, TestUserId, Config, null)).Returns(Result<Variation>.NullResult(null));
 
             optStronglyTyped.NotificationCenter.AddNotification(NotificationCenter.NotificationType.Decision, NotificationCallbackMock.Object.TestDecisionCallback);
diff --git a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
index 0c694eda..d5ab832a 100644
--- a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
@@ -186,16 +186,17 @@ public void TestDecide()
         }
 
         [Test]
-        public void TestForcedDecisionReturnsCorrectGetDecisionKey()
+        public void TestForcedDecisionReturnsCorrectFlagAndRuleKeys()
         {
             var user = Optimizely.CreateUserContext(UserID);
             var context = new OptimizelyDecisionContext("flag", null);
-
-            Assert.AreEqual("flag-$opt$-$opt-null-rule-key", context.DecisionKey);
+            Assert.AreEqual("flag", context.FlagKey);
+            Assert.Null(context.RuleKey);
 
             context = new OptimizelyDecisionContext("flag", "ruleKey");
 
-            Assert.AreEqual("flag-$opt$-ruleKey", context.DecisionKey);
+            Assert.AreEqual("flag", context.FlagKey);
+            Assert.AreEqual("ruleKey", context.RuleKey);
         }
 
         [Test]
@@ -226,7 +227,7 @@ public void TestGetForcedDecisionReturnsNullIfInvalidConfig()
         [Test]
         public void TestSetForcedDecisionReturnsFalseForNullConfig()
         {
-            var optly = new Optimizely(new FallbackProjectConfigManager(null));
+            var optly = new Optimizely(new FallbackProjectConfigManager(null), logger: LoggerMock.Object);
 
             var user = optly.CreateUserContext(UserID);
 
@@ -235,7 +236,7 @@ public void TestSetForcedDecisionReturnsFalseForNullConfig()
             var result = user.SetForcedDecision(context, decision);
 
             Assert.IsFalse(result);
-            //TODO: should assert logger is called
+            LoggerMock.Verify(log => log.Log(LogLevel.ERROR, "Optimizely SDK not configured properly yet."), Times.Once);
         }
 
         [Test]
@@ -310,7 +311,7 @@ public void TestFindValidatedForcedDecisionReturnsCorrectDecisionWithNullVariati
 
             var context = new OptimizelyDecisionContext("flagKey", "ruleKey");
 
-            var result = user.FindValidatedForcedDecision(context);
+            var result = user.FindValidatedForcedDecision(context, null);
 
             Assertions.AreEqual(expectedResult, result);
         }
diff --git a/OptimizelySDK.Tests/ProjectConfigTest.cs b/OptimizelySDK.Tests/ProjectConfigTest.cs
index 455bbc55..03faf85d 100644
--- a/OptimizelySDK.Tests/ProjectConfigTest.cs
+++ b/OptimizelySDK.Tests/ProjectConfigTest.cs
@@ -427,44 +427,43 @@ public void TestFlagVariations()
         {
             var allVariations = Config?.FlagVariationMap;
 
-            var expectedVariations1 = new List<Dictionary<string, List<Variation>>>();
-            var expectedVariationList = new List<Variation>
+            var expectedVariationDict = new Dictionary<string, Variation>
             {
-                new Variation
-                {
-                    FeatureEnabled = true,
-                    Id = "7722260071",
-                    Key = "group_exp_1_var_1",
-                    FeatureVariableUsageInstances = new List<FeatureVariableUsage> { new FeatureVariableUsage { Id = "155563", Value= "groupie_1_v1" } }
-                },
-                new Variation
-                {
-                    FeatureEnabled = true,
-                    Id = "7722360022",
-                    Key = "group_exp_1_var_2",
-                    FeatureVariableUsageInstances = new List<FeatureVariableUsage> { new FeatureVariableUsage { Id = "155563", Value= "groupie_1_v2" } }
-                },
-                new Variation
-                {
-                    FeatureEnabled = false,
-                    Id = "7713030086",
-                    Key = "group_exp_2_var_1",
-                    FeatureVariableUsageInstances = new List<FeatureVariableUsage> { new FeatureVariableUsage { Id = "155563", Value= "groupie_2_v1" } }
-                },
-                new Variation
-                {
-                    FeatureEnabled = false,
-                    Id = "7725250007",
-                    Key = "group_exp_2_var_2",
-                    FeatureVariableUsageInstances = new List<FeatureVariableUsage> { new FeatureVariableUsage { Id = "155563", Value= "groupie_2_v2" } }
+                { "group_exp_1_var_1",  new Variation
+                    {
+                        FeatureEnabled = true,
+                        Id = "7722260071",
+                        Key = "group_exp_1_var_1",
+                        FeatureVariableUsageInstances = new List<FeatureVariableUsage> { new FeatureVariableUsage { Id = "155563", Value= "groupie_1_v1" } }
+                    }
+                },
+                { "group_exp_1_var_2",  new Variation
+                    {
+                        FeatureEnabled = true,
+                        Id = "7722360022",
+                        Key = "group_exp_1_var_2",
+                        FeatureVariableUsageInstances = new List<FeatureVariableUsage> { new FeatureVariableUsage { Id = "155563", Value= "groupie_1_v2" } }
+                    }
+                },
+                { "group_exp_2_var_1",  new Variation
+                    {
+                        FeatureEnabled = false,
+                        Id = "7713030086",
+                        Key = "group_exp_2_var_1",
+                        FeatureVariableUsageInstances = new List<FeatureVariableUsage> { new FeatureVariableUsage { Id = "155563", Value= "groupie_2_v1" } }
+                    }
+                },
+                { "group_exp_2_var_2",  new Variation
+                    {
+                        FeatureEnabled = false,
+                        Id = "7725250007",
+                        Key = "group_exp_2_var_2",
+                        FeatureVariableUsageInstances = new List<FeatureVariableUsage> { new FeatureVariableUsage { Id = "155563", Value= "groupie_2_v2" } }
+                    }
                 }
             };
-            expectedVariations1.Add(new Dictionary<string, List<Variation>> { { "boolean_feature", expectedVariationList } });
-
-            var variations1 = allVariations.Where(v => v.Key == "boolean_feature").Select(v => new Dictionary<string, List<Variation>> { { v.Key, v.Value } }).ToList();
-
-            TestData.CompareObjects(expectedVariations1, variations1);
-            Assertions.AreEquivalent(expectedVariations1, variations1);
+            var filteredActualFlagVariations = allVariations["boolean_feature"];
+            TestData.CompareObjects(expectedVariationDict, filteredActualFlagVariations);
         }
 
         [Test]
diff --git a/OptimizelySDK/Bucketing/DecisionService.cs b/OptimizelySDK/Bucketing/DecisionService.cs
index feef3ab6..0796aa0b 100644
--- a/OptimizelySDK/Bucketing/DecisionService.cs
+++ b/OptimizelySDK/Bucketing/DecisionService.cs
@@ -81,28 +81,27 @@ public DecisionService(Bucketer bucketer, IErrorHandler errorHandler, UserProfil
         /// Get a Variation of an Experiment for a user to be allocated into.
         /// </summary>
         /// <param name = "experiment" > The Experiment the user will be bucketed into.</param>
-        /// <param name = "userId" > The userId of the user.
-        /// <param name = "filteredAttributes" > The user's attributes. This should be filtered to just attributes in the Datafile.</param>
+        /// <param name = "user" > Optimizely user context.
+        /// <param name = "config" > Project config.</param>
         /// <returns>The Variation the user is allocated into.</returns>
         public virtual Result<Variation> GetVariation(Experiment experiment,
             OptimizelyUserContext user,
-            ProjectConfig config,
-            UserAttributes filteredAttributes)
+            ProjectConfig config)
         {
-            return GetVariation(experiment, user, config, filteredAttributes, new OptimizelyDecideOption[] { });
+            return GetVariation(experiment, user, config, new OptimizelyDecideOption[] { });
         }
 
         /// <summary>
         /// Get a Variation of an Experiment for a user to be allocated into.
         /// </summary>
         /// <param name = "experiment" > The Experiment the user will be bucketed into.</param>
-        /// <param name = "userId" > The userId of the user.
-        /// <param name = "filteredAttributes" > The user's attributes. This should be filtered to just attributes in the Datafile.</param>
+        /// <param name = "user" > optimizely user context.
+        /// <param name = "config" > Project Config.</param>
+        /// <param name = "options" >An array of decision options.</param>
         /// <returns>The Variation the user is allocated into.</returns>
         public virtual Result<Variation> GetVariation(Experiment experiment,
             OptimizelyUserContext user,
             ProjectConfig config,
-            UserAttributes filteredAttributes,
             OptimizelyDecideOption[] options)
         {
             var reasons = new DecisionReasons();
@@ -159,6 +158,7 @@ public virtual Result<Variation> GetVariation(Experiment experiment,
                     ErrorHandler.HandleError(new Exceptions.OptimizelyRuntimeException(exception.Message));
                 }
             }
+            var filteredAttributes = user.GetAttributes();
             var doesUserMeetAudienceConditionsResult = ExperimentUtils.DoesUserMeetAudienceConditions(config, experiment, filteredAttributes, LOGGING_KEY_TYPE_EXPERIMENT, experiment.Key, Logger);
             reasons += doesUserMeetAudienceConditionsResult.DecisionReasons;
             if (doesUserMeetAudienceConditionsResult.ResultObject)
@@ -449,20 +449,68 @@ public virtual Result<FeatureDecision> GetVariationForFeatureRollout(FeatureFlag
                 return Result<FeatureDecision>.NullResult(reasons);
             }
 
+            var userId = user.GetUserId();
+            var attributes = user.GetAttributes();
+
             var index = 0;
             while (index < rolloutRulesLength)
             {
-                var decisionResult = GetVariationFromDeliveryRule(config, featureFlag.Key, rolloutRules, index, user);
-                reasons += decisionResult.DecisionReasons;
+                // To skip rules
+                var skipToEveryoneElse = false;
+
+                //Check forced decision first
+                var rule = rolloutRules[index];
+                var decisionContext = new OptimizelyDecisionContext(featureFlag.Key, rule.Key);
+                var forcedDecisionResponse = user.FindValidatedForcedDecision(decisionContext, config);
+
+                reasons += forcedDecisionResponse.DecisionReasons;
+                if (forcedDecisionResponse.ResultObject != null)
+                {
+                    return Result<FeatureDecision>.NewResult(new FeatureDecision(rule, forcedDecisionResponse.ResultObject, null), reasons);
+                }
+
+                // Regular decision
 
-                if (decisionResult.ResultObject?.Variation?.Key != null)
+                // Get Bucketing ID from user attributes.
+                var bucketingIdResult = GetBucketingId(userId, attributes);
+                reasons += bucketingIdResult.DecisionReasons;
+
+                var everyoneElse = index == rolloutRulesLength - 1;
+
+                var loggingKey = everyoneElse ? "Everyone Else" : string.Format("{0}", index + 1);
+
+                // Evaluate if user meets the audience condition of this rollout rule
+                var doesUserMeetAudienceConditionsResult = ExperimentUtils.DoesUserMeetAudienceConditions(config, rule, attributes, LOGGING_KEY_TYPE_RULE, rule.Key, Logger);
+                reasons += doesUserMeetAudienceConditionsResult.DecisionReasons;
+                if (doesUserMeetAudienceConditionsResult.ResultObject)
+                {
+                    Logger.Log(LogLevel.INFO, reasons.AddInfo($"User \"{userId}\" meets condition for targeting rule \"{loggingKey}\"."));
+
+                    var bucketedVariation = Bucketer.Bucket(config, rule, bucketingIdResult.ResultObject, userId);
+                    reasons += bucketedVariation?.DecisionReasons;
+
+                    if (bucketedVariation?.ResultObject?.Key != null)
+                    {
+                        Logger.Log(LogLevel.INFO, reasons.AddInfo($"User \"{userId}\" is in the traffic group of targeting rule \"{loggingKey}\"."));
+
+                        return Result<FeatureDecision>.NewResult(new FeatureDecision(rule, bucketedVariation.ResultObject, FeatureDecision.DECISION_SOURCE_ROLLOUT), reasons);
+                    }
+                    else if (!everyoneElse)
+                    {
+                        //skip this logging for everyoneElse rule since this has a message not for everyoneElse
+                        Logger.Log(LogLevel.INFO, reasons.AddInfo($"User \"{userId}\" is not in the traffic group for targeting rule \"{loggingKey}\". Checking EveryoneElse rule now."));
+                        skipToEveryoneElse = true;
+                    }
+                }
+                else
                 {
-                    return Result<FeatureDecision>.NewResult(new FeatureDecision(rolloutRules[index], decisionResult.ResultObject.Variation, FeatureDecision.DECISION_SOURCE_ROLLOUT), reasons);
+                    Logger.Log(LogLevel.DEBUG, reasons.AddInfo($"User \"{userId}\" does not meet the conditions for targeting rule \"{loggingKey}\"."));
                 }
 
                 // the last rule is special for "Everyone Else"
-                index = decisionResult.SkipToEveryoneElse ? (rolloutRulesLength - 1) : (index + 1);
+                index = skipToEveryoneElse ? (rolloutRulesLength - 1) : (index + 1);
             }
+
             return Result<FeatureDecision>.NullResult(reasons);
         }
 
@@ -498,138 +546,41 @@ public virtual Result<FeatureDecision> GetVariationForFeatureExperiment(FeatureF
             foreach (var experimentId in featureFlag.ExperimentIds)
             {
                 var experiment = config.GetExperimentFromId(experimentId);
+                Variation decisionVariation = null;
 
                 if (string.IsNullOrEmpty(experiment.Key))
                     continue;
-
-                var variationResult = GetVariationFromExperiment(config, featureFlag, experiment, user, options);
-                reasons += variationResult.DecisionReasons;
-
-                if (variationResult?.ResultObject?.Experiment != null && variationResult?.ResultObject?.Variation?.Id != null)
+                
+                var forcedDecisionResponse = user.FindValidatedForcedDecision(
+                    new OptimizelyDecisionContext(featureFlag.Key, experiment?.Key),
+                    config);
+                reasons += forcedDecisionResponse.DecisionReasons;
+                
+                if (forcedDecisionResponse?.ResultObject != null) 
                 {
-                    Logger.Log(LogLevel.INFO, reasons.AddInfo($"The user \"{userId}\" is bucketed into experiment \"{experiment.Key}\" of feature \"{featureFlag.Key}\"."));
-                    return Result<FeatureDecision>.NewResult(new FeatureDecision(experiment, variationResult.ResultObject.Variation, FeatureDecision.DECISION_SOURCE_FEATURE_TEST), reasons);
+                    decisionVariation = forcedDecisionResponse.ResultObject;
+                } 
+                else 
+                {
+                    var decisionResponse = GetVariation(experiment, user, config, options);
+                    
+                    reasons += decisionResponse?.DecisionReasons;
+                    decisionVariation = decisionResponse.ResultObject;
                 }
-            }
-
-            Logger.Log(LogLevel.INFO, reasons.AddInfo($"The user \"{userId}\" is not bucketed into any of the experiments on the feature \"{featureFlag.Key}\"."));
-            return Result<FeatureDecision>.NullResult(reasons);
-        }
-
-        
-
-        private Result<FeatureDecision> GetVariationFromExperiment(ProjectConfig config, FeatureFlag flag, Experiment experiment, OptimizelyUserContext user, OptimizelyDecideOption[] options)
-        {
-            var reasons = new DecisionReasons();
 
-            if (flag.ExperimentIds.Any())
-            {
-                foreach (var expId in flag.ExperimentIds)
+                if (!string.IsNullOrEmpty(decisionVariation?.Id))
                 {
-                    config.ExperimentIdMap.TryGetValue(expId, out var exp);
-
-                    var decisionVariation = GetVariationFromExperimentRule(config, flag.Key, experiment, user, options);
-                    reasons += decisionVariation?.DecisionReasons;
-
-                    var variation = decisionVariation?.ResultObject;
-
-                    if (variation != null)
-                    {
-                        var featureDecision = new FeatureDecision(exp, variation, FeatureDecision.DECISION_SOURCE_FEATURE_TEST);
+                    Logger.Log(LogLevel.INFO, reasons.AddInfo($"The user \"{userId}\" is bucketed into experiment \"{experiment.Key}\" of feature \"{featureFlag.Key}\"."));
 
-                        return Result<FeatureDecision>.NewResult(featureDecision, reasons);
-                    }
+                    var featureDecision = new FeatureDecision(experiment, decisionVariation, FeatureDecision.DECISION_SOURCE_FEATURE_TEST);
+                    return Result<FeatureDecision>.NewResult(featureDecision, reasons);
                 }
             }
 
+            Logger.Log(LogLevel.INFO, reasons.AddInfo($"The user \"{userId}\" is not bucketed into any of the experiments on the feature \"{featureFlag.Key}\"."));
             return Result<FeatureDecision>.NullResult(reasons);
         }
 
-        private Result<FeatureDecision> GetVariationFromDeliveryRule(ProjectConfig config, string key, List<Experiment> rules, int ruleIndex, OptimizelyUserContext user)
-        {
-            var reasons = new DecisionReasons();
-
-            bool skipToEveryoneElse = false;
-
-            //Check forced decision first
-            var rule = rules[ruleIndex];
-            var decisionContext = new OptimizelyDecisionContext(key, rule.Key);
-            var forcedDecisionResponse = user.FindValidatedForcedDecision(decisionContext);
-
-            reasons += forcedDecisionResponse.DecisionReasons;
-            if (forcedDecisionResponse.ResultObject != null)
-            {
-                return Result<FeatureDecision>.NewResult(new FeatureDecision(rule, forcedDecisionResponse.ResultObject, null), skipToEveryoneElse, reasons);
-            }
-
-            // Regular decision
-            var userId = user.GetUserId();
-            var attributes = user.GetAttributes();
-
-            // Get Bucketing ID from user attributes.
-            var bucketingIdResult = GetBucketingId(userId, attributes);
-            reasons += bucketingIdResult.DecisionReasons;
-
-            var everyoneElse = ruleIndex == rules.Count - 1;
-
-            var loggingKey = everyoneElse ? "Everyone Else" : ruleIndex + 1 + "";
-
-            Result<Variation> bucketedVariation = null;
-
-            // Evaluate if user meets the audience condition of this rollout rule
-            var doesUserMeetAudienceConditionsResult = ExperimentUtils.DoesUserMeetAudienceConditions(config, rule, attributes, LOGGING_KEY_TYPE_RULE, rule.Key, Logger);
-            reasons += doesUserMeetAudienceConditionsResult.DecisionReasons;
-            if (doesUserMeetAudienceConditionsResult.ResultObject)
-            {
-                Logger.Log(LogLevel.INFO, reasons.AddInfo($"User \"{userId}\" meets condition for targeting rule \"{loggingKey}\"."));
-
-                bucketedVariation = Bucketer.Bucket(config, rule, bucketingIdResult.ResultObject, userId);
-                reasons += bucketedVariation?.DecisionReasons;
-
-                if (bucketedVariation?.ResultObject?.Key != null)
-                {
-                    Logger.Log(LogLevel.INFO, reasons.AddInfo($"User \"{userId}\" is in the traffic group of targeting rule \"{loggingKey}\"."));
-                }
-                else if (!everyoneElse)
-                {
-                    //skip this loggng for everyoneElse rule since this has a message not for everyoneElse
-                    Logger.Log(LogLevel.INFO, reasons.AddInfo($"User \"{userId}\" is not in the traffic group for targeting rule \"{loggingKey}\". Checking EveryoneElse rule now."));
-                    skipToEveryoneElse = true;
-                }
-            }
-            else
-            {
-                Logger.Log(LogLevel.DEBUG, reasons.AddInfo($"User \"{userId}\" does not meet the conditions for targeting rule \"{loggingKey}\"."));
-            }
-
-            return Result<FeatureDecision>.NewResult(new FeatureDecision(rule, bucketedVariation?.ResultObject, null), skipToEveryoneElse, reasons);
-        }
-        private Result<Variation> GetVariationFromExperimentRule(ProjectConfig config, string key, Experiment experiment, OptimizelyUserContext user, OptimizelyDecideOption[] options)
-        {
-            var reasons = new DecisionReasons();
-
-            var ruleKey = experiment != null ? experiment.Key : null;
-
-            var decisionContext = new OptimizelyDecisionContext(key, ruleKey);
-
-            var forcedDecisionResponse = user.FindValidatedForcedDecision(decisionContext);
-
-            reasons += forcedDecisionResponse.DecisionReasons;
-
-            var variation = forcedDecisionResponse?.ResultObject;
-
-            if (variation != null)
-            {
-                return Result<Variation>.NewResult(variation, reasons);
-            }
-
-            var decisionResponse = GetVariation(experiment, user, config, user.GetAttributes(), options);
-
-            reasons += decisionResponse?.DecisionReasons;
-
-            return Result<Variation>.NewResult(decisionResponse?.ResultObject, reasons);
-        }
-
         /// <summary>
         /// Get the variation the user is bucketed into for the FeatureFlag
         /// </summary>
@@ -681,7 +632,7 @@ public virtual Result<FeatureDecision> GetVariationForFeature(FeatureFlag featur
             }
 
             Logger.Log(LogLevel.INFO, reasons.AddInfo($"The user \"{userId}\" is not bucketed into a rollout for feature flag \"{featureFlag.Key}\"."));
-            return Result<FeatureDecision>.NullResult(reasons);
+            return Result<FeatureDecision>.NewResult(new FeatureDecision(null, null, FeatureDecision.DECISION_SOURCE_ROLLOUT), reasons); ;
         }
 
         /// <summary>
diff --git a/OptimizelySDK/Config/DatafileProjectConfig.cs b/OptimizelySDK/Config/DatafileProjectConfig.cs
index 5f28fa71..07045ae3 100644
--- a/OptimizelySDK/Config/DatafileProjectConfig.cs
+++ b/OptimizelySDK/Config/DatafileProjectConfig.cs
@@ -205,11 +205,10 @@ private Dictionary<string, Dictionary<string, Variation>> _VariationIdMap
         private Dictionary<string, List<string>> ExperimentFeatureMap = new Dictionary<string, List<string>>();
 
         /// <summary>
-        /// Associated array of flags to experiments
+        /// Associated dictionary of flags to variations key value.
         /// </summary>
-
-        private Dictionary<string, List<Variation>> _FlagVariationMap = new Dictionary<string, List<Variation>>();
-        public Dictionary<string, List<Variation>> FlagVariationMap { get { return _FlagVariationMap; } }
+        private Dictionary<string, Dictionary<string, Variation>> _FlagVariationMap = new Dictionary<string, Dictionary<string, Variation>>();
+        public Dictionary<string, Dictionary<string, Variation>> FlagVariationMap { get { return _FlagVariationMap; } }
 
         //========================= Interfaces ===========================
 
@@ -355,73 +354,36 @@ private void Initialize()
                 }
             }
 
-            // Adding experiments in experiment-feature map.
+            var flagToVariationsMap = new Dictionary<string, Dictionary<string, Variation>>();
+            // Adding experiments in experiment-feature map and flag variation map to use.
             foreach (var feature in FeatureFlags)
             {
+                var variationKeyToVariationDict = new Dictionary<string, Variation>();
                 foreach (var experimentId in feature.ExperimentIds ?? new List<string>())
                 {
+                    foreach (var variationDictKV in ExperimentIdMap[experimentId].VariationKeyToVariationMap) {
+                        variationKeyToVariationDict[variationDictKV.Key] = variationDictKV.Value;
+                    }
+
                     if (ExperimentFeatureMap.ContainsKey(experimentId))
+                    {
                         ExperimentFeatureMap[experimentId].Add(feature.Id);
+                    }
                     else
+                    { 
                         ExperimentFeatureMap[experimentId] = new List<string> { feature.Id };
-                }
-            }
-            _FlagVariationMap = GetFlagVariationMap();
-        }
-
-        /// <summary>
-        /// Get the Flag variation map to use
-        /// </summary>
-        /// <returns>A map of flag key to variations</returns>
-        private Dictionary<string, List<Variation>> GetFlagVariationMap()
-        {
-            var variationsDict = new Dictionary<string, List<Variation>>();
-
-            foreach (var flag in FeatureFlags)
-            {
-                var variationIdToVariationsDict = new Dictionary<string, Variation>();
-
-                foreach (var rule in GetAllRulesForFlag(flag))
-                {
-                    foreach (var variation in rule.Variations)
-                    {
-                        if (!variationIdToVariationsDict.ContainsKey(variation.Id))
-                        {
-                            variationIdToVariationsDict.Add(variation.Id, variation);
-                        }
                     }
                 }
-                // Grab all the variations from the flag experiments and rollouts and add to flagVariationsMap
-                variationsDict[flag.Key] = variationIdToVariationsDict.Values.ToList<Variation>();
-            }
-            return variationsDict;
-        }
-
-        /// <summary>
-        /// Retrieves all the rules for a given feature flag
-        /// </summary>
-        /// <param name="flag">Feature flag to use</param>
-        /// <returns>A list of experiments</returns>
-        private List<Experiment> GetAllRulesForFlag(FeatureFlag flag)
-        {
-            var rules = new List<Experiment>();
-
-            RolloutIdMap.TryGetValue(flag.RolloutId, out var rollout);
-
-            foreach (var expId in flag.ExperimentIds)
-            {
-                if (ExperimentIdMap.TryGetValue(expId, out var rule))
-                {
-                    rules.Add(rule);
+                if (RolloutIdMap.TryGetValue(feature.RolloutId, out var rolloutRules)) {
+                    var rolloutRulesVariations = rolloutRules.Experiments.SelectMany(ex => ex.Variations);
+                    foreach (var rolloutRuleVariation in rolloutRulesVariations) {
+                        variationKeyToVariationDict[rolloutRuleVariation.Key] = rolloutRuleVariation;
+                    }
                 }
+                
+                flagToVariationsMap[feature.Key] = variationKeyToVariationDict;
             }
-
-            if (rollout != null)
-            {
-                rules.AddRange(rollout.Experiments);
-            }
-
-            return rules;
+            _FlagVariationMap = flagToVariationsMap;
         }
 
         /// <summary>
@@ -658,16 +620,12 @@ public FeatureFlag GetFeatureFlagFromKey(string featureKey)
         /// <returns></returns>
         public Variation GetFlagVariationByKey(string flagKey, string variationKey)
         {
-            if (_FlagVariationMap.TryGetValue(flagKey, out var variations))
-            {
-                foreach (var variation in variations)
-                {
-                    if (variation.Key == variationKey)
-                    {
-                        return variation;
-                    }
-                }
+            if (FlagVariationMap.TryGetValue(flagKey, out var variationsKeyMap)) {
+
+                variationsKeyMap.TryGetValue(variationKey, out var variation);
+                return variation;
             }
+
             return null;
         }
 
diff --git a/OptimizelySDK/Entity/Result.cs b/OptimizelySDK/Entity/Result.cs
index 04a30d6c..17a63133 100644
--- a/OptimizelySDK/Entity/Result.cs
+++ b/OptimizelySDK/Entity/Result.cs
@@ -21,12 +21,7 @@ public class Result<T>
     {
         public T ResultObject;
         public DecisionReasons DecisionReasons;
-        public bool SkipToEveryoneElse;
 
-        public static Result<T> NewResult(T resultObject, bool skipToEveryoneElse, DecisionReasons decisionReasons)
-        {
-            return new Result<T> { DecisionReasons = decisionReasons, ResultObject = resultObject, SkipToEveryoneElse = skipToEveryoneElse };
-        }
         public static Result<T> NewResult(T resultObject, DecisionReasons decisionReasons)
         {
             return new Result<T> { DecisionReasons = decisionReasons, ResultObject = resultObject };
diff --git a/OptimizelySDK/Event/Builder/EventBuilder.cs b/OptimizelySDK/Event/Builder/EventBuilder.cs
index 613a9edc..ff224a31 100644
--- a/OptimizelySDK/Event/Builder/EventBuilder.cs
+++ b/OptimizelySDK/Event/Builder/EventBuilder.cs
@@ -132,7 +132,7 @@ private Dictionary<string, object> GetImpressionParams(Experiment experiment, st
                     new Dictionary<string, object>
                     {
                         { Params.CAMPAIGN_ID,   experiment?.LayerId },
-                        { Params.EXPERIMENT_ID, experiment?.Id},
+                        { Params.EXPERIMENT_ID, experiment?.Id ?? string.Empty },
                         { Params.VARIATION_ID,  variationId }
                     }
             };
diff --git a/OptimizelySDK/ForcedDecisionsStore.cs b/OptimizelySDK/ForcedDecisionsStore.cs
new file mode 100644
index 00000000..da0fbac8
--- /dev/null
+++ b/OptimizelySDK/ForcedDecisionsStore.cs
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2021, Optimizely
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System.Collections.Generic;
+
+namespace OptimizelySDK
+{
+    /// <summary>
+    /// ForcedDecisionsStore defines helper methods that are used for optimizelyDecisionContext object manipulation.
+    /// </summary>
+    public class ForcedDecisionsStore
+    {
+        private Dictionary<string, OptimizelyForcedDecision> ForcedDecisionsMap { get; set; }
+        private static ForcedDecisionsStore NullForcedDecisionStore;
+
+        /// <summary>
+        /// Instantiates a NULL object when ForcedDecisionStore first time is used.
+        /// </summary>
+        static ForcedDecisionsStore()
+        {
+            NullForcedDecisionStore = new ForcedDecisionsStore();
+        }
+        public ForcedDecisionsStore()
+        {
+            ForcedDecisionsMap = new Dictionary<string, OptimizelyForcedDecision>();
+        }
+
+        /// <summary>
+        /// This method will return instance of ForcedDecisionStore that won't be accessible from outside.
+        /// Instead of copying everytime or putting NULL for every forced decision condition, this approach looks fine to me.
+        /// </summary>
+        /// <returns></returns>
+        internal static ForcedDecisionsStore NullForcedDecision()
+        {
+            return NullForcedDecisionStore;
+        }
+
+        public ForcedDecisionsStore(ForcedDecisionsStore forcedDecisionsStore)
+        {
+            ForcedDecisionsMap = new Dictionary<string, OptimizelyForcedDecision>(forcedDecisionsStore.ForcedDecisionsMap);
+        }
+
+        public int Count
+        {
+            get
+            {
+                return ForcedDecisionsMap.Count;
+            }
+        }
+        public bool Remove(OptimizelyDecisionContext context)
+        {
+            return ForcedDecisionsMap.Remove(context.GetKey());
+        }
+
+        public void RemoveAll()
+        {
+            ForcedDecisionsMap.Clear();
+        }
+
+        public OptimizelyForcedDecision this[OptimizelyDecisionContext context]
+        {
+            get
+            {
+                if (context != null && context.FlagKey != null
+                    && ForcedDecisionsMap.TryGetValue(context.GetKey(), out OptimizelyForcedDecision flagForcedDecision))
+                {
+                    return flagForcedDecision;
+                }
+                return null;
+            }
+            set
+            {
+                if (context != null && context.FlagKey != null)
+                {
+                    ForcedDecisionsMap[context.GetKey()] = value;
+                }
+            }
+
+        }
+    }
+}
diff --git a/OptimizelySDK/Optimizely.cs b/OptimizelySDK/Optimizely.cs
index 144fd082..a7265fa7 100644
--- a/OptimizelySDK/Optimizely.cs
+++ b/OptimizelySDK/Optimizely.cs
@@ -378,14 +378,16 @@ private Variation GetVariation(string experimentKey, string userId, ProjectConfi
             Experiment experiment = config.GetExperimentFromKey(experimentKey);
             if (experiment.Key == null)
                 return null;
-            var variation = DecisionService.GetVariation(experiment, CreateUserContext(userId, userAttributes), config, userAttributes).ResultObject;
+            userAttributes = userAttributes ?? new UserAttributes();
+
+            var userContext = CreateUserContext(userId, userAttributes);
+            var variation = DecisionService.GetVariation(experiment, userContext, config)?.ResultObject;
             var decisionInfo = new Dictionary<string, object>
             {
                 { "experimentKey", experimentKey },
                 { "variationKey", variation?.Key },
             };
 
-            userAttributes = userAttributes ?? new UserAttributes();
             var decisionNotificationType = config.IsFeatureExperiment(experiment.Id) ? DecisionNotificationTypes.FEATURE_TEST : DecisionNotificationTypes.AB_TEST;
             NotificationCenter.SendNotifications(NotificationCenter.NotificationType.Decision, decisionNotificationType, userId,
                 userAttributes, decisionInfo);
@@ -443,25 +445,6 @@ public Variation GetForcedVariation(string experimentKey, string userId)
             return DecisionService.GetForcedVariation(experimentKey, userId, config).ResultObject;
         }
 
-        public Variation GetFlagVariationByKey(string flagKey, string variationKey)
-        {
-            var flagVariationMap = ProjectConfigManager?.GetConfig().FlagVariationMap;
-            if (flagVariationMap.ContainsKey(flagKey) == true)
-            {
-                flagVariationMap.TryGetValue(flagKey, out var variations);
-
-                foreach (var variation in variations)
-                {
-                    if (variation.Key.Equals(variationKey))
-                    {
-                        return variation;
-                    }
-                }
-            }
-
-            return null;
-        }
-
         #region FeatureFlag APIs
 
         /// <summary>
@@ -778,7 +761,7 @@ internal OptimizelyDecision Decide(OptimizelyUserContext user,
             FeatureDecision decision = null;
 
             var decisionContext = new OptimizelyDecisionContext(flag.Key);
-            var forcedDecisionVariation = user.FindValidatedForcedDecision(decisionContext);
+            var forcedDecisionVariation = user.FindValidatedForcedDecision(decisionContext, config);
             decisionReasons += forcedDecisionVariation.DecisionReasons;
 
             if (forcedDecisionVariation.ResultObject != null)
diff --git a/OptimizelySDK/OptimizelyDecisionContext.cs b/OptimizelySDK/OptimizelyDecisionContext.cs
index fafec889..d487483b 100644
--- a/OptimizelySDK/OptimizelyDecisionContext.cs
+++ b/OptimizelySDK/OptimizelyDecisionContext.cs
@@ -16,25 +16,33 @@
 
 namespace OptimizelySDK
 {
+    /// <summary>
+    /// OptimizelyDecisionContext contains flag key and rule key to be used for setting 
+    /// and getting forced decision.
+    /// </summary>
     public class OptimizelyDecisionContext
     {
         public const string OPTI_NULL_RULE_KEY = "$opt-null-rule-key";
         public const string OPTI_KEY_DIVIDER = "-$opt$-";
+
         private string flagKey;
         private string ruleKey;
         private string decisionKey;
 
-        public OptimizelyDecisionContext(string flagKey, string ruleKey = null)
+        public string FlagKey { get { return flagKey; } }
+        public string RuleKey { get { return ruleKey; } }
+
+        public OptimizelyDecisionContext(string flagKey, string ruleKey= null)
         {
             this.flagKey = flagKey;
             this.ruleKey = ruleKey;
-            this.decisionKey = string.Format("{0}{1}{2}", flagKey, OPTI_KEY_DIVIDER, ruleKey ?? OPTI_NULL_RULE_KEY);
         }
 
-        public string FlagKey { get { return flagKey; } }
+        public string GetKey()
+        {
+            return string.Format("{0}{1}{2}", FlagKey, OPTI_KEY_DIVIDER, RuleKey ?? OPTI_NULL_RULE_KEY);
+        }
 
-        public string RuleKey { get { return ruleKey; } }
 
-        public string DecisionKey { get { return decisionKey; } }
     }
 }
diff --git a/OptimizelySDK/OptimizelySDK.csproj b/OptimizelySDK/OptimizelySDK.csproj
index e151529a..c8791237 100644
--- a/OptimizelySDK/OptimizelySDK.csproj
+++ b/OptimizelySDK/OptimizelySDK.csproj
@@ -92,6 +92,7 @@
     <Compile Include="OptimizelyDecisions\OptimizelyDecideOption.cs" />
     <Compile Include="OptimizelyDecisions\OptimizelyDecision.cs" />
     <Compile Include="OptimizelyForcedDecision.cs" />
+    <Compile Include="ForcedDecisionsStore.cs" />
     <Compile Include="OptimizelyUserContext.cs" />
     <Compile Include="OptimizelyJSON.cs" />
     <Compile Include="Entity\Rollout.cs" />
diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index 7ef49293..9b7f7a0e 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -41,29 +41,24 @@ public class OptimizelyUserContext
         // Optimizely object to be used.
         private Optimizely Optimizely;
 
-        private Dictionary<string, OptimizelyForcedDecision> ForcedDecisionsMap { get; set; }
+        private ForcedDecisionsStore ForcedDecisionsStore { get; set; }
 
-        public OptimizelyUserContext(Optimizely optimizely, string userId, UserAttributes userAttributes, IErrorHandler errorHandler, ILogger logger)
+        public OptimizelyUserContext(Optimizely optimizely, string userId, UserAttributes userAttributes, IErrorHandler errorHandler, ILogger logger) :
+            this(optimizely, userId, userAttributes, null, errorHandler, logger)
         {
-            ErrorHandler = errorHandler;
-            Logger = logger;
-            Optimizely = optimizely;
-            Attributes = userAttributes ?? new UserAttributes();
-            ForcedDecisionsMap = new Dictionary<string, OptimizelyForcedDecision>();
-            UserId = userId;
         }
 
-        public OptimizelyUserContext(Optimizely optimizely, string userId, UserAttributes userAttributes, Dictionary<string, OptimizelyForcedDecision> forcedDecisions, IErrorHandler errorHandler, ILogger logger)
+        public OptimizelyUserContext(Optimizely optimizely, string userId, UserAttributes userAttributes, ForcedDecisionsStore forcedDecisionsStore, IErrorHandler errorHandler, ILogger logger)
         {
             ErrorHandler = errorHandler;
             Logger = logger;
             Optimizely = optimizely;
             Attributes = userAttributes ?? new UserAttributes();
-            ForcedDecisionsMap = forcedDecisions ?? new Dictionary<string, OptimizelyForcedDecision>();
+            ForcedDecisionsStore = forcedDecisionsStore ?? new ForcedDecisionsStore();
             UserId = userId;
         }
 
-        private OptimizelyUserContext Copy() => new OptimizelyUserContext(Optimizely, UserId, GetAttributes(), ForcedDecisionsMap, ErrorHandler, Logger);
+        private OptimizelyUserContext Copy() => new OptimizelyUserContext(Optimizely, UserId, GetAttributes(), GetForcedDecisionsStore(), ErrorHandler, Logger);
 
         /// <summary>
         /// Returns Optimizely instance associated with the UserContext.
@@ -98,6 +93,27 @@ public UserAttributes GetAttributes()
             return copiedAttributes;
         }
 
+        /// <summary>
+        /// Returns copy of ForcedDecisionsStore associated with UserContext.
+        /// </summary>
+        /// <returns>copy of ForcedDecisionsStore.</returns>
+        public ForcedDecisionsStore GetForcedDecisionsStore()
+        {
+            ForcedDecisionsStore copiedForcedDecisionsStore = null;
+            lock (mutex)
+            {
+                if (ForcedDecisionsStore.Count == 0)
+                {
+                    copiedForcedDecisionsStore = ForcedDecisionsStore.NullForcedDecision();
+                } else
+                {
+                    copiedForcedDecisionsStore = new ForcedDecisionsStore(ForcedDecisionsStore);
+                }
+            }
+
+            return copiedForcedDecisionsStore;
+        }
+
         /// <summary>
         /// Set an attribute for a given key.
         /// </summary>
@@ -211,9 +227,8 @@ public virtual void TrackEvent(string eventName,
         /// <summary>
         /// Set a forced decision.
         /// </summary>
-        /// <param name="flagKey">The flag key.</param>
-        /// <param name="ruleKey">The rule key.</param>
-        /// <param name="variationKey">The variation key.</param>
+        /// <param name="context">The context object containing flag and rule key.</param>
+        /// <param name="decision">OptimizelyForcedDecision object containing variation key.</param>
         /// <returns></returns>
         public bool SetForcedDecision(OptimizelyDecisionContext context, OptimizelyForcedDecision decision)
         {
@@ -225,7 +240,7 @@ public bool SetForcedDecision(OptimizelyDecisionContext context, OptimizelyForce
 
             lock (mutex)
             {
-                ForcedDecisionsMap[context.DecisionKey] = decision;
+                ForcedDecisionsStore[context] = decision;
             }
 
             return true;
@@ -234,8 +249,7 @@ public bool SetForcedDecision(OptimizelyDecisionContext context, OptimizelyForce
         /// <summary>
         /// Gets a forced variation
         /// </summary>
-        /// <param name="flagKey">The flag key</param>
-        /// <param name="ruleKey">The rule key</param>
+        /// <param name="context">The context object containing flag and rule key.</param>
         /// <returns>The variation key for a forced decision</returns>
         public OptimizelyForcedDecision GetForcedDecision(OptimizelyDecisionContext context)
         {
@@ -251,7 +265,7 @@ public OptimizelyForcedDecision GetForcedDecision(OptimizelyDecisionContext cont
                 return null;
             }
 
-            if (ForcedDecisionsMap.Count == 0)
+            if (ForcedDecisionsStore.Count == 0)
             {
                 return null;
             }
@@ -260,7 +274,7 @@ public OptimizelyForcedDecision GetForcedDecision(OptimizelyDecisionContext cont
 
             lock (mutex)
             {
-                ForcedDecisionsMap.TryGetValue(context.DecisionKey, out decision);
+                decision = ForcedDecisionsStore[context];
             }
             return decision;
         }
@@ -268,14 +282,13 @@ public OptimizelyForcedDecision GetForcedDecision(OptimizelyDecisionContext cont
         /// <summary>
         /// Removes a forced decision.
         /// </summary>
-        /// <param name="flagKey">The flag key.</param>
-        /// <param name="ruleKey"></param>
+        /// <param name="context">The context object containing flag and rule key.</param>
         /// <returns>Whether the item was removed.</returns>
         public bool RemoveForcedDecision(OptimizelyDecisionContext context)
         {
             if (context == null || context.FlagKey == null)
             {
-                Logger.Log(LogLevel.WARN, "flagKey cannot be null");
+                Logger.Log(LogLevel.WARN, "FlagKey cannot be null");
                 return false;
             }
 
@@ -284,8 +297,11 @@ public bool RemoveForcedDecision(OptimizelyDecisionContext context)
                 Logger.Log(LogLevel.ERROR, DecisionMessage.SDK_NOT_READY);
                 return false;
             }
-
-            return ForcedDecisionsMap.Remove(context.DecisionKey);
+            
+            lock (mutex)
+            {
+                return ForcedDecisionsStore.Remove(context);
+            }
         }
 
         /// <summary>
@@ -302,7 +318,7 @@ public bool RemoveAllForcedDecisions()
 
             lock (mutex)
             {
-                ForcedDecisionsMap.Clear();
+                ForcedDecisionsStore.RemoveAll();
             }
             return true;
         }
@@ -310,19 +326,19 @@ public bool RemoveAllForcedDecisions()
         /// <summary>
         /// Finds a validated forced decision.
         /// </summary>
-        /// <param name="flagKey">The flag key.</param>
-        /// <param name="ruleKey">The rule key.</param>
+        /// <param name="context">Object containing flag and rule key of which forced decision is set.</param>
+        /// <param name="config">The Project config.</param>
         /// <returns>A result with the variation</returns>
-        public Result<Variation> FindValidatedForcedDecision(OptimizelyDecisionContext context)
+        public Result<Variation> FindValidatedForcedDecision(OptimizelyDecisionContext context, ProjectConfig config)
         {
             DecisionReasons reasons = new DecisionReasons();
             var forcedDecision = GetForcedDecision(context);
 
-            if (forcedDecision != null)
+            if (config != null && forcedDecision != null)
             {
                 var loggingKey = context.RuleKey != null ? "flag (" + context.FlagKey + "), rule (" + context.RuleKey + ")" : "flag (" + context.FlagKey + ")";
                 var variationKey = forcedDecision.VariationKey;
-                var variation = Optimizely.GetFlagVariationByKey(context.FlagKey, variationKey);
+                var variation = config.GetFlagVariationByKey(context.FlagKey, variationKey);
                 if (variation != null)
                 {
                     reasons.AddInfo("Decided by forced decision.");
diff --git a/OptimizelySDK/ProjectConfig.cs b/OptimizelySDK/ProjectConfig.cs
index 675d1dd5..9a6f0701 100644
--- a/OptimizelySDK/ProjectConfig.cs
+++ b/OptimizelySDK/ProjectConfig.cs
@@ -119,9 +119,9 @@ public interface ProjectConfig
         Dictionary<string, Rollout> RolloutIdMap { get; }
 
         /// <summary>
-        /// Associative array of Flag to Variation in the datafile
+        /// Associative dictionary of Flag to Variation key and Variation in the datafile
         /// </summary>
-        Dictionary<string, List<Variation>> FlagVariationMap { get; }
+        Dictionary<string, Dictionary<string, Variation>> FlagVariationMap { get; }
 
         //========================= Datafile Entities ===========================
 

From cdf53debdafc8146ccabf87d8682430077749ce4 Mon Sep 17 00:00:00 2001
From: mnoman09 <Muhammadnoman@folio3.com>
Date: Fri, 3 Dec 2021 23:36:49 +0500
Subject: [PATCH 121/130] fix(ForcedDecision): remove config-ready check from
 forced-decision apis (#288)

---
 OptimizelySDK.Tests/DecisionServiceTest.cs    |  2 +-
 .../OptimizelyUserContextTest.cs              | 47 -------------------
 OptimizelySDK/OptimizelyUserContext.cs        | 24 ----------
 3 files changed, 1 insertion(+), 72 deletions(-)

diff --git a/OptimizelySDK.Tests/DecisionServiceTest.cs b/OptimizelySDK.Tests/DecisionServiceTest.cs
index f746ac3f..fcf9fb22 100644
--- a/OptimizelySDK.Tests/DecisionServiceTest.cs
+++ b/OptimizelySDK.Tests/DecisionServiceTest.cs
@@ -951,7 +951,7 @@ public void TestGetVariationForFeatureWhenTheUserIsNeitherBucketedIntoFeatureExp
             OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns(UserProfileId);
 
             var actualDecision = DecisionServiceMock.Object.GetVariationForFeature(featureFlag, OptimizelyUserContextMock.Object, ProjectConfig);
-            Assert.IsNull(actualDecision.ResultObject);
+            Assert.IsNull(actualDecision.ResultObject.Variation);
 
             LoggerMock.Verify(l => l.Log(LogLevel.INFO, "The user \"userProfileId\" is not bucketed into a rollout for feature flag \"string_single_variable_feature\"."));
         }
diff --git a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
index d5ab832a..74572577 100644
--- a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
+++ b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs
@@ -224,21 +224,6 @@ public void TestGetForcedDecisionReturnsNullIfInvalidConfig()
             Assert.IsNull(result);
         }
 
-        [Test]
-        public void TestSetForcedDecisionReturnsFalseForNullConfig()
-        {
-            var optly = new Optimizely(new FallbackProjectConfigManager(null), logger: LoggerMock.Object);
-
-            var user = optly.CreateUserContext(UserID);
-
-            var context = new OptimizelyDecisionContext("flag", null);
-            var decision = new OptimizelyForcedDecision("variationKey");
-            var result = user.SetForcedDecision(context, decision);
-
-            Assert.IsFalse(result);
-            LoggerMock.Verify(log => log.Log(LogLevel.ERROR, "Optimizely SDK not configured properly yet."), Times.Once);
-        }
-
         [Test]
         public void TestGetForcedDecisionReturnsNullWithNullFlagKey()
         {
@@ -341,22 +326,6 @@ public void TestRemoveForcedDecisionRemovesDecision()
             Assert.AreEqual(null, result);
         }
 
-        [Test]
-        public void TestRemoveForcedDecisionReturnsFalseForNullConfig()
-        {
-            var optly = new Optimizely(new FallbackProjectConfigManager(null));
-
-            var user = optly.CreateUserContext(UserID);
-
-            var context = new OptimizelyDecisionContext("flagKey", null);
-            var decision = new OptimizelyForcedDecision("variationKey");
-            var setResult = user.SetForcedDecision(context, decision);
-
-            var result = user.RemoveForcedDecision(context);
-
-            Assert.AreEqual(false, result);
-        }
-
         [Test]
         public void TestRemoveAllForcedDecisionsRemovesDecisions()
         {
@@ -386,22 +355,6 @@ public void TestRemoveAllForcedDecisionsRemovesDecisions()
             Assert.AreEqual(null, result3);
         }
 
-        [Test]
-        public void TestRemoveAllForcedDecisionsReturnsFalseForNullConfig()
-        {
-            var optly = new Optimizely(new FallbackProjectConfigManager(null));
-
-            var user = optly.CreateUserContext(UserID);
-
-            var context = new OptimizelyDecisionContext("flagKey");
-            var decision = new OptimizelyForcedDecision("variation");
-            user.SetForcedDecision(context, decision);
-
-            var result = user.RemoveAllForcedDecisions();
-
-            Assert.AreEqual(false, result);
-        }
-
         [Test]
         public void DecideInvalidFlagKey()
         {
diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index 9b7f7a0e..9e7b0ac8 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -232,12 +232,6 @@ public virtual void TrackEvent(string eventName,
         /// <returns></returns>
         public bool SetForcedDecision(OptimizelyDecisionContext context, OptimizelyForcedDecision decision)
         {
-            if (!Optimizely.IsValid)
-            {
-                Logger.Log(LogLevel.ERROR, DecisionMessage.SDK_NOT_READY);
-                return false;
-            }
-
             lock (mutex)
             {
                 ForcedDecisionsStore[context] = decision;
@@ -253,12 +247,6 @@ public bool SetForcedDecision(OptimizelyDecisionContext context, OptimizelyForce
         /// <returns>The variation key for a forced decision</returns>
         public OptimizelyForcedDecision GetForcedDecision(OptimizelyDecisionContext context)
         {
-            if (!Optimizely.IsValid)
-            {
-                Logger.Log(LogLevel.ERROR, DecisionMessage.SDK_NOT_READY);
-                return null;
-            }
-
             if (context == null || context.FlagKey == null)
             {
                 Logger.Log(LogLevel.WARN, "flagKey cannot be null");
@@ -291,12 +279,6 @@ public bool RemoveForcedDecision(OptimizelyDecisionContext context)
                 Logger.Log(LogLevel.WARN, "FlagKey cannot be null");
                 return false;
             }
-
-            if (!Optimizely.IsValid)
-            {
-                Logger.Log(LogLevel.ERROR, DecisionMessage.SDK_NOT_READY);
-                return false;
-            }
             
             lock (mutex)
             {
@@ -310,12 +292,6 @@ public bool RemoveForcedDecision(OptimizelyDecisionContext context)
         /// <returns>Whether the clear was successful.</returns>
         public bool RemoveAllForcedDecisions()
         {
-            if (!Optimizely.IsValid)
-            {
-                Logger.Log(LogLevel.ERROR, DecisionMessage.SDK_NOT_READY);
-                return false;
-            }
-
             lock (mutex)
             {
                 ForcedDecisionsStore.RemoveAll();

From b6170cd8be9a804ac08aee65fe64236e3ae96256 Mon Sep 17 00:00:00 2001
From: Sohail Hussain <mirza.sohailhussain@gmail.com>
Date: Sat, 4 Dec 2021 23:00:33 -0800
Subject: [PATCH 122/130] some issues fixed.

---
 OptimizelySDK/Bucketing/DecisionService.cs  |  39 ++--
 OptimizelySDK/Event/Builder/EventBuilder.cs |  35 ++-
 OptimizelySDK/Event/EventFactory.cs         |   2 +-
 OptimizelySDK/Event/UserEventFactory.cs     |  15 +-
 OptimizelySDK/ForcedDecisionsStore.cs       |   2 +-
 OptimizelySDK/IOptimizely.cs                | 247 ++++++++++----------
 OptimizelySDK/Optimizely.cs                 |  19 +-
 OptimizelySDK/OptimizelyDecisionContext.cs  |  15 ++
 OptimizelySDK/OptimizelyForcedDecision.cs   |   4 +-
 OptimizelySDK/OptimizelyUserContext.cs      |   4 +-
 10 files changed, 195 insertions(+), 187 deletions(-)

diff --git a/OptimizelySDK/Bucketing/DecisionService.cs b/OptimizelySDK/Bucketing/DecisionService.cs
index 0796aa0b..d0c6177c 100644
--- a/OptimizelySDK/Bucketing/DecisionService.cs
+++ b/OptimizelySDK/Bucketing/DecisionService.cs
@@ -110,21 +110,21 @@ public virtual Result<Variation> GetVariation(Experiment experiment,
                 return Result<Variation>.NullResult(reasons);
 
             // check if a forced variation is set
-            var decisionVariation = GetForcedVariation(experiment.Key, userId, config);
-            reasons += decisionVariation.DecisionReasons;
-            var variation = decisionVariation?.ResultObject;
+            var decisionVariationResult = GetForcedVariation(experiment.Key, userId, config);
+            reasons += decisionVariationResult.DecisionReasons;
+            var variation = decisionVariationResult.ResultObject;
 
             if (variation == null)
             {
-                decisionVariation = GetWhitelistedVariation(experiment, user.GetUserId());
-                reasons += decisionVariation?.DecisionReasons;
+                decisionVariationResult = GetWhitelistedVariation(experiment, user.GetUserId());
+                reasons += decisionVariationResult.DecisionReasons;
 
-                variation = decisionVariation?.ResultObject;
+                variation = decisionVariationResult.ResultObject;
             }
 
             if (variation != null)
             {
-                return decisionVariation;
+                return decisionVariationResult;
             }
 
             // fetch the user profile map from the user profile service
@@ -139,9 +139,9 @@ public virtual Result<Variation> GetVariation(Experiment experiment,
                     if (userProfileMap != null && UserProfileUtil.IsValidUserProfileMap(userProfileMap))
                     {
                         userProfile = UserProfileUtil.ConvertMapToUserProfile(userProfileMap);
-                        decisionVariation = GetStoredVariation(experiment, userProfile, config);
-                        reasons += decisionVariation?.DecisionReasons;
-                        if (decisionVariation?.ResultObject != null) return decisionVariation?.SetReasons(reasons);
+                        decisionVariationResult = GetStoredVariation(experiment, userProfile, config);
+                        reasons += decisionVariationResult.DecisionReasons;
+                        if (decisionVariationResult.ResultObject != null) return decisionVariationResult.SetReasons(reasons);
                     }
                     else if (userProfileMap == null)
                     {
@@ -167,21 +167,21 @@ public virtual Result<Variation> GetVariation(Experiment experiment,
                 var bucketingIdResult = GetBucketingId(userId, filteredAttributes);
                 reasons += bucketingIdResult.DecisionReasons;
 
-                decisionVariation = Bucketer.Bucket(config, experiment, bucketingIdResult.ResultObject, userId);
-                reasons += decisionVariation?.DecisionReasons;
+                decisionVariationResult = Bucketer.Bucket(config, experiment, bucketingIdResult.ResultObject, userId);
+                reasons += decisionVariationResult.DecisionReasons;
 
-                if (decisionVariation?.ResultObject?.Key != null)
+                if (decisionVariationResult.ResultObject?.Key != null)
                 {
                     if (UserProfileService != null && !ignoreUPS)
                     {
                         var bucketerUserProfile = userProfile ?? new UserProfile(userId, new Dictionary<string, Decision>());
-                        SaveVariation(experiment, decisionVariation?.ResultObject, bucketerUserProfile);
+                        SaveVariation(experiment, decisionVariationResult.ResultObject, bucketerUserProfile);
                     }
                     else
                         Logger.Log(LogLevel.INFO, "This decision will not be saved since the UserProfileService is null.");
                 }
 
-                return decisionVariation?.SetReasons(reasons);
+                return decisionVariationResult.SetReasons(reasons);
             }
             Logger.Log(LogLevel.INFO, reasons.AddInfo($"User \"{user.GetUserId()}\" does not meet conditions to be in experiment \"{experiment.Key}\"."));
 
@@ -441,14 +441,13 @@ public virtual Result<FeatureDecision> GetVariationForFeatureRollout(FeatureFlag
                 return Result<FeatureDecision>.NullResult(reasons);
             }
 
-            var rolloutRulesLength = rollout.Experiments.Count;
-            var rolloutRules = rollout.Experiments;
-
-            if (rolloutRules == null || rolloutRulesLength == 0)
-            {
+            if (rollout.Experiments == null || rollout.Experiments.Count == 0) {
                 return Result<FeatureDecision>.NullResult(reasons);
             }
 
+            var rolloutRulesLength = rollout.Experiments.Count;
+            var rolloutRules = rollout.Experiments;
+
             var userId = user.GetUserId();
             var attributes = user.GetAttributes();
 
diff --git a/OptimizelySDK/Event/Builder/EventBuilder.cs b/OptimizelySDK/Event/Builder/EventBuilder.cs
index ff224a31..0f0b41b8 100644
--- a/OptimizelySDK/Event/Builder/EventBuilder.cs
+++ b/OptimizelySDK/Event/Builder/EventBuilder.cs
@@ -1,4 +1,4 @@
-/*
+/* 
  * Copyright 2017-2019, Optimizely
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 using OptimizelySDK.Bucketing;
 using OptimizelySDK.Entity;
 using OptimizelySDK.Logger;
@@ -93,10 +92,9 @@ private Dictionary<string, object> GetCommonParams(ProjectConfig config, string
 
             //Omit attribute values that are not supported by the log endpoint.
             foreach (var validUserAttribute in userAttributes.Where(attribute => Validator.IsUserAttributeValid(attribute)))
-            {
+            {                
                 var attributeId = config.GetAttributeId(validUserAttribute.Key);
-                if (!string.IsNullOrEmpty(attributeId))
-                {
+                if (!string.IsNullOrEmpty(attributeId)) {
                     userFeatures.Add(new Dictionary<string, object>
                     {
                         { "entity_id", attributeId },
@@ -125,23 +123,25 @@ private Dictionary<string, object> GetCommonParams(ProjectConfig config, string
 
         private Dictionary<string, object> GetImpressionParams(Experiment experiment, string variationId)
         {
+
             var impressionEvent = new Dictionary<string, object>();
 
             var decisions = new object[]
             {
                     new Dictionary<string, object>
                     {
-                        { Params.CAMPAIGN_ID,   experiment?.LayerId },
-                        { Params.EXPERIMENT_ID, experiment?.Id ?? string.Empty },
+                        { Params.CAMPAIGN_ID,   experiment.LayerId },
+                        { Params.EXPERIMENT_ID, experiment.Id },
                         { Params.VARIATION_ID,  variationId }
                     }
             };
 
+
             var events = new object[]
             {
                     new Dictionary<string, object>
                     {
-                        { "entity_id", experiment?.LayerId },
+                        { "entity_id", experiment.LayerId },
                         { "timestamp", DateTimeUtils.SecondsSince1970*1000 },
                         { "key", ACTIVATE_EVENT_KEY },
                         { "uuid", Guid.NewGuid() }
@@ -156,6 +156,7 @@ private Dictionary<string, object> GetImpressionParams(Experiment experiment, st
 
         private List<object> GetConversionParams(ProjectConfig config, string eventKey, string userId, Dictionary<string, object> eventTags)
         {
+
             var conversionEventParams = new List<object>();
             var snapshot = new Dictionary<string, object>();
 
@@ -167,20 +168,17 @@ private List<object> GetConversionParams(ProjectConfig config, string eventKey,
                         { "key", eventKey }
                     };
 
-            if (eventTags != null)
-            {
+            if (eventTags != null) {
                 var revenue = EventTagUtils.GetRevenueValue(eventTags, Logger);
 
-                if (revenue != null)
-                {
+                if (revenue != null) {
                     eventDict[EventTagUtils.REVENUE_EVENT_METRIC_NAME] = revenue;
                 }
 
-                var eventValue = EventTagUtils.GetNumericValue(eventTags, Logger);
+                var eventVallue = EventTagUtils.GetNumericValue(eventTags, Logger);
 
-                if (eventValue != null)
-                {
-                    eventDict[EventTagUtils.VALUE_EVENT_METRIC_NAME] = eventValue;
+                if (eventVallue != null) {
+                    eventDict[EventTagUtils.VALUE_EVENT_METRIC_NAME] = eventVallue;
                 }
 
                 if (eventTags.Any())
@@ -200,8 +198,7 @@ private Dictionary<string, object> GetImpressionOrConversionParamsWithCommonPara
         {
             var visitors = commonParams[Params.VISITORS] as object[];
 
-            if (visitors.Length > 0)
-            {
+            if (visitors.Length > 0) {
                 var visitor = visitors[0] as Dictionary<string, object>;
                 visitor["snapshots"] = conversionOrImpressionOnlyParams;
             }
@@ -221,6 +218,7 @@ private Dictionary<string, object> GetImpressionOrConversionParamsWithCommonPara
         public virtual LogEvent CreateImpressionEvent(ProjectConfig config, Experiment experiment, string variationId,
             string userId, UserAttributes userAttributes)
         {
+
             var commonParams = GetCommonParams(config, userId, userAttributes ?? new UserAttributes());
             var impressionOnlyParams = GetImpressionParams(experiment, variationId);
 
@@ -229,6 +227,7 @@ public virtual LogEvent CreateImpressionEvent(ProjectConfig config, Experiment e
             return new LogEvent(IMPRESSION_ENDPOINT, impressionParams, HTTP_VERB, HTTP_HEADERS);
         }
 
+
         /// <summary>
         /// Create conversion event to be sent to the logging endpoint.
         /// </summary>
diff --git a/OptimizelySDK/Event/EventFactory.cs b/OptimizelySDK/Event/EventFactory.cs
index eb7d2b28..63482a8b 100644
--- a/OptimizelySDK/Event/EventFactory.cs
+++ b/OptimizelySDK/Event/EventFactory.cs
@@ -114,7 +114,7 @@ private static Visitor CreateVisitor(ImpressionEvent impressionEvent) {
             var eventContext = impressionEvent.Context;
 
             Decision decision = new Decision(impressionEvent.Experiment?.LayerId,
-                impressionEvent.Experiment?.Id ?? string.Empty,
+                impressionEvent.Experiment?.Id,
                 impressionEvent.Variation?.Id,
                 impressionEvent.Metadata);
 
diff --git a/OptimizelySDK/Event/UserEventFactory.cs b/OptimizelySDK/Event/UserEventFactory.cs
index b56abbbd..339c8e68 100644
--- a/OptimizelySDK/Event/UserEventFactory.cs
+++ b/OptimizelySDK/Event/UserEventFactory.cs
@@ -76,15 +76,15 @@ public static ImpressionEvent CreateImpressionEvent(ProjectConfig projectConfig,
             .WithProjectId(projectConfig.ProjectId)
             .WithAccountId(projectConfig.AccountId)
             .WithAnonymizeIP(projectConfig.AnonymizeIP)
-            .WithRevision(projectConfig.Revision)
+            .WithRevision(projectConfig.Revision)                
             .Build();
 
-            var variationKey = "";
-            var ruleKey = "";
+            var variationKey = ""; 
+            var ruleKey = "";   
             if (variation != null)
             {
                 variationKey = variation.Key;
-                ruleKey = activatedExperiment?.Key ?? string.Empty;
+                ruleKey = activatedExperiment.Key;
             }
             var metadata = new DecisionMetadata(flagKey, ruleKey, ruleType, variationKey, enabled);
 
@@ -97,6 +97,7 @@ public static ImpressionEvent CreateImpressionEvent(ProjectConfig projectConfig,
                 .WithVariation(variation)
                 .WithVisitorAttributes(EventFactory.BuildAttributeList(userAttributes, projectConfig))
                 .Build();
+            
         }
 
         /// <summary>
@@ -108,12 +109,14 @@ public static ImpressionEvent CreateImpressionEvent(ProjectConfig projectConfig,
         /// <param name="userAttributes">The user's attributes</param>
         /// <param name="eventTags">Array Hash representing metadata associated with the event.</param>
         /// <returns>ConversionEvent instance</returns>
-        public static ConversionEvent CreateConversionEvent(ProjectConfig projectConfig,
+        public static ConversionEvent CreateConversionEvent(ProjectConfig projectConfig,                                                            
                                                             string eventKey,
                                                             string userId,
                                                             UserAttributes userAttributes,
                                                             EventTags eventTags)
         {
+            
+
             var eventContext = new EventContext.Builder()
                     .WithProjectId(projectConfig.ProjectId)
                     .WithAccountId(projectConfig.AccountId)
@@ -128,7 +131,7 @@ public static ConversionEvent CreateConversionEvent(ProjectConfig projectConfig,
                 .WithEvent(projectConfig.GetEvent(eventKey))
                 .WithUserId(userId)
                 .WithVisitorAttributes(EventFactory.BuildAttributeList(userAttributes, projectConfig))
-                .Build();
+                .Build();            
         }
     }
 }
diff --git a/OptimizelySDK/ForcedDecisionsStore.cs b/OptimizelySDK/ForcedDecisionsStore.cs
index da0fbac8..7097a121 100644
--- a/OptimizelySDK/ForcedDecisionsStore.cs
+++ b/OptimizelySDK/ForcedDecisionsStore.cs
@@ -74,7 +74,7 @@ public OptimizelyForcedDecision this[OptimizelyDecisionContext context]
         {
             get
             {
-                if (context != null && context.FlagKey != null
+                if (context != null && context.IsValid
                     && ForcedDecisionsMap.TryGetValue(context.GetKey(), out OptimizelyForcedDecision flagForcedDecision))
                 {
                     return flagForcedDecision;
diff --git a/OptimizelySDK/IOptimizely.cs b/OptimizelySDK/IOptimizely.cs
index 24ba3755..836cdb92 100644
--- a/OptimizelySDK/IOptimizely.cs
+++ b/OptimizelySDK/IOptimizely.cs
@@ -13,133 +13,132 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 using OptimizelySDK.Entity;
 using System.Collections.Generic;
 
 namespace OptimizelySDK
 {
-    public interface IOptimizely
-    {
-        /// <summary>
-        /// Returns true if the IOptimizely instance was initialized with a valid datafile
-        /// </summary>
-        bool IsValid { get; }
-
-        /// <summary>
-        /// Buckets visitor and sends impression event to Optimizely.
-        /// </summary>
-        /// <param name="experimentKey">experimentKey string Key identifying the experiment</param>
-        /// <param name="userId">string ID for user</param>
-        /// <param name="userAttributes">associative array of Attributes for the user</param>
-        /// <returns>null|Variation Representing variation</returns>
-        Variation Activate(string experimentKey, string userId, UserAttributes userAttributes = null);
-
-        /// <summary>
-        /// Create a context of the user for which decision APIs will be called.
-        /// A user context will be created successfully even when the SDK is not fully configured yet.
-        /// </summary>
-        /// <param name="userId">The user ID to be used for bucketing.</param>
-        /// <param name="userAttributes">The user's attributes</param>
-        /// <returns>OptimizelyUserContext | An OptimizelyUserContext associated with this OptimizelyClient.</returns>
-        OptimizelyUserContext CreateUserContext(string userId, UserAttributes userAttributes = null);
-
-        /// <summary>
-        /// Sends conversion event to Optimizely.
-        /// </summary>
-        /// <param name="eventKey">Event key representing the event which needs to be recorded</param>
-        /// <param name="userId">ID for user</param>
-        /// <param name="userAttributes">Attributes of the user</param>
-        /// <param name="eventTags">eventTags array Hash representing metadata associated with the event.</param>
-        void Track(string eventKey, string userId, UserAttributes userAttributes = null, EventTags eventTags = null);
-
-        /// <summary>
-        /// Get variation where user will be bucketed
-        /// </summary>
-        /// <param name="experimentKey">experimentKey string Key identifying the experiment</param>
-        /// <param name="userId">ID for the user</param>
-        /// <param name="userAttributes">Attributes for the users</param>
-        /// <returns>null|Variation Representing variation</returns>
-        Variation GetVariation(string experimentKey, string userId, UserAttributes userAttributes = null);
-
-        /// <summary>
-        /// Force a user into a variation for a given experiment.
-        /// </summary>
-        /// <param name="experimentKey">The experiment key</param>
-        /// <param name="userId">The user ID</param>
-        /// <param name="variationKey">The variation key specifies the variation which the user will be forced into.
-        /// If null, then clear the existing experiment-to-variation mapping.</param>
-        /// <returns>A boolean value that indicates if the set completed successfully.</returns>
-        bool SetForcedVariation(string experimentKey, string userId, string variationKey);
-
-        /// <summary>
-        /// Gets the forced variation key for the given user and experiment.
-        /// </summary>
-        /// <param name="experimentKey">The experiment key</param>
-        /// <param name="userId">The user ID</param>
-        /// <returns>null|string The variation key.</returns>
-        Variation GetForcedVariation(string experimentKey, string userId);
-
-        #region FeatureFlag APIs
-
-        /// <summary>
-        /// Determine whether a feature is enabled.
-        /// Send an impression event if the user is bucketed into an experiment using the feature.
-        /// </summary>
-        /// <param name="featureKey">The feature key</param>
-        /// <param name="userId">The user ID</param>
-        /// <param name="userAttributes">The user's attributes.</param>
-        /// <returns>True if feature is enabled, false or null otherwise</returns>
-        bool IsFeatureEnabled(string featureKey, string userId, UserAttributes userAttributes = null);
-
-        /// <summary>
-        /// Gets boolean feature variable value.
-        /// </summary>
-        /// <param name="featureKey">The feature flag key</param>
-        /// <param name="variableKey">The variable key</param>
-        /// <param name="userId">The user ID</param>
-        /// <param name="userAttributes">The user's attributes</param>
-        /// <returns>bool | Feature variable value or null</returns>
-        bool? GetFeatureVariableBoolean(string featureKey, string variableKey, string userId, UserAttributes userAttributes = null);
-
-        /// <summary>
-        /// Gets double feature variable value.
-        /// </summary>
-        /// <param name="featureKey">The feature flag key</param>
-        /// <param name="variableKey">The variable key</param>
-        /// <param name="userId">The user ID</param>
-        /// <param name="userAttributes">The user's attributes</param>
-        /// <returns>double | Feature variable value or null</returns>
-        double? GetFeatureVariableDouble(string featureKey, string variableKey, string userId, UserAttributes userAttributes = null);
-
-        /// <summary>
-        /// Gets integer feature variable value.
-        /// </summary>
-        /// <param name="featureKey">The feature flag key</param>
-        /// <param name="variableKey">The variable key</param>
-        /// <param name="userId">The user ID</param>
-        /// <param name="userAttributes">The user's attributes</param>
-        /// <returns>int | Feature variable value or null</returns>
-        int? GetFeatureVariableInteger(string featureKey, string variableKey, string userId, UserAttributes userAttributes = null);
-
-        /// <summary>
-        /// Gets string feature variable value.
-        /// </summary>
-        /// <param name="featureKey">The feature flag key</param>
-        /// <param name="variableKey">The variable key</param>
-        /// <param name="userId">The user ID</param>
-        /// <param name="userAttributes">The user's attributes</param>
-        /// <returns>string | Feature variable value or null</returns>
-        string GetFeatureVariableString(string featureKey, string variableKey, string userId, UserAttributes userAttributes = null);
-
-        /// <summary>
-        /// Get the list of features that are enabled for the user.
-        /// </summary>
-        /// <param name="userId">The user Id</param>
-        /// <param name="userAttributes">The user's attributes</param>
-        /// <returns>List of the feature keys that are enabled for the user.</returns>
-        List<string> GetEnabledFeatures(string userId, UserAttributes userAttributes = null);
-
-        #endregion FeatureFlag APIs
-    }
+	public interface IOptimizely
+	{
+		/// <summary>
+		/// Returns true if the IOptimizely instance was initialized with a valid datafile
+		/// </summary>
+		bool IsValid { get; }
+
+		/// <summary>
+		/// Buckets visitor and sends impression event to Optimizely.
+		/// </summary>
+		/// <param name="experimentKey">experimentKey string Key identifying the experiment</param>
+		/// <param name="userId">string ID for user</param>
+		/// <param name="userAttributes">associative array of Attributes for the user</param>
+		/// <returns>null|Variation Representing variation</returns>
+		Variation Activate(string experimentKey, string userId, UserAttributes userAttributes = null);
+
+		/// <summary>
+		/// Create a context of the user for which decision APIs will be called.
+		/// A user context will be created successfully even when the SDK is not fully configured yet.
+		/// </summary>
+		/// <param name="userId">The user ID to be used for bucketing.</param>
+		/// <param name="userAttributes">The user's attributes</param>
+		/// <returns>OptimizelyUserContext | An OptimizelyUserContext associated with this OptimizelyClient.</returns>
+		OptimizelyUserContext CreateUserContext(string userId, UserAttributes userAttributes = null);
+
+		/// <summary>
+		/// Sends conversion event to Optimizely.
+		/// </summary>
+		/// <param name="eventKey">Event key representing the event which needs to be recorded</param>
+		/// <param name="userId">ID for user</param>
+		/// <param name="userAttributes">Attributes of the user</param>
+		/// <param name="eventTags">eventTags array Hash representing metadata associated with the event.</param>
+		void Track(string eventKey, string userId, UserAttributes userAttributes = null, EventTags eventTags = null);
+
+		/// <summary>
+		/// Get variation where user will be bucketed
+		/// </summary>
+		/// <param name="experimentKey">experimentKey string Key identifying the experiment</param>
+		/// <param name="userId">ID for the user</param>
+		/// <param name="userAttributes">Attributes for the users</param>
+		/// <returns>null|Variation Representing variation</returns>
+		Variation GetVariation(string experimentKey, string userId, UserAttributes userAttributes = null);
+
+		/// <summary>
+		/// Force a user into a variation for a given experiment.
+		/// </summary>
+		/// <param name="experimentKey">The experiment key</param>
+		/// <param name="userId">The user ID</param>
+		/// <param name="variationKey">The variation key specifies the variation which the user will be forced into.
+		/// If null, then clear the existing experiment-to-variation mapping.</param>
+		/// <returns>A boolean value that indicates if the set completed successfully.</returns>
+		bool SetForcedVariation(string experimentKey, string userId, string variationKey);
+
+		/// <summary>
+		/// Gets the forced variation key for the given user and experiment.  
+		/// </summary>
+		/// <param name="experimentKey">The experiment key</param>
+		/// <param name="userId">The user ID</param>
+		/// <returns>null|string The variation key.</returns>
+		Variation GetForcedVariation(string experimentKey, string userId);
+
+		#region  FeatureFlag APIs
+
+		/// <summary>
+		/// Determine whether a feature is enabled.
+		/// Send an impression event if the user is bucketed into an experiment using the feature.
+		/// </summary>
+		/// <param name="featureKey">The feature key</param>
+		/// <param name="userId">The user ID</param>
+		/// <param name="userAttributes">The user's attributes.</param>
+		/// <returns>True if feature is enabled, false or null otherwise</returns>
+		bool IsFeatureEnabled(string featureKey, string userId, UserAttributes userAttributes = null);
+
+		/// <summary>
+		/// Gets boolean feature variable value.
+		/// </summary>
+		/// <param name="featureKey">The feature flag key</param>
+		/// <param name="variableKey">The variable key</param>
+		/// <param name="userId">The user ID</param>
+		/// <param name="userAttributes">The user's attributes</param>
+		/// <returns>bool | Feature variable value or null</returns>
+		bool? GetFeatureVariableBoolean(string featureKey, string variableKey, string userId, UserAttributes userAttributes = null);
+
+		/// <summary>
+		/// Gets double feature variable value.
+		/// </summary>
+		/// <param name="featureKey">The feature flag key</param>
+		/// <param name="variableKey">The variable key</param>
+		/// <param name="userId">The user ID</param>
+		/// <param name="userAttributes">The user's attributes</param>
+		/// <returns>double | Feature variable value or null</returns>
+		double? GetFeatureVariableDouble(string featureKey, string variableKey, string userId, UserAttributes userAttributes = null);
+
+		/// <summary>
+		/// Gets integer feature variable value.
+		/// </summary>
+		/// <param name="featureKey">The feature flag key</param>
+		/// <param name="variableKey">The variable key</param>
+		/// <param name="userId">The user ID</param>
+		/// <param name="userAttributes">The user's attributes</param>
+		/// <returns>int | Feature variable value or null</returns>
+		int? GetFeatureVariableInteger(string featureKey, string variableKey, string userId, UserAttributes userAttributes = null);
+
+		/// <summary>
+		/// Gets string feature variable value.
+		/// </summary>
+		/// <param name="featureKey">The feature flag key</param>
+		/// <param name="variableKey">The variable key</param>
+		/// <param name="userId">The user ID</param>
+		/// <param name="userAttributes">The user's attributes</param>
+		/// <returns>string | Feature variable value or null</returns>
+		string GetFeatureVariableString(string featureKey, string variableKey, string userId, UserAttributes userAttributes = null);
+
+		/// <summary>
+		/// Get the list of features that are enabled for the user.
+		/// </summary>
+		/// <param name="userId">The user Id</param>
+		/// <param name="userAttributes">The user's attributes</param>
+		/// <returns>List of the feature keys that are enabled for the user.</returns>
+		List<string> GetEnabledFeatures(string userId, UserAttributes userAttributes = null);
+
+		#endregion
+	}
 }
diff --git a/OptimizelySDK/Optimizely.cs b/OptimizelySDK/Optimizely.cs
index a7265fa7..54211345 100644
--- a/OptimizelySDK/Optimizely.cs
+++ b/OptimizelySDK/Optimizely.cs
@@ -69,10 +69,8 @@ public class Optimizely : IOptimizely, IDisposable
         /// It returns true if the ProjectConfig is valid otherwise false.
         /// Also, it may block execution if GetConfig() blocks execution to get ProjectConfig.
         /// </summary>
-        public bool IsValid
-        {
-            get
-            {
+        public bool IsValid {
+            get {
                 return ProjectConfigManager?.GetConfig() != null;
             }
         }
@@ -130,22 +128,17 @@ public Optimizely(string datafile,
                           EventProcessor eventProcessor = null,
                           OptimizelyDecideOption[] defaultDecideOptions = null)
         {
-            try
-            {
+            try {
                 InitializeComponents(eventDispatcher, logger, errorHandler, userProfileService, null, eventProcessor, defaultDecideOptions);
 
-                if (ValidateInputs(datafile, skipJsonValidation))
-                {
+                if (ValidateInputs(datafile, skipJsonValidation)) {
                     var config = DatafileProjectConfig.Create(datafile, Logger, ErrorHandler);
                     ProjectConfigManager = new FallbackProjectConfigManager(config);
-                }
-                else
-                {
+                } else {
                     Logger.Log(LogLevel.ERROR, "Provided 'datafile' has invalid schema.");
                 }
             }
-            catch (Exception ex)
-            {
+            catch (Exception ex) {
                 string error = String.Empty;
                 if (ex.GetType() == typeof(ConfigParseException))
                     error = ex.Message;
diff --git a/OptimizelySDK/OptimizelyDecisionContext.cs b/OptimizelySDK/OptimizelyDecisionContext.cs
index d487483b..24842d14 100644
--- a/OptimizelySDK/OptimizelyDecisionContext.cs
+++ b/OptimizelySDK/OptimizelyDecisionContext.cs
@@ -29,11 +29,26 @@ public class OptimizelyDecisionContext
         private string ruleKey;
         private string decisionKey;
 
+        /// <summary>
+        /// Represents the object is valid or not.
+        /// </summary>
+        public bool IsValid { get; private set; }
+
+        /// <summary>
+        /// Flag key of the context.
+        /// </summary>
         public string FlagKey { get { return flagKey; } }
+
+        /// <summary>
+        /// Rule key, it can be experiment or rollout key and nullable.
+        /// </summary>
         public string RuleKey { get { return ruleKey; } }
 
         public OptimizelyDecisionContext(string flagKey, string ruleKey= null)
         {
+            if (flagKey != null) {
+                IsValid = true;
+            }
             this.flagKey = flagKey;
             this.ruleKey = ruleKey;
         }
diff --git a/OptimizelySDK/OptimizelyForcedDecision.cs b/OptimizelySDK/OptimizelyForcedDecision.cs
index 49b45dde..83d2901f 100644
--- a/OptimizelySDK/OptimizelyForcedDecision.cs
+++ b/OptimizelySDK/OptimizelyForcedDecision.cs
@@ -1,5 +1,5 @@
 /*
- * Copyright 2020-2021, Optimizely
+ * Copyright 2021, Optimizely
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -22,7 +22,7 @@ public class OptimizelyForcedDecision
 
         public OptimizelyForcedDecision(string variationKey)
         {
-            this._variationKey = variationKey;
+            _variationKey = variationKey;
         }
 
         public string VariationKey { get { return _variationKey; } }
diff --git a/OptimizelySDK/OptimizelyUserContext.cs b/OptimizelySDK/OptimizelyUserContext.cs
index 9e7b0ac8..fe72338d 100644
--- a/OptimizelySDK/OptimizelyUserContext.cs
+++ b/OptimizelySDK/OptimizelyUserContext.cs
@@ -247,7 +247,7 @@ public bool SetForcedDecision(OptimizelyDecisionContext context, OptimizelyForce
         /// <returns>The variation key for a forced decision</returns>
         public OptimizelyForcedDecision GetForcedDecision(OptimizelyDecisionContext context)
         {
-            if (context == null || context.FlagKey == null)
+            if (context == null || !context.IsValid)
             {
                 Logger.Log(LogLevel.WARN, "flagKey cannot be null");
                 return null;
@@ -274,7 +274,7 @@ public OptimizelyForcedDecision GetForcedDecision(OptimizelyDecisionContext cont
         /// <returns>Whether the item was removed.</returns>
         public bool RemoveForcedDecision(OptimizelyDecisionContext context)
         {
-            if (context == null || context.FlagKey == null)
+            if (context == null || !context.IsValid)
             {
                 Logger.Log(LogLevel.WARN, "FlagKey cannot be null");
                 return false;

From 0d46ef7f631fb8b06bda7f5ee0180db6a8f1e83e Mon Sep 17 00:00:00 2001
From: muhammadnoman <muhammadnoman@folio3.com>
Date: Mon, 6 Dec 2021 20:40:29 +0500
Subject: [PATCH 123/130] Fixed null experiment check

---
 OptimizelySDK/Event/Builder/EventBuilder.cs | 6 +++---
 OptimizelySDK/Event/EventFactory.cs         | 4 +---
 2 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/OptimizelySDK/Event/Builder/EventBuilder.cs b/OptimizelySDK/Event/Builder/EventBuilder.cs
index 0f0b41b8..f6106540 100644
--- a/OptimizelySDK/Event/Builder/EventBuilder.cs
+++ b/OptimizelySDK/Event/Builder/EventBuilder.cs
@@ -130,8 +130,8 @@ private Dictionary<string, object> GetImpressionParams(Experiment experiment, st
             {
                     new Dictionary<string, object>
                     {
-                        { Params.CAMPAIGN_ID,   experiment.LayerId },
-                        { Params.EXPERIMENT_ID, experiment.Id },
+                        { Params.CAMPAIGN_ID,   experiment?.LayerId },
+                        { Params.EXPERIMENT_ID, experiment?.Id ?? string.Empty },
                         { Params.VARIATION_ID,  variationId }
                     }
             };
@@ -141,7 +141,7 @@ private Dictionary<string, object> GetImpressionParams(Experiment experiment, st
             {
                     new Dictionary<string, object>
                     {
-                        { "entity_id", experiment.LayerId },
+                        { "entity_id", experiment?.LayerId },
                         { "timestamp", DateTimeUtils.SecondsSince1970*1000 },
                         { "key", ACTIVATE_EVENT_KEY },
                         { "uuid", Guid.NewGuid() }
diff --git a/OptimizelySDK/Event/EventFactory.cs b/OptimizelySDK/Event/EventFactory.cs
index 63482a8b..e0981651 100644
--- a/OptimizelySDK/Event/EventFactory.cs
+++ b/OptimizelySDK/Event/EventFactory.cs
@@ -111,10 +111,8 @@ private static Visitor CreateVisitor(ImpressionEvent impressionEvent) {
                 return null;
             }
 
-            var eventContext = impressionEvent.Context;
-
             Decision decision = new Decision(impressionEvent.Experiment?.LayerId,
-                impressionEvent.Experiment?.Id,
+                impressionEvent.Experiment?.Id ?? string.Empty,
                 impressionEvent.Variation?.Id,
                 impressionEvent.Metadata);
 

From de95a2c1b68519d8b20fe19ef6965396e009960a Mon Sep 17 00:00:00 2001
From: muhammadnoman <muhammadnoman@folio3.com>
Date: Mon, 6 Dec 2021 20:52:16 +0500
Subject: [PATCH 124/130] Null exception fixed

---
 OptimizelySDK/Event/UserEventFactory.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/OptimizelySDK/Event/UserEventFactory.cs b/OptimizelySDK/Event/UserEventFactory.cs
index 339c8e68..c601b033 100644
--- a/OptimizelySDK/Event/UserEventFactory.cs
+++ b/OptimizelySDK/Event/UserEventFactory.cs
@@ -84,7 +84,7 @@ public static ImpressionEvent CreateImpressionEvent(ProjectConfig projectConfig,
             if (variation != null)
             {
                 variationKey = variation.Key;
-                ruleKey = activatedExperiment.Key;
+                ruleKey = activatedExperiment?.Key ?? string.Empty;
             }
             var metadata = new DecisionMetadata(flagKey, ruleKey, ruleType, variationKey, enabled);
 

From 0063e26bdbb5bbb09a844295211336b0c083cfca Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Tue, 7 Dec 2021 08:15:24 -0500
Subject: [PATCH 125/130] Cleanup from pr comments

---
 OptimizelySDK/Bucketing/DecisionService.cs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/OptimizelySDK/Bucketing/DecisionService.cs b/OptimizelySDK/Bucketing/DecisionService.cs
index feef3ab6..3f67b897 100644
--- a/OptimizelySDK/Bucketing/DecisionService.cs
+++ b/OptimizelySDK/Bucketing/DecisionService.cs
@@ -125,6 +125,7 @@ public virtual Result<Variation> GetVariation(Experiment experiment,
 
             if (variation != null)
             {
+                decisionVariation.SetReasons(reasons);
                 return decisionVariation;
             }
 

From 85b00ffad8a0d71ee8ce92448b9b2a48174d96b0 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Tue, 7 Dec 2021 08:44:00 -0500
Subject: [PATCH 126/130] added reason

---
 OptimizelySDK/Bucketing/DecisionService.cs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/OptimizelySDK/Bucketing/DecisionService.cs b/OptimizelySDK/Bucketing/DecisionService.cs
index d0c6177c..c82d2d07 100644
--- a/OptimizelySDK/Bucketing/DecisionService.cs
+++ b/OptimizelySDK/Bucketing/DecisionService.cs
@@ -124,6 +124,7 @@ public virtual Result<Variation> GetVariation(Experiment experiment,
 
             if (variation != null)
             {
+                decisionVariationResult.SetReasons(reasons);
                 return decisionVariationResult;
             }
 

From 0dccc30751b4d03df0b4c6608b313a731f1e6c39 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Tue, 7 Dec 2021 08:44:51 -0500
Subject: [PATCH 127/130] added elvis operator

---
 OptimizelySDK/Optimizely.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/OptimizelySDK/Optimizely.cs b/OptimizelySDK/Optimizely.cs
index 54211345..f1a1cef0 100644
--- a/OptimizelySDK/Optimizely.cs
+++ b/OptimizelySDK/Optimizely.cs
@@ -747,7 +747,7 @@ internal OptimizelyDecision Decide(OptimizelyUserContext user,
             }
 
             var userId = user?.GetUserId();
-            var userAttributes = user.GetAttributes();
+            var userAttributes = user?.GetAttributes();
             var decisionEventDispatched = false;
             var allOptions = GetAllOptions(options);
             var decisionReasons = new DecisionReasons();

From a829f600b23fe304449cfd273fcca683e032af6c Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Tue, 7 Dec 2021 08:45:27 -0500
Subject: [PATCH 128/130] cleaned up ternary

---
 OptimizelySDK/Optimizely.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/OptimizelySDK/Optimizely.cs b/OptimizelySDK/Optimizely.cs
index f1a1cef0..6874b6c1 100644
--- a/OptimizelySDK/Optimizely.cs
+++ b/OptimizelySDK/Optimizely.cs
@@ -825,7 +825,7 @@ internal OptimizelyDecision Decide(OptimizelyUserContext user,
             var variationKey = decision?.Variation?.Key;
 
             // TODO: add ruleKey values when available later. use a copy of experimentKey until then.
-            var ruleKey = decision != null && decision.Experiment != null ? decision?.Experiment?.Key : null;
+            var ruleKey = decision?.Experiment?.Key;
 
             var decisionInfo = new Dictionary<string, object>
             {

From e43898f617188fa366cdc8906b970e319927ed67 Mon Sep 17 00:00:00 2001
From: muhammadnoman <muhammadnoman@folio3.com>
Date: Tue, 7 Dec 2021 19:17:13 +0500
Subject: [PATCH 129/130] fixed eventValue typo

---
 OptimizelySDK/Event/Builder/EventBuilder.cs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/OptimizelySDK/Event/Builder/EventBuilder.cs b/OptimizelySDK/Event/Builder/EventBuilder.cs
index f6106540..fd08d327 100644
--- a/OptimizelySDK/Event/Builder/EventBuilder.cs
+++ b/OptimizelySDK/Event/Builder/EventBuilder.cs
@@ -175,10 +175,10 @@ private List<object> GetConversionParams(ProjectConfig config, string eventKey,
                     eventDict[EventTagUtils.REVENUE_EVENT_METRIC_NAME] = revenue;
                 }
 
-                var eventVallue = EventTagUtils.GetNumericValue(eventTags, Logger);
+                var eventValue = EventTagUtils.GetNumericValue(eventTags, Logger);
 
-                if (eventVallue != null) {
-                    eventDict[EventTagUtils.VALUE_EVENT_METRIC_NAME] = eventVallue;
+                if (eventValue != null) {
+                    eventDict[EventTagUtils.VALUE_EVENT_METRIC_NAME] = eventValue;
                 }
 
                 if (eventTags.Any())

From 0ac3dbedde15319e81b831fa0f6b1a855a622183 Mon Sep 17 00:00:00 2001
From: dustin-sier <dustin.sier@optimizely.com>
Date: Tue, 7 Dec 2021 15:02:06 -0500
Subject: [PATCH 130/130] trying to force a build

---
 OptimizelySDK/Optimizely.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/OptimizelySDK/Optimizely.cs b/OptimizelySDK/Optimizely.cs
index 6874b6c1..974a0361 100644
--- a/OptimizelySDK/Optimizely.cs
+++ b/OptimizelySDK/Optimizely.cs
@@ -835,7 +835,7 @@ internal OptimizelyDecision Decide(OptimizelyUserContext user,
                 { "variationKey", variationKey },
                 { "ruleKey", ruleKey },
                 { "reasons", reasonsToReport },
-                { "decisionEventDispatched", decisionEventDispatched }
+                { "decisionEventDispatched", decisionEventDispatched } 
             };
 
             NotificationCenter.SendNotifications(NotificationCenter.NotificationType.Decision, DecisionNotificationTypes.FLAG, userId,