feat(DecisionListener): Adds feature decision listener. (#157)

rashidsp · aliabbasrizvi · commit f140be182844 · 2019-03-26T11:29:22.000-07:00
diff --git a/lib/optimizely.rb b/lib/optimizely.rb
@@ -262,30 +262,44 @@ def is_feature_enabled(feature_flag_key, user_id, attributes = nil)
       end
 
       decision = @decision_service.get_variation_for_feature(feature_flag, user_id, attributes)
-      if decision.nil?
-        @logger.log(Logger::INFO,
-                    "Feature '#{feature_flag_key}' is not enabled for user '#{user_id}'.")
-        return false
-      end
 
-      variation = decision['variation']
-      if decision.source == Optimizely::DecisionService::DECISION_SOURCE_EXPERIMENT
-        # Send event if Decision came from an experiment.
-        send_impression(decision.experiment, variation['key'], user_id, attributes)
-      else
-        @logger.log(Logger::DEBUG,
-                    "The user '#{user_id}' is not being experimented on in feature '#{feature_flag_key}'.")
+      feature_enabled = false
+      source_string = Optimizely::DecisionService::DECISION_SOURCE_ROLLOUT
+      if decision.is_a?(Optimizely::DecisionService::Decision)
+        variation = decision['variation']
+        feature_enabled = variation['featureEnabled']
+        if decision.source == Optimizely::DecisionService::DECISION_SOURCE_EXPERIMENT
+          source_string = Optimizely::DecisionService::DECISION_SOURCE_EXPERIMENT
+          experiment_key = decision.experiment['key']
+          variation_key = variation['key']
+          # Send event if Decision came from an experiment.
+          send_impression(decision.experiment, variation['key'], user_id, attributes)
+        else
+          @logger.log(Logger::DEBUG,
+                      "The user '#{user_id}' is not being experimented on in feature '#{feature_flag_key}'.")
+        end
       end
 
-      if variation['featureEnabled'] == true
+      @notification_center.send_notifications(
+        NotificationCenter::NOTIFICATION_TYPES[:DECISION],
+        Helpers::Constants::DECISION_INFO_TYPES['FEATURE'],
+        user_id, (attributes || {}),
+        feature_key: feature_flag_key,
+        feature_enabled: feature_enabled,
+        source: source_string.upcase,
+        source_experiment_key: experiment_key,
+        source_variation_key: variation_key
+      )
+
+      if feature_enabled == true
         @logger.log(Logger::INFO,
                     "Feature '#{feature_flag_key}' is enabled for user '#{user_id}'.")
         return true
-      else
-        @logger.log(Logger::INFO,
-                    "Feature '#{feature_flag_key}' is not enabled for user '#{user_id}'.")
-        return false
       end
+
+      @logger.log(Logger::INFO,
+                  "Feature '#{feature_flag_key}' is not enabled for user '#{user_id}'.")
+      false
     end
 
     # Gets keys of all feature flags which are enabled for the user.
diff --git a/spec/project_spec.rb b/spec/project_spec.rb
@@ -1333,7 +1333,9 @@ class InvalidErrorHandler; end
           Optimizely::NotificationCenter::NOTIFICATION_TYPES[:ACTIVATE],
           experiment_to_return, 'test_user', nil, variation_to_return,
           instance_of(Optimizely::Event)
-        )
+        ).ordered
+
+      expect(project_instance.notification_center).to receive(:send_notifications).ordered
 
       allow(project_instance.decision_service).to receive(:get_variation_for_feature).and_return(decision_to_return)
 
@@ -1360,6 +1362,125 @@ class InvalidErrorHandler; end
       expect(project_instance.event_dispatcher).to have_received(:dispatch_event).with(instance_of(Optimizely::Event)).once
       expect(spy_logger).to have_received(:log).once.with(Logger::INFO, "Feature 'multi_variate_feature' is not enabled for user 'test_user'.")
     end
+
+    describe '.decision listener' do
+      it 'should call decision listener when user is bucketed into a feature experiment with featureEnabled property is true' do
+        allow(project_instance.event_dispatcher).to receive(:dispatch_event).with(instance_of(Optimizely::Event))
+        experiment_to_return = config_body['experiments'][3]
+        variation_to_return = experiment_to_return['variations'][0]
+        decision_to_return = Optimizely::DecisionService::Decision.new(
+          experiment_to_return,
+          variation_to_return,
+          Optimizely::DecisionService::DECISION_SOURCE_EXPERIMENT
+        )
+
+        allow(project_instance.decision_service).to receive(:get_variation_for_feature).and_return(decision_to_return)
+
+        # Activate listener
+        expect(project_instance.notification_center).to receive(:send_notifications).ordered
+
+        # Decision listener called when the user is in experiment with variation feature on.
+        expect(variation_to_return['featureEnabled']).to be true
+        expect(project_instance.notification_center).to receive(:send_notifications).once.with(
+          Optimizely::NotificationCenter::NOTIFICATION_TYPES[:DECISION],
+          'feature', 'test_user', {},
+          feature_enabled: true,
+          feature_key: 'multi_variate_feature',
+          source: 'EXPERIMENT',
+          source_experiment_key: 'test_experiment_multivariate',
+          source_variation_key: 'Fred'
+        ).ordered
+
+        project_instance.is_feature_enabled('multi_variate_feature', 'test_user')
+      end
+
+      it 'should call decision listener when user is bucketed into a feature experiment with featureEnabled property is false' do
+        allow(project_instance.event_dispatcher).to receive(:dispatch_event).with(instance_of(Optimizely::Event))
+        experiment_to_return = config_body['experiments'][3]
+        variation_to_return = experiment_to_return['variations'][1]
+        decision_to_return = Optimizely::DecisionService::Decision.new(
+          experiment_to_return,
+          variation_to_return,
+          Optimizely::DecisionService::DECISION_SOURCE_EXPERIMENT
+        )
+
+        allow(project_instance.decision_service).to receive(:get_variation_for_feature).and_return(decision_to_return)
+
+        expect(project_instance.notification_center).to receive(:send_notifications).ordered
+
+        # DECISION listener called when the user is in experiment with variation feature off.
+        expect(variation_to_return['featureEnabled']).to be false
+        expect(project_instance.notification_center).to receive(:send_notifications).once.with(
+          Optimizely::NotificationCenter::NOTIFICATION_TYPES[:DECISION],
+          'feature', 'test_user', {'browser_type' => 'chrome'},
+          feature_enabled: false,
+          feature_key: 'multi_variate_feature',
+          source: 'EXPERIMENT',
+          source_experiment_key: 'test_experiment_multivariate',
+          source_variation_key: 'Feorge'
+        )
+
+        project_instance.is_feature_enabled('multi_variate_feature', 'test_user', 'browser_type' => 'chrome')
+      end
+
+      it 'should call decision listener when user is bucketed into rollout with featureEnabled property is true' do
+        experiment_to_return = config_body['rollouts'][0]['experiments'][0]
+        variation_to_return = experiment_to_return['variations'][0]
+        decision_to_return = Optimizely::DecisionService::Decision.new(
+          experiment_to_return,
+          variation_to_return,
+          Optimizely::DecisionService::DECISION_SOURCE_ROLLOUT
+        )
+        allow(project_instance.decision_service).to receive(:get_variation_for_feature).and_return(decision_to_return)
+
+        # DECISION listener called when the user is in rollout with variation feature true.
+        expect(variation_to_return['featureEnabled']).to be true
+        expect(project_instance.notification_center).to receive(:send_notifications).once.with(
+          Optimizely::NotificationCenter::NOTIFICATION_TYPES[:DECISION],
+          'feature', 'test_user', {'browser_type' => 'firefox'},
+          feature_enabled: true,
+          feature_key: 'boolean_single_variable_feature',
+          source: 'ROLLOUT',
+          source_experiment_key: nil,
+          source_variation_key: nil
+        )
+
+        project_instance.is_feature_enabled('boolean_single_variable_feature', 'test_user', 'browser_type' => 'firefox')
+      end
+
+      it 'should call decision listener when user is bucketed into rollout with featureEnabled property is false' do
+        allow(project_instance.decision_service).to receive(:get_variation_for_feature).and_return(Optimizely::DecisionService::Decision)
+
+        # DECISION listener called when the user is in rollout with variation feature off.
+        expect(project_instance.notification_center).to receive(:send_notifications).once.with(
+          Optimizely::NotificationCenter::NOTIFICATION_TYPES[:DECISION],
+          'feature', 'test_user', {},
+          feature_enabled: false,
+          feature_key: 'boolean_single_variable_feature',
+          source: 'ROLLOUT',
+          source_experiment_key: nil,
+          source_variation_key: nil
+        )
+
+        project_instance.is_feature_enabled('boolean_single_variable_feature', 'test_user')
+      end
+
+      it 'call decision listener when the user is not bucketed into any experiment or rollout' do
+        allow(project_instance.decision_service).to receive(:get_variation_for_feature).and_return(nil)
+
+        expect(project_instance.notification_center).to receive(:send_notifications).once.with(
+          Optimizely::NotificationCenter::NOTIFICATION_TYPES[:DECISION],
+          'feature', 'test_user', {'browser_type' => 'firefox'},
+          feature_enabled: false,
+          feature_key: 'multi_variate_feature',
+          source: 'ROLLOUT',
+          source_experiment_key: nil,
+          source_variation_key: nil
+        )
+
+        project_instance.is_feature_enabled('multi_variate_feature', 'test_user', 'browser_type' => 'firefox')
+      end
+    end
   end
 
   describe '#get_enabled_features' do
@@ -1425,6 +1546,126 @@ class InvalidErrorHandler; end
       # Checks prevented features should not return
       expect(project_instance.get_enabled_features('test_user', 'browser_type' => 'chrome')).not_to include(*disabled_features)
     end
+
+    describe '.decision listener' do
+      it 'should return enabled features and call decision listener for all features' do
+        allow(project_instance.event_dispatcher).to receive(:dispatch_event).with(instance_of(Optimizely::Event))
+
+        enabled_features = %w[boolean_feature integer_single_variable_feature]
+
+        experiment_to_return = config_body['experiments'][3]
+        rollout_to_return = config_body['rollouts'][0]['experiments'][0]
+
+        allow(project_instance.decision_service).to receive(:get_variation_for_feature).and_return(
+          Optimizely::DecisionService::Decision.new(
+            experiment_to_return,
+            experiment_to_return['variations'][0],
+            Optimizely::DecisionService::DECISION_SOURCE_EXPERIMENT
+          ),
+          nil,
+          Optimizely::DecisionService::Decision.new(
+            rollout_to_return,
+            rollout_to_return['variations'][0],
+            Optimizely::DecisionService::DECISION_SOURCE_ROLLOUT
+          ),
+          Optimizely::DecisionService::Decision.new(
+            experiment_to_return,
+            experiment_to_return['variations'][1],
+            Optimizely::DecisionService::DECISION_SOURCE_EXPERIMENT
+          ),
+          nil,
+          nil,
+          Optimizely::DecisionService::Decision,
+          nil
+        )
+
+        expect(project_instance.notification_center).to receive(:send_notifications).twice.with(
+          Optimizely::NotificationCenter::NOTIFICATION_TYPES[:ACTIVATE], any_args
+        )
+
+        expect(project_instance.notification_center).to receive(:send_notifications).once.with(
+          Optimizely::NotificationCenter::NOTIFICATION_TYPES[:DECISION],
+          'feature', 'test_user', {'browser_type' => 'firefox'},
+          feature_enabled: true,
+          feature_key: 'boolean_feature',
+          source: 'EXPERIMENT',
+          source_experiment_key: 'test_experiment_multivariate',
+          source_variation_key: 'Fred'
+        ).ordered
+
+        expect(project_instance.notification_center).to receive(:send_notifications).once.with(
+          Optimizely::NotificationCenter::NOTIFICATION_TYPES[:DECISION],
+          'feature', 'test_user', {'browser_type' => 'firefox'},
+          feature_enabled: false,
+          feature_key: 'double_single_variable_feature',
+          source: 'ROLLOUT',
+          source_experiment_key: nil,
+          source_variation_key: nil
+        ).ordered
+
+        expect(project_instance.notification_center).to receive(:send_notifications).once.with(
+          Optimizely::NotificationCenter::NOTIFICATION_TYPES[:DECISION],
+          'feature', 'test_user', {'browser_type' => 'firefox'},
+          feature_enabled: true,
+          feature_key: 'integer_single_variable_feature',
+          source: 'ROLLOUT',
+          source_experiment_key: nil,
+          source_variation_key: nil
+        ).ordered
+
+        expect(project_instance.notification_center).to receive(:send_notifications).once.with(
+          Optimizely::NotificationCenter::NOTIFICATION_TYPES[:DECISION],
+          'feature', 'test_user', {'browser_type' => 'firefox'},
+          feature_enabled: false,
+          feature_key: 'boolean_single_variable_feature',
+          source: 'EXPERIMENT',
+          source_experiment_key: 'test_experiment_multivariate',
+          source_variation_key: 'Feorge'
+        ).ordered
+
+        expect(project_instance.notification_center).to receive(:send_notifications).once.with(
+          Optimizely::NotificationCenter::NOTIFICATION_TYPES[:DECISION],
+          'feature', 'test_user', {'browser_type' => 'firefox'},
+          feature_enabled: false,
+          feature_key: 'string_single_variable_feature',
+          source: 'ROLLOUT',
+          source_experiment_key: nil,
+          source_variation_key: nil
+        ).ordered
+
+        expect(project_instance.notification_center).to receive(:send_notifications).once.with(
+          Optimizely::NotificationCenter::NOTIFICATION_TYPES[:DECISION],
+          'feature', 'test_user', {'browser_type' => 'firefox'},
+          feature_enabled: false,
+          feature_key: 'multi_variate_feature',
+          source: 'ROLLOUT',
+          source_experiment_key: nil,
+          source_variation_key: nil
+        ).ordered
+
+        expect(project_instance.notification_center).to receive(:send_notifications).once.with(
+          Optimizely::NotificationCenter::NOTIFICATION_TYPES[:DECISION],
+          'feature', 'test_user', {'browser_type' => 'firefox'},
+          feature_enabled: false,
+          feature_key: 'mutex_group_feature',
+          source: 'ROLLOUT',
+          source_experiment_key: nil,
+          source_variation_key: nil
+        ).ordered
+
+        expect(project_instance.notification_center).to receive(:send_notifications).once.with(
+          Optimizely::NotificationCenter::NOTIFICATION_TYPES[:DECISION],
+          'feature', 'test_user', {'browser_type' => 'firefox'},
+          feature_enabled: false,
+          feature_key: 'empty_feature',
+          source: 'ROLLOUT',
+          source_experiment_key: nil,
+          source_variation_key: nil
+        ).ordered
+
+        expect(project_instance.get_enabled_features('test_user', 'browser_type' => 'firefox')).to eq(enabled_features)
+      end
+    end
   end
 
   describe '#get_feature_variable_string' do
