split 3.3.2 → 3.4.0

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

data/spec/user_spec.rb

@@ -59,6 +59,17 @@ describe Split::User do
         expect(@subject.keys).to include("link_color:finished")
       end
     end
+
+    context 'when already cleaned up' do
+      before do
+        @subject.cleanup_old_experiments!
+      end
+
+      it 'does not clean up again' do
+        expect(@subject).to_not receive(:keys_without_finished)
+        @subject.cleanup_old_experiments!
+      end
+    end
   end
 
   context "instantiated with custom adapter" do

data/split.gemspec

@@ -1,4 +1,5 @@
 # -*- encoding: utf-8 -*-
+# frozen_string_literal: true
 $:.push File.expand_path("../lib", __FILE__)
 require "split/version"
 
@@ -24,8 +25,6 @@ Gem::Specification.new do |s|
   s.required_ruby_version = '>= 1.9.3'
   s.required_rubygems_version = '>= 2.0.0'
 
-  s.rubyforge_project = "split"
-
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.require_paths = ["lib"]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: split
 version: !ruby/object:Gem::Version
-  version: 3.3.2
+  version: 3.4.0
 platform: ruby
 authors:
 - Andrew Nesbitt
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-12 00:00:00.000000000 Z
+date: 2019-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -175,8 +175,11 @@ files:
 - ".csslintrc"
 - ".eslintignore"
 - ".eslintrc"
+- ".github/ISSUE_TEMPLATE/bug_report.md"
 - ".gitignore"
+- ".rspec"
 - ".rubocop.yml"
+- ".rubocop_todo.yml"
 - ".travis.yml"
 - Appraisals
 - CHANGELOG.md
@@ -284,8 +287,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 2.0.0
 requirements: []
-rubyforge_project: split
-rubygems_version: 2.7.6
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Rack based split testing framework