split 4.0.1 → 4.0.5

data/spec/encapsulated_helper_spec.rb

@@ -1,13 +1,9 @@
 # frozen_string_literal: true
-require 'spec_helper'
-
-describe Split::EncapsulatedHelper do
-  include Split::EncapsulatedHelper
 
+require "spec_helper"
 
-  def params
-    raise NoMethodError, 'This method is not really defined'
-  end
+describe Split::EncapsulatedHelper do
+  let(:context_shim) { Split::EncapsulatedHelper::ContextShim.new(double(request: request)) }
 
   describe "ab_test" do
     before do
@@ -15,38 +11,66 @@ describe Split::EncapsulatedHelper do
       .and_return(mock_user)
     end
 
-    it "should not raise an error when params raises an error" do
-      expect{ params }.to raise_error(NoMethodError)
-      expect(lambda { ab_test('link_color', 'blue', 'red') }).not_to raise_error
-    end
-
     it "calls the block with selected alternative" do
-      expect{|block| ab_test('link_color', 'red', 'red', &block) }.to yield_with_args('red', {})
+      expect { |block| context_shim.ab_test("link_color", "red", "red", &block) }.to yield_with_args("red", {})
     end
 
     context "inside a view" do
-
       it "works inside ERB" do
-        require 'erb'
-        template = ERB.new(<<-ERB.split(/\s+/s).map(&:strip).join(' '), nil, "%")
-          foo <% ab_test(:foo, '1', '2') do |alt, meta| %>
+        require "erb"
+        template = ERB.new(<<-ERB.split(/\s+/s).map(&:strip).join(" "), nil, "%")
+          foo <% context_shim.ab_test(:foo, '1', '2') do |alt, meta| %>
             static <%= alt %>
           <% end %>
         ERB
         expect(template.result(binding)).to match(/foo  static \d/)
       end
-
     end
   end
 
   describe "context" do
-    it 'is passed in shim' do
-      ctx = Class.new{
+    it "is passed in shim" do
+      ctx = Class.new {
         include Split::EncapsulatedHelper
         public :session
       }.new
-      expect(ctx).to receive(:session){{}}
-      expect{ ctx.ab_test('link_color', 'blue', 'red') }.not_to raise_error
+
+      expect(ctx).to receive(:session) { {} }
+      expect { ctx.ab_test("link_color", "blue", "red") }.not_to raise_error
+    end
+
+    context "when request is defined in context of ContextShim" do
+      context "when overriding by params" do
+        it do
+          ctx = Class.new {
+            public :session
+            def request
+              build_request(params: {
+                "ab_test" => { "link_color" => "blue" }
+              })
+            end
+          }.new
+
+          context_shim = Split::EncapsulatedHelper::ContextShim.new(ctx)
+          expect(context_shim.ab_test("link_color", "blue", "red")).to be("blue")
+        end
+      end
+
+      context "when overriding by cookies" do
+        it do
+          ctx = Class.new {
+            public :session
+            def request
+              build_request(cookies: {
+                "split_override" => '{ "link_color": "red" }'
+              })
+            end
+          }.new
+
+          context_shim = Split::EncapsulatedHelper::ContextShim.new(ctx)
+          expect(context_shim.ab_test("link_color", "blue", "red")).to be("red")
+        end
+      end
     end
   end
 end

data/spec/experiment_catalog_spec.rb

@@ -1,53 +1,54 @@
 # frozen_string_literal: true
-require 'spec_helper'
+
+require "spec_helper"
 
 describe Split::ExperimentCatalog do
   subject { Split::ExperimentCatalog }
 
   describe ".find_or_create" do
     it "should not raise an error when passed strings for alternatives" do
-      expect { subject.find_or_create('xyz', '1', '2', '3') }.not_to raise_error
+      expect { subject.find_or_create("xyz", "1", "2", "3") }.not_to raise_error
     end
 
     it "should not raise an error when passed an array for alternatives" do
-      expect { subject.find_or_create('xyz', ['1', '2', '3']) }.not_to raise_error
+      expect { subject.find_or_create("xyz", ["1", "2", "3"]) }.not_to raise_error
     end
 
     it "should raise the appropriate error when passed integers for alternatives" do
-      expect { subject.find_or_create('xyz', 1, 2, 3) }.to raise_error(ArgumentError)
+      expect { subject.find_or_create("xyz", 1, 2, 3) }.to raise_error(ArgumentError)
     end
 
     it "should raise the appropriate error when passed symbols for alternatives" do
-      expect { subject.find_or_create('xyz', :a, :b, :c) }.to raise_error(ArgumentError)
+      expect { subject.find_or_create("xyz", :a, :b, :c) }.to raise_error(ArgumentError)
     end
 
     it "should not raise error when passed an array for goals" do
-      expect { subject.find_or_create({'link_color' => ["purchase", "refund"]}, 'blue', 'red') }
+      expect { subject.find_or_create({ "link_color" => ["purchase", "refund"] }, "blue", "red") }
           .not_to raise_error
     end
 
     it "should not raise error when passed just one goal" do
-      expect { subject.find_or_create({'link_color' => "purchase"}, 'blue', 'red') }
+      expect { subject.find_or_create({ "link_color" => "purchase" }, "blue", "red") }
           .not_to raise_error
     end
 
     it "constructs a new experiment" do
-      expect(subject.find_or_create('my_exp', 'control me').control.to_s).to eq('control me')
+      expect(subject.find_or_create("my_exp", "control me").control.to_s).to eq("control me")
     end
   end
 
-  describe '.find' do
+  describe ".find" do
     it "should return an existing experiment" do
-      experiment = Split::Experiment.new('basket_text', alternatives: ['blue', 'red', 'green'])
+      experiment = Split::Experiment.new("basket_text", alternatives: ["blue", "red", "green"])
       experiment.save
 
-      experiment = subject.find('basket_text')
+      experiment = subject.find("basket_text")
 
-      expect(experiment.name).to eq('basket_text')
+      expect(experiment.name).to eq("basket_text")
     end
 
     it "should return nil if experiment not exist" do
-      expect(subject.find('non_existent_experiment')).to be_nil
+      expect(subject.find("non_existent_experiment")).to be_nil
     end
   end
 end