active_remote-cached 1.0.0 → 1.2.0

data/spec/active_remote/cached_exist_methods_spec.rb

@@ -1,130 +1,208 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 class ExistMethodClass
   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 ExistMethodClass do
-  describe "API" do
+  describe 'API' do
     it "creates 'cached_exist_find_by_guid'" do
-      ExistMethodClass.must_respond_to("cached_exist_find_by_guid")
+      expect(ExistMethodClass).to respond_to(:cached_exist_find_by_guid)
     end
 
     it "creates 'cached_exist_search_by_guid'" do
-      ExistMethodClass.must_respond_to("cached_exist_search_by_guid")
+      expect(ExistMethodClass).to respond_to(:cached_exist_search_by_guid)
     end
 
     it "creates 'cached_exist_find_by_user_guid'" do
-      ExistMethodClass.must_respond_to("cached_exist_find_by_user_guid")
+      expect(ExistMethodClass).to respond_to(:cached_exist_find_by_user_guid)
     end
 
     it "creates 'cached_exist_search_by_user_guid'" do
-      ExistMethodClass.must_respond_to("cached_exist_search_by_user_guid")
+      expect(ExistMethodClass).to respond_to(:cached_exist_search_by_user_guid)
     end
 
     it "creates 'cached_exist_find_by_user_guid_and_client_guid'" do
-      ExistMethodClass.must_respond_to("cached_exist_find_by_user_guid_and_client_guid")
+      expect(ExistMethodClass).to respond_to(:cached_exist_find_by_user_guid_and_client_guid)
     end
 
     it "creates 'cached_exist_search_by_user_guid_and_client_guid'" do
-      ExistMethodClass.must_respond_to("cached_exist_search_by_user_guid_and_client_guid")
+      expect(ExistMethodClass).to respond_to(:cached_exist_search_by_user_guid_and_client_guid)
     end
 
     it "creates 'cached_exist_find_by_client_guid_and_user_guid'" do
-      ExistMethodClass.must_respond_to("cached_exist_find_by_client_guid_and_user_guid")
+      expect(ExistMethodClass).to respond_to(:cached_exist_find_by_client_guid_and_user_guid)
     end
 
     it "creates 'cached_exist_search_by_client_guid_and_user_guid'" do
-      ExistMethodClass.must_respond_to("cached_exist_search_by_client_guid_and_user_guid")
+      expect(ExistMethodClass).to respond_to(:cached_exist_search_by_client_guid_and_user_guid)
     end
 
     it "creates 'cached_exist_find_by_derp_and_user_guid_and_client_guid'" do
-      ExistMethodClass.must_respond_to("cached_exist_find_by_derp_and_user_guid_and_client_guid")
+      expect(ExistMethodClass).to respond_to(:cached_exist_find_by_derp_and_user_guid_and_client_guid)
     end
 
     it "creates 'cached_exist_search_by_derp_and_user_guid_and_client_guid'" do
-      ExistMethodClass.must_respond_to("cached_exist_search_by_derp_and_user_guid_and_client_guid")
+      expect(ExistMethodClass).to respond_to(:cached_exist_search_by_derp_and_user_guid_and_client_guid)
     end
 
     it "creates 'cached_exist_find_by_client_guid_and_derp_and_user_guid'" do
-      ExistMethodClass.must_respond_to("cached_exist_find_by_client_guid_and_derp_and_user_guid")
+      expect(ExistMethodClass).to respond_to(:cached_exist_find_by_client_guid_and_derp_and_user_guid)
     end
 
     it "creates 'cached_exist_search_by_client_guid_and_derp_and_user_guid'" do
-      ExistMethodClass.must_respond_to("cached_exist_search_by_client_guid_and_derp_and_user_guid")
+      expect(ExistMethodClass).to respond_to(:cached_exist_search_by_client_guid_and_derp_and_user_guid)
     end
 
     it "creates 'cached_exist_find_by_client_guid_and_user_guid_and_derp'" do
-      ExistMethodClass.must_respond_to("cached_exist_find_by_client_guid_and_user_guid_and_derp")
+      expect(ExistMethodClass).to respond_to(:cached_exist_find_by_client_guid_and_user_guid_and_derp)
     end
 
     it "creates 'cached_exist_search_by_client_guid_and_user_guid_and_derp'" do
-      ExistMethodClass.must_respond_to("cached_exist_search_by_client_guid_and_user_guid_and_derp")
+      expect(ExistMethodClass).to respond_to(:cached_exist_search_by_client_guid_and_user_guid_and_derp)
     end
 
     # ? based methods
     it "creates 'cached_exist_find_by_guid?'" do
-      ExistMethodClass.must_respond_to("cached_exist_find_by_guid?")
+      expect(ExistMethodClass).to respond_to(:cached_exist_find_by_guid?)
     end
 
     it "creates 'cached_exist_search_by_guid?'" do
-      ExistMethodClass.must_respond_to("cached_exist_search_by_guid?")
+      expect(ExistMethodClass).to respond_to(:cached_exist_search_by_guid?)
     end
 
     it "creates 'cached_exist_find_by_user_guid?'" do
-      ExistMethodClass.must_respond_to("cached_exist_find_by_user_guid?")
+      expect(ExistMethodClass).to respond_to(:cached_exist_find_by_user_guid?)
     end
 
     it "creates 'cached_exist_search_by_user_guid?'" do
-      ExistMethodClass.must_respond_to("cached_exist_search_by_user_guid?")
+      expect(ExistMethodClass).to respond_to(:cached_exist_search_by_user_guid?)
     end
 
     it "creates 'cached_exist_find_by_user_guid_and_client_guid?'" do
-      ExistMethodClass.must_respond_to("cached_exist_find_by_user_guid_and_client_guid?")
+      expect(ExistMethodClass).to respond_to(:cached_exist_find_by_user_guid_and_client_guid?)
     end
 
     it "creates 'cached_exist_search_by_user_guid_and_client_guid?'" do
-      ExistMethodClass.must_respond_to("cached_exist_search_by_user_guid_and_client_guid?")
+      expect(ExistMethodClass).to respond_to(:cached_exist_search_by_user_guid_and_client_guid?)
     end
 
     it "creates 'cached_exist_find_by_client_guid_and_user_guid?'" do
-      ExistMethodClass.must_respond_to("cached_exist_find_by_client_guid_and_user_guid?")
+      expect(ExistMethodClass).to respond_to(:cached_exist_find_by_client_guid_and_user_guid?)
     end
 
     it "creates 'cached_exist_search_by_client_guid_and_user_guid?'" do
-      ExistMethodClass.must_respond_to("cached_exist_search_by_client_guid_and_user_guid?")
+      expect(ExistMethodClass).to respond_to(:cached_exist_search_by_client_guid_and_user_guid?)
     end
 
     it "creates 'cached_exist_find_by_derp_and_user_guid_and_client_guid?'" do
-      ExistMethodClass.must_respond_to("cached_exist_find_by_derp_and_user_guid_and_client_guid?")
+      expect(ExistMethodClass).to respond_to(:cached_exist_find_by_derp_and_user_guid_and_client_guid?)
     end
 
     it "creates 'cached_exist_search_by_derp_and_user_guid_and_client_guid?'" do
-      ExistMethodClass.must_respond_to("cached_exist_search_by_derp_and_user_guid_and_client_guid?")
+      expect(ExistMethodClass).to respond_to(:cached_exist_search_by_derp_and_user_guid_and_client_guid?)
     end
 
     it "creates 'cached_exist_find_by_client_guid_and_derp_and_user_guid?'" do
-      ExistMethodClass.must_respond_to("cached_exist_find_by_client_guid_and_derp_and_user_guid?")
+      expect(ExistMethodClass).to respond_to(:cached_exist_find_by_client_guid_and_derp_and_user_guid?)
     end
 
     it "creates 'cached_exist_search_by_client_guid_and_derp_and_user_guid?'" do
-      ExistMethodClass.must_respond_to("cached_exist_search_by_client_guid_and_derp_and_user_guid?")
+      expect(ExistMethodClass).to respond_to(:cached_exist_search_by_client_guid_and_derp_and_user_guid?)
     end
 
     it "creates 'cached_exist_find_by_client_guid_and_user_guid_and_derp?'" do
-      ExistMethodClass.must_respond_to("cached_exist_find_by_client_guid_and_user_guid_and_derp?")
+      expect(ExistMethodClass).to respond_to(:cached_exist_find_by_client_guid_and_user_guid_and_derp?)
     end
 
     it "creates 'cached_exist_search_by_client_guid_and_user_guid_and_derp?'" do
-      ExistMethodClass.must_respond_to("cached_exist_search_by_client_guid_and_user_guid_and_derp?")
+      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

@@ -1,54 +1,63 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 class FindMethodClass
   include ::ActiveRemote::Cached
 
-  def self.find; nil; end
-  def self.search; nil; end
+  def self.find
+    nil
+  end
+
+  def self.search
+    nil
+  end
 
   cached_finders_for :foo, :expires_in => 500
   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 FindMethodClass do
-  describe "API" do
+  let(:versioned_prefix) { ::ActiveRemote::Cached::RUBY_AND_ACTIVE_SUPPORT_VERSION }
+
+  describe 'API' do
     it "creates 'cached_find_by_foo'" do
-      FindMethodClass.must_respond_to("cached_find_by_foo")
+      expect(FindMethodClass).to respond_to(:cached_find_by_foo)
     end
 
     it "creates 'cached_find_by_guid'" do
-      FindMethodClass.must_respond_to("cached_find_by_guid")
+      expect(FindMethodClass).to respond_to(:cached_find_by_guid)
     end
 
     it "creates 'cached_find_by_user_guid'" do
-      FindMethodClass.must_respond_to("cached_find_by_user_guid")
+      expect(FindMethodClass).to respond_to(:cached_find_by_user_guid)
     end
 
     it "creates 'cached_find_by_user_guid_and_client_guid'" do
-      FindMethodClass.must_respond_to("cached_find_by_user_guid_and_client_guid")
+      expect(FindMethodClass).to respond_to(:cached_find_by_user_guid_and_client_guid)
     end
 
     it "creates 'cached_find_by_client_guid_and_user_guid'" do
-      FindMethodClass.must_respond_to("cached_find_by_client_guid_and_user_guid")
+      expect(FindMethodClass).to respond_to(:cached_find_by_client_guid_and_user_guid)
     end
 
     it "creates 'cached_find_by_derp_and_user_guid_and_client_guid'" do
-      FindMethodClass.must_respond_to("cached_find_by_derp_and_user_guid_and_client_guid")
+      expect(FindMethodClass).to respond_to(:cached_find_by_derp_and_user_guid_and_client_guid)
     end
 
     it "creates 'cached_find_by_client_guid_and_derp_and_user_guid'" do
-      FindMethodClass.must_respond_to("cached_find_by_client_guid_and_derp_and_user_guid")
+      expect(FindMethodClass).to respond_to(:cached_find_by_client_guid_and_derp_and_user_guid)
     end
 
     it "creates 'cached_find_by_client_guid_and_user_guid_and_derp'" do
-      FindMethodClass.must_respond_to("cached_find_by_client_guid_and_user_guid_and_derp")
+      expect(FindMethodClass).to respond_to(:cached_find_by_client_guid_and_user_guid_and_derp)
     end
   end
 
-  describe "#cached_find_by_guid" do
+  describe '#cached_find_by_guid' do
     before do
       ::ActiveRemote::Cached.cache(HashCache.new)
       ::ActiveRemote::Cached.default_options(:expires_in => 100)
@@ -58,50 +67,50 @@ describe FindMethodClass do
       ::ActiveRemote::Cached.default_options({})
     end
 
-    it "executes find_by_guid when cached_find with guid called" do
-      FindMethodClass.stub(:find, :hello) do
-        FindMethodClass.cached_find(:guid => :guid).must_equal(:hello)
-      end
+    it 'executes find_by_guid when cached_find with guid called' do
+      expect(FindMethodClass).to receive(:find).and_return(:hello)
+      expect(FindMethodClass.cached_find(:guid => :guid)).to eq(:hello)
     end
 
-    it "executes the fetch block if not present in cache" do
-      FindMethodClass.stub(:find, :hello) do
-        FindMethodClass.cached_find_by_guid(:guid).must_equal(:hello)
-      end
+    it 'executes the fetch block if not present in cache' do
+      expect(FindMethodClass).to receive(:find).and_return(:hello)
+      expect(FindMethodClass.cached_find_by_guid(:guid)).to eq(:hello)
     end
 
-    it "merges the default options in for the fetch call" do
-      ::ActiveRemote::Cached.cache.expects(:fetch).with([FindMethodClass.name, "#find", "guid"], :expires_in => 100).returns(:hello)
-
-      FindMethodClass.stub(:find, :hello) do
-        FindMethodClass.cached_find_by_guid(:guid).must_equal(:hello)
-      end
+    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.guid'], { :expires_in => 100 }
+      ).and_return(:hello)
+      expect(FindMethodClass).not_to receive(:find)
+      expect(FindMethodClass.cached_find_by_guid(:guid)).to eq(:hello)
     end
 
-    it "overrides the default options with local options for the fetch call" do
-      ::ActiveRemote::Cached.cache.expects(:fetch).with([FindMethodClass.name, "#find", "guid"], :expires_in => 200).returns(:hello)
+    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.guid'], { :expires_in => 200 }
+      ).and_return(:hello)
+      expect(FindMethodClass).not_to receive(:find)
 
-      FindMethodClass.stub(:find, :hello) do
-        FindMethodClass.cached_find_by_guid(:guid, :expires_in => 200).must_equal(:hello)
-      end
+      expect(FindMethodClass.cached_find_by_guid(:guid, :expires_in => 200)).to eq(:hello)
     end
 
-    describe "namespaced cache" do
+    describe 'namespaced cache' do
       before do
-        ::ActiveRemote::Cached.default_options(:expires_in => 100, :namespace => "MyApp")
+        ::ActiveRemote::Cached.default_options(:expires_in => 100, :namespace => 'MyApp')
       end
 
-      it "uses the namespace as a prefix to the cache key" do
-        ::ActiveRemote::Cached.cache.expects(:fetch).with(["MyApp", FindMethodClass.name, "#find", "guid"], :expires_in => 100).returns(:hello)
+      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.guid'], { :expires_in => 100 }
+        ).and_return(:hello)
 
-        FindMethodClass.stub(:find, :hello) do
-          FindMethodClass.cached_find_by_guid(:guid)
-        end
+        expect(FindMethodClass).not_to receive(:find)
+        FindMethodClass.cached_find_by_guid(:guid)
       end
     end
   end
 
-  describe "#cached_find_by_foo" do
+  describe '#cached_find_by_foo' do
     before do
       ::ActiveRemote::Cached.cache(HashCache.new)
       ::ActiveRemote::Cached.default_options(:expires_in => 100)
@@ -111,20 +120,22 @@ describe FindMethodClass do
       ::ActiveRemote::Cached.default_options({})
     end
 
-    it "overrides the default options with cached_finder options for the fetch call" do
-      ::ActiveRemote::Cached.cache.expects(:fetch).with([FindMethodClass.name, "#find", "foo"], :expires_in => 500).returns(:hello)
+    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.foo'], { :expires_in => 500 }
+      ).and_return(:hello)
 
-      FindMethodClass.stub(:find, :hello) do
-        FindMethodClass.cached_find_by_foo(:foo).must_equal(:hello)
-      end
+      expect(FindMethodClass).not_to receive(:find)
+      expect(FindMethodClass.cached_find_by_foo(:foo)).to eq(:hello)
     end
 
-    it "overrides the cached_finder options with local options for the fetch call" do
-      ::ActiveRemote::Cached.cache.expects(:fetch).with([FindMethodClass.name, "#find", "foo"], :expires_in => 200).returns(:hello)
+    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.foo'], { :expires_in => 200 }
+      ).and_return(:hello)
 
-      FindMethodClass.stub(:find, :hello) do
-        FindMethodClass.cached_find_by_foo(:foo, :expires_in => 200).must_equal(:hello)
-      end
+      expect(FindMethodClass).not_to receive(:find)
+      expect(FindMethodClass.cached_find_by_foo(:foo, :expires_in => 200)).to eq(:hello)
     end
   end
 end