dhc 1.0.0

data/spec/interceptors/after_response_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC do
+  context 'interceptor' do
+    before(:each) do
+      class Services
+        def self.timing(_path, _time); end
+      end
+
+      class StatsTimingInterceptor < DHC::Interceptor
+        def after_response
+          uri = URI.parse(response.request.url)
+          path = [
+            'web',
+            ((ActiveSupport.gem_version >= Gem::Version.new('6.0.0')) ? Rails.application.class.module_parent_name : Rails.application.class.parent_name).underscore,
+            Rails.env,
+            response.request.method,
+            uri.scheme,
+            uri.host,
+            response.code
+          ].join('.')
+          Services.timing(path.downcase, response.time)
+        end
+      end
+      DHC.configure { |c| c.interceptors = [StatsTimingInterceptor] }
+    end
+
+    let(:url) { 'http://depay.fi/v2/feedbacks/-Sc4_pYNpqfsudzhtivfkA' }
+
+    it 'can take action after a response was received' do
+      allow(Services).to receive(:timing).with('web.dummy.test.get.http.depay.fi.200', 0)
+      stub_request(:get, url)
+      DHC.get(url)
+      expect(Services).to have_received(:timing)
+    end
+  end
+end

data/spec/interceptors/auth/basic_auth_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC::Auth do
+  before(:each) do
+    DHC.config.interceptors = [DHC::Auth]
+  end
+
+  it 'adds basic auth to every request' do
+    options = { basic: { username: 'steve', password: 'can' } }
+    DHC.config.endpoint(:local, 'http://depay.fi', auth: options)
+    stub_request(:get, 'http://depay.fi')
+      .with(headers: { 'Authorization' => 'Basic c3RldmU6Y2Fu' })
+    DHC.get(:local)
+  end
+end

data/spec/interceptors/auth/bearer_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC::Auth do
+  before(:each) do
+    DHC.config.interceptors = [DHC::Auth]
+  end
+
+  it 'adds the bearer token to every request' do
+    def bearer_token
+      '123456'
+    end
+    options = { bearer: -> { bearer_token } }
+    DHC.config.endpoint(:local, 'http://depay.fi', auth: options)
+    stub_request(:get, 'http://depay.fi').with(headers: { 'Authorization' => 'Bearer 123456' })
+    DHC.get(:local)
+  end
+end

data/spec/interceptors/auth/body_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC::Auth do
+  before(:each) do
+    DHC.config.interceptors = [DHC::Auth]
+  end
+
+  it 'adds body authentication to the existing request body' do
+    stub_request(:post, 'http://depay.fi/')
+      .with(body: {
+        message: 'body',
+        userToken: 'dheur5hrk3'
+      }.to_json)
+
+    DHC.post('http://depay.fi', auth: { body: { userToken: 'dheur5hrk3' } }, body: {
+               message: 'body'
+             })
+  end
+
+  it 'adds body authentication to an empty request body' do
+    stub_request(:post, 'http://depay.fi/')
+      .with(body: {
+        userToken: 'dheur5hrk3'
+      }.to_json)
+
+    DHC.post('http://depay.fi', auth: { body: { userToken: 'dheur5hrk3' } })
+  end
+
+  it 'adds nothing if request method is GET' do
+    stub_request(:get, 'http://depay.fi/')
+
+    DHC.get('http://depay.fi', auth: { body: { userToken: 'dheur5hrk3' } })
+  end
+end

data/spec/interceptors/auth/long_basic_auth_credentials_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC::Auth do
+  before(:each) do
+    DHC.config.interceptors = [DHC::Auth]
+  end
+
+  it 'adds basic auth in a correct way even if username and password are especially long' do
+    options = { basic: { username: '123456789101234', password: '12345678901234567890123456789012' } }
+    DHC.config.endpoint(:local, 'http://depay.fi', auth: options)
+    stub_request(:get, 'http://depay.fi')
+      .with(headers: { 'Authorization' => 'Basic MTIzNDU2Nzg5MTAxMjM0OjEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEy' })
+    DHC.get(:local)
+  end
+end

data/spec/interceptors/auth/no_instance_var_for_options_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC::Auth do
+  before(:each) do
+    class AuthPrepInterceptor < DHC::Interceptor
+
+      def before_request
+        request.options[:auth] = { bearer: 'sometoken' }
+      end
+    end
+
+    DHC.config.interceptors = [AuthPrepInterceptor, DHC::Auth]
+  end
+
+  after do
+    DHC.config.reset
+  end
+
+  it 'does not use instance variables internally so that other interceptors can still change auth options' do
+    stub_request(:get, 'http://depay.fi/')
+      .with(headers: { 'Authorization' => 'Bearer sometoken' })
+      .to_return(status: 200)
+    DHC.get('http://depay.fi')
+  end
+end

data/spec/interceptors/auth/reauthentication_configuration_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC::Auth do
+  let(:bearer_token) { '123456' }
+
+  before(:each) do
+    stub_request(:get, 'http://depay.fi').with(headers: { 'Authorization' => "Bearer #{bearer_token}" })
+  end
+
+  context 'configuration check not happening' do
+    let(:options) { { bearer: bearer_token } }
+
+    before(:each) { DHC.config.interceptors = [DHC::Auth, DHC::Retry] }
+
+    it 'max_recovery_attempts is zero' do
+      expect_any_instance_of(described_class).not_to receive(:warn)
+      DHC.config.endpoint(:local, 'http://depay.fi', auth: options.merge(max_recovery_attempts: 0))
+      DHC.get(:local)
+    end
+
+    it 'max_recovery_attempts is missing' do
+      expect_any_instance_of(described_class).not_to receive(:warn)
+      DHC.config.endpoint(:local, 'http://depay.fi', auth: options)
+      DHC.get(:local)
+    end
+  end
+
+  context 'configuration check happening' do
+    let(:options) { { bearer: bearer_token, max_recovery_attempts: 1, refresh_client_token: -> { 'here comes your refresh code' } } }
+
+    it 'no warning with proper options' do
+      DHC.config.interceptors = [DHC::Auth, DHC::Retry]
+      DHC.config.endpoint(:local, 'http://depay.fi', auth: options)
+      expect_any_instance_of(described_class).not_to receive(:warn)
+      DHC.get(:local)
+    end
+
+    it 'warn refresh_client_token is a string' do
+      DHC.config.interceptors = [DHC::Auth, DHC::Retry]
+      DHC.config.endpoint(:local, 'http://depay.fi', auth: options.merge(refresh_client_token: bearer_token))
+      expect_any_instance_of(described_class).to receive(:warn).with('[WARNING] The given refresh_client_token must be a Proc for reauthentication.')
+      DHC.get(:local)
+    end
+
+    it 'warn interceptors miss DHC::Retry' do
+      DHC.config.interceptors = [DHC::Auth]
+      DHC.config.endpoint(:local, 'http://depay.fi', auth: options)
+      expect_any_instance_of(described_class).to receive(:warn).with('[WARNING] Your interceptors must include DHC::Retry after DHC::Auth.')
+      DHC.get(:local)
+    end
+
+    it 'warn interceptors DHC::Retry before DHC::Auth' do
+      DHC.config.interceptors = [DHC::Retry, DHC::Auth]
+      DHC.config.endpoint(:local, 'http://depay.fi', auth: options)
+      expect_any_instance_of(described_class).to receive(:warn).with('[WARNING] Your interceptors must include DHC::Retry after DHC::Auth.')
+      DHC.get(:local)
+    end
+  end
+end

data/spec/interceptors/auth/reauthentication_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC::Auth do
+  let(:initial_token) { '123456' }
+  let(:refresh_token) { 'abcdef' }
+  let(:options) { { bearer: initial_token, refresh_client_token: -> { refresh_token } } }
+  let!(:auth_failing) do
+    stub_request(:get, 'http://depay.fi')
+      .with(headers: { 'Authorization' => "Bearer #{initial_token}" })
+      .to_return(status: 401, body: '{}') # DHC::Unauthorized
+  end
+  let!(:auth_suceeding_after_recovery) do
+    stub_request(:get, 'http://depay.fi')
+      .with(headers: { 'Authorization' => "Bearer #{refresh_token}" })
+  end
+
+  before(:each) do
+    DHC.config.interceptors = [DHC::Auth, DHC::Retry]
+  end
+
+  it 'recovery is attempted' do
+    DHC.config.endpoint(:local, 'http://depay.fi', auth: options)
+    # the retried request (with updated Bearer), that should work
+    DHC.get(:local)
+    expect(auth_suceeding_after_recovery).to have_been_made.once
+  end
+
+  it 'recovery is not attempted again when the request has reauthenticated: true ' do
+    DHC.config.endpoint(:local, 'http://depay.fi', auth: options.merge(reauthenticated: true))
+    expect { DHC.get(:local) }.to raise_error(DHC::Unauthorized)
+  end
+
+  context 'token format' do
+    let(:initial_token) { 'BAsZ-98-ZZZ' }
+
+    it 'refreshes tokens with various formats' do
+      DHC.config.endpoint(:local, 'http://depay.fi', auth: options)
+      DHC.get(:local)
+      expect(auth_suceeding_after_recovery).to have_been_made.once
+    end
+  end
+end

data/spec/interceptors/before_request_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC do
+  context 'interceptor' do
+    before(:each) do
+      class TrackingIdInterceptor < DHC::Interceptor
+        def before_request
+          request.params[:tid] = 123
+        end
+      end
+      DHC.configure { |c| c.interceptors = [TrackingIdInterceptor] }
+    end
+
+    it 'can modify requests before they are send' do
+      stub_request(:get, 'http://depay.fi/?tid=123')
+      DHC.get('http://depay.fi')
+    end
+  end
+end

data/spec/interceptors/before_response_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC do
+  context 'interceptor' do
+    before(:each) do
+      class SomeInterceptor < DHC::Interceptor
+        def before_response; end
+      end
+      DHC.configure { |c| c.interceptors = [SomeInterceptor] }
+    end
+
+    it 'can perform some actions before a reponse is received' do
+      expect_any_instance_of(SomeInterceptor).to receive(:before_response)
+      stub_request(:get, 'http://depay.fi')
+      DHC.get('http://depay.fi')
+    end
+  end
+end

data/spec/interceptors/caching/hydra_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC::Caching do
+  before(:each) do
+    DHC.config.interceptors = [DHC::Caching]
+    DHC::Caching.cache = Rails.cache
+    Rails.cache.clear
+  end
+
+  let!(:first_request) do
+    stub_request(:get, 'http://depay.fi/').to_return(body: 'Website')
+  end
+
+  let!(:second_request) do
+    stub_request(:get, 'http://depay.fi/weather').to_return(body: 'The weather')
+  end
+
+  it 'does not fetch requests served from cache when doing requests in parallel with hydra' do
+    DHC.request([{ url: 'http://depay.fi', cache: true }, { url: 'http://depay.fi/weather', cache: true }])
+    DHC.request([{ url: 'http://depay.fi', cache: true }, { url: 'http://depay.fi/weather', cache: true }])
+    assert_requested first_request, times: 1
+    assert_requested second_request, times: 1
+  end
+end

data/spec/interceptors/caching/main_spec.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC::Caching do
+  before(:each) do
+    DHC.config.interceptors = [DHC::Caching]
+    DHC::Caching.cache = Rails.cache
+    Rails.cache.clear
+  end
+
+  let(:stub) { stub_request(:get, 'http://depay.fi').to_return(status: 200, body: 'The Website') }
+
+  it 'serves a response from cache' do
+    stub
+    DHC.config.endpoint(:local, 'http://depay.fi', cache: { expires_in: 5.minutes })
+    expect(Rails.cache).to receive(:write)
+      .with(
+        "DHC_CACHE(v#{DHC::Caching::CACHE_VERSION}): GET http://depay.fi",
+        {
+          body: 'The Website',
+          code: 200,
+          headers: nil,
+          return_code: nil,
+          mock: :webmock
+        }, { expires_in: 5.minutes }
+      )
+      .and_call_original
+    original_response = DHC.get(:local)
+    cached_response = DHC.get(:local)
+    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 stub, times: 1
+  end
+
+  it 'does not serve from cache if option is not set' do
+    DHC.config.endpoint(:local, 'http://depay.fi')
+    expect(Rails.cache).not_to receive(:write)
+    expect(Rails.cache).not_to receive(:fetch)
+    stub
+    2.times { DHC.get(:local) }
+    assert_requested stub, times: 2
+  end
+
+  it 'lets you configure the cache key that will be used' do
+    DHC.config.endpoint(:local, 'http://depay.fi', cache: { key: 'STATICKEY' })
+    expect(Rails.cache).to receive(:fetch).at_least(:once).with("DHC_CACHE(v#{DHC::Caching::CACHE_VERSION}): STATICKEY").and_call_original
+    expect(Rails.cache).to receive(:write).with("DHC_CACHE(v#{DHC::Caching::CACHE_VERSION}): STATICKEY", anything, anything).and_call_original
+    stub
+    DHC.get(:local)
+  end
+
+  it 'does not store server errors in cache' do
+    DHC.config.endpoint(:local, 'http://depay.fi', cache: true)
+    stub_request(:get, 'http://depay.fi').to_return(status: 500, body: 'ERROR')
+    expect { DHC.get(:local) }.to raise_error DHC::ServerError
+    stub
+    expect(Rails.cache).to receive(:write).once
+    DHC.get(:local)
+  end
+
+  it 'marks response not from cache as not served from cache and from cache as served from cache' do
+    stub
+    DHC.config.endpoint(:local, 'http://depay.fi', cache: true)
+    original_response = DHC.get(:local)
+    expect(original_response.from_cache?).to eq false
+    cached_response = DHC.get(:local)
+    expect(cached_response.from_cache?).to eq true
+  end
+end

data/spec/interceptors/caching/methods_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC::Caching do
+  before(:each) do
+    DHC.config.interceptors = [DHC::Caching]
+    DHC::Caching.cache = Rails.cache
+    Rails.cache.clear
+
+    DHC.config.endpoint(:local, 'http://depay.fi', cache: { expires_in: 5.minutes })
+  end
+
+  let!(:stub) { stub_request(:post, 'http://depay.fi').to_return(status: 200, body: 'The Website') }
+
+  it 'only caches GET requests by default' do
+    expect(Rails.cache).not_to receive(:write)
+    DHC.post(:local)
+    assert_requested stub, times: 1
+  end
+
+  it 'also caches other methods, when explicitly enabled' do
+    expect(Rails.cache).to receive(:write)
+      .with(
+        "DHC_CACHE(v#{DHC::Caching::CACHE_VERSION}): POST http://depay.fi",
+        {
+          body: 'The Website',
+          code: 200,
+          headers: nil,
+          return_code: nil,
+          mock: :webmock
+        }, { expires_in: 5.minutes }
+      )
+      .and_call_original
+    original_response = DHC.post(:local, cache: { methods: [:post] })
+    cached_response = DHC.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
+    assert_requested stub, times: 1
+  end
+end