active_remote-cached 0.2.0 → 1.1.1

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

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: active_remote-cached
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Brandon Dewitt
-autorequire: 
+- MXDevExperience
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-03-19 00:00:00.000000000 Z
+date: 2024-06-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_remote
@@ -16,14 +17,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '6.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '6.1'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -94,15 +95,45 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: ' Provides "cached" finders and a DSL to enumerate which finders should
   have cached versions '
 email:
 - brandonsdewitt@gmail.com
+- devexperience@mx.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rubocop.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -124,7 +155,7 @@ files:
 homepage: ''
 licenses: []
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -132,18 +163,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
-signing_key: 
+rubygems_version: 3.1.6
+signing_key:
 specification_version: 4
 summary: Provides a configuration for caching mechanisms and finders on ActiveRemote
-  models that are cached/cacheable
+  models
 test_files:
 - spec/active_remote/cached/argument_keys_spec.rb
 - spec/active_remote/cached/cache_spec.rb