split 3.3.0 → 4.0.0.pre

data/spec/configuration_spec.rb

@@ -212,20 +212,6 @@ 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 '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).to eq("redis://localhost:6379")
@@ -240,6 +226,7 @@ describe Split::Configuration do
       it "should use the ENV variable" do
         ENV['REDIS_URL'] = "env_redis_url"
         expect(Split::Configuration.new.redis).to eq("env_redis_url")
+        ENV.delete('REDIS_URL')
       end
     end
   end

data/spec/dashboard/pagination_helpers_spec.rb

@@ -10,7 +10,9 @@ describe Split::DashboardPaginationHelpers do
     context 'when params empty' do
       let(:params) { Hash[] }
 
-      it 'returns 10' do
+      it 'returns the default (10)' do
+        default_per_page = Split.configuration.dashboard_pagination_default_per_page
+        expect(pagination_per).to eql default_per_page
         expect(pagination_per).to eql 10
       end
     end

data/spec/dashboard_helpers_spec.rb

@@ -27,11 +27,11 @@ describe Split::DashboardHelpers do
 
     describe '#round' do
       it 'can round number strings' do
-        expect(round('3.1415')).to eq BigDecimal.new('3.14')
+        expect(round('3.1415')).to eq BigDecimal('3.14')
       end
 
       it 'can round number strings for precsion' do
-        expect(round('3.1415', 1)).to eq BigDecimal.new('3.1')
+        expect(round('3.1415', 1)).to eq BigDecimal('3.1')
       end
 
       it 'can handle invalid number strings' do

data/spec/dashboard_spec.rb

@@ -6,8 +6,16 @@ require 'split/dashboard'
 describe Split::Dashboard do
   include Rack::Test::Methods
 
+  class TestDashboard < Split::Dashboard
+    include Split::Helper
+
+    get '/my_experiment' do
+      ab_test(params[:experiment], 'blue', 'red')
+    end
+  end
+
   def app
-    @app ||= Split::Dashboard
+    @app ||= TestDashboard
   end
 
   def link(color)
@@ -29,6 +37,10 @@ describe Split::Dashboard do
   let(:red_link) { link("red") }
   let(:blue_link) { link("blue") }
 
+  before(:each) do
+    Split.configuration.beta_probability_simulations = 1
+  end
+
   it "should respond to /" do
     get '/'
     expect(last_response).to be_ok
@@ -74,17 +86,49 @@ describe Split::Dashboard do
   end
 
   describe "force alternative" do
-    let!(:user) do
-      Split::User.new(@app, { experiment.name => 'a' })
-    end
+    context "initial version" do
+      let!(:user) do
+        Split::User.new(@app, { experiment.name => 'red' })
+      end
 
-    before do
-      allow(Split::User).to receive(:new).and_return(user)
+      before do
+        allow(Split::User).to receive(:new).and_return(user)
+      end
+
+      it "should set current user's alternative" do
+        blue_link.participant_count = 7
+        post "/force_alternative?experiment=#{experiment.name}", alternative: "blue"
+
+        get "/my_experiment?experiment=#{experiment.name}"
+        expect(last_response.body).to include("blue")
+      end
+
+      it "should not modify an existing user" do
+        blue_link.participant_count = 7
+        post "/force_alternative?experiment=#{experiment.name}", alternative: "blue"
+
+        expect(user[experiment.key]).to eq("red")
+        expect(blue_link.participant_count).to eq(7)
+      end
     end
 
-    it "should set current user's alternative" do
-      post "/force_alternative?experiment=#{experiment.name}", alternative: "b"
-      expect(user[experiment.name]).to eq("b")
+    context "incremented version" do
+      let!(:user) do
+        experiment.increment_version
+        Split::User.new(@app, { "#{experiment.name}:#{experiment.version}" => 'red' })
+      end
+
+      before do
+        allow(Split::User).to receive(:new).and_return(user)
+      end
+
+      it "should set current user's alternative" do
+        blue_link.participant_count = 7
+        post "/force_alternative?experiment=#{experiment.name}", alternative: "blue"
+
+        get "/my_experiment?experiment=#{experiment.name}"
+        expect(last_response.body).to include("blue")
+      end
     end
   end
 
@@ -120,7 +164,7 @@ describe Split::Dashboard do
     it "removes winner" do
       post "/reopen?experiment=#{experiment.name}"
 
-      expect(experiment).to_not have_winner
+      expect(Split::ExperimentCatalog.find(experiment.name)).to_not have_winner
     end
 
     it "keeps existing stats" do
@@ -135,6 +179,28 @@ describe Split::Dashboard do
     end
   end
 
+  describe "update cohorting" do
+    it "calls enable of cohorting when action is enable" do
+      post "/update_cohorting?experiment=#{experiment.name}", { "cohorting_action": "enable" }
+
+      expect(experiment.cohorting_disabled?).to eq false
+    end
+
+    it "calls disable of cohorting when action is disable" do
+      post "/update_cohorting?experiment=#{experiment.name}", { "cohorting_action": "disable" }
+
+      expect(experiment.cohorting_disabled?).to eq true
+    end
+
+    it "calls neither enable or disable cohorting when passed invalid action" do
+      previous_value = experiment.cohorting_disabled?
+
+      post "/update_cohorting?experiment=#{experiment.name}", { "cohorting_action": "other" }
+
+      expect(experiment.cohorting_disabled?).to eq previous_value
+    end
+  end
+
   it "should reset an experiment" do
     red_link.participant_count = 5
     blue_link.participant_count = 7
@@ -167,19 +233,14 @@ describe Split::Dashboard do
   end
 
   it "should display the start date" do
-    experiment_start_time = Time.parse('2011-07-07')
-    expect(Time).to receive(:now).at_least(:once).and_return(experiment_start_time)
-    experiment
+    experiment.start
 
     get '/'
 
-    expect(last_response.body).to include('<small>2011-07-07</small>')
+    expect(last_response.body).to include("<small>#{experiment.start_time.strftime('%Y-%m-%d')}</small>")
   end
 
   it "should handle experiments without a start date" do
-    experiment_start_time = Time.parse('2011-07-07')
-    expect(Time).to receive(:now).at_least(:once).and_return(experiment_start_time)
-
     Split.redis.hdel(:experiment_start_times, experiment.name)
 
     get '/'

data/spec/encapsulated_helper_spec.rb

@@ -21,7 +21,7 @@ describe Split::EncapsulatedHelper do
     end
 
     it "calls the block with selected alternative" do
-      expect{|block| ab_test('link_color', 'red', 'red', &block) }.to yield_with_args('red', nil)
+      expect{|block| ab_test('link_color', 'red', 'red', &block) }.to yield_with_args('red', {})
     end
 
     context "inside a view" do
@@ -33,7 +33,7 @@ describe Split::EncapsulatedHelper do
             static <%= alt %>
           <% end %>
         ERB
-        expect(template.result(binding)).to match /foo  static \d/
+        expect(template.result(binding)).to match(/foo  static \d/)
       end
 
     end

data/spec/experiment_spec.rb

@@ -37,7 +37,7 @@ describe Split::Experiment do
 
     it "should save to redis" do
       experiment.save
-      expect(Split.redis.exists('basket_text')).to be true
+      expect(Split.redis.exists?('basket_text')).to be true
     end
 
     it "should save the start time to redis" do
@@ -85,8 +85,8 @@ describe Split::Experiment do
     it "should not create duplicates when saving multiple times" do
       experiment.save
       experiment.save
-      expect(Split.redis.exists('basket_text')).to be true
-      expect(Split.redis.lrange('basket_text', 0, -1)).to eq(['Basket', "Cart"])
+      expect(Split.redis.exists?('basket_text')).to be true
+      expect(Split.redis.lrange('basket_text', 0, -1)).to eq(['{"Basket":1}', '{"Cart":1}'])
     end
 
     describe 'new record?' do
@@ -118,6 +118,23 @@ describe Split::Experiment do
       experiment = Split::Experiment.new('basket_text', :alternatives => ['Basket', "Cart"], :resettable => false)
       expect(experiment.resettable).to be_falsey
     end
+
+    context 'from configuration' do
+      let(:experiment_name) { :my_experiment }
+      let(:experiments) do
+        {
+          experiment_name => {
+            :alternatives => ['Control Opt', 'Alt one']
+          }
+        }
+      end
+
+      before { Split.configuration.experiments = experiments }
+
+      it 'assigns default values to the experiment' do
+        expect(Split::Experiment.new(experiment_name).resettable).to eq(true)
+      end
+    end
   end
 
   describe 'persistent configuration' do
@@ -134,10 +151,23 @@ describe Split::Experiment do
 
     describe '#metadata' do
       let(:experiment) { Split::Experiment.new('basket_text', :alternatives => ['Basket', "Cart"], :algorithm => Split::Algorithms::Whiplash, :metadata => meta) }
+      let(:meta) { { a: 'b' }}
+
+      before do
+        experiment.save
+      end
+
+      it "should delete the key when metadata is removed" do
+        experiment.metadata = nil
+        experiment.save
+
+        expect(Split.redis.exists?(experiment.metadata_key)).to be_falsey
+      end
+
       context 'simple hash' do
         let(:meta) {  { 'basket' => 'a', 'cart' => 'b' } }
+
         it "should persist metadata in redis" do
-          experiment.save
           e = Split::ExperimentCatalog.find('basket_text')
           expect(e).to eq(experiment)
           expect(e.metadata).to eq(meta)
@@ -147,7 +177,6 @@ describe Split::Experiment do
       context 'nested hash' do
         let(:meta) {  { 'basket' => { 'one' => 'two' }, 'cart' => 'b' } }
         it "should persist metadata in redis" do
-          experiment.save
           e = Split::ExperimentCatalog.find('basket_text')
           expect(e).to eq(experiment)
           expect(e.metadata).to eq(meta)
@@ -180,7 +209,7 @@ describe Split::Experiment do
       experiment.save
 
       experiment.delete
-      expect(Split.redis.exists('link_color')).to be false
+      expect(Split.redis.exists?('link_color')).to be false
       expect(Split::ExperimentCatalog.find('link_color')).to be_nil
     end
 
@@ -206,19 +235,59 @@ describe Split::Experiment do
       experiment.delete
       expect(experiment.start_time).to be_nil
     end
-  end
 
+    it "should default cohorting back to false" do
+      experiment.disable_cohorting
+      expect(experiment.cohorting_disabled?).to eq(true)
+      experiment.delete
+      expect(experiment.cohorting_disabled?).to eq(false)
+    end
+  end
 
   describe 'winner' do
     it "should have no winner initially" do
       expect(experiment.winner).to be_nil
     end
+  end
 
-    it "should allow you to specify a winner" do
+  describe 'winner=' do
+    it 'should allow you to specify a winner' do
       experiment.save
       experiment.winner = 'red'
       expect(experiment.winner.name).to eq('red')
     end
+
+    it 'should call the on_experiment_winner_choose hook' do
+      expect(Split.configuration.on_experiment_winner_choose).to receive(:call)
+      experiment.winner = 'green'
+    end
+
+    context 'when has_winner state is memoized' do
+      before { expect(experiment).to_not have_winner }
+
+      it 'should keep has_winner state consistent' do
+        experiment.winner = 'red'
+        expect(experiment).to have_winner
+      end
+    end
+  end
+
+  describe 'reset_winner' do
+    before { experiment.winner = 'green' }
+
+    it 'should reset the winner' do
+      experiment.reset_winner
+      expect(experiment.winner).to be_nil
+    end
+
+    context 'when has_winner state is memoized' do
+      before { expect(experiment).to have_winner }
+
+      it 'should keep has_winner state consistent' do
+        experiment.reset_winner
+        expect(experiment).to_not have_winner
+      end
+    end
   end
 
   describe 'has_winner?' do
@@ -235,6 +304,12 @@ describe Split::Experiment do
         expect(experiment).to_not have_winner
       end
     end
+
+    it 'memoizes has_winner state' do
+      expect(experiment).to receive(:winner).once
+      expect(experiment).to_not have_winner
+      expect(experiment).to_not have_winner
+    end
   end
 
   describe 'reset' do
@@ -335,6 +410,22 @@ describe Split::Experiment do
     end
   end
 
+  describe "#cohorting_disabled?" do
+    it "returns false when nothing has been configured" do
+      expect(experiment.cohorting_disabled?).to eq false
+    end
+
+    it "returns true when enable_cohorting is performed" do
+      experiment.enable_cohorting
+      expect(experiment.cohorting_disabled?).to eq false
+    end
+
+    it "returns false when nothing has been configured" do
+      experiment.disable_cohorting
+      expect(experiment.cohorting_disabled?).to eq true
+    end
+  end
+
   describe 'changing an existing experiment' do
     def same_but_different_alternative
       Split::ExperimentCatalog.find_or_create('link_color', 'blue', 'yellow', 'orange')
@@ -357,6 +448,21 @@ describe Split::Experiment do
       expect(same_experiment_again.version).to eq(1)
     end
 
+    context "when metadata is changed" do
+      it "should increase version" do
+        experiment.save
+        experiment.metadata = { 'foo' => 'bar' }
+
+        expect { experiment.save }.to change { experiment.version }.by(1)
+      end
+
+      it "does not increase version" do
+        experiment.metadata = nil
+        experiment.save
+        expect { experiment.save }.to change { experiment.version }.by(0)
+      end
+    end
+
     context 'when experiment configuration is changed' do
       let(:reset_manually) { false }
 
@@ -414,9 +520,7 @@ describe Split::Experiment do
     }
 
     context "saving experiment" do
-      def same_but_different_goals
-        Split::ExperimentCatalog.find_or_create({'link_color' => ["purchase", "refund"]}, 'blue', 'red', 'green')
-      end
+      let(:same_but_different_goals) { Split::ExperimentCatalog.find_or_create({'link_color' => ["purchase", "refund"]}, 'blue', 'red', 'green') }
 
       before { experiment.save }
 
@@ -425,7 +529,7 @@ describe Split::Experiment do
       end
 
       it "should reset an experiment if it is loaded with different goals" do
-        same_experiment = same_but_different_goals
+        same_but_different_goals
         expect(Split::ExperimentCatalog.find("link_color").goals).to eq(["purchase", "refund"])
       end
 

data/spec/goals_collection_spec.rb

@@ -48,7 +48,7 @@ describe Split::GoalsCollection do
       goals_collection.save
 
       goals_collection.delete
-      expect(Split.redis.exists(goals_key)).to be false
+      expect(Split.redis.exists?(goals_key)).to be false
     end
   end
 

data/spec/helper_spec.rb

@@ -183,8 +183,7 @@ describe Split::Helper do
       ab_test('link_color', {'blue' => 0.01}, 'red' => 0.2)
       experiment = Split::ExperimentCatalog.find('link_color')
       expect(experiment.alternatives.map(&:name)).to eq(['blue', 'red'])
-      # TODO: persist alternative weights
-      # expect(experiment.alternatives.collect{|a| a.weight}).to eq([0.01, 0.2])
+      expect(experiment.alternatives.collect{|a| a.weight}).to match_array([0.01, 0.2])
     end
 
     it "should only let a user participate in one experiment at a time" do
@@ -230,13 +229,15 @@ describe Split::Helper do
 
       context "when user already has experiment" do
         let(:mock_user){ Split::User.new(self, {'test_0' => 'test-alt'}) }
-        before{
+
+        before do
           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
-        }
+        end
 
         it "should restore previously selected alternative" do
           expect(ab_user.active_experiments.size).to eq 1
@@ -244,6 +245,16 @@ describe Split::Helper do
           expect(ab_test(:test_0, {'control' => 1}, {"test-alt" => 100})).to eq 'test-alt'
         end
 
+        it "should select the correct alternatives after experiment resets" do
+          experiment = Split::ExperimentCatalog.find(:test_0)
+          experiment.reset
+          mock_user[experiment.key] = 'test-alt'
+
+          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' => 0}, {"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' } }
@@ -266,129 +277,187 @@ describe Split::Helper do
   end
 
   describe 'metadata' do
-    before do
-      Split.configuration.experiments = {
-        :my_experiment => {
-          :alternatives => ["one", "two"],
-          :resettable => false,
-          :metadata => { 'one' => 'Meta1', 'two' => 'Meta2' }
+    context 'is defined' do
+      before do
+        Split.configuration.experiments = {
+          :my_experiment => {
+            :alternatives => ["one", "two"],
+            :resettable => false,
+            :metadata => { 'one' => 'Meta1', 'two' => 'Meta2' }
+          }
         }
-      }
-    end
+      end
 
-    it 'should be passed to helper block' do
-      @params = { 'ab_test' => { 'my_experiment' => 'one' } }
-      expect(ab_test('my_experiment')).to eq 'one'
-      expect(ab_test('my_experiment') do |alternative, meta|
-        meta
-      end).to eq('Meta1')
+      it 'should be passed to helper block' do
+        @params = { 'ab_test' => { 'my_experiment' => 'two' } }
+        expect(ab_test('my_experiment')).to eq 'two'
+        expect(ab_test('my_experiment') do |alternative, meta|
+          meta
+        end).to eq('Meta2')
+      end
+
+      it 'should pass control metadata helper block if library disabled' do
+        Split.configure do |config|
+          config.enabled = false
+        end
+
+        expect(ab_test('my_experiment')).to eq 'one'
+        expect(ab_test('my_experiment') do |_, meta|
+          meta
+        end).to eq('Meta1')
+      end
     end
 
-    it 'should pass empty hash to helper block if library disabled' do
-      Split.configure do |config|
-        config.enabled = false
+    context 'is not defined' do
+      before do
+        Split.configuration.experiments = {
+          :my_experiment => {
+            :alternatives => ["one", "two"],
+            :resettable => false,
+            :metadata => nil
+          }
+        }
       end
 
-      expect(ab_test('my_experiment')).to eq 'one'
-      expect(ab_test('my_experiment') do |_, meta|
-        meta
-      end).to eq({})
+      it 'should be passed to helper block' do
+        expect(ab_test('my_experiment') do |alternative, meta|
+          meta
+        end).to eq({})
+      end
+
+      it 'should pass control metadata helper block if library disabled' do
+        Split.configure do |config|
+          config.enabled = false
+        end
+
+        expect(ab_test('my_experiment') do |_, meta|
+          meta
+        end).to eq({})
+      end
     end
   end
 
   describe 'ab_finished' do
-    before(:each) do
-      @experiment_name = 'link_color'
-      @alternatives = ['blue', 'red']
-      @experiment = Split::ExperimentCatalog.find_or_create(@experiment_name, *@alternatives)
-      @alternative_name = ab_test(@experiment_name, *@alternatives)
-      @previous_completion_count = Split::Alternative.new(@alternative_name, @experiment_name).completed_count
-    end
+    context 'for an experiment that the user participates in' do
+      before(:each) do
+        @experiment_name = 'link_color'
+        @alternatives = ['blue', 'red']
+        @experiment = Split::ExperimentCatalog.find_or_create(@experiment_name, *@alternatives)
+        @alternative_name = ab_test(@experiment_name, *@alternatives)
+        @previous_completion_count = Split::Alternative.new(@alternative_name, @experiment_name).completed_count
+      end
 
-    it 'should increment the counter for the completed alternative' do
-      ab_finished(@experiment_name)
-      new_completion_count = Split::Alternative.new(@alternative_name, @experiment_name).completed_count
-      expect(new_completion_count).to eq(@previous_completion_count + 1)
-    end
+      it 'should increment the counter for the completed alternative' do
+        ab_finished(@experiment_name)
+        new_completion_count = Split::Alternative.new(@alternative_name, @experiment_name).completed_count
+        expect(new_completion_count).to eq(@previous_completion_count + 1)
+      end
 
-    it "should set experiment's finished key if reset is false" do
-      ab_finished(@experiment_name, {:reset => false})
-      expect(ab_user[@experiment.key]).to eq(@alternative_name)
-      expect(ab_user[@experiment.finished_key]).to eq(true)
-    end
+      it "should set experiment's finished key if reset is false" do
+        ab_finished(@experiment_name, {:reset => false})
+        expect(ab_user[@experiment.key]).to eq(@alternative_name)
+        expect(ab_user[@experiment.finished_key]).to eq(true)
+      end
 
-    it 'should not increment the counter if reset is false and the experiment has been already finished' do
-      2.times { ab_finished(@experiment_name, {:reset => false}) }
-      new_completion_count = Split::Alternative.new(@alternative_name, @experiment_name).completed_count
-      expect(new_completion_count).to eq(@previous_completion_count + 1)
-    end
+      it 'should not increment the counter if reset is false and the experiment has been already finished' do
+        2.times { ab_finished(@experiment_name, {:reset => false}) }
+        new_completion_count = Split::Alternative.new(@alternative_name, @experiment_name).completed_count
+        expect(new_completion_count).to eq(@previous_completion_count + 1)
+      end
 
-    it 'should not increment the counter for an experiment that the user is not participating in' do
-      ab_test('button_size', 'small', 'big')
+      it 'should not increment the counter for an ended experiment' do
+        e = Split::ExperimentCatalog.find_or_create('button_size', 'small', 'big')
+        e.winner = 'small'
+        a = ab_test('button_size', 'small', 'big')
+        expect(a).to eq('small')
+        expect(lambda {
+          ab_finished('button_size')
+        }).not_to change { Split::Alternative.new(a, 'button_size').completed_count }
+      end
 
-      # So, user should be participating in the link_color experiment and
-      # receive the control for button_size. As the user is not participating in
-      # the button size experiment, finishing it should not increase the
-      # completion count for that alternative.
-      expect(lambda {
-        ab_finished('button_size')
-      }).not_to change { Split::Alternative.new('small', 'button_size').completed_count }
-    end
+      it "should clear out the user's participation from their session" do
+        expect(ab_user[@experiment.key]).to eq(@alternative_name)
+        ab_finished(@experiment_name)
+        expect(ab_user.keys).to be_empty
+      end
 
-    it 'should not increment the counter for an ended experiment' do
-      e = Split::ExperimentCatalog.find_or_create('button_size', 'small', 'big')
-      e.winner = 'small'
-      a = ab_test('button_size', 'small', 'big')
-      expect(a).to eq('small')
-      expect(lambda {
-        ab_finished('button_size')
-      }).not_to change { Split::Alternative.new(a, 'button_size').completed_count }
-    end
+      it "should not clear out the users session if reset is false" do
+        expect(ab_user[@experiment.key]).to eq(@alternative_name)
+        ab_finished(@experiment_name, {:reset => false})
+        expect(ab_user[@experiment.key]).to eq(@alternative_name)
+        expect(ab_user[@experiment.finished_key]).to eq(true)
+      end
 
-    it "should clear out the user's participation from their session" do
-      expect(ab_user[@experiment.key]).to eq(@alternative_name)
-      ab_finished(@experiment_name)
-      expect(ab_user.keys).to be_empty
-    end
+      it "should reset the users session when experiment is not versioned" do
+        expect(ab_user[@experiment.key]).to eq(@alternative_name)
+        ab_finished(@experiment_name)
+        expect(ab_user.keys).to be_empty
+      end
 
-    it "should not clear out the users session if reset is false" do
-      expect(ab_user[@experiment.key]).to eq(@alternative_name)
-      ab_finished(@experiment_name, {:reset => false})
-      expect(ab_user[@experiment.key]).to eq(@alternative_name)
-      expect(ab_user[@experiment.finished_key]).to eq(true)
-    end
+      it "should reset the users session when experiment is versioned" do
+        @experiment.increment_version
+        @alternative_name = ab_test(@experiment_name, *@alternatives)
 
-    it "should reset the users session when experiment is not versioned" do
-      expect(ab_user[@experiment.key]).to eq(@alternative_name)
-      ab_finished(@experiment_name)
-      expect(ab_user.keys).to be_empty
-    end
+        expect(ab_user[@experiment.key]).to eq(@alternative_name)
+        ab_finished(@experiment_name)
+        expect(ab_user.keys).to be_empty
+      end
 
-    it "should reset the users session when experiment is versioned" do
-      @experiment.increment_version
-      @alternative_name = ab_test(@experiment_name, *@alternatives)
+      context "when on_trial_complete is set" do
+        before { Split.configuration.on_trial_complete = :some_method }
+        it "should call the method" do
+          expect(self).to receive(:some_method)
+          ab_finished(@experiment_name)
+        end
 
-      expect(ab_user[@experiment.key]).to eq(@alternative_name)
-      ab_finished(@experiment_name)
-      expect(ab_user.keys).to be_empty
+        it "should not call the method without alternative" do
+          ab_user[@experiment.key] = nil
+          expect(self).not_to receive(:some_method)
+          ab_finished(@experiment_name)
+        end
+      end
     end
 
-    it "should do nothing where the experiment was not started by this user" do
-      ab_user = nil
-      expect(lambda { ab_finished('some_experiment_not_started_by_the_user') }).not_to raise_exception
+    context 'for an experiment that the user is excluded from' do
+      before do
+        alternative = ab_test('link_color', 'blue', 'red')
+        expect(Split::Alternative.new(alternative, 'link_color').participant_count).to eq(1)
+        alternative = ab_test('button_size', 'small', 'big')
+        expect(Split::Alternative.new(alternative, 'button_size').participant_count).to eq(0)
+      end
+
+      it 'should not increment the completed counter' do
+        # So, user should be participating in the link_color experiment and
+        # receive the control for button_size. As the user is not participating in
+        # the button size experiment, finishing it should not increase the
+        # completion count for that alternative.
+        expect(lambda {
+          ab_finished('button_size')
+        }).not_to change { Split::Alternative.new('small', 'button_size').completed_count }
+      end
     end
 
-    context "when on_trial_complete is set" do
-      before { Split.configuration.on_trial_complete = :some_method }
-      it "should call the method" do
-        expect(self).to receive(:some_method)
-        ab_finished(@experiment_name)
+    context 'for an experiment that the user does not participate in' do
+      before do
+        Split::ExperimentCatalog.find_or_create(:not_started_experiment, 'control', 'alt')
+      end
+      it 'should not raise an exception' do
+        expect { ab_finished(:not_started_experiment) }.not_to raise_exception
       end
 
-      it "should not call the method without alternative" do
-        ab_user[@experiment.key] = nil
-        expect(self).not_to receive(:some_method)
-        ab_finished(@experiment_name)
+      it 'should not change the user state when reset is false' do
+        expect { ab_finished(:not_started_experiment, reset: false) }.not_to change { ab_user.keys}.from([])
+      end
+
+      it 'should not change the user state when reset is true' do
+        expect(self).not_to receive(:reset!)
+        ab_finished(:not_started_experiment)
+      end
+
+      it 'should not increment the completed counter' do
+        ab_finished(:not_started_experiment)
+        expect(Split::Alternative.new('control', :not_started_experiment).completed_count).to eq(0)
+        expect(Split::Alternative.new('alt', :not_started_experiment).completed_count).to eq(0)
       end
     end
   end
@@ -528,6 +597,17 @@ describe Split::Helper do
       expect(active_experiments.first[0]).to eq "link_color"
     end
 
+    it 'should show versioned tests properly' do
+      10.times { experiment.reset }
+
+      alternative = ab_test(experiment.name, 'blue', 'red')
+      ab_finished(experiment.name, reset: false)
+
+      expect(experiment.version).to eq(10)
+      expect(active_experiments.count).to eq 1
+      expect(active_experiments).to eq({'link_color' => alternative })
+    end
+
     it 'should show multiple tests' do
       Split.configure do |config|
         config.allow_multiple_experiments = true
@@ -545,7 +625,7 @@ describe Split::Helper do
       end
       e = Split::ExperimentCatalog.find_or_create('def', '4', '5', '6')
       e.winner = '4'
-      alternative = ab_test('def', '4', '5', '6')
+      ab_test('def', '4', '5', '6')
       another_alternative = ab_test('ghi', '7', '8', '9')
       expect(active_experiments.count).to eq 1
       expect(active_experiments.first[0]).to eq "ghi"
@@ -564,6 +644,11 @@ describe Split::Helper do
         expect(alternative).to eq experiment.control.name
       end
 
+      it 'should not create a experiment' do
+        ab_test('link_color', 'blue', 'red')
+        expect(Split::Experiment.new('link_color')).to be_a_new_record
+      end
+
       it "should not increment the participation count" do
 
         previous_red_count = Split::Alternative.new('red', 'link_color').participant_count
@@ -1016,8 +1101,8 @@ describe Split::Helper do
 
   it 'should handle multiple experiments correctly' do
     experiment2 = Split::ExperimentCatalog.find_or_create('link_color2', 'blue', 'red')
-    alternative_name = ab_test('link_color', 'blue', 'red')
-    alternative_name2 = ab_test('link_color2', 'blue', 'red')
+    ab_test('link_color', 'blue', 'red')
+    ab_test('link_color2', 'blue', 'red')
     ab_finished('link_color2')
 
     experiment2.alternatives.each do |alt|
@@ -1053,15 +1138,9 @@ describe Split::Helper do
       end
 
       it "should increment the counter for the specified-goal completed alternative" do
-        expect(lambda {
-          expect(lambda {
-            ab_finished({"link_color" => ["purchase"]})
-          }).not_to change {
-            Split::Alternative.new(@alternative_name, @experiment_name).completed_count(@goal2)
-          }
-        }).to change {
-          Split::Alternative.new(@alternative_name, @experiment_name).completed_count(@goal1)
-        }.by(1)
+        expect{ ab_finished({"link_color" => ["purchase"]}) }
+          .to change{ Split::Alternative.new(@alternative_name, @experiment_name).completed_count(@goal2) }.by(0)
+          .and change{ Split::Alternative.new(@alternative_name, @experiment_name).completed_count(@goal1) }.by(1)
       end
     end
   end