Improve Dual Adapter

Author: santib

lib/split/persistence/dual_adapter.rb

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
-require 'forwardable'
-
 module Split
   module Persistence
     class DualAdapter
-      extend Forwardable
-      def_delegators :@adapter, :keys, :[], :[]=, :delete
+      def self.with_config(options={})
+        self.config.merge!(options)
+        self
+      end
+
+      def self.config
+        @config ||= {}
+      end
 
       def initialize(context)
         if logged_in = self.class.config[:logged_in]
@@ -22,22 +26,28 @@ def initialize(context)
           raise "Please configure :logged_out_adapter"
         end
 
-        if logged_in.call(context)
-          @adapter = logged_in_adapter.new(context)
-        else
-          @adapter = logged_out_adapter.new(context)
-        end
+        @logged_in = logged_in.call(context)
+        @logged_in_adapter = logged_in_adapter.new(context)
+        @logged_out_adapter = logged_out_adapter.new(context)
       end
 
-      def self.with_config(options={})
-        self.config.merge!(options)
-        self
+      def keys
+        @logged_in_adapter.keys + @logged_out_adapter.keys
       end
 
-      def self.config
-        @config ||= {}
+      def [](key)
+        @logged_in && @logged_in_adapter[key] || @logged_out_adapter[key]
+      end
+
+      def []=(key, value)
+        @logged_in_adapter[key] = value if @logged_in
+        @logged_out_adapter[key] = value
       end
 
+      def delete(key)
+        @logged_in_adapter.delete(key)
+        @logged_out_adapter.delete(key)
+      end
     end
   end
 end

spec/persistence/dual_adapter_spec.rb

@@ -1,102 +1,116 @@
 # 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')
+  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
+      ).new(context)
     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 '#[]=' 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')
+      subject['my_key'] = 'my_value'
     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')
+    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
-  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
-        ).new(context)
-    }
+    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'] }
+      expect(subject.keys).to eq(['my_value', 'my_value'])
+    end
   end
 
-  context "when not logged in" do
-    subject {
+  context 'when logged out' do
+    subject do
       described_class.with_config(
         logged_in: lambda { |context| false },
-        logged_in_adapter: not_selected_adapter,
-        logged_out_adapter: selected_adapter
-        ).new(context)
-    }
+        logged_in_adapter: logged_in_adapter,
+        logged_out_adapter: logged_out_adapter
+      ).new(context)
+    end
 
-    it_should_behave_like "forwarding calls"
+    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(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'] }
+      expect(subject.keys).to eq(['my_value', 'my_value'])
+    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