active_remote-cached 1.1.1 → 1.2.0

data/spec/active_remote/cached_spec.rb

@@ -0,0 +1,331 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+# 5.minutes below. The library does not require this itself.
+require 'active_support/core_ext/numeric/time'
+
+class ConfigurationClass
+  include ::ActiveRemote::Cached
+
+  def self.find(*)
+    :find_result
+  end
+
+  def self.search(*)
+    [:search_result]
+  end
+
+  cached_finders_for :guid
+  cached_finders_for %i[alpha beta]
+
+  # Declared twice on purpose, to prove cached_methods does not repeat itself.
+  cached_finders_for :guid
+end
+
+class AliasFinderClass
+  include ::ActiveRemote::Cached
+
+  def self.find(*)
+    :find_result
+  end
+
+  def self.search(*)
+    [:search_result]
+  end
+
+  cached_finders :guid
+end
+
+class ChildFinderClass < ConfigurationClass; end
+
+class DurationOptionClass
+  include ::ActiveRemote::Cached
+
+  def self.find(*)
+    :find_result
+  end
+
+  def self.search(*)
+    [:search_result]
+  end
+
+  # 5.minutes has no literal form. The options must not be interpolated into
+  # the generated source.
+  cached_finders_for :guid, :expires_in => 5.minutes
+end
+
+class DurationChildClass < DurationOptionClass; end
+
+describe ::ActiveRemote::Cached do
+  let(:versioned_prefix) { ::ActiveRemote::Cached::RUBY_AND_ACTIVE_SUPPORT_VERSION }
+
+  before do
+    ::ActiveRemote::Cached.cache(HashCache.new)
+  end
+
+  after do
+    ::ActiveRemote::Cached.default_options({})
+  end
+
+  describe '.cache' do
+    it 'wraps the cache provider in a cache' do
+      expect(::ActiveRemote::Cached.cache).to be_a(::ActiveRemote::Cached::Cache)
+    end
+
+    it 'returns the current cache when no cache provider is given' do
+      cache = ::ActiveRemote::Cached.cache
+
+      expect(::ActiveRemote::Cached.cache).to be(cache)
+    end
+  end
+
+  describe '.default_options' do
+    it 'returns an empty hash when no options are set' do
+      expect(::ActiveRemote::Cached.default_options).to eq({})
+    end
+
+    it 'returns the options that were set' do
+      ::ActiveRemote::Cached.default_options(:expires_in => 100)
+
+      expect(::ActiveRemote::Cached.default_options).to eq(:expires_in => 100)
+    end
+
+    # Passing nil reads the options. Callers must pass an empty hash to clear.
+    it 'keeps the current options when nil is given' do
+      ::ActiveRemote::Cached.default_options(:expires_in => 100)
+
+      expect(::ActiveRemote::Cached.default_options(nil)).to eq(:expires_in => 100)
+    end
+
+    it 'clears the current options when an empty hash is given' do
+      ::ActiveRemote::Cached.default_options(:expires_in => 100)
+
+      expect(::ActiveRemote::Cached.default_options({})).to eq({})
+    end
+  end
+
+  describe 'RUBY_AND_ACTIVE_SUPPORT_VERSION' do
+    it 'prefixes every cache key' do
+      expect(::ActiveRemote::Cached.cache).to receive(:fetch).with(
+        [versioned_prefix, ConfigurationClass.name, '#find', 'guid.guid'], {}
+      ).and_return(:find_result)
+
+      ConfigurationClass.cached_find_by_guid(:guid)
+    end
+  end
+
+  describe '.cached_find' do
+    it 'calls find with the given arguments' do
+      expect(ConfigurationClass).to receive(:find).and_return(:hello)
+
+      expect(ConfigurationClass.cached_find(:guid => :guid)).to eq(:hello)
+    end
+
+    it 'sorts the argument keys before it builds the cache key' do
+      expect(ConfigurationClass).to receive(:cached_find_by_alpha_and_beta).with('A', 'B', {})
+
+      ConfigurationClass.cached_find(:beta => 'B', :alpha => 'A')
+    end
+
+    it 'yields to the block instead of calling find' do
+      expect(ConfigurationClass).not_to receive(:find)
+
+      expect(ConfigurationClass.cached_find(:guid => :guid) { :block_result }).to eq(:block_result)
+    end
+
+    it 'passes the options through to the fetch call' do
+      expect(::ActiveRemote::Cached.cache).to receive(:fetch).with(
+        [versioned_prefix, ConfigurationClass.name, '#find', 'guid.guid'], { :expires_in => 200 }
+      ).and_return(:hello)
+
+      expect(ConfigurationClass.cached_find({ :guid => :guid }, :expires_in => 200)).to eq(:hello)
+    end
+  end
+
+  describe '.cached_search' do
+    it 'calls search with the given arguments' do
+      expect(ConfigurationClass).to receive(:search).and_return([:hello])
+
+      expect(ConfigurationClass.cached_search(:guid => :guid)).to eq([:hello])
+    end
+
+    it 'sorts the argument keys before it builds the cache key' do
+      expect(ConfigurationClass).to receive(:cached_search_by_alpha_and_beta).with('A', 'B', {})
+
+      ConfigurationClass.cached_search(:beta => 'B', :alpha => 'A')
+    end
+  end
+
+  describe '.cached_methods' do
+    it 'does not repeat a method when the same finder is declared twice' do
+      expect(ConfigurationClass.cached_methods).to eq(ConfigurationClass.cached_methods.uniq)
+    end
+  end
+
+  describe '.cached_finders' do
+    it 'creates the same methods as cached_finders_for' do
+      expect(AliasFinderClass).to respond_to(:cached_find_by_guid)
+      expect(AliasFinderClass).to respond_to(:cached_search_by_guid)
+    end
+  end
+
+  describe '.respond_to_missing?' do
+    it 'is true for a finder that was defined' do
+      expect(ConfigurationClass.respond_to?(:cached_find_by_alpha_and_beta)).to eq(true)
+    end
+
+    it 'is true for a finder whose arguments are in a different order' do
+      expect(ConfigurationClass.respond_to?(:cached_find_by_beta_and_alpha)).to eq(true)
+    end
+
+    it 'is false for a finder that was not defined' do
+      expect(ConfigurationClass.respond_to?(:cached_find_by_missing)).to eq(false)
+    end
+
+    it 'returns a method object for a finder in a different argument order' do
+      expect(ConfigurationClass.method(:cached_find_by_beta_and_alpha)).to be_a(::Method)
+    end
+  end
+
+  describe '.method_missing' do
+    it 'raises NoMethodError for a method that is not a finder' do
+      expect { ConfigurationClass.not_a_finder }.to raise_error(::NoMethodError)
+    end
+
+    it 'raises NoMethodError for a finder that was not defined' do
+      expect { ConfigurationClass.cached_find_by_missing(:value) }.to raise_error(::NoMethodError)
+    end
+  end
+
+  describe '._args_in_sorted_order' do
+    it 'reorders the arguments to match the defined method' do
+      expect(ConfigurationClass).to receive(:cached_find_by_alpha_and_beta).with('A', 'B')
+
+      ConfigurationClass.cached_find_by_beta_and_alpha('B', 'A')
+    end
+
+    it 'passes the options hash through as the last argument' do
+      expect(ConfigurationClass).to receive(:cached_find_by_alpha_and_beta).with('A', 'B', { :expires_in => 10 })
+
+      ConfigurationClass.cached_find_by_beta_and_alpha('B', 'A', { :expires_in => 10 })
+    end
+
+    # A missing argument used to become nil, and the finder then cached a
+    # record under a key built from that nil.
+    it 'raises ArgumentError when an argument is missing' do
+      expect do
+        ConfigurationClass.cached_find_by_beta_and_alpha('B')
+      end.to raise_error(::ArgumentError, /given 1, expected 2/)
+    end
+  end
+
+  describe '._method_missing_name' do
+    it 'returns nil when the method name is not a finder' do
+      expect(ConfigurationClass._method_missing_name(:not_a_finder)).to be_nil
+    end
+
+    it 'sorts the argument names in the method name' do
+      expect(ConfigurationClass._method_missing_name(:cached_find_by_beta_and_alpha)).to eq(
+        :cached_find_by_alpha_and_beta
+      )
+    end
+
+    # The regex has no anchors, so it matches a finder name inside a longer
+    # name. This records the current behavior. See the note in the README.
+    it 'matches a finder name that is a suffix of a longer method name' do
+      expect(ConfigurationClass._method_missing_name(:not_cached_find_by_guid)).to eq(
+        :cached_find_by_guid
+      )
+    end
+  end
+
+  describe 'a finder whose definition fails' do
+    let(:broken_class) do
+      Class.new do
+        include ::ActiveRemote::Cached
+
+        def self.find(*)
+          :find_result
+        end
+
+        def self.search(*)
+          [:search_result]
+        end
+      end
+    end
+
+    # cached_methods used to be written before class_eval ran, so a failure
+    # registered a name with no method behind it. method_missing then
+    # dispatched to that same missing name and recursed until the stack ran out.
+    it 'registers no method name' do
+      expect { broken_class.cached_finders_for :'bad-name' }.to raise_error(::SyntaxError)
+
+      expect(broken_class.cached_methods).to eq([])
+    end
+
+    it 'raises NoMethodError rather than recursing' do
+      begin
+        broken_class.cached_finders_for :'bad-name'
+      rescue ::SyntaxError # rubocop:disable Lint/SuppressedException
+      end
+
+      expect { broken_class.cached_delete_by_guid('x') }.to raise_error(::NoMethodError)
+    end
+  end
+
+  describe 'a finder declared with an option that has no literal form' do
+    it 'defines the finder methods' do
+      expect(DurationOptionClass).to respond_to(:cached_find_by_guid)
+      expect(DurationOptionClass).to respond_to(:cached_search_by_guid)
+    end
+
+    it 'passes the option through to the fetch call' do
+      expect(::ActiveRemote::Cached.cache).to receive(:fetch).with(
+        [versioned_prefix, DurationOptionClass.name, '#find', 'guid.guid'], { :expires_in => 5.minutes }
+      ).and_return(:hello)
+
+      expect(DurationOptionClass.cached_find_by_guid(:guid)).to eq(:hello)
+    end
+
+    it 'lets a local option override the declared option' do
+      expect(::ActiveRemote::Cached.cache).to receive(:fetch).with(
+        [versioned_prefix, DurationOptionClass.name, '#find', 'guid.guid'], { :expires_in => 200 }
+      ).and_return(:hello)
+
+      expect(DurationOptionClass.cached_find_by_guid(:guid, :expires_in => 200)).to eq(:hello)
+    end
+
+    it 'applies the declared option in a subclass' do
+      expect(::ActiveRemote::Cached.cache).to receive(:fetch).with(
+        [versioned_prefix, DurationChildClass.name, '#find', 'guid.guid'], { :expires_in => 5.minutes }
+      ).and_return(:hello)
+
+      expect(DurationChildClass.cached_find_by_guid(:guid)).to eq(:hello)
+    end
+  end
+
+  describe 'a subclass of a class with cached finders' do
+    it 'responds to the finders the parent defined' do
+      expect(ChildFinderClass).to respond_to(:cached_find_by_alpha_and_beta)
+    end
+
+    it 'calls the finders the parent defined' do
+      expect(ChildFinderClass).to receive(:find).and_return(:hello)
+
+      expect(ChildFinderClass.cached_find_by_alpha_and_beta('A', 'B')).to eq(:hello)
+    end
+
+    it 'has an empty cached_methods list of its own' do
+      expect(ChildFinderClass.cached_methods).to eq([])
+    end
+
+    # method_missing reads cached_methods, which is empty on the subclass, so
+    # the subclass cannot reorder the arguments the way the parent can.
+    it 'does not accept the finder arguments in a different order' do
+      expect(ConfigurationClass.cached_find_by_beta_and_alpha('B', 'A')).to eq(:find_result)
+
+      expect { ChildFinderClass.cached_find_by_beta_and_alpha('B', 'A') }.to raise_error(::NoMethodError)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'ostruct'
 require 'rubygems'
 require 'bundler'
 Bundler.require(:default, :development, :test)

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_remote-cached
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Brandon Dewitt
 - MXDevExperience
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-06-10 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_remote
@@ -31,9 +30,23 @@ 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: '6.1'
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -67,6 +80,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  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'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -113,16 +140,16 @@ dependencies:
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.80'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.80'
 description: ' Provides "cached" finders and a DSL to enumerate which finders should
   have cached versions '
 email:
@@ -132,8 +159,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
 - ".gitignore"
 - ".rubocop.yml"
+- Appraisals
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -151,11 +180,15 @@ files:
 - spec/active_remote/cached_exist_methods_spec.rb
 - spec/active_remote/cached_find_methods_spec.rb
 - spec/active_remote/cached_search_methods_spec.rb
+- spec/active_remote/cached_spec.rb
 - spec/spec_helper.rb
-homepage: ''
-licenses: []
-metadata: {}
-post_install_message:
+homepage: https://github.com/mxenabled/active_remote-cached
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/mxenabled/active_remote-cached
+  source_code_uri: https://github.com/mxenabled/active_remote-cached
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -163,23 +196,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.6'
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Provides a configuration for caching mechanisms and finders on ActiveRemote
   models
-test_files:
-- spec/active_remote/cached/argument_keys_spec.rb
-- spec/active_remote/cached/cache_spec.rb
-- spec/active_remote/cached_delete_methods_spec.rb
-- spec/active_remote/cached_exist_methods_spec.rb
-- spec/active_remote/cached_find_methods_spec.rb
-- spec/active_remote/cached_search_methods_spec.rb
-- spec/spec_helper.rb
+test_files: []