lhc 6.1.3 → 6.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 20a9521feba97cd8bd75c3af4e7b44ed138a3de0
-  data.tar.gz: d33be7d617ca75e711ee53c725a36cdf4f2efb59
+  metadata.gz: 7caf5dc6e24346cc42e287a8bac832cd81011c5a
+  data.tar.gz: 17bd6df84e9fce4212921c8348b2053031f62da1
 SHA512:
-  metadata.gz: d18302eeeae9e5b4be7cc01b9566cb9e448bf6aa0ee6ca7697e3a2fe4f0dfc68a8e37f21de495ddcd3a84feba6ecedc6bf8f4b5923f81d92d6149c81c8b025a5
-  data.tar.gz: af340762cdca2439f2b5b3e776c95e6a950043f1f159371b5bc2c084f7c02d74ba654e45316e21468a9ae1a4e63b043d11ca96b565ce46308bc104fb67c8f51e
+  metadata.gz: cb849054f246290fe96388ed66abaf3ded5dc8d2a00b7eb7afd857efbfd3d9e820bf0014780c296a37f865c2665cee1b399f1a6d9bc549d48092177cb4885908
+  data.tar.gz: 2f3a0b17c338a1c36dca14e1fa2b3cfc3d1897263cc373a9912a4da9717c5a909677cc4c0fd987ef7e010c964ad2529ae4df816db31384560be826bc28d2256e

data/docs/interceptors/caching.md

@@ -31,23 +31,25 @@ You can also enable caching when configuring an endpoint in LHS.
 Only GET requests are cached by default. If you want to cache any other request method, just configure it:
 
 ```ruby
-  LHC.get('http://local.ch', cache: true, cached_methods: [:post, :head])
+  LHC.get('http://local.ch', cache: { methods: [:get] })
 ```
 
 ## Options
 
 ```ruby
-  LHC.get('http://local.ch', cache: true, cache_expires_in: 1.day, cache_race_condition_ttl: 15.seconds)
+  LHC.get('http://local.ch', cache: { key: 'key' expires_in: 1.day, race_condition_ttl: 15.seconds, use: ActiveSupport::Cache::MemoryStore.new })
 ```
 
-`cache_expires_in` - lets the cache expires every X seconds.
+`expires_in` - lets the cache expires every X seconds.
 
-`cache_key` - Set the key that is used for caching by using the option. Every key is prefixed with `LHC_CACHE(v1): `.
+`key` - Set the key that is used for caching by using the option. Every key is prefixed with `LHC_CACHE(v1): `.
 
-`cache_race_condition_ttl` - very useful in situations where a cache entry is used very frequently and is under heavy load.
+`race_condition_ttl` - very useful in situations where a cache entry is used very frequently and is under heavy load.
 If a cache expires and due to heavy load several different processes will try to read data natively and then they all will try to write to cache.
 To avoid that case the first process to find an expired cache entry will bump the cache expiration time by the value set in `cache_race_condition_ttl`.
 
+`use` - Set an explicit cache to be used for this request. If this option is missing `LHC::Caching.cache` is used.
+
 ## Testing
 
 Add to your spec_helper.rb:

data/lhc.gemspec

@@ -30,6 +30,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'pry'
   s.add_development_dependency 'rubocop', '~> 0.36.0'
   s.add_development_dependency 'rubocop-rspec'
-  
+
   s.license = 'GPL-3'
 end

data/lib/lhc/interceptors/caching.rb

@@ -6,31 +6,64 @@ class LHC::Caching < LHC::Interceptor
   CACHE_VERSION = '1'
 
   # Options forwarded to the cache
-  FORWARDED_OPTIONS = {
-    cache_expires_in: :expires_in,
-    cache_race_condition_ttl: :race_condition_ttl
-  }
+  FORWARDED_OPTIONS = [:expires_in, :race_condition_ttl]
 
   def before_request(request)
-    return unless cache
-    return unless request.options[:cache]
-    return unless cached_method?(request.method, request.options[:cache_methods])
-    cached_response_data = cache.fetch(key(request))
-    return unless cached_response_data
-    logger.info "Served from cache: #{key(request)}" if logger
-    from_cache(request, cached_response_data)
+    return unless cache?(request)
+    deprecation_warning(request.options)
+    options = options(request.options)
+    key = key(request, options[:key])
+    response_data = cache_for(options).fetch(key)
+    return unless response_data
+    logger.info "Served from cache: #{key}" if logger
+    from_cache(request, response_data)
   end
 
   def after_response(response)
-    return unless cache
+    return unless response.success?
     request = response.request
-    return unless cached_method?(request.method, request.options[:cache_methods])
-    return if !request.options[:cache] || !response.success?
-    cache.write(key(request), to_cache(response), options(request.options))
+    return unless cache?(request)
+    options = options(request.options)
+    cache_for(options).write(
+      key(request, options[:key]),
+      to_cache(response),
+      cache_options(options)
+    )
   end
 
   private
 
+  # return the cache for the given options
+  def cache_for(options)
+    options.fetch(:use, cache)
+  end
+
+  # do we even need to bother with this interceptor?
+  # based on the options, this method will
+  # return false if this interceptor cannot work
+  def cache?(request)
+    return false unless request.options[:cache]
+    options = options(request.options)
+    cache_for(options) &&
+      cached_method?(request.method, options[:methods])
+  end
+
+  # returns the request_options
+  # will map deprecated options to the new format
+  def options(request_options)
+    options = request_options[:cache] == true ? {} : request_options[:cache].dup
+    map_deprecated_options!(request_options, options)
+    options
+  end
+
+  # maps `cache_key` -> `key`, `cache_expires_in` -> `expires_in` and so on
+  def map_deprecated_options!(request_options, options)
+    deprecated_keys(request_options).each do |deprecated_key|
+      new_key = deprecated_key.to_s.gsub(/^cache_/, '').to_sym
+      options[new_key] = request_options[deprecated_key]
+    end
+  end
+
   # converts json we read from the cache to an LHC::Response object
   def from_cache(request, data)
     raw = Typhoeus::Response.new(data)
@@ -53,8 +86,7 @@ class LHC::Caching < LHC::Interceptor
     data
   end
 
-  def key(request)
-    key = request.options[:cache_key]
+  def key(request, key)
     unless key
       key = "#{request.method.upcase} #{request.url}"
       key += "?#{request.params.to_query}" unless request.params.blank?
@@ -68,11 +100,26 @@ class LHC::Caching < LHC::Interceptor
     (cached_methods || [:get]).include?(method)
   end
 
-  def options(input = {})
-    options = {}
-    FORWARDED_OPTIONS.each do |k, v|
-      options[v] = input[k] if input.key?(k)
+  # extracts the options that should be forwarded to
+  # the cache
+  def cache_options(input = {})
+    input.each_with_object({}) do |(key, value), result|
+      result[key] = value if key.in? FORWARDED_OPTIONS
+      result
+    end
+  end
+
+  # grabs the deprecated keys from the request options
+  def deprecated_keys(request_options)
+    request_options.keys.select { |k| k =~ /^cache_.*/ }.sort
+  end
+
+  # emits a deprecation warning if necessary
+  def deprecation_warning(request_options)
+    unless deprecated_keys(request_options).empty?
+      ActiveSupport::Deprecation.warn(
+        "Cache options have changed! #{deprecated_keys(request_options).join(', ')} are deprecated and will be removed in future versions."
+      )
     end
-    options
   end
 end

data/lib/lhc/version.rb

@@ -1,3 +1,3 @@
 module LHC
-  VERSION ||= "6.1.3"
+  VERSION ||= "6.2.0"
 end

data/spec/interceptors/caching/main_spec.rb

@@ -11,7 +11,7 @@ describe LHC::Caching do
 
   it 'serves a response from cache' do
     stub
-    LHC.config.endpoint(:local, 'http://local.ch', cache: true, cache_expires_in: 5.minutes)
+    LHC.config.endpoint(:local, 'http://local.ch', cache: { expires_in: 5.minutes })
     expect(Rails.cache).to receive(:write)
       .with(
         "LHC_CACHE(v#{LHC::Caching::CACHE_VERSION}): GET http://local.ch",
@@ -44,7 +44,7 @@ describe LHC::Caching do
   end
 
   it 'lets you configure the cache key that will be used' do
-    LHC.config.endpoint(:local, 'http://local.ch', cache: true, cache_key: 'STATICKEY')
+    LHC.config.endpoint(:local, 'http://local.ch', cache: { key: 'STATICKEY' })
     expect(Rails.cache).to receive(:fetch).with("LHC_CACHE(v#{LHC::Caching::CACHE_VERSION}): STATICKEY").and_call_original
     expect(Rails.cache).to receive(:write).with("LHC_CACHE(v#{LHC::Caching::CACHE_VERSION}): STATICKEY", anything, anything).and_call_original
     stub
@@ -62,7 +62,7 @@ describe LHC::Caching do
 
   it 'marks response not from cache as not served from cache and from cache as served from cache' do
     stub
-    LHC.config.endpoint(:local, 'http://local.ch', cache: true, cache_expires_in: 5.minutes)
+    LHC.config.endpoint(:local, 'http://local.ch', cache: true)
     original_response = LHC.get(:local)
     cached_response = LHC.get(:local)
     expect(original_response.from_cache?).to eq false

data/spec/interceptors/caching/methods_spec.rb

@@ -10,7 +10,7 @@ describe LHC::Caching do
   let!(:stub) { stub_request(:post, 'http://local.ch').to_return(status: 200, body: 'The Website') }
 
   before(:each) do
-    LHC.config.endpoint(:local, 'http://local.ch', cache: true, cache_expires_in: 5.minutes)
+    LHC.config.endpoint(:local, 'http://local.ch', cache: { expires_in: 5.minutes })
   end
 
   it 'only caches GET requests by default' do
@@ -32,8 +32,8 @@ describe LHC::Caching do
         }, { expires_in: 5.minutes }
       )
       .and_call_original
-    original_response = LHC.post(:local, cache_methods: [:post])
-    cached_response = LHC.post(:local, cache_methods: [:post])
+    original_response = LHC.post(:local, cache: { methods: [:post] })
+    cached_response = LHC.post(:local, cache: { methods: [:post] })
     expect(original_response.body).to eq cached_response.body
     expect(original_response.code).to eq cached_response.code
     expect(original_response.headers).to eq cached_response.headers

data/spec/interceptors/caching/options_spec.rb

@@ -0,0 +1,88 @@
+require 'rails_helper'
+
+# due to the fact that options passed into LHC get dup'ed
+# we need a class where we can setup method expectations
+# with `expect_any_instance`
+class CacheMock
+  def fetch(*_)
+  end
+
+  def write(*_)
+  end
+end
+
+describe LHC::Caching do
+  let(:default_cache) { LHC::Caching.cache }
+  before(:each) do
+    stub_request(:get, 'http://local.ch').to_return(status: 200, body: 'The Website')
+    LHC.config.interceptors = [LHC::Caching]
+    default_cache.clear
+  end
+
+  it 'maps deprecated cache options' do
+    expected_options = { expires_in: 5.minutes, race_condition_ttl: 15.seconds }
+    expected_key = "LHC_CACHE(v1): key"
+    expect(default_cache).to receive(:write).with(expected_key, anything, expected_options)
+    expect(lambda {
+      LHC.get('http://local.ch', cache: true, cache_expires_in: 5.minutes, cache_key: 'key', cache_race_condition_ttl: 15.seconds)
+    }).to output(
+      %r{Cache options have changed! cache_expires_in, cache_key, cache_race_condition_ttl are deprecated and will be removed in future versions.}
+    ).to_stderr
+  end
+
+  it 'does cache' do
+    expect(default_cache).to receive(:fetch)
+    expect(default_cache).to receive(:write)
+    LHC.get('http://local.ch', cache: true)
+  end
+
+  it 'does not cache' do
+    expect(default_cache).not_to receive(:fetch)
+    expect(default_cache).not_to receive(:write)
+    LHC.get('http://local.ch')
+  end
+
+  context 'options - directly via LHC.get' do
+    it 'uses the default cache' do
+      expect(default_cache).to receive(:fetch)
+      expect(default_cache).to receive(:write)
+      LHC.get('http://local.ch', cache: true)
+    end
+
+    it 'uses the provided cache' do
+      expect_any_instance_of(CacheMock).to receive(:fetch)
+      expect_any_instance_of(CacheMock).to receive(:write)
+      LHC.get('http://local.ch', cache: { use: CacheMock.new })
+    end
+
+    it 'cache options are properly forwarded to the cache' do
+      cache_options = { expires_in: 5.minutes, race_condition_ttl: 15.seconds }
+      expect(default_cache).to receive(:write).with(anything, anything, cache_options)
+      LHC.get('http://local.ch', cache: cache_options)
+    end
+  end
+
+  context 'options - via endpoint configuration' do
+    it 'uses the default cache' do
+      LHC.config.endpoint(:local, 'http://local.ch', cache: true)
+      expect(default_cache).to receive(:fetch)
+      expect(default_cache).to receive(:write)
+      LHC.get(:local)
+    end
+
+    it 'uses the provided cache' do
+      options = { cache: { use: CacheMock.new } }
+      LHC.config.endpoint(:local, 'http://local.ch', options)
+      expect_any_instance_of(CacheMock).to receive(:fetch)
+      expect_any_instance_of(CacheMock).to receive(:write)
+      LHC.get(:local)
+    end
+
+    it 'cache options are properly forwarded to the cache' do
+      cache_options = { expires_in: 5.minutes, race_condition_ttl: 15.seconds }
+      LHC.config.endpoint(:local, 'http://local.ch', cache: cache_options)
+      expect(default_cache).to receive(:write).with(anything, anything, cache_options)
+      LHC.get(:local)
+    end
+  end
+end

data/spec/interceptors/caching/parameters_spec.rb

@@ -8,7 +8,7 @@ describe LHC::Caching do
     end
 
     it 'considers parameters when writing/reading from cache' do
-      LHC.config.endpoint(:local, 'http://local.ch', cache: true, cache_expires_in: 5.minutes)
+      LHC.config.endpoint(:local, 'http://local.ch', cache: true)
       stub_request(:get, 'http://local.ch').to_return(status: 200, body: 'The Website')
       stub_request(:get, 'http://local.ch?location=zuerich').to_return(status: 200, body: 'The Website for Zuerich')
       expect(

data/spec/interceptors/caching/response_status_spec.rb

@@ -3,7 +3,7 @@ require 'rails_helper'
 describe LHC::Caching do
   before(:each) do
     LHC.config.interceptors = [LHC::Caching]
-    LHC.config.endpoint(:local, 'http://local.ch', cache: true, cache_expires_in: 5.minutes)
+    LHC.config.endpoint(:local, 'http://local.ch', cache: true)
     Rails.cache.clear
     # leverage the Typhoeus internal mock attribute in order to get Typhoeus evaluate the return_code
     # lib/typhoeus/response/status.rb:48

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lhc
 version: !ruby/object:Gem::Version
-  version: 6.1.3
+  version: 6.2.0
 platform: ruby
 authors:
 - https://github.com/local-ch/lhc/contributors
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-10 00:00:00.000000000 Z
+date: 2017-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: typhoeus
@@ -264,6 +264,7 @@ files:
 - spec/interceptors/caching/hydra_spec.rb
 - spec/interceptors/caching/main_spec.rb
 - spec/interceptors/caching/methods_spec.rb
+- spec/interceptors/caching/options_spec.rb
 - spec/interceptors/caching/parameters_spec.rb
 - spec/interceptors/caching/response_status_spec.rb
 - spec/interceptors/caching/to_cache_spec.rb
@@ -390,6 +391,7 @@ test_files:
 - spec/interceptors/caching/hydra_spec.rb
 - spec/interceptors/caching/main_spec.rb
 - spec/interceptors/caching/methods_spec.rb
+- spec/interceptors/caching/options_spec.rb
 - spec/interceptors/caching/parameters_spec.rb
 - spec/interceptors/caching/response_status_spec.rb
 - spec/interceptors/caching/to_cache_spec.rb