dhc 1.0.0

data/spec/interceptors/caching/multilevel_cache_spec.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC::Caching do
+  let(:redis_url) { 'redis://localhost:6379/0' }
+  let(:redis_cache) do
+    spy('ActiveSupport::Cache::RedisCacheStore')
+  end
+
+  before do
+    Rails.cache.clear
+    DHC.config.interceptors = [DHC::Caching]
+    ActiveSupport::Cache::RedisCacheStore.new(url: redis_url).clear
+    allow(ActiveSupport::Cache::RedisCacheStore).to receive(:new).and_return(redis_cache)
+    allow(redis_cache).to receive(:present?).and_return(true)
+  end
+
+  let!(:request_stub) do
+    stub_request(:get, 'http://depay.fi/')
+      .to_return(body: '<h1>Hi there</h1>')
+  end
+
+  def request
+    DHC.get('http://depay.fi', cache: true)
+  end
+
+  def response_has_been_cached_and_served_from_cache!
+    original_response = request
+    cached_response = request
+
+    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
+    expect(original_response.options[:return_code]).to eq cached_response.options[:return_code]
+    expect(original_response.mock).to eq cached_response.mock
+
+    assert_requested request_stub, times: 1
+  end
+
+  context 'only local cache has been configured' do
+    before do
+      DHC::Caching.cache = Rails.cache
+    end
+
+    it 'serves a response from local cache without trying the central cache' do
+      expect(Rails.cache).to receive(:fetch).at_least(:once).and_call_original
+      expect(Rails.cache).to receive(:write).and_call_original
+      expect(-> { response_has_been_cached_and_served_from_cache! })
+        .to output(%{[DHC] served from local cache: "DHC_CACHE(v1): GET http://depay.fi"\n}).to_stdout
+    end
+  end
+
+  context 'local and central cache have been configured' do
+    before do
+      DHC::Caching.cache = Rails.cache
+      DHC::Caching.central = {
+        read: redis_url,
+        write: redis_url
+      }
+    end
+
+    context 'found in central cache' do
+      it 'serves it from central cache if found there' do
+        expect(redis_cache).to receive(:fetch).and_return(nil,
+                                                            body: '<h1>Hi there</h1>', code: 200, headers: nil, return_code: nil, mock: :webmock)
+        expect(redis_cache).to receive(:write).and_return(true)
+        expect(Rails.cache).to receive(:fetch).and_call_original
+        expect(Rails.cache).to receive(:write).and_call_original
+        expect(-> { response_has_been_cached_and_served_from_cache! })
+          .to output(%{[DHC] served from central cache: "DHC_CACHE(v1): GET http://depay.fi"\n}).to_stdout
+      end
+    end
+
+    context 'not found in central cache' do
+      it 'serves it from local cache if found there' do
+        expect(redis_cache).to receive(:fetch).and_return(nil, nil)
+        expect(redis_cache).to receive(:write).and_return(true)
+        expect(Rails.cache).to receive(:fetch).at_least(:once).and_call_original
+        expect(Rails.cache).to receive(:write).and_call_original
+        expect(-> { response_has_been_cached_and_served_from_cache! })
+          .to output(%{[DHC] served from local cache: "DHC_CACHE(v1): GET http://depay.fi"\n}).to_stdout
+      end
+    end
+  end
+
+  context 'only central read configured' do
+    before do
+      DHC::Caching.cache = Rails.cache
+      DHC::Caching.central = {
+        read: redis_url
+      }
+    end
+
+    it 'still serves responses from cache, but does not write them back' do
+      expect(redis_cache).to receive(:fetch).and_return(nil, body: '<h1>Hi there</h1>', code: 200, headers: nil, return_code: nil, mock: :webmock)
+      expect(redis_cache).not_to receive(:write)
+      expect(Rails.cache).to receive(:fetch).and_call_original
+      expect(Rails.cache).to receive(:write).and_call_original
+      expect(-> { response_has_been_cached_and_served_from_cache! })
+        .to output(%{[DHC] served from central cache: "DHC_CACHE(v1): GET http://depay.fi"\n}).to_stdout
+    end
+  end
+
+  context 'only central write configured' do
+    before do
+      DHC::Caching.cache = Rails.cache
+      DHC::Caching.central = {
+        write: redis_url
+      }
+    end
+
+    it 'still writes responses to cache, but does not retrieve them from there' do
+      expect(redis_cache).not_to receive(:fetch)
+      expect(redis_cache).to receive(:write).and_return(true)
+      expect(Rails.cache).to receive(:fetch).at_least(:once).and_call_original
+      expect(Rails.cache).to receive(:write).and_call_original
+      expect(-> { response_has_been_cached_and_served_from_cache! })
+        .to output(%{[DHC] served from local cache: "DHC_CACHE(v1): GET http://depay.fi"\n}).to_stdout
+    end
+  end
+
+  context 'central cache configured only' do
+    before do
+      DHC::Caching.cache = nil
+      DHC::Caching.central = {
+        read: redis_url,
+        write: redis_url
+      }
+    end
+
+    it 'does not inquire the local cache for information neither to write them' do
+      expect(redis_cache).to receive(:fetch).and_return(nil, body: '<h1>Hi there</h1>', code: 200, headers: nil, return_code: nil, mock: :webmock)
+      expect(redis_cache).to receive(:write).and_return(true)
+      expect(-> { response_has_been_cached_and_served_from_cache! })
+        .to output(%{[DHC] served from central cache: "DHC_CACHE(v1): GET http://depay.fi"\n}).to_stdout
+    end
+  end
+end

data/spec/interceptors/caching/options_spec.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+# due to the fact that options passed into DHC 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 DHC::Caching do
+  let(:default_cache) { DHC::Caching.cache }
+
+  before(:each) do
+    stub_request(:get, 'http://depay.fi').to_return(status: 200, body: 'The Website')
+    DHC.config.interceptors = [DHC::Caching]
+    default_cache.clear
+  end
+
+  it 'does cache' do
+    expect(default_cache).to receive(:fetch)
+    expect(default_cache).to receive(:write)
+    DHC.get('http://depay.fi', cache: true)
+  end
+
+  it 'does not cache' do
+    expect(default_cache).not_to receive(:fetch)
+    expect(default_cache).not_to receive(:write)
+    DHC.get('http://depay.fi')
+  end
+
+  context 'options - directly via DHC.get' do
+    it 'uses the default cache' do
+      expect(default_cache).to receive(:fetch)
+      expect(default_cache).to receive(:write)
+      DHC.get('http://depay.fi', 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)
+      DHC.get('http://depay.fi', 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)
+      DHC.get('http://depay.fi', cache: cache_options)
+    end
+  end
+
+  context 'options - via endpoint configuration' do
+    it 'uses the default cache' do
+      DHC.config.endpoint(:local, 'http://depay.fi', cache: true)
+      expect(default_cache).to receive(:fetch)
+      expect(default_cache).to receive(:write)
+      DHC.get(:local)
+    end
+
+    it 'uses the provided cache' do
+      options = { cache: { use: CacheMock.new } }
+      DHC.config.endpoint(:local, 'http://depay.fi', options)
+      expect_any_instance_of(CacheMock).to receive(:fetch)
+      expect_any_instance_of(CacheMock).to receive(:write)
+      DHC.get(:local)
+    end
+
+    it 'cache options are properly forwarded to the cache' do
+      cache_options = { expires_in: 5.minutes, race_condition_ttl: 15.seconds }
+      DHC.config.endpoint(:local, 'http://depay.fi', cache: cache_options)
+      expect(default_cache).to receive(:write).with(anything, anything, cache_options)
+      DHC.get(:local)
+    end
+  end
+end

data/spec/interceptors/caching/parameters_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC::Caching do
+  context 'parameters' do
+    before(:each) do
+      DHC.config.interceptors = [DHC::Caching]
+      Rails.cache.clear
+    end
+
+    it 'considers parameters when writing/reading from cache' do
+      DHC.config.endpoint(:local, 'http://depay.fi', cache: true)
+      stub_request(:get, 'http://depay.fi').to_return(status: 200, body: 'The Website')
+      stub_request(:get, 'http://depay.fi?location=zuerich').to_return(status: 200, body: 'The Website for Zuerich')
+      expect(
+        DHC.get(:local).body
+      ).to eq 'The Website'
+      expect(
+        DHC.get(:local, params: { location: 'zuerich' }).body
+      ).to eq 'The Website for Zuerich'
+    end
+  end
+end

data/spec/interceptors/caching/response_status_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC::Caching do
+  before(:each) do
+    DHC.config.interceptors = [DHC::Caching]
+    DHC.config.endpoint(:local, 'http://depay.fi', 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
+    allow_any_instance_of(Typhoeus::Response).to receive(:mock).and_return(false)
+  end
+
+  let!(:stub) { stub_request(:get, 'http://depay.fi').to_return(status: 200, body: 'The Website') }
+
+  it 'provides the correct response status for responses from cache' do
+    stub
+    # the real request provides the return_code
+    allow_any_instance_of(Typhoeus::Response).to receive(:options)
+      .and_return(code: 200, status_message: '', body: 'The Website', headers: nil, return_code: :ok)
+    response = DHC.get(:local)
+    expect(response.success?).to eq true
+    # the cached response should get it from the cache
+    allow_any_instance_of(Typhoeus::Response).to receive(:options).and_call_original
+    cached_response = DHC.get(:local)
+    expect(cached_response.success?).to eq true
+  end
+end

data/spec/interceptors/caching/to_cache_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC::Caching do
+  context 'to_cache' do
+    it 'returns a marshalable object to store in the cache' do
+      expect do
+        response = Typhoeus::Response.new(headers: { 'Accept' => 'application/json' })
+        Marshal.dump(
+          DHC::Caching.new(response).send(:to_cache, response)
+        )
+      end.not_to raise_error
+    end
+  end
+end

data/spec/interceptors/default_interceptors_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC do
+  context 'default interceptors' do
+    before(:each) do
+      DHC.configure {}
+    end
+
+    it 'alwayses return a list for default interceptors' do
+      expect(DHC.config.interceptors).to eq []
+    end
+  end
+end

data/spec/interceptors/default_timeout/main_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC::DefaultTimeout do
+  before(:each) do
+    DHC.config.interceptors = [DHC::DefaultTimeout]
+    DHC::DefaultTimeout.timeout = nil
+    DHC::DefaultTimeout.connecttimeout = nil
+  end
+
+  let(:stub) { stub_request(:get, 'http://depay.fi').to_return(status: 200, body: 'The Website') }
+
+  it 'applies default timeouts to all requests made' do
+    stub
+    expect_any_instance_of(Ethon::Easy).to receive(:http_request)
+      .with(anything, anything, hash_including(timeout: 15, connecttimeout: 2)).and_call_original
+    DHC.get('http://depay.fi')
+  end
+
+  context 'with changed default timesouts' do
+    before(:each) do
+      DHC::DefaultTimeout.timeout = 10
+      DHC::DefaultTimeout.connecttimeout = 3
+    end
+
+    it 'applies custom default timeouts to all requests made' do
+      stub
+      expect_any_instance_of(Ethon::Easy).to receive(:http_request)
+        .with(anything, anything, hash_including(timeout: 10, connecttimeout: 3)).and_call_original
+      DHC.get('http://depay.fi')
+    end
+  end
+end

data/spec/interceptors/define_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC do
+  context 'interceptor' do
+    before(:each) do
+      class SomeInterceptor < DHC::Interceptor
+      end
+
+      class AnotherInterceptor < DHC::Interceptor
+      end
+    end
+
+    it 'performs interceptor when they are set globally' do
+      DHC.configure { |c| c.interceptors = [SomeInterceptor] }
+      expect_any_instance_of(SomeInterceptor).to receive(:before_request)
+      stub_request(:get, 'http://depay.fi')
+      DHC.get('http://depay.fi')
+    end
+
+    it 'overrides interceptors on request level' do
+      DHC.configure { |c| c.interceptors = [SomeInterceptor] }
+      expect_any_instance_of(AnotherInterceptor).to receive(:before_request)
+      expect_any_instance_of(SomeInterceptor).not_to receive(:before_request)
+      stub_request(:get, 'http://depay.fi')
+      DHC.get('http://depay.fi', interceptors: [AnotherInterceptor])
+    end
+  end
+end

data/spec/interceptors/dup_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC do
+  context 'interceptor' do
+    before(:each) do
+      class SomeInterceptor < DHC::Interceptor
+      end
+    end
+
+    it 'does not dup' do
+      options = { interceptors: [SomeInterceptor] }
+      expect(
+        options.deep_dup[:interceptors].include?(SomeInterceptor)
+      ).to eq true
+    end
+  end
+end

data/spec/interceptors/logging/main_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC::Logging do
+  let(:logger) { spy('logger') }
+
+  before(:each) do
+    DHC.config.interceptors = [DHC::Logging]
+    DHC::Logging.logger = logger
+    stub_request(:get, 'http://depay.fi').to_return(status: 200)
+  end
+
+  it 'does log information before and after every request made with DHC' do
+    DHC.get('http://depay.fi')
+    expect(logger).to have_received(:info).once.with(
+      %r{Before DHC request <\d+> GET http://depay.fi at \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\+\d{2}:\d{2} Params={} Headers={.*?}}
+    )
+    expect(logger).to have_received(:info).once.with(
+      %r{After DHC response for request <\d+> GET http://depay.fi at \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\+\d{2}:\d{2} Time=0ms URL=http://depay.fi:80/}
+    )
+  end
+
+  context 'source' do
+    let(:source) { '/Users/Sebastian/DHC/test.rb' }
+
+    it 'does log the source if provided as option' do
+      DHC.get('http://depay.fi', source: source)
+      expect(logger).to have_received(:info).once.with(
+        %r{Before DHC request <\d+> GET http://depay.fi at \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\+\d{2}:\d{2} Params={} Headers={.*?} \nCalled from #{source}}
+      )
+      expect(logger).to have_received(:info).once.with(
+        %r{After DHC response for request <\d+> GET http://depay.fi at \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\+\d{2}:\d{2} Time=0ms URL=http://depay.fi:80/ \nCalled from #{source}}
+      )
+    end
+  end
+end

data/spec/interceptors/monitoring/caching_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC::Monitoring do
+  let(:stub) do
+    stub_request(:get, 'http://depay.fi').to_return(status: 200, body: 'The Website')
+  end
+
+  module Statsd
+    def self.count(_path, _value); end
+
+    def self.timing(_path, _value); end
+  end
+
+  before(:each) do
+    DHC::Monitoring.statsd = Statsd
+    Rails.cache.clear
+    allow(Statsd).to receive(:count).with('dhc.dummy.test.depay_fi.get.before_request', 1)
+    allow(Statsd).to receive(:count).with('dhc.dummy.test.depay_fi.get.count', 1)
+    allow(Statsd).to receive(:count).with('dhc.dummy.test.depay_fi.get.after_request', 1)
+    allow(Statsd).to receive(:count).with('dhc.dummy.test.depay_fi.get.200', 1)
+  end
+
+  context 'interceptors configured correctly' do
+    before do
+      DHC.config.interceptors = [DHC::Caching, DHC::Monitoring]
+    end
+
+    context 'requesting with cache option' do
+      it 'monitors miss/hit for caching' do
+        stub
+        expect(Statsd).to receive(:count).with('dhc.dummy.test.depay_fi.get.cache.miss', 1)
+        expect(Statsd).to receive(:count).with('dhc.dummy.test.depay_fi.get.cache.hit', 1)
+        DHC.get('http://depay.fi', cache: true)
+        DHC.get('http://depay.fi', cache: true)
+      end
+    end
+
+    context 'request uncached' do
+      it 'requesting without cache option' do
+        stub
+        expect(Statsd).not_to receive(:count).with('dhc.dummy.test.depay_fi.get.cache.miss', 1)
+        expect(Statsd).not_to receive(:count).with('dhc.dummy.test.depay_fi.get.cache.hit', 1)
+        DHC.get('http://depay.fi')
+        DHC.get('http://depay.fi')
+      end
+    end
+  end
+
+  context 'wrong interceptor order' do
+    before(:each) do
+      DHC.config.interceptors = [DHC::Monitoring, DHC::Caching] # monitoring needs to be after Caching
+    end
+
+    it 'does monitors miss/hit for caching and warns about wrong order of interceptors' do
+      stub
+      expect(Statsd).not_to receive(:count).with('dhc.dummy.test.depay_fi.get.cache.miss', 1)
+      expect(Statsd).not_to receive(:count).with('dhc.dummy.test.depay_fi.get.cache.hit', 1)
+      expect(-> {
+        DHC.get('http://depay.fi', cache: true)
+        DHC.get('http://depay.fi', cache: true)
+      }).to output("[WARNING] Your interceptors must include DHC::Caching and DHC::Monitoring and also in that order.\n[WARNING] Your interceptors must include DHC::Caching and DHC::Monitoring and also in that order.\n").to_stderr
+    end
+  end
+end