dhc 1.0.0

data/spec/interceptors/monitoring/main_spec.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC::Monitoring do
+  let(:stub) { stub_request(:get, 'http://depay.fi').to_return(status: 200, body: 'The Website') }
+  let(:endpoint_configuration) { DHC.config.endpoint(:local, 'http://depay.fi') }
+
+  module Statsd
+    def self.count(_path, _value); end
+
+    def self.timing(_path, _value); end
+  end
+
+  before(:each) do
+    DHC.config.interceptors = [DHC::Monitoring]
+    DHC::Monitoring.statsd = Statsd
+    Rails.cache.clear
+    endpoint_configuration
+  end
+
+  it 'does not report anything if no statsd is configured' do
+    stub
+    DHC.get(:local) # and also does not crash ;)
+  end
+
+  context 'statsd configured' do
+    it 'reports trial, response and timing by default ' do
+      stub
+      expect(Statsd).to receive(:count).with('dhc.dummy.test.depay_fi.get.before_request', 1)
+      expect(Statsd).to receive(:count).with('dhc.dummy.test.depay_fi.get.after_request', 1)
+      expect(Statsd).to receive(:count).with('dhc.dummy.test.depay_fi.get.count', 1)
+      expect(Statsd).to receive(:count).with('dhc.dummy.test.depay_fi.get.200', 1)
+      expect(Statsd).to receive(:timing).with('dhc.dummy.test.depay_fi.get.time', anything)
+      DHC.get(:local)
+    end
+
+    it 'does not report timing when response failed' do
+      stub_request(:get, 'http://depay.fi').to_return(status: 500)
+      expect(Statsd).to receive(:count).with('dhc.dummy.test.depay_fi.get.before_request', 1)
+      expect(Statsd).to receive(:count).with('dhc.dummy.test.depay_fi.get.after_request', 1)
+      expect(Statsd).to receive(:count).with('dhc.dummy.test.depay_fi.get.count', 1)
+      expect(Statsd).to receive(:count).with('dhc.dummy.test.depay_fi.get.500', 1)
+      expect(Statsd).not_to receive(:timing)
+      expect { DHC.get(:local) }.to raise_error DHC::ServerError
+    end
+
+    it 'reports timeout instead of status code if response timed out' do
+      stub_request(:get, 'http://depay.fi').to_timeout
+      expect(Statsd).to receive(:count).with('dhc.dummy.test.depay_fi.get.before_request', 1)
+      expect(Statsd).to receive(:count).with('dhc.dummy.test.depay_fi.get.after_request', 1)
+      expect(Statsd).to receive(:count).with('dhc.dummy.test.depay_fi.get.count', 1)
+      expect(Statsd).to receive(:count).with('dhc.dummy.test.depay_fi.get.timeout', 1)
+      expect(Statsd).not_to receive(:timing)
+      expect { DHC.get(:local) }.to raise_error DHC::Timeout
+    end
+
+    it 'allows to set the stats key for request' do
+      stub
+      expect(Statsd).to receive(:count).with('defined_key.before_request', 1)
+      expect(Statsd).to receive(:count).with('defined_key.after_request', 1)
+      expect(Statsd).to receive(:count).with('defined_key.count', 1)
+      expect(Statsd).to receive(:count).with('defined_key.200', 1)
+      expect(Statsd).to receive(:timing).with('defined_key.time', anything)
+      DHC.get(:local, monitoring_key: 'defined_key')
+    end
+  end
+
+  context 'without protocol' do
+    let(:endpoint_configuration) { DHC.config.endpoint(:local, 'depay.fi') }
+
+    it 'reports trial, response and timing by default ' do
+      stub
+      expect(Statsd).to receive(:count).with('dhc.dummy.test.depay_fi.get.before_request', 1)
+      expect(Statsd).to receive(:count).with('dhc.dummy.test.depay_fi.get.after_request', 1)
+      expect(Statsd).to receive(:count).with('dhc.dummy.test.depay_fi.get.count', 1)
+      expect(Statsd).to receive(:count).with('dhc.dummy.test.depay_fi.get.200', 1)
+      expect(Statsd).to receive(:timing).with('dhc.dummy.test.depay_fi.get.time', anything)
+      DHC.get(:local)
+    end
+  end
+
+  context 'with configured environment' do
+    before do
+      DHC::Monitoring.env = 'beta'
+    end
+
+    it 'uses the configured env' do
+      stub
+      expect(Statsd).to receive(:count).with('dhc.dummy.beta.depay_fi.get.before_request', 1)
+      expect(Statsd).to receive(:count).with('dhc.dummy.beta.depay_fi.get.after_request', 1)
+      expect(Statsd).to receive(:count).with('dhc.dummy.beta.depay_fi.get.count', 1)
+      expect(Statsd).to receive(:count).with('dhc.dummy.beta.depay_fi.get.200', 1)
+      DHC.get(:local)
+    end
+  end
+end

data/spec/interceptors/prometheus_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+require 'prometheus/client'
+
+describe DHC::Prometheus do
+  before(:each) do
+    DHC.config.interceptors = [DHC::Prometheus]
+    DHC::Prometheus.client = Prometheus::Client
+    DHC::Prometheus.namespace = 'test_app'
+    stub_request(:get, 'http://depay.fi')
+    expect(Prometheus::Client).to receive(:registry).and_call_original.at_least(:once)
+  end
+
+  let(:client) { double('prometheus/client') }
+
+  context 'registering' do
+    it 'creates a counter and histogram registry in the prometheus client' do
+      expect(Prometheus::Client.registry).to receive(:counter).and_call_original.once
+        .with(:dhc_requests, 'Counter of all DHC requests.')
+      expect(Prometheus::Client.registry).to receive(:histogram).and_call_original.once
+        .with(:dhc_request_seconds, 'Request timings for all DHC requests in seconds.')
+
+      DHC.get('http://depay.fi')
+      DHC.get('http://depay.fi') # second request, registration should happen only once
+    end
+  end
+
+  context 'logging' do
+    let(:requests_registry_double) { double('requests_registry_double') }
+    let(:times_registry_double) { double('times_registry_double') }
+
+    it 'logs monitoring information to the created registries' do
+      expect(Prometheus::Client.registry).to receive(:get).and_return(requests_registry_double).once
+        .with(:dhc_requests)
+      expect(Prometheus::Client.registry).to receive(:get).and_return(times_registry_double).once
+        .with(:dhc_request_seconds)
+
+      expect(requests_registry_double).to receive(:increment).once
+        .with(
+          code: 200,
+          success: true,
+          timeout: false,
+          app: 'test_app',
+          host: 'depay.fi'
+        )
+
+      expect(times_registry_double).to receive(:observe).once
+        .with({ host: 'depay.fi', app: 'test_app' }, 0)
+
+      DHC.get('http://depay.fi')
+    end
+  end
+end

data/spec/interceptors/response_competition_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC do
+  context 'interceptor response competition' do
+    before(:each) do
+      class LocalCacheInterceptor < DHC::Interceptor
+        @@cached = false
+        cattr_accessor :cached
+
+        def before_request
+          if @@cached
+            return DHC::Response.new(Typhoeus::Response.new(response_code: 200, return_code: :ok, response_body: 'Im served from local cache'), nil)
+          end
+        end
+      end
+
+      class RemoteCacheInterceptor < DHC::Interceptor
+
+        def before_request
+          if request.response.nil?
+            return DHC::Response.new(Typhoeus::Response.new(response_code: 200, return_code: :ok, response_body: 'Im served from remote cache'), nil)
+          end
+        end
+      end
+
+      DHC.configure { |c| c.interceptors = [LocalCacheInterceptor, RemoteCacheInterceptor] }
+    end
+
+    it 'can handle multiple interceptors that compete for returning the response' do
+      response = DHC.get('http://depay.fi')
+      expect(response.body).to eq 'Im served from remote cache'
+      LocalCacheInterceptor.cached = true
+      response = DHC.get('http://depay.fi')
+      expect(response.body).to eq 'Im served from local cache'
+    end
+  end
+end

data/spec/interceptors/retry/main_spec.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC::Rollbar do
+  before(:each) do
+    DHC.config.interceptors = [DHC::Retry]
+  end
+
+  let(:status) { 500 }
+
+  let(:request_stub) do
+    @retry_count = 0
+    stub_request(:get, 'http://depay.fi').to_return do |_|
+      if @retry_count == max_retry_count
+        { status: 200 }
+      else
+        @retry_count += 1
+        { status: status }
+      end
+    end
+  end
+
+  let(:max_retry_count) { 3 }
+
+  it 'retries a request up to 3 times (default)' do
+    request_stub
+    response = DHC.get('http://depay.fi', retry: true)
+    expect(response.success?).to eq true
+    expect(response.code).to eq 200
+    expect(request_stub).to have_been_requested.times(4)
+  end
+
+  context 'retry only once' do
+    let(:retry_options) { { max: 1 } }
+    let(:max_retry_count) { 1 }
+
+    it 'retries only once' do
+      request_stub
+      response = DHC.get('http://depay.fi', retry: { max: 1 })
+      expect(response.success?).to eq true
+      expect(response.code).to eq 200
+      expect(request_stub).to have_been_requested.times(2)
+    end
+  end
+
+  context 'retry all' do
+    let(:max_retry_count) { 2 }
+
+    before do
+      expect(DHC::Retry).to receive(:max).at_least(:once).and_return(2)
+      expect(DHC::Retry).to receive(:all).at_least(:once).and_return(true)
+    end
+
+    it 'retries if configured globally' do
+      request_stub
+      response = DHC.get('http://depay.fi')
+      expect(response.success?).to eq true
+      expect(response.code).to eq 200
+      expect(request_stub).to have_been_requested.times(3)
+    end
+  end
+
+  context 'ignore error' do
+    let(:status) { 404 }
+
+    it 'does not retry if the error is explicitly ignored' do
+      request_stub
+      DHC.get('http://depay.fi', retry: { max: 1 }, ignore: [DHC::NotFound])
+      expect(request_stub).to have_been_requested.times(1)
+    end
+  end
+end

data/spec/interceptors/return_response_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC do
+  context 'interceptor' do
+    before(:each) do
+      class CacheInterceptor < DHC::Interceptor
+
+        def before_request
+          DHC::Response.new(Typhoeus::Response.new(response_code: 200, return_code: :ok, response_body: 'Im served from cache'), nil)
+        end
+      end
+      DHC.configure { |c| c.interceptors = [CacheInterceptor] }
+    end
+
+    it 'can return a response rather then doing a real request' do
+      response = DHC.get('http://depay.fi')
+      expect(response.body).to eq 'Im served from cache'
+    end
+
+    context 'misusage' do
+      before(:each) do
+        class AnotherInterceptor < DHC::Interceptor
+          def before_request
+            DHC::Response.new(Typhoeus::Response.new(response_code: 200, return_code: :ok), nil)
+          end
+        end
+      end
+
+      it 'raises an exception when two interceptors try to return a response' do
+        expect(lambda {
+          DHC.get('http://depay.fi', interceptors: [CacheInterceptor, AnotherInterceptor])
+        }).to raise_error 'Response already set from another interceptor'
+      end
+    end
+  end
+end

data/spec/interceptors/rollbar/invalid_encoding_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC::Rollbar do
+  context 'invalid encoding in rollbar payload' do
+    before(:each) do
+      DHC.config.interceptors = [DHC::Rollbar]
+      stub_request(:get, 'http://depay.fi').to_return(status: 400)
+
+      allow(described_class).to receive(:fix_invalid_encoding).and_call_original
+      # a stub that will throw a error on first call and suceed on subsequent calls
+      call_counter = 0
+      class Rollbar; end
+      ::Rollbar.stub(:warning) do
+        call_counter += 1
+        raise Encoding::UndefinedConversionError if call_counter == 1
+      end
+
+      # the response for the caller is still DHC::BadRequest
+      expect(-> { DHC.get('http://depay.fi', rollbar: { additional: invalid }) }).to raise_error DHC::BadRequest
+    end
+
+    let(:invalid) { (+"in\xc3lid").force_encoding('ASCII-8BIT') }
+    let(:valid) { described_class.fix_invalid_encoding(invalid) }
+
+    it 'calls fix_invalid_encoding incase a Encoding::UndefinedConversionError was encountered' do
+      expect(described_class).to have_received(:fix_invalid_encoding).with(invalid)
+    end
+
+    it 'calls Rollbar.warn with the fixed data' do
+      expect(::Rollbar).to have_received(:warning)
+        .with(
+          'Status: 400 URL: http://depay.fi',
+          hash_including(
+            response: anything,
+            request: anything,
+            additional: valid
+          )
+        )
+    end
+  end
+end

data/spec/interceptors/rollbar/main_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC::Rollbar do
+  before(:each) do
+    DHC.config.interceptors = [DHC::Rollbar]
+  end
+
+  context 'Rollbar is undefined' do
+    before(:each) do
+      Object.send(:remove_const, 'Rollbar') if Object.const_defined?('Rollbar')
+    end
+    it 'does not report' do
+      stub_request(:get, 'http://depay.fi').to_return(status: 400)
+      expect(-> { DHC.get('http://depay.fi') })
+        .to raise_error DHC::BadRequest
+    end
+  end
+
+  context 'Rollbar is defined' do
+    before(:each) do
+      class Rollbar; end
+      ::Rollbar.stub(:warning)
+    end
+
+    it 'does report errors to rollbar' do
+      stub_request(:get, 'http://depay.fi').to_return(status: 400)
+      expect(-> { DHC.get('http://depay.fi') })
+        .to raise_error DHC::BadRequest
+      expect(::Rollbar).to have_received(:warning)
+        .with(
+          'Status: 400 URL: http://depay.fi',
+          response: hash_including(body: anything, code: anything, headers: anything, time: anything, timeout?: anything),
+          request: hash_including(url: anything, method: anything, headers: anything, params: anything)
+        )
+    end
+
+    context 'additional params' do
+      it 'does report errors to rollbar with additional data' do
+        stub_request(:get, 'http://depay.fi')
+          .to_return(status: 400)
+        expect(-> { DHC.get('http://depay.fi', rollbar: { additional: 'data' }) })
+          .to raise_error DHC::BadRequest
+        expect(::Rollbar).to have_received(:warning)
+          .with(
+            'Status: 400 URL: http://depay.fi',
+            hash_including(
+              response: anything,
+              request: anything,
+              additional: 'data'
+            )
+          )
+      end
+    end
+  end
+end

data/spec/interceptors/throttle/main_spec.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC::Throttle do
+  let(:options_break) { false }
+  let(:options_expires) { { header: 'reset' } }
+  let(:options_limit) { { header: 'limit' } }
+  let(:options_remaining) { { header: 'remaining' } }
+  let(:provider) { 'depay.fi' }
+  let(:quota_limit) { 10_000 }
+  let(:quota_remaining) { 1900 }
+  let(:quota_reset) { (Time.zone.now + 1.hour).to_i }
+  let(:options) do
+    {
+      throttle: {
+        provider: provider,
+        track: true,
+        limit: options_limit,
+        remaining: options_remaining,
+        expires: options_expires,
+        break: options_break
+      }
+    }
+  end
+
+  before(:each) do
+    DHC::Throttle.track = nil
+    DHC.config.interceptors = [DHC::Throttle]
+
+    stub_request(:get, 'http://depay.fi').to_return(
+      headers: { 'limit' => quota_limit, 'remaining' => quota_remaining, 'reset' => quota_reset }
+    )
+  end
+
+  it 'tracks the request limits based on response data' do
+    DHC.get('http://depay.fi', options)
+    expect(DHC::Throttle.track[provider][:limit]).to eq quota_limit
+    expect(DHC::Throttle.track[provider][:remaining]).to eq quota_remaining
+  end
+
+  context 'fix predefined integer for limit' do
+    let(:options_limit) { 1000 }
+
+    it 'tracks the limit based on initialy provided data' do
+      DHC.get('http://depay.fi', options)
+      expect(DHC::Throttle.track[provider][:limit]).to eq options_limit
+    end
+  end
+
+  context 'breaks' do
+    let(:options_break) { '80%' }
+
+    it 'hit the breaks if throttling quota is reached' do
+      DHC.get('http://depay.fi', options)
+      expect { DHC.get('http://depay.fi', options) }.to raise_error(
+        DHC::Throttle::OutOfQuota,
+        'Reached predefined quota for depay.fi'
+      )
+    end
+
+    context 'still within quota' do
+      let(:options_break) { '90%' }
+
+      it 'does not hit the breaks' do
+        DHC.get('http://depay.fi', options)
+        DHC.get('http://depay.fi', options)
+      end
+    end
+  end
+
+  context 'no response headers' do
+    before { stub_request(:get, 'http://depay.fi').to_return(status: 200) }
+
+    it 'does not raise an exception' do
+      DHC.get('http://depay.fi', options)
+    end
+
+    context 'no remaining tracked, but break enabled' do
+      let(:options_break) { '90%' }
+
+      it 'does not fail if a remaining was not tracked yet' do
+        DHC.get('http://depay.fi', options)
+        DHC.get('http://depay.fi', options)
+      end
+    end
+  end
+
+  context 'expires' do
+    let(:options_break) { '80%' }
+
+    it 'attempts another request if the quota expired' do
+      DHC.get('http://depay.fi', options)
+      expect { DHC.get('http://depay.fi', options) }.to raise_error(
+        DHC::Throttle::OutOfQuota,
+        'Reached predefined quota for depay.fi'
+      )
+      Timecop.travel(Time.zone.now + 2.hours)
+      DHC.get('http://depay.fi', options)
+    end
+  end
+
+  describe 'configuration values as Procs' do
+    describe 'calculate "limit" in proc' do
+      let(:options_limit) do
+        ->(*) { 10_000 }
+      end
+
+      before(:each) do
+        DHC.get('http://depay.fi', options)
+      end
+
+      context 'breaks' do
+        let(:options_break) { '80%' }
+
+        it 'hit the breaks if throttling quota is reached' do
+          expect { DHC.get('http://depay.fi', options) }.to raise_error(
+            DHC::Throttle::OutOfQuota,
+            'Reached predefined quota for depay.fi'
+          )
+        end
+
+        context 'still within quota' do
+          let(:options_break) { '90%' }
+
+          it 'does not hit the breaks' do
+            DHC.get('http://depay.fi', options)
+          end
+        end
+      end
+    end
+
+    describe 'calculate "remaining" in proc' do
+      let(:quota_current) { 8100 }
+      let(:options_remaining) do
+        ->(response) { response.headers['limit'].to_i - response.headers['current'].to_i }
+      end
+
+      before(:each) do
+        stub_request(:get, 'http://depay.fi').to_return(
+          headers: { 'limit' => quota_limit, 'current' => quota_current, 'reset' => quota_reset }
+        )
+        DHC.get('http://depay.fi', options)
+      end
+
+      context 'breaks' do
+        let(:options_break) { '80%' }
+
+        it 'hit the breaks if throttling quota is reached' do
+          expect { DHC.get('http://depay.fi', options) }.to raise_error(
+            DHC::Throttle::OutOfQuota,
+            'Reached predefined quota for depay.fi'
+          )
+        end
+
+        context 'still within quota' do
+          let(:options_break) { '90%' }
+
+          it 'does not hit the breaks' do
+            DHC.get('http://depay.fi', options)
+          end
+        end
+      end
+    end
+
+    describe 'calculate "reset" in proc' do
+      let(:options_expires) { ->(*) { Time.zone.now + 1.second } }
+
+      before(:each) do
+        stub_request(:get, 'http://depay.fi').to_return(
+          headers: { 'limit' => quota_limit, 'remaining' => quota_remaining }
+        )
+        DHC.get('http://depay.fi', options)
+      end
+
+      context 'breaks' do
+        let(:options_break) { '80%' }
+
+        it 'hit the breaks if throttling quota is reached' do
+          expect { DHC.get('http://depay.fi', options) }.to raise_error(
+            DHC::Throttle::OutOfQuota,
+            'Reached predefined quota for depay.fi'
+          )
+        end
+
+        context 'still within quota' do
+          let(:options_break) { '90%' }
+
+          it 'does not hit the breaks' do
+            DHC.get('http://depay.fi', options)
+          end
+        end
+      end
+    end
+  end
+
+  describe 'parsing reset time given in prose' do
+    let(:quota_reset) { (Time.zone.now + 1.day).strftime('%A, %B %d, %Y 12:00:00 AM GMT').to_s }
+
+    before { DHC.get('http://depay.fi', options) }
+
+    context 'breaks' do
+      let(:options_break) { '80%' }
+
+      it 'hit the breaks if throttling quota is reached' do
+        expect { DHC.get('http://depay.fi', options) }.to raise_error(
+          DHC::Throttle::OutOfQuota,
+          'Reached predefined quota for depay.fi'
+        )
+      end
+
+      context 'still within quota' do
+        let(:options_break) { '90%' }
+
+        it 'does not hit the breaks' do
+          DHC.get('http://depay.fi', options)
+        end
+      end
+    end
+  end
+
+  context 'when value is empty' do
+    let(:quota_reset) { nil }
+
+    before do
+      stub_request(:get, 'http://depay.fi').to_return(
+        headers: { 'limit' => quota_limit, 'remaining' => quota_remaining }
+      )
+      DHC.get('http://depay.fi', options)
+    end
+
+    it 'still runs' do
+      DHC.get('http://depay.fi', options)
+    end
+  end
+end