ab-split 1.0.0

data/spec/persistence_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe Split::Persistence do
+
+  subject { Split::Persistence }
+
+  describe ".adapter" do
+    context "when the persistence config is a symbol" do
+      it "should return the appropriate adapter for the symbol" do
+        expect(Split.configuration).to receive(:persistence).twice.and_return(:cookie)
+        expect(subject.adapter).to eq(Split::Persistence::CookieAdapter)
+      end
+
+      it "should return an adapter whose class is present in Split::Persistence::ADAPTERS" do
+        expect(Split.configuration).to receive(:persistence).twice.and_return(:cookie)
+        expect(Split::Persistence::ADAPTERS.values).to include(subject.adapter)
+      end
+
+      it "should raise if the adapter cannot be found" do
+        expect(Split.configuration).to receive(:persistence).twice.and_return(:something_weird)
+        expect { subject.adapter }.to raise_error(Split::InvalidPersistenceAdapterError)
+      end
+    end
+    context "when the persistence config is a class" do
+      let(:custom_adapter_class) { MyCustomAdapterClass = Class.new }
+      it "should return that class" do
+        expect(Split.configuration).to receive(:persistence).twice.and_return(custom_adapter_class)
+        expect(subject.adapter).to eq(MyCustomAdapterClass)
+      end
+    end
+  end
+
+end

data/spec/redis_interface_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe Split::RedisInterface do
+  let(:list_name) { 'list_name' }
+  let(:set_name) { 'set_name' }
+  let(:interface) { described_class.new }
+
+  describe '#persist_list' do
+    subject(:persist_list) do
+      interface.persist_list(list_name, %w(a b c d))
+    end
+
+    specify do
+      expect(persist_list).to eq %w(a b c d)
+      expect(Split.redis.lindex(list_name, 0)).to eq 'a'
+      expect(Split.redis.lindex(list_name, 1)).to eq 'b'
+      expect(Split.redis.lindex(list_name, 2)).to eq 'c'
+      expect(Split.redis.lindex(list_name, 3)).to eq 'd'
+      expect(Split.redis.llen(list_name)).to eq 4
+    end
+
+    context 'list is overwritten but not deleted' do
+      specify do
+        expect(persist_list).to eq %w(a b c d)
+        interface.persist_list(list_name, ['z'])
+        expect(Split.redis.lindex(list_name, 0)).to eq 'z'
+        expect(Split.redis.llen(list_name)).to eq 1
+      end
+    end
+  end
+
+  describe '#add_to_list' do
+    subject(:add_to_list) do
+      interface.add_to_list(list_name, 'y')
+      interface.add_to_list(list_name, 'z')
+    end
+
+    specify do
+      add_to_list
+      expect(Split.redis.lindex(list_name, 0)).to eq 'y'
+      expect(Split.redis.lindex(list_name, 1)).to eq 'z'
+      expect(Split.redis.llen(list_name)).to eq 2
+    end
+  end
+
+  describe '#set_list_index' do
+    subject(:set_list_index) do
+      interface.add_to_list(list_name, 'y')
+      interface.add_to_list(list_name, 'z')
+      interface.set_list_index(list_name, 0, 'a')
+    end
+
+    specify do
+      set_list_index
+      expect(Split.redis.lindex(list_name, 0)).to eq 'a'
+      expect(Split.redis.lindex(list_name, 1)).to eq 'z'
+      expect(Split.redis.llen(list_name)).to eq 2
+    end
+  end
+
+  describe '#list_length' do
+    subject(:list_length) do
+      interface.add_to_list(list_name, 'y')
+      interface.add_to_list(list_name, 'z')
+      interface.list_length(list_name)
+    end
+
+    specify do
+      expect(list_length).to eq 2
+    end
+  end
+
+  describe '#remove_last_item_from_list' do
+    subject(:remove_last_item_from_list) do
+      interface.add_to_list(list_name, 'y')
+      interface.add_to_list(list_name, 'z')
+      interface.remove_last_item_from_list(list_name)
+    end
+
+    specify do
+      remove_last_item_from_list
+      expect(Split.redis.lindex(list_name, 0)).to eq 'y'
+      expect(Split.redis.llen(list_name)).to eq 1
+    end
+  end
+
+  describe '#make_list_length' do
+    subject(:make_list_length) do
+      interface.add_to_list(list_name, 'y')
+      interface.add_to_list(list_name, 'z')
+      interface.make_list_length(list_name, 1)
+    end
+
+    specify do
+      make_list_length
+      expect(Split.redis.lindex(list_name, 0)).to eq 'y'
+      expect(Split.redis.llen(list_name)).to eq 1
+    end
+  end
+
+  describe '#add_to_set' do
+    subject(:add_to_set) do
+      interface.add_to_set(set_name, 'something')
+    end
+
+    specify do
+      add_to_set
+      expect(Split.redis.sismember(set_name, 'something')).to be true
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+ENV['RACK_ENV'] = "test"
+
+require 'rubygems'
+require 'bundler/setup'
+
+require 'simplecov'
+SimpleCov.start
+
+require 'split'
+require 'ostruct'
+require 'yaml'
+
+Dir['./spec/support/*.rb'].each { |f| require f }
+
+require "fakeredis"
+
+G_fakeredis = Redis.new
+
+module GlobalSharedContext
+  extend RSpec::SharedContext
+  let(:mock_user){ Split::User.new(double(session: {})) }
+  before(:each) do
+    Split.configuration = Split::Configuration.new
+    Split.redis = G_fakeredis
+    Split.redis.flushall
+    @ab_user = mock_user
+    params = nil
+  end
+end
+
+RSpec.configure do |config|
+  config.order = 'random'
+  config.include GlobalSharedContext
+end
+
+def session
+  @session ||= {}
+end
+
+def params
+  @params ||= {}
+end
+
+def request(ua = 'Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_6_6; de-de) AppleWebKit/533.20.25 (KHTML, like Gecko) Version/5.0.4 Safari/533.20.27')
+  @request ||= begin
+    r = OpenStruct.new
+    r.user_agent = ua
+    r.ip = '192.168.1.1'
+    r
+  end
+end

data/spec/split_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+RSpec.describe Split do
+
+  around(:each) do |ex|
+    old_env, old_redis = [ENV.delete('REDIS_URL'), Split.redis]
+    ex.run
+    ENV['REDIS_URL'] = old_env
+    Split.redis = old_redis
+  end
+
+  describe '#redis=' do
+    it 'accepts a url string' do
+      Split.redis = 'redis://localhost:6379'
+      expect(Split.redis).to be_a(Redis)
+
+      client = Split.redis.connection
+      expect(client[:host]).to eq("localhost")
+      expect(client[:port]).to eq(6379)
+    end
+
+    it 'accepts an options hash' do
+      Split.redis = {host: 'localhost', port: 6379, db: 12}
+      expect(Split.redis).to be_a(Redis)
+
+      client = Split.redis.connection
+      expect(client[:host]).to eq("localhost")
+      expect(client[:port]).to eq(6379)
+      expect(client[:db]).to eq(12)
+    end
+
+    it 'accepts a valid Redis instance' do
+      other_redis = Redis.new(url: "redis://localhost:6379")
+      Split.redis = other_redis
+      expect(Split.redis).to eq(other_redis)
+    end
+
+    it 'raises an ArgumentError when server cannot be determined' do
+      expect { Split.redis = Object.new }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/support/cookies_mock.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+class CookiesMock
+
+  def initialize
+    @cookies = {}
+  end
+
+  def []=(key, value)
+    @cookies[key] = value[:value]
+  end
+
+  def [](key)
+    @cookies[key]
+  end
+
+  def delete(key)
+    @cookies.delete(key)
+  end
+
+end

data/spec/trial_spec.rb

@@ -0,0 +1,299 @@
+# frozen_string_literal: true
+require 'spec_helper'
+require 'split/trial'
+
+describe Split::Trial do
+  let(:user) { mock_user }
+  let(:alternatives) { ['basket', 'cart'] }
+  let(:experiment) do
+    Split::Experiment.new('basket_text', :alternatives => alternatives).save
+  end
+
+  it "should be initializeable" do
+    experiment  = double('experiment')
+    alternative = double('alternative', :kind_of? => Split::Alternative)
+    trial = Split::Trial.new(:experiment => experiment, :alternative => alternative)
+    expect(trial.experiment).to eq(experiment)
+    expect(trial.alternative).to eq(alternative)
+  end
+
+  describe "alternative" do
+    it "should use the alternative if specified" do
+      alternative = double('alternative', :kind_of? => Split::Alternative)
+      trial = Split::Trial.new(:experiment => double('experiment'),
+          :alternative => alternative, :user => user)
+      expect(trial).not_to receive(:choose)
+      expect(trial.alternative).to eq(alternative)
+    end
+
+    it "should load the alternative when the alternative name is set" do
+      experiment = Split::Experiment.new('basket_text', :alternatives => ['basket', 'cart'])
+      experiment.save
+
+      trial = Split::Trial.new(:experiment => experiment, :alternative => 'basket')
+      expect(trial.alternative.name).to eq('basket')
+    end
+  end
+
+  describe "metadata" do
+    let(:metadata) { Hash[alternatives.map { |k| [k, "Metadata for #{k}"] }] }
+    let(:experiment) do
+      Split::Experiment.new('basket_text', :alternatives => alternatives, :metadata => metadata).save
+    end
+
+    it 'has metadata on each trial' do
+      trial = Split::Trial.new(:experiment => experiment, :user => user, :metadata => metadata['cart'],
+                               :override => 'cart')
+      expect(trial.metadata).to eq(metadata['cart'])
+    end
+
+    it 'has metadata on each trial from the experiment' do
+      trial = Split::Trial.new(:experiment => experiment, :user => user)
+      trial.choose!
+      expect(trial.metadata).to eq(metadata[trial.alternative.name])
+      expect(trial.metadata).to match(/#{trial.alternative.name}/)
+    end
+  end
+
+  describe "#choose!" do
+    let(:context) { double(on_trial_callback: 'test callback') }
+    let(:trial) do
+      Split::Trial.new(:user => user, :experiment => experiment)
+    end
+
+    shared_examples_for 'a trial with callbacks' do
+      it 'does not run if on_trial callback is not respondable' do
+        Split.configuration.on_trial = :foo
+        allow(context).to receive(:respond_to?).with(:foo, true).and_return false
+        expect(context).to_not receive(:foo)
+        trial.choose! context
+      end
+      it 'runs on_trial callback' do
+        Split.configuration.on_trial = :on_trial_callback
+        expect(context).to receive(:on_trial_callback)
+        trial.choose! context
+      end
+      it 'does not run nil on_trial callback' do
+        Split.configuration.on_trial = nil
+        expect(context).not_to receive(:on_trial_callback)
+        trial.choose! context
+      end
+    end
+
+    def expect_alternative(trial, alternative_name)
+      3.times do
+        trial.choose! context
+        expect(alternative_name).to include(trial.alternative.name)
+      end
+    end
+
+    context "when override is present" do
+      let(:override) { 'cart' }
+      let(:trial) do
+        Split::Trial.new(:user => user, :experiment => experiment, :override => override)
+      end
+
+      it_behaves_like 'a trial with callbacks'
+
+      it "picks the override" do
+        expect(experiment).to_not receive(:next_alternative)
+        expect_alternative(trial, override)
+      end
+
+      context "when alternative doesn't exist" do
+        let(:override) { nil }
+        it 'falls back on next_alternative' do
+          expect(experiment).to receive(:next_alternative).and_call_original
+          expect_alternative(trial, alternatives)
+        end
+      end
+    end
+
+    context "when disabled option is true" do
+      let(:trial) do
+        Split::Trial.new(:user => user, :experiment => experiment, :disabled => true)
+      end
+
+      it "picks the control", :aggregate_failures do
+        Split.configuration.on_trial = :on_trial_callback
+        expect(experiment).to_not receive(:next_alternative)
+
+        expect(context).not_to receive(:on_trial_callback)
+
+        expect_alternative(trial, 'basket')
+        Split.configuration.on_trial = nil
+      end
+    end
+
+    context "when Split is globally disabled" do
+      it "picks the control and does not run on_trial callbacks", :aggregate_failures do
+        Split.configuration.enabled = false
+        Split.configuration.on_trial = :on_trial_callback
+
+        expect(experiment).to_not receive(:next_alternative)
+        expect(context).not_to receive(:on_trial_callback)
+        expect_alternative(trial, 'basket')
+
+        Split.configuration.enabled = true
+        Split.configuration.on_trial = nil
+      end
+    end
+
+    context "when experiment has winner" do
+      let(:trial) do
+        Split::Trial.new(:user => user, :experiment => experiment)
+      end
+
+      it_behaves_like 'a trial with callbacks'
+
+      it "picks the winner" do
+        experiment.winner = 'cart'
+        expect(experiment).to_not receive(:next_alternative)
+
+        expect_alternative(trial, 'cart')
+      end
+    end
+
+    context "when exclude is true" do
+      let(:trial) do
+        Split::Trial.new(:user => user, :experiment => experiment, :exclude => true)
+      end
+
+      it_behaves_like 'a trial with callbacks'
+
+      it "picks the control" do
+        expect(experiment).to_not receive(:next_alternative)
+        expect_alternative(trial, 'basket')
+      end
+    end
+
+    context "when user is already participating" do
+      it_behaves_like 'a trial with callbacks'
+
+      it "picks the same alternative" do
+        user[experiment.key] = 'basket'
+        expect(experiment).to_not receive(:next_alternative)
+
+        expect_alternative(trial, 'basket')
+      end
+
+      context "when alternative is not found" do
+        it "falls back on next_alternative" do
+          user[experiment.key] = 'notfound'
+          expect(experiment).to receive(:next_alternative).and_call_original
+          expect_alternative(trial, alternatives)
+        end
+      end
+    end
+
+    context "when user is a new participant" do
+      it "picks a new alternative and runs on_trial_choose callback", :aggregate_failures do
+        Split.configuration.on_trial_choose = :on_trial_choose_callback
+
+        expect(experiment).to receive(:next_alternative).and_call_original
+        expect(context).to receive(:on_trial_choose_callback)
+
+        trial.choose! context
+
+        expect(trial.alternative.name).to_not be_empty
+        Split.configuration.on_trial_choose = nil
+      end
+    end
+  end
+
+  describe "#complete!" do
+    let(:trial) { Split::Trial.new(:user => user, :experiment => experiment) }
+    context 'when there are no goals' do
+      it 'should complete the trial' do
+        trial.choose!
+        old_completed_count = trial.alternative.completed_count
+        trial.complete!
+        expect(trial.alternative.completed_count).to be(old_completed_count+1)
+      end
+    end
+
+    context 'when there are many goals' do
+      let(:goals) { ['first', 'second'] }
+      let(:trial) { Split::Trial.new(:user => user, :experiment => experiment, :goals => goals) }
+      shared_examples_for "goal completion" do
+        it 'should not complete the trial' do
+          trial.choose!
+          old_completed_count = trial.alternative.completed_count
+          trial.complete!(goal)
+          expect(trial.alternative.completed_count).to_not be(old_completed_count+1)
+        end
+      end
+
+      describe 'Array of Goals' do
+        let(:goal) { [goals.first] }
+        it_behaves_like 'goal completion'
+      end
+
+      describe 'String of Goal' do
+        let(:goal) { goals.first }
+        it_behaves_like 'goal completion'
+      end
+
+    end
+  end
+
+  describe "alternative recording" do
+    before(:each) { Split.configuration.store_override = false }
+
+    context "when override is present" do
+      it "stores when store_override is true" do
+        trial = Split::Trial.new(:user => user, :experiment => experiment, :override => 'basket')
+
+        Split.configuration.store_override = true
+        expect(user).to receive("[]=")
+        trial.choose!
+        expect(trial.alternative.participant_count).to eq(1)
+      end
+
+      it "does not store when store_override is false" do
+        trial = Split::Trial.new(:user => user, :experiment => experiment, :override => 'basket')
+
+        expect(user).to_not receive("[]=")
+        trial.choose!
+      end
+    end
+
+    context "when disabled is present" do
+      it "stores when store_override is true" do
+        trial = Split::Trial.new(:user => user, :experiment => experiment, :disabled => true)
+
+        Split.configuration.store_override = true
+        expect(user).to receive("[]=")
+        trial.choose!
+      end
+
+      it "does not store when store_override is false" do
+        trial = Split::Trial.new(:user => user, :experiment => experiment, :disabled => true)
+
+        expect(user).to_not receive("[]=")
+        trial.choose!
+      end
+    end
+
+    context "when exclude is present" do
+      it "does not store" do
+        trial = Split::Trial.new(:user => user, :experiment => experiment, :exclude => true)
+
+        expect(user).to_not receive("[]=")
+        trial.choose!
+      end
+    end
+
+    context 'when experiment has winner' do
+      let(:trial) do
+        experiment.winner = 'cart'
+        Split::Trial.new(:user => user, :experiment => experiment)
+      end
+
+      it 'does not store' do
+        expect(user).to_not receive("[]=")
+        trial.choose!
+      end
+    end
+  end
+end