sync tests

Author: raju-opti

lib/core/decision_service/index.spec.ts

@@ -1718,6 +1718,205 @@ describe('DecisionService', () => {
     });
   });
 
+  describe('resolveVariationForFeatureList - sync', () => {
+    beforeEach(() => {
+      mockBucket.mockReset();
+    });
+
+    it('should skip cmab experiments', async () => {
+      const { decisionService, cmabService } = getDecisionService();
+      const config = createProjectConfig(getDecisionTestDatafile());
+
+      const user = new OptimizelyUserContext({
+        optimizely: {} as any,
+        userId: 'tester',
+        attributes: {
+          age: 15, // should satisfy audience condition for all experiments and targeted delivery
+        },
+      });
+
+      mockBucket.mockImplementation((param: BucketerParams) => {
+        const ruleKey = param.experimentKey;
+        if (ruleKey === 'delivery_1') {
+          return {
+            result: '5004',
+            reasons: [],
+          };
+        }
+        return {
+          result: null,
+          reasons: [],
+        };
+      });
+
+      const feature = config.featureKeyMap['flag_1'];
+      const value = decisionService.resolveVariationsForFeatureList('sync', config, [feature], user, {}).get();
+
+      const variation = value[0];
+
+      expect(variation.result).toEqual({
+        experiment: config.experimentKeyMap['delivery_1'],
+        variation: config.variationIdMap['5004'],
+        decisionSource: DECISION_SOURCES.ROLLOUT,
+      });
+
+      expect(mockBucket).toHaveBeenCalledTimes(3);
+      verifyBucketCall(0, config, config.experimentKeyMap['exp_1'], user);
+      verifyBucketCall(1, config, config.experimentKeyMap['exp_2'], user);
+      verifyBucketCall(2, config, config.experimentKeyMap['delivery_1'], user);
+
+      expect(cmabService.getDecision).not.toHaveBeenCalled();
+    });
+
+    it('should ignore async user profile service', async () => {
+      const { decisionService, userProfileServiceAsync } = getDecisionService({
+        userProfileService: false,
+        userProfileServiceAsync: true,
+      });
+
+      userProfileServiceAsync?.lookup.mockResolvedValue({
+        user_id: 'tester',
+        experiment_bucket_map: {
+          '2002': {
+            variation_id: '5001',
+          },
+        },
+      });
+      userProfileServiceAsync?.save.mockResolvedValue(null);
+
+      mockBucket.mockImplementation((param: BucketerParams) => {
+        const ruleKey = param.experimentKey;
+        if (ruleKey === 'exp_2') {
+          return {
+            result: '5002',
+            reasons: [],
+          };
+        }
+        return {
+          result: null,
+          reasons: [],
+        };
+      });
+
+      const config = createProjectConfig(getDecisionTestDatafile());
+
+      const user = new OptimizelyUserContext({
+        optimizely: {} as any,
+        userId: 'tester',
+        attributes: {
+          age: 55, // should satisfy audience condition for exp_2 and exp_3
+        },
+      });
+
+      const feature = config.featureKeyMap['flag_1'];
+      const value = decisionService.resolveVariationsForFeatureList('sync', config, [feature], user, {}).get();
+
+      const variation = value[0];
+
+      expect(variation.result).toEqual({
+        experiment: config.experimentKeyMap['exp_2'],
+        variation: config.variationIdMap['5002'],
+        decisionSource: DECISION_SOURCES.FEATURE_TEST,
+      });
+
+      expect(userProfileServiceAsync?.lookup).not.toHaveBeenCalled();
+      expect(userProfileServiceAsync?.save).not.toHaveBeenCalled();
+    });
+
+    it('should use sync user profile service', async () => {
+      const { decisionService, userProfileService, userProfileServiceAsync } = getDecisionService({
+        userProfileService: true,
+        userProfileServiceAsync: true,
+      });
+
+      userProfileService?.lookup.mockImplementation((userId: string) => {
+        if (userId === 'tester-1') {
+          return {
+            user_id: 'tester-1',
+            experiment_bucket_map: {
+              '2002': {
+                variation_id: '5001',
+              },
+            },
+          };
+        }
+        return null;
+      });
+
+      userProfileServiceAsync?.lookup.mockResolvedValue(null);
+      userProfileServiceAsync?.save.mockResolvedValue(null);
+
+      mockBucket.mockImplementation((param: BucketerParams) => {
+        const ruleKey = param.experimentKey;
+        if (ruleKey === 'exp_2') {
+          return {
+            result: '5002',
+            reasons: [],
+          };
+        }
+        return {
+          result: null,
+          reasons: [],
+        };
+      });
+
+      const config = createProjectConfig(getDecisionTestDatafile());
+
+      const user1 = new OptimizelyUserContext({
+        optimizely: {} as any,
+        userId: 'tester-1',
+        attributes: {
+          age: 55, // should satisfy audience condition for exp_2 and exp_3
+        },
+      });
+
+      const feature = config.featureKeyMap['flag_1'];
+      const value = decisionService.resolveVariationsForFeatureList('sync', config, [feature], user1, {}).get();
+
+      const variation = value[0];
+
+      expect(variation.result).toEqual({
+        experiment: config.experimentKeyMap['exp_2'],
+        variation: config.variationIdMap['5001'],
+        decisionSource: DECISION_SOURCES.FEATURE_TEST,
+      });
+
+      expect(userProfileService?.lookup).toHaveBeenCalledTimes(1);
+      expect(userProfileService?.lookup).toHaveBeenCalledWith('tester-1');
+
+      const user2 = new OptimizelyUserContext({
+        optimizely: {} as any,
+        userId: 'tester-2',
+        attributes: {
+          age: 55, // should satisfy audience condition for exp_2 and exp_3
+        },
+      });
+
+      const value2 = decisionService.resolveVariationsForFeatureList('sync', config, [feature], user2, {}).get();
+      const variation2 = value2[0];
+      expect(variation2.result).toEqual({
+        experiment: config.experimentKeyMap['exp_2'],
+        variation: config.variationIdMap['5002'],
+        decisionSource: DECISION_SOURCES.FEATURE_TEST,
+      });
+
+      expect(userProfileService?.lookup).toHaveBeenCalledTimes(2);
+      expect(userProfileService?.lookup).toHaveBeenNthCalledWith(2, 'tester-2');
+      expect(userProfileService?.save).toHaveBeenCalledTimes(1);
+      expect(userProfileService?.save).toHaveBeenCalledWith({
+        user_id: 'tester-2',
+        experiment_bucket_map: {
+          '2002': {
+            variation_id: '5002',
+          },
+        },
+      });
+
+      expect(userProfileServiceAsync?.lookup).not.toHaveBeenCalled();
+      expect(userProfileServiceAsync?.save).not.toHaveBeenCalled();
+    });
+  });
+
   describe('getVariationsForFeatureList', () => {
     beforeEach(() => {
       mockBucket.mockReset();