split 3.2.0 → 4.0.5

data/spec/metric_spec.rb

@@ -1,31 +1,31 @@
 # frozen_string_literal: true
-require 'spec_helper'
-require 'split/metric'
+
+require "spec_helper"
+require "split/metric"
 
 describe Split::Metric do
-  describe 'possible experiments' do
+  describe "possible experiments" do
     it "should load the experiment if there is one, but no metric" do
-      experiment = Split::ExperimentCatalog.find_or_create('color', 'red', 'blue')
-      expect(Split::Metric.possible_experiments('color')).to eq([experiment])
+      experiment = Split::ExperimentCatalog.find_or_create("color", "red", "blue")
+      expect(Split::Metric.possible_experiments("color")).to eq([experiment])
     end
 
     it "should load the experiments in a metric" do
-      experiment1 = Split::ExperimentCatalog.find_or_create('color', 'red', 'blue')
-      experiment2 = Split::ExperimentCatalog.find_or_create('size', 'big', 'small')
+      experiment1 = Split::ExperimentCatalog.find_or_create("color", "red", "blue")
+      experiment2 = Split::ExperimentCatalog.find_or_create("size", "big", "small")
 
-      metric = Split::Metric.new(:name => 'purchase', :experiments => [experiment1, experiment2])
+      metric = Split::Metric.new(name: "purchase", experiments: [experiment1, experiment2])
       metric.save
-      expect(Split::Metric.possible_experiments('purchase')).to include(experiment1, experiment2)
+      expect(Split::Metric.possible_experiments("purchase")).to include(experiment1, experiment2)
     end
 
     it "should load both the metric experiments and an experiment with the same name" do
-      experiment1 = Split::ExperimentCatalog.find_or_create('purchase', 'red', 'blue')
-      experiment2 = Split::ExperimentCatalog.find_or_create('size', 'big', 'small')
+      experiment1 = Split::ExperimentCatalog.find_or_create("purchase", "red", "blue")
+      experiment2 = Split::ExperimentCatalog.find_or_create("size", "big", "small")
 
-      metric = Split::Metric.new(:name => 'purchase', :experiments => [experiment2])
+      metric = Split::Metric.new(name: "purchase", experiments: [experiment2])
       metric.save
-      expect(Split::Metric.possible_experiments('purchase')).to include(experiment1, experiment2)
+      expect(Split::Metric.possible_experiments("purchase")).to include(experiment1, experiment2)
     end
   end
-
 end

data/spec/persistence/cookie_adapter_spec.rb

@@ -1,43 +1,121 @@
 # frozen_string_literal: true
+
 require "spec_helper"
-require 'rack/test'
+require "rack/test"
 
 describe Split::Persistence::CookieAdapter do
+  subject { described_class.new(context) }
+
+  shared_examples "sets cookies correctly" do
+    describe "#[] and #[]=" do
+      it "set and return the value for given key" do
+        subject["my_key"] = "my_value"
+        expect(subject["my_key"]).to eq("my_value")
+      end
+
+      it "handles invalid JSON" do
+        context.request.cookies["split"] = "{\"foo\":2,"
+
+        expect(subject["my_key"]).to be_nil
+        subject["my_key"] = "my_value"
+        expect(subject["my_key"]).to eq("my_value")
+      end
+
+      it "ignores valid JSON of invalid type (integer)" do
+        context.request.cookies["split"] = "2"
+
+        expect(subject["my_key"]).to be_nil
+        subject["my_key"] = "my_value"
+        expect(subject["my_key"]).to eq("my_value")
+      end
 
-  let(:env) { Rack::MockRequest.env_for("http://example.com:8080/") }
-  let(:request) { Rack::Request.new(env) }
-  let(:response) { Rack::MockResponse.new(200, {}, "") }
-  let(:context) { double(request: request, response: response) }
-  subject { Split::Persistence::CookieAdapter.new(context) }
+      it "ignores valid JSON of invalid type (array)" do
+        context.request.cookies["split"] = "[\"foo\", \"bar\"]"
 
-  describe "#[] and #[]=" do
-    it "should set and return the value for given key" do
-      subject["my_key"] = "my_value"
-      expect(subject["my_key"]).to eq("my_value")
+        expect(subject["my_key"]).to be_nil
+        subject["my_key"] = "my_value"
+        expect(subject["my_key"]).to eq("my_value")
+      end
     end
-  end
 
-  describe "#delete" do
-    it "should delete the given key" do
-      subject["my_key"] = "my_value"
-      subject.delete("my_key")
-      expect(subject["my_key"]).to be_nil
+    describe "#delete" do
+      it "should delete the given key" do
+        subject["my_key"] = "my_value"
+        subject.delete("my_key")
+        expect(subject["my_key"]).to be_nil
+      end
     end
-  end
 
-  describe "#keys" do
-    it "should return an array of the session's stored keys" do
-      subject["my_key"] = "my_value"
-      subject["my_second_key"] = "my_second_value"
-      expect(subject.keys).to match(["my_key", "my_second_key"])
+    describe "#keys" do
+      it "should return an array of the session's stored keys" do
+        subject["my_key"] = "my_value"
+        subject["my_second_key"] = "my_second_value"
+        expect(subject.keys).to match(["my_key", "my_second_key"])
+      end
     end
   end
 
-  it "handles invalid JSON" do
-    context.request.cookies[:split] = { :value => '{"foo":2,', :expires => Time.now }
-    expect(subject["my_key"]).to be_nil
-    subject["my_key"] = "my_value"
-    expect(subject["my_key"]).to eq("my_value")
+
+  context "when using Rack" do
+    let(:env) { Rack::MockRequest.env_for("http://example.com:8080/") }
+    let(:request) { Rack::Request.new(env) }
+    let(:response) { Rack::MockResponse.new(200, {}, "") }
+    let(:context) { double(request: request, response: response, cookies: CookiesMock.new) }
+
+    include_examples "sets cookies correctly"
+
+    it "puts multiple experiments in a single cookie" do
+      subject["foo"] = "FOO"
+      subject["bar"] = "BAR"
+      expect(Array(context.response.headers["Set-Cookie"])).to include(/\Asplit=%7B%22foo%22%3A%22FOO%22%2C%22bar%22%3A%22BAR%22%7D; path=\/; expires=[a-zA-Z]{3}, \d{2} [a-zA-Z]{3} \d{4} \d{2}:\d{2}:\d{2} [A-Z]{3}\Z/)
+    end
+
+    it "ensure other added cookies are not overriden" do
+      context.response.set_cookie "dummy", "wow"
+      subject["foo"] = "FOO"
+      expect(Array(context.response.headers["Set-Cookie"])).to include(/dummy=wow/)
+      expect(Array(context.response.headers["Set-Cookie"])).to include(/split=/)
+    end
   end
 
+  context "when @context is an ActionController::Base" do
+    before :context do
+      require "rails"
+      require "action_controller/railtie"
+    end
+
+    let(:context) do
+      controller = controller_class.new
+      if controller.respond_to?(:set_request!)
+        controller.set_request!(ActionDispatch::Request.new({}))
+      else # Before rails 5.0
+        controller.send(:"request=", ActionDispatch::Request.new({}))
+      end
+
+      response = ActionDispatch::Response.new(200, {}, "").tap do |res|
+        res.request = controller.request
+      end
+
+      if controller.respond_to?(:set_response!)
+        controller.set_response!(response)
+      else # Before rails 5.0
+        controller.send(:set_response!, response)
+      end
+      controller
+    end
+
+    let(:controller_class) { Class.new(ActionController::Base) }
+
+    include_examples "sets cookies correctly"
+
+    it "puts multiple experiments in a single cookie" do
+      subject["foo"] = "FOO"
+      subject["bar"] = "BAR"
+      expect(subject.keys).to eq(["foo", "bar"])
+      expect(subject["foo"]).to eq("FOO")
+      expect(subject["bar"]).to eq("BAR")
+      cookie_jar = context.request.env["action_dispatch.cookies"]
+      expect(cookie_jar["split"]).to eq('{"foo":"FOO","bar":"BAR"}')
+    end
+  end
 end

data/spec/persistence/dual_adapter_spec.rb

@@ -1,102 +1,194 @@
 # frozen_string_literal: true
+
 require "spec_helper"
 
 describe Split::Persistence::DualAdapter do
+  let(:context) { "some context" }
 
-  let(:context){ "some context" }
-
-  let(:just_adapter){ Class.new }
-  let(:selected_adapter_instance){ double }
-  let(:selected_adapter){
-    c = Class.new
-    expect(c).to receive(:new){ selected_adapter_instance }
-    c
-  }
-  let(:not_selected_adapter){
-    c = Class.new
-    expect(c).not_to receive(:new)
-    c
-  }
-
-  shared_examples_for "forwarding calls" do
-    it "#[]=" do
-      expect(selected_adapter_instance).to receive(:[]=).with('my_key', 'my_value')
-      expect_any_instance_of(not_selected_adapter).not_to receive(:[]=)
-      subject["my_key"] = "my_value"
-    end
+  let(:logged_in_adapter_instance) { double }
+  let(:logged_in_adapter) do
+    Class.new.tap { |c| allow(c).to receive(:new) { logged_in_adapter_instance } }
+  end
+  let(:logged_out_adapter_instance) { double }
+  let(:logged_out_adapter) do
+    Class.new.tap { |c| allow(c).to receive(:new) { logged_out_adapter_instance } }
+  end
 
-    it "#[]" do
-      expect(selected_adapter_instance).to receive(:[]).with('my_key'){'my_value'}
-      expect_any_instance_of(not_selected_adapter).not_to receive(:[])
-      expect(subject["my_key"]).to eq('my_value')
-    end
+  context "when fallback_to_logged_out_adapter is false" do
+    context "when logged in" do
+      subject do
+        described_class.with_config(
+          logged_in: lambda { |context| true },
+          logged_in_adapter: logged_in_adapter,
+          logged_out_adapter: logged_out_adapter,
+          fallback_to_logged_out_adapter: false
+        ).new(context)
+      end
+
+      it "#[]=" do
+        expect(logged_in_adapter_instance).to receive(:[]=).with("my_key", "my_value")
+        expect_any_instance_of(logged_out_adapter).not_to receive(:[]=)
+        subject["my_key"] = "my_value"
+      end
+
+      it "#[]" do
+        expect(logged_in_adapter_instance).to receive(:[]).with("my_key") { "my_value" }
+        expect_any_instance_of(logged_out_adapter).not_to receive(:[])
+        expect(subject["my_key"]).to eq("my_value")
+      end
 
-    it "#delete" do
-      expect(selected_adapter_instance).to receive(:delete).with('my_key'){'my_value'}
-      expect_any_instance_of(not_selected_adapter).not_to receive(:delete)
-      expect(subject.delete("my_key")).to eq('my_value')
+      it "#delete" do
+        expect(logged_in_adapter_instance).to receive(:delete).with("my_key") { "my_value" }
+        expect_any_instance_of(logged_out_adapter).not_to receive(:delete)
+        expect(subject.delete("my_key")).to eq("my_value")
+      end
+
+      it "#keys" do
+        expect(logged_in_adapter_instance).to receive(:keys) { ["my_value"] }
+        expect_any_instance_of(logged_out_adapter).not_to receive(:keys)
+        expect(subject.keys).to eq(["my_value"])
+      end
     end
 
-    it "#keys" do
-      expect(selected_adapter_instance).to receive(:keys){'my_value'}
-      expect_any_instance_of(not_selected_adapter).not_to receive(:keys)
-      expect(subject.keys).to eq('my_value')
+    context "when logged out" do
+      subject do
+        described_class.with_config(
+          logged_in: lambda { |context| false },
+          logged_in_adapter: logged_in_adapter,
+          logged_out_adapter: logged_out_adapter,
+          fallback_to_logged_out_adapter: false
+        ).new(context)
+      end
+
+      it "#[]=" do
+        expect_any_instance_of(logged_in_adapter).not_to receive(:[]=)
+        expect(logged_out_adapter_instance).to receive(:[]=).with("my_key", "my_value")
+        subject["my_key"] = "my_value"
+      end
+
+      it "#[]" do
+        expect_any_instance_of(logged_in_adapter).not_to receive(:[])
+        expect(logged_out_adapter_instance).to receive(:[]).with("my_key") { "my_value" }
+        expect(subject["my_key"]).to eq("my_value")
+      end
+
+      it "#delete" do
+        expect_any_instance_of(logged_in_adapter).not_to receive(:delete)
+        expect(logged_out_adapter_instance).to receive(:delete).with("my_key") { "my_value" }
+        expect(subject.delete("my_key")).to eq("my_value")
+      end
+
+      it "#keys" do
+        expect_any_instance_of(logged_in_adapter).not_to receive(:keys)
+        expect(logged_out_adapter_instance).to receive(:keys) { ["my_value", "my_value2"] }
+        expect(subject.keys).to eq(["my_value", "my_value2"])
+      end
     end
   end
 
-  context "when logged in" do
-    subject {
-      described_class.with_config(
-        logged_in: lambda { |context| true },
-        logged_in_adapter: selected_adapter,
-        logged_out_adapter: not_selected_adapter
+  context "when fallback_to_logged_out_adapter is true" do
+    context "when logged in" do
+      subject do
+        described_class.with_config(
+          logged_in: lambda { |context| true },
+          logged_in_adapter: logged_in_adapter,
+          logged_out_adapter: logged_out_adapter,
+          fallback_to_logged_out_adapter: true
         ).new(context)
-    }
+      end
 
-    it_should_behave_like "forwarding calls"
-  end
+      it "#[]=" do
+        expect(logged_in_adapter_instance).to receive(:[]=).with("my_key", "my_value")
+        expect(logged_out_adapter_instance).to receive(:[]=).with("my_key", "my_value")
+        expect(logged_out_adapter_instance).to receive(:[]).with("my_key") { nil }
+        subject["my_key"] = "my_value"
+      end
+
+      it "#[]" do
+        expect(logged_in_adapter_instance).to receive(:[]).with("my_key") { "my_value" }
+        expect_any_instance_of(logged_out_adapter).not_to receive(:[])
+        expect(subject["my_key"]).to eq("my_value")
+      end
+
+      it "#delete" do
+        expect(logged_in_adapter_instance).to receive(:delete).with("my_key") { "my_value" }
+        expect(logged_out_adapter_instance).to receive(:delete).with("my_key") { "my_value" }
+        expect(subject.delete("my_key")).to eq("my_value")
+      end
+
+      it "#keys" do
+        expect(logged_in_adapter_instance).to receive(:keys) { ["my_value"] }
+        expect(logged_out_adapter_instance).to receive(:keys) { ["my_value", "my_value2"] }
+        expect(subject.keys).to eq(["my_value", "my_value2"])
+      end
+    end
 
-  context "when not logged in" do
-    subject {
-      described_class.with_config(
-        logged_in: lambda { |context| false },
-        logged_in_adapter: not_selected_adapter,
-        logged_out_adapter: selected_adapter
+    context "when logged out" do
+      subject do
+        described_class.with_config(
+          logged_in: lambda { |context| false },
+          logged_in_adapter: logged_in_adapter,
+          logged_out_adapter: logged_out_adapter,
+          fallback_to_logged_out_adapter: true
         ).new(context)
-    }
+      end
+
+      it "#[]=" do
+        expect_any_instance_of(logged_in_adapter).not_to receive(:[]=)
+        expect(logged_out_adapter_instance).to receive(:[]=).with("my_key", "my_value")
+        expect(logged_out_adapter_instance).to receive(:[]).with("my_key") { nil }
+        subject["my_key"] = "my_value"
+      end
+
+      it "#[]" do
+        expect_any_instance_of(logged_in_adapter).not_to receive(:[])
+        expect(logged_out_adapter_instance).to receive(:[]).with("my_key") { "my_value" }
+        expect(subject["my_key"]).to eq("my_value")
+      end
+
+      it "#delete" do
+        expect(logged_in_adapter_instance).to receive(:delete).with("my_key") { "my_value" }
+        expect(logged_out_adapter_instance).to receive(:delete).with("my_key") { "my_value" }
+        expect(subject.delete("my_key")).to eq("my_value")
+      end
 
-    it_should_behave_like "forwarding calls"
+      it "#keys" do
+        expect(logged_in_adapter_instance).to receive(:keys) { ["my_value"] }
+        expect(logged_out_adapter_instance).to receive(:keys) { ["my_value", "my_value2"] }
+        expect(subject.keys).to eq(["my_value", "my_value2"])
+      end
+    end
   end
 
   describe "when errors in config" do
-    before{
-      described_class.config.clear
-    }
-    let(:some_proc){ ->{} }
+    before { described_class.config.clear }
+    let(:some_proc) { -> { } }
+
     it "when no logged in adapter" do
-      expect{
+      expect {
         described_class.with_config(
           logged_in: some_proc,
-          logged_out_adapter: just_adapter
-          ).new(context)
+          logged_out_adapter: logged_out_adapter
+        ).new(context)
       }.to raise_error(StandardError, /:logged_in_adapter/)
     end
+
     it "when no logged out adapter" do
-      expect{
+      expect {
         described_class.with_config(
           logged_in: some_proc,
-          logged_in_adapter: just_adapter
-          ).new(context)
+          logged_in_adapter: logged_in_adapter
+        ).new(context)
       }.to raise_error(StandardError, /:logged_out_adapter/)
     end
+
     it "when no logged in detector" do
-      expect{
+      expect {
         described_class.with_config(
-          logged_in_adapter: just_adapter,
-          logged_out_adapter: just_adapter
-          ).new(context)
+          logged_in_adapter: logged_in_adapter,
+          logged_out_adapter: logged_out_adapter
+        ).new(context)
       }.to raise_error(StandardError, /:logged_in$/)
     end
   end
-
 end

data/spec/persistence/redis_adapter_spec.rb

@@ -1,72 +1,81 @@
 # frozen_string_literal: true
+
 require "spec_helper"
 
 describe Split::Persistence::RedisAdapter do
-
-  let(:context) { double(:lookup => 'blah') }
+  let(:context) { double(lookup: "blah") }
 
   subject { Split::Persistence::RedisAdapter.new(context) }
 
-  describe '#redis_key' do
+  describe "#redis_key" do
     before { Split::Persistence::RedisAdapter.reset_config! }
 
-    context 'default' do
-      it 'should raise error with prompt to set lookup_by' do
-        expect{Split::Persistence::RedisAdapter.new(context)}.to raise_error(RuntimeError)
+    context "default" do
+      it "should raise error with prompt to set lookup_by" do
+        expect { Split::Persistence::RedisAdapter.new(context) }.to raise_error(RuntimeError)
       end
     end
 
-    context 'config with key' do
+    context "config with key" do
       before { Split::Persistence::RedisAdapter.reset_config! }
-      subject { Split::Persistence::RedisAdapter.new(context, 'manual') }
+      subject { Split::Persistence::RedisAdapter.new(context, "manual") }
 
       it 'should be "persistence:manual"' do
-        expect(subject.redis_key).to eq('persistence:manual')
+        expect(subject.redis_key).to eq("persistence:manual")
       end
     end
 
     context 'config with lookup_by = proc { "block" }' do
-      before { Split::Persistence::RedisAdapter.with_config(:lookup_by => proc{'block'}) }
+      before { Split::Persistence::RedisAdapter.with_config(lookup_by: proc { "block" }) }
 
       it 'should be "persistence:block"' do
-        expect(subject.redis_key).to eq('persistence:block')
+        expect(subject.redis_key).to eq("persistence:block")
       end
     end
 
-    context 'config with lookup_by = proc { |context| context.test }' do
-      before { Split::Persistence::RedisAdapter.with_config(:lookup_by => proc{'block'}) }
-      let(:context) { double(:test => 'block') }
+    context "config with lookup_by = proc { |context| context.test }" do
+      before { Split::Persistence::RedisAdapter.with_config(lookup_by: proc { "block" }) }
+      let(:context) { double(test: "block") }
 
       it 'should be "persistence:block"' do
-        expect(subject.redis_key).to eq('persistence:block')
+        expect(subject.redis_key).to eq("persistence:block")
       end
     end
 
     context 'config with lookup_by = "method_name"' do
-      before { Split::Persistence::RedisAdapter.with_config(:lookup_by => 'method_name') }
-      let(:context) { double(:method_name => 'val') }
+      before { Split::Persistence::RedisAdapter.with_config(lookup_by: "method_name") }
+      let(:context) { double(method_name: "val") }
 
       it 'should be "persistence:bar"' do
-        expect(subject.redis_key).to eq('persistence:val')
+        expect(subject.redis_key).to eq("persistence:val")
       end
     end
 
-    context 'config with namespace and lookup_by' do
-      before { Split::Persistence::RedisAdapter.with_config(:lookup_by => proc{'frag'}, :namespace => 'namer') }
+    context "config with namespace and lookup_by" do
+      before { Split::Persistence::RedisAdapter.with_config(lookup_by: proc { "frag" }, namespace: "namer") }
 
       it 'should be "namer"' do
-        expect(subject.redis_key).to eq('namer:frag')
+        expect(subject.redis_key).to eq("namer:frag")
       end
     end
   end
 
-  context 'functional tests' do
-    before { Split::Persistence::RedisAdapter.with_config(:lookup_by => 'lookup') }
+  describe "#find" do
+    before { Split::Persistence::RedisAdapter.with_config(lookup_by: proc { "frag" }, namespace: "a_namespace") }
+
+    it "should create and user from a given key" do
+      adapter = Split::Persistence::RedisAdapter.find(2)
+      expect(adapter.redis_key).to eq("a_namespace:2")
+    end
+  end
+
+  context "functional tests" do
+    before { Split::Persistence::RedisAdapter.with_config(lookup_by: "lookup") }
 
     describe "#[] and #[]=" do
-      it "should set and return the value for given key" do
-        subject["my_key"] = "my_value"
-        expect(subject["my_key"]).to eq("my_value")
+      it "should convert to string, set and return the value for given key" do
+        subject["my_key"] = true
+        expect(subject["my_key"]).to eq("true")
       end
     end
 
@@ -85,6 +94,5 @@ describe Split::Persistence::RedisAdapter do
         expect(subject.keys).to match(["my_key", "my_second_key"])
       end
     end
-
   end
 end

data/spec/persistence/session_adapter_spec.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
+
 require "spec_helper"
 
 describe Split::Persistence::SessionAdapter do
-
-  let(:context) { double(:session => {}) }
+  let(:context) { double(session: {}) }
   subject { Split::Persistence::SessionAdapter.new(context) }
 
   describe "#[] and #[]=" do
@@ -28,5 +28,4 @@ describe Split::Persistence::SessionAdapter do
       expect(subject.keys).to match(["my_key", "my_second_key"])
     end
   end
-
 end

data/spec/persistence_spec.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
+
 require "spec_helper"
 
 describe Split::Persistence do
-
   subject { Split::Persistence }
 
   describe ".adapter" do
@@ -30,5 +30,4 @@ describe Split::Persistence do
       end
     end
   end
-
 end