active_remote-cached 1.1.1 → 1.2.0

data/spec/active_remote/cached/cache_spec.rb

@@ -3,30 +3,196 @@
 require 'spec_helper'
 
 describe ::ActiveRemote::Cached::Cache do
+  let(:invalid_provider_error) { ::ActiveRemote::Cached::Cache::InvalidCacheProvider }
+  let(:cache_provider) { ::ActiveSupport::Cache::MemoryStore.new }
+  let(:cache) { ::ActiveRemote::Cached::Cache.new(cache_provider) }
+
   describe 'API' do
     it 'validates #delete present' do
       cache = OpenStruct.new(:write => nil, :fetch => nil, :read => nil, :exist? => nil)
-      expect { ::ActiveRemote::Cached.cache(cache) }.to raise_error(RuntimeError, /respond_to.*delete/i)
+      expect { ::ActiveRemote::Cached.cache(cache) }.to raise_error(invalid_provider_error, /respond_to.*delete/i)
     end
 
     it 'validates #exist? present' do
       cache = OpenStruct.new(:write => nil, :delete => nil, :read => nil, :fetch => nil)
-      expect { ::ActiveRemote::Cached.cache(cache) }.to raise_error(RuntimeError, /respond_to.*exist/i)
+      expect { ::ActiveRemote::Cached.cache(cache) }.to raise_error(invalid_provider_error, /respond_to.*exist/i)
     end
 
     it 'validates #fetch present' do
       cache = OpenStruct.new(:write => nil, :delete => nil, :read => nil, :exist? => nil)
-      expect { ::ActiveRemote::Cached.cache(cache) }.to raise_error(RuntimeError, /respond_to.*fetch/i)
+      expect { ::ActiveRemote::Cached.cache(cache) }.to raise_error(invalid_provider_error, /respond_to.*fetch/i)
     end
 
     it 'validates #read present' do
       cache = OpenStruct.new(:write => nil, :delete => nil, :fetch => nil, :exist? => nil)
-      expect { ::ActiveRemote::Cached.cache(cache) }.to raise_error(RuntimeError, /respond_to.*read/i)
+      expect { ::ActiveRemote::Cached.cache(cache) }.to raise_error(invalid_provider_error, /respond_to.*read/i)
     end
 
     it 'validates #write present' do
       cache = OpenStruct.new(:read => nil, :delete => nil, :fetch => nil, :exist? => nil)
-      expect { ::ActiveRemote::Cached.cache(cache) }.to raise_error(RuntimeError, /respond_to.*write/i)
+      expect { ::ActiveRemote::Cached.cache(cache) }.to raise_error(invalid_provider_error, /respond_to.*write/i)
+    end
+  end
+
+  describe '#nested_caching?' do
+    it 'is false before nested caching is enabled' do
+      expect(cache.nested_caching?).to eq(false)
+    end
+  end
+
+  describe 'delegation' do
+    it 'exposes the cache provider it was given' do
+      expect(cache.cache_provider).to be(cache_provider)
+    end
+
+    it 'delegates unknown methods to the cache provider' do
+      expect(cache_provider).to receive(:clear).and_return(:cleared)
+      expect(cache.clear).to eq(:cleared)
+    end
+  end
+
+  describe '#fetch' do
+    it 'returns a nil value but does not persist it by default' do
+      expect(cache.fetch('key') { nil }).to be_nil
+      expect(cache_provider.exist?('key')).to eq(false)
+    end
+
+    it 'returns an empty value but does not persist it by default' do
+      expect(cache.fetch('key') { [] }).to eq([])
+      expect(cache_provider.exist?('key')).to eq(false)
+    end
+
+    it 'persists a nil value when :allow_nil is given' do
+      expect(cache.fetch('key', :allow_nil => true) { nil }).to be_nil
+      expect(cache_provider.exist?('key')).to eq(true)
+    end
+
+    it 'persists an empty value when :allow_empty is given' do
+      expect(cache.fetch('key', :allow_empty => true) { [] }).to eq([])
+      expect(cache_provider.exist?('key')).to eq(true)
+    end
+
+    it 'persists a value that is neither nil nor empty' do
+      expect(cache.fetch('key') { [:record] }).to eq([:record])
+      expect(cache_provider.exist?('key')).to eq(true)
+    end
+  end
+
+  describe '#fetch round trips' do
+    let(:counting_provider) do
+      Class.new(::ActiveSupport::Cache::MemoryStore) do
+        def initialize(*args)
+          @calls = []
+          super
+        end
+
+        attr_reader :calls
+
+        def fetch(*args, **options, &block)
+          @calls << :fetch
+          super
+        end
+
+        def write(*args, **options)
+          @calls << :write
+          super
+        end
+
+        def delete(*args, **options)
+          @calls << :delete
+          super
+        end
+      end.new
+    end
+
+    # The provider used to write the nil and then take a second round trip to
+    # delete it. :skip_nil makes the provider skip the write.
+    it 'takes one provider call for a nil value' do
+      cache = ::ActiveRemote::Cached::Cache.new(counting_provider)
+
+      cache.fetch('key') { nil }
+
+      expect(counting_provider.calls).to eq([:fetch])
+    end
+
+    it 'still writes a nil when :allow_nil is given' do
+      cache = ::ActiveRemote::Cached::Cache.new(counting_provider)
+
+      cache.fetch('key', :allow_nil => true) { nil }
+
+      expect(counting_provider.calls).to eq(%i[fetch write])
+      expect(counting_provider.exist?('key')).to eq(true)
+    end
+  end
+
+  describe '#enable_nested_caching!' do
+    it 'writes to the cache provider only until nested caching is enabled' do
+      cache.write('key', 'value')
+
+      expect(cache_provider.read('key')).to eq('value')
+    end
+
+    context 'when nested caching is enabled' do
+      before do
+        cache.enable_nested_caching!
+      end
+
+      it 'writes to both the nested cache and the cache provider' do
+        cache.write('key', 'value')
+
+        expect(cache.read('key')).to eq('value')
+        expect(cache_provider.read('key')).to eq('value')
+      end
+
+      it 'deletes from both the nested cache and the cache provider' do
+        cache.write('key', 'value')
+        cache.delete('key')
+
+        expect(cache.read('key')).to be_nil
+        expect(cache_provider.read('key')).to be_nil
+      end
+
+      it 'reads the nested value in preference to the cache provider value' do
+        cache.write('key', 'nested')
+        cache_provider.write('key', 'provider')
+
+        expect(cache.read('key')).to eq('nested')
+      end
+
+      it 'reports a key that only the cache provider holds' do
+        cache_provider.write('key', 'provider')
+
+        expect(cache.exist?('key')).to eq(true)
+      end
+
+      it 'reports that nested caching is on' do
+        expect(cache.nested_caching?).to eq(true)
+      end
+
+      # A new Cache starts with nested caching off, so swapping the provider
+      # used to turn the setting off without saying so.
+      it 'keeps nested caching on when the cache provider is replaced' do
+        original_cache = ::ActiveRemote::Cached.cache
+
+        ::ActiveRemote::Cached.cache(cache_provider)
+        ::ActiveRemote::Cached.cache.enable_nested_caching!
+        ::ActiveRemote::Cached.cache(::ActiveSupport::Cache::MemoryStore.new)
+
+        expect(::ActiveRemote::Cached.cache.nested_caching?).to eq(true)
+      ensure
+        # .cache now carries the nested setting forward, so reset the module
+        # rather than call it again.
+        ::ActiveRemote::Cached.instance_variable_set(:@cache_provider, original_cache)
+      end
+
+      # #read joins the two providers with ||, so a false value in the nested
+      # cache falls through to the cache provider. This records that behavior.
+      it 'falls through to the cache provider when the nested value is false' do
+        cache.write('key', false)
+        cache_provider.write('key', 'provider')
+
+        expect(cache.read('key')).to eq('provider')
+      end
     end
   end
 end

data/spec/active_remote/cached_delete_methods_spec.rb

@@ -5,12 +5,12 @@ require 'spec_helper'
 class DeleteMethodClass
   include ::ActiveRemote::Cached
 
-  def self.find
-    nil
+  def self.find(*)
+    :record
   end
 
-  def self.search
-    nil
+  def self.search(*)
+    [:record]
   end
 
   cached_finders_for :guid
@@ -49,4 +49,51 @@ describe DeleteMethodClass do
       expect(DeleteMethodClass).to respond_to(:cached_delete_by_client_guid_and_user_guid_and_derp)
     end
   end
+
+  describe '#cached_delete_by_guid' do
+    before do
+      ::ActiveRemote::Cached.cache(HashCache.new)
+    end
+
+    after do
+      ::ActiveRemote::Cached.default_options({})
+    end
+
+    it 'deletes the find cache key' do
+      DeleteMethodClass.cached_find_by_guid(:guid)
+      expect(DeleteMethodClass.cached_exist_find_by_guid?(:guid)).to eq(true)
+
+      DeleteMethodClass.cached_delete_by_guid(:guid)
+
+      expect(DeleteMethodClass.cached_exist_find_by_guid?(:guid)).to eq(false)
+    end
+
+    it 'deletes the search cache key' do
+      DeleteMethodClass.cached_search_by_guid(:guid)
+      expect(DeleteMethodClass.cached_exist_search_by_guid?(:guid)).to eq(true)
+
+      DeleteMethodClass.cached_delete_by_guid(:guid)
+
+      expect(DeleteMethodClass.cached_exist_search_by_guid?(:guid)).to eq(false)
+    end
+
+    it 'does not raise when the cache keys are not present' do
+      expect { DeleteMethodClass.cached_delete_by_guid(:missing) }.not_to raise_error
+    end
+
+    describe 'namespaced cache' do
+      it 'deletes the namespaced find and search cache keys' do
+        expect(::ActiveRemote::Cached.cache).to receive(:delete).with(
+          [::ActiveRemote::Cached::RUBY_AND_ACTIVE_SUPPORT_VERSION, 'MyApp', DeleteMethodClass.name, '#find',
+           'guid.guid']
+        )
+        expect(::ActiveRemote::Cached.cache).to receive(:delete).with(
+          [::ActiveRemote::Cached::RUBY_AND_ACTIVE_SUPPORT_VERSION, 'MyApp', DeleteMethodClass.name, '#search',
+           'guid.guid']
+        )
+
+        DeleteMethodClass.cached_delete_by_guid(:guid, :namespace => 'MyApp')
+      end
+    end
+  end
 end

data/spec/active_remote/cached_exist_methods_spec.rb

@@ -5,12 +5,12 @@ require 'spec_helper'
 class ExistMethodClass
   include ::ActiveRemote::Cached
 
-  def self.find
-    nil
+  def self.find(*)
+    :record
   end
 
-  def self.search
-    nil
+  def self.search(*)
+    [:record]
   end
 
   cached_finders_for :guid
@@ -134,4 +134,75 @@ describe ExistMethodClass do
       expect(ExistMethodClass).to respond_to(:cached_exist_search_by_client_guid_and_user_guid_and_derp?)
     end
   end
+
+  describe '#cached_exist_find_by_guid?' do
+    before do
+      ::ActiveRemote::Cached.cache(HashCache.new)
+    end
+
+    after do
+      ::ActiveRemote::Cached.default_options({})
+    end
+
+    it 'returns false before the find cache key is written' do
+      expect(ExistMethodClass.cached_exist_find_by_guid?(:guid)).to eq(false)
+    end
+
+    it 'returns true after the find cache key is written' do
+      ExistMethodClass.cached_find_by_guid(:guid)
+
+      expect(ExistMethodClass.cached_exist_find_by_guid?(:guid)).to eq(true)
+    end
+
+    it 'returns the same result as the method without the question mark' do
+      ExistMethodClass.cached_find_by_guid(:guid)
+
+      expect(ExistMethodClass.cached_exist_find_by_guid(:guid)).to eq(
+        ExistMethodClass.cached_exist_find_by_guid?(:guid)
+      )
+    end
+
+    it 'ignores a search cache key for the same arguments' do
+      ExistMethodClass.cached_search_by_guid(:guid)
+
+      expect(ExistMethodClass.cached_exist_find_by_guid?(:guid)).to eq(false)
+    end
+
+    describe 'namespaced cache' do
+      it 'uses the namespace as a prefix to the cache key' do
+        expect(::ActiveRemote::Cached.cache).to receive(:exist?).with(
+          [::ActiveRemote::Cached::RUBY_AND_ACTIVE_SUPPORT_VERSION, 'MyApp', ExistMethodClass.name, '#find',
+           'guid.guid']
+        ).and_return(true)
+
+        expect(ExistMethodClass.cached_exist_find_by_guid?(:guid, :namespace => 'MyApp')).to eq(true)
+      end
+    end
+  end
+
+  describe '#cached_exist_search_by_guid?' do
+    before do
+      ::ActiveRemote::Cached.cache(HashCache.new)
+    end
+
+    after do
+      ::ActiveRemote::Cached.default_options({})
+    end
+
+    it 'returns false before the search cache key is written' do
+      expect(ExistMethodClass.cached_exist_search_by_guid?(:guid)).to eq(false)
+    end
+
+    it 'returns true after the search cache key is written' do
+      ExistMethodClass.cached_search_by_guid(:guid)
+
+      expect(ExistMethodClass.cached_exist_search_by_guid?(:guid)).to eq(true)
+    end
+
+    it 'ignores a find cache key for the same arguments' do
+      ExistMethodClass.cached_find_by_guid(:guid)
+
+      expect(ExistMethodClass.cached_exist_search_by_guid?(:guid)).to eq(false)
+    end
+  end
 end

data/spec/active_remote/cached_find_methods_spec.rb

@@ -21,9 +21,7 @@ class FindMethodClass
 end
 
 describe FindMethodClass do
-  let(:versioned_prefix) do
-    "#{RUBY_ENGINE_VERSION}:#{ActiveSupport::VERSION::STRING}"
-  end
+  let(:versioned_prefix) { ::ActiveRemote::Cached::RUBY_AND_ACTIVE_SUPPORT_VERSION }
 
   describe 'API' do
     it "creates 'cached_find_by_foo'" do
@@ -81,7 +79,7 @@ describe FindMethodClass do
 
     it 'merges the default options in for the fetch call' do
       expect(::ActiveRemote::Cached.cache).to receive(:fetch).with(
-        [versioned_prefix, FindMethodClass.name, '#find', 'guid'], { :expires_in => 100 }
+        [versioned_prefix, FindMethodClass.name, '#find', 'guid.guid'], { :expires_in => 100 }
       ).and_return(:hello)
       expect(FindMethodClass).not_to receive(:find)
       expect(FindMethodClass.cached_find_by_guid(:guid)).to eq(:hello)
@@ -89,7 +87,7 @@ describe FindMethodClass do
 
     it 'overrides the default options with local options for the fetch call' do
       expect(::ActiveRemote::Cached.cache).to receive(:fetch).with(
-        [versioned_prefix, FindMethodClass.name, '#find', 'guid'], { :expires_in => 200 }
+        [versioned_prefix, FindMethodClass.name, '#find', 'guid.guid'], { :expires_in => 200 }
       ).and_return(:hello)
       expect(FindMethodClass).not_to receive(:find)
 
@@ -103,7 +101,7 @@ describe FindMethodClass do
 
       it 'uses the namespace as a prefix to the cache key' do
         expect(::ActiveRemote::Cached.cache).to receive(:fetch).with(
-          [versioned_prefix, 'MyApp', FindMethodClass.name, '#find', 'guid'], { :expires_in => 100 }
+          [versioned_prefix, 'MyApp', FindMethodClass.name, '#find', 'guid.guid'], { :expires_in => 100 }
         ).and_return(:hello)
 
         expect(FindMethodClass).not_to receive(:find)
@@ -124,7 +122,7 @@ describe FindMethodClass do
 
     it 'overrides the default options with cached_finder options for the fetch call' do
       expect(::ActiveRemote::Cached.cache).to receive(:fetch).with(
-        [versioned_prefix, FindMethodClass.name, '#find', 'foo'], { :expires_in => 500 }
+        [versioned_prefix, FindMethodClass.name, '#find', 'foo.foo'], { :expires_in => 500 }
       ).and_return(:hello)
 
       expect(FindMethodClass).not_to receive(:find)
@@ -133,7 +131,7 @@ describe FindMethodClass do
 
     it 'overrides the cached_finder options with local options for the fetch call' do
       expect(::ActiveRemote::Cached.cache).to receive(:fetch).with(
-        [versioned_prefix, FindMethodClass.name, '#find', 'foo'], { :expires_in => 200 }
+        [versioned_prefix, FindMethodClass.name, '#find', 'foo.foo'], { :expires_in => 200 }
       ).and_return(:hello)
 
       expect(FindMethodClass).not_to receive(:find)

data/spec/active_remote/cached_search_methods_spec.rb

@@ -26,9 +26,7 @@ class SearchMethodClass
 end
 
 describe SearchMethodClass do
-  let(:versioned_prefix) do
-    "#{RUBY_ENGINE_VERSION}:#{ActiveSupport::VERSION::STRING}"
-  end
+  let(:versioned_prefix) { ::ActiveRemote::Cached::RUBY_AND_ACTIVE_SUPPORT_VERSION }
 
   describe 'API' do
     it "creates 'cached_search_by_foo'" do
@@ -166,7 +164,7 @@ describe SearchMethodClass do
 
     it 'merges the default options in for the fetch call' do
       expect(::ActiveRemote::Cached.cache).to receive(:fetch).with(
-        [versioned_prefix, SearchMethodClass.name, '#search', 'guid'], { :expires_in => 100 }
+        [versioned_prefix, SearchMethodClass.name, '#search', 'guid.guid'], { :expires_in => 100 }
       ).and_return(:hello)
 
       expect(SearchMethodClass).not_to receive(:search)
@@ -175,7 +173,7 @@ describe SearchMethodClass do
 
     it 'overrides the default options with local options for the fetch call' do
       expect(::ActiveRemote::Cached.cache).to receive(:fetch).with(
-        [versioned_prefix, SearchMethodClass.name, '#search', 'guid'], { :expires_in => 200 }
+        [versioned_prefix, SearchMethodClass.name, '#search', 'guid.guid'], { :expires_in => 200 }
       ).and_return(:hello)
 
       expect(SearchMethodClass).not_to receive(:search)
@@ -189,7 +187,7 @@ describe SearchMethodClass do
 
       it 'uses the namespace as a prefix to the cache key' do
         expect(::ActiveRemote::Cached.cache).to receive(:fetch).with(
-          [versioned_prefix, 'MyApp', SearchMethodClass.name, '#search', 'guid'], { :expires_in => 100 }
+          [versioned_prefix, 'MyApp', SearchMethodClass.name, '#search', 'guid.guid'], { :expires_in => 100 }
         ).and_return(:hello)
 
         expect(SearchMethodClass).not_to receive(:search)
@@ -210,7 +208,7 @@ describe SearchMethodClass do
 
     it 'overrides the default options with cached_finder options for the fetch call' do
       expect(::ActiveRemote::Cached.cache).to receive(:fetch).with(
-        [versioned_prefix, SearchMethodClass.name, '#search', 'foo'], { :expires_in => 500 }
+        [versioned_prefix, SearchMethodClass.name, '#search', 'foo.foo'], { :expires_in => 500 }
       ).and_return(:hello)
 
       expect(SearchMethodClass).not_to receive(:find)
@@ -219,7 +217,7 @@ describe SearchMethodClass do
 
     it 'overrides the cached_finder options with local options for the fetch call' do
       expect(::ActiveRemote::Cached.cache).to receive(:fetch).with(
-        [versioned_prefix, SearchMethodClass.name, '#search', 'foo'], { :expires_in => 200 }
+        [versioned_prefix, SearchMethodClass.name, '#search', 'foo.foo'], { :expires_in => 200 }
       ).and_return(:hello)
 
       expect(SearchMethodClass).not_to receive(:find)
@@ -248,6 +246,57 @@ describe SearchMethodClass do
         SearchMethodClass.cached_search_by_foo!(:foo, :expires_in => 200)
       end.to raise_error ::ActiveRemote::RemoteRecordNotFound
     end
+
+    it 'raises ActiveRemote::RemoteRecordNotFound when the block returns no results' do
+      expect(SearchMethodClass).not_to receive(:search)
+      expect do
+        SearchMethodClass.cached_search_by_foo!(:foo) { [] }
+      end.to raise_error ::ActiveRemote::RemoteRecordNotFound
+    end
+
+    it 'raises ActiveRemote::RemoteRecordNotFound when the first result is nil' do
+      expect(SearchMethodClass).not_to receive(:search)
+      expect do
+        SearchMethodClass.cached_search_by_foo!(:foo) { [nil] }
+      end.to raise_error ::ActiveRemote::RemoteRecordNotFound
+    end
+
+    it 'raises ActiveRemote::RemoteRecordNotFound when the results are nil' do
+      expect(SearchMethodClass).to receive(:search).and_return(nil)
+      expect do
+        SearchMethodClass.cached_search_by_foo!(:foo)
+      end.to raise_error ::ActiveRemote::RemoteRecordNotFound
+    end
+
+    it 'names the model class in the error' do
+      expect(SearchMethodClass).to receive(:search).and_return([])
+      expect do
+        SearchMethodClass.cached_search_by_foo!(:foo)
+      end.to raise_error(::ActiveRemote::RemoteRecordNotFound, /SearchMethodClass/)
+    end
+
+    it 'reports the model class on the error' do
+      expect(SearchMethodClass).to receive(:search).and_return([])
+
+      SearchMethodClass.cached_search_by_foo!(:foo)
+    rescue ::ActiveRemote::RemoteRecordNotFound => e
+      expect(e.remote_record_class).to eq(SearchMethodClass)
+    end
+
+    it 'does not cache the results when it raises' do
+      expect do
+        SearchMethodClass.cached_search_by_foo!(:foo) { [] }
+      end.to raise_error ::ActiveRemote::RemoteRecordNotFound
+
+      expect(SearchMethodClass.cached_exist_search_by_foo?(:foo)).to eq(false)
+    end
+
+    it 'caches the results when they are present' do
+      expect(SearchMethodClass).to receive(:search).once.and_return([:hello])
+
+      expect(SearchMethodClass.cached_search_by_foo!(:foo)).to eq([:hello])
+      expect(SearchMethodClass.cached_search_by_foo!(:foo)).to eq([:hello])
+    end
   end
 
   # This tests the method_missing override