split 3.4.0 → 4.0.1

data/lib/split.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
+
 require 'redis'
 
 require 'split/algorithms/block_randomization'
 require 'split/algorithms/weighted_sample'
 require 'split/algorithms/whiplash'
 require 'split/alternative'
+require 'split/cache'
 require 'split/configuration'
 require 'split/encapsulated_helper'
 require 'split/exceptions'
@@ -35,9 +37,9 @@ module Split
   #      `Redis::DistRedis`, or `Redis::Namespace`.
   def redis=(server)
     @redis = if server.is_a?(String)
-      Redis.new(:url => server, :thread_safe => true)
+      Redis.new(url: server)
     elsif server.is_a?(Hash)
-      Redis.new(server.merge(:thread_safe => true))
+      Redis.new(server)
     elsif server.respond_to?(:smembers)
       server
     else
@@ -64,11 +66,15 @@ module Split
     self.configuration ||= Configuration.new
     yield(configuration)
   end
+
+  def cache(namespace, key, &block)
+    Split::Cache.fetch(namespace, key, &block)
+  end
 end
 
 # Check to see if being run in a Rails application.  If so, wait until before_initialize to run configuration so Gems that create ENV variables have the chance to initialize first.
 if defined?(::Rails)
-  class Railtie < Rails::Railtie
+  class Split::Railtie < Rails::Railtie
     config.before_initialize { Split.configure {} }
   end
 else

data/spec/alternative_spec.rb

@@ -126,7 +126,7 @@ describe Split::Alternative do
 
   it "should save to redis" do
     alternative.save
-    expect(Split.redis.exists('basket_text:Basket')).to be true
+    expect(Split.redis.exists?('basket_text:Basket')).to be true
   end
 
   it "should increment participation count" do

data/spec/cache_spec.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe Split::Cache do
+
+  let(:namespace) { :test_namespace }
+  let(:key) { :test_key }
+  let(:now) { 1606189017 }
+
+  before { allow(Time).to receive(:now).and_return(now) }
+
+  describe 'clear' do
+
+    before { Split.configuration.cache = true }
+
+    it 'clears the cache' do
+      expect(Time).to receive(:now).and_return(now).exactly(2).times
+      Split::Cache.fetch(namespace, key) { Time.now }
+      Split::Cache.clear
+      Split::Cache.fetch(namespace, key) { Time.now }
+    end
+  end
+
+  describe 'clear_key' do
+    before { Split.configuration.cache = true }
+
+    it 'clears the cache' do
+      expect(Time).to receive(:now).and_return(now).exactly(3).times
+      Split::Cache.fetch(namespace, :key1) { Time.now }
+      Split::Cache.fetch(namespace, :key2) { Time.now }
+      Split::Cache.clear_key(:key1)
+
+      Split::Cache.fetch(namespace, :key1) { Time.now }
+      Split::Cache.fetch(namespace, :key2) { Time.now }
+    end
+  end
+
+  describe 'fetch' do
+
+    subject { Split::Cache.fetch(namespace, key) { Time.now } }
+
+    context 'when cache disabled' do
+
+      before { Split.configuration.cache = false }
+
+      it 'returns the yield' do
+        expect(subject).to eql(now)
+      end
+
+      it 'yields every time' do
+        expect(Time).to receive(:now).and_return(now).exactly(2).times
+        Split::Cache.fetch(namespace, key) { Time.now }
+        Split::Cache.fetch(namespace, key) { Time.now }
+      end
+    end
+
+    context 'when cache enabled' do
+
+      before { Split.configuration.cache = true }
+
+      it 'returns the yield' do
+        expect(subject).to eql(now)
+      end
+
+      it 'yields once' do
+        expect(Time).to receive(:now).and_return(now).once
+        Split::Cache.fetch(namespace, key) { Time.now }
+        Split::Cache.fetch(namespace, key) { Time.now }
+      end
+
+      it 'honors namespace' do
+        expect(Split::Cache.fetch(:a, key) { :a }).to eql(:a)
+        expect(Split::Cache.fetch(:b, key) { :b }).to eql(:b)
+
+        expect(Split::Cache.fetch(:a, key) { :a }).to eql(:a)
+        expect(Split::Cache.fetch(:b, key) { :b }).to eql(:b)
+      end
+
+      it 'honors key' do
+        expect(Split::Cache.fetch(namespace, :a) { :a }).to eql(:a)
+        expect(Split::Cache.fetch(namespace, :b) { :b }).to eql(:b)
+
+        expect(Split::Cache.fetch(namespace, :a) { :a }).to eql(:a)
+        expect(Split::Cache.fetch(namespace, :b) { :b }).to eql(:b)
+      end
+    end
+  end
+end

data/spec/configuration_spec.rb

@@ -212,23 +212,12 @@ describe Split::Configuration do
     expect(@config.normalized_experiments).to eq({:my_experiment=>{:alternatives=>[{"control_opt"=>0.67}, [{"second_opt"=>0.1}, {"third_opt"=>0.23}]]}})
   end
 
-  context 'redis_url configuration [DEPRECATED]' do
-    it 'should warn on set and assign to #redis' do
-      expect(@config).to receive(:warn).with(/\[DEPRECATED\]/) { nil }
-      @config.redis_url = 'example_url'
-      expect(@config.redis).to eq('example_url')
-    end
-
-    it 'should warn on get and return #redis' do
-      expect(@config).to receive(:warn).with(/\[DEPRECATED\]/) { nil }
-      @config.redis = 'example_url'
-      expect(@config.redis_url).to eq('example_url')
-    end
-  end
-
   context "redis configuration" do
     it "should default to local redis server" do
-      expect(@config.redis).to eq("redis://localhost:6379")
+      old_redis_url = ENV['REDIS_URL']
+      ENV.delete('REDIS_URL')
+      expect(Split::Configuration.new.redis).to eq("redis://localhost:6379")
+      ENV['REDIS_URL'] = old_redis_url
     end
 
     it "should allow for redis url to be configured" do
@@ -238,8 +227,10 @@ describe Split::Configuration do
 
     context "provided REDIS_URL environment variable" do
       it "should use the ENV variable" do
+        old_redis_url = ENV['REDIS_URL']
         ENV['REDIS_URL'] = "env_redis_url"
         expect(Split::Configuration.new.redis).to eq("env_redis_url")
+        ENV['REDIS_URL'] = old_redis_url
       end
     end
   end
@@ -255,4 +246,15 @@ describe Split::Configuration do
     end
   end
 
+  context "persistence cookie domain" do
+    it "should default to nil" do
+      expect(@config.persistence_cookie_domain).to eq(nil)
+    end
+
+    it "should allow the persistence cookie domain to be configured" do
+      @config.persistence_cookie_domain = '.acme.com'
+      expect(@config.persistence_cookie_domain).to eq('.acme.com')
+    end
+  end
+
 end

data/spec/dashboard_spec.rb

@@ -6,8 +6,16 @@ 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)
@@ -90,8 +98,17 @@ describe Split::Dashboard do
       it "should set current user's alternative" do
         blue_link.participant_count = 7
         post "/force_alternative?experiment=#{experiment.name}", alternative: "blue"
-        expect(user[experiment.key]).to eq("blue")
-        expect(blue_link.participant_count).to eq(8)
+
+        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
 
@@ -108,8 +125,9 @@ describe Split::Dashboard do
       it "should set current user's alternative" do
         blue_link.participant_count = 7
         post "/force_alternative?experiment=#{experiment.name}", alternative: "blue"
-        expect(user[experiment.key]).to eq("blue")
-        expect(blue_link.participant_count).to eq(8)
+
+        get "/my_experiment?experiment=#{experiment.name}"
+        expect(last_response.body).to include("blue")
       end
     end
   end
@@ -161,6 +179,28 @@ 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
+
   it "should reset an experiment" do
     red_link.participant_count = 5
     blue_link.participant_count = 7

data/spec/encapsulated_helper_spec.rb

@@ -21,7 +21,7 @@ describe Split::EncapsulatedHelper do
     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| ab_test('link_color', 'red', 'red', &block) }.to yield_with_args('red', {})
     end
 
     context "inside a view" do

data/spec/experiment_spec.rb

@@ -35,15 +35,9 @@ 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
+      expect(Split.redis.exists?('basket_text')).to be true
     end
 
     it "should save the start time to redis" do
@@ -91,7 +85,7 @@ describe Split::Experiment do
     it "should not create duplicates when saving multiple times" do
       experiment.save
       experiment.save
-      expect(Split.redis.exists('basket_text')).to be true
+      expect(Split.redis.exists?('basket_text')).to be true
       expect(Split.redis.lrange('basket_text', 0, -1)).to eq(['{"Basket":1}', '{"Cart":1}'])
     end
 
@@ -124,6 +118,23 @@ describe Split::Experiment do
       experiment = Split::Experiment.new('basket_text', :alternatives => ['Basket', "Cart"], :resettable => false)
       expect(experiment.resettable).to be_falsey
     end
+
+    context 'from configuration' do
+      let(:experiment_name) { :my_experiment }
+      let(:experiments) do
+        {
+          experiment_name => {
+            :alternatives => ['Control Opt', 'Alt one']
+          }
+        }
+      end
+
+      before { Split.configuration.experiments = experiments }
+
+      it 'assigns default values to the experiment' do
+        expect(Split::Experiment.new(experiment_name).resettable).to eq(true)
+      end
+    end
   end
 
   describe 'persistent configuration' do
@@ -140,10 +151,23 @@ describe Split::Experiment do
 
     describe '#metadata' do
       let(:experiment) { Split::Experiment.new('basket_text', :alternatives => ['Basket', "Cart"], :algorithm => Split::Algorithms::Whiplash, :metadata => meta) }
+      let(:meta) { { a: 'b' }}
+
+      before do
+        experiment.save
+      end
+
+      it "should delete the key when metadata is removed" do
+        experiment.metadata = nil
+        experiment.save
+
+        expect(Split.redis.exists?(experiment.metadata_key)).to be_falsey
+      end
+
       context 'simple hash' do
         let(:meta) {  { 'basket' => 'a', 'cart' => 'b' } }
+
         it "should persist metadata in redis" do
-          experiment.save
           e = Split::ExperimentCatalog.find('basket_text')
           expect(e).to eq(experiment)
           expect(e.metadata).to eq(meta)
@@ -153,7 +177,6 @@ describe Split::Experiment do
       context 'nested hash' do
         let(:meta) {  { 'basket' => { 'one' => 'two' }, 'cart' => 'b' } }
         it "should persist metadata in redis" do
-          experiment.save
           e = Split::ExperimentCatalog.find('basket_text')
           expect(e).to eq(experiment)
           expect(e.metadata).to eq(meta)
@@ -186,7 +209,7 @@ describe Split::Experiment do
       experiment.save
 
       experiment.delete
-      expect(Split.redis.exists('link_color')).to be false
+      expect(Split.redis.exists?('link_color')).to be false
       expect(Split::ExperimentCatalog.find('link_color')).to be_nil
     end
 
@@ -212,8 +235,14 @@ describe Split::Experiment do
       experiment.delete
       expect(experiment.start_time).to be_nil
     end
-  end
 
+    it "should default cohorting back to false" do
+      experiment.disable_cohorting
+      expect(experiment.cohorting_disabled?).to eq(true)
+      experiment.delete
+      expect(experiment.cohorting_disabled?).to eq(false)
+    end
+  end
 
   describe 'winner' do
     it "should have no winner initially" do
@@ -222,12 +251,17 @@ describe Split::Experiment do
   end
 
   describe 'winner=' do
-    it "should allow you to specify a winner" do
+    it 'should allow you to specify a winner' do
       experiment.save
       experiment.winner = 'red'
       expect(experiment.winner.name).to eq('red')
     end
 
+    it 'should call the on_experiment_winner_choose hook' do
+      expect(Split.configuration.on_experiment_winner_choose).to receive(:call)
+      experiment.winner = 'green'
+    end
+
     context 'when has_winner state is memoized' do
       before { expect(experiment).to_not have_winner }
 
@@ -376,6 +410,22 @@ describe Split::Experiment do
     end
   end
 
+  describe "#cohorting_disabled?" do
+    it "returns false when nothing has been configured" do
+      expect(experiment.cohorting_disabled?).to eq false
+    end
+
+    it "returns true when enable_cohorting is performed" do
+      experiment.enable_cohorting
+      expect(experiment.cohorting_disabled?).to eq false
+    end
+
+    it "returns false when nothing has been configured" do
+      experiment.disable_cohorting
+      expect(experiment.cohorting_disabled?).to eq true
+    end
+  end
+
   describe 'changing an existing experiment' do
     def same_but_different_alternative
       Split::ExperimentCatalog.find_or_create('link_color', 'blue', 'yellow', 'orange')
@@ -398,6 +448,21 @@ describe Split::Experiment do
       expect(same_experiment_again.version).to eq(1)
     end
 
+    context "when metadata is changed" do
+      it "should increase version" do
+        experiment.save
+        experiment.metadata = { 'foo' => 'bar' }
+
+        expect { experiment.save }.to change { experiment.version }.by(1)
+      end
+
+      it "does not increase version" do
+        experiment.metadata = nil
+        experiment.save
+        expect { experiment.save }.to change { experiment.version }.by(0)
+      end
+    end
+
     context 'when experiment configuration is changed' do
       let(:reset_manually) { false }
 

data/spec/goals_collection_spec.rb

@@ -48,7 +48,7 @@ describe Split::GoalsCollection do
       goals_collection.save
 
       goals_collection.delete
-      expect(Split.redis.exists(goals_key)).to be false
+      expect(Split.redis.exists?(goals_key)).to be false
     end
   end
 

data/spec/helper_spec.rb

@@ -229,13 +229,15 @@ describe Split::Helper do
 
       context "when user already has experiment" do
         let(:mock_user){ Split::User.new(self, {'test_0' => 'test-alt'}) }
-        before{
+
+        before do
           Split.configure do |config|
             config.allow_multiple_experiments = 'control'
           end
+
           Split::ExperimentCatalog.find_or_initialize('test_0', 'control', 'test-alt').save
           Split::ExperimentCatalog.find_or_initialize('test_1', 'control', 'test-alt').save
-        }
+        end
 
         it "should restore previously selected alternative" do
           expect(ab_user.active_experiments.size).to eq 1
@@ -243,6 +245,16 @@ describe Split::Helper do
           expect(ab_test(:test_0, {'control' => 1}, {"test-alt" => 100})).to eq 'test-alt'
         end
 
+        it "should select the correct alternatives after experiment resets" do
+          experiment = Split::ExperimentCatalog.find(:test_0)
+          experiment.reset
+          mock_user[experiment.key] = 'test-alt'
+
+          expect(ab_user.active_experiments.size).to eq 1
+          expect(ab_test(:test_0, {'control' => 100}, {"test-alt" => 1})).to eq 'test-alt'
+          expect(ab_test(:test_0, {'control' => 0}, {"test-alt" => 100})).to eq 'test-alt'
+        end
+
         it "lets override existing choice" do
           pending "this requires user store reset on first call not depending on whelther it is current trial"
           @params = { 'ab_test' => { 'test_1' => 'test-alt' } }
@@ -265,33 +277,63 @@ describe Split::Helper do
   end
 
   describe 'metadata' do
-    before do
-      Split.configuration.experiments = {
-        :my_experiment => {
-          :alternatives => ["one", "two"],
-          :resettable => false,
-          :metadata => { 'one' => 'Meta1', 'two' => 'Meta2' }
+    context 'is defined' do
+      before do
+        Split.configuration.experiments = {
+          :my_experiment => {
+            :alternatives => ["one", "two"],
+            :resettable => false,
+            :metadata => { 'one' => 'Meta1', 'two' => 'Meta2' }
+          }
         }
-      }
-    end
+      end
 
-    it 'should be passed to helper block' do
-      @params = { 'ab_test' => { 'my_experiment' => 'one' } }
-      expect(ab_test('my_experiment')).to eq 'one'
-      expect(ab_test('my_experiment') do |alternative, meta|
-        meta
-      end).to eq('Meta1')
+      it 'should be passed to helper block' do
+        @params = { 'ab_test' => { 'my_experiment' => 'two' } }
+        expect(ab_test('my_experiment')).to eq 'two'
+        expect(ab_test('my_experiment') do |alternative, meta|
+          meta
+        end).to eq('Meta2')
+      end
+
+      it 'should pass control metadata helper block if library disabled' do
+        Split.configure do |config|
+          config.enabled = false
+        end
+
+        expect(ab_test('my_experiment')).to eq 'one'
+        expect(ab_test('my_experiment') do |_, meta|
+          meta
+        end).to eq('Meta1')
+      end
     end
 
-    it 'should pass empty hash to helper block if library disabled' do
-      Split.configure do |config|
-        config.enabled = false
+    context 'is not defined' do
+      before do
+        Split.configuration.experiments = {
+          :my_experiment => {
+            :alternatives => ["one", "two"],
+            :resettable => false,
+            :metadata => nil
+          }
+        }
+      end
+
+      it 'should be passed to helper block' do
+        expect(ab_test('my_experiment') do |alternative, meta|
+          meta
+        end).to eq({})
       end
 
-      expect(ab_test('my_experiment')).to eq 'one'
-      expect(ab_test('my_experiment') do |_, meta|
-        meta
-      end).to eq({})
+      it 'should pass control metadata helper block if library disabled' do
+        Split.configure do |config|
+          config.enabled = false
+        end
+
+        expect(ab_test('my_experiment') do |_, meta|
+          meta
+        end).to eq({})
+      end
     end
   end
 
@@ -1096,15 +1138,9 @@ describe Split::Helper do
       end
 
       it "should increment the counter for the specified-goal completed alternative" do
-        expect(lambda {
-          expect(lambda {
-            ab_finished({"link_color" => ["purchase"]})
-          }).not_to change {
-            Split::Alternative.new(@alternative_name, @experiment_name).completed_count(@goal2)
-          }
-        }).to change {
-          Split::Alternative.new(@alternative_name, @experiment_name).completed_count(@goal1)
-        }.by(1)
+        expect{ ab_finished({"link_color" => ["purchase"]}) }
+          .to change{ Split::Alternative.new(@alternative_name, @experiment_name).completed_count(@goal2) }.by(0)
+          .and change{ Split::Alternative.new(@alternative_name, @experiment_name).completed_count(@goal1) }.by(1)
       end
     end
   end

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/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') }