split 3.3.2 → 4.0.0.pre2

data/spec/helper_spec.rb

@@ -183,8 +183,7 @@ describe Split::Helper do
       ab_test('link_color', {'blue' => 0.01}, 'red' => 0.2)
       experiment = Split::ExperimentCatalog.find('link_color')
       expect(experiment.alternatives.map(&:name)).to eq(['blue', 'red'])
-      # TODO: persist alternative weights
-      # expect(experiment.alternatives.collect{|a| a.weight}).to eq([0.01, 0.2])
+      expect(experiment.alternatives.collect{|a| a.weight}).to match_array([0.01, 0.2])
     end
 
     it "should only let a user participate in one experiment at a time" do
@@ -230,13 +229,15 @@ describe Split::Helper do
 
       context "when user already has experiment" do
         let(:mock_user){ Split::User.new(self, {'test_0' => 'test-alt'}) }
-        before{
+
+        before do
           Split.configure do |config|
             config.allow_multiple_experiments = 'control'
           end
+
           Split::ExperimentCatalog.find_or_initialize('test_0', 'control', 'test-alt').save
           Split::ExperimentCatalog.find_or_initialize('test_1', 'control', 'test-alt').save
-        }
+        end
 
         it "should restore previously selected alternative" do
           expect(ab_user.active_experiments.size).to eq 1
@@ -244,6 +245,16 @@ describe Split::Helper do
           expect(ab_test(:test_0, {'control' => 1}, {"test-alt" => 100})).to eq 'test-alt'
         end
 
+        it "should select the correct alternatives after experiment resets" do
+          experiment = Split::ExperimentCatalog.find(:test_0)
+          experiment.reset
+          mock_user[experiment.key] = 'test-alt'
+
+          expect(ab_user.active_experiments.size).to eq 1
+          expect(ab_test(:test_0, {'control' => 100}, {"test-alt" => 1})).to eq 'test-alt'
+          expect(ab_test(:test_0, {'control' => 0}, {"test-alt" => 100})).to eq 'test-alt'
+        end
+
         it "lets override existing choice" do
           pending "this requires user store reset on first call not depending on whelther it is current trial"
           @params = { 'ab_test' => { 'test_1' => 'test-alt' } }
@@ -266,129 +277,187 @@ describe Split::Helper do
   end
 
   describe 'metadata' do
-    before do
-      Split.configuration.experiments = {
-        :my_experiment => {
-          :alternatives => ["one", "two"],
-          :resettable => false,
-          :metadata => { 'one' => 'Meta1', 'two' => 'Meta2' }
+    context 'is defined' do
+      before do
+        Split.configuration.experiments = {
+          :my_experiment => {
+            :alternatives => ["one", "two"],
+            :resettable => false,
+            :metadata => { 'one' => 'Meta1', 'two' => 'Meta2' }
+          }
         }
-      }
-    end
+      end
 
-    it 'should be passed to helper block' do
-      @params = { 'ab_test' => { 'my_experiment' => 'one' } }
-      expect(ab_test('my_experiment')).to eq 'one'
-      expect(ab_test('my_experiment') do |alternative, meta|
-        meta
-      end).to eq('Meta1')
+      it 'should be passed to helper block' do
+        @params = { 'ab_test' => { 'my_experiment' => 'two' } }
+        expect(ab_test('my_experiment')).to eq 'two'
+        expect(ab_test('my_experiment') do |alternative, meta|
+          meta
+        end).to eq('Meta2')
+      end
+
+      it 'should pass control metadata helper block if library disabled' do
+        Split.configure do |config|
+          config.enabled = false
+        end
+
+        expect(ab_test('my_experiment')).to eq 'one'
+        expect(ab_test('my_experiment') do |_, meta|
+          meta
+        end).to eq('Meta1')
+      end
     end
 
-    it 'should pass empty hash to helper block if library disabled' do
-      Split.configure do |config|
-        config.enabled = false
+    context 'is not defined' do
+      before do
+        Split.configuration.experiments = {
+          :my_experiment => {
+            :alternatives => ["one", "two"],
+            :resettable => false,
+            :metadata => nil
+          }
+        }
+      end
+
+      it 'should be passed to helper block' do
+        expect(ab_test('my_experiment') do |alternative, meta|
+          meta
+        end).to eq({})
       end
 
-      expect(ab_test('my_experiment')).to eq 'one'
-      expect(ab_test('my_experiment') do |_, meta|
-        meta
-      end).to eq({})
+      it 'should pass control metadata helper block if library disabled' do
+        Split.configure do |config|
+          config.enabled = false
+        end
+
+        expect(ab_test('my_experiment') do |_, meta|
+          meta
+        end).to eq({})
+      end
     end
   end
 
   describe 'ab_finished' do
-    before(:each) do
-      @experiment_name = 'link_color'
-      @alternatives = ['blue', 'red']
-      @experiment = Split::ExperimentCatalog.find_or_create(@experiment_name, *@alternatives)
-      @alternative_name = ab_test(@experiment_name, *@alternatives)
-      @previous_completion_count = Split::Alternative.new(@alternative_name, @experiment_name).completed_count
-    end
+    context 'for an experiment that the user participates in' do
+      before(:each) do
+        @experiment_name = 'link_color'
+        @alternatives = ['blue', 'red']
+        @experiment = Split::ExperimentCatalog.find_or_create(@experiment_name, *@alternatives)
+        @alternative_name = ab_test(@experiment_name, *@alternatives)
+        @previous_completion_count = Split::Alternative.new(@alternative_name, @experiment_name).completed_count
+      end
 
-    it 'should increment the counter for the completed alternative' do
-      ab_finished(@experiment_name)
-      new_completion_count = Split::Alternative.new(@alternative_name, @experiment_name).completed_count
-      expect(new_completion_count).to eq(@previous_completion_count + 1)
-    end
+      it 'should increment the counter for the completed alternative' do
+        ab_finished(@experiment_name)
+        new_completion_count = Split::Alternative.new(@alternative_name, @experiment_name).completed_count
+        expect(new_completion_count).to eq(@previous_completion_count + 1)
+      end
 
-    it "should set experiment's finished key if reset is false" do
-      ab_finished(@experiment_name, {:reset => false})
-      expect(ab_user[@experiment.key]).to eq(@alternative_name)
-      expect(ab_user[@experiment.finished_key]).to eq(true)
-    end
+      it "should set experiment's finished key if reset is false" do
+        ab_finished(@experiment_name, {:reset => false})
+        expect(ab_user[@experiment.key]).to eq(@alternative_name)
+        expect(ab_user[@experiment.finished_key]).to eq(true)
+      end
 
-    it 'should not increment the counter if reset is false and the experiment has been already finished' do
-      2.times { ab_finished(@experiment_name, {:reset => false}) }
-      new_completion_count = Split::Alternative.new(@alternative_name, @experiment_name).completed_count
-      expect(new_completion_count).to eq(@previous_completion_count + 1)
-    end
+      it 'should not increment the counter if reset is false and the experiment has been already finished' do
+        2.times { ab_finished(@experiment_name, {:reset => false}) }
+        new_completion_count = Split::Alternative.new(@alternative_name, @experiment_name).completed_count
+        expect(new_completion_count).to eq(@previous_completion_count + 1)
+      end
 
-    it 'should not increment the counter for an experiment that the user is not participating in' do
-      ab_test('button_size', 'small', 'big')
+      it 'should not increment the counter for an ended experiment' do
+        e = Split::ExperimentCatalog.find_or_create('button_size', 'small', 'big')
+        e.winner = 'small'
+        a = ab_test('button_size', 'small', 'big')
+        expect(a).to eq('small')
+        expect(lambda {
+          ab_finished('button_size')
+        }).not_to change { Split::Alternative.new(a, 'button_size').completed_count }
+      end
 
-      # So, user should be participating in the link_color experiment and
-      # receive the control for button_size. As the user is not participating in
-      # the button size experiment, finishing it should not increase the
-      # completion count for that alternative.
-      expect(lambda {
-        ab_finished('button_size')
-      }).not_to change { Split::Alternative.new('small', 'button_size').completed_count }
-    end
+      it "should clear out the user's participation from their session" do
+        expect(ab_user[@experiment.key]).to eq(@alternative_name)
+        ab_finished(@experiment_name)
+        expect(ab_user.keys).to be_empty
+      end
 
-    it 'should not increment the counter for an ended experiment' do
-      e = Split::ExperimentCatalog.find_or_create('button_size', 'small', 'big')
-      e.winner = 'small'
-      a = ab_test('button_size', 'small', 'big')
-      expect(a).to eq('small')
-      expect(lambda {
-        ab_finished('button_size')
-      }).not_to change { Split::Alternative.new(a, 'button_size').completed_count }
-    end
+      it "should not clear out the users session if reset is false" do
+        expect(ab_user[@experiment.key]).to eq(@alternative_name)
+        ab_finished(@experiment_name, {:reset => false})
+        expect(ab_user[@experiment.key]).to eq(@alternative_name)
+        expect(ab_user[@experiment.finished_key]).to eq(true)
+      end
 
-    it "should clear out the user's participation from their session" do
-      expect(ab_user[@experiment.key]).to eq(@alternative_name)
-      ab_finished(@experiment_name)
-      expect(ab_user.keys).to be_empty
-    end
+      it "should reset the users session when experiment is not versioned" do
+        expect(ab_user[@experiment.key]).to eq(@alternative_name)
+        ab_finished(@experiment_name)
+        expect(ab_user.keys).to be_empty
+      end
 
-    it "should not clear out the users session if reset is false" do
-      expect(ab_user[@experiment.key]).to eq(@alternative_name)
-      ab_finished(@experiment_name, {:reset => false})
-      expect(ab_user[@experiment.key]).to eq(@alternative_name)
-      expect(ab_user[@experiment.finished_key]).to eq(true)
-    end
+      it "should reset the users session when experiment is versioned" do
+        @experiment.increment_version
+        @alternative_name = ab_test(@experiment_name, *@alternatives)
 
-    it "should reset the users session when experiment is not versioned" do
-      expect(ab_user[@experiment.key]).to eq(@alternative_name)
-      ab_finished(@experiment_name)
-      expect(ab_user.keys).to be_empty
-    end
+        expect(ab_user[@experiment.key]).to eq(@alternative_name)
+        ab_finished(@experiment_name)
+        expect(ab_user.keys).to be_empty
+      end
 
-    it "should reset the users session when experiment is versioned" do
-      @experiment.increment_version
-      @alternative_name = ab_test(@experiment_name, *@alternatives)
+      context "when on_trial_complete is set" do
+        before { Split.configuration.on_trial_complete = :some_method }
+        it "should call the method" do
+          expect(self).to receive(:some_method)
+          ab_finished(@experiment_name)
+        end
 
-      expect(ab_user[@experiment.key]).to eq(@alternative_name)
-      ab_finished(@experiment_name)
-      expect(ab_user.keys).to be_empty
+        it "should not call the method without alternative" do
+          ab_user[@experiment.key] = nil
+          expect(self).not_to receive(:some_method)
+          ab_finished(@experiment_name)
+        end
+      end
     end
 
-    it "should do nothing where the experiment was not started by this user" do
-      ab_user = nil
-      expect(lambda { ab_finished('some_experiment_not_started_by_the_user') }).not_to raise_exception
+    context 'for an experiment that the user is excluded from' do
+      before do
+        alternative = ab_test('link_color', 'blue', 'red')
+        expect(Split::Alternative.new(alternative, 'link_color').participant_count).to eq(1)
+        alternative = ab_test('button_size', 'small', 'big')
+        expect(Split::Alternative.new(alternative, 'button_size').participant_count).to eq(0)
+      end
+
+      it 'should not increment the completed counter' do
+        # So, user should be participating in the link_color experiment and
+        # receive the control for button_size. As the user is not participating in
+        # the button size experiment, finishing it should not increase the
+        # completion count for that alternative.
+        expect(lambda {
+          ab_finished('button_size')
+        }).not_to change { Split::Alternative.new('small', 'button_size').completed_count }
+      end
     end
 
-    context "when on_trial_complete is set" do
-      before { Split.configuration.on_trial_complete = :some_method }
-      it "should call the method" do
-        expect(self).to receive(:some_method)
-        ab_finished(@experiment_name)
+    context 'for an experiment that the user does not participate in' do
+      before do
+        Split::ExperimentCatalog.find_or_create(:not_started_experiment, 'control', 'alt')
+      end
+      it 'should not raise an exception' do
+        expect { ab_finished(:not_started_experiment) }.not_to raise_exception
       end
 
-      it "should not call the method without alternative" do
-        ab_user[@experiment.key] = nil
-        expect(self).not_to receive(:some_method)
-        ab_finished(@experiment_name)
+      it 'should not change the user state when reset is false' do
+        expect { ab_finished(:not_started_experiment, reset: false) }.not_to change { ab_user.keys}.from([])
+      end
+
+      it 'should not change the user state when reset is true' do
+        expect(self).not_to receive(:reset!)
+        ab_finished(:not_started_experiment)
+      end
+
+      it 'should not increment the completed counter' do
+        ab_finished(:not_started_experiment)
+        expect(Split::Alternative.new('control', :not_started_experiment).completed_count).to eq(0)
+        expect(Split::Alternative.new('alt', :not_started_experiment).completed_count).to eq(0)
       end
     end
   end
@@ -528,6 +597,17 @@ describe Split::Helper do
       expect(active_experiments.first[0]).to eq "link_color"
     end
 
+    it 'should show versioned tests properly' do
+      10.times { experiment.reset }
+
+      alternative = ab_test(experiment.name, 'blue', 'red')
+      ab_finished(experiment.name, reset: false)
+
+      expect(experiment.version).to eq(10)
+      expect(active_experiments.count).to eq 1
+      expect(active_experiments).to eq({'link_color' => alternative })
+    end
+
     it 'should show multiple tests' do
       Split.configure do |config|
         config.allow_multiple_experiments = true
@@ -545,7 +625,7 @@ describe Split::Helper do
       end
       e = Split::ExperimentCatalog.find_or_create('def', '4', '5', '6')
       e.winner = '4'
-      alternative = ab_test('def', '4', '5', '6')
+      ab_test('def', '4', '5', '6')
       another_alternative = ab_test('ghi', '7', '8', '9')
       expect(active_experiments.count).to eq 1
       expect(active_experiments.first[0]).to eq "ghi"
@@ -1021,8 +1101,8 @@ describe Split::Helper do
 
   it 'should handle multiple experiments correctly' do
     experiment2 = Split::ExperimentCatalog.find_or_create('link_color2', 'blue', 'red')
-    alternative_name = ab_test('link_color', 'blue', 'red')
-    alternative_name2 = ab_test('link_color2', 'blue', 'red')
+    ab_test('link_color', 'blue', 'red')
+    ab_test('link_color2', 'blue', 'red')
     ab_finished('link_color2')
 
     experiment2.alternatives.each do |alt|
@@ -1058,15 +1138,9 @@ describe Split::Helper do
       end
 
       it "should increment the counter for the specified-goal completed alternative" do
-        expect(lambda {
-          expect(lambda {
-            ab_finished({"link_color" => ["purchase"]})
-          }).not_to change {
-            Split::Alternative.new(@alternative_name, @experiment_name).completed_count(@goal2)
-          }
-        }).to change {
-          Split::Alternative.new(@alternative_name, @experiment_name).completed_count(@goal1)
-        }.by(1)
+        expect{ ab_finished({"link_color" => ["purchase"]}) }
+          .to change{ Split::Alternative.new(@alternative_name, @experiment_name).completed_count(@goal2) }.by(0)
+          .and change{ Split::Alternative.new(@alternative_name, @experiment_name).completed_count(@goal1) }.by(1)
       end
     end
   end

data/spec/persistence/cookie_adapter_spec.rb

@@ -52,7 +52,7 @@ describe Split::Persistence::CookieAdapter do
     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/)
+      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} [A-Z]{3}\Z/)
     end
 
     it "ensure other added cookies are not overriden" do

data/spec/persistence/dual_adapter_spec.rb

@@ -1,102 +1,194 @@
 # frozen_string_literal: true
-require "spec_helper"
+
+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){ ->{} }
-    it "when no logged in adapter" do
+  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: 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
+
+    it 'when no logged out adapter' do
       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
+
+    it 'when no logged in detector' do
       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