split 2.2.0 → 3.3.0

data/spec/combined_experiments_helper_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+require 'spec_helper'
+require 'split/combined_experiments_helper'
+
+describe Split::CombinedExperimentsHelper do
+  include Split::CombinedExperimentsHelper
+
+  describe 'ab_combined_test' do
+    let!(:config_enabled) { true }
+    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
+        }
+      }
+      Split.configuration.enabled = config_enabled
+      Split.configuration.allow_multiple_experiments = allow_multiple_experiments
+    end
+
+    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 )
+      end
+    end
+
+    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)
+      end
+    end
+
+    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 )
+      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(ab_combined_test('combined_exp_1')).to eq('test-alt')
+    end
+  end
+end

data/spec/dashboard/pagination_helpers_spec.rb

@@ -0,0 +1,198 @@
+require 'spec_helper'
+require 'split/dashboard/pagination_helpers'
+
+describe Split::DashboardPaginationHelpers do
+  include Split::DashboardPaginationHelpers
+
+  let(:url) { '/split/' }
+
+  describe '#pagination_per' do
+    context 'when params empty' do
+      let(:params) { Hash[] }
+
+      it 'returns 10' do
+        expect(pagination_per).to eql 10
+      end
+    end
+
+    context 'when params[:per] is 5' do
+      let(:params) { Hash[per: 5] }
+
+      it 'returns 5' do
+        expect(pagination_per).to eql 5
+      end
+    end
+  end
+
+  describe '#page_number' do
+    context 'when params empty' do
+      let(:params) { Hash[] }
+
+      it 'returns 1' do
+        expect(page_number).to eql 1
+      end
+    end
+
+    context 'when params[:page] is "2"' do
+      let(:params) { Hash[page: '2'] }
+
+      it 'returns 2' do
+        expect(page_number).to eql 2
+      end
+    end
+  end
+
+  describe '#paginated' do
+    let(:collection) { (1..20).to_a }
+    let(:params) { Hash[per: '5', page: '3'] }
+
+    it { expect(paginated(collection)).to eql [11, 12, 13, 14, 15] }
+  end
+
+  describe '#show_first_page_tag?' do
+    context 'when page is 1' do
+      it { expect(show_first_page_tag?).to be false }
+    end
+
+    context 'when page is 3' do
+      let(:params) { Hash[page: '3'] }
+      it { expect(show_first_page_tag?).to be true }
+    end
+  end
+
+  describe '#first_page_tag' do
+    it { expect(first_page_tag).to eql '<a href="/split?page=1&per=10">1</a>' }
+  end
+
+  describe '#show_first_ellipsis_tag?' do
+    context 'when page is 1' do
+      it { expect(show_first_ellipsis_tag?).to be false }
+    end
+
+    context 'when page is 4' do
+      let(:params) { Hash[page: '4'] }
+      it { expect(show_first_ellipsis_tag?).to be true }
+    end
+  end
+
+  describe '#ellipsis_tag' do
+    it { expect(ellipsis_tag).to eql '<span>...</span>' }
+  end
+
+  describe '#show_prev_page_tag?' do
+    context 'when page is 1' do
+      it { expect(show_prev_page_tag?).to be false }
+    end
+
+    context 'when page is 2' do
+      let(:params) { Hash[page: '2'] }
+      it { expect(show_prev_page_tag?).to be true }
+    end
+  end
+
+  describe '#prev_page_tag' do
+    context 'when page is 2' do
+      let(:params) { Hash[page: '2'] }
+
+      it do
+        expect(prev_page_tag).to eql '<a href="/split?page=1&per=10">1</a>'
+      end
+    end
+
+    context 'when page is 3' do
+      let(:params) { Hash[page: '3'] }
+
+      it do
+        expect(prev_page_tag).to eql '<a href="/split?page=2&per=10">2</a>'
+      end
+    end
+  end
+
+  describe '#show_prev_page_tag?' do
+    context 'when page is 1' do
+      it { expect(show_prev_page_tag?).to be false }
+    end
+
+    context 'when page is 2' do
+      let(:params) { Hash[page: '2'] }
+      it { expect(show_prev_page_tag?).to be true }
+    end
+  end
+
+  describe '#current_page_tag' do
+    context 'when page is 1' do
+      let(:params) { Hash[page: '1'] }
+      it { expect(current_page_tag).to eql '<span><b>1</b></span>' }
+    end
+
+    context 'when page is 2' do
+      let(:params) { Hash[page: '2'] }
+      it { expect(current_page_tag).to eql '<span><b>2</b></span>' }
+    end
+  end
+
+  describe '#show_next_page_tag?' do
+    context 'when page is 2' do
+      let(:params) { Hash[page: '2'] }
+
+      context 'when collection length is 20' do
+        let(:collection) { (1..20).to_a }
+        it { expect(show_next_page_tag?(collection)).to be false }
+      end
+
+      context 'when collection length is 25' do
+        let(:collection) { (1..25).to_a }
+        it { expect(show_next_page_tag?(collection)).to be true }
+      end
+    end
+  end
+
+  describe '#next_page_tag' do
+    context 'when page is 1' do
+      let(:params) { Hash[page: '1'] }
+      it { expect(next_page_tag).to eql '<a href="/split?page=2&per=10">2</a>' }
+    end
+
+    context 'when page is 2' do
+      let(:params) { Hash[page: '2'] }
+      it { expect(next_page_tag).to eql '<a href="/split?page=3&per=10">3</a>' }
+    end
+  end
+
+  describe '#total_pages' do
+    context 'when collection length is 30' do
+      let(:collection) { (1..30).to_a }
+      it { expect(total_pages(collection)).to eql 3 }
+    end
+
+    context 'when collection length is 35' do
+      let(:collection) { (1..35).to_a }
+      it { expect(total_pages(collection)).to eql 4 }
+    end
+  end
+
+  describe '#show_last_ellipsis_tag?' do
+    let(:collection) { (1..30).to_a }
+    let(:params) { Hash[per: '5', page: '2'] }
+    it { expect(show_last_ellipsis_tag?(collection)).to be true }
+  end
+
+  describe '#show_last_page_tag?' do
+    let(:collection) { (1..30).to_a }
+
+    context 'when page is 5/6' do
+      let(:params) { Hash[per: '5', page: '5'] }
+      it { expect(show_last_page_tag?(collection)).to be false }
+    end
+
+    context 'when page is 4/6' do
+      let(:params) { Hash[per: '5', page: '4'] }
+      it { expect(show_last_page_tag?(collection)).to be true }
+    end
+  end
+
+  describe '#last_page_tag' do
+    let(:collection) { (1..30).to_a }
+    it { expect(last_page_tag(collection)).to eql '<a href="/split?page=3&per=10">3</a>' }
+  end
+end

data/spec/dashboard/paginator_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+require 'spec_helper'
+require 'split/dashboard/paginator'
+
+describe Split::DashboardPaginator do
+  context 'when collection is 1..20' do
+    let(:collection) { (1..20).to_a }
+
+    context 'when per 5 for page' do
+      let(:per) { 5 }
+
+      it 'when page number is 1 result is [1, 2, 3, 4, 5]' do
+        result = Split::DashboardPaginator.new(collection, 1, per).paginate
+        expect(result).to eql [1, 2, 3, 4, 5]
+      end
+
+      it 'when page number is 2 result is [6, 7, 8, 9, 10]' do
+        result = Split::DashboardPaginator.new(collection, 2, per).paginate
+        expect(result).to eql [6, 7, 8, 9, 10]
+      end
+    end
+
+    context 'when per 10 for page' do
+      let(:per) { 10 }
+
+      it 'when page number is 1 result is [1..10]' do
+        result = Split::DashboardPaginator.new(collection, 1, per).paginate
+        expect(result).to eql [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+      end
+
+      it 'when page number is 2 result is [10..20]' do
+        result = Split::DashboardPaginator.new(collection, 2, per).paginate
+        expect(result).to eql [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
+      end
+    end
+  end
+end

data/spec/dashboard_helpers_spec.rb

@@ -24,5 +24,19 @@ describe Split::DashboardHelpers do
       expect(confidence_level(2.58)).to eq('99% confidence')
       expect(confidence_level(3.00)).to eq('99% confidence')
     end
+
+    describe '#round' do
+      it 'can round number strings' do
+        expect(round('3.1415')).to eq BigDecimal.new('3.14')
+      end
+
+      it 'can round number strings for precsion' do
+        expect(round('3.1415', 1)).to eq BigDecimal.new('3.1')
+      end
+
+      it 'can handle invalid number strings' do
+        expect(round('N/A')).to be_zero
+      end
+    end
   end
 end

data/spec/experiment_spec.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 require 'spec_helper'
-require 'split/experiment'
-require 'split/algorithms'
 require 'time'
 
 describe Split::Experiment do
@@ -460,7 +458,7 @@ describe Split::Experiment do
       expect(experiment.alternatives[0].p_winner).to be_within(0.04).of(0.50)
     end
 
-    it "should calculate the probability of being the winning alternative separately for each goal" do
+    it "should calculate the probability of being the winning alternative separately for each goal", :skip => true do
       experiment = Split::ExperimentCatalog.find_or_create({'link_color3' => ["purchase", "refund"]}, 'blue', 'red', 'green')
       goal1 = experiment.goals[0]
       goal2 = experiment.goals[1]

data/spec/helper_spec.rb

@@ -35,6 +35,18 @@ describe Split::Helper do
       expect(lambda { ab_test({'link_color' => "purchase"}, 'blue', 'red') }).not_to raise_error
     end
 
+    it "raises an appropriate error when processing combined expirements" do
+      Split.configuration.experiments = {
+        :combined_exp_1 => {
+          :alternatives => [  { name: "control", percent: 50 },  { name: "test-alt", percent: 50 } ],
+          :metric => :my_metric,
+          :combined_experiments => [:combined_exp_1_sub_1]
+        }
+      }
+      Split::ExperimentCatalog.find_or_create('combined_exp_1')
+      expect(lambda { ab_test('combined_exp_1')}).to raise_error(Split::InvalidExperimentsFormatError )
+    end
+
     it "should assign a random alternative to a new user when there are an equal number of alternatives assigned" do
       ab_test('link_color', 'blue', 'red')
       expect(['red', 'blue']).to include(ab_user['link_color'])
@@ -687,6 +699,14 @@ describe Split::Helper do
     end
   end
 
+  describe 'when user is previewing' do
+    before(:each) do
+      @request = OpenStruct.new(headers: { 'x-purpose' => 'preview' })
+    end
+
+    it_behaves_like "a disabled test"
+  end
+
   describe 'versioned experiments' do
     it "should use version zero if no version is present" do
       alternative_name = ab_test('link_color', 'blue', 'red')

data/spec/persistence/cookie_adapter_spec.rb

@@ -1,39 +1,106 @@
 # frozen_string_literal: true
 require "spec_helper"
+require 'rack/test'
 
 describe Split::Persistence::CookieAdapter do
+  subject { described_class.new(context) }
 
-  let(:context) { double(:cookies => CookiesMock.new) }
-  subject { Split::Persistence::CookieAdapter.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
 
-  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 "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
-  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.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(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

@@ -47,7 +47,7 @@ describe Split::Persistence::DualAdapter do
   context "when logged in" do
     subject {
       described_class.with_config(
-        logged_in: -> (context) { true },
+        logged_in: lambda { |context| true },
         logged_in_adapter: selected_adapter,
         logged_out_adapter: not_selected_adapter
         ).new(context)
@@ -59,7 +59,7 @@ describe Split::Persistence::DualAdapter do
   context "when not logged in" do
     subject {
       described_class.with_config(
-        logged_in: -> (context) { false },
+        logged_in: lambda { |context| false },
         logged_in_adapter: not_selected_adapter,
         logged_out_adapter: selected_adapter
         ).new(context)

data/spec/split_spec.rb

@@ -15,19 +15,19 @@ RSpec.describe Split do
       Split.redis = 'redis://localhost:6379'
       expect(Split.redis).to be_a(Redis)
 
-      client = Split.redis.client
-      expect(client.host).to eq("localhost")
-      expect(client.port).to eq(6379)
+      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.client
-      expect(client.host).to eq("localhost")
-      expect(client.port).to eq(6379)
-      expect(client.db).to eq(12)
+      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

data/split.gemspec

@@ -12,7 +12,17 @@ Gem::Specification.new do |s|
   s.homepage    = "https://github.com/splitrb/split"
   s.summary     = "Rack based split testing framework"
 
-  s.required_ruby_version = '>= 1.9.2'
+  s.metadata    = {
+   "homepage_uri" => "https://github.com/splitrb/split",
+   "changelog_uri" => "https://github.com/splitrb/split/blob/master/CHANGELOG.md",
+   "source_code_uri" => "https://github.com/splitrb/split",
+   "bug_tracker_uri" => "https://github.com/splitrb/split/issues",
+   "wiki_uri" => "https://github.com/splitrb/split/wiki",
+   "mailing_list_uri" => "https://groups.google.com/d/forum/split-ruby"
+ }
+
+  s.required_ruby_version = '>= 1.9.3'
+  s.required_rubygems_version = '>= 2.0.0'
 
   s.rubyforge_project = "split"
 
@@ -24,11 +34,11 @@ Gem::Specification.new do |s|
   s.add_dependency 'sinatra',         '>= 1.2.6'
   s.add_dependency 'simple-random',   '>= 0.9.3'
 
-  s.add_development_dependency 'bundler',     '~> 1.10'
-  s.add_development_dependency 'simplecov',   '~> 0.12'
+  s.add_development_dependency 'bundler',     '~> 1.14'
+  s.add_development_dependency 'simplecov',   '~> 0.15'
   s.add_development_dependency 'rack-test',   '~> 0.6'
-  s.add_development_dependency 'rake',        '~> 11.1'
-  s.add_development_dependency 'rspec',       '~> 3.4'
+  s.add_development_dependency 'rake',        '~> 12'
+  s.add_development_dependency 'rspec',       '~> 3.7'
   s.add_development_dependency 'pry',         '~> 0.10'
-  s.add_development_dependency 'fakeredis',   '~> 0.6.0'
+  s.add_development_dependency 'fakeredis',   '~> 0.7'
 end