Add test cases for cmab decision options

Author: muzahidul-opti

Sources/Implementation/DefaultDecisionService.swift

@@ -365,7 +365,7 @@ class DefaultDecisionService: OPTDecisionService {
         var decisions = [DecisionResponse<FeatureDecision>]()
 
         for featureFlag in featureFlags {
-            let flagDecisionResponse = getDecisionForFlag(config: config, featureFlag: featureFlag, user: user, userProfileTracker: profileTracker, opType: opType)
+            let flagDecisionResponse = getDecisionForFlag(config: config, featureFlag: featureFlag, user: user, userProfileTracker: profileTracker, opType: opType, options: options)
             decisions.append(flagDecisionResponse)
         }
 
@@ -398,22 +398,23 @@ class DefaultDecisionService: OPTDecisionService {
             let holdoutDecision = getVariationForHoldout(config: config,
                                                          flagKey: featureFlag.key,
                                                          holdout: holdout,
-                                                         user: user)
+                                                         user: user,
+                                                         options: options)
             reasons.merge(holdoutDecision.reasons)
             if let variation = holdoutDecision.result {
                 let featureDicision = FeatureDecision(experiment: holdout, variation: variation, source: Constants.DecisionSource.holdout.rawValue)
                 return DecisionResponse(result: featureDicision, reasons: reasons)
             }
         }
 
-        let flagExpDecision = getVariationForFeatureExperiments(config: config, featureFlag: featureFlag, user: user, userProfileTracker: userProfileTracker, opType: opType)
+        let flagExpDecision = getVariationForFeatureExperiments(config: config, featureFlag: featureFlag, user: user, userProfileTracker: userProfileTracker, opType: opType, options: options)
         reasons.merge(flagExpDecision.reasons)
 
         if let decision = flagExpDecision.result {
             return DecisionResponse(result: decision, reasons: reasons)
         }
 
-        let rolloutDecision = getVariationForFeatureRollout(config: config, featureFlag: featureFlag, user: user)
+        let rolloutDecision = getVariationForFeatureRollout(config: config, featureFlag: featureFlag, user: user, options: options)
         reasons.merge(rolloutDecision.reasons)
 
         if let decision = rolloutDecision.result {
@@ -631,6 +632,7 @@ class DefaultDecisionService: OPTDecisionService {
         let decisionResponse = getVariation(config: config,
                                             experiment: rule,
                                             user: user,
+                                            options: options,
                                             opType: opType,
                                             userProfileTracker: userProfileTracker)
         let variationResult = decisionResponse.result

Tests/OptimizelyTests-Common/OptimizelyUserContextTests_Decide_CMAB.swift

@@ -152,7 +152,7 @@ class OptimizelyUserContextTests_Decide_CMAB: XCTestCase {
         wait(for: [expectation], timeout: 5) // Increased timeout for reliability
     }
 
-    func testDecideAsync_cmabWithCaching() {
+    func testDecideAsync_cmabWithUserProfileCahing() {
         let expectation1 = XCTestExpectation(description: "First CMAB decision")
         let expectation2 = XCTestExpectation(description: "Second CMAB decision")
 
@@ -169,7 +169,7 @@ class OptimizelyUserContextTests_Decide_CMAB: XCTestCase {
             attributes: ["gender": "f", "age": 25]
         )
 
-        // First decision
+        // First decision cache into user profile
         user.decideAsync(key: "feature_1") { decision in
             XCTAssertEqual(decision.variationKey, "a")
             XCTAssertEqual(self.mockCmabService.decisionCallCount, 1)
@@ -186,38 +186,44 @@ class OptimizelyUserContextTests_Decide_CMAB: XCTestCase {
 
         wait(for: [expectation1, expectation2], timeout: 1)
     }
-    // FixMe: Need to fix the test case
-//    func testDecideAsync_cmabWithIgnoreCache() {
-//        let expectation = XCTestExpectation(description: "CMAB ignore cache")
-//        // Set up the CMAB experiment
-//        let cmab: Cmab = try! OTUtils.model(from: ["trafficAllocation": 10000, "attributeIds": ["10389729780"]])
-//        var experiments = optimizely.config!.project.experiments
-//        experiments[0].cmab = cmab
-//        optimizely.config?.project.experiments = experiments
-//        mockCmabService.variationId = "10389729780" // corresponds to variation "a"
-//        
-//        // Create user with attributes that match CMAB experiment
-//        let user = optimizely.createUserContext(
-//            userId: kUserId,
-//            attributes: ["gender": "f", "age": 25]
-//        )
-//        
-//        // Make decision with ignoreCmabCache option
-//        user.decideAsync(
-//            key: "feature_1",
-//            options: [.ignoreCmabCache, .ignoreUserProfileService]
-//        ) { decision in
-//            XCTAssertEqual(decision.variationKey, "a")
-//            XCTAssertTrue(self.mockCmabService.decisionCalled)
-//            XCTAssertTrue(self.mockCmabService.ignoreCacheUsed)
-//            expectation.fulfill()
-//        }
-//        
-//        wait(for: [expectation], timeout: 1)
-//    }
- 
-    
 
+    func testDecideAsync_cmabCacheOptions() {
+        let exp1 = XCTestExpectation(description: "First call")
+        let exp2 = XCTestExpectation(description: "Second call")
+        let exp3 = XCTestExpectation(description: "Third call")
+
+        
+        // Set up the CMAB experiment
+        let cmab: Cmab = try! OTUtils.model(from: ["trafficAllocation": 10000, "attributeIds": ["10389729780"]])
+        var experiments = optimizely.config!.project.experiments
+        experiments[0].cmab = cmab
+        optimizely.config?.project.experiments = experiments
+        mockCmabService.variationId = "10389729780" // corresponds to variation "a"
+        
+        // Create user with attributes that match CMAB experiment
+        let user = optimizely.createUserContext(
+            userId: kUserId,
+            attributes: ["gender": "f", "age": 25]
+        )
+        user.decideAsync(key: "feature_1", options: [.ignoreUserProfileService, .ignoreCmabCache]) { decision in
+            XCTAssertEqual(decision.variationKey, "a")
+            XCTAssertTrue(self.mockCmabService.ignoreCacheUsed)
+            exp1.fulfill()
+        }
+        user.decideAsync(key: "feature_1", options: [.ignoreUserProfileService, .resetCmabCache]) { decision in
+            XCTAssertEqual(decision.variationKey, "a")
+            XCTAssertTrue(self.mockCmabService.resetCacheCache)
+            exp2.fulfill()
+        }
+        user.decideAsync(key: "feature_1", options: [.ignoreUserProfileService, .invalidateUserCmabCache]) { decision in
+            XCTAssertEqual(decision.variationKey, "a")
+            XCTAssertTrue(self.mockCmabService.invalidateUserCmabCache)
+            exp3.fulfill()
+        }
+        wait(for: [exp1, exp2, exp3], timeout: 1)
+
+    }
+ 
     func testDecideAsync_cmabError() {
         let expectation = XCTestExpectation(description: "CMAB error handling")
         // Set up the CMAB experiment
@@ -244,25 +250,27 @@ class OptimizelyUserContextTests_Decide_CMAB: XCTestCase {
 
 }
 
-
 fileprivate class MockCmabService: DefaultCmabService {
     var variationId: String?
     var error: Error?
     var decisionCalled = false
     var decisionCallCount = 0
     var lastRuleId: String?
     var ignoreCacheUsed = false
+    var resetCacheCache = false
+    var invalidateUserCmabCache = false
 
     init() {
         super.init(cmabClient: DefaultCmabClient(), cmabCache: LruCache(size: 10, timeoutInSecs: 10))
     }
 
     override func getDecision(config: ProjectConfig, userContext: OptimizelyUserContext, ruleId: String, options: [OptimizelyDecideOption]) -> Result<CmabDecision, any Error> {
         decisionCalled = true
-        decisionCallCount += 1
         lastRuleId = ruleId
         ignoreCacheUsed = options.contains(.ignoreCmabCache)
-        
+        resetCacheCache = options.contains(.resetCmabCache)
+        invalidateUserCmabCache = options.contains(.invalidateUserCmabCache)
+        decisionCallCount += 1
         if let error = error {
             return .failure(error)
         }