Updating whitelisting check to override audience check (#8)

* Forced variation precedence

* Tests

* Respond to feedback, update ProjectConfig spec to point to V2 datafile

Author: delikat

lib/optimizely.rb

@@ -160,6 +160,10 @@ def preconditions_valid?(experiment_key, user_id, attributes)
         return false
       end
 
+      if @config.user_in_forced_variation?(experiment_key, user_id)
+        return true
+      end
+
       unless Audience.user_in_experiment?(@config, experiment_key, attributes)
         @logger.log(Logger::INFO,
                     "User '#{user_id} does not meet the conditions to be in experiment '#{experiment_key}.")

lib/optimizely/project_config.rb

@@ -257,6 +257,19 @@ def get_attribute_id(attribute_key)
       nil
     end
 
+    def user_in_forced_variation?(experiment_key, user_id)
+      # Determines if a given user is in a forced variation
+      #
+      # experiment_key - String experiment key
+      # user_id - String user ID
+      #
+      # Returns true if user is in a forced variation
+
+      forced_variations = get_forced_variations(experiment_key)
+      return forced_variations.include?(user_id) if forced_variations
+      false
+    end
+
     private
 
     def generate_key_map(array, key)

spec/project_config_spec.rb

@@ -3,25 +3,40 @@
 require 'optimizely/exceptions'
 
 describe Optimizely::ProjectConfig do
-  let(:config_body) { OptimizelySpec::V1_CONFIG_BODY }
-  let(:config_body_JSON) { OptimizelySpec::V1_CONFIG_BODY_JSON }
+  let(:config_body) { OptimizelySpec::V2_CONFIG_BODY }
+  let(:config_body_JSON) { OptimizelySpec::V2_CONFIG_BODY_JSON }
   let(:error_handler) { Optimizely::NoOpErrorHandler.new }
   let(:logger) { Optimizely::NoOpLogger.new }
+  let(:config) { Optimizely::ProjectConfig.new(config_body_JSON, logger, error_handler)}
+
+  describe '#user_in_forced_variations' do
+    it 'should return false when the experiment has no forced variations' do
+      expect(config.user_in_forced_variation?('group1_exp1', 'test_user')).to be(false)
+    end
+
+    it 'should return false when the user is not in a forced variation' do
+      expect(config.user_in_forced_variation?('test_experiment', 'test_user')).to be(false)
+    end
+
+    it 'should return true when the user is in a forced variation' do
+      expect(config.user_in_forced_variation?('test_experiment', 'forced_user1')).to be(true)
+    end
+  end
 
   describe '.initialize' do
     it 'should initialize properties correctly upon creating project' do
       project_config = Optimizely::ProjectConfig.new(config_body_JSON, logger, error_handler)
 
       expect(project_config.account_id).to eq(config_body['accountId'])
-      expect(project_config.attributes).to eq(config_body['dimensions'])
+      expect(project_config.attributes).to eq(config_body['attributes'])
       expect(project_config.audiences).to eq(config_body['audiences'])
       expect(project_config.events).to eq(config_body['events'])
       expect(project_config.groups).to eq(config_body['groups'])
       expect(project_config.project_id).to eq(config_body['projectId'])
       expect(project_config.revision).to eq(config_body['revision'])
 
       expected_attribute_key_map = {
-        'browser_type' => config_body['dimensions'][0]
+        'browser_type' => config_body['attributes'][0]
       }
 
       expected_audience_id_map = {

spec/project_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require 'optimizely'
+require 'optimizely/audience'
 require 'optimizely/helpers/validator'
 require 'optimizely/exceptions'
 require 'optimizely/version'
@@ -98,8 +99,8 @@ class InvalidErrorHandler; end
       allow(project_instance.bucketer).to receive(:bucket).and_return('111128')
       allow(project_instance.event_dispatcher).to receive(:dispatch_event).with(instance_of(Optimizely::Event))
       allow(project_instance.config).to receive(:get_audience_ids_for_experiment)
-                                       .with('test_experiment')
-                                       .and_return([])
+                                    .with('test_experiment')
+                                    .and_return([])
 
       stub_request(:get, log_url).with(:query => params)
 
@@ -506,6 +507,41 @@ class InvalidErrorHandler; end
       expect { project_instance.activate('test_experiment', 'test_user', 'invalid') }
              .to raise_error(Optimizely::InvalidAttributeFormatError)
     end
+
+    it 'should override the audience check if the user is whitelisted to a specific variation' do
+      params = {
+        'projectId' => '111001',
+        'accountId' => '12001',
+        'visitorId' => 'forced_audience_user',
+        'userFeatures' => [
+          {
+            'id' => '111094',
+            'name' => 'browser_type',
+            'type' => 'custom',
+            'value' => 'wrong_browser',
+            'shouldIndex' => true,
+          },
+        ],
+        'clientEngine' => 'ruby-sdk',
+        'clientVersion' => version,
+        'timestamp' => (time_now.to_f * 1000).to_i,
+        'isGlobalHoldback' => false,
+        'layerId' => '3',
+        'decision' => {
+          'variationId' => '122229',
+          'experimentId' => '122227',
+          'isLayerHoldback' => false,
+        }
+      }
+
+      allow(project_instance.event_dispatcher).to receive(:dispatch_event).with(instance_of(Optimizely::Event))
+      allow(Optimizely::Audience).to receive(:user_in_experiment?)
+
+      expect(project_instance.activate('test_experiment_with_audience', 'forced_audience_user', 'browser_type' => 'wrong_browser'))
+        .to eq('variation_with_audience')
+      expect(project_instance.event_dispatcher).to have_received(:dispatch_event).with(Optimizely::Event.new(:post, impression_log_url, params, post_headers)).once
+      expect(Optimizely::Audience).to_not have_received(:user_in_experiment?)
+    end
   end
 
   describe '#track' do
@@ -681,6 +717,48 @@ class InvalidErrorHandler; end
       expect { project_instance.track('invalid_event', 'test_user') }.to raise_error(Optimizely::InvalidGoalError)
       expect(project_instance.event_dispatcher).to_not have_received(:dispatch_event)
     end
+
+    it 'should override the audience check if the user is whitelisted to a specific variation' do
+      params = {
+        'projectId' => '111001',
+        'accountId' => '12001',
+        'visitorId' => 'forced_audience_user',
+        'userFeatures' => [
+          {
+            'id' => '111094',
+            'name' => 'browser_type',
+            'type' => 'custom',
+            'value' => 'wrong_browser',
+            'shouldIndex' => true,
+          }
+        ],
+        'clientEngine' => 'ruby-sdk',
+        'clientVersion' => version,
+        'timestamp' => (time_now.to_f * 1000).to_i,
+        'isGlobalHoldback' => false,
+        'eventEntityId' => '111097',
+        'eventFeatures' => [],
+        'eventName' => 'test_event_with_audience',
+        'eventMetrics' => [],
+        'layerStates' => [
+          {
+            'layerId' => '3',
+            'decision' => {
+              'variationId' => '122229',
+              'experimentId' => '122227',
+              'isLayerHoldback' => false,
+            },
+            'actionTriggered' => true,
+          }
+        ]
+      }
+      allow(project_instance.event_dispatcher).to receive(:dispatch_event).with(instance_of(Optimizely::Event))
+      allow(Optimizely::Audience).to receive(:user_in_experiment?)
+
+      project_instance.track('test_event_with_audience', 'forced_audience_user', 'browser_type' => 'wrong_browser')
+      expect(Optimizely::Audience).to_not have_received(:user_in_experiment?)
+      expect(project_instance.event_dispatcher).to have_received(:dispatch_event).with(Optimizely::Event.new(:post, conversion_log_url, params, post_headers)).once
+    end
   end
 
   describe '#get_variation' do
@@ -712,5 +790,13 @@ class InvalidErrorHandler; end
       expect { project_instance.get_variation('test_experiment', 'test_user', 'invalid') }
              .to raise_error(Optimizely::InvalidAttributeFormatError)
     end
+
+    it 'should override the audience check if the user is whitelisted to a specific variation' do
+      allow(Optimizely::Audience).to receive(:user_in_experiment?)
+
+      expect(project_instance.get_variation('test_experiment_with_audience', 'forced_audience_user', 'browser_type' => 'wrong_browser'))
+        .to eq('variation_with_audience')
+      expect(Optimizely::Audience).to_not have_received(:user_in_experiment?)
+    end
   end
 end

spec/spec_params.rb

@@ -83,7 +83,9 @@ module OptimizelySpec
         'entityId' => '122229',
         'endOfRange' => 10000
       }],
-      'forcedVariations' => {},
+      'forcedVariations' => {
+        'forced_audience_user' => 'variation_with_audience',
+      },
       'id' => '122227',
       'percentageIncluded' => 10000,
       'variations' => [{