feat: Added ODPSegmentManager

OptimizelySDK.Tests/OdpTests/OdpSegmentManagerTest.cs

@@ -0,0 +1,213 @@
+/* 
+ * Copyright 2022 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
+ *
+ * https://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 Moq;
+using NUnit.Framework;
+using OptimizelySDK.AudienceConditions;
+using OptimizelySDK.ErrorHandler;
+using OptimizelySDK.Logger;
+using OptimizelySDK.Odp;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+
+namespace OptimizelySDK.Tests.OdpTests
+{
+    [TestFixture]
+    public class OdpSegmentManagerTest
+    {
+        private const string API_KEY = "S0m3Ap1KEy4U";
+        private const string API_HOST = "https://odp-host.example.com";
+        private const string FS_USER_ID = "some_valid_user_id";
+
+        private static readonly string expectedCacheKey = $"fs_user_id-$-{FS_USER_ID}";
+
+        private static readonly List<string> segmentsToCheck = new List<string>
+        {
+            "segment1",
+            "segment2",
+        };
+
+        private OdpConfig _odpConfig;
+        private Mock<IOdpSegmentApiManager> _mockApiManager;
+        private Mock<ILogger> _mockLogger;
+        private Mock<ICache<List<string>>> _mockCache;
+
+        [SetUp]
+        public void Setup()
+        {
+            _odpConfig = new OdpConfig(API_KEY, API_HOST, segmentsToCheck);
+
+            _mockApiManager = new Mock<IOdpSegmentApiManager>();
+
+            _mockLogger = new Mock<ILogger>();
+            _mockLogger.Setup(i => i.Log(It.IsAny<LogLevel>(), It.IsAny<string>()));
+
+            _mockCache = new Mock<ICache<List<string>>>();
+        }
+
+        [Test]
+        public void ShouldFetchSegmentsOnCacheMiss()
+        {
+            var keyCollector = new List<string>();
+            _mockCache.Setup(c => c.Lookup(Capture.In(keyCollector)))
+                .Returns(default(List<string>));
+            _mockApiManager.Setup(a => a.FetchSegments(It.IsAny<string>(), It.IsAny<string>(),
+                    It.IsAny<OdpUserKeyType>(), It.IsAny<string>(), It.IsAny<List<string>>()))
+                .Returns(segmentsToCheck.ToArray());
+            var manager = new OdpSegmentManager(_odpConfig, _mockApiManager.Object,
+                Constants.DEFAULT_MAX_CACHE_SIZE, null, _mockLogger.Object, _mockCache.Object);
+
+            var segments = manager.FetchQualifiedSegments(FS_USER_ID);
+
+            var cacheKey = keyCollector.FirstOrDefault();
+            Assert.AreEqual(expectedCacheKey, cacheKey);
+            _mockCache.Verify(c => c.Reset(), Times.Never);
+            _mockCache.Verify(c => c.Lookup(cacheKey), Times.Once);
+            _mockLogger.Verify(l =>
+                l.Log(LogLevel.DEBUG, "ODP Cache Miss. Making a call to ODP Server."), Times.Once);
+            _mockApiManager.Verify(
+                a => a.FetchSegments(
+                    API_KEY,
+                    API_HOST,
+                    OdpUserKeyType.FS_USER_ID,
+                    FS_USER_ID,
+                    _odpConfig.SegmentsToCheck), Times.Once);
+            _mockCache.Verify(c => c.Save(cacheKey, It.IsAny<List<string>>()), Times.Once);
+            Assert.AreEqual(segmentsToCheck, segments);
+        }
+
+        [Test]
+        public void ShouldFetchSegmentsSuccessOnCacheHit()
+        {
+            var keyCollector = new List<string>();
+            _mockCache.Setup(c => c.Lookup(Capture.In(keyCollector)))
+                .Returns(segmentsToCheck);
+            _mockApiManager.Setup(a => a.FetchSegments(It.IsAny<string>(), It.IsAny<string>(),
+                It.IsAny<OdpUserKeyType>(), It.IsAny<string>(), It.IsAny<List<string>>()));
+            var manager = new OdpSegmentManager(_odpConfig, _mockApiManager.Object,
+                Constants.DEFAULT_MAX_CACHE_SIZE, null, _mockLogger.Object, _mockCache.Object);
+
+            var segments = manager.FetchQualifiedSegments(FS_USER_ID);
+
+            var cacheKey = keyCollector.FirstOrDefault();
+            Assert.AreEqual(expectedCacheKey, cacheKey);
+            _mockCache.Verify(c => c.Reset(), Times.Never);
+            _mockCache.Verify(c => c.Lookup(cacheKey), Times.Once);
+            _mockLogger.Verify(l =>
+                l.Log(LogLevel.DEBUG, "ODP Cache Hit. Returning segments from Cache."), Times.Once);
+            _mockApiManager.Verify(
+                a => a.FetchSegments(It.IsAny<string>(), It.IsAny<string>(),
+                    It.IsAny<OdpUserKeyType>(), It.IsAny<string>(), It.IsAny<List<string>>()),
+                Times.Never);
+            _mockCache.Verify(c => c.Save(expectedCacheKey, It.IsAny<List<string>>()), Times.Never);
+            Assert.AreEqual(segmentsToCheck, segments);
+        }
+
+        [Test]
+        public void ShouldHandleFetchSegmentsWithError()
+        {
+            // OdpSegmentApiManager.FetchSegments() return null on any error
+            _mockApiManager.Setup(a => a.FetchSegments(It.IsAny<string>(), It.IsAny<string>(),
+                    It.IsAny<OdpUserKeyType>(), It.IsAny<string>(), It.IsAny<List<string>>()))
+                .Returns(null as string[]);
+            var manager = new OdpSegmentManager(_odpConfig, _mockApiManager.Object,
+                Constants.DEFAULT_MAX_CACHE_SIZE, null, _mockLogger.Object, _mockCache.Object);
+
+            var segments = manager.FetchQualifiedSegments(FS_USER_ID);
+
+            _mockCache.Verify(c => c.Reset(), Times.Never);
+            _mockCache.Verify(c => c.Lookup(expectedCacheKey), Times.Once);
+            _mockApiManager.Verify(
+                a => a.FetchSegments(It.IsAny<string>(), It.IsAny<string>(),
+                    It.IsAny<OdpUserKeyType>(), It.IsAny<string>(), It.IsAny<List<string>>()),
+                Times.Once);
+            _mockCache.Verify(c => c.Save(expectedCacheKey, It.IsAny<List<string>>()), Times.Once);
+            Assert.IsNull(segments);
+        }
+
+        [Test]
+        public void ShouldLogAndReturnNullWhenWhenOdpConfigNotReady()
+        {
+            var mockOdpConfig = new Mock<OdpConfig>(API_KEY, API_HOST, new List<string>(0));
+            mockOdpConfig.Setup(o => o.IsReady()).Returns(false);
+            var manager = new OdpSegmentManager(mockOdpConfig.Object, _mockApiManager.Object,
+                Constants.DEFAULT_MAX_CACHE_SIZE, null, _mockLogger.Object, _mockCache.Object);
+
+            var segments = manager.FetchQualifiedSegments(FS_USER_ID);
+
+            Assert.IsNull(segments);
+            _mockLogger.Verify(
+                l => l.Log(LogLevel.WARN, Constants.ODP_NOT_INTEGRATED_MESSAGE),
+                Times.Once);
+        }
+
+        [Test]
+        public void ShouldIgnoreCache()
+        {
+            var manager = new OdpSegmentManager(_odpConfig, _mockApiManager.Object,
+                Constants.DEFAULT_MAX_CACHE_SIZE, null, _mockLogger.Object, _mockCache.Object);
+
+            manager.FetchQualifiedSegments(FS_USER_ID, new List<OdpSegmentOption>
+            {
+                OdpSegmentOption.IgnoreCache,
+            });
+
+            _mockCache.Verify(c => c.Reset(), Times.Never);
+            _mockCache.Verify(c => c.Lookup(It.IsAny<string>()), Times.Never);
+            _mockApiManager.Verify(
+                a => a.FetchSegments(It.IsAny<string>(), It.IsAny<string>(),
+                    It.IsAny<OdpUserKeyType>(), It.IsAny<string>(), It.IsAny<List<string>>()),
+                Times.Once);
+            _mockCache.Verify(c => c.Save(expectedCacheKey, It.IsAny<List<string>>()), Times.Never);
+        }
+
+        [Test]
+        public void ShouldResetCache()
+        {
+            var manager = new OdpSegmentManager(_odpConfig, _mockApiManager.Object,
+                Constants.DEFAULT_MAX_CACHE_SIZE, null, _mockLogger.Object, _mockCache.Object);
+
+            manager.FetchQualifiedSegments(FS_USER_ID, new List<OdpSegmentOption>
+            {
+                OdpSegmentOption.ResetCache,
+            });
+
+            _mockCache.Verify(c => c.Reset(), Times.Once);
+            _mockCache.Verify(c => c.Lookup(It.IsAny<string>()), Times.Never);
+            _mockApiManager.Verify(
+                a => a.FetchSegments(It.IsAny<string>(), It.IsAny<string>(),
+                    It.IsAny<OdpUserKeyType>(), It.IsAny<string>(), It.IsAny<List<string>>()),
+                Times.Once);
+            _mockCache.Verify(c => c.Save(expectedCacheKey, It.IsAny<List<string>>()), Times.Once);
+        }
+
+        [Test]
+        public void ShouldMakeValidCacheKey()
+        {
+            var keyCollector = new List<string>();
+            _mockCache.Setup(c => c.Lookup(Capture.In(keyCollector)));
+            var manager = new OdpSegmentManager(_odpConfig, _mockApiManager.Object,
+                Constants.DEFAULT_MAX_CACHE_SIZE, null, _mockLogger.Object, _mockCache.Object);
+
+            manager.FetchQualifiedSegments(FS_USER_ID);
+
+            var cacheKey = keyCollector.FirstOrDefault();
+            Assert.AreEqual(expectedCacheKey, cacheKey);
+        }
+    }
+}

OptimizelySDK.Tests/OptimizelySDK.Tests.csproj

@@ -85,6 +85,7 @@
     <Compile Include="OdpTests\LruCacheTest.cs" />
     <Compile Include="OdpTests\OdpEventManagerTests.cs" />
     <Compile Include="OdpTests\OdpEventApiManagerTest.cs" />
+    <Compile Include="OdpTests\OdpSegmentManagerTest.cs" />
     <Compile Include="OptimizelyConfigTests\OptimizelyConfigTest.cs" />
     <Compile Include="OptimizelyDecisions\OptimizelyDecisionTest.cs" />
     <Compile Include="OptimizelyJSONTest.cs" />

OptimizelySDK/Odp/Constants.cs

@@ -101,5 +101,15 @@ public static class Constants
         /// Default amount of time to wait for ODP response
         /// </summary>
         public static readonly TimeSpan DEFAULT_TIMEOUT_INTERVAL = TimeSpan.FromSeconds(10);
+
+        /// <summary>
+        /// Default maximum number of elements to cache
+        /// </summary>
+        public const int DEFAULT_MAX_CACHE_SIZE = 10000;
+
+        /// <summary>
+        /// Default number of minutes to cache
+        /// </summary>
+        public const int DEFAULT_CACHE_MINUTES = 10;
     }
 }

OptimizelySDK/Odp/Enums.cs

@@ -16,11 +16,23 @@
 
 namespace OptimizelySDK.Odp
 {
+    /// <summary>
+    /// Type of ODP key used for fetching segments & sending events
+    /// </summary>
     public enum OdpUserKeyType
     {
         // ReSharper disable InconsistentNaming
-        // ODP expects these names; .ToString() used
-        VUID = 0,
+        // ODP expects these names in UPPERCASE; .ToString() used
+        VUID = 0, // kept for SDK consistency and awareness
         FS_USER_ID = 1,
     }
+
+    /// <summary>
+    /// Options used during segment cache handling
+    /// </summary>
+    public enum OdpSegmentOption
+    {
+        IgnoreCache = 0,
+        ResetCache = 1,
+    }
 }

OptimizelySDK/Odp/IOdpSegmentManager.cs

@@ -0,0 +1,35 @@
+/* 
+ * Copyright 2022 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
+ *
+ * https://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.Odp
+{
+    /// <summary>
+    /// Interface to schedule connections to ODP for audience segmentation and caches the results.
+    /// </summary>
+    public interface IOdpSegmentManager
+    {
+        /// <summary>
+        /// Attempts to fetch and return a list of a user's qualified segments from the local segments cache.
+        /// If no cached data exists for the target user, this fetches and caches data from the ODP server instead.
+        /// </summary>
+        /// <param name="fsUserId">The FS User ID identifying the user</param>
+        /// <param name="options">An array of OptimizelySegmentOption used to ignore and/or reset the cache.</param>
+        /// <returns>Qualified segments for the user from the cache or the ODP server if the cache is empty.</returns>
+        List<string> FetchQualifiedSegments(string fsUserId, List<OdpSegmentOption> options = null);
+    }
+}

OptimizelySDK/Odp/LruCache.cs

@@ -25,11 +25,6 @@ namespace OptimizelySDK.Odp
     public class LruCache<T> : ICache<T>
         where T : class
     {
-        /// <summary>
-        /// Default maximum number of elements to store
-        /// </summary>
-        private const int DEFAULT_MAX_SIZE = 10000;
-
         /// <summary>
         /// The maximum number of elements that should be stored
         /// </summary>
@@ -66,7 +61,8 @@ public class LruCache<T> : ICache<T>
         /// <param name="maxSize">Maximum number of elements to allow in the cache</param>
         /// <param name="itemTimeout">Timeout or time to live for each item</param>
         /// <param name="logger">Implementation used for recording LRU events or errors</param>
-        public LruCache(int maxSize = DEFAULT_MAX_SIZE, TimeSpan? itemTimeout = default,
+        public LruCache(int maxSize = Constants.DEFAULT_MAX_CACHE_SIZE,
+            TimeSpan? itemTimeout = default,
             ILogger logger = null
         )
         {
@@ -76,7 +72,7 @@ public LruCache(int maxSize = DEFAULT_MAX_SIZE, TimeSpan? itemTimeout = default,
 
             _logger = logger ?? new DefaultLogger();
 
-            _timeout = itemTimeout ?? TimeSpan.FromMinutes(10);
+            _timeout = itemTimeout ?? TimeSpan.FromMinutes(Constants.DEFAULT_CACHE_MINUTES);
             if (_timeout < TimeSpan.Zero)
             {
                 _logger.Log(LogLevel.WARN,
@@ -118,9 +114,11 @@ public void Save(string key, T value)
                     {
                         var leastRecentlyUsedItem = _list.Last;
 
-                        var leastRecentlyUsedItemKey = (from cacheItem in _cache
-                            where cacheItem.Value == leastRecentlyUsedItem.Value
-                            select cacheItem.Key).FirstOrDefault();
+                        var leastRecentlyUsedItemKey =
+                            _cache.Where(
+                                    cacheItem => cacheItem.Value == leastRecentlyUsedItem.Value).
+                                Select(cacheItem => cacheItem.Key).
+                                FirstOrDefault();
 
                         if (leastRecentlyUsedItemKey != null)
                         {
@@ -227,9 +225,17 @@ public string[] _readCurrentCacheKeys()
         {
             _logger.Log(LogLevel.WARN, "_readCurrentCacheKeys used for non-testing purpose");
 
-            return (from listItem in _list
-                join cacheItem in _cache on listItem equals cacheItem.Value
-                select cacheItem.Key).ToArray();
+            string[] cacheKeys;
+            lock (_mutex)
+            {
+                cacheKeys = _list.Join(_cache,
+                        listItem => listItem,
+                        cacheItem => cacheItem.Value,
+                        (listItem, cacheItem) => cacheItem.Key).
+                    ToArray();
+            }
+
+            return cacheKeys;
         }
     }
 }

OptimizelySDK/Odp/OdpConfig.cs

@@ -108,5 +108,14 @@ public virtual bool IsReady()
         {
             return !(string.IsNullOrWhiteSpace(ApiKey) || string.IsNullOrWhiteSpace(ApiHost));
         }
+
+        /// <summary>
+        /// Determines if ODP configuration contains segments
+        /// </summary>
+        /// <returns></returns>
+        public bool HasSegments()
+        {
+            return SegmentsToCheck?.Count > 0;
+        }
     }
 }