split 4.0.1 → 4.0.3

data/spec/alternative_spec.rb

@@ -1,19 +1,19 @@
 # frozen_string_literal: true
-require 'spec_helper'
-require 'split/alternative'
 
-describe Split::Alternative do
+require "spec_helper"
+require "split/alternative"
 
+describe Split::Alternative do
   let(:alternative) {
-    Split::Alternative.new('Basket', 'basket_text')
+    Split::Alternative.new("Basket", "basket_text")
   }
 
   let(:alternative2) {
-    Split::Alternative.new('Cart', 'basket_text')
+    Split::Alternative.new("Cart", "basket_text")
   }
 
   let!(:experiment) {
-    Split::ExperimentCatalog.find_or_create({"basket_text" => ["purchase", "refund"]}, "Basket", "Cart")
+    Split::ExperimentCatalog.find_or_create({ "basket_text" => ["purchase", "refund"] }, "Basket", "Cart")
   }
 
   let(:goal1) { "purchase" }
@@ -24,48 +24,48 @@ describe Split::Alternative do
   end
 
   it "should have and only return the name" do
-    expect(alternative.name).to eq('Basket')
+    expect(alternative.name).to eq("Basket")
   end
 
-  describe 'weights' do
+  describe "weights" do
     it "should set the weights" do
-      experiment = Split::Experiment.new('basket_text', :alternatives => [{'Basket' => 0.6}, {"Cart" => 0.4}])
+      experiment = Split::Experiment.new("basket_text", alternatives: [{ "Basket" => 0.6 }, { "Cart" => 0.4 }])
       first = experiment.alternatives[0]
-      expect(first.name).to eq('Basket')
+      expect(first.name).to eq("Basket")
       expect(first.weight).to eq(0.6)
 
       second = experiment.alternatives[1]
-      expect(second.name).to eq('Cart')
+      expect(second.name).to eq("Cart")
       expect(second.weight).to eq(0.4)
     end
 
     it "accepts probability on alternatives" do
       Split.configuration.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 },
           ]
         }
       }
       experiment = Split::Experiment.new(:my_experiment)
       first = experiment.alternatives[0]
-      expect(first.name).to eq('control_opt')
+      expect(first.name).to eq("control_opt")
       expect(first.weight).to eq(0.67)
 
       second = experiment.alternatives[1]
-      expect(second.name).to eq('second_opt')
+      expect(second.name).to eq("second_opt")
       expect(second.weight).to eq(0.1)
     end
 
     it "accepts probability on some alternatives" do
       Split.configuration.experiments = {
-        :my_experiment => {
-          :alternatives => [
-            { :name => "control_opt", :percent => 34 },
+        my_experiment: {
+          alternatives: [
+            { name: "control_opt", percent: 34 },
             "second_opt",
-            { :name => "third_opt", :percent => 23 },
+            { name: "third_opt", percent: 23 },
             "fourth_opt",
           ],
         }
@@ -87,11 +87,11 @@ describe Split::Alternative do
     #
     it "allows name param without probability" do
       Split.configuration.experiments = {
-        :my_experiment => {
-          :alternatives => [
-            { :name => "control_opt" },
+        my_experiment: {
+          alternatives: [
+            { name: "control_opt" },
             "second_opt",
-            { :name => "third_opt", :percent => 64 },
+            { name: "third_opt", percent: 64 },
           ],
         }
       }
@@ -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
@@ -166,7 +166,7 @@ describe Split::Alternative do
     expect(alternative2.control?).to be_falsey
   end
 
-  describe 'unfinished_count' do
+  describe "unfinished_count" do
     it "should be difference between participant and completed counts" do
       alternative.increment_participation
       expect(alternative.unfinished_count).to eq(alternative.participant_count)
@@ -182,7 +182,7 @@ describe Split::Alternative do
     end
   end
 
-  describe 'conversion rate' do
+  describe "conversion rate" do
     it "should be 0 if there are no conversions" do
       expect(alternative.completed_count).to eq(0)
       expect(alternative.conversion_rate).to eq(0)
@@ -225,8 +225,7 @@ describe Split::Alternative do
     end
   end
 
-  describe 'z score' do
-
+  describe "z score" do
     it "should return an error string when the control has 0 people" do
       expect(alternative2.z_score).to eq("Needs 30+ participants.")
       expect(alternative2.z_score(goal1)).to eq("Needs 30+ participants.")
@@ -269,9 +268,9 @@ describe Split::Alternative do
 
     it "should be N/A for the control" do
       control = experiment.control
-      expect(control.z_score).to eq('N/A')
-      expect(control.z_score(goal1)).to eq('N/A')
-      expect(control.z_score(goal2)).to eq('N/A')
+      expect(control.z_score).to eq("N/A")
+      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
@@ -289,8 +288,8 @@ describe Split::Alternative do
 
   describe "extra_info" do
     it "reads saved value of recorded_info in redis" do
-      saved_recorded_info = {"key_1" => 1, "key_2" => "2"}
-      Split.redis.hset "#{alternative.experiment_name}:#{alternative.name}", 'recorded_info', saved_recorded_info.to_json
+      saved_recorded_info = { "key_1" => 1, "key_2" => "2" }
+      Split.redis.hset "#{alternative.experiment_name}:#{alternative.name}", "recorded_info", saved_recorded_info.to_json
       extra_info = alternative.extra_info
 
       expect(extra_info).to eql(saved_recorded_info)

data/spec/cache_spec.rb

@@ -1,19 +1,18 @@
 # frozen_string_literal: true
-require 'spec_helper'
 
-describe Split::Cache do
+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
-
+  describe "clear" do
     before { Split.configuration.cache = true }
 
-    it 'clears the cache' do
+    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
@@ -21,10 +20,10 @@ describe Split::Cache do
     end
   end
 
-  describe 'clear_key' do
+  describe "clear_key" do
     before { Split.configuration.cache = true }
 
-    it 'clears the cache' do
+    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 }
@@ -35,40 +34,37 @@ describe Split::Cache do
     end
   end
 
-  describe 'fetch' do
-
+  describe "fetch" do
     subject { Split::Cache.fetch(namespace, key) { Time.now } }
 
-    context 'when cache disabled' do
-
+    context "when cache disabled" do
       before { Split.configuration.cache = false }
 
-      it 'returns the yield' do
+      it "returns the yield" do
         expect(subject).to eql(now)
       end
 
-      it 'yields every time' do
+      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
-
+    context "when cache enabled" do
       before { Split.configuration.cache = true }
 
-      it 'returns the yield' do
+      it "returns the yield" do
         expect(subject).to eql(now)
       end
 
-      it 'yields once' do
+      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
+      it "honors namespace" do
         expect(Split::Cache.fetch(:a, key) { :a }).to eql(:a)
         expect(Split::Cache.fetch(:b, key) { :b }).to eql(:b)
 
@@ -76,7 +72,7 @@ describe Split::Cache do
         expect(Split::Cache.fetch(:b, key) { :b }).to eql(:b)
       end
 
-      it 'honors key' do
+      it "honors key" do
         expect(Split::Cache.fetch(namespace, :a) { :a }).to eql(:a)
         expect(Split::Cache.fetch(namespace, :b) { :b }).to eql(:b)
 

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