refactor: adjust CmabCache inheritance to typealias and update cache timeout calculation

Author: muzahidul-opti

Sources/CMAB/CmabCache.swift

@@ -19,11 +19,4 @@ import Foundation
 let DEFAULT_CMAB_CACHE_TIMEOUT = 30 * 60 // 30 minutes
 let DEFAULT_CMAB_CACHE_SIZE = 100
 
-class CmabCache: LruCache<String, CmabCacheValue> {
-    override func lookup(key: String) -> CmabCacheValue? {
-        if timeoutInSecs <= 0 {
-            return nil
-        }
-        return super.lookup(key: key)
-    }
-}
+typealias CmabCache = LruCache<String, CmabCacheValue>

Sources/CMAB/CmabService.swift

@@ -198,7 +198,9 @@ extension DefaultCmabService {
     }
 
     static func createDefault(cacheSize: Int, cacheTimeout: Int) -> DefaultCmabService {
-        let cache = CmabCache(size: cacheSize, timeoutInSecs: cacheTimeout)
+        // if cache timeout is set to 0 or negative, use default timeout
+        let timeout = cacheTimeout <= 0 ? DEFAULT_CMAB_CACHE_TIMEOUT : cacheTimeout
+        let cache = CmabCache(size: cacheSize, timeoutInSecs: timeout)
         return DefaultCmabService(cmabClient: DefaultCmabClient(), cmabCache: cache)
     }
 }

Tests/OptimizelyTests-APIs/OptimizelyClientTests_ODP.swift

@@ -53,7 +53,7 @@ class OptimizelyClientTests_ODP: XCTestCase {
                                                 cmabCacheSize: 50,
                                                 cmabCacheTimeoutInSecs: 120)
         var optimizely = OptimizelyClient(sdkKey: OTUtils.randomSdkKey, settings: sdkSettings)
-        let cmabCache = ((optimizely.decisionService as! DefaultDecisionService).cmabService as! DefaultCmabService).cmabCache
+        var cmabCache = ((optimizely.decisionService as! DefaultDecisionService).cmabService as! DefaultCmabService).cmabCache
         XCTAssertEqual(50, cmabCache.maxSize)
         XCTAssertEqual(120, cmabCache.timeoutInSecs)
         XCTAssertEqual(12, optimizely.odpManager.segmentManager?.segmentsCache.maxSize)
@@ -64,6 +64,13 @@ class OptimizelyClientTests_ODP: XCTestCase {
         optimizely = OptimizelyClient(sdkKey: OTUtils.randomSdkKey, settings: sdkSettings)
         XCTAssertEqual(34, optimizely.odpManager.segmentManager?.apiMgr.resourceTimeoutInSecs)
         XCTAssertEqual(45, optimizely.odpManager.eventManager?.apiMgr.resourceTimeoutInSecs)
+        
+        sdkSettings = OptimizelySdkSettings(cmabCacheSize: 50, cmabCacheTimeoutInSecs: -10)
+        
+        optimizely = OptimizelyClient(sdkKey: OTUtils.randomSdkKey, settings: sdkSettings)
+        cmabCache = ((optimizely.decisionService as! DefaultDecisionService).cmabService as! DefaultCmabService).cmabCache
+        XCTAssertEqual(50, cmabCache.maxSize)
+        XCTAssertEqual(1800, cmabCache.timeoutInSecs)
 
         sdkSettings = OptimizelySdkSettings(disableOdp: true)
         optimizely = OptimizelyClient(sdkKey: OTUtils.randomSdkKey, settings: sdkSettings)

Tests/OptimizelyTests-Common/CmabServiceTests.swift

@@ -717,7 +717,8 @@ extension DefaultCmabServiceTests {
     }
 
     func testCacheTimeoutZero() {
-        // Create a cache with timeout 0 (immediate expiration)
+        // When timeout is 0, LruCache uses default timeout (30 * 60 seconds = 1800 seconds)
+        // So cache will NOT expire within the test timeframe
         let zeroTimeoutCache = CmabCache(size: 10, timeoutInSecs: 0)
         let zeroTimeoutService = DefaultCmabService(cmabClient: cmabClient, cmabCache: zeroTimeoutCache)
 
@@ -733,48 +734,49 @@ extension DefaultCmabServiceTests {
             options: []
         ) { result in
             switch result {
-            case .success(let decision):
-                XCTAssertEqual(decision.variationId, "variation-first")
-                XCTAssertTrue(self.cmabClient.fetchDecisionCalled, "Should call API on first request")
-                
-            case .failure(let error):
-                XCTFail("Expected success but got error: \(error)")
+                case .success(let decision):
+                    XCTAssertEqual(decision.variationId, "variation-first")
+                    XCTAssertTrue(self.cmabClient.fetchDecisionCalled, "Should call API on first request")
+                    
+                case .failure(let error):
+                    XCTFail("Expected success but got error: \(error)")
             }
             expectation1.fulfill()
         }
 
         wait(for: [expectation1], timeout: 1.0)
 
-        // Reset and change the variation
+        // Reset client but don't change the result
         cmabClient.reset()
         cmabClient.fetchDecisionResult = .success("variation-second")
 
-        // Small delay to ensure cache timeout
-        Thread.sleep(forTimeInterval: 1.1)
+        // Small delay (but not enough to expire default 1800s timeout)
+        Thread.sleep(forTimeInterval: 0.1)
 
         let expectation2 = self.expectation(description: "second request")
 
-        // Second request - should NOT use cache (timeout = 0, cache expired)
+        // Second request - SHOULD use cache (timeout defaults to 1800s, not expired)
         zeroTimeoutService.getDecision(
             config: config,
             userContext: userContext,
             ruleId: "exp-123",
             options: []
         ) { result in
             switch result {
-            case .success(let decision):
-                XCTAssertEqual(decision.variationId, "variation-second")
-                XCTAssertTrue(self.cmabClient.fetchDecisionCalled, "Should call API again when cache timeout is 0")
-                
-            case .failure(let error):
-                XCTFail("Expected success but got error: \(error)")
+                case .success(let decision):
+                    // Should get cached value, not the new one
+                    XCTAssertEqual(decision.variationId, "variation-first")
+                    XCTAssertFalse(self.cmabClient.fetchDecisionCalled, "Should use cache when timeout defaults to 1800s")
+                    
+                case .failure(let error):
+                    XCTFail("Expected success but got error: \(error)")
             }
             expectation2.fulfill()
         }
 
         wait(for: [expectation2], timeout: 1.0)
     }
-    
+
     func testCacheSizeZeroAndTimeoutZero() {
         // Create a cache with both size 0 and timeout 0 (completely disabled)
         let disabledCache = CmabCache(size: 0, timeoutInSecs: 0)