split 3.0.0 → 3.4.0

data/spec/experiment_spec.rb

@@ -35,6 +35,12 @@ describe Split::Experiment do
       expect(experiment.resettable).to be_truthy
     end
 
+    it "should be resettable when loading from configuration" do
+      allow(Split.configuration).to receive(:experiment_for).with('some_experiment') { { alternatives: %w(a b) } }
+
+      expect(Split::Experiment.new('some_experiment')).to be_resettable
+    end
+
     it "should save to redis" do
       experiment.save
       expect(Split.redis.exists('basket_text')).to be true
@@ -86,7 +92,7 @@ describe Split::Experiment 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.lrange('basket_text', 0, -1)).to eq(['{"Basket":1}', '{"Cart":1}'])
     end
 
     describe 'new record?' do
@@ -213,12 +219,41 @@ describe Split::Experiment do
     it "should have no winner initially" do
       expect(experiment.winner).to be_nil
     end
+  end
 
+  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
+
+    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 +270,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
@@ -414,9 +455,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 +464,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
 
@@ -458,7 +497,7 @@ describe Split::Experiment do
       expect(experiment.alternatives[0].p_winner).to be_within(0.04).of(0.50)
     end
 
-    it "should calculate the probability of being the winning alternative separately for each goal" do
+    it "should calculate the probability of being the winning alternative separately for each goal", :skip => true do
       experiment = Split::ExperimentCatalog.find_or_create({'link_color3' => ["purchase", "refund"]}, 'blue', 'red', 'green')
       goal1 = experiment.goals[0]
       goal2 = experiment.goals[1]

data/spec/helper_spec.rb

@@ -35,6 +35,18 @@ describe Split::Helper do
       expect(lambda { ab_test({'link_color' => "purchase"}, 'blue', 'red') }).not_to raise_error
     end
 
+    it "raises an appropriate error when processing combined expirements" do
+      Split.configuration.experiments = {
+        :combined_exp_1 => {
+          :alternatives => [  { name: "control", percent: 50 },  { name: "test-alt", percent: 50 } ],
+          :metric => :my_metric,
+          :combined_experiments => [:combined_exp_1_sub_1]
+        }
+      }
+      Split::ExperimentCatalog.find_or_create('combined_exp_1')
+      expect(lambda { ab_test('combined_exp_1')}).to raise_error(Split::InvalidExperimentsFormatError )
+    end
+
     it "should assign a random alternative to a new user when there are an equal number of alternatives assigned" do
       ab_test('link_color', 'blue', 'red')
       expect(['red', 'blue']).to include(ab_user['link_color'])
@@ -171,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
@@ -285,98 +296,126 @@ describe Split::Helper do
   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
@@ -516,6 +555,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
@@ -533,7 +583,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"
@@ -552,6 +602,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
@@ -687,6 +742,14 @@ describe Split::Helper do
     end
   end
 
+  describe 'when user is previewing' do
+    before(:each) do
+      @request = OpenStruct.new(headers: { 'x-purpose' => 'preview' })
+    end
+
+    it_behaves_like "a disabled test"
+  end
+
   describe 'versioned experiments' do
     it "should use version zero if no version is present" do
       alternative_name = ab_test('link_color', 'blue', 'red')
@@ -996,8 +1059,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|

data/spec/persistence/cookie_adapter_spec.rb

@@ -1,39 +1,106 @@
 # frozen_string_literal: true
 require "spec_helper"
+require 'rack/test'
 
 describe Split::Persistence::CookieAdapter do
+  subject { described_class.new(context) }
 
-  let(:context) { double(:cookies => CookiesMock.new) }
-  subject { Split::Persistence::CookieAdapter.new(context) }
+  shared_examples "sets cookies correctly" do
+    describe "#[] and #[]=" do
+      it "set and return the value for given key" do
+        subject["my_key"] = "my_value"
+        expect(subject["my_key"]).to eq("my_value")
+      end
 
-  describe "#[] and #[]=" do
-    it "should set and return the value for given key" do
-      subject["my_key"] = "my_value"
-      expect(subject["my_key"]).to eq("my_value")
+      it "handles invalid JSON" do
+        context.request.cookies[:split] = {
+          :value => '{"foo":2,',
+          :expires => Time.now
+        }
+        expect(subject["my_key"]).to be_nil
+        subject["my_key"] = "my_value"
+        expect(subject["my_key"]).to eq("my_value")
+      end
     end
-  end
 
-  describe "#delete" do
-    it "should delete the given key" do
-      subject["my_key"] = "my_value"
-      subject.delete("my_key")
-      expect(subject["my_key"]).to be_nil
+    describe "#delete" do
+      it "should delete the given key" do
+        subject["my_key"] = "my_value"
+        subject.delete("my_key")
+        expect(subject["my_key"]).to be_nil
+      end
     end
-  end
 
-  describe "#keys" do
-    it "should return an array of the session's stored keys" do
-      subject["my_key"] = "my_value"
-      subject["my_second_key"] = "my_second_value"
-      expect(subject.keys).to match(["my_key", "my_second_key"])
+    describe "#keys" do
+      it "should return an array of the session's stored keys" do
+        subject["my_key"] = "my_value"
+        subject["my_second_key"] = "my_second_value"
+        expect(subject.keys).to match(["my_key", "my_second_key"])
+      end
     end
   end
 
-  it "handles invalid JSON" do
-    context.cookies[:split] = { :value => '{"foo":2,', :expires => Time.now }
-    expect(subject["my_key"]).to be_nil
-    subject["my_key"] = "my_value"
-    expect(subject["my_key"]).to eq("my_value")
+
+  context "when using Rack" do
+    let(:env) { Rack::MockRequest.env_for("http://example.com:8080/") }
+    let(:request) { Rack::Request.new(env) }
+    let(:response) { Rack::MockResponse.new(200, {}, "") }
+    let(:context) { double(request: request, response: response, cookies: CookiesMock.new) }
+
+    include_examples "sets cookies correctly"
+
+    it "puts multiple experiments in a single cookie" do
+      subject["foo"] = "FOO"
+      subject["bar"] = "BAR"
+      expect(context.response.headers["Set-Cookie"]).to match(/\Asplit=%7B%22foo%22%3A%22FOO%22%2C%22bar%22%3A%22BAR%22%7D; path=\/; expires=[a-zA-Z]{3}, \d{2} [a-zA-Z]{3} \d{4} \d{2}:\d{2}:\d{2} -0000\Z/)
+    end
+
+    it "ensure other added cookies are not overriden" do
+      context.response.set_cookie 'dummy', 'wow'
+      subject["foo"] = "FOO"
+      expect(context.response.headers["Set-Cookie"]).to include("dummy=wow")
+      expect(context.response.headers["Set-Cookie"]).to include("split=")
+    end
   end
 
+  context "when @context is an ActionController::Base" do
+    before :context do
+      require "rails"
+      require "action_controller/railtie"
+    end
+
+    let(:context) do
+      controller = controller_class.new
+      if controller.respond_to?(:set_request!)
+        controller.set_request!(ActionDispatch::Request.new({}))
+      else # Before rails 5.0
+        controller.send(:"request=", ActionDispatch::Request.new({}))
+      end
+
+      response = ActionDispatch::Response.new(200, {}, '').tap do |res|
+        res.request = controller.request
+      end
+
+      if controller.respond_to?(:set_response!)
+        controller.set_response!(response)
+      else # Before rails 5.0
+        controller.send(:set_response!, response)
+      end
+      controller
+    end
+
+    let(:controller_class) { Class.new(ActionController::Base) }
+
+    include_examples "sets cookies correctly"
+
+    it "puts multiple experiments in a single cookie" do
+      subject["foo"] = "FOO"
+      subject["bar"] = "BAR"
+      expect(subject.keys).to eq(["foo", "bar"])
+      expect(subject["foo"]).to eq("FOO")
+      expect(subject["bar"]).to eq("BAR")
+      cookie_jar = context.request.env["action_dispatch.cookies"]
+      expect(cookie_jar['split']).to eq("{\"foo\":\"FOO\",\"bar\":\"BAR\"}")
+    end
+  end
 end