split 4.0.0.pre2 → 4.0.2

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,24 +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}]]}})
+    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
-      old_redis_url = ENV['REDIS_URL']
-      ENV.delete('REDIS_URL')
+      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
+      ENV["REDIS_URL"] = old_redis_url
     end
 
     it "should allow for redis url to be configured" do
@@ -227,10 +222,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"
+        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
+        ENV["REDIS_URL"] = old_redis_url
       end
     end
   end
@@ -252,9 +247,8 @@ describe Split::Configuration do
     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')
+      @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

@@ -1,108 +1,110 @@
-require 'spec_helper'
-require 'split/dashboard/pagination_helpers'
+# frozen_string_literal: true
+
+require "spec_helper"
+require "split/dashboard/pagination_helpers"
 
 describe Split::DashboardPaginationHelpers do
   include Split::DashboardPaginationHelpers
 
-  let(:url) { '/split/' }
+  let(:url) { "/split/" }
 
-  describe '#pagination_per' do
-    context 'when params empty' do
+  describe "#pagination_per" do
+    context "when params empty" do
       let(:params) { Hash[] }
 
-      it 'returns the default (10)' do
+      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
+    context "when params[:per] is 5" do
       let(:params) { Hash[per: 5] }
 
-      it 'returns 5' do
+      it "returns 5" do
         expect(pagination_per).to eql 5
       end
     end
   end
 
-  describe '#page_number' do
-    context 'when params empty' do
+  describe "#page_number" do
+    context "when params empty" do
       let(:params) { Hash[] }
 
-      it 'returns 1' do
+      it "returns 1" do
         expect(page_number).to eql 1
       end
     end
 
     context 'when params[:page] is "2"' do
-      let(:params) { Hash[page: '2'] }
+      let(:params) { Hash[page: "2"] }
 
-      it 'returns 2' do
+      it "returns 2" do
         expect(page_number).to eql 2
       end
     end
   end
 
-  describe '#paginated' do
+  describe "#paginated" do
     let(:collection) { (1..20).to_a }
-    let(:params) { Hash[per: '5', page: '3'] }
+    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
+  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'] }
+    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
+  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
+  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'] }
+    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>' }
+  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
+  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'] }
+    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'] }
+  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'] }
+    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>'
@@ -110,90 +112,90 @@ describe Split::DashboardPaginationHelpers do
     end
   end
 
-  describe '#show_prev_page_tag?' do
-    context 'when page is 1' do
+  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'] }
+    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>' }
+  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>' }
+    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'] }
+  describe "#show_next_page_tag?" do
+    context "when page is 2" do
+      let(:params) { Hash[page: "2"] }
 
-      context 'when collection length is 20' do
+      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
+      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'] }
+  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'] }
+    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
+  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
+    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
+  describe "#show_last_ellipsis_tag?" do
     let(:collection) { (1..30).to_a }
-    let(:params) { Hash[per: '5', page: '2'] }
+    let(:params) { Hash[per: "5", page: "2"] }
     it { expect(show_last_ellipsis_tag?(collection)).to be true }
   end
 
-  describe '#show_last_page_tag?' do
+  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'] }
+    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'] }
+    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
+  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

data/spec/dashboard/paginator_spec.rb

@@ -1,34 +1,35 @@
 # frozen_string_literal: true
-require 'spec_helper'
-require 'split/dashboard/paginator'
+
+require "spec_helper"
+require "split/dashboard/paginator"
 
 describe Split::DashboardPaginator do
-  context 'when collection is 1..20' do
+  context "when collection is 1..20" do
     let(:collection) { (1..20).to_a }
 
-    context 'when per 5 for page' do
+    context "when per 5 for page" do
       let(:per) { 5 }
 
-      it 'when page number is 1 result is [1, 2, 3, 4, 5]' do
+      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
+      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
+    context "when per 10 for page" do
       let(:per) { 10 }
 
-      it 'when page number is 1 result is [1..10]' do
+      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
+      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

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('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('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