split 3.2.0 → 4.0.5

data/spec/redis_interface_spec.rb

@@ -1,111 +1,54 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 describe Split::RedisInterface do
-  let(:list_name) { 'list_name' }
-  let(:set_name) { 'set_name' }
+  let(:list_name) { "list_name" }
+  let(:set_name) { "set_name" }
   let(:interface) { described_class.new }
 
-  describe '#persist_list' do
+  describe "#persist_list" do
     subject(:persist_list) do
       interface.persist_list(list_name, %w(a b c d))
     end
 
     specify do
       expect(persist_list).to eq %w(a b c d)
-      expect(Split.redis.lindex(list_name, 0)).to eq 'a'
-      expect(Split.redis.lindex(list_name, 1)).to eq 'b'
-      expect(Split.redis.lindex(list_name, 2)).to eq 'c'
-      expect(Split.redis.lindex(list_name, 3)).to eq 'd'
+      expect(Split.redis.lindex(list_name, 0)).to eq "a"
+      expect(Split.redis.lindex(list_name, 1)).to eq "b"
+      expect(Split.redis.lindex(list_name, 2)).to eq "c"
+      expect(Split.redis.lindex(list_name, 3)).to eq "d"
       expect(Split.redis.llen(list_name)).to eq 4
     end
 
-    context 'list is overwritten but not deleted' do
+    context "list is overwritten but not deleted" do
       specify do
         expect(persist_list).to eq %w(a b c d)
-        interface.persist_list(list_name, ['z'])
-        expect(Split.redis.lindex(list_name, 0)).to eq 'z'
+        interface.persist_list(list_name, ["z"])
+        expect(Split.redis.lindex(list_name, 0)).to eq "z"
         expect(Split.redis.llen(list_name)).to eq 1
       end
     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)
+  describe "#add_to_set" do
+    subject(:add_to_set) do
+      interface.add_to_set(set_name, "something")
     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
+      add_to_set
+      expect(Split.redis.sismember(set_name, "something")).to be true
     end
-  end
 
-  describe '#add_to_set' do
-    subject(:add_to_set) do
-      interface.add_to_set(set_name, 'something')
-    end
+    context "when a Redis version is used that supports the 'sadd?' method" do
+      before { expect(Split.redis).to receive(:respond_to?).with(:sadd?).and_return(true) }
 
-    specify do
-      add_to_set
-      expect(Split.redis.sismember(set_name, 'something')).to be true
+      it "will use this method instead of 'sadd'" do
+        expect(Split.redis).to receive(:sadd?).with(set_name, "something")
+        expect(Split.redis).not_to receive(:sadd).with(set_name, "something")
+        add_to_set
+      end
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,37 +1,38 @@
 # frozen_string_literal: true
-ENV['RACK_ENV'] = "test"
 
-require 'rubygems'
-require 'bundler/setup'
+ENV["RACK_ENV"] = "test"
 
-require 'simplecov'
-SimpleCov.start
-
-require 'split'
-require 'ostruct'
-require 'yaml'
+require "rubygems"
+require "bundler/setup"
 
-Dir['./spec/support/*.rb'].each { |f| require f }
+require "simplecov"
+SimpleCov.start
 
-require "fakeredis"
+require "split"
+require "yaml"
+require "pry"
 
-G_fakeredis = Redis.new
+Dir["./spec/support/*.rb"].each { |f| require f }
 
 module GlobalSharedContext
   extend RSpec::SharedContext
-  let(:mock_user){ Split::User.new(double(session: {})) }
+  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
+    @params = nil
   end
 end
 
 RSpec.configure do |config|
-  config.order = 'random'
+  config.order = "random"
   config.include GlobalSharedContext
+  config.raise_errors_for_deprecations!
 end
 
 def session
@@ -42,11 +43,24 @@ def params
   @params ||= {}
 end
 
-def request(ua = 'Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_6_6; de-de) AppleWebKit/533.20.25 (KHTML, like Gecko) Version/5.0.4 Safari/533.20.27')
-  @request ||= begin
-    r = OpenStruct.new
-    r.user_agent = ua
-    r.ip = '192.168.1.1'
-    r
-  end
+def request
+  @request ||= build_request
+end
+
+DummyRequest = Struct.new(:user_agent, :ip, :params, :cookies, :headers)
+
+def build_request(
+  user_agent: "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_6_6; de-de) AppleWebKit/533.20.25 (KHTML, like Gecko) Version/5.0.4 Safari/533.20.27",
+  ip: "192.168.1.1",
+  params: {},
+  cookies: {},
+  headers: {}
+)
+  r = DummyRequest.new
+  r.user_agent = user_agent
+  r.ip = ip
+  r.params = params
+  r.cookies = cookies
+  r.headers = headers
+  r
 end

data/spec/split_spec.rb

@@ -1,42 +1,42 @@
 # frozen_string_literal: true
-require 'spec_helper'
 
-RSpec.describe Split do
+require "spec_helper"
 
+RSpec.describe Split do
   around(:each) do |ex|
-    old_env, old_redis = [ENV.delete('REDIS_URL'), Split.redis]
+    old_env, old_redis = [ENV.delete("REDIS_URL"), Split.redis]
     ex.run
-    ENV['REDIS_URL'] = old_env
+    ENV["REDIS_URL"] = old_env
     Split.redis = old_redis
   end
 
-  describe '#redis=' do
-    it 'accepts a url string' do
-      Split.redis = 'redis://localhost:6379'
+  describe "#redis=" do
+    it "accepts a url string" do
+      Split.redis = "redis://localhost:6379"
       expect(Split.redis).to be_a(Redis)
 
-      client = Split.redis.client
-      expect(client.host).to eq("localhost")
-      expect(client.port).to eq(6379)
+      client = Split.redis.connection
+      expect(client[:host]).to eq("localhost")
+      expect(client[:port]).to eq(6379)
     end
 
-    it 'accepts an options hash' do
-      Split.redis = {host: 'localhost', port: 6379, db: 12}
+    it "accepts an options hash" do
+      Split.redis = { host: "localhost", port: 6379, db: 12 }
       expect(Split.redis).to be_a(Redis)
 
-      client = Split.redis.client
-      expect(client.host).to eq("localhost")
-      expect(client.port).to eq(6379)
-      expect(client.db).to eq(12)
+      client = Split.redis.connection
+      expect(client[:host]).to eq("localhost")
+      expect(client[:port]).to eq(6379)
+      expect(client[:db]).to eq(12)
     end
 
-    it 'accepts a valid Redis instance' do
+    it "accepts a valid Redis instance" do
       other_redis = Redis.new(url: "redis://localhost:6379")
       Split.redis = other_redis
       expect(Split.redis).to eq(other_redis)
     end
 
-    it 'raises an ArgumentError when server cannot be determined' do
+    it "raises an ArgumentError when server cannot be determined" do
       expect { Split.redis = Object.new }.to raise_error(ArgumentError)
     end
   end

data/spec/support/cookies_mock.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
-class CookiesMock
 
+class CookiesMock
   def initialize
     @cookies = {}
   end
@@ -16,5 +16,4 @@ class CookiesMock
   def delete(key)
     @cookies.delete(key)
   end
-
 end

data/spec/trial_spec.rb

@@ -1,54 +1,55 @@
 # frozen_string_literal: true
-require 'spec_helper'
-require 'split/trial'
+
+require "spec_helper"
+require "split/trial"
 
 describe Split::Trial do
   let(:user) { mock_user }
-  let(:alternatives) { ['basket', 'cart'] }
+  let(:alternatives) { ["basket", "cart"] }
   let(:experiment) do
-    Split::Experiment.new('basket_text', :alternatives => alternatives).save
+    Split::Experiment.new("basket_text", alternatives: alternatives).save
   end
 
   it "should be initializeable" do
-    experiment  = double('experiment')
-    alternative = double('alternative', :kind_of? => Split::Alternative)
-    trial = Split::Trial.new(:experiment => experiment, :alternative => alternative)
+    experiment  = double("experiment")
+    alternative = double("alternative", kind_of?: Split::Alternative)
+    trial = Split::Trial.new(experiment: experiment, alternative: alternative)
     expect(trial.experiment).to eq(experiment)
     expect(trial.alternative).to eq(alternative)
   end
 
   describe "alternative" do
     it "should use the alternative if specified" do
-      alternative = double('alternative', :kind_of? => Split::Alternative)
-      trial = Split::Trial.new(:experiment => double('experiment'),
-          :alternative => alternative, :user => user)
+      alternative = double("alternative", kind_of?: Split::Alternative)
+      trial = Split::Trial.new(experiment: double("experiment"),
+          alternative: alternative, user: user)
       expect(trial).not_to receive(:choose)
       expect(trial.alternative).to eq(alternative)
     end
 
     it "should load the alternative when the alternative name is set" do
-      experiment = Split::Experiment.new('basket_text', :alternatives => ['basket', 'cart'])
+      experiment = Split::Experiment.new("basket_text", alternatives: ["basket", "cart"])
       experiment.save
 
-      trial = Split::Trial.new(:experiment => experiment, :alternative => 'basket')
-      expect(trial.alternative.name).to eq('basket')
+      trial = Split::Trial.new(experiment: experiment, alternative: "basket")
+      expect(trial.alternative.name).to eq("basket")
     end
   end
 
   describe "metadata" do
     let(:metadata) { Hash[alternatives.map { |k| [k, "Metadata for #{k}"] }] }
     let(:experiment) do
-      Split::Experiment.new('basket_text', :alternatives => alternatives, :metadata => metadata).save
+      Split::Experiment.new("basket_text", alternatives: alternatives, metadata: metadata).save
     end
 
-    it 'has metadata on each trial' do
-      trial = Split::Trial.new(:experiment => experiment, :user => user, :metadata => metadata['cart'],
-                               :override => 'cart')
-      expect(trial.metadata).to eq(metadata['cart'])
+    it "has metadata on each trial" do
+      trial = Split::Trial.new(experiment: experiment, user: user, metadata: metadata["cart"],
+                               override: "cart")
+      expect(trial.metadata).to eq(metadata["cart"])
     end
 
-    it 'has metadata on each trial from the experiment' do
-      trial = Split::Trial.new(:experiment => experiment, :user => user)
+    it "has metadata on each trial from the experiment" do
+      trial = Split::Trial.new(experiment: experiment, user: user)
       trial.choose!
       expect(trial.metadata).to eq(metadata[trial.alternative.name])
       expect(trial.metadata).to match(/#{trial.alternative.name}/)
@@ -56,24 +57,24 @@ describe Split::Trial do
   end
 
   describe "#choose!" do
-    let(:context) { double(on_trial_callback: 'test callback') }
+    let(:context) { double(on_trial_callback: "test callback") }
     let(:trial) do
-      Split::Trial.new(:user => user, :experiment => experiment)
+      Split::Trial.new(user: user, experiment: experiment)
     end
 
-    shared_examples_for 'a trial with callbacks' do
-      it 'does not run if on_trial callback is not respondable' do
+    shared_examples_for "a trial with callbacks" do
+      it "does not run if on_trial callback is not respondable" do
         Split.configuration.on_trial = :foo
         allow(context).to receive(:respond_to?).with(:foo, true).and_return false
         expect(context).to_not receive(:foo)
         trial.choose! context
       end
-      it 'runs on_trial callback' do
+      it "runs on_trial callback" do
         Split.configuration.on_trial = :on_trial_callback
         expect(context).to receive(:on_trial_callback)
         trial.choose! context
       end
-      it 'does not run nil on_trial callback' do
+      it "does not run nil on_trial callback" do
         Split.configuration.on_trial = nil
         expect(context).not_to receive(:on_trial_callback)
         trial.choose! context
@@ -88,12 +89,12 @@ describe Split::Trial do
     end
 
     context "when override is present" do
-      let(:override) { 'cart' }
+      let(:override) { "cart" }
       let(:trial) do
-        Split::Trial.new(:user => user, :experiment => experiment, :override => override)
+        Split::Trial.new(user: user, experiment: experiment, override: override)
       end
 
-      it_behaves_like 'a trial with callbacks'
+      it_behaves_like "a trial with callbacks"
 
       it "picks the override" do
         expect(experiment).to_not receive(:next_alternative)
@@ -102,7 +103,7 @@ describe Split::Trial do
 
       context "when alternative doesn't exist" do
         let(:override) { nil }
-        it 'falls back on next_alternative' do
+        it "falls back on next_alternative" do
           expect(experiment).to receive(:next_alternative).and_call_original
           expect_alternative(trial, alternatives)
         end
@@ -111,7 +112,7 @@ describe Split::Trial do
 
     context "when disabled option is true" do
       let(:trial) do
-        Split::Trial.new(:user => user, :experiment => experiment, :disabled => true)
+        Split::Trial.new(user: user, experiment: experiment, disabled: true)
       end
 
       it "picks the control", :aggregate_failures do
@@ -120,7 +121,7 @@ describe Split::Trial do
 
         expect(context).not_to receive(:on_trial_callback)
 
-        expect_alternative(trial, 'basket')
+        expect_alternative(trial, "basket")
         Split.configuration.on_trial = nil
       end
     end
@@ -132,7 +133,7 @@ describe Split::Trial do
 
         expect(experiment).to_not receive(:next_alternative)
         expect(context).not_to receive(:on_trial_callback)
-        expect_alternative(trial, 'basket')
+        expect_alternative(trial, "basket")
 
         Split.configuration.enabled = true
         Split.configuration.on_trial = nil
@@ -141,40 +142,48 @@ describe Split::Trial do
 
     context "when experiment has winner" do
       let(:trial) do
-        Split::Trial.new(:user => user, :experiment => experiment)
+        Split::Trial.new(user: user, experiment: experiment)
       end
 
-      it_behaves_like 'a trial with callbacks'
+      it_behaves_like "a trial with callbacks"
 
       it "picks the winner" do
-        experiment.winner = 'cart'
+        experiment.winner = "cart"
         expect(experiment).to_not receive(:next_alternative)
 
-        expect_alternative(trial, 'cart')
+        expect_alternative(trial, "cart")
       end
     end
 
     context "when exclude is true" do
       let(:trial) do
-        Split::Trial.new(:user => user, :experiment => experiment, :exclude => true)
+        Split::Trial.new(user: user, experiment: experiment, exclude: true)
       end
 
-      it_behaves_like 'a trial with callbacks'
+      it_behaves_like "a trial with callbacks"
 
       it "picks the control" do
         expect(experiment).to_not receive(:next_alternative)
-        expect_alternative(trial, 'basket')
+        expect_alternative(trial, "basket")
       end
     end
 
     context "when user is already participating" do
-      it_behaves_like 'a trial with callbacks'
+      it_behaves_like "a trial with callbacks"
 
       it "picks the same alternative" do
-        user[experiment.key] = 'basket'
+        user[experiment.key] = "basket"
         expect(experiment).to_not receive(:next_alternative)
 
-        expect_alternative(trial, 'basket')
+        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
 
@@ -190,42 +199,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
-      it 'should complete the trial' do
+    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'] }
-      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
+    context "when there are many goals" do
+      let(:goals) { [ "goal1", "goal2" ] }
+      let(:trial) { Split::Trial.new(user: user, experiment: experiment, goals: goals) }
 
-      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
 
@@ -234,7 +269,7 @@ describe Split::Trial do
 
     context "when override is present" do
       it "stores when store_override is true" do
-        trial = Split::Trial.new(:user => user, :experiment => experiment, :override => 'basket')
+        trial = Split::Trial.new(user: user, experiment: experiment, override: "basket")
 
         Split.configuration.store_override = true
         expect(user).to receive("[]=")
@@ -243,7 +278,7 @@ describe Split::Trial do
       end
 
       it "does not store when store_override is false" do
-        trial = Split::Trial.new(:user => user, :experiment => experiment, :override => 'basket')
+        trial = Split::Trial.new(user: user, experiment: experiment, override: "basket")
 
         expect(user).to_not receive("[]=")
         trial.choose!
@@ -252,7 +287,7 @@ describe Split::Trial do
 
     context "when disabled is present" do
       it "stores when store_override is true" do
-        trial = Split::Trial.new(:user => user, :experiment => experiment, :disabled => true)
+        trial = Split::Trial.new(user: user, experiment: experiment, disabled: true)
 
         Split.configuration.store_override = true
         expect(user).to receive("[]=")
@@ -260,7 +295,7 @@ describe Split::Trial do
       end
 
       it "does not store when store_override is false" do
-        trial = Split::Trial.new(:user => user, :experiment => experiment, :disabled => true)
+        trial = Split::Trial.new(user: user, experiment: experiment, disabled: true)
 
         expect(user).to_not receive("[]=")
         trial.choose!
@@ -269,8 +304,20 @@ describe Split::Trial do
 
     context "when exclude is present" do
       it "does not store" do
-        trial = Split::Trial.new(:user => user, :experiment => experiment, :exclude => true)
+        trial = Split::Trial.new(user: user, experiment: experiment, exclude: true)
+
+        expect(user).to_not receive("[]=")
+        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