[FSSDK-11544] test coverage

Author: junaed-optimizely

OptimizelySDK.Tests/EntityTests/HoldoutTests.cs

@@ -0,0 +1,196 @@
+/*
+ * Copyright 2025, 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;
+using System.IO;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using NUnit.Framework;
+using OptimizelySDK.Entity;
+
+namespace OptimizelySDK.Tests
+{
+    [TestFixture]
+    public class HoldoutTests
+    {
+        private JObject testData;
+
+        [SetUp]
+        public void Setup()
+        {
+            // Load test data
+            var testDataPath = Path.Combine(TestContext.CurrentContext.TestDirectory, 
+                "TestData", "HoldoutTestData.json");
+            var jsonContent = File.ReadAllText(testDataPath);
+            testData = JObject.Parse(jsonContent);
+        }
+
+        [Test]
+        public void TestHoldoutDeserialization()
+        {
+            // Test global holdout deserialization
+            var globalHoldoutJson = testData["globalHoldout"].ToString();
+            var globalHoldout = JsonConvert.DeserializeObject<Holdout>(globalHoldoutJson);
+
+            Assert.IsNotNull(globalHoldout);
+            Assert.AreEqual("holdout_global_1", globalHoldout.Id);
+            Assert.AreEqual("global_holdout", globalHoldout.Key);
+            Assert.AreEqual("Running", globalHoldout.Status);
+            Assert.AreEqual("layer_1", globalHoldout.LayerId);
+            Assert.IsNotNull(globalHoldout.Variations);
+            Assert.AreEqual(1, globalHoldout.Variations.Length);
+            Assert.IsNotNull(globalHoldout.TrafficAllocation);
+            Assert.AreEqual(1, globalHoldout.TrafficAllocation.Length);
+            Assert.IsNotNull(globalHoldout.IncludedFlags);
+            Assert.AreEqual(0, globalHoldout.IncludedFlags.Length);
+            Assert.IsNotNull(globalHoldout.ExcludedFlags);
+            Assert.AreEqual(0, globalHoldout.ExcludedFlags.Length);
+        }
+
+        [Test]
+        public void TestHoldoutWithIncludedFlags()
+        {
+            var includedHoldoutJson = testData["includedFlagsHoldout"].ToString();
+            var includedHoldout = JsonConvert.DeserializeObject<Holdout>(includedHoldoutJson);
+
+            Assert.IsNotNull(includedHoldout);
+            Assert.AreEqual("holdout_included_1", includedHoldout.Id);
+            Assert.AreEqual("included_holdout", includedHoldout.Key);
+            Assert.IsNotNull(includedHoldout.IncludedFlags);
+            Assert.AreEqual(2, includedHoldout.IncludedFlags.Length);
+            Assert.Contains("flag_1", includedHoldout.IncludedFlags);
+            Assert.Contains("flag_2", includedHoldout.IncludedFlags);
+            Assert.IsNotNull(includedHoldout.ExcludedFlags);
+            Assert.AreEqual(0, includedHoldout.ExcludedFlags.Length);
+        }
+
+        [Test]
+        public void TestHoldoutWithExcludedFlags()
+        {
+            var excludedHoldoutJson = testData["excludedFlagsHoldout"].ToString();
+            var excludedHoldout = JsonConvert.DeserializeObject<Holdout>(excludedHoldoutJson);
+
+            Assert.IsNotNull(excludedHoldout);
+            Assert.AreEqual("holdout_excluded_1", excludedHoldout.Id);
+            Assert.AreEqual("excluded_holdout", excludedHoldout.Key);
+            Assert.IsNotNull(excludedHoldout.IncludedFlags);
+            Assert.AreEqual(0, excludedHoldout.IncludedFlags.Length);
+            Assert.IsNotNull(excludedHoldout.ExcludedFlags);
+            Assert.AreEqual(2, excludedHoldout.ExcludedFlags.Length);
+            Assert.Contains("flag_3", excludedHoldout.ExcludedFlags);
+            Assert.Contains("flag_4", excludedHoldout.ExcludedFlags);
+        }
+
+        [Test]
+        public void TestHoldoutWithEmptyFlags()
+        {
+            var globalHoldoutJson = testData["globalHoldout"].ToString();
+            var globalHoldout = JsonConvert.DeserializeObject<Holdout>(globalHoldoutJson);
+
+            Assert.IsNotNull(globalHoldout);
+            Assert.IsNotNull(globalHoldout.IncludedFlags);
+            Assert.AreEqual(0, globalHoldout.IncludedFlags.Length);
+            Assert.IsNotNull(globalHoldout.ExcludedFlags);
+            Assert.AreEqual(0, globalHoldout.ExcludedFlags.Length);
+        }
+
+        [Test]
+        public void TestHoldoutEquality()
+        {
+            var holdoutJson = testData["globalHoldout"].ToString();
+            var holdout1 = JsonConvert.DeserializeObject<Holdout>(holdoutJson);
+            var holdout2 = JsonConvert.DeserializeObject<Holdout>(holdoutJson);
+
+            Assert.IsNotNull(holdout1);
+            Assert.IsNotNull(holdout2);
+            // Note: This test depends on how Holdout implements equality
+            // If Holdout doesn't override Equals, this will test reference equality
+            // You may need to implement custom equality logic for Holdout
+        }
+
+        [Test]
+        public void TestHoldoutStatusParsing()
+        {
+            var globalHoldoutJson = testData["globalHoldout"].ToString();
+            var globalHoldout = JsonConvert.DeserializeObject<Holdout>(globalHoldoutJson);
+
+            Assert.IsNotNull(globalHoldout);
+            Assert.AreEqual("Running", globalHoldout.Status);
+            
+            // Test that the holdout is considered activated when status is "Running"
+            // This assumes there's an IsActivated property or similar logic
+            // Adjust based on actual Holdout implementation
+        }
+
+        [Test]
+        public void TestHoldoutVariationsDeserialization()
+        {
+            var holdoutJson = testData["includedFlagsHoldout"].ToString();
+            var holdout = JsonConvert.DeserializeObject<Holdout>(holdoutJson);
+
+            Assert.IsNotNull(holdout);
+            Assert.IsNotNull(holdout.Variations);
+            Assert.AreEqual(1, holdout.Variations.Length);
+            
+            var variation = holdout.Variations[0];
+            Assert.AreEqual("var_2", variation.Id);
+            Assert.AreEqual("treatment", variation.Key);
+            Assert.AreEqual(true, variation.FeatureEnabled);
+        }
+
+        [Test]
+        public void TestHoldoutTrafficAllocationDeserialization()
+        {
+            var holdoutJson = testData["excludedFlagsHoldout"].ToString();
+            var holdout = JsonConvert.DeserializeObject<Holdout>(holdoutJson);
+
+            Assert.IsNotNull(holdout);
+            Assert.IsNotNull(holdout.TrafficAllocation);
+            Assert.AreEqual(1, holdout.TrafficAllocation.Length);
+            
+            var trafficAllocation = holdout.TrafficAllocation[0];
+            Assert.AreEqual("var_3", trafficAllocation.EntityId);
+            Assert.AreEqual(10000, trafficAllocation.EndOfRange);
+        }
+
+        [Test]
+        public void TestHoldoutNullSafety()
+        {
+            // Test that holdout can handle null/missing includedFlags and excludedFlags
+            var minimalHoldoutJson = @"{
+                ""id"": ""test_holdout"",
+                ""key"": ""test_key"",
+                ""status"": ""Running"",
+                ""layerId"": ""test_layer"",
+                ""variations"": [],
+                ""trafficAllocation"": [],
+                ""audienceIds"": [],
+                ""audienceConditions"": []
+            }";
+
+            var holdout = JsonConvert.DeserializeObject<Holdout>(minimalHoldoutJson);
+
+            Assert.IsNotNull(holdout);
+            Assert.AreEqual("test_holdout", holdout.Id);
+            Assert.AreEqual("test_key", holdout.Key);
+            
+            // Verify that missing includedFlags and excludedFlags are handled properly
+            // This depends on how the Holdout entity handles missing properties
+            Assert.IsNotNull(holdout.IncludedFlags);
+            Assert.IsNotNull(holdout.ExcludedFlags);
+        }
+    }
+}

OptimizelySDK.Tests/OptimizelySDK.Tests.csproj

@@ -119,19 +119,24 @@
     <Compile Include="ValidEventDispatcher.cs"/>
     <Compile Include="ConfigTest\TestPollingProjectConfigManager.cs"/>
     <Compile Include="EntityTests\FeatureVariableTest.cs"/>
+    <Compile Include="EntityTests\HoldoutTests.cs"/>
     <Compile Include="EventTests\EventEntitiesTest.cs"/>
     <Compile Include="EventTests\UserEventFactoryTest.cs"/>
     <Compile Include="EventTests\EventFactoryTest.cs"/>
     <Compile Include="EventTests\CanonicalEvent.cs"/>
     <Compile Include="OptimizelyFactoryTest.cs"/>
     <Compile Include="Utils\TestData.cs"/>
     <Compile Include="Utils\Reflection.cs"/>
+    <Compile Include="UtilsTests\HoldoutConfigTests.cs"/>
     <Compile Include="ConfigTest\ProjectConfigProps.cs"/>
     <Compile Include="Utils\TestHttpProjectConfigManagerUtil.cs"/>
   </ItemGroup>
   <ItemGroup>
     <Content Include="App.config"/>
     <EmbeddedResource Include="OdpSegmentsDatafile.json"/>
+    <Content Include="TestData\HoldoutTestData.json">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
   </ItemGroup>
   <ItemGroup>
     <EmbeddedResource Include="IntegrationEmptyDatafile.json"/>

OptimizelySDK.Tests/ProjectConfigTest.cs

@@ -16,6 +16,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using Moq;
 using Newtonsoft.Json;
@@ -1351,5 +1352,121 @@ public void TestProjectConfigWithOtherIntegrationsInCollection()
             Assert.IsNull(datafileProjectConfig.HostForOdp);
             Assert.IsNull(datafileProjectConfig.PublicKeyForOdp);
         }
+
+        #region Holdout Integration Tests
+
+        [Test]
+        public void TestHoldoutDeserialization_FromDatafile()
+        {
+            // Test that holdouts can be deserialized from a datafile with holdouts
+            var testDataPath = Path.Combine(TestContext.CurrentContext.TestDirectory, 
+                "TestData", "HoldoutTestData.json");
+            var jsonContent = File.ReadAllText(testDataPath);
+            var testData = JObject.Parse(jsonContent);
+            
+            var datafileJson = testData["datafileWithHoldouts"].ToString();
+            
+            var datafileProjectConfig = DatafileProjectConfig.Create(datafileJson, 
+                new NoOpLogger(), new NoOpErrorHandler()) as DatafileProjectConfig;
+
+            Assert.IsNotNull(datafileProjectConfig.Holdouts);
+            Assert.AreEqual(3, datafileProjectConfig.Holdouts.Length);
+            Assert.IsNotNull(datafileProjectConfig.HoldoutIdMap);
+            Assert.AreEqual(3, datafileProjectConfig.HoldoutIdMap.Count);
+
+            // Verify specific holdouts are present
+            Assert.IsTrue(datafileProjectConfig.HoldoutIdMap.ContainsKey("holdout_global_1"));
+            Assert.IsTrue(datafileProjectConfig.HoldoutIdMap.ContainsKey("holdout_included_1"));
+            Assert.IsTrue(datafileProjectConfig.HoldoutIdMap.ContainsKey("holdout_excluded_1"));
+        }
+
+        [Test]
+        public void TestGetHoldoutsForFlag_Integration()
+        {
+            var testDataPath = Path.Combine(TestContext.CurrentContext.TestDirectory, 
+                "TestData", "HoldoutTestData.json");
+            var jsonContent = File.ReadAllText(testDataPath);
+            var testData = JObject.Parse(jsonContent);
+            
+            var datafileJson = testData["datafileWithHoldouts"].ToString();
+            
+            var datafileProjectConfig = DatafileProjectConfig.Create(datafileJson, 
+                new NoOpLogger(), new NoOpErrorHandler()) as DatafileProjectConfig;
+
+            // Test GetHoldoutsForFlag method
+            var holdoutsForFlag1 = datafileProjectConfig.GetHoldoutsForFlag("flag_1");
+            Assert.IsNotNull(holdoutsForFlag1);
+            Assert.AreEqual(3, holdoutsForFlag1.Length); // Global + excluded holdout (applies to all except flag_3/flag_4) + included holdout
+
+            var holdoutsForFlag3 = datafileProjectConfig.GetHoldoutsForFlag("flag_3");
+            Assert.IsNotNull(holdoutsForFlag3);
+            Assert.AreEqual(1, holdoutsForFlag3.Length); // Only true global (excluded holdout excludes flag_3)
+
+            var holdoutsForUnknownFlag = datafileProjectConfig.GetHoldoutsForFlag("unknown_flag");
+            Assert.IsNotNull(holdoutsForUnknownFlag);
+            Assert.AreEqual(2, holdoutsForUnknownFlag.Length); // Global + excluded holdout (unknown_flag not in excluded list)
+        }
+
+        [Test]
+        public void TestGetHoldout_Integration()
+        {
+            var testDataPath = Path.Combine(TestContext.CurrentContext.TestDirectory, 
+                "TestData", "HoldoutTestData.json");
+            var jsonContent = File.ReadAllText(testDataPath);
+            var testData = JObject.Parse(jsonContent);
+            
+            var datafileJson = testData["datafileWithHoldouts"].ToString();
+            
+            var datafileProjectConfig = DatafileProjectConfig.Create(datafileJson, 
+                new NoOpLogger(), new NoOpErrorHandler()) as DatafileProjectConfig;
+
+            // Test GetHoldout method
+            var globalHoldout = datafileProjectConfig.GetHoldout("holdout_global_1");
+            Assert.IsNotNull(globalHoldout);
+            Assert.AreEqual("holdout_global_1", globalHoldout.Id);
+            Assert.AreEqual("global_holdout", globalHoldout.Key);
+
+            var invalidHoldout = datafileProjectConfig.GetHoldout("invalid_id");
+            Assert.IsNotNull(invalidHoldout);
+            Assert.AreEqual("", invalidHoldout.Id); // Dummy holdout has empty ID
+        }
+
+        [Test]
+        public void TestMissingHoldoutsField_BackwardCompatibility()
+        {
+            // Test that a datafile without holdouts field still works
+            var datafileWithoutHoldouts = @"{
+                ""version"": ""4"",
+                ""rollouts"": [],
+                ""projectId"": ""test_project"",
+                ""experiments"": [],
+                ""groups"": [],
+                ""attributes"": [],
+                ""audiences"": [],
+                ""layers"": [],
+                ""events"": [],
+                ""revision"": ""1"",
+                ""featureFlags"": []
+            }";
+
+            var datafileProjectConfig = DatafileProjectConfig.Create(datafileWithoutHoldouts, 
+                new NoOpLogger(), new NoOpErrorHandler()) as DatafileProjectConfig;
+
+            Assert.IsNotNull(datafileProjectConfig.Holdouts);
+            Assert.AreEqual(0, datafileProjectConfig.Holdouts.Length);
+            Assert.IsNotNull(datafileProjectConfig.HoldoutIdMap);
+            Assert.AreEqual(0, datafileProjectConfig.HoldoutIdMap.Count);
+
+            // Methods should still work with empty holdouts
+            var holdouts = datafileProjectConfig.GetHoldoutsForFlag("any_flag");
+            Assert.IsNotNull(holdouts);
+            Assert.AreEqual(0, holdouts.Length);
+
+            var holdout = datafileProjectConfig.GetHoldout("any_id");
+            Assert.IsNotNull(holdout);
+            Assert.AreEqual("", holdout.Id); // Dummy holdout has empty ID
+        }
+
+        #endregion
     }
 }