split 3.0.0 → 3.4.0

data/lib/split/persistence/dual_adapter.rb

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
-require 'forwardable'
-
 module Split
   module Persistence
     class DualAdapter
-      extend Forwardable
-      def_delegators :@adapter, :keys, :[], :[]=, :delete
+      def self.with_config(options={})
+        self.config.merge!(options)
+        self
+      end
+
+      def self.config
+        @config ||= {}
+      end
 
       def initialize(context)
         if logged_in = self.class.config[:logged_in]
@@ -22,22 +26,60 @@ module Split
           raise "Please configure :logged_out_adapter"
         end
 
-        if logged_in.call(context)
-          @adapter = logged_in_adapter.new(context)
+        @fallback_to_logged_out_adapter =
+          self.class.config[:fallback_to_logged_out_adapter] || false
+        @logged_in = logged_in.call(context)
+        @logged_in_adapter = logged_in_adapter.new(context)
+        @logged_out_adapter = logged_out_adapter.new(context)
+        @active_adapter = @logged_in ? @logged_in_adapter : @logged_out_adapter
+      end
+
+      def keys
+        if @fallback_to_logged_out_adapter
+          (@logged_in_adapter.keys + @logged_out_adapter.keys).uniq
         else
-          @adapter = logged_out_adapter.new(context)
+          @active_adapter.keys
         end
       end
 
-      def self.with_config(options={})
-        self.config.merge!(options)
-        self
+      def [](key)
+        if @fallback_to_logged_out_adapter
+          @logged_in && @logged_in_adapter[key] || @logged_out_adapter[key]
+        else
+          @active_adapter[key]
+        end
       end
 
-      def self.config
-        @config ||= {}
+      def []=(key, value)
+        if @fallback_to_logged_out_adapter
+          @logged_in_adapter[key] = value if @logged_in
+          old_value = @logged_out_adapter[key]
+          @logged_out_adapter[key] = value
+
+          decrement_participation(key, old_value) if decrement_participation?(old_value, value)
+        else
+          @active_adapter[key] = value
+        end
+      end
+
+      def delete(key)
+        if @fallback_to_logged_out_adapter
+          @logged_in_adapter.delete(key)
+          @logged_out_adapter.delete(key)
+        else
+          @active_adapter.delete(key)
+        end
       end
 
+      private
+
+      def decrement_participation?(old_value, value)
+        !old_value.nil? && !value.nil? && old_value != value
+      end
+
+      def decrement_participation(key, value)
+        Split.redis.hincrby("#{key}:#{value}", 'participant_count', -1)
+      end
     end
   end
 end

data/lib/split/redis_interface.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Split
   # Simplifies the interface to Redis.
   class RedisInterface
@@ -35,9 +36,7 @@ module Split
     end
 
     def make_list_length(list_name, new_length)
-      while list_length(list_name) > new_length
-        remove_last_item_from_list(list_name)
-      end
+      redis.ltrim(list_name, 0, new_length - 1)
     end
 
     def add_to_set(set_name, value)

data/lib/split/trial.rb

@@ -2,7 +2,7 @@
 module Split
   class Trial
     attr_accessor :experiment
-    attr_accessor :metadata
+    attr_writer :metadata
 
     def initialize(attrs = {})
       self.experiment   = attrs.delete(:experiment)
@@ -68,10 +68,8 @@ module Split
         if exclude_user?
           self.alternative = @experiment.control
         else
-          value = @user[@experiment.key]
-          if value
-            self.alternative = value
-          else
+          self.alternative = @user[@experiment.key]
+          if alternative.nil?
             self.alternative = @experiment.next_alternative
 
             # Increment the number of participants since we are actually choosing a new alternative
@@ -82,7 +80,7 @@ module Split
         end
       end
 
-      @user[@experiment.key] = alternative.name if should_store_alternative?
+      @user[@experiment.key] = alternative.name if !@experiment.has_winner? && should_store_alternative?
       @alternative_choosen = true
       run_callback context, Split.configuration.on_trial unless @options[:disabled] || Split.configuration.disabled?
       alternative

data/lib/split/user.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'forwardable'
 
 module Split
@@ -8,9 +9,11 @@ module Split
 
     def initialize(context, adapter=nil)
       @user = adapter || Split::Persistence.adapter.new(context)
+      @cleaned_up = false
     end
 
     def cleanup_old_experiments!
+      return if @cleaned_up
       keys_without_finished(user.keys).each do |key|
         experiment = ExperimentCatalog.find key_without_version(key)
         if experiment.nil? || experiment.has_winner? || experiment.start_time.nil?
@@ -18,6 +21,7 @@ module Split
           user.delete Experiment.finished_key(key)
         end
       end
+      @cleaned_up = true
     end
 
     def max_experiments_reached?(experiment_key)
@@ -38,7 +42,7 @@ module Split
 
     def active_experiments
       experiment_pairs = {}
-      user.keys.each do |key|
+      keys_without_finished(user.keys).each do |key|
         Metric.possible_experiments(key_without_version(key)).each do |experiment|
           if !experiment.has_winner?
             experiment_pairs[key_without_version(key)] = user[key]

data/lib/split/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 module Split
   MAJOR   = 3
-  MINOR   = 0
+  MINOR   = 4
   PATCH   = 0
   VERSION = [MAJOR, MINOR, PATCH].join('.')
 end

data/lib/split.rb

@@ -13,6 +13,7 @@ require 'split/experiment_catalog'
 require 'split/extensions/string'
 require 'split/goals_collection'
 require 'split/helper'
+require 'split/combined_experiments_helper'
 require 'split/metric'
 require 'split/persistence'
 require 'split/redis_interface'
@@ -65,4 +66,11 @@ module Split
   end
 end
 
-Split.configure {}
+# 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
+    config.before_initialize { Split.configure {} }
+  end
+else
+  Split.configure {}
+end

data/spec/alternative_spec.rb

@@ -273,6 +273,18 @@ describe Split::Alternative do
       expect(control.z_score(goal1)).to eq('N/A')
       expect(control.z_score(goal2)).to eq('N/A')
     end
+
+    it "should not blow up for Conversion Rates > 1" do
+      control = experiment.control
+      control.participant_count = 3474
+      control.set_completed_count(4244)
+
+      alternative2.participant_count = 3434
+      alternative2.set_completed_count(4358)
+
+      expect { control.z_score }.not_to raise_error
+      expect { alternative2.z_score }.not_to raise_error
+    end
   end
 
   describe "extra_info" do

data/spec/combined_experiments_helper_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+require 'spec_helper'
+require 'split/combined_experiments_helper'
+
+describe Split::CombinedExperimentsHelper do
+  include Split::CombinedExperimentsHelper
+
+  describe 'ab_combined_test' do
+    let!(:config_enabled) { true }
+    let!(:combined_experiments) { [:exp_1_click, :exp_1_scroll ]}
+    let!(:allow_multiple_experiments) { true }
+
+    before do
+      Split.configuration.experiments = {
+        :combined_exp_1 => {
+          :alternatives => [ {"control"=> 0.5}, {"test-alt"=> 0.5} ],
+          :metric => :my_metric,
+          :combined_experiments => combined_experiments
+        }
+      }
+      Split.configuration.enabled = config_enabled
+      Split.configuration.allow_multiple_experiments = allow_multiple_experiments
+    end
+
+    context 'without config enabled' do
+      let!(:config_enabled) { false }
+
+      it "raises an error" do
+        expect(lambda { ab_combined_test :combined_exp_1 }).to raise_error(Split::InvalidExperimentsFormatError )
+      end
+    end
+
+    context 'multiple experiments disabled' do
+      let!(:allow_multiple_experiments) { false }
+
+      it "raises an error if multiple experiments is disabled" do
+        expect(lambda { ab_combined_test :combined_exp_1 }).to raise_error(Split::InvalidExperimentsFormatError)
+      end
+    end
+
+    context 'without combined experiments' do
+      let!(:combined_experiments) { nil }
+
+      it "raises an error" do
+        expect(lambda { ab_combined_test :combined_exp_1 }).to raise_error(Split::InvalidExperimentsFormatError )
+      end
+    end
+
+    it "uses same alternative for all sub experiments and returns the alternative" do
+      allow(self).to receive(:get_alternative) { "test-alt" }
+      expect(self).to receive(:ab_test).with(:exp_1_click, {"control"=>0.5}, {"test-alt"=>0.5}) { "test-alt" }
+      expect(self).to receive(:ab_test).with(:exp_1_scroll, [{"control" => 0, "test-alt" => 1}])
+
+      expect(ab_combined_test('combined_exp_1')).to eq('test-alt')
+    end
+  end
+end

data/spec/dashboard/pagination_helpers_spec.rb

@@ -0,0 +1,200 @@
+require 'spec_helper'
+require 'split/dashboard/pagination_helpers'
+
+describe Split::DashboardPaginationHelpers do
+  include Split::DashboardPaginationHelpers
+
+  let(:url) { '/split/' }
+
+  describe '#pagination_per' do
+    context 'when params empty' do
+      let(:params) { Hash[] }
+
+      it 'returns the default (10)' do
+        default_per_page = Split.configuration.dashboard_pagination_default_per_page
+        expect(pagination_per).to eql default_per_page
+        expect(pagination_per).to eql 10
+      end
+    end
+
+    context 'when params[:per] is 5' do
+      let(:params) { Hash[per: 5] }
+
+      it 'returns 5' do
+        expect(pagination_per).to eql 5
+      end
+    end
+  end
+
+  describe '#page_number' do
+    context 'when params empty' do
+      let(:params) { Hash[] }
+
+      it 'returns 1' do
+        expect(page_number).to eql 1
+      end
+    end
+
+    context 'when params[:page] is "2"' do
+      let(:params) { Hash[page: '2'] }
+
+      it 'returns 2' do
+        expect(page_number).to eql 2
+      end
+    end
+  end
+
+  describe '#paginated' do
+    let(:collection) { (1..20).to_a }
+    let(:params) { Hash[per: '5', page: '3'] }
+
+    it { expect(paginated(collection)).to eql [11, 12, 13, 14, 15] }
+  end
+
+  describe '#show_first_page_tag?' do
+    context 'when page is 1' do
+      it { expect(show_first_page_tag?).to be false }
+    end
+
+    context 'when page is 3' do
+      let(:params) { Hash[page: '3'] }
+      it { expect(show_first_page_tag?).to be true }
+    end
+  end
+
+  describe '#first_page_tag' do
+    it { expect(first_page_tag).to eql '<a href="/split?page=1&per=10">1</a>' }
+  end
+
+  describe '#show_first_ellipsis_tag?' do
+    context 'when page is 1' do
+      it { expect(show_first_ellipsis_tag?).to be false }
+    end
+
+    context 'when page is 4' do
+      let(:params) { Hash[page: '4'] }
+      it { expect(show_first_ellipsis_tag?).to be true }
+    end
+  end
+
+  describe '#ellipsis_tag' do
+    it { expect(ellipsis_tag).to eql '<span>...</span>' }
+  end
+
+  describe '#show_prev_page_tag?' do
+    context 'when page is 1' do
+      it { expect(show_prev_page_tag?).to be false }
+    end
+
+    context 'when page is 2' do
+      let(:params) { Hash[page: '2'] }
+      it { expect(show_prev_page_tag?).to be true }
+    end
+  end
+
+  describe '#prev_page_tag' do
+    context 'when page is 2' do
+      let(:params) { Hash[page: '2'] }
+
+      it do
+        expect(prev_page_tag).to eql '<a href="/split?page=1&per=10">1</a>'
+      end
+    end
+
+    context 'when page is 3' do
+      let(:params) { Hash[page: '3'] }
+
+      it do
+        expect(prev_page_tag).to eql '<a href="/split?page=2&per=10">2</a>'
+      end
+    end
+  end
+
+  describe '#show_prev_page_tag?' do
+    context 'when page is 1' do
+      it { expect(show_prev_page_tag?).to be false }
+    end
+
+    context 'when page is 2' do
+      let(:params) { Hash[page: '2'] }
+      it { expect(show_prev_page_tag?).to be true }
+    end
+  end
+
+  describe '#current_page_tag' do
+    context 'when page is 1' do
+      let(:params) { Hash[page: '1'] }
+      it { expect(current_page_tag).to eql '<span><b>1</b></span>' }
+    end
+
+    context 'when page is 2' do
+      let(:params) { Hash[page: '2'] }
+      it { expect(current_page_tag).to eql '<span><b>2</b></span>' }
+    end
+  end
+
+  describe '#show_next_page_tag?' do
+    context 'when page is 2' do
+      let(:params) { Hash[page: '2'] }
+
+      context 'when collection length is 20' do
+        let(:collection) { (1..20).to_a }
+        it { expect(show_next_page_tag?(collection)).to be false }
+      end
+
+      context 'when collection length is 25' do
+        let(:collection) { (1..25).to_a }
+        it { expect(show_next_page_tag?(collection)).to be true }
+      end
+    end
+  end
+
+  describe '#next_page_tag' do
+    context 'when page is 1' do
+      let(:params) { Hash[page: '1'] }
+      it { expect(next_page_tag).to eql '<a href="/split?page=2&per=10">2</a>' }
+    end
+
+    context 'when page is 2' do
+      let(:params) { Hash[page: '2'] }
+      it { expect(next_page_tag).to eql '<a href="/split?page=3&per=10">3</a>' }
+    end
+  end
+
+  describe '#total_pages' do
+    context 'when collection length is 30' do
+      let(:collection) { (1..30).to_a }
+      it { expect(total_pages(collection)).to eql 3 }
+    end
+
+    context 'when collection length is 35' do
+      let(:collection) { (1..35).to_a }
+      it { expect(total_pages(collection)).to eql 4 }
+    end
+  end
+
+  describe '#show_last_ellipsis_tag?' do
+    let(:collection) { (1..30).to_a }
+    let(:params) { Hash[per: '5', page: '2'] }
+    it { expect(show_last_ellipsis_tag?(collection)).to be true }
+  end
+
+  describe '#show_last_page_tag?' do
+    let(:collection) { (1..30).to_a }
+
+    context 'when page is 5/6' do
+      let(:params) { Hash[per: '5', page: '5'] }
+      it { expect(show_last_page_tag?(collection)).to be false }
+    end
+
+    context 'when page is 4/6' do
+      let(:params) { Hash[per: '5', page: '4'] }
+      it { expect(show_last_page_tag?(collection)).to be true }
+    end
+  end
+
+  describe '#last_page_tag' do
+    let(:collection) { (1..30).to_a }
+    it { expect(last_page_tag(collection)).to eql '<a href="/split?page=3&per=10">3</a>' }
+  end
+end

data/spec/dashboard/paginator_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+require 'spec_helper'
+require 'split/dashboard/paginator'
+
+describe Split::DashboardPaginator do
+  context 'when collection is 1..20' do
+    let(:collection) { (1..20).to_a }
+
+    context 'when per 5 for page' do
+      let(:per) { 5 }
+
+      it 'when page number is 1 result is [1, 2, 3, 4, 5]' do
+        result = Split::DashboardPaginator.new(collection, 1, per).paginate
+        expect(result).to eql [1, 2, 3, 4, 5]
+      end
+
+      it 'when page number is 2 result is [6, 7, 8, 9, 10]' do
+        result = Split::DashboardPaginator.new(collection, 2, per).paginate
+        expect(result).to eql [6, 7, 8, 9, 10]
+      end
+    end
+
+    context 'when per 10 for page' do
+      let(:per) { 10 }
+
+      it 'when page number is 1 result is [1..10]' do
+        result = Split::DashboardPaginator.new(collection, 1, per).paginate
+        expect(result).to eql [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+      end
+
+      it 'when page number is 2 result is [10..20]' do
+        result = Split::DashboardPaginator.new(collection, 2, per).paginate
+        expect(result).to eql [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
+      end
+    end
+  end
+end

data/spec/dashboard_helpers_spec.rb

@@ -27,11 +27,11 @@ describe Split::DashboardHelpers do
 
     describe '#round' do
       it 'can round number strings' do
-        expect(round('3.1415')).to eq BigDecimal.new('3.14')
+        expect(round('3.1415')).to eq BigDecimal('3.14')
       end
 
       it 'can round number strings for precsion' do
-        expect(round('3.1415', 1)).to eq BigDecimal.new('3.1')
+        expect(round('3.1415', 1)).to eq BigDecimal('3.1')
       end
 
       it 'can handle invalid number strings' do

data/spec/dashboard_spec.rb

@@ -29,6 +29,10 @@ describe Split::Dashboard do
   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 '/'
     expect(last_response).to be_ok
@@ -74,17 +78,39 @@ describe Split::Dashboard do
   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"
+        expect(user[experiment.key]).to eq("blue")
+        expect(blue_link.participant_count).to eq(8)
+      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"
+        expect(user[experiment.key]).to eq("blue")
+        expect(blue_link.participant_count).to eq(8)
+      end
     end
   end
 
@@ -120,7 +146,7 @@ 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
@@ -167,19 +193,14 @@ describe Split::Dashboard do
   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 '/'
 
-    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 '/'

data/spec/encapsulated_helper_spec.rb

@@ -33,7 +33,7 @@ describe Split::EncapsulatedHelper do
             static <%= alt %>
           <% end %>
         ERB
-        expect(template.result(binding)).to match /foo  static \d/
+        expect(template.result(binding)).to match(/foo  static \d/)
       end
 
     end