split 2.1.0 → 2.2.0

data/lib/split/extensions.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
-%w[array string].each do |f|
+%w[string].each do |f|
   require "split/extensions/#{f}"
 end

data/lib/split/goals_collection.rb

@@ -22,7 +22,7 @@ module Split
 
     def save
       return false if @goals.nil?
-      @goals.reverse.each { |goal| Split.redis.lpush(goals_key, goal) }
+      RedisInterface.new.persist_list(goals_key, @goals)
     end
 
     def validate!

data/lib/split/redis_interface.rb

@@ -0,0 +1,51 @@
+module Split
+  # Simplifies the interface to Redis.
+  class RedisInterface
+    def initialize
+      self.redis = Split.redis
+    end
+
+    def persist_list(list_name, list_values)
+      max_index = list_length(list_name) - 1
+      list_values.each_with_index do |value, index|
+        if index > max_index
+          add_to_list(list_name, value)
+        else
+          set_list_index(list_name, index, value)
+        end
+      end
+      make_list_length(list_name, list_values.length)
+      list_values
+    end
+
+    def add_to_list(list_name, value)
+      redis.rpush(list_name, value)
+    end
+
+    def set_list_index(list_name, index, value)
+      redis.lset(list_name, index, value)
+    end
+
+    def list_length(list_name)
+      redis.llen(list_name)
+    end
+
+    def remove_last_item_from_list(list_name)
+      redis.rpop(list_name)
+    end
+
+    def make_list_length(list_name, new_length)
+      while list_length(list_name) > new_length
+        remove_last_item_from_list(list_name)
+      end
+    end
+
+    def add_to_set(set_name, value)
+      redis.sadd(set_name, value) unless redis.sismember(set_name, value)
+    end
+
+    private
+
+    attr_accessor :redis
+  end
+end

data/lib/split/user.rb

@@ -21,7 +21,7 @@ module Split
     def max_experiments_reached?(experiment_key)
       if Split.configuration.allow_multiple_experiments == 'control'
         experiments = active_experiments
-        count_control = experiments.values.count {|v| v == 'control'}
+        count_control = experiments.count {|k,v| k == experiment_key || v == 'control'}
         experiments.size > count_control
       else
         !Split.configuration.allow_multiple_experiments &&

data/lib/split/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 module Split
   MAJOR   = 2
-  MINOR   = 1
+  MINOR   = 2
   PATCH   = 0
   VERSION = [MAJOR, MINOR, PATCH].join('.')
 end

data/spec/configuration_spec.rb

@@ -212,20 +212,34 @@ describe Split::Configuration do
     expect(@config.normalized_experiments).to eq({:my_experiment=>{:alternatives=>[{"control_opt"=>0.67}, [{"second_opt"=>0.1}, {"third_opt"=>0.23}]]}})
   end
 
-  context "configuration URL" do
+  context 'redis_url configuration [DEPRECATED]' do
+    it 'should warn on set and assign to #redis' do
+      expect(@config).to receive(:warn).with(/\[DEPRECATED\]/) { nil }
+      @config.redis_url = 'example_url'
+      expect(@config.redis).to eq('example_url')
+    end
+
+    it 'should warn on get and return #redis' do
+      expect(@config).to receive(:warn).with(/\[DEPRECATED\]/) { nil }
+      @config.redis = 'example_url'
+      expect(@config.redis_url).to eq('example_url')
+    end
+  end
+
+  context "redis configuration" do
     it "should default to local redis server" do
-      expect(@config.redis_url).to eq("localhost:6379")
+      expect(@config.redis).to eq("redis://localhost:6379")
     end
 
     it "should allow for redis url to be configured" do
-      @config.redis_url = "custom_redis_url"
-      expect(@config.redis_url).to eq("custom_redis_url")
+      @config.redis = "custom_redis_url"
+      expect(@config.redis).to eq("custom_redis_url")
     end
 
     context "provided REDIS_URL environment variable" do
       it "should use the ENV variable" do
         ENV['REDIS_URL'] = "env_redis_url"
-        expect(Split::Configuration.new.redis_url).to eq("env_redis_url")
+        expect(Split::Configuration.new.redis).to eq("env_redis_url")
       end
     end
   end

data/spec/dashboard_spec.rb

@@ -73,6 +73,21 @@ describe Split::Dashboard do
     end
   end
 
+  describe "force alternative" do
+    let!(:user) do
+      Split::User.new(@app, { experiment.name => 'a' })
+    end
+
+    before do
+      allow(Split::User).to receive(:new).and_return(user)
+    end
+
+    it "should set current user's alternative" do
+      post "/force_alternative?experiment=#{experiment.name}", alternative: "b"
+      expect(user[experiment.name]).to eq("b")
+    end
+  end
+
   describe "index page" do
     context "with winner" do
       before { experiment.winner = 'red' }

data/spec/encapsulated_helper_spec.rb

@@ -4,18 +4,49 @@ require 'spec_helper'
 describe Split::EncapsulatedHelper do
   include Split::EncapsulatedHelper
 
-  before do
-    allow_any_instance_of(Split::EncapsulatedHelper::ContextShim).to receive(:ab_user)
-        .and_return(mock_user)
-  end
 
   def params
     raise NoMethodError, 'This method is not really defined'
   end
 
   describe "ab_test" do
+    before do
+      allow_any_instance_of(Split::EncapsulatedHelper::ContextShim).to receive(:ab_user)
+      .and_return(mock_user)
+    end
+
     it "should not raise an error when params raises an error" do
+      expect{ params }.to raise_error(NoMethodError)
       expect(lambda { ab_test('link_color', 'blue', 'red') }).not_to raise_error
     end
+
+    it "calls the block with selected alternative" do
+      expect{|block| ab_test('link_color', 'red', 'red', &block) }.to yield_with_args('red', nil)
+    end
+
+    context "inside a view" do
+
+      it "works inside ERB" do
+        require 'erb'
+        template = ERB.new(<<-ERB.split(/\s+/s).map(&:strip).join(' '), nil, "%")
+          foo <% ab_test(:foo, '1', '2') do |alt, meta| %>
+            static <%= alt %>
+          <% end %>
+        ERB
+        expect(template.result(binding)).to match /foo  static \d/
+      end
+
+    end
+  end
+
+  describe "context" do
+    it 'is passed in shim' do
+      ctx = Class.new{
+        include Split::EncapsulatedHelper
+        public :session
+      }.new
+      expect(ctx).to receive(:session){{}}
+      expect{ ctx.ab_test('link_color', 'blue', 'red') }.not_to raise_error
+    end
   end
 end

data/spec/experiment_spec.rb

@@ -13,9 +13,7 @@ describe Split::Experiment do
     Split::Alternative.new(color, 'link_color')
   end
 
-  let(:experiment) {
-    new_experiment
-  }
+  let(:experiment) { new_experiment }
 
   let(:blue) { alternative("blue") }
   let(:green) { alternative("green") }
@@ -242,7 +240,15 @@ describe Split::Experiment do
   end
 
   describe 'reset' do
-    before { experiment.save }
+    let(:reset_manually) { false }
+
+    before do
+      allow(Split.configuration).to receive(:reset_manually).and_return(reset_manually)
+      experiment.save
+      green.increment_participation
+      green.increment_participation
+    end
+
     it 'should reset all alternatives' do
       experiment.winner = 'green'
 
@@ -352,6 +358,34 @@ describe Split::Experiment do
       same_experiment_again = same_but_different_alternative
       expect(same_experiment_again.version).to eq(1)
     end
+
+    context 'when experiment configuration is changed' do
+      let(:reset_manually) { false }
+
+      before do
+        experiment.save
+        allow(Split.configuration).to receive(:reset_manually).and_return(reset_manually)
+        green.increment_participation
+        green.increment_participation
+        experiment.set_alternatives_and_options(alternatives: %w(blue red green zip),
+                                                goals: %w(purchase))
+        experiment.save
+      end
+
+      it 'resets all alternatives' do
+        expect(green.participant_count).to eq(0)
+        expect(green.completed_count).to eq(0)
+      end
+
+      context 'when reset_manually is set' do
+        let(:reset_manually) { true }
+
+        it 'does not reset alternatives' do
+          expect(green.participant_count).to eq(2)
+          expect(green.completed_count).to eq(0)
+        end
+      end
+    end
   end
 
   describe 'alternatives passed as non-strings' do
@@ -448,5 +482,4 @@ describe Split::Experiment do
       expect(experiment.calc_winning_alternatives).to be nil
     end
   end
-
 end

data/spec/helper_spec.rb

@@ -197,24 +197,51 @@ describe Split::Helper do
       expect(button_size_alt.participant_count).to eq(1)
     end
 
-    it "should let a user participate in many experiment with one non-'control' alternative with allow_multiple_experiments = 'control'" do
-      Split.configure do |config|
-        config.allow_multiple_experiments = 'control'
-      end
-      groups = []
-      (0..100).each do |n|
-        alt = ab_test("test#{n}".to_sym, {'control' => (100 - n)}, {'test#{n}-alt' => n})
-        groups << alt
+    context "with allow_multiple_experiments = 'control'" do
+      it "should let a user participate in many experiment with one non-'control' alternative" do
+        Split.configure do |config|
+          config.allow_multiple_experiments = 'control'
+        end
+        groups = 100.times.map do |n|
+          ab_test("test#{n}".to_sym, {'control' => (100 - n)}, {"test#{n}-alt" => n})
+        end
+
+        experiments = ab_user.active_experiments
+        expect(experiments.size).to be > 1
+
+        count_control = experiments.values.count { |g| g == 'control' }
+        expect(count_control).to eq(experiments.size - 1)
+
+        count_alts = groups.count { |g| g != 'control' }
+        expect(count_alts).to eq(1)
       end
 
-      experiments = ab_user.active_experiments
-      expect(experiments.size).to be > 1
+      context "when user already has experiment" do
+        let(:mock_user){ Split::User.new(self, {'test_0' => 'test-alt'}) }
+        before{
+          Split.configure do |config|
+            config.allow_multiple_experiments = 'control'
+          end
+          Split::ExperimentCatalog.find_or_initialize('test_0', 'control', 'test-alt').save
+          Split::ExperimentCatalog.find_or_initialize('test_1', 'control', 'test-alt').save
+        }
 
-      count_control = experiments.values.count { |g| g == 'control' }
-      expect(count_control).to eq(experiments.size - 1)
+        it "should restore previously selected alternative" do
+          expect(ab_user.active_experiments.size).to eq 1
+          expect(ab_test(:test_0, {'control' => 100}, {"test-alt" => 1})).to eq 'test-alt'
+          expect(ab_test(:test_0, {'control' => 1}, {"test-alt" => 100})).to eq 'test-alt'
+        end
+
+        it "lets override existing choice" do
+          pending "this requires user store reset on first call not depending on whelther it is current trial"
+          @params = { 'ab_test' => { 'test_1' => 'test-alt' } }
+
+          expect(ab_test(:test_0, {'control' => 0}, {"test-alt" => 100})).to eq 'control'
+          expect(ab_test(:test_1, {'control' => 100}, {"test-alt" => 1})).to eq 'test-alt'
+        end
+
+      end
 
-      count_alts = groups.count { |g| g != 'control' }
-      expect(count_alts).to eq(1)
     end
 
     it "should not over-write a finished key when an experiment is on a later version" do
@@ -642,6 +669,22 @@ describe Split::Helper do
 
       it_behaves_like "a disabled test"
     end
+
+    context "when ignored other address" do
+      before do
+        @request = OpenStruct.new(:ip => '1.1.1.1')
+        Split.configure do |c|
+          c.ignore_ip_addresses << '81.19.48.130'
+        end
+      end
+
+      it "works as usual" do
+        alternative_name = ab_test('link_color', 'red', 'blue')
+        expect{
+          ab_finished('link_color')
+        }.to change(Split::Alternative.new(alternative_name, 'link_color'), :completed_count).by(1)
+      end
+    end
   end
 
   describe 'versioned experiments' do
@@ -774,7 +817,7 @@ describe Split::Helper do
             end
           end
 
-          expect(Split.configuration.db_failover_on_db_error).to receive(:call)
+          expect(Split.configuration.db_failover_on_db_error).to receive(:call).and_call_original
           ab_test('link_color', 'blue', 'red')
         end
 
@@ -833,7 +876,7 @@ describe Split::Helper do
             end
           end
 
-          expect(Split.configuration.db_failover_on_db_error).to receive(:call)
+          expect(Split.configuration.db_failover_on_db_error).to receive(:call).and_call_original
           ab_finished('link_color')
         end
       end

data/spec/persistence/dual_adapter_spec.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe Split::Persistence::DualAdapter do
+
+  let(:context){ "some context" }
+
+  let(:just_adapter){ Class.new }
+  let(:selected_adapter_instance){ double }
+  let(:selected_adapter){
+    c = Class.new
+    expect(c).to receive(:new){ selected_adapter_instance }
+    c
+  }
+  let(:not_selected_adapter){
+    c = Class.new
+    expect(c).not_to receive(:new)
+    c
+  }
+
+  shared_examples_for "forwarding calls" do
+    it "#[]=" do
+      expect(selected_adapter_instance).to receive(:[]=).with('my_key', 'my_value')
+      expect_any_instance_of(not_selected_adapter).not_to receive(:[]=)
+      subject["my_key"] = "my_value"
+    end
+
+    it "#[]" do
+      expect(selected_adapter_instance).to receive(:[]).with('my_key'){'my_value'}
+      expect_any_instance_of(not_selected_adapter).not_to receive(:[])
+      expect(subject["my_key"]).to eq('my_value')
+    end
+
+    it "#delete" do
+      expect(selected_adapter_instance).to receive(:delete).with('my_key'){'my_value'}
+      expect_any_instance_of(not_selected_adapter).not_to receive(:delete)
+      expect(subject.delete("my_key")).to eq('my_value')
+    end
+
+    it "#keys" do
+      expect(selected_adapter_instance).to receive(:keys){'my_value'}
+      expect_any_instance_of(not_selected_adapter).not_to receive(:keys)
+      expect(subject.keys).to eq('my_value')
+    end
+  end
+
+  context "when logged in" do
+    subject {
+      described_class.with_config(
+        logged_in: -> (context) { true },
+        logged_in_adapter: selected_adapter,
+        logged_out_adapter: not_selected_adapter
+        ).new(context)
+    }
+
+    it_should_behave_like "forwarding calls"
+  end
+
+  context "when not logged in" do
+    subject {
+      described_class.with_config(
+        logged_in: -> (context) { false },
+        logged_in_adapter: not_selected_adapter,
+        logged_out_adapter: selected_adapter
+        ).new(context)
+    }
+
+    it_should_behave_like "forwarding calls"
+  end
+
+  describe "when errors in config" do
+    before{
+      described_class.config.clear
+    }
+    let(:some_proc){ ->{} }
+    it "when no logged in adapter" do
+      expect{
+        described_class.with_config(
+          logged_in: some_proc,
+          logged_out_adapter: just_adapter
+          ).new(context)
+      }.to raise_error(StandardError, /:logged_in_adapter/)
+    end
+    it "when no logged out adapter" do
+      expect{
+        described_class.with_config(
+          logged_in: some_proc,
+          logged_in_adapter: just_adapter
+          ).new(context)
+      }.to raise_error(StandardError, /:logged_out_adapter/)
+    end
+    it "when no logged in detector" do
+      expect{
+        described_class.with_config(
+          logged_in_adapter: just_adapter,
+          logged_out_adapter: just_adapter
+          ).new(context)
+      }.to raise_error(StandardError, /:logged_in$/)
+    end
+  end
+
+end