split 3.3.0 → 4.0.0.pre

data/spec/persistence/cookie_adapter_spec.rb

@@ -52,7 +52,7 @@ describe Split::Persistence::CookieAdapter do
     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/)
+      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} [A-Z]{3}\Z/)
     end
 
     it "ensure other added cookies are not overriden" do

data/spec/persistence/dual_adapter_spec.rb

@@ -1,102 +1,194 @@
 # frozen_string_literal: true
-require "spec_helper"
+
+require 'spec_helper'
 
 describe Split::Persistence::DualAdapter do
+  let(:context) { 'some context' }
 
-  let(:context){ "some context" }
-
-  let(:just_adapter){ Class.new }
-  let(:selected_adapter_instance){ double }
-  let(:selected_adapter){
-    c = Class.new
-    expect(c).to receive(:new){ selected_adapter_instance }
-    c
-  }
-  let(:not_selected_adapter){
-    c = Class.new
-    expect(c).not_to receive(:new)
-    c
-  }
-
-  shared_examples_for "forwarding calls" do
-    it "#[]=" do
-      expect(selected_adapter_instance).to receive(:[]=).with('my_key', 'my_value')
-      expect_any_instance_of(not_selected_adapter).not_to receive(:[]=)
-      subject["my_key"] = "my_value"
-    end
+  let(:logged_in_adapter_instance) { double }
+  let(:logged_in_adapter) do
+    Class.new.tap { |c| allow(c).to receive(:new) { logged_in_adapter_instance } }
+  end
+  let(:logged_out_adapter_instance) { double }
+  let(:logged_out_adapter) do
+    Class.new.tap { |c| allow(c).to receive(:new) { logged_out_adapter_instance } }
+  end
 
-    it "#[]" do
-      expect(selected_adapter_instance).to receive(:[]).with('my_key'){'my_value'}
-      expect_any_instance_of(not_selected_adapter).not_to receive(:[])
-      expect(subject["my_key"]).to eq('my_value')
-    end
+  context 'when fallback_to_logged_out_adapter is false' do
+    context 'when logged in' do
+      subject do
+        described_class.with_config(
+          logged_in: lambda { |context| true },
+          logged_in_adapter: logged_in_adapter,
+          logged_out_adapter: logged_out_adapter,
+          fallback_to_logged_out_adapter: false
+        ).new(context)
+      end
+
+      it '#[]=' do
+        expect(logged_in_adapter_instance).to receive(:[]=).with('my_key', 'my_value')
+        expect_any_instance_of(logged_out_adapter).not_to receive(:[]=)
+        subject['my_key'] = 'my_value'
+      end
+
+      it '#[]' do
+        expect(logged_in_adapter_instance).to receive(:[]).with('my_key') { 'my_value' }
+        expect_any_instance_of(logged_out_adapter).not_to receive(:[])
+        expect(subject['my_key']).to eq('my_value')
+      end
 
-    it "#delete" do
-      expect(selected_adapter_instance).to receive(:delete).with('my_key'){'my_value'}
-      expect_any_instance_of(not_selected_adapter).not_to receive(:delete)
-      expect(subject.delete("my_key")).to eq('my_value')
+      it '#delete' do
+        expect(logged_in_adapter_instance).to receive(:delete).with('my_key') { 'my_value' }
+        expect_any_instance_of(logged_out_adapter).not_to receive(:delete)
+        expect(subject.delete('my_key')).to eq('my_value')
+      end
+
+      it '#keys' do
+        expect(logged_in_adapter_instance).to receive(:keys) { ['my_value'] }
+        expect_any_instance_of(logged_out_adapter).not_to receive(:keys)
+        expect(subject.keys).to eq(['my_value'])
+      end
     end
 
-    it "#keys" do
-      expect(selected_adapter_instance).to receive(:keys){'my_value'}
-      expect_any_instance_of(not_selected_adapter).not_to receive(:keys)
-      expect(subject.keys).to eq('my_value')
+    context 'when logged out' do
+      subject do
+        described_class.with_config(
+          logged_in: lambda { |context| false },
+          logged_in_adapter: logged_in_adapter,
+          logged_out_adapter: logged_out_adapter,
+          fallback_to_logged_out_adapter: false
+        ).new(context)
+      end
+
+      it '#[]=' do
+        expect_any_instance_of(logged_in_adapter).not_to receive(:[]=)
+        expect(logged_out_adapter_instance).to receive(:[]=).with('my_key', 'my_value')
+        subject['my_key'] = 'my_value'
+      end
+
+      it '#[]' do
+        expect_any_instance_of(logged_in_adapter).not_to receive(:[])
+        expect(logged_out_adapter_instance).to receive(:[]).with('my_key') { 'my_value' }
+        expect(subject['my_key']).to eq('my_value')
+      end
+
+      it '#delete' do
+        expect_any_instance_of(logged_in_adapter).not_to receive(:delete)
+        expect(logged_out_adapter_instance).to receive(:delete).with('my_key') { 'my_value' }
+        expect(subject.delete('my_key')).to eq('my_value')
+      end
+
+      it '#keys' do
+        expect_any_instance_of(logged_in_adapter).not_to receive(:keys)
+        expect(logged_out_adapter_instance).to receive(:keys) { ['my_value', 'my_value2'] }
+        expect(subject.keys).to eq(['my_value', 'my_value2'])
+      end
     end
   end
 
-  context "when logged in" do
-    subject {
-      described_class.with_config(
-        logged_in: lambda { |context| true },
-        logged_in_adapter: selected_adapter,
-        logged_out_adapter: not_selected_adapter
+  context 'when fallback_to_logged_out_adapter is true' do
+    context 'when logged in' do
+      subject do
+        described_class.with_config(
+          logged_in: lambda { |context| true },
+          logged_in_adapter: logged_in_adapter,
+          logged_out_adapter: logged_out_adapter,
+          fallback_to_logged_out_adapter: true
         ).new(context)
-    }
+      end
 
-    it_should_behave_like "forwarding calls"
-  end
+      it '#[]=' do
+        expect(logged_in_adapter_instance).to receive(:[]=).with('my_key', 'my_value')
+        expect(logged_out_adapter_instance).to receive(:[]=).with('my_key', 'my_value')
+        expect(logged_out_adapter_instance).to receive(:[]).with('my_key') { nil }
+        subject['my_key'] = 'my_value'
+      end
+
+      it '#[]' do
+        expect(logged_in_adapter_instance).to receive(:[]).with('my_key') { 'my_value' }
+        expect_any_instance_of(logged_out_adapter).not_to receive(:[])
+        expect(subject['my_key']).to eq('my_value')
+      end
+
+      it '#delete' do
+        expect(logged_in_adapter_instance).to receive(:delete).with('my_key') { 'my_value' }
+        expect(logged_out_adapter_instance).to receive(:delete).with('my_key') { 'my_value' }
+        expect(subject.delete('my_key')).to eq('my_value')
+      end
+
+      it '#keys' do
+        expect(logged_in_adapter_instance).to receive(:keys) { ['my_value'] }
+        expect(logged_out_adapter_instance).to receive(:keys) { ['my_value', 'my_value2'] }
+        expect(subject.keys).to eq(['my_value', 'my_value2'])
+      end
+    end
 
-  context "when not logged in" do
-    subject {
-      described_class.with_config(
-        logged_in: lambda { |context| false },
-        logged_in_adapter: not_selected_adapter,
-        logged_out_adapter: selected_adapter
+    context 'when logged out' do
+      subject do
+        described_class.with_config(
+          logged_in: lambda { |context| false },
+          logged_in_adapter: logged_in_adapter,
+          logged_out_adapter: logged_out_adapter,
+          fallback_to_logged_out_adapter: true
         ).new(context)
-    }
+      end
+
+      it '#[]=' do
+        expect_any_instance_of(logged_in_adapter).not_to receive(:[]=)
+        expect(logged_out_adapter_instance).to receive(:[]=).with('my_key', 'my_value')
+        expect(logged_out_adapter_instance).to receive(:[]).with('my_key') { nil }
+        subject['my_key'] = 'my_value'
+      end
+
+      it '#[]' do
+        expect_any_instance_of(logged_in_adapter).not_to receive(:[])
+        expect(logged_out_adapter_instance).to receive(:[]).with('my_key') { 'my_value' }
+        expect(subject['my_key']).to eq('my_value')
+      end
+
+      it '#delete' do
+        expect(logged_in_adapter_instance).to receive(:delete).with('my_key') { 'my_value' }
+        expect(logged_out_adapter_instance).to receive(:delete).with('my_key') { 'my_value' }
+        expect(subject.delete('my_key')).to eq('my_value')
+      end
 
-    it_should_behave_like "forwarding calls"
+      it '#keys' do
+        expect(logged_in_adapter_instance).to receive(:keys) { ['my_value'] }
+        expect(logged_out_adapter_instance).to receive(:keys) { ['my_value', 'my_value2'] }
+        expect(subject.keys).to eq(['my_value', 'my_value2'])
+      end
+    end
   end
 
-  describe "when errors in config" do
-    before{
-      described_class.config.clear
-    }
-    let(:some_proc){ ->{} }
-    it "when no logged in adapter" do
+  describe 'when errors in config' do
+    before { described_class.config.clear }
+    let(:some_proc) { ->{} }
+
+    it 'when no logged in adapter' do
       expect{
         described_class.with_config(
           logged_in: some_proc,
-          logged_out_adapter: just_adapter
-          ).new(context)
+          logged_out_adapter: logged_out_adapter
+        ).new(context)
       }.to raise_error(StandardError, /:logged_in_adapter/)
     end
-    it "when no logged out adapter" do
+
+    it 'when no logged out adapter' do
       expect{
         described_class.with_config(
           logged_in: some_proc,
-          logged_in_adapter: just_adapter
-          ).new(context)
+          logged_in_adapter: logged_in_adapter
+        ).new(context)
       }.to raise_error(StandardError, /:logged_out_adapter/)
     end
-    it "when no logged in detector" do
+
+    it 'when no logged in detector' do
       expect{
         described_class.with_config(
-          logged_in_adapter: just_adapter,
-          logged_out_adapter: just_adapter
-          ).new(context)
+          logged_in_adapter: logged_in_adapter,
+          logged_out_adapter: logged_out_adapter
+        ).new(context)
       }.to raise_error(StandardError, /:logged_in$/)
     end
   end
-
 end

data/spec/persistence/redis_adapter_spec.rb

@@ -60,6 +60,15 @@ describe Split::Persistence::RedisAdapter do
     end
   end
 
+  describe '#find' do
+    before { Split::Persistence::RedisAdapter.with_config(:lookup_by => proc{'frag'}, :namespace => 'a_namespace') }
+
+    it "should create and user from a given key" do
+      adapter = Split::Persistence::RedisAdapter.find(2)
+      expect(adapter.redis_key).to eq("a_namespace:2")
+    end
+  end
+
   context 'functional tests' do
     before { Split::Persistence::RedisAdapter.with_config(:lookup_by => 'lookup') }
 

data/spec/redis_interface_spec.rb

@@ -29,75 +29,6 @@ describe Split::RedisInterface do
     end
   end
 
-  describe '#add_to_list' do
-    subject(:add_to_list) do
-      interface.add_to_list(list_name, 'y')
-      interface.add_to_list(list_name, 'z')
-    end
-
-    specify do
-      add_to_list
-      expect(Split.redis.lindex(list_name, 0)).to eq 'y'
-      expect(Split.redis.lindex(list_name, 1)).to eq 'z'
-      expect(Split.redis.llen(list_name)).to eq 2
-    end
-  end
-
-  describe '#set_list_index' do
-    subject(:set_list_index) do
-      interface.add_to_list(list_name, 'y')
-      interface.add_to_list(list_name, 'z')
-      interface.set_list_index(list_name, 0, 'a')
-    end
-
-    specify do
-      set_list_index
-      expect(Split.redis.lindex(list_name, 0)).to eq 'a'
-      expect(Split.redis.lindex(list_name, 1)).to eq 'z'
-      expect(Split.redis.llen(list_name)).to eq 2
-    end
-  end
-
-  describe '#list_length' do
-    subject(:list_length) do
-      interface.add_to_list(list_name, 'y')
-      interface.add_to_list(list_name, 'z')
-      interface.list_length(list_name)
-    end
-
-    specify do
-      expect(list_length).to eq 2
-    end
-  end
-
-  describe '#remove_last_item_from_list' do
-    subject(:remove_last_item_from_list) do
-      interface.add_to_list(list_name, 'y')
-      interface.add_to_list(list_name, 'z')
-      interface.remove_last_item_from_list(list_name)
-    end
-
-    specify do
-      remove_last_item_from_list
-      expect(Split.redis.lindex(list_name, 0)).to eq 'y'
-      expect(Split.redis.llen(list_name)).to eq 1
-    end
-  end
-
-  describe '#make_list_length' do
-    subject(:make_list_length) do
-      interface.add_to_list(list_name, 'y')
-      interface.add_to_list(list_name, 'z')
-      interface.make_list_length(list_name, 1)
-    end
-
-    specify do
-      make_list_length
-      expect(Split.redis.lindex(list_name, 0)).to eq 'y'
-      expect(Split.redis.llen(list_name)).to eq 1
-    end
-  end
-
   describe '#add_to_set' do
     subject(:add_to_set) do
       interface.add_to_set(set_name, 'something')

data/spec/spec_helper.rb

@@ -13,17 +13,16 @@ require 'yaml'
 
 Dir['./spec/support/*.rb'].each { |f| require f }
 
-require "fakeredis"
-
-G_fakeredis = Redis.new
-
 module GlobalSharedContext
   extend RSpec::SharedContext
   let(:mock_user){ Split::User.new(double(session: {})) }
+
   before(:each) do
     Split.configuration = Split::Configuration.new
-    Split.redis = G_fakeredis
-    Split.redis.flushall
+    Split.redis = Redis.new
+    Split.redis.select(10)
+    Split.redis.flushdb
+    Split::Cache.clear
     @ab_user = mock_user
     params = nil
   end

data/spec/trial_spec.rb

@@ -176,6 +176,14 @@ describe Split::Trial do
 
         expect_alternative(trial, 'basket')
       end
+
+      context "when alternative is not found" do
+        it "falls back on next_alternative" do
+          user[experiment.key] = 'notfound'
+          expect(experiment).to receive(:next_alternative).and_call_original
+          expect_alternative(trial, alternatives)
+        end
+      end
     end
 
     context "when user is a new participant" do
@@ -190,42 +198,68 @@ describe Split::Trial do
         expect(trial.alternative.name).to_not be_empty
         Split.configuration.on_trial_choose = nil
       end
+
+      it "assigns user to an alternative" do
+        trial.choose! context
+
+        expect(alternatives).to include(user[experiment.name])
+      end
+
+      context "when cohorting is disabled" do
+        before(:each) { allow(experiment).to receive(:cohorting_disabled?).and_return(true) }
+
+        it "picks the control and does not run on_trial callbacks" do
+          Split.configuration.on_trial = :on_trial_callback
+
+          expect(experiment).to_not receive(:next_alternative)
+          expect(context).not_to receive(:on_trial_callback)
+          expect_alternative(trial, 'basket')
+
+          Split.configuration.enabled = true
+          Split.configuration.on_trial = nil
+        end
+
+        it "user is not assigned an alternative" do
+          trial.choose! context
+
+          expect(user[experiment]).to eq(nil)
+        end
+      end
     end
   end
 
   describe "#complete!" do
-    let(:trial) { Split::Trial.new(:user => user, :experiment => experiment) }
     context 'when there are no goals' do
+      let(:trial) { Split::Trial.new(:user => user, :experiment => experiment) }
       it 'should complete the trial' do
         trial.choose!
         old_completed_count = trial.alternative.completed_count
         trial.complete!
-        expect(trial.alternative.completed_count).to be(old_completed_count+1)
+        expect(trial.alternative.completed_count).to eq(old_completed_count + 1)
       end
     end
 
-    context 'when there are many goals' do
-      let(:goals) { ['first', 'second'] }
+    context "when there are many goals" do
+      let(:goals) { [ "goal1", "goal2" ] }
       let(:trial) { Split::Trial.new(:user => user, :experiment => experiment, :goals => goals) }
-      shared_examples_for "goal completion" do
-        it 'should not complete the trial' do
-          trial.choose!
-          old_completed_count = trial.alternative.completed_count
-          trial.complete!(goal)
-          expect(trial.alternative.completed_count).to_not be(old_completed_count+1)
-        end
-      end
 
-      describe 'Array of Goals' do
-        let(:goal) { [goals.first] }
-        it_behaves_like 'goal completion'
+      it "increments the completed count corresponding to the goals" do
+        trial.choose!
+        old_completed_counts = goals.map{ |goal| [goal, trial.alternative.completed_count(goal)] }.to_h 
+        trial.complete!
+        goals.each { | goal | expect(trial.alternative.completed_count(goal)).to eq(old_completed_counts[goal] + 1) }
       end
+    end
 
-      describe 'String of Goal' do
-        let(:goal) { goals.first }
-        it_behaves_like 'goal completion'
+    context "when there is 1 goal of type string" do
+      let(:goal) { "goal" }
+      let(:trial) { Split::Trial.new(:user => user, :experiment => experiment, :goals => goal) }
+      it "increments the completed count corresponding to the goal" do
+        trial.choose!
+        old_completed_count = trial.alternative.completed_count(goal)
+        trial.complete!
+        expect(trial.alternative.completed_count(goal)).to eq(old_completed_count + 1)
       end
-
     end
   end
 
@@ -275,5 +309,17 @@ describe Split::Trial do
         trial.choose!
       end
     end
+
+    context 'when experiment has winner' do
+      let(:trial) do
+        experiment.winner = 'cart'
+        Split::Trial.new(:user => user, :experiment => experiment)
+      end
+
+      it 'does not store' do
+        expect(user).to_not receive("[]=")
+        trial.choose!
+      end
+    end
   end
 end