split 3.2.0 → 4.0.5

data/spec/cache_spec.rb

@@ -0,0 +1,84 @@
+# 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/combined_experiments_helper_spec.rb

@@ -1,57 +1,58 @@
 # frozen_string_literal: true
-require 'spec_helper'
-require 'split/combined_experiments_helper'
+
+require "spec_helper"
+require "split/combined_experiments_helper"
 
 describe Split::CombinedExperimentsHelper do
   include Split::CombinedExperimentsHelper
 
-  describe 'ab_combined_test' do
+  describe "ab_combined_test" do
     let!(:config_enabled) { true }
-    let!(:combined_experiments) { [:exp_1_click, :exp_1_scroll ]}
+    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
+        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
+    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 )
+        expect { ab_combined_test :combined_exp_1 }.to raise_error(Split::InvalidExperimentsFormatError)
       end
     end
 
-    context 'multiple experiments disabled' do
+    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)
+        expect { ab_combined_test :combined_exp_1 }.to raise_error(Split::InvalidExperimentsFormatError)
       end
     end
 
-    context 'without combined experiments' do
+    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 )
+        expect { 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(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')
+      expect(ab_combined_test("combined_exp_1")).to eq("test-alt")
     end
   end
 end

data/spec/configuration_spec.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
-require 'spec_helper'
 
-describe Split::Configuration do
+require "spec_helper"
 
+describe Split::Configuration do
   before(:each) { @config = Split::Configuration.new }
 
   it "should provide a default value for ignore_ip_addresses" do
@@ -58,17 +58,15 @@ describe Split::Configuration do
   end
 
   it "should load a metric" do
-    @config.experiments = {:my_experiment=>
-        {:alternatives=>["control_opt", "other_opt"], :metric=>:my_metric}}
+    @config.experiments = { my_experiment: { alternatives: ["control_opt", "other_opt"], metric: :my_metric } }
 
     expect(@config.metrics).not_to be_nil
     expect(@config.metrics.keys).to eq([:my_metric])
   end
 
   it "should allow loading of experiment using experment_for" do
-    @config.experiments = {:my_experiment=>
-        {:alternatives=>["control_opt", "other_opt"], :metric=>:my_metric}}
-    expect(@config.experiment_for(:my_experiment)).to eq({:alternatives=>["control_opt", ["other_opt"]]})
+    @config.experiments = { my_experiment: { alternatives: ["control_opt", "other_opt"], metric: :my_metric } }
+    expect(@config.experiment_for(:my_experiment)).to eq({ alternatives: ["control_opt", ["other_opt"]] })
   end
 
   context "when experiments are defined via YAML" do
@@ -82,12 +80,12 @@ describe Split::Configuration do
                 - Alt One
                 - Alt Two
               resettable: false
-            eos
+          eos
           @config.experiments = YAML.load(experiments_yaml)
         end
 
-        it 'should normalize experiments' do
-          expect(@config.normalized_experiments).to eq({:my_experiment=>{:resettable=>false,:alternatives=>["Control Opt", ["Alt One", "Alt Two"]]}})
+        it "should normalize experiments" do
+          expect(@config.normalized_experiments).to eq({ my_experiment: { resettable: false, alternatives: ["Control Opt", ["Alt One", "Alt Two"]] } })
         end
       end
 
@@ -110,14 +108,14 @@ describe Split::Configuration do
                 Alt Two:
                   text: 'Alternative Two'
               resettable: false
-            eos
+          eos
           @config.experiments = YAML.load(experiments_yaml)
         end
 
-        it 'should have metadata on the experiment' do
+        it "should have metadata on the experiment" do
           meta = @config.normalized_experiments[:my_experiment][:metadata]
           expect(meta).to_not be nil
-          expect(meta['Control Opt']['text']).to eq('Control Option')
+          expect(meta["Control Opt"]["text"]).to eq("Control Option")
         end
       end
 
@@ -138,25 +136,23 @@ describe Split::Configuration do
               alternatives:
                 - a
                 - b
-            eos
+          eos
           @config.experiments = YAML.load(experiments_yaml)
         end
 
         it "should normalize experiments" do
-          expect(@config.normalized_experiments).to eq({:my_experiment=>{:resettable=>false,:alternatives=>[{"Control Opt"=>0.67},
-            [{"Alt One"=>0.1}, {"Alt Two"=>0.23}]]}, :another_experiment=>{:alternatives=>["a", ["b"]]}})
+          expect(@config.normalized_experiments).to eq({ my_experiment: { resettable: false, alternatives: [{ "Control Opt"=>0.67 },
+            [{ "Alt One"=>0.1 }, { "Alt Two"=>0.23 }]] }, another_experiment: { alternatives: ["a", ["b"]] } })
         end
 
         it "should recognize metrics" do
           expect(@config.metrics).not_to be_nil
           expect(@config.metrics.keys).to eq([:my_metric])
         end
-
       end
     end
 
     context "as symbols" do
-
       context "with valid YAML" do
         before do
           experiments_yaml = <<-eos
@@ -166,21 +162,20 @@ describe Split::Configuration do
                 - Alt One
                 - Alt Two
               :resettable: false
-            eos
+          eos
           @config.experiments = YAML.load(experiments_yaml)
         end
 
         it "should normalize experiments" do
-          expect(@config.normalized_experiments).to eq({:my_experiment=>{:resettable=>false,:alternatives=>["Control Opt", ["Alt One", "Alt Two"]]}})
+          expect(@config.normalized_experiments).to eq({ my_experiment: { resettable: false, alternatives: ["Control Opt", ["Alt One", "Alt Two"]] } })
         end
       end
 
       context "with invalid YAML" do
-
         let(:yaml) { YAML.load(input) }
 
         context "with an empty string" do
-          let(:input) { '' }
+          let(:input) { "" }
 
           it "should raise an error" do
             expect { @config.experiments = yaml }.to raise_error(Split::InvalidExperimentsFormatError)
@@ -188,7 +183,7 @@ describe Split::Configuration do
         end
 
         context "with just the YAML header" do
-          let(:input) { '---' }
+          let(:input) { "---" }
 
           it "should raise an error" do
             expect { @config.experiments = yaml }.to raise_error(Split::InvalidExperimentsFormatError)
@@ -200,35 +195,24 @@ describe Split::Configuration do
 
   it "should normalize experiments" do
     @config.experiments = {
-      :my_experiment => {
-        :alternatives => [
-          { :name => "control_opt", :percent => 67 },
-          { :name => "second_opt", :percent => 10 },
-          { :name => "third_opt", :percent => 23 },
+      my_experiment: {
+        alternatives: [
+          { name: "control_opt", percent: 67 },
+          { name: "second_opt", percent: 10 },
+          { name: "third_opt", percent: 23 },
         ],
       }
     }
 
-    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
+    expect(@config.normalized_experiments).to eq({ my_experiment: { alternatives: [{ "control_opt"=>0.67 }, [{ "second_opt"=>0.1 }, { "third_opt"=>0.23 }]] } })
   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 +222,10 @@ describe Split::Configuration do
 
     context "provided REDIS_URL environment variable" do
       it "should use the ENV variable" do
-        ENV['REDIS_URL'] = "env_redis_url"
+        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 +241,14 @@ 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/pagination_helpers_spec.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+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,38 @@
+# 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

@@ -1,41 +1,42 @@
 # frozen_string_literal: true
-require 'spec_helper'
-require 'split/dashboard/helpers'
+
+require "spec_helper"
+require "split/dashboard/helpers"
 
 include Split::DashboardHelpers
 
 describe Split::DashboardHelpers do
-  describe 'confidence_level' do
-    it 'should handle very small numbers' do
-      expect(confidence_level(Complex(2e-18, -0.03))).to eq('Insufficient confidence')
+  describe "confidence_level" do
+    it "should handle very small numbers" do
+      expect(confidence_level(Complex(2e-18, -0.03))).to eq("Insufficient confidence")
     end
 
     it "should consider a z-score of 1.65 <= z < 1.96 as 90% confident" do
-      expect(confidence_level(1.65)).to eq('90% confidence')
-      expect(confidence_level(1.80)).to eq('90% confidence')
+      expect(confidence_level(1.65)).to eq("90% confidence")
+      expect(confidence_level(1.80)).to eq("90% confidence")
     end
 
     it "should consider a z-score of 1.96 <= z < 2.58 as 95% confident" do
-      expect(confidence_level(1.96)).to eq('95% confidence')
-      expect(confidence_level(2.00)).to eq('95% confidence')
+      expect(confidence_level(1.96)).to eq("95% confidence")
+      expect(confidence_level(2.00)).to eq("95% confidence")
     end
 
     it "should consider a z-score of z >= 2.58 as 99% confident" do
-      expect(confidence_level(2.58)).to eq('99% confidence')
-      expect(confidence_level(3.00)).to eq('99% confidence')
+      expect(confidence_level(2.58)).to eq("99% confidence")
+      expect(confidence_level(3.00)).to eq("99% confidence")
     end
 
-    describe '#round' do
-      it 'can round number strings' do
-        expect(round('3.1415')).to eq BigDecimal.new('3.14')
+    describe "#round" do
+      it "can round number strings" do
+        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')
+      it "can round number strings for precsion" do
+        expect(round("3.1415", 1)).to eq BigDecimal("3.1")
       end
 
-      it 'can handle invalid number strings' do
-        expect(round('N/A')).to be_zero
+      it "can handle invalid number strings" do
+        expect(round("N/A")).to be_zero
       end
     end
   end