restful_resource 2.8.0 → 2.11.0

data/lib/restful_resource.rb

@@ -8,12 +8,13 @@ require 'faraday_cdn_metrics'
 require 'faraday/encoding'
 require 'active_support'
 require 'active_support/all'
-require 'resolv-replace.rb'
+require 'resolv-replace'
 require_relative 'restful_resource/version'
 require_relative 'restful_resource/null_logger'
 require_relative 'restful_resource/paginated_array'
 require_relative 'restful_resource/parameter_missing_error'
 require_relative 'restful_resource/resource_id_missing_error'
+require_relative 'restful_resource/strict_open_struct'
 require_relative 'restful_resource/open_object'
 require_relative 'restful_resource/response'
 require_relative 'restful_resource/request'

data/lib/restful_resource/base.rb

@@ -34,58 +34,58 @@ module RestfulResource
     end
 
     def self.find(id, **params)
-      params_without_options, options = format_params(params)
+      params_without_options, options = format_params(**params)
 
-      response = http.get(member_url(id, params_without_options), **options)
+      response = http.get(member_url(id, **params_without_options), **options)
       new(parse_json(response.body))
     end
 
     def self.where(**params)
-      params_without_options, options = format_params(params)
+      params_without_options, options = format_params(**params)
 
-      url = collection_url(params_without_options)
+      url = collection_url(**params_without_options)
       response = http.get(url, **options)
       paginate_response(response)
     end
 
     def self.get(**params)
-      params_without_options, options = format_params(params)
+      params_without_options, options = format_params(**params)
 
-      response = http.get(collection_url(params_without_options), **options)
+      response = http.get(collection_url(**params_without_options), **options)
       new(parse_json(response.body))
     end
 
     def self.delete(id, **params)
-      params_without_options, options = format_params(params)
-      response = http.delete(member_url(id, params_without_options), **options)
-      RestfulResource::OpenObject.new(parse_json(response.body))
+      params_without_options, options = format_params(**params)
+      response = http.delete(member_url(id, **params_without_options), **options)
+      new(parse_json(response.body))
     end
 
     def self.patch(id, data: {}, headers: {}, **params)
-      params_without_options, options = format_params(params)
+      params_without_options, options = format_params(**params)
       options.delete(:headers)
 
-      url = member_url(id, params_without_options)
+      url = member_url(id, **params_without_options)
 
       response = http.patch(url, data: data, headers: headers, **options)
       new(parse_json(response.body))
     end
 
     def self.put(id, data: {}, headers: {}, **params)
-      params_without_options, options = format_params(params)
+      params_without_options, options = format_params(**params)
       options.delete(:headers)
 
-      url = member_url(id, params_without_options)
+      url = member_url(id, **params_without_options)
 
       response = http.put(url, data: data, headers: headers, **options)
       new(parse_json(response.body))
     end
 
     def self.post(data: {}, headers: {}, **params)
-      params_without_options, options = format_params(params)
+      params_without_options, options = format_params(**params)
       options.delete(:headers)
 
-      url = collection_url(params_without_options)
+      url = collection_url(**params_without_options)
 
       response = http.post(url, data: data, headers: headers, **options)
 
@@ -93,7 +93,7 @@ module RestfulResource
     end
 
     def self.all(**params)
-      where(params)
+      where(**params)
     end
 
     def self.action(action_name)
@@ -119,8 +119,6 @@ module RestfulResource
       end
     end
 
-    protected
-
     def self.http
       @http || superclass.http
     end
@@ -135,11 +133,9 @@ module RestfulResource
 
     def self.collection_url(**params)
       url = merge_url_paths(base_url, @resource_path, @action_prefix)
-      replace_parameters(url, params)
+      replace_parameters(url, **params)
     end
 
-    private
-
     def self.format_params(**params)
       headers = params.delete(:headers) || {}
 
@@ -147,7 +143,7 @@ module RestfulResource
       open_timeout = params.delete(:open_timeout)
       timeout = params.delete(:timeout)
 
-      [params, headers: headers, open_timeout: open_timeout, timeout: timeout]
+      [params, { headers: headers, open_timeout: open_timeout, timeout: timeout }]
     end
 
     def self.merge_url_paths(uri, *paths)
@@ -158,7 +154,7 @@ module RestfulResource
       raise ResourceIdMissingError if id.blank?
 
       url = merge_url_paths(base_url, @resource_path, CGI.escape(id.to_s), @action_prefix)
-      replace_parameters(url, params)
+      replace_parameters(url, **params)
     end
 
     def self.new_collection(json)
@@ -177,7 +173,7 @@ module RestfulResource
       missing_params = []
       params = params.with_indifferent_access
 
-      url_params = url.scan(/:([A-Za-z][^\/]*)/).flatten
+      url_params = url.scan(%r{:([A-Za-z][^/]*)}).flatten
       url_params.each do |key|
         value = params.delete(key)
         if value.nil?

data/lib/restful_resource/http_client.rb

@@ -265,6 +265,11 @@ module RestfulResource
       response = e.response
       raise ClientError, request unless response
 
+      handle_error(request, response)
+    rescue Faraday::ServerError => e
+      response = e.response
+      raise ClientError, request unless response
+
       handle_error(request, response)
     end
 

data/lib/restful_resource/open_object.rb

@@ -1,7 +1,7 @@
 module RestfulResource
   class OpenObject
     def initialize(attributes = {}, _hack_for_activeresource = false)
-      @inner_object = OpenStruct.new(attributes)
+      @inner_object = StrictOpenStruct.new(attributes)
     end
 
     def method_missing(method, *args, &block)

data/lib/restful_resource/rails_validations.rb

@@ -17,13 +17,16 @@ module RestfulResource
         with_validations { super }
       end
 
+      def delete(*)
+        with_validations { super }
+      end
+
       private
 
       def with_validations(id = nil, data: {})
         yield
       rescue HttpClient::UnprocessableEntity => e
         errors = parse_json(e.response.body)
-        result = nil
         result = if errors.is_a?(Hash) && errors.key?('errors')
                    data.merge(errors)
                  else

data/lib/restful_resource/redirections.rb

@@ -9,15 +9,17 @@ module RestfulResource
     def self.included(base)
       base.instance_eval do
         def post(data: {}, delay: 1.0, max_attempts: 10, headers: {}, open_timeout: nil, timeout: nil, **params)
-          url = collection_url(params)
+          url = collection_url(**params)
 
-          response = accept_redirected_result(response: http.post(url, data: data, headers: headers, open_timeout: nil, timeout: nil), delay: delay, max_attempts: max_attempts)
+          response = accept_redirected_result(
+            response: http.post(url, data: data, headers: headers, open_timeout: nil, timeout: nil),
+            delay: delay,
+            max_attempts: max_attempts
+          )
 
           new(parse_json(response.body))
         end
 
-        private
-
         def self.accept_redirected_result(response:, delay:, max_attempts:)
           new_response = response
           if response.status == 303

data/lib/restful_resource/strict_open_struct.rb

@@ -0,0 +1,5 @@
+module RestfulResource
+  class StrictOpenStruct < ::OpenStruct
+    undef_method :dig, :[]
+  end
+end

data/lib/restful_resource/version.rb

@@ -1,3 +1,3 @@
 module RestfulResource
-  VERSION = '2.8.0'.freeze
+  VERSION = '2.11.0'.freeze
 end

data/restful_resource.gemspec

@@ -20,18 +20,19 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'carwow_rubocop'
+  spec.add_development_dependency 'pry'
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rspec'
-  spec.add_development_dependency 'rspec_junit_formatter'
   spec.add_development_dependency 'rspec-its'
+  spec.add_development_dependency 'rspec_junit_formatter'
 
-  spec.add_dependency 'activesupport'
-  spec.add_dependency 'faraday', '~> 0.15.0'
-  spec.add_dependency 'faraday-cdn-metrics'
+  spec.add_dependency 'activesupport', '~> 6.0'
+  spec.add_dependency 'faraday', '~> 1.0'
+  spec.add_dependency 'faraday-cdn-metrics', '~> 0.2'
   spec.add_dependency 'faraday-encoding'
-  spec.add_dependency 'faraday-http-cache'
-  spec.add_dependency 'faraday_middleware'
+  spec.add_dependency 'faraday-http-cache', '~> 2.2'
+  spec.add_dependency 'faraday_middleware', '~> 1.0'
   spec.add_dependency 'link_header'
-  spec.add_dependency 'rack'
-  spec.add_dependency 'typhoeus'
+  spec.add_dependency 'rack', '~> 2.2'
+  spec.add_dependency 'typhoeus', '~> 1.4'
 end

data/spec/restful_resource/associations_spec.rb

@@ -11,7 +11,6 @@ describe RestfulResource::Associations do
             { first_name: 'David', second_name: 'Doe' },
             { first_name: 'Mary', second_name: 'Doe' }
           ]
-
       )
     end
 
@@ -39,7 +38,6 @@ describe RestfulResource::Associations do
       @child = ComplicatedModule::Child.new(
         first_name: 'David', second_name: 'Smith',
         parent: { name: 'John Smith' }
-
       )
     end
 

data/spec/restful_resource/base_spec.rb

@@ -365,17 +365,17 @@ RSpec.describe RestfulResource::Base do
     end
 
     it 'does not return inner object table' do
-      expect(@makes.first.as_json).to eq ({ 'name' => 'Audi', 'slug' => 'Audi-Slug' })
+      expect(@makes.first.as_json).to eq({ 'name' => 'Audi', 'slug' => 'Audi-Slug' })
     end
 
     it 'returns inner object table on selected fields' do
-      expect(@makes.last.as_json(only: [:name])).to eq ({ 'name' => 'Fiat' })
+      expect(@makes.last.as_json(only: [:name])).to eq({ 'name' => 'Fiat' })
     end
   end
 
   describe '.member_url' do
     it 'requires a member ID' do
-      expect { described_class.member_url('', {}) }.to raise_error(RestfulResource::ResourceIdMissingError)
+      expect { described_class.member_url('') }.to raise_error(RestfulResource::ResourceIdMissingError)
     end
   end
 
@@ -406,17 +406,17 @@ RSpec.describe RestfulResource::Base do
                                                                )
 
       client.configure(base_url: 'http://foo.bar',
-                                username: username,
-                                password: password,
-                                auth_token: auth_token,
-                                logger: logger,
-                                cache_store: cache_store,
-                                instrumentation: instrumentation,
-                                timeout: timeout,
-                                open_timeout: open_timeout,
-                                faraday_config: faraday_config,
-                                faraday_options: faraday_options
-                               )
+                       username: username,
+                       password: password,
+                       auth_token: auth_token,
+                       logger: logger,
+                       cache_store: cache_store,
+                       instrumentation: instrumentation,
+                       timeout: timeout,
+                       open_timeout: open_timeout,
+                       faraday_config: faraday_config,
+                       faraday_options: faraday_options
+                      )
     end
   end
 

data/spec/restful_resource/http_client_configuration_spec.rb

@@ -19,7 +19,7 @@ describe RestfulResource::HttpClient do
 
     describe 'Builder configuration' do
       it 'uses the typhoeus adapter' do
-        expect(middleware).to include Faraday::Adapter::Typhoeus
+        expect(connection.adapter).to eq Faraday::Adapter::Typhoeus
       end
 
       it 'url_encodes requests' do
@@ -81,13 +81,13 @@ describe RestfulResource::HttpClient do
             described_class.new(instrumentation: { app_name: 'rails', api_name: 'api', metric_class: FakeMetrics })
 
             expect(RestfulResource::Instrumentation).to have_received(:new)
-                                               .with(app_name: 'rails',
-                                                     api_name: 'api',
-                                                     request_instrument_name: 'http.api',
-                                                     cache_instrument_name: 'http_cache.api',
-                                                     server_cache_instrument_name: 'cdn_metrics.api',
-                                                     metric_class: FakeMetrics
-                                                    )
+              .with(app_name: 'rails',
+                    api_name: 'api',
+                    request_instrument_name: 'http.api',
+                    cache_instrument_name: 'http_cache.api',
+                    server_cache_instrument_name: 'cdn_metrics.api',
+                    metric_class: FakeMetrics
+                   )
           end
 
           it 'subscribes to the notifications' do

data/spec/restful_resource/http_client_spec.rb

@@ -16,175 +16,97 @@ RSpec.describe RestfulResource::HttpClient do
   end
 
   describe 'Basic HTTP' do
-    it 'executes get' do
-      connection = faraday_connection do |stubs|
-        stubs.get('http://httpbin.org/get') { |_env| [200, {}, nil] }
-      end
-
-      response = http_client(connection).get('http://httpbin.org/get')
-      expect(response.status).to eq 200
-    end
-
-    it 'executes patch' do
-      connection = faraday_connection do |stubs|
-        # Note: request body is serialized as url-encoded so the stub body must be in the same format to match
-        stubs.patch('http://httpbin.org/patch', 'name=Alfred') { |_env| [200, {}, nil] }
-      end
-
-      response = http_client(connection).patch('http://httpbin.org/patch', data: { name: 'Alfred' })
-      expect(response.status).to eq 200
-    end
+    shared_examples 'error codes throw exception' do |verb, status, exception_class|
+      it "raises an error #{status}" do
+        url = "http://httpbin.org/status/#{status}"
 
-    it 'executes put' do
-      connection = faraday_connection do |stubs|
-        # Note: request body is serialized as url-encoded so the stub body must be in the same format to match
-        stubs.put('http://httpbin.org/put', 'name=Alfred') { |_env| [200, {}, nil] }
-      end
-
-      response = http_client(connection).put('http://httpbin.org/put', data: { name: 'Alfred' })
-      expect(response.status).to eq 200
-    end
-
-    it 'executes post' do
-      connection = faraday_connection do |stubs|
-        # Note: request body is serialized as url-encoded so the stub body must be in the same format to match
-        stubs.post('http://httpbin.org/post', 'name=Alfred') { |_env| [200, {}, %("name": "Alfred")] }
-      end
-
-      response = http_client(connection).post('http://httpbin.org/post', data: { name: 'Alfred' })
-
-      expect(response.body).to include 'name": "Alfred'
-      expect(response.status).to eq 200
-    end
-
-    it 'executes delete' do
-      connection = faraday_connection do |stubs|
-        stubs.delete('http://httpbin.org/delete') { |_env| [200, {}, nil] }
-      end
-
-      response = http_client(connection).delete('http://httpbin.org/delete')
-
-      expect(response.status).to eq 200
-    end
-
-    it 'patch should raise error 409' do
-      connection = faraday_connection do |stubs|
-        stubs.patch('http://httpbin.org/status/409') { |_env| [409, {}, nil] }
-      end
-
-      expect { http_client(connection).patch('http://httpbin.org/status/409') }.to raise_error(RestfulResource::HttpClient::Conflict)
-    end
+        connection = faraday_connection do |stubs|
+          stubs.send(verb, url) { [status, {}, nil] }
+        end
 
-    it 'patch should raise error 422' do
-      connection = faraday_connection do |stubs|
-        stubs.patch('http://httpbin.org/status/422') { |_env| [422, {}, nil] }
+        expect { http_client(connection).send(verb, url) }.to raise_error(exception_class)
       end
-
-      expect { http_client(connection).patch('http://httpbin.org/status/422') }.to raise_error(RestfulResource::HttpClient::UnprocessableEntity)
     end
 
-    it 'put should raise error 409' do
-      connection = faraday_connection do |stubs|
-        stubs.put('http://httpbin.org/status/409') { |_env| [409, {}, nil] }
-      end
+    shared_examples 'raise an exception on error responses' do |verb|
+      include_examples 'error codes throw exception', verb, 409, RestfulResource::HttpClient::Conflict
+      include_examples 'error codes throw exception', verb, 404, RestfulResource::HttpClient::ResourceNotFound
+      include_examples 'error codes throw exception', verb, 422, RestfulResource::HttpClient::UnprocessableEntity
+      include_examples 'error codes throw exception', verb, 429, RestfulResource::HttpClient::TooManyRequests
+      include_examples 'error codes throw exception', verb, 502, RestfulResource::HttpClient::BadGateway
+      include_examples 'error codes throw exception', verb, 503, RestfulResource::HttpClient::ServiceUnavailable
+      include_examples 'error codes throw exception', verb, 504, RestfulResource::HttpClient::GatewayTimeout
 
-      expect { http_client(connection).put('http://httpbin.org/status/409') }.to raise_error(RestfulResource::HttpClient::Conflict)
+      include_examples 'error codes throw exception', verb, 418, RestfulResource::HttpClient::OtherHttpError
     end
 
-    it 'put should raise error 422' do
-      connection = faraday_connection do |stubs|
-        stubs.put('http://httpbin.org/status/422') { |_env| [422, {}, nil] }
-      end
+    context 'GET' do
+      include_examples 'raise an exception on error responses', :get
 
-      expect { http_client(connection).put('http://httpbin.org/status/422') }.to raise_error(RestfulResource::HttpClient::UnprocessableEntity)
-    end
+      it 'executes get' do
+        connection = faraday_connection do |stubs|
+          stubs.get('http://httpbin.org/get') { |_env| [200, {}, nil] }
+        end
 
-    it 'post should raise error 422' do
-      connection = faraday_connection do |stubs|
-        stubs.post('http://httpbin.org/status/422') { |_env| [422, {}, nil] }
+        response = http_client(connection).get('http://httpbin.org/get')
+        expect(response.status).to eq 200
       end
-
-      expect { http_client(connection).post('http://httpbin.org/status/422') }.to raise_error(RestfulResource::HttpClient::UnprocessableEntity)
     end
 
-    it 'post should raise error 429' do
-      connection = faraday_connection do |stubs|
-        stubs.post('http://httpbin.org/status/429') { |_env| [429, {}, nil] }
-      end
+    context 'PATCH' do
+      include_examples 'raise an exception on error responses', :patch
 
-      expect { http_client(connection).post('http://httpbin.org/status/429') }.to raise_error(RestfulResource::HttpClient::TooManyRequests)
-    end
+      it 'executes patch' do
+        connection = faraday_connection do |stubs|
+          # NOTE: request body is serialized as url-encoded so the stub body must be in the same format to match
+          stubs.patch('http://httpbin.org/patch', 'name=Alfred') { |_env| [200, {}, nil] }
+        end
 
-    it 'patch should raise error 502' do
-      connection = faraday_connection do |stubs|
-        stubs.patch('http://httpbin.org/status/502') { |_env| [502, {}, nil] }
+        response = http_client(connection).patch('http://httpbin.org/patch', data: { name: 'Alfred' })
+        expect(response.status).to eq 200
       end
-
-      expect { http_client(connection).patch('http://httpbin.org/status/502') }.to raise_error(RestfulResource::HttpClient::BadGateway)
     end
 
-    it 'put should raise error 502' do
-      connection = faraday_connection do |stubs|
-        stubs.put('http://httpbin.org/status/502') { |_env| [502, {}, nil] }
-      end
-
-      expect { http_client(connection).put('http://httpbin.org/status/502') }.to raise_error(RestfulResource::HttpClient::BadGateway)
-    end
+    context 'PUT' do
+      include_examples 'raise an exception on error responses', :put
+      it 'executes put' do
+        connection = faraday_connection do |stubs|
+          # NOTE: request body is serialized as url-encoded so the stub body must be in the same format to match
+          stubs.put('http://httpbin.org/put', 'name=Alfred') { |_env| [200, {}, nil] }
+        end
 
-    it 'post should raise error 502' do
-      connection = faraday_connection do |stubs|
-        stubs.post('http://httpbin.org/status/502') { |_env| [502, {}, nil] }
+        response = http_client(connection).put('http://httpbin.org/put', data: { name: 'Alfred' })
+        expect(response.status).to eq 200
       end
-
-      expect { http_client(connection).post('http://httpbin.org/status/502') }.to raise_error(RestfulResource::HttpClient::BadGateway)
     end
 
-    it 'patch should raise error 503' do
-      connection = faraday_connection do |stubs|
-        stubs.patch('http://httpbin.org/status/503') { |_env| [503, {}, nil] }
-      end
+    context 'POST' do
+      include_examples 'raise an exception on error responses', :post
+      it 'executes post' do
+        connection = faraday_connection do |stubs|
+          # NOTE: request body is serialized as url-encoded so the stub body must be in the same format to match
+          stubs.post('http://httpbin.org/post', 'name=Alfred') { |_env| [200, {}, %("name": "Alfred")] }
+        end
 
-      expect { http_client(connection).patch('http://httpbin.org/status/503') }.to raise_error(RestfulResource::HttpClient::ServiceUnavailable)
-    end
+        response = http_client(connection).post('http://httpbin.org/post', data: { name: 'Alfred' })
 
-    it 'put should raise error 503' do
-      connection = faraday_connection do |stubs|
-        stubs.put('http://httpbin.org/status/503') { |_env| [503, {}, nil] }
+        expect(response.body).to include 'name": "Alfred'
+        expect(response.status).to eq 200
       end
-
-      expect { http_client(connection).put('http://httpbin.org/status/503') }.to raise_error(RestfulResource::HttpClient::ServiceUnavailable)
     end
 
-    it 'post should raise error 503' do
-      connection = faraday_connection do |stubs|
-        stubs.post('http://httpbin.org/status/503') { |_env| [503, {}, nil] }
-      end
+    context 'DELETE' do
+      include_examples 'raise an exception on error responses', :delete
 
-      expect { http_client(connection).post('http://httpbin.org/status/503') }.to raise_error(RestfulResource::HttpClient::ServiceUnavailable)
-    end
+      it 'executes delete' do
+        connection = faraday_connection do |stubs|
+          stubs.delete('http://httpbin.org/delete') { |_env| [200, {}, nil] }
+        end
 
-    it 'post should raise error 504' do
-      connection = faraday_connection do |stubs|
-        stubs.post('http://httpbin.org/status/504') { |_env| [504, {}, nil] }
-      end
+        response = http_client(connection).delete('http://httpbin.org/delete')
 
-      expect { http_client(connection).post('http://httpbin.org/status/504') }.to raise_error(RestfulResource::HttpClient::GatewayTimeout)
-    end
-
-    it 'raises error on 404' do
-      connection = faraday_connection do |stubs|
-        stubs.get('http://httpbin.org/status/404') { |_env| [404, {}, nil] }
-        stubs.post('http://httpbin.org/status/404') { |_env| [404, {}, nil] }
-        stubs.patch('http://httpbin.org/status/404') { |_env| [404, {}, nil] }
-        stubs.put('http://httpbin.org/status/404') { |_env| [404, {}, nil] }
-        stubs.delete('http://httpbin.org/status/404') { |_env| [404, {}, nil] }
+        expect(response.status).to eq 200
       end
-
-      expect { http_client(connection).get('http://httpbin.org/status/404') }.to raise_error(RestfulResource::HttpClient::ResourceNotFound)
-      expect { http_client(connection).delete('http://httpbin.org/status/404') }.to raise_error(RestfulResource::HttpClient::ResourceNotFound)
-      expect { http_client(connection).patch('http://httpbin.org/status/404', data: { name: 'Mad cow' }) }.to raise_error(RestfulResource::HttpClient::ResourceNotFound)
-      expect { http_client(connection).put('http://httpbin.org/status/404', data: { name: 'Mad cow' }) }.to raise_error(RestfulResource::HttpClient::ResourceNotFound)
-      expect { http_client(connection).post('http://httpbin.org/status/404', data: { name: 'Mad cow' }) }.to raise_error(RestfulResource::HttpClient::ResourceNotFound)
     end
 
     it 'raises Faraday::ConnectionFailed errors' do
@@ -210,14 +132,6 @@ RSpec.describe RestfulResource::HttpClient do
 
       expect { http_client(connection).get('https://localhost:3005') }.to raise_error(RestfulResource::HttpClient::ClientError)
     end
-
-    it 'raises OtherHttpError for other status response codes' do
-      connection = faraday_connection do |stubs|
-        stubs.get('http://httpbin.org/status/418') { |_env| [418, {}, nil] }
-      end
-
-      expect { http_client(connection).get('http://httpbin.org/status/418') }.to raise_error(RestfulResource::HttpClient::OtherHttpError)
-    end
   end
 
   describe 'Authentication' do
@@ -305,10 +219,10 @@ RSpec.describe RestfulResource::HttpClient do
       conn
     end
 
-
     context 'when explicit timeout set on connection' do
       let(:timeout) { 5 }
       let(:required_headers) { { 'X-Client-Timeout' => 5 } }
+
       it 'sets X-Client-Timeout correctly' do
         response = http_client.get('http://httpbin.org/get')