split 3.2.0 → 4.0.5

data/spec/dashboard_spec.rb

@@ -1,13 +1,22 @@
 # frozen_string_literal: true
-require 'spec_helper'
-require 'rack/test'
-require 'split/dashboard'
+
+require "spec_helper"
+require "rack/test"
+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)
@@ -19,18 +28,22 @@ describe Split::Dashboard do
   }
 
   let(:experiment_with_goals) {
-    Split::ExperimentCatalog.find_or_create({"link_color" => ["goal_1", "goal_2"]}, "blue", "red")
+    Split::ExperimentCatalog.find_or_create({ "link_color" => ["goal_1", "goal_2"] }, "blue", "red")
   }
 
   let(:metric) {
-    Split::Metric.find_or_create(name: 'testmetric', experiments: [experiment, experiment_with_goals])
+    Split::Metric.find_or_create(name: "testmetric", experiments: [experiment, experiment_with_goals])
   }
 
   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 '/'
+    get "/"
     expect(last_response).to be_ok
   end
 
@@ -42,76 +55,108 @@ describe Split::Dashboard do
     context "experiment without goals" do
       it "should display a Start button" do
         experiment
-        get '/'
-        expect(last_response.body).to include('Start')
+        get "/"
+        expect(last_response.body).to include("Start")
 
         post "/start?experiment=#{experiment.name}"
-        get '/'
-        expect(last_response.body).to include('Reset Data')
-        expect(last_response.body).not_to include('Metrics:')
+        get "/"
+        expect(last_response.body).to include("Reset Data")
+        expect(last_response.body).not_to include("Metrics:")
       end
     end
 
     context "experiment with metrics" do
       it "should display the names of associated metrics" do
         metric
-        get '/'
-        expect(last_response.body).to include('Metrics:testmetric')
+        get "/"
+        expect(last_response.body).to include("Metrics:testmetric")
       end
     end
 
     context "with goals" do
       it "should display a Start button" do
         experiment_with_goals
-        get '/'
-        expect(last_response.body).to include('Start')
+        get "/"
+        expect(last_response.body).to include("Start")
 
         post "/start?experiment=#{experiment.name}"
-        get '/'
-        expect(last_response.body).to include('Reset Data')
+        get "/"
+        expect(last_response.body).to include("Reset Data")
       end
     end
   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
 
   describe "index page" do
     context "with winner" do
-      before { experiment.winner = 'red' }
+      before { experiment.winner = "red" }
 
       it "displays `Reopen Experiment` button" do
-        get '/'
+        get "/"
 
-        expect(last_response.body).to include('Reopen Experiment')
+        expect(last_response.body).to include("Reopen Experiment")
       end
     end
 
     context "without winner" do
       it "should not display `Reopen Experiment` button" do
-        get '/'
+        get "/"
 
-        expect(last_response.body).to_not include('Reopen Experiment')
+        expect(last_response.body).to_not include("Reopen Experiment")
       end
     end
   end
 
   describe "reopen experiment" do
-    before { experiment.winner = 'red' }
+    before { experiment.winner = "red" }
 
-    it 'redirects' do
+    it "redirects" do
       post "/reopen?experiment=#{experiment.name}"
 
       expect(last_response).to be_redirect
@@ -120,13 +165,13 @@ 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
       red_link.participant_count = 5
       blue_link.participant_count = 7
-      experiment.winner = 'blue'
+      experiment.winner = "blue"
 
       post "/reopen?experiment=#{experiment.name}"
 
@@ -135,10 +180,63 @@ 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
+
+  describe "initialize experiment" do
+    before do
+      Split.configuration.experiments = {
+        my_experiment: {
+          alternatives: [ "control", "alternative" ],
+        }
+      }
+    end
+
+    it "initializes the experiment when the experiment is given" do
+      expect(Split::ExperimentCatalog.find("my_experiment")).to be nil
+
+      post "/initialize_experiment", { experiment: "my_experiment" }
+
+      experiment = Split::ExperimentCatalog.find("my_experiment")
+      expect(experiment).to be_a(Split::Experiment)
+    end
+
+    it "does not attempt to intialize the experiment when empty experiment is given" do
+      post "/initialize_experiment", { experiment: "" }
+
+      expect(Split::ExperimentCatalog).to_not receive(:find_or_create)
+    end
+
+    it "does not attempt to intialize the experiment when no experiment is given" do
+      post "/initialize_experiment"
+
+      expect(Split::ExperimentCatalog).to_not receive(:find_or_create)
+    end
+  end
+
   it "should reset an experiment" do
     red_link.participant_count = 5
     blue_link.participant_count = 7
-    experiment.winner = 'blue'
+    experiment.winner = "blue"
 
     post "/reset?experiment=#{experiment.name}"
 
@@ -160,30 +258,37 @@ describe Split::Dashboard do
 
   it "should mark an alternative as the winner" do
     expect(experiment.winner).to be_nil
-    post "/experiment?experiment=#{experiment.name}", :alternative => 'red'
+    post "/experiment?experiment=#{experiment.name}", alternative: "red"
 
     expect(last_response).to be_redirect
-    expect(experiment.winner.name).to eq('red')
+    expect(experiment.winner.name).to eq("red")
   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 '/'
+    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 '/'
+    get "/"
 
-    expect(last_response.body).to include('<small>Unknown</small>')
+    expect(last_response.body).to include("<small>Unknown</small>")
+  end
+
+  it "should be explode with experiments with invalid data" do
+    red_link.participant_count = 1
+    red_link.set_completed_count(10)
+
+    blue_link.participant_count = 3
+    blue_link.set_completed_count(2)
+
+    get "/"
+
+    expect(last_response).to be_ok
   end
 end

data/spec/encapsulated_helper_spec.rb

@@ -1,13 +1,9 @@
 # frozen_string_literal: true
-require 'spec_helper'
-
-describe Split::EncapsulatedHelper do
-  include Split::EncapsulatedHelper
 
+require "spec_helper"
 
-  def params
-    raise NoMethodError, 'This method is not really defined'
-  end
+describe Split::EncapsulatedHelper do
+  let(:context_shim) { Split::EncapsulatedHelper::ContextShim.new(double(request: request)) }
 
   describe "ab_test" do
     before do
@@ -15,38 +11,66 @@ describe Split::EncapsulatedHelper do
       .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)
+      expect { |block| context_shim.ab_test("link_color", "red", "red", &block) }.to yield_with_args("red", {})
     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| %>
+        require "erb"
+        template = ERB.new(<<-ERB.split(/\s+/s).map(&:strip).join(" "), nil, "%")
+          foo <% context_shim.ab_test(:foo, '1', '2') do |alt, meta| %>
             static <%= alt %>
           <% end %>
         ERB
-        expect(template.result(binding)).to match /foo  static \d/
+        expect(template.result(binding)).to match(/foo  static \d/)
       end
-
     end
   end
 
   describe "context" do
-    it 'is passed in shim' do
-      ctx = Class.new{
+    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
+
+      expect(ctx).to receive(:session) { {} }
+      expect { ctx.ab_test("link_color", "blue", "red") }.not_to raise_error
+    end
+
+    context "when request is defined in context of ContextShim" do
+      context "when overriding by params" do
+        it do
+          ctx = Class.new {
+            public :session
+            def request
+              build_request(params: {
+                "ab_test" => { "link_color" => "blue" }
+              })
+            end
+          }.new
+
+          context_shim = Split::EncapsulatedHelper::ContextShim.new(ctx)
+          expect(context_shim.ab_test("link_color", "blue", "red")).to be("blue")
+        end
+      end
+
+      context "when overriding by cookies" do
+        it do
+          ctx = Class.new {
+            public :session
+            def request
+              build_request(cookies: {
+                "split_override" => '{ "link_color": "red" }'
+              })
+            end
+          }.new
+
+          context_shim = Split::EncapsulatedHelper::ContextShim.new(ctx)
+          expect(context_shim.ab_test("link_color", "blue", "red")).to be("red")
+        end
+      end
     end
   end
 end

data/spec/experiment_catalog_spec.rb

@@ -1,53 +1,54 @@
 # frozen_string_literal: true
-require 'spec_helper'
+
+require "spec_helper"
 
 describe Split::ExperimentCatalog do
   subject { Split::ExperimentCatalog }
 
   describe ".find_or_create" do
     it "should not raise an error when passed strings for alternatives" do
-      expect { subject.find_or_create('xyz', '1', '2', '3') }.not_to raise_error
+      expect { subject.find_or_create("xyz", "1", "2", "3") }.not_to raise_error
     end
 
     it "should not raise an error when passed an array for alternatives" do
-      expect { subject.find_or_create('xyz', ['1', '2', '3']) }.not_to raise_error
+      expect { subject.find_or_create("xyz", ["1", "2", "3"]) }.not_to raise_error
     end
 
     it "should raise the appropriate error when passed integers for alternatives" do
-      expect { subject.find_or_create('xyz', 1, 2, 3) }.to raise_error(ArgumentError)
+      expect { subject.find_or_create("xyz", 1, 2, 3) }.to raise_error(ArgumentError)
     end
 
     it "should raise the appropriate error when passed symbols for alternatives" do
-      expect { subject.find_or_create('xyz', :a, :b, :c) }.to raise_error(ArgumentError)
+      expect { subject.find_or_create("xyz", :a, :b, :c) }.to raise_error(ArgumentError)
     end
 
     it "should not raise error when passed an array for goals" do
-      expect { subject.find_or_create({'link_color' => ["purchase", "refund"]}, 'blue', 'red') }
+      expect { subject.find_or_create({ "link_color" => ["purchase", "refund"] }, "blue", "red") }
           .not_to raise_error
     end
 
     it "should not raise error when passed just one goal" do
-      expect { subject.find_or_create({'link_color' => "purchase"}, 'blue', 'red') }
+      expect { subject.find_or_create({ "link_color" => "purchase" }, "blue", "red") }
           .not_to raise_error
     end
 
     it "constructs a new experiment" do
-      expect(subject.find_or_create('my_exp', 'control me').control.to_s).to eq('control me')
+      expect(subject.find_or_create("my_exp", "control me").control.to_s).to eq("control me")
     end
   end
 
-  describe '.find' do
+  describe ".find" do
     it "should return an existing experiment" do
-      experiment = Split::Experiment.new('basket_text', alternatives: ['blue', 'red', 'green'])
+      experiment = Split::Experiment.new("basket_text", alternatives: ["blue", "red", "green"])
       experiment.save
 
-      experiment = subject.find('basket_text')
+      experiment = subject.find("basket_text")
 
-      expect(experiment.name).to eq('basket_text')
+      expect(experiment.name).to eq("basket_text")
     end
 
     it "should return nil if experiment not exist" do
-      expect(subject.find('non_existent_experiment')).to be_nil
+      expect(subject.find("non_existent_experiment")).to be_nil
     end
   end
 end