lhc 12.0.0

data/spec/formats/multipart_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC do
+  include ActionDispatch::TestProcess
+
+  context 'multipart' do
+    let(:file) { fixture_file_upload(Tempfile.new, 'image/jpeg') }
+    let(:body) { { size: 2231 }.to_json }
+    let(:location) { 'http://local.ch/uploads/image.jpg' }
+
+    it 'formats requests to be multipart/form-data' do
+      stub_request(:post, 'http://local.ch/') do |request|
+        raise 'Content-Type header wrong' unless request.headers['Content-Type'] == 'multipart/form-data'
+        raise 'Body wrongly formatted' unless request.body.match(/file=%23%3CActionDispatch%3A%3AHttp%3A%3AUploadedFile%3A.*%3E&type=Image/)
+      end.to_return(status: 200, body: body, headers: { 'Location' => location })
+      response = LHC.multipart.post(
+        'http://local.ch',
+        body: { file: file, type: 'Image' }
+      )
+      expect(response.body).to eq body
+      expect(response.headers['Location']).to eq location
+    end
+  end
+end

data/spec/formats/plain_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC do
+  include ActionDispatch::TestProcess
+
+  context 'plain' do
+    let(:file) { fixture_file_upload(Tempfile.new, 'image/jpeg') }
+
+    it 'leaves plains requests unformatted' do
+      stub_request(:post, 'http://local.ch/')
+        .with(body: /file=%23%3CRack%3A%3ATest%3A%3AUploadedFile%3.*%3E&type=Image/)
+        .to_return do |request|
+          expect(request.headers['Content-Type']).to be_blank
+
+          { status: 204 }
+        end
+      response = LHC.plain.post(
+        'http://local.ch',
+        body: { file: file, type: 'Image' }
+      )
+      expect(lambda {
+        response.body
+        response.data
+      }).not_to raise_error
+    end
+  end
+end

data/spec/interceptors/after_request_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC do
+  context 'interceptor' do
+    before(:each) do
+      class SomeInterceptor < LHC::Interceptor
+        def after_request; end
+      end
+      LHC.configure { |c| c.interceptors = [SomeInterceptor] }
+    end
+
+    it 'can perform some actions after a request was fired' do
+      expect_any_instance_of(SomeInterceptor).to receive(:after_request)
+      stub_request(:get, 'http://local.ch')
+      LHC.get('http://local.ch')
+    end
+  end
+end

data/spec/interceptors/after_response_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC do
+  context 'interceptor' do
+    before(:each) do
+      class Services
+        def self.timing(_path, _time); end
+      end
+
+      class StatsTimingInterceptor < LHC::Interceptor
+        def after_response
+          uri = URI.parse(response.request.url)
+          path = [
+            'web',
+            Rails.application.class.parent_name,
+            Rails.env,
+            response.request.method,
+            uri.scheme,
+            uri.host,
+            response.code
+          ].join('.')
+          Services.timing(path.downcase, response.time)
+        end
+      end
+      LHC.configure { |c| c.interceptors = [StatsTimingInterceptor] }
+    end
+
+    let(:url) { "http://local.ch/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.local.ch.200', 0)
+      stub_request(:get, url)
+      LHC.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 LHC::Auth do
+  before(:each) do
+    LHC.config.interceptors = [LHC::Auth]
+  end
+
+  it 'adds basic auth to every request' do
+    options = { basic: { username: 'steve', password: 'can' } }
+    LHC.config.endpoint(:local, 'http://local.ch', auth: options)
+    stub_request(:get, 'http://local.ch')
+      .with(headers: { 'Authorization' => 'Basic c3RldmU6Y2Fu' })
+    LHC.get(:local)
+  end
+end

data/spec/interceptors/auth/bearer_spec.rb

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

data/spec/interceptors/auth/reauthentication_configuration_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC::Auth do
+  let(:bearer_token) { '123456' }
+
+  before(:each) do
+    stub_request(:get, 'http://local.ch').with(headers: { 'Authorization' => "Bearer #{bearer_token}" })
+  end
+
+  context "configuration check not happening" do
+    let(:options) { { bearer: bearer_token } }
+
+    before(:each) { LHC.config.interceptors = [LHC::Auth, LHC::Retry] }
+
+    it "max_recovery_attempts is zero" do
+      expect_any_instance_of(described_class).not_to receive(:warn)
+      LHC.config.endpoint(:local, 'http://local.ch', auth: options.merge(max_recovery_attempts: 0))
+      LHC.get(:local)
+    end
+
+    it "max_recovery_attempts is missing" do
+      expect_any_instance_of(described_class).not_to receive(:warn)
+      LHC.config.endpoint(:local, 'http://local.ch', auth: options)
+      LHC.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
+      LHC.config.interceptors = [LHC::Auth, LHC::Retry]
+      LHC.config.endpoint(:local, 'http://local.ch', auth: options)
+      expect_any_instance_of(described_class).not_to receive(:warn)
+      LHC.get(:local)
+    end
+
+    it "warn refresh_client_token is a string" do
+      LHC.config.interceptors = [LHC::Auth, LHC::Retry]
+      LHC.config.endpoint(:local, 'http://local.ch', 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.")
+      LHC.get(:local)
+    end
+
+    it "warn interceptors miss LHC::Retry" do
+      LHC.config.interceptors = [LHC::Auth]
+      LHC.config.endpoint(:local, 'http://local.ch', auth: options)
+      expect_any_instance_of(described_class).to receive(:warn).with("[WARNING] Your interceptors must include LHC::Retry after LHC::Auth.")
+      LHC.get(:local)
+    end
+
+    it "warn interceptors LHC::Retry before LHC::Auth" do
+      LHC.config.interceptors = [LHC::Retry, LHC::Auth]
+      LHC.config.endpoint(:local, 'http://local.ch', auth: options)
+      expect_any_instance_of(described_class).to receive(:warn).with("[WARNING] Your interceptors must include LHC::Retry after LHC::Auth.")
+      LHC.get(:local)
+    end
+  end
+end

data/spec/interceptors/auth/reauthentication_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC::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://local.ch')
+      .with(headers: { 'Authorization' => "Bearer #{initial_token}" })
+      .to_return(status: 401, body: "{}") # LHC::Unauthorized
+  end
+  let!(:auth_suceeding_after_recovery) do
+    stub_request(:get, 'http://local.ch')
+      .with(headers: { 'Authorization' => "Bearer #{refresh_token}" })
+  end
+
+  before(:each) do
+    LHC.config.interceptors = [LHC::Auth, LHC::Retry]
+  end
+
+  it "recovery is attempted" do
+    LHC.config.endpoint(:local, 'http://local.ch', auth: options)
+    # the retried request (with updated Bearer), that should work
+    LHC.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
+    LHC.config.endpoint(:local, 'http://local.ch', auth: options.merge(reauthenticated: true))
+    expect { LHC.get(:local) }.to raise_error(LHC::Unauthorized)
+  end
+
+  context 'token format' do
+    let(:initial_token) { 'BAsZ-98-ZZZ' }
+
+    it 'refreshes tokens with various formats' do
+      LHC.config.endpoint(:local, 'http://local.ch', auth: options)
+      LHC.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 LHC do
+  context 'interceptor' do
+    before(:each) do
+      class TrackingIdInterceptor < LHC::Interceptor
+        def before_request
+          request.params[:tid] = 123
+        end
+      end
+      LHC.configure { |c| c.interceptors = [TrackingIdInterceptor] }
+    end
+
+    it 'can modify requests before they are send' do
+      stub_request(:get, "http://local.ch/?tid=123")
+      LHC.get('http://local.ch')
+    end
+  end
+end

data/spec/interceptors/before_response_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC do
+  context 'interceptor' do
+    before(:each) do
+      class SomeInterceptor < LHC::Interceptor
+        def before_response; end
+      end
+      LHC.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://local.ch')
+      LHC.get('http://local.ch')
+    end
+  end
+end

data/spec/interceptors/caching/hydra_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC::Caching do
+  before(:each) do
+    LHC.config.interceptors = [LHC::Caching]
+    LHC::Caching.cache = Rails.cache
+    Rails.cache.clear
+  end
+
+  let!(:first_request) do
+    stub_request(:get, "http://local.ch/").to_return(body: 'Website')
+  end
+
+  let!(:second_request) do
+    stub_request(:get, "http://local.ch/weather").to_return(body: 'The weather')
+  end
+
+  it 'does not fetch requests served from cache when doing requests in parallel with hydra' do
+    LHC.request([{ url: 'http://local.ch', cache: true }, { url: 'http://local.ch/weather', cache: true }])
+    LHC.request([{ url: 'http://local.ch', cache: true }, { url: 'http://local.ch/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 LHC::Caching do
+  before(:each) do
+    LHC.config.interceptors = [LHC::Caching]
+    LHC::Caching.cache = Rails.cache
+    Rails.cache.clear
+  end
+
+  let(:stub) { stub_request(:get, 'http://local.ch').to_return(status: 200, body: 'The Website') }
+
+  it 'serves a response from cache' do
+    stub
+    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",
+        {
+          body: 'The Website',
+          code: 200,
+          headers: nil,
+          return_code: nil,
+          mock: :webmock
+        }, { expires_in: 5.minutes }
+      )
+      .and_call_original
+    original_response = LHC.get(:local)
+    cached_response = LHC.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
+    LHC.config.endpoint(:local, 'http://local.ch')
+    expect(Rails.cache).not_to receive(:write)
+    expect(Rails.cache).not_to receive(:fetch)
+    stub
+    2.times { LHC.get(:local) }
+    assert_requested stub, times: 2
+  end
+
+  it 'lets you configure the cache key that will be used' do
+    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
+    LHC.get(:local)
+  end
+
+  it 'does not store server errors in cache' do
+    LHC.config.endpoint(:local, 'http://local.ch', cache: true)
+    stub_request(:get, 'http://local.ch').to_return(status: 500, body: 'ERROR')
+    expect { LHC.get(:local) }.to raise_error LHC::ServerError
+    stub
+    expect(Rails.cache).to receive(:write).once
+    LHC.get(:local)
+  end
+
+  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)
+    original_response = LHC.get(:local)
+    cached_response = LHC.get(:local)
+    expect(original_response.from_cache?).to eq false
+    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 LHC::Caching do
+  before(:each) do
+    LHC.config.interceptors = [LHC::Caching]
+    LHC::Caching.cache = Rails.cache
+    Rails.cache.clear
+
+    LHC.config.endpoint(:local, 'http://local.ch', cache: { expires_in: 5.minutes })
+  end
+
+  let!(:stub) { stub_request(:post, 'http://local.ch').to_return(status: 200, body: 'The Website') }
+
+  it 'only caches GET requests by default' do
+    expect(Rails.cache).not_to receive(:write)
+    LHC.post(:local)
+    assert_requested stub, times: 1
+  end
+
+  it 'also caches other methods, when explicitly enabled' do
+    expect(Rails.cache).to receive(:write)
+      .with(
+        "LHC_CACHE(v#{LHC::Caching::CACHE_VERSION}): POST http://local.ch",
+        {
+          body: 'The Website',
+          code: 200,
+          headers: nil,
+          return_code: nil,
+          mock: :webmock
+        }, { expires_in: 5.minutes }
+      )
+      .and_call_original
+    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
+    assert_requested stub, times: 1
+  end
+end