split 0.5.0 → 0.6.0

data/spec/configuration_spec.rb

@@ -27,9 +27,25 @@ describe Split::Configuration do
   end
 
   it "should provide a default pattern for robots" do
-    %w[Baidu Gigabot Googlebot libwww-perl lwp-trivial msnbot SiteUptime Slurp WordPress ZIBB ZyBorg].each do |robot|
+    %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
     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)"
+
+    @config.robot_regex.should =~ " - "
+  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)"
+  end
+
+  it "should allow adding a bot to the bot list" do
+    @config.bots["newbot"] = "An amazing test bot"
+    @config.robot_regex.should =~ "newbot"
   end
 
   it "should use the session adapter for persistence by default" do
@@ -43,13 +59,85 @@ describe Split::Configuration do
     @config.metrics.should_not be_nil
     @config.metrics.keys.should ==  [: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"]]}
   end
-  
+
+  context "when experiments are defined via YAML" do
+    context "as strings" do
+      context "in a basic configuration" do
+        before do
+          experiments_yaml = <<-eos
+            my_experiment:
+              alternatives:
+                - Control Opt
+                - Alt One
+                - Alt Two
+              resettable: false
+            eos
+          @config.experiments = YAML.load(experiments_yaml)
+        end
+
+        it 'should normalize experiments' do
+          @config.normalized_experiments.should == {:my_experiment=>{:alternatives=>["Control Opt", ["Alt One", "Alt Two"]]}}
+        end
+      end
+
+      context "in a complex configuration" do
+        before do
+          experiments_yaml = <<-eos
+            my_experiment:
+              alternatives:
+                - name: Control Opt
+                  percent: 67
+                - name: Alt One
+                  percent: 10
+                - name: Alt Two
+                  percent: 23
+              resettable: false
+              metric: my_metric
+            another_experiment:
+              alternatives:
+                - a
+                - b
+            eos
+          @config.experiments = YAML.load(experiments_yaml)
+        end
+
+        it "should normalize experiments" do
+          @config.normalized_experiments.should == {:my_experiment=>{: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]
+        end
+      end
+    end
+
+    context "as symbols" do
+      before do
+        experiments_yaml = <<-eos
+          :my_experiment:
+            :alternatives:
+              - Control Opt
+              - Alt One
+              - Alt Two
+            :resettable: false
+          eos
+        @config.experiments = YAML.load(experiments_yaml)
+      end
+
+      it "should normalize experiments" do
+        @config.normalized_experiments.should == {:my_experiment=>{:alternatives=>["Control Opt", ["Alt One", "Alt Two"]]}}
+      end
+    end
+  end
+
   it "should normalize experiments" do
     @config.experiments = {
       :my_experiment => {
@@ -60,7 +148,7 @@ describe Split::Configuration do
         ],
       }
     }
-    
+
     @config.normalized_experiments.should == {:my_experiment=>{:alternatives=>[{"control_opt"=>0.67}, [{"second_opt"=>0.1}, {"third_opt"=>0.23}]]}}
   end
 end

data/spec/dashboard_spec.rb

@@ -5,6 +5,22 @@ require 'split/dashboard'
 describe Split::Dashboard do
   include Rack::Test::Methods
 
+  let(:link_color) {
+    Split::Experiment.find_or_create('link_color', 'blue', 'red')
+  }
+
+  def link(color)
+    Split::Alternative.new(color, 'link_color')
+  end
+
+  let(:red_link) {
+    link("red")
+  }
+
+  let(:blue_link) {
+    link("blue")
+  }
+
   def app
     @app ||= Split::Dashboard
   end
@@ -15,33 +31,33 @@ describe Split::Dashboard do
   end
 
   it "should reset an experiment" do
-    experiment = Split::Experiment.find_or_create('link_color', 'blue', 'red')
+    experiment = link_color
 
-    red = Split::Alternative.new('red', 'link_color')
-    blue = Split::Alternative.new('blue', 'link_color')
-    red.participant_count = 5
-    blue.participant_count = 6
+    red_link.participant_count = 5
+    blue_link.participant_count = 7
+    experiment.winner = 'blue'
 
     post '/reset/link_color'
 
     last_response.should be_redirect
 
-    new_red_count = Split::Alternative.new('red', 'link_color').participant_count
-    new_blue_count = Split::Alternative.new('blue', 'link_color').participant_count
+    new_red_count = red_link.participant_count
+    new_blue_count = blue_link.participant_count
 
     new_blue_count.should eql(0)
     new_red_count.should eql(0)
+    experiment.winner.should be_nil
   end
 
   it "should delete an experiment" do
-    experiment = Split::Experiment.find_or_create('link_color', 'blue', 'red')
+    experiment = link_color
     delete '/link_color'
     last_response.should be_redirect
     Split::Experiment.find('link_color').should be_nil
   end
 
   it "should mark an alternative as the winner" do
-    experiment = Split::Experiment.find_or_create('link_color', 'blue', 'red')
+    experiment = link_color
     experiment.winner.should be_nil
 
     post '/link_color', :alternative => 'red'
@@ -53,7 +69,7 @@ describe Split::Dashboard do
   it "should display the start date" do
     experiment_start_time = Time.parse('2011-07-07')
     Time.stub(:now => experiment_start_time)
-    experiment = Split::Experiment.find_or_create('link_color', 'blue', 'red')
+    experiment = link_color
 
     get '/'
 
@@ -63,7 +79,7 @@ describe Split::Dashboard do
   it "should handle experiments without a start date" do
     experiment_start_time = Time.parse('2011-07-07')
     Time.stub(:now => experiment_start_time)
-    experiment = Split::Experiment.find_or_create('link_color', 'blue', 'red')
+    experiment = link_color
 
     Split.redis.hdel(:experiment_start_times, experiment.name)
 

data/spec/experiment_spec.rb

@@ -4,9 +4,24 @@ require 'split/algorithms'
 require 'time'
 
 describe Split::Experiment do
+  def new_experiment(goals=[])
+    Split::Experiment.new('link_color', :alternatives => ['blue', 'red', 'green'], :goals => goals)
+  end
+
+  def alternative(color)
+    Split::Alternative.new(color, 'link_color')
+  end
+
+  let(:experiment) {
+    new_experiment
+  }
+
+  let(:blue) { alternative("blue") }
+  let(:green) { alternative("green") }
+
   context "with an experiment" do
-    let(:experiment) { Split::Experiment.new('basket_text', :alternative_names => ['Basket', "Cart"]) }
-    
+    let(:experiment) { Split::Experiment.new('basket_text', :alternatives => ['Basket', "Cart"]) }
+
     it "should have a name" do
       experiment.name.should eql('basket_text')
     end
@@ -14,15 +29,15 @@ describe Split::Experiment do
     it "should have alternatives" do
       experiment.alternatives.length.should be 2
     end
-    
+
     it "should have alternatives with correct names" do
       experiment.alternatives.collect{|a| a.name}.should == ['Basket', 'Cart']
     end
-    
+
     it "should be resettable by default" do
       experiment.resettable.should be_true
     end
-    
+
     it "should save to redis" do
       experiment.save
       Split.redis.exists('basket_text').should be true
@@ -35,10 +50,10 @@ describe Split::Experiment do
 
       Split::Experiment.find('basket_text').start_time.should == experiment_start_time
     end
-  
+
     it "should save the selected algorithm to redis" do
       experiment_algorithm = Split::Algorithms::Whiplash
-      experiment.algorithm = experiment_algorithm 
+      experiment.algorithm = experiment_algorithm
       experiment.save
 
       Split::Experiment.find('basket_text').algorithm.should == experiment_algorithm
@@ -60,7 +75,7 @@ describe Split::Experiment do
       Split.redis.exists('basket_text').should be true
       Split.redis.lrange('basket_text', 0, -1).should eql(['Basket', "Cart"])
     end
-    
+
     describe 'new record?' do
       it "should know if it hasn't been saved yet" do
         experiment.new_record?.should be_true
@@ -71,18 +86,19 @@ describe Split::Experiment do
         experiment.new_record?.should be_false
       end
     end
-    
+
     describe 'find' do
       it "should return an existing experiment" do
         experiment.save
-        Split::Experiment.find('basket_text').name.should eql('basket_text')
+        experiment = Split::Experiment.find('basket_text')
+        experiment.name.should eql('basket_text')
       end
 
       it "should return an existing experiment" do
         Split::Experiment.find('non_existent_experiment').should be_nil
       end
     end
-    
+
     describe 'control' do
       it 'should be the first alternative' do
         experiment.save
@@ -90,80 +106,74 @@ describe Split::Experiment do
       end
     end
   end
+
   describe 'initialization' do
     it "should set the algorithm when passed as an option to the initializer" do
-       experiment = Split::Experiment.new('basket_text', :alternative_names => ['Basket', "Cart"], :algorithm =>  Split::Algorithms::Whiplash)
+       experiment = Split::Experiment.new('basket_text', :alternatives => ['Basket', "Cart"], :algorithm =>  Split::Algorithms::Whiplash)
        experiment.algorithm.should == Split::Algorithms::Whiplash
     end
-  
+
     it "should be possible to make an experiment not resettable" do
-      experiment = Split::Experiment.new('basket_text', :alternative_names => ['Basket', "Cart"], :resettable => false)
-      experiment.resettable.should be_false    
+      experiment = Split::Experiment.new('basket_text', :alternatives => ['Basket', "Cart"], :resettable => false)
+      experiment.resettable.should be_false
     end
   end
-  
+
   describe 'persistent configuration' do
-  
+
     it "should persist resettable in redis" do
-      experiment = Split::Experiment.new('basket_text', :alternative_names => ['Basket', "Cart"], :resettable => false)
+      experiment = Split::Experiment.new('basket_text', :alternatives => ['Basket', "Cart"], :resettable => false)
       experiment.save
-        
+
       e = Split::Experiment.find('basket_text')
       e.should == experiment
       e.resettable.should be_false
-    
+
     end
-    
+
     it "should persist algorithm in redis" do
-      experiment = Split::Experiment.new('basket_text', :alternative_names => ['Basket', "Cart"], :algorithm => Split::Algorithms::Whiplash)
+      experiment = Split::Experiment.new('basket_text', :alternatives => ['Basket', "Cart"], :algorithm => Split::Algorithms::Whiplash)
       experiment.save
-  
+
       e = Split::Experiment.find('basket_text')
       e.should == experiment
       e.algorithm.should == Split::Algorithms::Whiplash
     end
   end
 
-  
-  
-  
   describe 'deleting' do
     it 'should delete itself' do
-      experiment = Split::Experiment.new('basket_text', :alternative_names => [ 'Basket', "Cart"])
+      experiment = Split::Experiment.new('basket_text', :alternatives => [ 'Basket', "Cart"])
       experiment.save
 
       experiment.delete
-      Split.redis.exists('basket_text').should be false
-      Split::Experiment.find('basket_text').should be_nil
+      Split.redis.exists('link_color').should be false
+      Split::Experiment.find('link_color').should be_nil
     end
 
     it "should increment the version" do
-      experiment = Split::Experiment.find_or_create('link_color', 'blue', 'red', 'green')
       experiment.version.should eql(0)
       experiment.delete
       experiment.version.should eql(1)
     end
   end
 
+
   describe 'winner' do
     it "should have no winner initially" do
-      experiment = Split::Experiment.find_or_create('link_color', 'blue', 'red')
       experiment.winner.should be_nil
     end
 
     it "should allow you to specify a winner" do
-      experiment = Split::Experiment.find_or_create('link_color', 'blue', 'red')
+      experiment.save
       experiment.winner = 'red'
-
-      experiment = Split::Experiment.find_or_create('link_color', 'blue', 'red')
       experiment.winner.name.should == 'red'
     end
   end
 
   describe 'reset' do
+    before { experiment.save }
     it 'should reset all alternatives' do
-      experiment = Split::Experiment.find_or_create('link_color', 'blue', 'red', 'green')
-      green = Split::Alternative.new('green', 'link_color')
       experiment.winner = 'green'
 
       experiment.next_alternative.name.should eql('green')
@@ -171,14 +181,11 @@ describe Split::Experiment do
 
       experiment.reset
 
-      reset_green = Split::Alternative.new('green', 'link_color')
-      reset_green.participant_count.should eql(0)
-      reset_green.completed_count.should eql(0)
+      green.participant_count.should eql(0)
+      green.completed_count.should eql(0)
     end
 
     it 'should reset the winner' do
-      experiment = Split::Experiment.find_or_create('link_color', 'blue', 'red', 'green')
-      green = Split::Alternative.new('green', 'link_color')
       experiment.winner = 'green'
 
       experiment.next_alternative.name.should eql('green')
@@ -190,29 +197,28 @@ describe Split::Experiment do
     end
 
     it "should increment the version" do
-      experiment = Split::Experiment.find_or_create('link_color', 'blue', 'red', 'green')
       experiment.version.should eql(0)
       experiment.reset
       experiment.version.should eql(1)
     end
   end
-  
+
   describe 'algorithm' do
     let(:experiment) { Split::Experiment.find_or_create('link_color', 'blue', 'red', 'green') }
-    
+
     it 'should use the default algorithm if none is specified' do
       experiment.algorithm.should == Split.configuration.algorithm
     end
-    
+
     it 'should use the user specified algorithm for this experiment if specified' do
       experiment.algorithm = Split::Algorithms::Whiplash
       experiment.algorithm.should == Split::Algorithms::Whiplash
     end
   end
-  
+
   describe 'next_alternative' do
     let(:experiment) { Split::Experiment.find_or_create('link_color', 'blue', 'red', 'green') }
-    
+
     it "should always return the winner if one exists" do
       green = Split::Alternative.new('green', 'link_color')
       experiment.winner = 'green'
@@ -220,42 +226,42 @@ describe Split::Experiment do
       experiment.next_alternative.name.should eql('green')
       green.increment_participation
 
-      experiment = Split::Experiment.find_or_create('link_color', 'blue', 'red', 'green')
       experiment.next_alternative.name.should eql('green')
     end
-    
+
     it "should use the specified algorithm if a winner does not exist" do
       Split.configuration.algorithm.should_receive(:choose_alternative).and_return(Split::Alternative.new('green', 'link_color'))
       experiment.next_alternative.name.should eql('green')
     end
   end
-  
+
   describe 'single alternative' do
     let(:experiment) { Split::Experiment.find_or_create('link_color', 'blue') }
-    
+
     it "should always return the color blue" do
       experiment.next_alternative.name.should eql('blue')
-    end 
+    end
   end
 
   describe 'changing an existing experiment' do
+    def same_but_different_alternative
+      Split::Experiment.find_or_create('link_color', 'blue', 'yellow', 'orange')
+    end
+
     it "should reset an experiment if it is loaded with different alternatives" do
-      experiment = Split::Experiment.find_or_create('link_color', 'blue', 'red', 'green')
-      blue = Split::Alternative.new('blue', 'link_color')
+      experiment.save
       blue.participant_count = 5
-      blue.save
-      same_experiment = Split::Experiment.find_or_create('link_color', 'blue', 'yellow', 'orange')
+      same_experiment = same_but_different_alternative
       same_experiment.alternatives.map(&:name).should eql(['blue', 'yellow', 'orange'])
-      new_blue = Split::Alternative.new('blue', 'link_color')
-      new_blue.participant_count.should eql(0)
+      blue.participant_count.should eql(0)
     end
 
     it "should only reset once" do
-      experiment = Split::Experiment.find_or_create('link_color', 'blue', 'red', 'green')
+      experiment.save
       experiment.version.should eql(0)
-      same_experiment = Split::Experiment.find_or_create('link_color', 'blue', 'yellow', 'orange')
+      same_experiment = same_but_different_alternative
       same_experiment.version.should eql(1)
-      same_experiment_again = Split::Experiment.find_or_create('link_color', 'blue', 'yellow', 'orange')
+      same_experiment_again = same_but_different_alternative
       same_experiment_again.version.should eql(1)
     end
   end
@@ -268,18 +274,55 @@ describe Split::Experiment do
   end
 
   describe 'specifying weights' do
-    it "should work for a new experiment" do
-      experiment = Split::Experiment.find_or_create('link_color', {'blue' => 1}, {'red' => 2 })
+    let(:experiment_with_weight) {
+      Split::Experiment.find_or_create('link_color', {'blue' => 1}, {'red' => 2 })
+    }
 
-      experiment.alternatives.map(&:weight).should == [1, 2]
+    it "should work for a new experiment" do
+      experiment_with_weight.alternatives.map(&:weight).should == [1, 2]
     end
 
     it "should work for an existing experiment" do
-      experiment = Split::Experiment.find_or_create('link_color', 'blue', 'red')
       experiment.save
+      experiment_with_weight.alternatives.map(&:weight).should == [1, 2]
+    end
+  end
 
-      same_experiment = Split::Experiment.find_or_create('link_color', {'blue' => 1}, {'red' => 2 })
-      same_experiment.alternatives.map(&:weight).should == [1, 2]
+  describe "specifying goals" do
+    let(:experiment) {
+      new_experiment(["purchase"])
+    }
+
+    context "saving experiment" do
+      def same_but_different_goals
+        Split::Experiment.find_or_create({'link_color' => ["purchase", "refund"]}, 'blue', 'red', 'green')
+      end
+
+      before { experiment.save }
+
+      it "can find existing experiment" do
+        Split::Experiment.find("link_color").name.should eql("link_color")
+      end
+
+      it "should reset an experiment if it is loaded with different goals" do
+        same_experiment = same_but_different_goals
+        Split::Experiment.find("link_color").goals.should == ["purchase", "refund"]
+      end
+
+    end
+
+    it "should have goals" do
+      experiment.goals.should eql(["purchase"])
+    end
+
+    context "find or create experiment" do
+      it "should have correct goals"  do
+        experiment = Split::Experiment.find_or_create({'link_color3' => ["purchase", "refund"]}, 'blue', 'red', 'green')
+        experiment.goals.should == ["purchase", "refund"]
+        experiment = Split::Experiment.find_or_create('link_color3', 'blue', 'red', 'green')
+        experiment.goals.should == []
+      end
     end
   end
+
 end