lhc 12.0.3 → 12.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad768b826ac53e7175609b97943ffbb746f514c1f99bdfb7174d48307052df4c
-  data.tar.gz: 7bcbcf0c7d08b7be73eb7ece1b688fb8be003d68d269b4ef70d5994fab9cc07a
+  metadata.gz: 1a536d04e90db04fdeca6edd06c3e88782106a660d410a1b908b94147a3e9154
+  data.tar.gz: d0d89904a00069fdd8f3ef297f296e5da9d1383a4b4239aeebf00b6869be082a
 SHA512:
-  metadata.gz: c181e5bc874086374c453e6056d31c948eaa2d4a869dfa002819e3236d486c6b98e7d3c058e5cca2dbc423d58a0777b3208471426dc8e47c085cc92cedef6afb
-  data.tar.gz: 3203b6a2ae1c3180271b7d7f16b5dbf1b499cad6c623145139d74a5e65bd59d7376267702417e483f6c82b0942d89e72b0b24fe7e978b349de75a9a1cffd6e55
+  metadata.gz: 858291c8b53ce6447df1cc23fabd7c74ca4307ff7590eaebb76f4d538b769f81d9d89055bf79bf564814cf55c6832fccee42918100433061331252c6aafd8042
+  data.tar.gz: 49356178736094b85a4d9c1eab8dcf390024df5b580cb696e7f02683cbc1f1cf4a3e5bcfc6e03f5e8b9330fed1e02b94dd8bbbe17ec3c58e14b91b7352df9030

data/README.md

@@ -58,6 +58,7 @@ use it like:
         * [Authentication Interceptor](#authentication-interceptor)
            * [Bearer Authentication](#bearer-authentication)
            * [Basic Authentication](#basic-authentication)
+           * [Body Authentication](#body-authentication)
            * [Reauthenticate](#reauthenticate)
            * [Bearer Authentication with client access token](#bearer-authentication-with-client-access-token)
         * [Caching Interceptor](#caching-interceptor)
@@ -92,6 +93,8 @@ use it like:
 
 
 
+
+
 ## Basic methods
 
 Available are `get`, `post`, `put` & `delete`.
@@ -261,7 +264,7 @@ You can also use URL templates, when [configuring endpoints](#configuring-endpoi
   LHC.configure do |c|
     c.endpoint(:find_feedback, 'http://datastore/v2/feedbacks/{id}')
   end
-  
+
   LHC.get(:find_feedback, params:{ id: 123 }) # GET http://datastore/v2/feedbacks/123
 ```
 
@@ -274,7 +277,7 @@ Working and configuring timeouts is important, to ensure your app stays alive wh
 LHC forwards two timeout options directly to typhoeus:
 
 `timeout` (in seconds) - The maximum time in seconds that you allow the libcurl transfer operation to take. Normally, name lookups can take a considerable time and limiting operations to less than a few seconds risk aborting perfectly normal operations. This option may cause libcurl to use the SIGALRM signal to timeout system calls.
-`connecttimeout` (in seconds) - It should contain the maximum time in seconds that you allow the connection phase to the server to take. This only limits the connection phase, it has no impact once it has connected. Set to zero to switch to the default built-in connection timeout - 300 seconds. 
+`connecttimeout` (in seconds) - It should contain the maximum time in seconds that you allow the connection phase to the server to take. This only limits the connection phase, it has no impact once it has connected. Set to zero to switch to the default built-in connection timeout - 300 seconds.
 
 ```ruby
 LHC.get('http://local.ch', timeout: 5, connecttimeout: 1)
@@ -479,7 +482,7 @@ You can configure global placeholders, that are used when generating urls from u
     c.placeholder(:datastore, 'http://datastore')
     c.endpoint(:feedbacks, '{+datastore}/feedbacks', { params: { has_reviews: true } })
   end
-  
+
   LHC.get(:feedbacks) # http://datastore/v2/feedbacks
 ```
 
@@ -549,6 +552,20 @@ Adds the following header to the request:
 
 Which is the base64 encoded credentials "username:password".
 
+##### Body Authentication
+
+```ruby
+  LHC.post('http://local.ch', auth: { body: { userToken: 'dheur5hrk3' } })
+```
+
+Adds the following to body of all requests:
+
+```
+  {
+    "userToken": "dheur5hrk3"
+  }
+```
+
 ##### Reauthenticate
 
 The current implementation can only offer reauthenticate for _client access tokens_. For this to work the following has to be given:
@@ -713,7 +730,7 @@ LHC::Monitoring.env = ENV['DEPLOYMENT_TYPE'] || Rails.env
 
 It tracks request attempts with `before_request` and `after_request` (counts).
 
-In case your workers/processes are getting killed due limited time constraints, 
+In case your workers/processes are getting killed due limited time constraints,
 you are able to detect deltas with relying on "before_request", and "after_request" counts:
 
 ```ruby
@@ -764,7 +781,7 @@ Logs basic request/response information to prometheus.
   LHC.configure do |c|
     c.interceptors = [LHC::Prometheus]
   end
-    
+
   LHC::Prometheus.client = Prometheus::Client
   LHC::Prometheus.namespace = 'web_location_app'
 ```
@@ -786,7 +803,7 @@ If you enable the retry interceptor, you can have LHC retry requests for you:
   LHC.configure do |c|
     c.interceptors = [LHC::Retry]
   end
-  
+
   response = LHC.get('http://local.ch', retry: true)
 ```
 
@@ -861,15 +878,15 @@ The throttle interceptor allows you to raise an exception if a predefined quota
   end
 ```
 ```ruby
-options = { 
+options = {
   throttle: {
-    track: true, # enables tracking of current limit/remaining requests of rate-limiting
-    break: '80%', # quota in percent after which errors are raised. Percentage symbol is optional, values will be converted to integer (e.g. '23.5' will become 23)
-    provider: 'local.ch', # name of the provider under which throttling tracking is aggregated,
-    limit: { header: 'Rate-Limit-Limit' }, # either a hard-coded integer, or a hash pointing at the response header containing the limit value
-    remaining: { header: 'Rate-Limit-Remaining' }, # a hash pointing at the response header containing the current amount of remaining requests
-    expires: { header: 'Rate-Limit-Reset' } # a hash pointing at the response header containing the timestamp when the quota will reset
-  } 
+    track: true,
+    break: '80%',
+    provider: 'local.ch',
+    limit: { header: 'Rate-Limit-Limit' },
+    remaining: { header: 'Rate-Limit-Remaining' },
+    expires: { header: 'Rate-Limit-Reset' }
+  }
 }
 
 LHC.get('http://local.ch', options)
@@ -878,6 +895,16 @@ LHC.get('http://local.ch', options)
 LHC.get('http://local.ch', options)
 # raises LHC::Throttle::OutOfQuota: Reached predefined quota for local.ch
 ```
+**Options Description**
+* `track`: enables tracking of current limit/remaining requests of rate-limiting
+* `break`: quota in percent after which errors are raised. Percentage symbol is optional, values will be converted to integer (e.g. '23.5' will become 23)
+* `provider`: name of the provider under which throttling tracking is aggregated,
+* `limit`: either a hard-coded integer, or a hash pointing at the response header containing the limit value
+* `remaining`:
+  * a hash pointing at the response header containing the current amount of remaining requests
+  * a proc that receives the response as argument and returns the current amount
+  of remaining requests
+* `expires`: a hash pointing at the response header containing the timestamp when the quota will reset
 
 #### Zipkin
 

data/lib/lhc/interceptors/auth.rb

@@ -4,8 +4,13 @@ class LHC::Auth < LHC::Interceptor
   include ActiveSupport::Configurable
   config_accessor :refresh_client_token
 
+  def before_raw_request
+    body_authentication! if auth_options[:body]
+  end
+
   def before_request
-    authenticate!
+    bearer_authentication! if auth_options[:bearer]
+    basic_authentication! if auth_options[:basic]
   end
 
   def after_response
@@ -16,12 +21,9 @@ class LHC::Auth < LHC::Interceptor
 
   private
 
-  def authenticate!
-    if auth_options[:bearer]
-      bearer_authentication!
-    elsif auth_options[:basic]
-      basic_authentication!
-    end
+  def body_authentication!
+    auth = auth_options[:body]
+    request.options[:body] = (request.options[:body] || {}).merge(auth)
   end
 
   def basic_authentication!
@@ -78,7 +80,7 @@ class LHC::Auth < LHC::Interceptor
   end
 
   def auth_options
-    @auth_options ||= request.options[:auth].dup || {}
+    request.options[:auth] || {}
   end
 
   def configuration_correct?

data/lib/lhc/interceptors/throttle.rb

@@ -21,8 +21,7 @@ class LHC::Throttle < LHC::Interceptor
 
   def after_response
     options = response.request.options.dig(:throttle)
-    return unless options
-    return unless options.dig(:track)
+    return unless throttle?(options)
     self.class.track ||= {}
     self.class.track[options.dig(:provider)] = {
       limit: limit(options: options[:limit], response: response),
@@ -33,6 +32,10 @@ class LHC::Throttle < LHC::Interceptor
 
   private
 
+  def throttle?(options)
+    [options&.dig(:track), response.headers].none?(&:blank?)
+  end
+
   def break_when_quota_reached!
     options = request.options.dig(:throttle)
     track = (self.class.track || {}).dig(options[:provider])
@@ -46,36 +49,37 @@ class LHC::Throttle < LHC::Interceptor
   end
 
   def limit(options:, response:)
-    @limit ||= begin
-      if options.is_a?(Integer)
-        options
-      elsif options.is_a?(Hash) && options[:header] && response.headers.present?
-        response.headers[options[:header]]&.to_i
+    @limit ||=
+      begin
+        if options.is_a?(Integer)
+          options
+        elsif options.is_a?(Hash) && options[:header]
+          response.headers[options[:header]]&.to_i
+        end
       end
-    end
   end
 
   def remaining(options:, response:)
-    @remaining ||= begin
-      if options.is_a?(Hash) && options[:header] && response.headers.present?
-        response.headers[options[:header]]&.to_i
+    @remaining ||=
+      begin
+        if options.is_a?(Proc)
+          options.call(response)
+        elsif options.is_a?(Hash) && options[:header]
+          response.headers[options[:header]]&.to_i
+        end
       end
-    end
   end
 
   def expires(options:, response:)
-    @expires ||= begin
-      if options.is_a?(Hash) && options[:header] && response.headers.present?
-        convert_expires(response.headers[options[:header]]&.to_i)
-      else
-        convert_expires(options)
-      end
-    end
+    @expires ||= convert_expires(read_expire_option(options, response))
+  end
+
+  def read_expire_option(options, response)
+    (options.is_a?(Hash) && options[:header]) ? response.headers[options[:header]] : options
   end
 
   def convert_expires(value)
-    if value.is_a?(Integer)
-      Time.zone.at(value).to_datetime
-    end
+    return Time.parse(value) if value.match(/GMT/)
+    Time.zone.at(value.to_i).to_datetime if value.present?
   end
 end

data/lib/lhc/response/data.rb

@@ -12,9 +12,9 @@ class LHC::Response::Data
     @data = data
 
     if as_json.is_a?(Hash)
-      @base = LHC::Response::Data::Item.new(response, data: data)
+      @base = LHC::Response::Data::Item.new(@response, data: data)
     elsif as_json.is_a?(Array)
-      @base = LHC::Response::Data::Collection.new(response, data: data)
+      @base = LHC::Response::Data::Collection.new(@response, data: data)
     end
   end
 

data/lib/lhc/response/data/base.rb

@@ -4,7 +4,7 @@
 # but made accssible in the ruby world
 module LHC::Response::Data::Base
   def as_json
-    @json ||= (@data || response.format.as_json(response.body))
+    @json ||= (@data || @response.format.as_json(@response.body))
   end
 
   def as_open_struct
@@ -12,11 +12,7 @@ module LHC::Response::Data::Base
       if @data
         JSON.parse(@data.to_json, object_class: OpenStruct)
       else
-        response.format.as_open_struct(response.body)
+        @response.format.as_open_struct(@response.body)
       end
   end
-
-  private
-
-  attr_reader :response
 end

data/lib/lhc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LHC
-  VERSION ||= '12.0.3'
+  VERSION ||= '12.2.0'
 end

data/spec/interceptors/auth/body_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC::Auth do
+  before(:each) do
+    LHC.config.interceptors = [LHC::Auth]
+  end
+
+  it 'adds body authentication to the existing request body' do
+    stub_request(:post, "http://local.ch/")
+      .with(body: {
+        message: 'body',
+        userToken: 'dheur5hrk3'
+      }.to_json)
+
+    LHC.post('http://local.ch', auth: { body: { userToken: 'dheur5hrk3' } }, body: {
+               message: 'body'
+             })
+  end
+
+  it 'adds body authentication to an empty request body' do
+    stub_request(:post, "http://local.ch/")
+      .with(body: {
+        userToken: 'dheur5hrk3'
+      }.to_json)
+
+    LHC.post('http://local.ch', auth: { body: { userToken: 'dheur5hrk3' } })
+  end
+
+  it 'adds nothing if request method is GET' do
+    stub_request(:get, "http://local.ch/")
+
+    LHC.get('http://local.ch', auth: { body: { userToken: 'dheur5hrk3' } })
+  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 LHC::Auth do
+  before(:each) do
+    class AuthPrepInterceptor < LHC::Interceptor
+
+      def before_request
+        request.options[:auth] = { bearer: 'sometoken' }
+      end
+    end
+
+    LHC.config.interceptors = [AuthPrepInterceptor, LHC::Auth]
+  end
+
+  after do
+    LHC.config.reset
+  end
+
+  it 'does not use instance variables internally so that other interceptors can still change auth options' do
+    stub_request(:get, "http://local.ch/")
+      .with(headers: { 'Authorization' => 'Bearer sometoken' })
+      .to_return(status: 200)
+    LHC.get('http://local.ch')
+  end
+end

data/spec/interceptors/throttle/main_spec.rb

@@ -3,66 +3,64 @@
 require 'rails_helper'
 
 describe LHC::Throttle do
+  let(:options_break) { false }
+  let(:options_expires) { { header: 'reset' } }
+  let(:options_limit) { { header: 'limit' } }
+  let(:options_remaining) { { header: 'remaining' } }
   let(:provider) { 'local.ch' }
-  let(:limit) { 10000 }
-  let(:remaining) { 1900 }
+  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: limit_options,
-        remaining: { header: 'Rate-Limit-Remaining' },
-        expires: { header: 'Rate-Limit-Reset' },
-        break: break_option
+        limit: options_limit,
+        remaining: options_remaining,
+        expires: options_expires,
+        break: options_break
       }
     }
   end
-  let(:limit_options) { { header: 'Rate-Limit-Limit' } }
-  let(:break_option) { false }
-  let(:expires_in) { (Time.zone.now + 1.hour).to_i }
 
   before(:each) do
     LHC::Throttle.track = nil
     LHC.config.interceptors = [LHC::Throttle]
 
-    stub_request(:get, 'http://local.ch')
-      .to_return(
-        headers: {
-          'Rate-Limit-Limit' => limit,
-          'Rate-Limit-Remaining' => remaining,
-          'Rate-Limit-Reset' => expires_in
-        }
-      )
+    stub_request(:get, 'http://local.ch').to_return(
+      headers: { 'limit' => quota_limit, 'remaining' => quota_remaining, 'reset' => quota_reset }
+    )
   end
 
   it 'tracks the request limits based on response data' do
     LHC.get('http://local.ch', options)
-    expect(LHC::Throttle.track[provider][:limit]).to eq limit
-    expect(LHC::Throttle.track[provider][:remaining]).to eq remaining
+    expect(LHC::Throttle.track[provider][:limit]).to eq quota_limit
+    expect(LHC::Throttle.track[provider][:remaining]).to eq quota_remaining
   end
 
   context 'fix predefined integer for limit' do
-    let(:limit_options) { 1000 }
+    let(:options_limit) { 1000 }
 
     it 'tracks the limit based on initialy provided data' do
       LHC.get('http://local.ch', options)
-      expect(LHC::Throttle.track[provider][:limit]).to eq limit_options
+      expect(LHC::Throttle.track[provider][:limit]).to eq options_limit
     end
   end
 
   context 'breaks' do
-    let(:break_option) { '80%' }
+    let(:options_break) { '80%' }
 
     it 'hit the breaks if throttling quota is reached' do
       LHC.get('http://local.ch', options)
-      expect(-> {
-        LHC.get('http://local.ch', options)
-      }).to raise_error(LHC::Throttle::OutOfQuota, 'Reached predefined quota for local.ch')
+      expect { LHC.get('http://local.ch', options) }.to raise_error(
+        LHC::Throttle::OutOfQuota,
+        'Reached predefined quota for local.ch'
+      )
     end
 
     context 'still within quota' do
-      let(:break_option) { '90%' }
+      let(:options_break) { '90%' }
 
       it 'does not hit the breaks' do
         LHC.get('http://local.ch', options)
@@ -72,17 +70,14 @@ describe LHC::Throttle do
   end
 
   context 'no response headers' do
-    before do
-      stub_request(:get, 'http://local.ch')
-        .to_return(status: 200)
-    end
+    before { stub_request(:get, 'http://local.ch').to_return(status: 200) }
 
     it 'does not raise an exception' do
       LHC.get('http://local.ch', options)
     end
 
     context 'no remaining tracked, but break enabled' do
-      let(:break_option) { '90%' }
+      let(:options_break) { '90%' }
 
       it 'does not fail if a remaining was not tracked yet' do
         LHC.get('http://local.ch', options)
@@ -92,15 +87,76 @@ describe LHC::Throttle do
   end
 
   context 'expires' do
-    let(:break_option) { '80%' }
+    let(:options_break) { '80%' }
 
     it 'attempts another request if the quota expired' do
       LHC.get('http://local.ch', options)
-      expect(-> {
-        LHC.get('http://local.ch', options)
-      }).to raise_error(LHC::Throttle::OutOfQuota, 'Reached predefined quota for local.ch')
+      expect { LHC.get('http://local.ch', options) }.to raise_error(
+        LHC::Throttle::OutOfQuota,
+        'Reached predefined quota for local.ch'
+      )
       Timecop.travel(Time.zone.now + 2.hours)
       LHC.get('http://local.ch', options)
     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://local.ch').to_return(
+        headers: { 'limit' => quota_limit, 'current' => quota_current, 'reset' => quota_reset }
+      )
+      LHC.get('http://local.ch', options)
+    end
+
+    context 'breaks' do
+      let(:options_break) { '80%' }
+
+      it 'hit the breaks if throttling quota is reached' do
+        expect { LHC.get('http://local.ch', options) }.to raise_error(
+          LHC::Throttle::OutOfQuota,
+          'Reached predefined quota for local.ch'
+        )
+      end
+
+      context 'still within quota' do
+        let(:options_break) { '90%' }
+
+        it 'does not hit the breaks' do
+          LHC.get('http://local.ch', options)
+          LHC.get('http://local.ch', options)
+        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 { LHC.get('http://local.ch', options) }
+
+    context 'breaks' do
+      let(:options_break) { '80%' }
+
+      it 'hit the breaks if throttling quota is reached' do
+        expect { LHC.get('http://local.ch', options) }.to raise_error(
+          LHC::Throttle::OutOfQuota,
+          'Reached predefined quota for local.ch'
+        )
+      end
+
+      context 'still within quota' do
+        let(:options_break) { '90%' }
+
+        it 'does not hit the breaks' do
+          LHC.get('http://local.ch', options)
+          LHC.get('http://local.ch', options)
+        end
+      end
+    end
+  end
 end

data/spec/response/data_spec.rb

@@ -58,4 +58,28 @@ describe LHC::Response do
       end
     end
   end
+
+  context 'response data if responding error data contains a response' do
+    before do
+      stub_request(:get, "http://listings/")
+        .to_return(status: 404, body: {
+          meta: {
+            errors: [
+              { code: 2000, msg: 'I like to hide error messages (this is meta).' }
+            ]
+          },
+          response: 'why not?'
+        }.to_json)
+    end
+
+    it 'does not throw a stack level to deep issue when accessing data in a rescue context' do
+      begin
+        LHC.get('http://listings')
+      rescue LHC::Error => error
+        expect(
+          error.response.request.response.data.meta.errors.detect { |item| item.code == 2000 }.msg
+        ).to eq 'I like to hide error messages (this is meta).'
+      end
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lhc
 version: !ruby/object:Gem::Version
-  version: 12.0.3
+  version: 12.2.0
 platform: ruby
 authors:
 - https://github.com/local-ch/lhc/contributors
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-07-14 00:00:00.000000000 Z
+date: 2020-08-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -325,7 +325,9 @@ files:
 - spec/interceptors/after_response_spec.rb
 - spec/interceptors/auth/basic_auth_spec.rb
 - spec/interceptors/auth/bearer_spec.rb
+- spec/interceptors/auth/body_spec.rb
 - spec/interceptors/auth/long_basic_auth_credentials_spec.rb
+- spec/interceptors/auth/no_instance_var_for_options_spec.rb
 - spec/interceptors/auth/reauthentication_configuration_spec.rb
 - spec/interceptors/auth/reauthentication_spec.rb
 - spec/interceptors/before_request_spec.rb
@@ -387,7 +389,7 @@ homepage: https://github.com/local-ch/lhc
 licenses:
 - GPL-3.0
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -403,8 +405,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements:
 - Ruby >= 2.0.0
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 3.0.3
+signing_key:
 specification_version: 4
 summary: Advanced HTTP Client for Ruby, fueled with interceptors
 test_files:
@@ -476,7 +478,9 @@ test_files:
 - spec/interceptors/after_response_spec.rb
 - spec/interceptors/auth/basic_auth_spec.rb
 - spec/interceptors/auth/bearer_spec.rb
+- spec/interceptors/auth/body_spec.rb
 - spec/interceptors/auth/long_basic_auth_credentials_spec.rb
+- spec/interceptors/auth/no_instance_var_for_options_spec.rb
 - spec/interceptors/auth/reauthentication_configuration_spec.rb
 - spec/interceptors/auth/reauthentication_spec.rb
 - spec/interceptors/before_request_spec.rb