[FSSDK-11529] Impression event logic adjustment for holdouts

lib/event_processor/event_builder/user_event.ts

@@ -28,6 +28,7 @@ import {
 
 import { EventTags, UserAttributes } from '../../shared_types';
 import { LoggerFacade } from '../../logging/logger';
+import { DECISION_SOURCES } from '../../common_exports';
 
 export type VisitorAttribute = {
   entityId: string
@@ -185,7 +186,8 @@ export const buildImpressionEvent = function({
   const variationId = decision.getVariationId(decisionObj);
   const cmabUuid = decisionObj.cmabUuid;
 
-  const layerId = experimentId !== null ? getLayerId(configObj, experimentId) : null;
+  const layerId =
+    experimentId !== null && ruleType !== DECISION_SOURCES.HOLDOUT ? getLayerId(configObj, experimentId) : null;
 
   return {
     ...buildBaseEvent({

lib/feature_toggle.ts

@@ -31,4 +31,4 @@
  * flag and all associated checks can be removed from the codebase.
  */
 
-export const holdout = () => false;
+export const holdout = () => true;

lib/optimizely/index.spec.ts

@@ -29,6 +29,34 @@ import { DECISION_SOURCES } from '../utils/enums';
 import OptimizelyUserContext from '../optimizely_user_context';
 import { newErrorDecision } from '../optimizely_decision';
 import { ImpressionEvent } from '../event_processor/event_builder/user_event';
+import { OptimizelyDecideOption } from '../shared_types';
+
+
+const holdoutData = [
+  {
+    id: 'holdout_test_id',
+    key: 'holdout_test_key',
+    status: 'Running',
+    includeFlags: [],
+    excludeFlags: [],
+    audienceIds: [],
+    audienceConditions: [],
+    variations: [
+      {
+        id: 'holdout_variation_id',
+        key: 'holdout_variation_key',
+        variables: [],
+        featureEnabled: false,
+      },
+    ],
+    trafficAllocation: [
+      {
+        entityId: 'holdout_variation_id',
+        endOfRange: 10000,
+      },
+    ],
+  },
+];
 
 describe('Optimizely', () => {
   const eventDispatcher = {
@@ -212,5 +240,179 @@ describe('Optimizely', () => {
       const event = processSpy.mock.calls[0][0] as ImpressionEvent;
       expect(event.cmabUuid).toBe('uuid-cmab');
     });
+
+    it('should dispatch impression event for holdout decision', async () => {
+      const datafile = getDecisionTestDatafile();
+
+      datafile.holdouts = holdoutData;      
+      const projectConfig = createProjectConfig(datafile);
+
+      const projectConfigManager = getMockProjectConfigManager({
+        initConfig: projectConfig,
+      });
+
+      const mockEventDispatcher = {
+        dispatchEvent: vi.fn(() => Promise.resolve({ statusCode: 200 })),
+      };
+      const eventProcessor = getForwardingEventProcessor(mockEventDispatcher);
+      const processSpy = vi.spyOn(eventProcessor, 'process');
+
+      const optimizely = new Optimizely({
+        clientEngine: 'node-sdk',
+        projectConfigManager,
+        eventProcessor,
+        jsonSchemaValidator,
+        logger,
+        odpManager,
+        disposable: true,
+        cmabService: {} as any
+      });
+
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      const decisionService = optimizely.decisionService;
+      vi.spyOn(decisionService, 'resolveVariationsForFeatureList').mockImplementation(() => {
+        return Value.of('async', [{
+          error: false,
+          result: {
+            variation: projectConfig.holdouts[0].variations[0],
+            experiment: projectConfig.holdouts[0],
+            decisionSource: DECISION_SOURCES.HOLDOUT,
+          },
+          reasons: [],
+        }]);
+      });
+
+      const user = new OptimizelyUserContext({
+        optimizely,
+        userId: 'test_user',
+        attributes: {},
+      });
+
+      const decision = await optimizely.decideAsync(user, 'flag_1', []);
+
+      expect(decision.ruleKey).toBe('holdout_test_key');
+      expect(decision.flagKey).toBe('flag_1');
+      expect(decision.variationKey).toBe('holdout_variation_key');
+      expect(decision.enabled).toBe(false);
+
+      expect(eventProcessor.process).toHaveBeenCalledOnce();
+
+      const event = processSpy.mock.calls[0][0] as ImpressionEvent;
+
+      expect(event.type).toBe('impression');
+      expect(event.ruleKey).toBe('holdout_test_key');
+      expect(event.ruleType).toBe('holdout');
+      expect(event.enabled).toBe(false);
+    });
+
+    it('should not dispatch impression event for holdout when DISABLE_DECISION_EVENT is used', async () => {
+      const datafile = getDecisionTestDatafile();
+
+      datafile.holdouts = holdoutData;
+
+      const projectConfig = createProjectConfig(datafile);
+
+      const projectConfigManager = getMockProjectConfigManager({
+        initConfig: projectConfig,
+      });
+
+      const mockEventDispatcher = {
+        dispatchEvent: vi.fn(() => Promise.resolve({ statusCode: 200 })),
+      };
+      const eventProcessor = getForwardingEventProcessor(mockEventDispatcher);
+      vi.spyOn(eventProcessor, 'process');
+
+      const optimizely = new Optimizely({
+        clientEngine: 'node-sdk',
+        projectConfigManager,
+        eventProcessor,
+        jsonSchemaValidator,
+        logger,
+        odpManager,
+        disposable: true,
+        cmabService: {} as any
+      });
+
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      const decisionService = optimizely.decisionService;
+      vi.spyOn(decisionService, 'resolveVariationsForFeatureList').mockImplementation(() => {
+        return Value.of('async', [{
+          error: false,
+          result: {
+            variation: projectConfig.holdouts![0].variations[0],
+            experiment: projectConfig.holdouts![0],
+            decisionSource: DECISION_SOURCES.HOLDOUT,
+          },
+          reasons: [],
+        }]);
+      });
+
+      const user = new OptimizelyUserContext({
+        optimizely,
+        userId: 'test_user',
+        attributes: {},
+      });
+
+      const decision = await optimizely.decideAsync(user, 'flag_1', [OptimizelyDecideOption.DISABLE_DECISION_EVENT]);
+
+      expect(decision.ruleKey).toBe('holdout_test_key');
+      expect(decision.enabled).toBe(false);
+      expect(eventProcessor.process).not.toHaveBeenCalled();
+    });
   });
+  describe('isFeatureEnabled', () => {
+    it('should dispatch impression event for holdout decision for isFeatureEnabled', async () => {
+      const datafile = getDecisionTestDatafile();
+      datafile.holdouts = holdoutData;
+
+      const projectConfig = createProjectConfig(datafile);
+      const projectConfigManager = getMockProjectConfigManager({
+        initConfig: projectConfig,
+      });
+      const mockEventDispatcher = {
+        dispatchEvent: vi.fn(() => Promise.resolve({ statusCode: 200 })),
+      };
+      const eventProcessor = getForwardingEventProcessor(mockEventDispatcher);
+      vi.spyOn(eventProcessor, 'process');
+
+      const optimizely = new Optimizely({
+        clientEngine: 'node-sdk',
+        projectConfigManager,
+        eventProcessor,
+        jsonSchemaValidator,
+        logger,
+        odpManager,
+        disposable: true,
+        cmabService: {} as any
+      });
+
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      const decisionService = optimizely.decisionService;
+      vi.spyOn(decisionService, 'getVariationForFeature').mockReturnValue({
+        error: false,
+        result: {
+          variation: projectConfig.holdouts![0].variations[0],
+          experiment: projectConfig.holdouts![0],
+          decisionSource: DECISION_SOURCES.HOLDOUT,
+        },
+        reasons: [],
+      });
+      const result = optimizely.isFeatureEnabled('flag_1', 'test_user', {});
+
+      expect(result).toBe(false);
+
+      expect(eventProcessor.process).toHaveBeenCalledOnce();
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      const event = eventProcessor.process.mock.calls[0][0] as ImpressionEvent;
+
+      expect(event.type).toBe('impression');
+      expect(event.ruleKey).toBe('holdout_test_key');
+      expect(event.ruleType).toBe('holdout');
+      expect(event.enabled).toBe(false);
+    });
+  })
 });

lib/optimizely/index.ts

@@ -652,7 +652,7 @@ export default class Optimizely extends BaseService implements Client {
 
       let featureEnabled = decision.getFeatureEnabledFromVariation(decisionObj);
 
-      if (decisionSource === DECISION_SOURCES.FEATURE_TEST) {
+      if (decisionSource === DECISION_SOURCES.FEATURE_TEST || decisionSource === DECISION_SOURCES.HOLDOUT) {
         sourceInfo = {
           experimentKey: experimentKey,
           variationKey: variationKey,
@@ -661,6 +661,7 @@ export default class Optimizely extends BaseService implements Client {
 
       if (
         decisionSource === DECISION_SOURCES.FEATURE_TEST ||
+        decisionSource === DECISION_SOURCES.HOLDOUT ||
         (decisionSource === DECISION_SOURCES.ROLLOUT && projectConfig.getSendFlagDecisionsValue(configObj))
       ) {
         this.sendImpressionEvent(decisionObj, feature.key, userId, featureEnabled, attributes);
@@ -1503,6 +1504,7 @@ export default class Optimizely extends BaseService implements Client {
       if (
         !options[OptimizelyDecideOption.DISABLE_DECISION_EVENT] &&
         (decisionSource === DECISION_SOURCES.FEATURE_TEST ||
+          decisionSource === DECISION_SOURCES.HOLDOUT ||
           (decisionSource === DECISION_SOURCES.ROLLOUT && projectConfig.getSendFlagDecisionsValue(configObj)))
       ) {
         this.sendImpressionEvent(decisionObj, key, userId, flagEnabled, attributes);