active_remote-cached 1.0.0 → 1.1.1

data/spec/active_remote/cached_find_methods_spec.rb

@@ -1,54 +1,65 @@
+# 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) do
+    "#{RUBY_ENGINE_VERSION}:#{ActiveSupport::VERSION::STRING}"
+  end
+
+  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 +69,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'], { :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'], { :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'], { :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 +122,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'], { :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'], { :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

data/spec/active_remote/cached_search_methods_spec.rb

@@ -1,63 +1,96 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 class SearchMethodClass
   include ::ActiveRemote::Cached
 
-  def self.derp; nil; end
-  def self.find; nil; end
-  def self.search; nil; end
+  def self.derp
+    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]
+  cached_finders_for %i[zippy123 alpha]
 end
 
 describe SearchMethodClass do
-  describe "API" do
+  let(:versioned_prefix) do
+    "#{RUBY_ENGINE_VERSION}:#{ActiveSupport::VERSION::STRING}"
+  end
+
+  describe 'API' do
     it "creates 'cached_search_by_foo'" do
-      SearchMethodClass.must_respond_to("cached_search_by_foo")
+      expect(SearchMethodClass).to respond_to(:cached_search_by_foo)
     end
 
     it "creates 'cached_search_by_foo!'" do
-      SearchMethodClass.must_respond_to("cached_search_by_foo!")
+      expect(SearchMethodClass).to respond_to(:cached_search_by_foo!)
     end
 
     it "creates 'cached_search_by_guid'" do
-      SearchMethodClass.must_respond_to("cached_search_by_guid")
+      expect(SearchMethodClass).to respond_to(:cached_search_by_guid)
     end
 
     it "creates 'cached_search_by_user_guid'" do
-      SearchMethodClass.must_respond_to("cached_search_by_user_guid")
+      expect(SearchMethodClass).to respond_to(:cached_search_by_user_guid)
     end
 
     it "creates 'cached_search_by_user_guid_and_client_guid'" do
-      SearchMethodClass.must_respond_to("cached_search_by_user_guid_and_client_guid")
+      expect(SearchMethodClass).to respond_to(:cached_search_by_user_guid_and_client_guid)
     end
 
     it "creates 'cached_search_by_client_guid_and_user_guid'" do
-      SearchMethodClass.must_respond_to("cached_search_by_client_guid_and_user_guid")
+      expect(SearchMethodClass).to respond_to(:cached_search_by_client_guid_and_user_guid)
     end
 
     it "creates 'cached_search_by_derp_and_user_guid_and_client_guid'" do
-      SearchMethodClass.must_respond_to("cached_search_by_derp_and_user_guid_and_client_guid")
+      expect(SearchMethodClass).to respond_to(:cached_search_by_derp_and_user_guid_and_client_guid)
     end
 
     it "creates 'cached_search_by_client_guid_and_derp_and_user_guid'" do
-      SearchMethodClass.must_respond_to("cached_search_by_client_guid_and_derp_and_user_guid")
+      expect(SearchMethodClass).to respond_to(:cached_search_by_client_guid_and_derp_and_user_guid)
     end
 
     it "creates 'cached_search_by_client_guid_and_user_guid_and_derp'" do
-      SearchMethodClass.must_respond_to("cached_search_by_client_guid_and_user_guid_and_derp")
+      expect(SearchMethodClass).to respond_to(:cached_search_by_client_guid_and_user_guid_and_derp)
     end
 
     it "creates 'cached_search_by_client_guid_and_user_guid_and_derp!'" do
-      SearchMethodClass.must_respond_to("cached_search_by_client_guid_and_user_guid_and_derp!")
+      expect(SearchMethodClass).to respond_to(:cached_search_by_client_guid_and_user_guid_and_derp!)
+    end
+
+    # Ensure it works with numbers in method name
+    it "creates 'cached_search_by_alpha_and_zippy123'" do
+      expect(SearchMethodClass).to respond_to(:cached_search_by_alpha_and_zippy123)
+    end
+
+    # Ensure it responds to methods where params are not sorted
+    # i.e. the method missing override is used.
+    it "responds to 'cached_search_by_zippy123_and_alpha'" do
+      expect(SearchMethodClass).to respond_to(:cached_search_by_zippy123_and_alpha)
+    end
+
+    # Ensure the right method actually gets called when
+    # method_missing override is used.
+    it "can call 'cached_search_by_zippy123_and_alpha' when not defined" do
+      expect(SearchMethodClass).to receive(:search)
+      SearchMethodClass.cached_search_by_zippy123_and_alpha('abc', '123')
     end
   end
 
-  describe "#cached_search_by_guid" do
+  describe '#cached_search_by_guid' do
     before do
       ::ActiveRemote::Cached.cache(HashCache.new)
       ::ActiveRemote::Cached.default_options(:expires_in => 100)
@@ -67,108 +100,105 @@ describe SearchMethodClass do
       ::ActiveRemote::Cached.default_options({})
     end
 
-    it "executes the search block when a block is passed" do
-      SearchMethodClass.stub(:derp, :derp) do
-        SearchMethodClass.cached_search(:guid => :guid) do
-          SearchMethodClass.derp
-        end.must_equal(:derp)
-      end
+    it 'executes the search block when a block is passed' do
+      expect(SearchMethodClass).to receive(:derp).and_return(:derp)
+      expect(SearchMethodClass.cached_search(:guid => :guid) do
+        SearchMethodClass.derp
+      end).to eq(:derp)
     end
 
-    it "does not persist empty values by default" do
-      SearchMethodClass.stub(:derp, []) do
-        SearchMethodClass.cached_search(:guid => :guid) do
-          SearchMethodClass.derp
-        end
+    it 'does not persist empty values by default' do
+      expect(SearchMethodClass).to receive(:derp).and_return([])
 
-        SearchMethodClass.cached_exist_search_by_guid?(:guid).must_equal(false)
+      SearchMethodClass.cached_search(:guid => :guid) do
+        SearchMethodClass.derp
       end
-    end
 
-    it "persists empty values when allow_empty sent" do
-      SearchMethodClass.stub(:derp, []) do
-        SearchMethodClass.cached_search({:guid => :guid}, :allow_empty => true) do
-          SearchMethodClass.derp
-        end
+      expect(SearchMethodClass.cached_exist_search_by_guid?(:guid)).to eq(false)
+    end
 
-        SearchMethodClass.cached_exist_search_by_guid?(:guid).must_equal(true)
+    it 'persists empty values when allow_empty sent' do
+      expect(SearchMethodClass).to receive(:derp).and_return([])
+      SearchMethodClass.cached_search({ :guid => :guid }, :allow_empty => true) do
+        SearchMethodClass.derp
       end
-    end
 
-    it "does not persist nil values by default" do
-      SearchMethodClass.stub(:derp, nil) do
-        SearchMethodClass.cached_search(:guid => :guid) do
-          SearchMethodClass.derp
-        end
+      expect(SearchMethodClass.cached_exist_search_by_guid?(:guid)).to eq(true)
+    end
 
-        SearchMethodClass.cached_exist_search_by_guid?(:guid).must_equal(false)
+    it 'does not persist nil values by default' do
+      expect(SearchMethodClass).to receive(:derp).and_return(nil)
+      SearchMethodClass.cached_search(:guid => :guid) do
+        SearchMethodClass.derp
       end
-    end
 
-    it "persists nil values when allow_nil sent" do
-      SearchMethodClass.stub(:derp, nil) do
-        SearchMethodClass.cached_search({:guid => :guid}, :allow_nil => true) do
-          SearchMethodClass.derp
-        end
+      expect(SearchMethodClass.cached_exist_search_by_guid?(:guid)).to eq(false)
+    end
 
-        SearchMethodClass.cached_exist_search_by_guid?(:guid).must_equal(true)
+    it 'persists nil values when allow_nil sent' do
+      expect(SearchMethodClass).to receive(:derp).and_return(nil)
+      SearchMethodClass.cached_search({ :guid => :guid }, :allow_nil => true) do
+        SearchMethodClass.derp
       end
-    end
 
-    it "does persist non nil values" do
-      SearchMethodClass.stub(:derp, :derp) do
-        SearchMethodClass.cached_search(:guid => :guid) do
-          SearchMethodClass.derp
-        end
+      expect(SearchMethodClass.cached_exist_search_by_guid?(:guid)).to eq(true)
+    end
 
-        SearchMethodClass.cached_exist_search_by_guid?(:guid).must_equal(true)
+    it 'does persist non nil values' do
+      expect(SearchMethodClass).to receive(:derp).and_return(:derp)
+      SearchMethodClass.cached_search(:guid => :guid) do
+        SearchMethodClass.derp
       end
+
+      expect(SearchMethodClass.cached_exist_search_by_guid?(:guid)).to eq(true)
     end
 
-    it "executes search_by_guid when cached_search with guid called" do
-      FindMethodClass.stub(:search, :hello) do
-        FindMethodClass.cached_search(:guid => :guid).must_equal(:hello)
-      end
+    it 'executes search_by_guid when cached_search with guid called' do
+      expect(SearchMethodClass).to receive(:search).and_return(:hello)
+
+      expect(SearchMethodClass.cached_search(:guid => :guid)).to eq(:hello)
     end
 
-    it "executes the fetch block if not present in cache" do
-      SearchMethodClass.stub(:search, :hello) do
-        SearchMethodClass.cached_search_by_guid(:guid).must_equal(:hello)
-      end
+    it 'executes the fetch block if not present in cache' do
+      expect(SearchMethodClass).to receive(:search).and_return(:hello)
+      expect(SearchMethodClass.cached_search_by_guid(:guid)).to eq(:hello)
     end
 
-    it "merges the default options in for the fetch call" do
-      ::ActiveRemote::Cached.cache.expects(:fetch).with([SearchMethodClass.name, "#search", "guid"], :expires_in => 100).returns(:hello)
+    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 }
+      ).and_return(:hello)
 
-      SearchMethodClass.stub(:search, :hello) do
-        SearchMethodClass.cached_search_by_guid(:guid).must_equal(:hello)
-      end
+      expect(SearchMethodClass).not_to receive(:search)
+      expect(SearchMethodClass.cached_search_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([SearchMethodClass.name, "#search", "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, SearchMethodClass.name, '#search', 'guid'], { :expires_in => 200 }
+      ).and_return(:hello)
 
-      SearchMethodClass.stub(:search, :hello) do
-        SearchMethodClass.cached_search_by_guid(:guid, :expires_in => 200).must_equal(:hello)
-      end
+      expect(SearchMethodClass).not_to receive(:search)
+      expect(SearchMethodClass.cached_search_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", SearchMethodClass.name, "#search", "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', SearchMethodClass.name, '#search', 'guid'], { :expires_in => 100 }
+        ).and_return(:hello)
 
-        SearchMethodClass.stub(:search, :hello) do
-          SearchMethodClass.cached_search_by_guid(:guid)
-        end
+        expect(SearchMethodClass).not_to receive(:search)
+        SearchMethodClass.cached_search_by_guid(:guid)
       end
     end
   end
 
-  describe "#cached_search_by_foo" do
+  describe '#cached_search_by_foo' do
     before do
       ::ActiveRemote::Cached.cache(HashCache.new)
       ::ActiveRemote::Cached.default_options(:expires_in => 100)
@@ -178,24 +208,26 @@ describe SearchMethodClass 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([SearchMethodClass.name, "#search", "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, SearchMethodClass.name, '#search', 'foo'], { :expires_in => 500 }
+      ).and_return(:hello)
 
-      SearchMethodClass.stub(:find, :hello) do
-        SearchMethodClass.cached_search_by_foo(:foo).must_equal(:hello)
-      end
+      expect(SearchMethodClass).not_to receive(:find)
+      expect(SearchMethodClass.cached_search_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([SearchMethodClass.name, "#search", "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, SearchMethodClass.name, '#search', 'foo'], { :expires_in => 200 }
+      ).and_return(:hello)
 
-      SearchMethodClass.stub(:find, :hello) do
-        SearchMethodClass.cached_search_by_foo(:foo, :expires_in => 200).must_equal(:hello)
-      end
+      expect(SearchMethodClass).not_to receive(:find)
+      expect(SearchMethodClass.cached_search_by_foo(:foo, :expires_in => 200)).to eq(:hello)
     end
   end
 
-  describe "#cached_search_by_foo!" do
+  describe '#cached_search_by_foo!' do
     before do
       ::ActiveRemote::Cached.cache(HashCache.new)
       ::ActiveRemote::Cached.default_options(:expires_in => 100)
@@ -205,16 +237,35 @@ describe SearchMethodClass do
       ::ActiveRemote::Cached.default_options({})
     end
 
-    it "returns results when present" do
-      SearchMethodClass.stub(:search, [:hello]) do
-        SearchMethodClass.cached_search_by_foo!(:foo, :expires_in => 200).must_equal([:hello])
-      end
+    it 'and_return results when present' do
+      expect(SearchMethodClass).to receive(:search).and_return([:hello])
+      expect(SearchMethodClass.cached_search_by_foo!(:foo, :expires_in => 200)).to eq([:hello])
     end
 
-    it "raises ActiveRemote::RemoteRecordNotFound when not found" do
-      SearchMethodClass.stub(:search, []) do
-        -> { SearchMethodClass.cached_search_by_foo!(:foo, :expires_in => 200) }.must_raise ::ActiveRemote::RemoteRecordNotFound
-      end
+    it 'raises ActiveRemote::RemoteRecordNotFound when not found' do
+      expect(SearchMethodClass).to receive(:search).and_return([])
+      expect do
+        SearchMethodClass.cached_search_by_foo!(:foo, :expires_in => 200)
+      end.to raise_error ::ActiveRemote::RemoteRecordNotFound
+    end
+  end
+
+  # This tests the method_missing override
+  describe '#cached_search_by_zippy123_and_alpha' do
+    before do
+      ::ActiveRemote::Cached.cache(HashCache.new)
+      ::ActiveRemote::Cached.default_options(:expires_in => 100)
+    end
+
+    after do
+      ::ActiveRemote::Cached.default_options({})
+    end
+
+    it 'calls the underlying method with params in correct order' do
+      expect(SearchMethodClass).to receive(:cached_search_by_alpha_and_zippy123).with('123', 'abc').and_return(:hello)
+
+      # Calls method that does not exist (different param order)
+      expect(SearchMethodClass.cached_search_by_zippy123_and_alpha('abc', '123')).to eq(:hello)
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,21 +1,16 @@
+# frozen_string_literal: true
+
 require 'rubygems'
 require 'bundler'
 Bundler.require(:default, :development, :test)
 
-require 'minitest/mock'
-require 'minitest/spec'
-require 'minitest/autorun'
-require 'minitest/pride'
-
 class HashCache < Hash
   def exist?(key)
-    self.has_key?(key)
+    key?(key)
   end
 
-  def fetch(key, options = {}, &blk)
-    if self.has_key?(key)
-      return self[key]
-    end
+  def fetch(key, _options = {})
+    return self[key] if key?(key)
 
     self[key] = yield
   end