ab-split 1.0.0

data/spec/metric_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+require 'spec_helper'
+require 'split/metric'
+
+describe Split::Metric 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])
+    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')
+
+      metric = Split::Metric.new(:name => 'purchase', :experiments => [experiment1, experiment2])
+      metric.save
+      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')
+
+      metric = Split::Metric.new(:name => 'purchase', :experiments => [experiment2])
+      metric.save
+      expect(Split::Metric.possible_experiments('purchase')).to include(experiment1, experiment2)
+    end
+  end
+
+end

data/spec/persistence/cookie_adapter_spec.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+require "spec_helper"
+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] = {
+          :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")
+      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
+      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"])
+      end
+    end
+  end
+
+
+  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(context.response.headers["Set-Cookie"]).to match(/\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} -0000\Z/)
+    end
+
+    it "ensure other added cookies are not overriden" do
+      context.response.set_cookie 'dummy', 'wow'
+      subject["foo"] = "FOO"
+      expect(context.response.headers["Set-Cookie"]).to include("dummy=wow")
+      expect(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

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Split::Persistence::DualAdapter do
+  let(:context) { 'some context' }
+
+  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
+
+  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(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
+
+    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 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 '#[]=' 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 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 '#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) { ->{} }
+
+    it 'when no logged in adapter' do
+      expect{
+        described_class.with_config(
+          logged_in: some_proc,
+          logged_out_adapter: logged_out_adapter
+        ).new(context)
+      }.to raise_error(StandardError, /:logged_in_adapter/)
+    end
+
+    it 'when no logged out adapter' do
+      expect{
+        described_class.with_config(
+          logged_in: some_proc,
+          logged_in_adapter: logged_in_adapter
+        ).new(context)
+      }.to raise_error(StandardError, /:logged_out_adapter/)
+    end
+
+    it 'when no logged in detector' do
+      expect{
+        described_class.with_config(
+          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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe Split::Persistence::RedisAdapter do
+
+  let(:context) { double(:lookup => 'blah') }
+
+  subject { Split::Persistence::RedisAdapter.new(context) }
+
+  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)
+      end
+    end
+
+    context 'config with key' do
+      before { Split::Persistence::RedisAdapter.reset_config! }
+      subject { Split::Persistence::RedisAdapter.new(context, 'manual') }
+
+      it 'should be "persistence:manual"' do
+        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'}) }
+
+      it 'should be "persistence:block"' do
+        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') }
+
+      it 'should be "persistence:block"' do
+        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') }
+
+      it 'should be "persistence:bar"' do
+        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') }
+
+      it 'should be "namer"' do
+        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 "#[] 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")
+      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
+      end
+    end
+
+    describe "#keys" do
+      it "should return an array of the user'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
+end

data/spec/persistence/session_adapter_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe Split::Persistence::SessionAdapter do
+
+  let(:context) { double(:session => {}) }
+  subject { Split::Persistence::SessionAdapter.new(context) }
+
+  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")
+    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
+    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"])
+    end
+  end
+
+end