active_remote-cached 1.0.0 → 1.2.0

data/spec/active_remote/cached/argument_keys_spec.rb

@@ -1,25 +1,151 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ::ActiveRemote::Cached::ArgumentKeys do
-  it "does not mutate a string by default" do
-    ::ActiveRemote::Cached::ArgumentKeys.new("hello", {}).cache_key.must_equal("hello")
+  it 'does not mutate a string by default' do
+    expect(::ActiveRemote::Cached::ArgumentKeys.new('hello', {}).cache_key).to eq('hello')
   end
 
-  it "returns a string of a symbol by default" do
-    ::ActiveRemote::Cached::ArgumentKeys.new(:hello, {}).cache_key.must_equal("hello")
+  it 'returns a string of a symbol by default' do
+    expect(::ActiveRemote::Cached::ArgumentKeys.new(:hello, {}).cache_key).to eq('hello')
   end
 
-  it "does not mutate a string with special characters by default" do
-    ::ActiveRemote::Cached::ArgumentKeys.new("hello {}", {}).cache_key.must_equal("hello {}")
+  it 'does not mutate a string with special characters by default' do
+    expect(::ActiveRemote::Cached::ArgumentKeys.new('hello {}', {}).cache_key).to eq('hello {}')
   end
 
-  it "removes special characters from string with special characters when :active_remote_cached_remove_characters" do
+  it 'removes special characters from string with special characters when :active_remote_cached_remove_characters' do
     options = { :active_remote_cached_remove_characters => true }
-    ::ActiveRemote::Cached::ArgumentKeys.new("hello {}", options).cache_key.must_equal("hello")
+    expect(::ActiveRemote::Cached::ArgumentKeys.new('hello {}', options).cache_key).to eq('hello')
+  end
+
+  it 'replaces special characters from string with special characters when :active_remote_cached_replace_characters' do
+    options = { :active_remote_cached_replace_characters => true }
+    expect(::ActiveRemote::Cached::ArgumentKeys.new('hello {}', options).cache_key).to eq('helloSPLBRB')
+  end
+
+  it 'replaces a tab when :active_remote_cached_replace_characters' do
+    options = { :active_remote_cached_replace_characters => true }
+    expect(::ActiveRemote::Cached::ArgumentKeys.new("a\tb", options).cache_key).to eq('aTBb')
+  end
+
+  it 'replaces a newline when :active_remote_cached_replace_characters' do
+    options = { :active_remote_cached_replace_characters => true }
+    expect(::ActiveRemote::Cached::ArgumentKeys.new("a\nb", options).cache_key).to eq('aNLb')
+  end
+
+  # REMOVE_CHARACTERS uses [[:space:]], so both options must cover the same
+  # whitespace. A raw tab or newline in a key breaks the Memcached protocol.
+  it 'leaves no whitespace in the key under either option' do
+    argument = "a b\tc\nd\re\ff\vg"
+
+    removed = ::ActiveRemote::Cached::ArgumentKeys.new(
+      argument, :active_remote_cached_remove_characters => true
+    ).cache_key
+    replaced = ::ActiveRemote::Cached::ArgumentKeys.new(
+      argument, :active_remote_cached_replace_characters => true
+    ).cache_key
+
+    expect(removed).not_to match(/[[:space:]]/)
+    expect(replaced).not_to match(/[[:space:]]/)
+  end
+
+  it 'joins multiple arguments into one key' do
+    expect(::ActiveRemote::Cached::ArgumentKeys.new('hello', 'world', {}).cache_key).to eq('helloworld')
+  end
+
+  it 'removes nil arguments from the key' do
+    expect(::ActiveRemote::Cached::ArgumentKeys.new('hello', nil, 'world', {}).cache_key).to eq('helloworld')
+  end
+
+  it 'flattens nested array arguments into the key' do
+    expect(::ActiveRemote::Cached::ArgumentKeys.new(['hello', ['world']], {}).cache_key).to eq('helloworld')
+  end
+
+  it 'returns an empty key when no arguments are given' do
+    expect(::ActiveRemote::Cached::ArgumentKeys.new({}).cache_key).to eq('')
+  end
+
+  it 'returns the cache key from #to_s' do
+    expect(::ActiveRemote::Cached::ArgumentKeys.new('hello', {}).to_s).to eq('hello')
+  end
+
+  it 'removes characters when both the remove and the replace option are given' do
+    options = {
+      :active_remote_cached_remove_characters => true,
+      :active_remote_cached_replace_characters => true
+    }
+    expect(::ActiveRemote::Cached::ArgumentKeys.new('hello {}', options).cache_key).to eq('hello')
   end
 
-  it "replaces special characters from string with special characters when :active_remote_cached_replace_characters" do
+  describe '.for_fields' do
+    it 'names each field in the key' do
+      argument_keys = ::ActiveRemote::Cached::ArgumentKeys.for_fields(%i[alpha beta], %w[x y], {})
+
+      expect(argument_keys.cache_key).to eq('alpha.x/beta.y')
+    end
+
+    it 'gives two finders with the same values two different keys' do
+      alpha_beta = ::ActiveRemote::Cached::ArgumentKeys.for_fields(%i[alpha beta], %w[x y], {})
+      gamma_delta = ::ActiveRemote::Cached::ArgumentKeys.for_fields(%i[gamma delta], %w[x y], {})
+
+      expect(alpha_beta.cache_key).not_to eq(gamma_delta.cache_key)
+    end
+
+    it 'gives a single field a different key than two fields with the same characters' do
+      one_field = ::ActiveRemote::Cached::ArgumentKeys.for_fields(%i[guid], %w[xy], {})
+      two_fields = ::ActiveRemote::Cached::ArgumentKeys.for_fields(%i[alpha beta], %w[x y], {})
+
+      expect(one_field.cache_key).not_to eq(two_fields.cache_key)
+    end
+
+    it 'joins an array value with a comma' do
+      argument_keys = ::ActiveRemote::Cached::ArgumentKeys.for_fields(%i[guid], [%w[a b]], {})
+
+      expect(argument_keys.cache_key).to eq('guid.a.b')
+    end
+
+    it 'removes a nil inside an array value' do
+      argument_keys = ::ActiveRemote::Cached::ArgumentKeys.for_fields(%i[guid], [['a', nil, 'b']], {})
+
+      expect(argument_keys.cache_key).to eq('guid.a.b')
+    end
+
+    it 'gives an empty value for a nil argument' do
+      argument_keys = ::ActiveRemote::Cached::ArgumentKeys.for_fields(%i[alpha beta], ['x', nil], {})
+
+      expect(argument_keys.cache_key).to eq('alpha.x/beta.')
+    end
+
+    it 'escapes a separator inside a value' do
+      argument_keys = ::ActiveRemote::Cached::ArgumentKeys.for_fields(%i[guid], ['a/b.c%d'], {})
+
+      expect(argument_keys.cache_key).to eq('guid.a%2Fb%2Ec%25d')
+    end
+
+    it 'keeps the separators when the remove option is given' do
+      options = { :active_remote_cached_remove_characters => true }
+      argument_keys = ::ActiveRemote::Cached::ArgumentKeys.for_fields(%i[alpha beta], ['hello {}', 'y'], options)
+
+      expect(argument_keys.cache_key).to eq('alpha.hello/beta.y')
+    end
+
+    it 'keeps the separators when the replace option is given' do
+      options = { :active_remote_cached_replace_characters => true }
+      argument_keys = ::ActiveRemote::Cached::ArgumentKeys.for_fields(%i[alpha beta], ['hello {}', 'y'], options)
+
+      expect(argument_keys.cache_key).to eq('alpha.helloSPLBRB/beta.y')
+    end
+  end
+
+  # #cache_key calls gsub! on an instance variable, so a second call must not
+  # replace the characters of the first result again.
+  it 'returns the same key when :active_remote_cached_replace_characters is called twice' do
     options = { :active_remote_cached_replace_characters => true }
-    ::ActiveRemote::Cached::ArgumentKeys.new("hello {}", options).cache_key.must_equal("helloSPLBRB")
+    argument_keys = ::ActiveRemote::Cached::ArgumentKeys.new('hello {}', options)
+
+    expect(argument_keys.cache_key).to eq('helloSPLBRB')
+    expect(argument_keys.cache_key).to eq('helloSPLBRB')
   end
 end

data/spec/active_remote/cached/cache_spec.rb

@@ -1,35 +1,198 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ::ActiveRemote::Cached::Cache do
-  describe "API" do
-    it "validates #delete present" 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)
-      error = lambda { ::ActiveRemote::Cached.cache(cache) }.must_raise(RuntimeError)
-      error.message.must_match(/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
+    it 'validates #exist? present' do
       cache = OpenStruct.new(:write => nil, :delete => nil, :read => nil, :fetch => nil)
-      error = lambda { ::ActiveRemote::Cached.cache(cache) }.must_raise(RuntimeError)
-      error.message.must_match(/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
+    it 'validates #fetch present' do
       cache = OpenStruct.new(:write => nil, :delete => nil, :read => nil, :exist? => nil)
-      error = lambda { ::ActiveRemote::Cached.cache(cache) }.must_raise(RuntimeError)
-      error.message.must_match(/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
+    it 'validates #read present' do
       cache = OpenStruct.new(:write => nil, :delete => nil, :fetch => nil, :exist? => nil)
-      error = lambda { ::ActiveRemote::Cached.cache(cache) }.must_raise(RuntimeError)
-      error.message.must_match(/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
+    it 'validates #write present' do
       cache = OpenStruct.new(:read => nil, :delete => nil, :fetch => nil, :exist? => nil)
-      error = lambda { ::ActiveRemote::Cached.cache(cache)}.must_raise(RuntimeError)
-      error.message.must_match(/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

@@ -1,45 +1,99 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 class DeleteMethodClass
   include ::ActiveRemote::Cached
 
-  def self.find; nil; end
-  def self.search; nil; end
+  def self.find(*)
+    :record
+  end
+
+  def self.search(*)
+    [:record]
+  end
 
   cached_finders_for :guid
   cached_finders_for :guid, :user_guid
-  cached_finders_for [:user_guid, :client_guid]
-  cached_finders_for [:derp, :user_guid, :client_guid]
+  cached_finders_for %i[user_guid client_guid]
+  cached_finders_for %i[derp user_guid client_guid]
 end
 
 describe DeleteMethodClass do
-  describe "API" do
+  describe 'API' do
     it "creates 'cached_delete_by_guid'" do
-      DeleteMethodClass.must_respond_to("cached_delete_by_guid")
+      expect(DeleteMethodClass).to respond_to(:cached_delete_by_guid)
     end
 
     it "creates 'cached_delete_by_user_guid'" do
-      DeleteMethodClass.must_respond_to("cached_delete_by_user_guid")
+      expect(DeleteMethodClass).to respond_to(:cached_delete_by_user_guid)
     end
 
     it "creates 'cached_delete_by_user_guid_and_client_guid'" do
-      DeleteMethodClass.must_respond_to("cached_delete_by_user_guid_and_client_guid")
+      expect(DeleteMethodClass).to respond_to(:cached_delete_by_user_guid_and_client_guid)
     end
 
     it "creates 'cached_delete_by_client_guid_and_user_guid'" do
-      DeleteMethodClass.must_respond_to("cached_delete_by_client_guid_and_user_guid")
+      expect(DeleteMethodClass).to respond_to(:cached_delete_by_client_guid_and_user_guid)
     end
 
     it "creates 'cached_delete_by_derp_and_user_guid_and_client_guid'" do
-      DeleteMethodClass.must_respond_to("cached_delete_by_derp_and_user_guid_and_client_guid")
+      expect(DeleteMethodClass).to respond_to(:cached_delete_by_derp_and_user_guid_and_client_guid)
     end
 
     it "creates 'cached_delete_by_client_guid_and_derp_and_user_guid'" do
-      DeleteMethodClass.must_respond_to("cached_delete_by_client_guid_and_derp_and_user_guid")
+      expect(DeleteMethodClass).to respond_to(:cached_delete_by_client_guid_and_derp_and_user_guid)
     end
 
     it "creates 'cached_delete_by_client_guid_and_user_guid_and_derp'" do
-      DeleteMethodClass.must_respond_to("cached_delete_by_client_guid_and_user_guid_and_derp")
+      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