[FSSDK-11185] Update: Send CMAB uuid in impression events

lib/optimizely.rb

@@ -219,7 +219,7 @@ def create_optimizely_decision(user_context, flag_key, decision, reasons, decide
       end
 
       if !decide_options.include?(OptimizelyDecideOption::DISABLE_DECISION_EVENT) && (decision_source == Optimizely::DecisionService::DECISION_SOURCES['FEATURE_TEST'] || config.send_flag_decisions)
-        send_impression(config, experiment, variation_key || '', flag_key, rule_key || '', feature_enabled, decision_source, user_id, attributes)
+        send_impression(config, experiment, variation_key || '', flag_key, rule_key || '', feature_enabled, decision_source, user_id, attributes, decision&.cmab_uuid)
         decision_event_dispatched = true
       end
 
@@ -1244,7 +1244,7 @@ def validate_instantiation_options
       raise InvalidInputError, 'event_dispatcher'
     end
 
-    def send_impression(config, experiment, variation_key, flag_key, rule_key, enabled, rule_type, user_id, attributes = nil)
+    def send_impression(config, experiment, variation_key, flag_key, rule_key, enabled, rule_type, user_id, attributes = nil, cmab_uuid = nil)
       if experiment.nil?
         experiment = {
           'id' => '',
@@ -1276,6 +1276,7 @@ def send_impression(config, experiment, variation_key, flag_key, rule_key, enabl
         variation_key: variation_key,
         enabled: enabled
       }
+      metadata[:cmab_uuid] = cmab_uuid unless cmab_uuid.nil?
 
       user_event = UserEventFactory.create_impression_event(config, experiment, variation_id, metadata, user_id, attributes)
       @event_processor.process(user_event)

spec/optimizely_user_context_spec.rb

@@ -556,6 +556,7 @@
       decision = user_context_obj.decide(feature_key, [Optimizely::Decide::OptimizelyDecideOption::INCLUDE_REASONS])
       expect(decision.variation_key).to eq('18257766532')
       expect(decision.rule_key).to eq('18322080788')
+      # puts decision.reasons
       expect(decision.reasons).to include('Invalid variation is mapped to flag (feature_1), rule (exp_with_audience) and user (tester) in the forced decision map.')
 
       # delivery-rule-to-decision

spec/project_spec.rb

@@ -4308,6 +4308,103 @@ def callback(_args); end
         expect(decision.reasons).to include('CMAB service failed to fetch decision')
       end
     end
+    describe 'CMAB experiments' do
+      it 'should include CMAB UUID in dispatched event when decision service returns CMAB result' do
+        # Use an existing feature flag from the test config
+        feature_flag_key = 'boolean_single_variable_feature'
+
+        # Get an existing experiment that actually exists in the datafile
+        # Looking at the test config, let's use experiment ID '122230' which exists
+        existing_experiment = project_config.get_experiment_from_id('122230')
+
+        # Modify the existing experiment to be a CMAB experiment
+        cmab_experiment = existing_experiment.dup
+        cmab_experiment['trafficAllocation'] = [] # Empty for CMAB
+        cmab_experiment['cmab'] = {'attributeIds' => %w[808797688 808797689], 'trafficAllocation' => 4000}
+
+        # Mock the config to return our modified CMAB experiment
+        allow(project_instance.config_manager.config).to receive(:get_experiment_from_id)
+          .with('122230')
+          .and_return(cmab_experiment)
+
+        allow(project_instance.config_manager.config).to receive(:experiment_running?)
+          .with(cmab_experiment)
+          .and_return(true)
+
+        # Get the feature flag and update it to reference our CMAB experiment
+        feature_flag = project_instance.config_manager.config.get_feature_flag_from_key(feature_flag_key)
+        feature_flag['experimentIds'] = ['122230']
+
+        # Use existing variations from the original experiment
+        variation_to_use = existing_experiment['variations'][0]
+
+        # Create a decision with CMAB UUID
+        expected_cmab_uuid = 'uuid-cmab'
+        decision_with_cmab = Optimizely::DecisionService::Decision.new(
+          cmab_experiment,
+          variation_to_use,
+          Optimizely::DecisionService::DECISION_SOURCES['FEATURE_TEST'],
+          expected_cmab_uuid
+        )
+
+        decision_result_with_cmab = Optimizely::DecisionService::DecisionResult.new(
+          decision_with_cmab,
+          false,
+          []
+        )
+
+        # Mock get_variations_for_feature_list to return CMAB result
+        allow(project_instance.decision_service).to receive(:get_variations_for_feature_list)
+          .and_return([decision_result_with_cmab])
+
+        # Set up time and UUID mocks for consistent event data
+        allow(Time).to receive(:now).and_return(time_now)
+        allow(SecureRandom).to receive(:uuid).and_return('a68cf1ad-0393-4e18-af87-efe8f01a7c9c')
+
+        # Create array to capture dispatched events
+        dispatched_events = []
+        allow(project_instance.event_dispatcher).to receive(:dispatch_event) do |event|
+          dispatched_events << event
+        end
+
+        user_context = project_instance.create_user_context('test_user')
+        decision = user_context.decide(feature_flag_key)
+
+        # Wait for batch processing thread to send event
+        sleep 0.1 until project_instance.event_processor.event_queue.empty?
+
+        # Verify the decision contains expected information
+        expect(decision.enabled).to eq(true)
+        expect(decision.variation_key).to eq(variation_to_use['key'])
+        expect(decision.rule_key).to eq(existing_experiment['key'])
+        expect(decision.flag_key).to eq(feature_flag_key)
+
+        # Verify an event was dispatched
+        expect(dispatched_events.length).to eq(1)
+
+        dispatched_event = dispatched_events[0]
+
+        # Remove the puts statement and verify the event structure and CMAB UUID
+        expect(dispatched_event.params).to have_key(:visitors)
+        expect(dispatched_event.params[:visitors].length).to be > 0
+        expect(dispatched_event.params[:visitors][0]).to have_key(:snapshots)
+        expect(dispatched_event.params[:visitors][0][:snapshots].length).to be > 0
+        expect(dispatched_event.params[:visitors][0][:snapshots][0]).to have_key(:decisions)
+        expect(dispatched_event.params[:visitors][0][:snapshots][0][:decisions].length).to be > 0
+
+        # Get the metadata and assert CMAB UUID
+        metadata = dispatched_event.params[:visitors][0][:snapshots][0][:decisions][0][:metadata]
+        expect(metadata).to have_key(:cmab_uuid)
+        expect(metadata[:cmab_uuid]).to eq(expected_cmab_uuid)
+
+        # Also verify other expected metadata fields
+        expect(metadata[:flag_key]).to eq(feature_flag_key)
+        expect(metadata[:rule_key]).to eq('test_experiment_multivariate')
+        expect(metadata[:rule_type]).to eq('feature-test')
+        expect(metadata[:variation_key]).to eq('Fred')
+        expect(metadata[:enabled]).to eq(true)
+      end
+    end
   end
 
   describe '#decide_all' do