split 0.7.2 → 0.7.3

data/lib/split/dashboard/views/_experiment.erb

@@ -71,7 +71,7 @@
             <% end %>
           <% else %>
             <form action="<%= url experiment.name %>" method='post' onclick="return confirmWinner()">
-              <input type='hidden' name='alternative' value='<%= alternative.name %>'>
+              <input type='hidden' name='alternative' value='<%= h alternative.name %>'>
               <input type="submit" value="Use this" class="green">
             </form>
           <% end %>

data/lib/split/helper.rb

@@ -27,12 +27,13 @@ module Split
         else
           control_variable(control)
         end
-      rescue Errno::ECONNREFUSED => e
+      rescue Errno::ECONNREFUSED, Redis::CannotConnectError => e
         raise(e) unless Split.configuration.db_failover
         Split.configuration.db_failover_on_db_error.call(e)
 
-        if Split.configuration.db_failover_allow_parameter_override && override_present?(experiment_name)
-          ret = override_alternative(experiment_name)
+        if Split.configuration.db_failover_allow_parameter_override
+          ret = override_alternative(experiment_name) if override_present?(experiment_name)
+          ret = control_variable(control) if split_generically_disabled?
         end
       ensure
         ret ||= control_variable(control)
@@ -97,6 +98,10 @@ module Split
       params[experiment_name] if override_present?(experiment_name)
     end
 
+    def split_generically_disabled?
+      defined?(params) && params['SPLIT_DISABLE']
+    end
+
     def begin_experiment(experiment, alternative_name = nil)
       alternative_name ||= experiment.control.name
       ab_user[experiment.key] = alternative_name
@@ -169,6 +174,9 @@ module Split
       if override_present?(experiment.name) and experiment[override_alternative(experiment.name)]
         ret = override_alternative(experiment.name)
         ab_user[experiment.key] = ret if Split.configuration.store_override
+      elsif split_generically_disabled?
+        ret = experiment.control.name
+        ab_user[experiment.key] = ret if Split.configuration.store_override
       elsif experiment.has_winner?
         ret = experiment.winner.name
       else

data/lib/split/version.rb

@@ -1,6 +1,6 @@
 module Split
   MAJOR   = 0
   MINOR   = 7
-  PATCH   = 2
+  PATCH   = 3
   VERSION = [MAJOR, MINOR, PATCH].join('.')
 end

data/spec/algorithms/weighted_sample_spec.rb

@@ -3,16 +3,16 @@ require "spec_helper"
 describe Split::Algorithms::WeightedSample do
   it "should return an alternative" do
     experiment = Split::Experiment.find_or_create('link_color', {'blue' => 100}, {'red' => 0 })
-    Split::Algorithms::WeightedSample.choose_alternative(experiment).class.should == Split::Alternative
+    expect(Split::Algorithms::WeightedSample.choose_alternative(experiment).class).to eq(Split::Alternative)
   end
 
   it "should always return a heavily weighted option" do
     experiment = Split::Experiment.find_or_create('link_color', {'blue' => 100}, {'red' => 0 })
-    Split::Algorithms::WeightedSample.choose_alternative(experiment).name.should == 'blue'
+    expect(Split::Algorithms::WeightedSample.choose_alternative(experiment).name).to eq('blue')
   end
 
   it "should return one of the results" do
     experiment = Split::Experiment.find_or_create('link_color', {'blue' => 1}, {'red' => 1 })
-    ['red', 'blue'].should include Split::Algorithms::WeightedSample.choose_alternative(experiment).name
+    expect(['red', 'blue']).to include Split::Algorithms::WeightedSample.choose_alternative(experiment).name
   end
-end
+end

data/spec/algorithms/whiplash_spec.rb

@@ -4,20 +4,20 @@ describe Split::Algorithms::Whiplash do
 
   it "should return an algorithm" do
     experiment = Split::Experiment.find_or_create('link_color', {'blue' => 1}, {'red' => 1 })
-    Split::Algorithms::Whiplash.choose_alternative(experiment).class.should == Split::Alternative
+    expect(Split::Algorithms::Whiplash.choose_alternative(experiment).class).to eq(Split::Alternative)
   end
 
   it "should return one of the results" do
     experiment = Split::Experiment.find_or_create('link_color', {'blue' => 1}, {'red' => 1 })
-    ['red', 'blue'].should include Split::Algorithms::Whiplash.choose_alternative(experiment).name
+    expect(['red', 'blue']).to include Split::Algorithms::Whiplash.choose_alternative(experiment).name
   end
 
   it "should guess floats" do
-    Split::Algorithms::Whiplash.send(:arm_guess, 0, 0).class.should == Float
-    Split::Algorithms::Whiplash.send(:arm_guess, 1, 0).class.should == Float
-    Split::Algorithms::Whiplash.send(:arm_guess, 2, 1).class.should == Float
-    Split::Algorithms::Whiplash.send(:arm_guess, 1000, 5).class.should == Float
-    Split::Algorithms::Whiplash.send(:arm_guess, 10, -2).class.should == Float
+    expect(Split::Algorithms::Whiplash.send(:arm_guess, 0, 0).class).to eq(Float)
+    expect(Split::Algorithms::Whiplash.send(:arm_guess, 1, 0).class).to eq(Float)
+    expect(Split::Algorithms::Whiplash.send(:arm_guess, 2, 1).class).to eq(Float)
+    expect(Split::Algorithms::Whiplash.send(:arm_guess, 1000, 5).class).to eq(Float)
+    expect(Split::Algorithms::Whiplash.send(:arm_guess, 10, -2).class).to eq(Float)
   end
 
-end
+end

data/spec/alternative_spec.rb

@@ -19,23 +19,23 @@ describe Split::Alternative do
   let(:goal2) { "refund" }
 
   it "should have goals" do
-    alternative.goals.should eql(["purchase", "refund"])
+    expect(alternative.goals).to eq(["purchase", "refund"])
   end
 
   it "should have and only return the name" do
-    alternative.name.should eql('Basket')
+    expect(alternative.name).to eq('Basket')
   end
 
   describe 'weights' do
     it "should set the weights" do
       experiment = Split::Experiment.new('basket_text', :alternatives => [{'Basket' => 0.6}, {"Cart" => 0.4}])
       first = experiment.alternatives[0]
-      first.name.should == 'Basket'
-      first.weight.should == 0.6
+      expect(first.name).to eq('Basket')
+      expect(first.weight).to eq(0.6)
 
       second = experiment.alternatives[1]
-      second.name.should == 'Cart'
-      second.weight.should == 0.4
+      expect(second.name).to eq('Cart')
+      expect(second.weight).to eq(0.4)
     end
 
     it "accepts probability on alternatives" do
@@ -50,12 +50,12 @@ describe Split::Alternative do
       }
       experiment = Split::Experiment.new(:my_experiment)
       first = experiment.alternatives[0]
-      first.name.should == 'control_opt'
-      first.weight.should == 0.67
+      expect(first.name).to eq('control_opt')
+      expect(first.weight).to eq(0.67)
 
       second = experiment.alternatives[1]
-      second.name.should == 'second_opt'
-      second.weight.should == 0.1
+      expect(second.name).to eq('second_opt')
+      expect(second.weight).to eq(0.1)
     end
 
     it "accepts probability on some alternatives" do
@@ -79,8 +79,8 @@ describe Split::Alternative do
       ].each do |h|
         name, weight = h
         alt = alts.shift
-        alt.name.should == name
-        alt.weight.should == weight
+        expect(alt.name).to eq(name)
+        expect(alt.weight).to eq(weight)
       end
     end
     #
@@ -103,35 +103,35 @@ describe Split::Alternative do
       ].each do |h|
         name, weight = h
         alt = alts.shift
-        alt.name.should == name
-        alt.weight.should == weight
+        expect(alt.name).to eq(name)
+        expect(alt.weight).to eq(weight)
       end
     end
   end
 
   it "should have a default participation count of 0" do
-    alternative.participant_count.should eql(0)
+    expect(alternative.participant_count).to eq(0)
   end
 
   it "should have a default completed count of 0 for each goal" do
-    alternative.completed_count.should eql(0)
-    alternative.completed_count(goal1).should eql(0)
-    alternative.completed_count(goal2).should eql(0)
+    expect(alternative.completed_count).to eq(0)
+    expect(alternative.completed_count(goal1)).to eq(0)
+    expect(alternative.completed_count(goal2)).to eq(0)
   end
 
   it "should belong to an experiment" do
-    alternative.experiment.name.should eql(experiment.name)
+    expect(alternative.experiment.name).to eq(experiment.name)
   end
 
   it "should save to redis" do
     alternative.save
-    Split.redis.exists('basket_text:Basket').should be true
+    expect(Split.redis.exists('basket_text:Basket')).to be true
   end
 
   it "should increment participation count" do
     old_participant_count = alternative.participant_count
     alternative.increment_participation
-    alternative.participant_count.should eql(old_participant_count+1)
+    expect(alternative.participant_count).to eq(old_participant_count+1)
   end
 
   it "should increment completed count for each goal" do
@@ -143,9 +143,9 @@ describe Split::Alternative do
     alternative.increment_completion(goal1)
     alternative.increment_completion(goal2)
 
-    alternative.completed_count.should eql(old_default_completed_count+1)
-    alternative.completed_count(goal1).should eql(old_completed_count_for_goal1+1)
-    alternative.completed_count(goal2).should eql(old_completed_count_for_goal2+1)
+    expect(alternative.completed_count).to eq(old_default_completed_count+1)
+    expect(alternative.completed_count(goal1)).to eq(old_completed_count_for_goal1+1)
+    expect(alternative.completed_count(goal2)).to eq(old_completed_count_for_goal2+1)
   end
 
   it "can be reset" do
@@ -154,21 +154,21 @@ describe Split::Alternative do
     alternative.set_completed_count(5, goal2)
     alternative.set_completed_count(6)
     alternative.reset
-    alternative.participant_count.should eql(0)
-    alternative.completed_count(goal1).should eql(0)
-    alternative.completed_count(goal2).should eql(0)
-    alternative.completed_count.should eql(0)
+    expect(alternative.participant_count).to eq(0)
+    expect(alternative.completed_count(goal1)).to eq(0)
+    expect(alternative.completed_count(goal2)).to eq(0)
+    expect(alternative.completed_count).to eq(0)
   end
 
   it "should know if it is the control of an experiment" do
-    alternative.control?.should be_true
-    alternative2.control?.should be_false
+    expect(alternative.control?).to be_truthy
+    expect(alternative2.control?).to be_falsey
   end
 
   describe 'unfinished_count' do
     it "should be difference between participant and completed counts" do
       alternative.increment_participation
-      alternative.unfinished_count.should eql(alternative.participant_count)
+      expect(alternative.unfinished_count).to eq(alternative.participant_count)
     end
 
     it "should return the correct unfinished_count" do
@@ -177,35 +177,35 @@ describe Split::Alternative do
       alternative.set_completed_count(3, goal2)
       alternative.set_completed_count(2)
 
-      alternative.unfinished_count.should eql(1)
+      expect(alternative.unfinished_count).to eq(1)
     end
   end
 
   describe 'conversion rate' do
     it "should be 0 if there are no conversions" do
-      alternative.completed_count.should eql(0)
-      alternative.conversion_rate.should eql(0)
+      expect(alternative.completed_count).to eq(0)
+      expect(alternative.conversion_rate).to eq(0)
     end
 
     it "calculate conversion rate" do
-      alternative.stub(:participant_count).and_return(10)
-      alternative.stub(:completed_count).and_return(4)
-      alternative.conversion_rate.should eql(0.4)
+      expect(alternative).to receive(:participant_count).exactly(6).times.and_return(10)
+      expect(alternative).to receive(:completed_count).and_return(4)
+      expect(alternative.conversion_rate).to eq(0.4)
 
-      alternative.stub(:completed_count).with(goal1).and_return(5)
-      alternative.conversion_rate(goal1).should eql(0.5)
+      expect(alternative).to receive(:completed_count).with(goal1).and_return(5)
+      expect(alternative.conversion_rate(goal1)).to eq(0.5)
 
-      alternative.stub(:completed_count).with(goal2).and_return(6)
-      alternative.conversion_rate(goal2).should eql(0.6)
+      expect(alternative).to receive(:completed_count).with(goal2).and_return(6)
+      expect(alternative.conversion_rate(goal2)).to eq(0.6)
     end
   end
 
   describe 'z score' do
 
     it "should return an error string when the control has 0 people" do
-      alternative2.z_score.should eql("Needs 30+ participants.")
-      alternative2.z_score(goal1).should eql("Needs 30+ participants.")
-      alternative2.z_score(goal2).should eql("Needs 30+ participants.")
+      expect(alternative2.z_score).to eq("Needs 30+ participants.")
+      expect(alternative2.z_score(goal1)).to eq("Needs 30+ participants.")
+      expect(alternative2.z_score(goal2)).to eq("Needs 30+ participants.")
     end
 
     it "should return an error string when the data is skewed or incomplete as per the np > 5 test" do
@@ -216,7 +216,7 @@ describe Split::Alternative do
       alternative2.participant_count = 50
       alternative2.set_completed_count(1)
 
-      alternative2.z_score.should eql("Needs 5+ conversions.")
+      expect(alternative2.z_score).to eq("Needs 5+ conversions.")
     end
 
     it "should return a float for a z_score given proper data" do
@@ -227,8 +227,8 @@ describe Split::Alternative do
       alternative2.participant_count = 100
       alternative2.set_completed_count(25)
 
-      alternative2.z_score.should be_kind_of(Float)
-      alternative2.z_score.should_not eql(0)
+      expect(alternative2.z_score).to be_kind_of(Float)
+      expect(alternative2.z_score).to_not eq(0)
     end
 
     it "should correctly calculate a z_score given proper data" do
@@ -239,14 +239,14 @@ describe Split::Alternative do
       alternative2.participant_count = 142
       alternative2.set_completed_count(119)
 
-      alternative2.z_score.round(2).should eql(2.58)
+      expect(alternative2.z_score.round(2)).to eq(2.58)
     end
 
     it "should be N/A for the control" do
       control = experiment.control
-      control.z_score.should eql('N/A')
-      control.z_score(goal1).should eql('N/A')
-      control.z_score(goal2).should eql('N/A')
+      expect(control.z_score).to eq('N/A')
+      expect(control.z_score(goal1)).to eq('N/A')
+      expect(control.z_score(goal2)).to eq('N/A')
     end
   end
 end

data/spec/configuration_spec.rb

@@ -5,69 +5,69 @@ describe Split::Configuration do
   before(:each) { @config = Split::Configuration.new }
 
   it "should provide a default value for ignore_ip_addresses" do
-    @config.ignore_ip_addresses.should eql([])
+    expect(@config.ignore_ip_addresses).to eq([])
   end
 
   it "should provide default values for db failover" do
-    @config.db_failover.should be_false
-    @config.db_failover_on_db_error.should be_a Proc
+    expect(@config.db_failover).to be_falsey
+    expect(@config.db_failover_on_db_error).to be_a Proc
   end
 
   it "should not allow multiple experiments by default" do
-    @config.allow_multiple_experiments.should be_false
+    expect(@config.allow_multiple_experiments).to be_falsey
   end
 
   it "should be enabled by default" do
-    @config.enabled.should be_true
+    expect(@config.enabled).to be_truthy
   end
 
   it "disabled is the opposite of enabled" do
     @config.enabled = false
-    @config.disabled?.should be_true
+    expect(@config.disabled?).to be_truthy
   end
 
   it "should not store the overridden test group per default" do
-    @config.store_override.should be_false
+    expect(@config.store_override).to be_falsey
   end
 
   it "should provide a default pattern for robots" do
     %w[Baidu Gigabot Googlebot libwww-perl lwp-trivial msnbot SiteUptime Slurp WordPress ZIBB ZyBorg YandexBot AdsBot-Google Wget curl bitlybot facebookexternalhit spider].each do |robot|
-      @config.robot_regex.should =~ robot
+      expect(@config.robot_regex).to match(robot)
     end
 
-    @config.robot_regex.should =~ "EventMachine HttpClient"
-    @config.robot_regex.should =~ "libwww-perl/5.836"
-    @config.robot_regex.should =~ "Pingdom.com_bot_version_1.4_(http://www.pingdom.com)"
+    expect(@config.robot_regex).to match("EventMachine HttpClient")
+    expect(@config.robot_regex).to match("libwww-perl/5.836")
+    expect(@config.robot_regex).to match("Pingdom.com_bot_version_1.4_(http://www.pingdom.com)")
 
-    @config.robot_regex.should =~ " - "
+    expect(@config.robot_regex).to match(" - ")
   end
 
   it "should accept real UAs with the robot regexp" do
-    @config.robot_regex.should_not =~ "Mozilla/5.0 (Windows; U; Windows NT 6.0; en-US; rv:1.9.1.4) Gecko/20091017 SeaMonkey/2.0"
-    @config.robot_regex.should_not =~ "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.1; Trident/4.0; F-6.0SP2-20041109; .NET CLR 2.0.50727; .NET CLR 3.0.04506.648; .NET CLR 3.5.21022; .NET CLR 1.1.4322; InfoPath.3)"
+    expect(@config.robot_regex).not_to match("Mozilla/5.0 (Windows; U; Windows NT 6.0; en-US; rv:1.9.1.4) Gecko/20091017 SeaMonkey/2.0")
+    expect(@config.robot_regex).not_to match("Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.1; Trident/4.0; F-6.0SP2-20041109; .NET CLR 2.0.50727; .NET CLR 3.0.04506.648; .NET CLR 3.5.21022; .NET CLR 1.1.4322; InfoPath.3)")
   end
 
   it "should allow adding a bot to the bot list" do
     @config.bots["newbot"] = "An amazing test bot"
-    @config.robot_regex.should =~ "newbot"
+    expect(@config.robot_regex).to match("newbot")
   end
 
   it "should use the session adapter for persistence by default" do
-    @config.persistence.should eq(Split::Persistence::SessionAdapter)
+    expect(@config.persistence).to eq(Split::Persistence::SessionAdapter)
   end
 
   it "should load a metric" do
     @config.experiments = {:my_experiment=>
         {:alternatives=>["control_opt", "other_opt"], :metric=>:my_metric}}
 
-    @config.metrics.should_not be_nil
-    @config.metrics.keys.should ==  [:my_metric]
+    expect(@config.metrics).not_to be_nil
+    expect(@config.metrics.keys).to eq([:my_metric])
   end
 
   it "should allow loading of experiment using experment_for" do
     @config.experiments = {:my_experiment=>
         {:alternatives=>["control_opt", "other_opt"], :metric=>:my_metric}}
-    @config.experiment_for(:my_experiment).should == {:alternatives=>["control_opt", ["other_opt"]]}
+    expect(@config.experiment_for(:my_experiment)).to eq({:alternatives=>["control_opt", ["other_opt"]]})
   end
 
   context "when experiments are defined via YAML" do
@@ -86,7 +86,7 @@ describe Split::Configuration do
         end
 
         it 'should normalize experiments' do
-          @config.normalized_experiments.should == {:my_experiment=>{:resettable=>false,:alternatives=>["Control Opt", ["Alt One", "Alt Two"]]}}
+          expect(@config.normalized_experiments).to eq({:my_experiment=>{:resettable=>false,:alternatives=>["Control Opt", ["Alt One", "Alt Two"]]}})
         end
       end
 
@@ -112,13 +112,13 @@ describe Split::Configuration do
         end
 
         it "should normalize experiments" do
-          @config.normalized_experiments.should == {:my_experiment=>{:resettable=>false,:alternatives=>[{"Control Opt"=>0.67},
-            [{"Alt One"=>0.1}, {"Alt Two"=>0.23}]]}, :another_experiment=>{:alternatives=>["a", ["b"]]}}
+          expect(@config.normalized_experiments).to eq({:my_experiment=>{:resettable=>false,:alternatives=>[{"Control Opt"=>0.67},
+            [{"Alt One"=>0.1}, {"Alt Two"=>0.23}]]}, :another_experiment=>{:alternatives=>["a", ["b"]]}})
         end
 
         it "should recognize metrics" do
-          @config.metrics.should_not be_nil
-          @config.metrics.keys.should ==  [:my_metric]
+          expect(@config.metrics).not_to be_nil
+          expect(@config.metrics.keys).to eq([:my_metric])
         end
       end
     end
@@ -139,7 +139,7 @@ describe Split::Configuration do
         end
 
         it "should normalize experiments" do
-          @config.normalized_experiments.should == {:my_experiment=>{:resettable=>false,:alternatives=>["Control Opt", ["Alt One", "Alt Two"]]}}
+          expect(@config.normalized_experiments).to eq({:my_experiment=>{:resettable=>false,:alternatives=>["Control Opt", ["Alt One", "Alt Two"]]}})
         end
       end
 
@@ -177,6 +177,6 @@ describe Split::Configuration do
       }
     }
 
-    @config.normalized_experiments.should == {:my_experiment=>{:alternatives=>[{"control_opt"=>0.67}, [{"second_opt"=>0.1}, {"third_opt"=>0.23}]]}}
+    expect(@config.normalized_experiments).to eq({:my_experiment=>{:alternatives=>[{"control_opt"=>0.67}, [{"second_opt"=>0.1}, {"third_opt"=>0.23}]]}})
   end
 end