flexirest 1.10.1 → 1.10.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 89ef0bd6a927d830d9f98f1e4deeee8d26bf68a203a001f2299785386e1365b9
-  data.tar.gz: 3fa35c87cb16df1181207a6393682c6ec003346b4789d8bff30bbedbdba0e753
+  metadata.gz: eb22808a993f64bfac3dd7e8927b0f9a0847800666962b0182a1e9161cf776fe
+  data.tar.gz: ad93e71fdfbb91fc68fc3b7939b7b023399672560e14e976eadb7e1db38bf995
 SHA512:
-  metadata.gz: 520a9f3131d517c00180dd15a9fbd8c03372343bde13474457a37db78b321efa54a756878bd5161253ab6646a6e6ffc24171a3f69fca043c14cfb49630cf7ef8
-  data.tar.gz: 5580fe4c1079b03fb51465550afce7ca4a542051efbd127df0405d113d47955182d88cfc324ff184a36be7eee0d4eaab5fad85efe47f94d5163846aad952df6d
+  metadata.gz: 9d82ab1f62bdd4b55a08d0c49584fc251842773ca5a8d986dd980116498a021ff6287092ea83eee429ad1f04dab719cd8b40116b21e432c4ca32d0ffd056549e
+  data.tar.gz: 925fbd8da65f0dda69db4629d7fec401944d2846669b272045342a2384671bb45b55aa98905c17328631862b6953ac7ad5675c76980b7896c2a5916c968c365c

data/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## 1.10.6
+
+Bugfix:
+
+- Flexirest was erroring if Rails.logger was defined but was nil (thanks to Alex Oxte for the PR)
+
+## 1.10.5
+
+Enhancement:
+
+- Allow skipping of caching for single endpoints
+
+## 1.10.4
+
+Enhancement:
+
+- Implement support for in-header Basic Auth (thanks to François Ferrandis for the PR)
+
+## 1.10.3
+
+Enhancement:
+
+- Ignore/wrap root functionality available for all routes, rather than just route specifically (thanks to Sampat Badhe for the PR)
+
+## 1.10.2
+
+Bugfix:
+
+- JSON-API calls do not include linked resources when no other parameter is passed (thanks to Stevo-S for the bug report and François Ferrandis for the PR)
+
 ## 1.10.1
 
 Enhancement:

data/docs/authentication.md

@@ -40,6 +40,30 @@ Or if it's called from a class context:
 Person.find(id: 1234)
 ```
 
+### Basic authentication method
+
+Flexirest provides two methods for HTTP Basic Auth. The default method is `:url`:
+
+```ruby
+class Person < Flexirest::Base
+  basic_auth_method :url
+end
+# Includes the credentials in the URL:
+#   https://my_username:my_password@example.com/
+```
+
+But you might want to keep the credentials out of your logs and use the `:header` method:
+
+```ruby
+class Person < Flexirest::Base
+  basic_auth_method :header
+end
+# Clean URL:
+#   https://example.com/
+# with the base64 encoded credentials:
+#   Authorization: Basic YXBpOmViNjkzZWMtODI1MmMtZDYzMDEtMDJmZDAtZDBmYjctYzM0ODU=
+```
+
 ## Api-Auth
 
 Using the [Api-Auth](https://github.com/mgomes/api_auth) integration it is very easy to sign requests. Include the Api-Auth gem in your `Gemfile` and  then add it to your application. Then simply configure Api-Auth one time in your app and all requests will be signed from then on.

data/docs/caching.md

@@ -14,6 +14,14 @@ class Person < Flexirest::Base
 end
 ```
 
+or per request endpoint with:
+
+```ruby
+class Person < Flexirest::Base
+    get :all, "/people", skip_caching: true
+end
+```
+
 If Rails is defined, it will default to using Rails.cache as the cache store, if not, you'll need to configure one with a `ActiveSupport::Cache::Store` compatible object using:
 
 ```ruby

data/docs/filtering-result-lists.md

@@ -1,6 +1,6 @@
 # *Flexirest:* Filtering result lists
 
-If the API returns a JSON list of items, this is retured to you as a `Flexirest::ResultIterator` object. A `ResultIterator` sorts simple filtering of the list using a `where` method based on values matching a specified criteria (or matching using regular expressions):
+If the API returns a JSON list of items, this is returned to you as a `Flexirest::ResultIterator` object. A `ResultIterator` sorts simple filtering of the list using a `where` method based on values matching a specified criteria (or matching using regular expressions):
 
 ```ruby
 class Article < Flexirest::Base

data/docs/json-api.md

@@ -12,17 +12,26 @@ This proxy translates requests according to the JSON API specifications, parses
 
 It supports lazy loading by default. Unless a compound document is returned from the connected JSON API service, it will make another request to the service for the specified linked resource.
 
+
+## Including associations
+
 To reduce the number of requests to the service, you can ask the service to include the linked resources in the response. Such responses are called "compound documents". To do this, use the `includes` method:
 
 ```ruby
-# Makes a call to /articles with parameters: include=images
+# Makes a call to: /articles?include=images
 Article.includes(:images).all
 
-# For nested resources, the include parameter becomes: include=images.tags,images.photographer
+# Fetch nested resources: /articles?include=images.tags,images.photographer
 Article.includes(:images => [:tags, :photographer]).all
+
+# Note: the `includes` method takes precedence over the passed `:include` parameter.
+# This will result in query: /articles?include=images
+Article.includes(:images).all(include: "author")
 ```
 
-For POST and PATCH requests, the proxy formats a JSON API compliant request, and adds a `Content-Type: application/vnd.api+json` header. It guesses the `type` value in the resource object from the class name, but it can be set specifically with `alias_type`:
+## Resource type
+
+The `type` value is guessed from the class name, but it can be set specifically with `alias_type`:
 
 ```ruby
 class Photographer < Flexirest::Base
@@ -34,7 +43,10 @@ class Photographer < Flexirest::Base
 end
 ```
 
-NB: Updating relationships is not yet supported.
+
+## Notes
+
+Updating relationships is not yet supported.
 
 
 -----

data/docs/plain-requests.md

@@ -7,7 +7,7 @@ class Person < Flexirest::Base
 end
 
 people = Person._plain_request('http://api.example.com/v1/people') # Defaults to get with no parameters
-# people is a normal Flexirest object, implementing iteration, HAL loading, etc.
+# people is a string containing the response
 
 Person._plain_request('http://api.example.com/v1/people', :post, {id:1234,name:"John"}) # Post with parameters
 ```

data/docs/proxying-apis.md

@@ -40,7 +40,7 @@ Article.all.first_name == "Billy"
 This example does two things:
 
 1. It rewrites the incoming URL for any requests matching "_/all_" to "/all_people"
-2. It uses the `translate` method to move the "fname" attribute from the response body to be called "first_name". The translate method must return the new object at the end (either the existing object alterered, or a new object to replace it with)
+2. It uses the `translate` method to move the "fname" attribute from the response body to be called "first_name". The translate method must return the new object at the end (either the existing object altered, or a new object to replace it with)
 
 As the comment shows, you can use `url value` to set the request URL to a particular value, or you can call `gsub!` on the url to replace parts of it using more complicated regular expressions.
 

data/docs/raw-requests.md

@@ -1,6 +1,6 @@
 # *Flexirest:* Raw requests
 
-Sometimes you have have a URL that you just want to force through, but have the response handled in the same way as normal objects or you want to have the callbacks run (say for authentication). The easiest way to do that is to call `_request` on the class:
+Sometimes you have a URL that you just want to force through, but have the response handled in the same way as normal objects or you want to have the callbacks run (say for authentication). The easiest way to do that is to call `_request` on the class:
 
 ```ruby
 class Person < Flexirest::Base
@@ -12,7 +12,7 @@ people = Person._request('http://api.example.com/v1/people') # Defaults to get w
 Person._request('http://api.example.com/v1/people', :post, {id:1234,name:"John"}) # Post with parameters
 ```
 
-When you need to specify custom headers (for example for authentication) you can do this with a fourth option to the `_request` method. If you are using the default paramaters you'll need to specify them. For example:
+When you need to specify custom headers (for example for authentication) you can do this with a fourth option to the `_request` method. If you are using the default parameters you'll need to specify them. For example:
 
 ```ruby
 Person._request("http://api.example.com/v1/people", :get, {}, {headers:{"X-Something": "foo/bar"}})

data/docs/root-elements.md

@@ -2,13 +2,32 @@
 
 If your response comes back with a root node and you'd like to ignore it, you can define the mapping as:
 
+```ruby
+Flexirest::Base.ignore_root = "data"
+```
+
+Any `ignore_root` setting in specific class overrides this declared default.
+
 ```ruby
 class Feed < Flexirest::Base
-  post :list, "/feed", ignore_root: "feed"
+  ignore_root: "feed"
+
+  post :list, "/feed"
+end
+```
+
+And any `ignore_root` setting in specific request overrides the both default and class specific setting.
+
+
+```ruby
+class Feed < Flexirest::Base
+  ignore_root: 'feed'
+
+  post :list, "/feed", ignore_root: "result"
 end
 ```
 
-This also works if you'd want to remove a tree of root nodes:
+You can also assign an array to `ignore_root` if you'd want to remove a tree of root nodes.
 
 ```ruby
 class Feed < Flexirest::Base
@@ -26,16 +45,32 @@ Alternatively if you want to wrap your JSON request body in a root element, e.g.
 }
 ```
 
-You can do it like this:
+You can do it using `wrap_root`:
+
+```ruby
+Flexirest::Base.wrap_root = "data"
+```
+
+Any `wrap_root` setting in specific class overrides this declared default.
 
 ```ruby
 class Feed < Flexirest::Base
-  post :list, "/feed", wrap_root: "feed"
-end
+  wrap_root: "feed"
 
-Feed.list(id: 1)
+  post :list, "/feed"
+end
 ```
 
+And any `wrap_root` setting in specific request overrides the both default and class specific setting.
+
+
+```ruby
+class Feed < Flexirest::Base
+  wrap_root: 'feed'
+
+  post :list, "/feed", wrap_root: "data"
+end
+```
 
 -----
 

data/flexirest.gemspec

@@ -39,7 +39,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "api-auth", ">= 1.3.1", "< 2.4"
   spec.add_development_dependency 'typhoeus'
   spec.add_development_dependency 'activemodel'
-  spec.add_development_dependency 'rest-client', ">= 1.8.0"
+  spec.add_development_dependency 'rest-client'
 
   spec.add_runtime_dependency "mime-types"
   spec.add_runtime_dependency "multi_json"

data/lib/flexirest/configuration.rb

@@ -13,6 +13,32 @@ module Flexirest
       @api_auth_access_id = nil
       @api_auth_secret_key = nil
       @api_auth_options = {}
+      @ignore_root = nil
+      @wrap_root = nil
+
+      def ignore_root(value=nil)
+        if value.nil?
+          value = if @ignore_root.nil? && superclass.respond_to?(:ignore_root)
+            superclass.ignore_root
+          else
+            @ignore_root
+          end
+        else
+          @ignore_root = value
+        end
+      end
+
+      def wrap_root(value=nil)
+        if value.nil?
+          value = if @wrap_root.nil? && superclass.respond_to?(:wrap_root)
+            superclass.wrap_root
+          else
+            @wrap_root
+          end
+        else
+          @wrap_root = value
+        end
+      end
 
       def base_url(value = nil)
         @base_url ||= nil
@@ -109,6 +135,23 @@ module Flexirest
         @@password = value
       end
 
+      DEFAULT_BASIC_URL_METHOD = :url
+
+      def basic_auth_method(value = nil)
+        if value.nil? # Used as a getter method
+          if @basic_auth_method.nil? && superclass.respond_to?(:basic_auth_method)
+            superclass.basic_auth_method
+          else
+            @basic_auth_method || DEFAULT_BASIC_URL_METHOD
+          end
+        else # Used as a setter method
+          unless [:header, :url].include?(value)
+            raise %(Invalid basic_auth_method #{value.inspect}. Valid methods are :url (default) and :header.)
+          end
+          @basic_auth_method = value
+        end
+      end
+
       def alias_type(value = nil)
         @alias_type ||= nil
         if value.nil?
@@ -285,6 +328,7 @@ module Flexirest
         @adapter              = Faraday.default_adapter
         @api_auth_access_id   = nil
         @api_auth_secret_key  = nil
+        @basic_auth_method    = :url
       end
 
       private

data/lib/flexirest/json_api_proxy.rb

@@ -50,11 +50,8 @@ module Flexirest
         end
 
         def translate(params, include_associations)
-          # Return to caller if nothing is to be done
-          return params unless params.present? && include_associations.present?
-
           # Format the linked resources array, and assign to include key
-          params[:include] = format_include_params(include_associations)
+          params[:include] = format_include_params(include_associations) if include_associations.present?
         end
 
         private

data/lib/flexirest/logger.rb

@@ -17,7 +17,7 @@ module Flexirest
     end
 
     def self.debug(message)
-      if defined?(Rails) && Rails.respond_to?(:logger)
+      if defined?(Rails) && Rails.logger.present?
         Rails.logger.debug(message)
       elsif @logfile
         if @logfile.is_a?(String)
@@ -33,7 +33,7 @@ module Flexirest
     end
 
     def self.info(message)
-      if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+      if defined?(Rails) && Rails.logger.present?
         Rails.logger.info(message)
       elsif @logfile
         if @logfile.is_a?(String)
@@ -49,7 +49,7 @@ module Flexirest
     end
 
     def self.warn(message)
-      if defined?(Rails) && Rails.respond_to?(:logger)
+      if defined?(Rails) && Rails.logger.present?
         Rails.logger.warn(message)
       elsif @logfile
         if @logfile.is_a?(String)
@@ -65,7 +65,7 @@ module Flexirest
     end
 
     def self.error(message)
-      if defined?(Rails) && Rails.respond_to?(:logger)
+      if defined?(Rails) && Rails.logger.present?
         Rails.logger.error(message)
       elsif @logfile
         if @logfile.is_a?(String)

data/lib/flexirest/request.rb

@@ -32,6 +32,10 @@ module Flexirest
       !@object.respond_to?(:dirty?)
     end
 
+    def model_class
+      object_is_class? ? @object : @object.class
+    end
+
     def class_name
       if object_is_class?
         @object.name
@@ -124,6 +128,18 @@ module Flexirest
       ret
     end
 
+    def inject_basic_auth_in_url(url)
+      url.gsub!(%r{//(.)}, "//#{username}:#{password}@\\1") if !url[%r{//[^/]*:[^/]*@}]
+    end
+
+    def using_basic_auth?
+      !!username
+    end
+
+    def basic_auth_digest
+      Base64.strict_encode64("#{username}:#{password}")
+    end
+
     def request_body_type
       if @method[:options][:request_body_type]
         @method[:options][:request_body_type]
@@ -136,6 +152,30 @@ module Flexirest
       end
     end
 
+    def ignore_root
+      if @method[:options][:ignore_root]
+        @method[:options][:ignore_root]
+      elsif @object.nil?
+        nil
+      elsif object_is_class?
+        @object.ignore_root
+      else
+        @object.class.ignore_root
+      end
+    end
+
+    def wrap_root
+      if @method[:options][:wrap_root]
+        @method[:options][:wrap_root]
+      elsif @object.nil?
+        nil
+      elsif object_is_class?
+        @object.wrap_root
+      else
+        @object.class.wrap_root
+      end
+    end
+
     def verbose?
       if object_is_class?
         @object.verbose
@@ -272,7 +312,7 @@ module Flexirest
 
           result = handle_response(response_env, cached)
           @response_delegate.__setobj__(result)
-          original_object_class.write_cached_response(self, response_env, result)
+          original_object_class.write_cached_response(self, response_env, result) unless @method[:options][:skip_caching]
         end
 
         # If this was not a parallel request just return the original result
@@ -438,8 +478,8 @@ module Flexirest
           @post_params
         else
           p = (params || @post_params || {})
-          if @method[:options][:wrap_root].present?
-            p = {@method[:options][:wrap_root] => p}
+          if wrap_root.present?
+            p = {wrap_root => p}
           end
           p.to_query
         end
@@ -452,8 +492,8 @@ module Flexirest
           @post_params
         else
           p = (params || @post_params || {})
-          if @method[:options][:wrap_root].present?
-            p = {@method[:options][:wrap_root] => p}
+          if wrap_root.present?
+            p = {wrap_root => p}
           end
           data, mp_headers = Flexirest::Multipart::Post.prepare_query(p)
           mp_headers.each do |k,v|
@@ -467,8 +507,8 @@ module Flexirest
         elsif @post_params.is_a?(String)
           @post_params
         else
-          if @method[:options][:wrap_root].present?
-            {@method[:options][:wrap_root] => (params || @post_params || {})}.to_json
+          if wrap_root.present?
+            {wrap_root => (params || @post_params || {})}.to_json
           else
             (params || @post_params || {}).to_json
           end
@@ -483,7 +523,7 @@ module Flexirest
 
     def do_request(etag)
       http_headers = {}
-      http_headers["If-None-Match"] = etag if etag
+      http_headers["If-None-Match"] = etag if etag && !@method[:options][:skip_caching]
       http_headers["Accept"] = "application/hal+json, application/json;q=0.5"
       headers.each do |key,value|
         value = value.join(",") if value.is_a?(Array)
@@ -503,7 +543,9 @@ module Flexirest
           else
             _, @base_url, @url = parts
           end
-          base_url.gsub!(%r{//(.)}, "//#{username}:#{password}@\\1") if username && !base_url[%r{//[^/]*:[^/]*@}]
+          if using_basic_auth? && model_class.basic_auth_method == :url
+            inject_basic_auth_in_url(base_url)
+          end
           connection = Flexirest::ConnectionManager.get_connection(base_url)
         end
       else
@@ -516,7 +558,9 @@ module Flexirest
         else
           base_url = parts[0]
         end
-        base_url.gsub!(%r{//(.)}, "//#{username}:#{password}@\\1") if username && !base_url[%r{//[^/]*:[^/]*@}]
+        if using_basic_auth? && model_class.basic_auth_method == :url
+          inject_basic_auth_in_url(base_url)
+        end
         connection = Flexirest::ConnectionManager.get_connection(base_url)
       end
       if @method[:options][:direct]
@@ -542,6 +586,8 @@ module Flexirest
           :api_auth_secret_key => api_auth_secret_key,
           :api_auth_options => api_auth_options
         }
+      elsif using_basic_auth? && model_class.basic_auth_method == :header
+        http_headers["Authorization"] = "Basic #{basic_auth_digest}"
       end
       if @method[:options][:timeout]
         request_options[:timeout] = @method[:options][:timeout]
@@ -601,7 +647,7 @@ module Flexirest
           else
             Flexirest::Logger.debug "  \033[1;4;32m#{Flexirest.name}\033[0m #{@instrumentation_name} - Response received #{@response.body.size} bytes"
           end
-          result = generate_new_object(ignore_root: @method[:options][:ignore_root], ignore_xml_root: @method[:options][:ignore_xml_root])
+          result = generate_new_object(ignore_root: ignore_root, ignore_xml_root: @method[:options][:ignore_xml_root])
           # TODO: Cleanup when ignore_xml_root is removed
         else
           raise ResponseParseException.new(status:status, body:@response.body, headers: @response.headers)
@@ -814,15 +860,15 @@ module Flexirest
           body = JsonAPIProxy::Response.parse(body, @object)
         end
 
-        if options[:ignore_root]
-          [options[:ignore_root]].flatten.each do |key|
+        if ignore_root
+          [ignore_root].flatten.each do |key|
             body = body[key.to_s]
           end
         end
       elsif is_xml_response?
         body = @response.body.blank? ? {} : Crack::XML.parse(@response.body)
-        if options[:ignore_root]
-          [options[:ignore_root]].flatten.each do |key|
+        if ignore_root
+          [ignore_root].flatten.each do |key|
             body = body[key.to_s]
           end
         elsif options[:ignore_xml_root]
@@ -844,7 +890,7 @@ module Flexirest
         result = new_object(body, @overridden_name)
         result._status = @response.status
         result._headers = @response.response_headers
-        result._etag = @response.response_headers['ETag']
+        result._etag = @response.response_headers['ETag'] unless @method[:options][:skip_caching]
         if !object_is_class? && options[:mutable] != false
           @object._copy_from(result)
           @object._clean!

data/lib/flexirest/version.rb

@@ -1,3 +1,3 @@
 module Flexirest
-  VERSION = "1.10.1"
+  VERSION = "1.10.6"
 end

data/spec/lib/json_api_spec.rb

@@ -303,7 +303,7 @@ describe 'JSON API' do
   let(:tags) { JsonAPIExample::Tag }
   let(:author) { JsonAPIExample::Author }
 
-  context 'responses' do
+  describe 'responses' do
     it 'should return the data object if the response contains only one data instance' do
       expect(subject.find(1)).to be_an_instance_of(JsonAPIExampleArticle)
     end
@@ -370,17 +370,17 @@ describe 'JSON API' do
     end
   end
 
-  context 'attributes' do
+  describe 'attributes' do
     it 'should return the attributes as part of the data instance' do
-      expect(subject.find(1).item).to_not be_nil
+      expect(subject.find(1).item).to eq("item one")
     end
 
     it 'should return the association\'s attributes as part of the association instance' do
-      expect(subject.includes(:author).find_single_author(1).author.item).to_not be_nil
+      expect(subject.includes(:author).find_single_author(1).author.item).to eq("item two")
     end
   end
 
-  context 'associations' do
+  describe 'associations' do
     it 'should retrieve the resource\'s associations via its relationships object' do
       expect(subject.includes(:tags).find(1).tags.size).to eq(2)
     end
@@ -415,6 +415,40 @@ describe 'JSON API' do
     end
   end
 
+  describe 'requests' do
+    describe 'the `include=` parameter' do
+      before { stub_request(:get, %r{example\.com/articles}) }
+
+      context 'when using `.includes(:tags)`' do
+        it 'equal "tags"' do
+          JsonAPIExample::Article.includes(:tags).real_index
+          expect(WebMock).to have_requested(:get, 'http://www.example.com/articles?include=tags')
+        end
+      end
+
+      context 'when using `.includes(tags: [:authors, :articles])`' do
+        it 'equal "tags.authors,tags.articles"' do
+          JsonAPIExample::Article.includes(tags: [:authors, :articles]).real_index
+          expect(WebMock).to have_requested(:get, 'http://www.example.com/articles?include=tags.authors,tags.articles')
+        end
+      end
+
+      context 'when using both `.includes(:tags)` and other params in the final call' do
+        it 'uses the values passed to the `includes() method`' do
+          JsonAPIExample::Article.includes(:tags).real_index(filter: { author_id: 4 })
+          expect(WebMock).to have_requested(:get, 'http://www.example.com/articles?filter%5Bauthor_id%5D=4&include=tags')
+        end
+      end
+
+      context 'when using both `.includes(:tags)` and the :include param in final call' do
+        it 'uses the values passed to the `includes() method`' do
+          JsonAPIExample::Article.includes(:tags).real_index(include: "author")
+          expect(WebMock).to have_requested(:get, 'http://www.example.com/articles?include=tags')
+        end
+      end
+    end
+  end
+
   context 'lazy loading' do
     it 'should fetch association lazily' do
       stub_request(:get, /www.example.com\/articles\/1\/tags/)
@@ -434,7 +468,7 @@ describe 'JSON API' do
     end
   end
 
-  context 'client' do
+  describe 'client' do
     it 'should request with json api format, and expect a json api response' do
       expect_any_instance_of(Flexirest::Connection).to receive(:post) { |_, _, _, options|
         expect(options[:headers]).to include('Content-Type' => 'application/vnd.api+json')

data/spec/lib/request_spec.rb

@@ -41,6 +41,7 @@ describe Flexirest::Request do
       get :find, "/:id", required: [:id]
       get :find_cat, "/:id/cat"
       get :fruits, "/fruits"
+      get :uncached, "/uncached", skip_caching: true
       get :change, "/change"
       get :plain, "/plain/:id", plain: true
       post :create, "/create", rubify_names: true
@@ -81,6 +82,26 @@ describe Flexirest::Request do
       get :all, "/"
     end
 
+    class AuthenticatedBasicHeaderExampleClient < Flexirest::Base
+      base_url "http://www.example.com"
+      username "john"
+      password "smith"
+      basic_auth_method :header
+      get :all, "/"
+    end
+
+    class AuthenticatedBasicHeaderExampleClientChildClass < AuthenticatedBasicHeaderExampleClient
+      get :child_method, "/"
+    end
+
+    class AuthenticatedBasicUrlExampleClient < Flexirest::Base
+      base_url "http://www.example.com"
+      username "john"
+      password "smith"
+      basic_auth_method :url
+      get :all, "/"
+    end
+
     class AuthenticatedProcExampleClient < Flexirest::Base
       base_url "http://www.example.com"
       username Proc.new { |obj| obj ? "bill-#{obj.id}" : "bill" }
@@ -199,6 +220,89 @@ describe Flexirest::Request do
       }
     end
 
+    class LocalIgnoredRootExampleClient < ExampleClient
+      ignore_root "feed"
+
+      get :root, "/root", fake: %Q{
+        {
+          "feed": {
+            "title": "Example Feed"
+          }
+        }
+      }
+    end
+
+    class LocalIgnoredMultiLevelRootExampleClient < ExampleClient
+      ignore_root [:response, "data", "object"]
+
+      get :multi_level_root, "/multi-level-root", fake: %Q{
+        {
+          "response": {
+            "data": {
+              "object": {
+                "title": "Example Multi Level Feed"
+              }
+            }
+          }
+        }
+      }
+    end
+
+    class BaseIgnoredRootExampleClient < Flexirest::Base
+      base_url "http://www.example.com"
+      ignore_root "feed"
+    end
+
+    class GlobalIgnoredRootExampleClient < BaseIgnoredRootExampleClient
+      get :root, "/root", fake: %Q{
+        {
+          "feed": {
+            "title": "Example Feed"
+          }
+        }
+      }
+    end
+
+    class OverrideGlobalIgnoredRootForFileExampleClient < BaseIgnoredRootExampleClient
+      ignore_root "data"
+
+      get :root, "/root", fake: %Q{
+        {
+          "data": {
+            "title": "Example Feed"
+          }
+        }
+      }
+    end
+
+    class OverrideGlobalIgnoredRootForRequestExampleClient < BaseIgnoredRootExampleClient
+      get :root, "/root", ignore_root: "data", fake: %Q{
+        {
+          "data": {
+            "title": "Example Feed"
+          }
+        }
+      }
+    end
+
+    class BaseWrappedRootExampleClient < Flexirest::Base
+      base_url "http://www.example.com"
+      wrap_root "base_data"
+    end
+
+    class GlobalWrappedRootExampleClient < BaseWrappedRootExampleClient
+      put :wrapped, "/put/:id"
+    end
+
+    class OverrideGlobalWrappedRootForFileExampleClient < BaseWrappedRootExampleClient
+      wrap_root "class_specific_data"
+      put :wrapped, "/put/:id"
+    end
+
+    class OverrideGlobalWrappedRootForRequestExampleClient < BaseWrappedRootExampleClient
+      put :wrapped, "/put/:id", wrap_root: "request_specific_data"
+    end
+
     class WhitelistedDateClient < Flexirest::Base
       base_url "http://www.example.com"
       put :conversion, "/put/:id"
@@ -231,13 +335,53 @@ describe Flexirest::Request do
     expect(servers.uniq.count).to eq(2)
   end
 
-  it "should get an HTTP connection with authentication when called" do
+  it "should use the URL method for Basic HTTP Auth when no basic_auth_method is set" do
+    mocked_response = ::FaradayResponseMock.new(OpenStruct.new(body:'{"result":true}', response_headers:{}))
+
     connection = double(Flexirest::Connection).as_null_object
     expect(Flexirest::ConnectionManager).to receive(:get_connection).with("http://john:smith@www.example.com").and_return(connection)
-    expect(connection).to receive(:get).with("/", an_instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(body:'{"result":true}', response_headers:{})))
+    expect(connection).to receive(:get).with("/", an_instance_of(Hash)).and_return(mocked_response)
     AuthenticatedExampleClient.all
   end
 
+  it "should use the headers method for Basic auth when basic_auth_method is set to :header" do
+    mocked_response = ::FaradayResponseMock.new(OpenStruct.new(body:'{"result":true}', response_headers:{}))
+    headers_including_auth = hash_including({ "Authorization" => "Basic am9objpzbWl0aA==" })
+
+    connection = double(Flexirest::Connection).as_null_object
+    expect(Flexirest::ConnectionManager).to receive(:get_connection).with("http://www.example.com").and_return(connection)
+    expect(connection).to receive(:get).with("/", hash_including(headers: headers_including_auth)).and_return(mocked_response)
+    AuthenticatedBasicHeaderExampleClient.all
+  end
+
+  it "should raise an error if Basic HTTP method is not :header or :url" do
+    expect do
+      AuthenticatedExampleClient.class_eval do
+        basic_auth_method :some_invalid_value
+      end
+    end.to raise_error(RuntimeError, "Invalid basic_auth_method :some_invalid_value. Valid methods are :url (default) and :header.")
+  end
+
+  it "should use the setting set on the parent class" do
+    mocked_response = ::FaradayResponseMock.new(OpenStruct.new(body:'{"result":true}', response_headers:{}))
+    headers_including_auth = hash_including({ "Authorization" => "Basic am9objpzbWl0aA==" })
+
+    connection = double(Flexirest::Connection).as_null_object
+    expect(Flexirest::ConnectionManager).to receive(:get_connection).with("http://www.example.com").and_return(connection)
+    expect(connection).to receive(:get).with("/", hash_including(headers: headers_including_auth)).and_return(mocked_response)
+    AuthenticatedBasicHeaderExampleClientChildClass.child_method
+  end
+
+  it "should use the URL method for Basic auth when basic_auth_method is set to :url (and not include Authorization header)" do
+    mocked_response = ::FaradayResponseMock.new(OpenStruct.new(body:'{"result":true}', response_headers:{}))
+    headers_not_including_auth = hash_excluding("Authorization")
+
+    connection = double(Flexirest::Connection).as_null_object
+    expect(Flexirest::ConnectionManager).to receive(:get_connection).with("http://john:smith@www.example.com").and_return(connection)
+    expect(connection).to receive(:get).with("/", headers: headers_not_including_auth).and_return(mocked_response)
+    AuthenticatedBasicUrlExampleClient.all
+  end
+
   it "should get an HTTP connection with basic authentication using procs when called in a class context" do
     connection = double(Flexirest::Connection).as_null_object
     expect(Flexirest::ConnectionManager).to receive(:get_connection).with("http://bill:jones@www.example.com").and_return(connection)
@@ -854,6 +998,35 @@ describe Flexirest::Request do
     expect(object._etag).to eq("123456")
   end
 
+  it "shouldn't expose the etag header if skip_caching is enabled" do
+    response = ::FaradayResponseMock.new(OpenStruct.new(body: "{}", response_headers: {"ETag" => "123456"}, status: 200))
+    expect_any_instance_of(Flexirest::Connection).to receive(:get).with("/uncached", an_instance_of(Hash)).and_return(response)
+    object = ExampleClient.uncached
+    expect(object._etag).to_not eq("123456")
+  end
+
+  it "shouldn't send the etag header if skip_caching is enabled" do
+    cached_response = Flexirest::CachedResponse.new(status:200, result:"", response_headers: {})
+    cached_response.etag = "123456"
+    expect(ExampleClient).to receive(:read_cached_response).and_return(cached_response)
+
+    response = ::FaradayResponseMock.new(OpenStruct.new(body: "{}", response_headers: {"ETag" => "123456"}, status: 200))
+    expect_any_instance_of(Flexirest::Connection).to receive(:get).with("/uncached", {
+      api_auth: {
+        api_auth_access_id: "id123",
+        api_auth_options: {},
+        api_auth_secret_key: "secret123"
+      },
+      headers: {
+        "Accept"=>"application/hal+json, application/json;q=0.5",
+        "Content-Type"=>"application/x-www-form-urlencoded; charset=utf-8"
+      }
+    }).and_return(response)
+
+    expect(ExampleClient).to_not receive(:write_cached_response)
+    object = ExampleClient.uncached
+  end
+
   it "should expose all headers" do
     response = ::FaradayResponseMock.new(OpenStruct.new(body: "{}", response_headers: {"X-Test-Header" => "true"}, status: 200))
     expect_any_instance_of(Flexirest::Connection).to receive(:get).with("/123", an_instance_of(Hash)).and_return(response)
@@ -1355,6 +1528,62 @@ describe Flexirest::Request do
     expect(IgnoredMultiLevelRootExampleClient.multi_level_root.title).to eq("Example Multi Level Feed")
   end
 
+  it "should ignore a specified root element" do
+    expect(LocalIgnoredRootExampleClient.root.title).to eq("Example Feed")
+  end
+
+  it "should ignore a specified multi-level root element" do
+    expect(LocalIgnoredMultiLevelRootExampleClient.multi_level_root.title).to eq("Example Multi Level Feed")
+  end
+
+  it "should ignore a specified root element" do
+    expect(GlobalIgnoredRootExampleClient.root.title).to eq("Example Feed")
+  end
+
+  it "should ignore a specified root element" do
+    expect(OverrideGlobalIgnoredRootForFileExampleClient.root.title).to eq("Example Feed")
+  end
+
+  it "should ignore a specified root element" do
+    expect(OverrideGlobalIgnoredRootForRequestExampleClient.root.title).to eq("Example Feed")
+  end
+
+  it "should wrap elements if specified, in form-encoded format" do
+    expect_any_instance_of(Flexirest::Connection).to receive(:put).with("/put/1234", %q(base_data%5Bdebug%5D=true&base_data%5Btest%5D=foo), an_instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(body:"{\"result\":true}", response_headers:{})))
+    GlobalWrappedRootExampleClient.request_body_type :form_encoded
+    GlobalWrappedRootExampleClient.wrapped id:1234, debug:true, test:'foo'
+  end
+
+  it "should wrap elements if specified, in form-encoded format" do
+    expect_any_instance_of(Flexirest::Connection).to receive(:put).with("/put/1234", %q(class_specific_data%5Bdebug%5D=true&class_specific_data%5Btest%5D=foo), an_instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(body:"{\"result\":true}", response_headers:{})))
+    OverrideGlobalWrappedRootForFileExampleClient.request_body_type :form_encoded
+    OverrideGlobalWrappedRootForFileExampleClient.wrapped id:1234, debug:true, test:'foo'
+  end
+
+  it "should wrap elements if specified, in form-encoded format" do
+    expect_any_instance_of(Flexirest::Connection).to receive(:put).with("/put/1234", %q(request_specific_data%5Bdebug%5D=true&request_specific_data%5Btest%5D=foo), an_instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(body:"{\"result\":true}", response_headers:{})))
+    OverrideGlobalWrappedRootForRequestExampleClient.request_body_type :form_encoded
+    OverrideGlobalWrappedRootForRequestExampleClient.wrapped id:1234, debug:true, test:'foo'
+  end
+
+  it "should encode the body wrapped in a root element in a JSON format if specified" do
+    expect_any_instance_of(Flexirest::Connection).to receive(:put).with("/put/1234", %q({"base_data":{"debug":true,"test":"foo"}}), an_instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(body:"{\"result\":true}", response_headers:{})))
+    GlobalWrappedRootExampleClient.request_body_type :json
+    GlobalWrappedRootExampleClient.wrapped id:1234, debug:true, test:'foo'
+  end
+
+  it "should encode the body wrapped in a root element in a JSON format if specified" do
+    expect_any_instance_of(Flexirest::Connection).to receive(:put).with("/put/1234", %q({"class_specific_data":{"debug":true,"test":"foo"}}), an_instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(body:"{\"result\":true}", response_headers:{})))
+    OverrideGlobalWrappedRootForFileExampleClient.request_body_type :json
+    OverrideGlobalWrappedRootForFileExampleClient.wrapped id:1234, debug:true, test:'foo'
+  end
+
+  it "should encode the body wrapped in a root element in a JSON format if specified" do
+    expect_any_instance_of(Flexirest::Connection).to receive(:put).with("/put/1234", %q({"request_specific_data":{"debug":true,"test":"foo"}}), an_instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(body:"{\"result\":true}", response_headers:{})))
+    OverrideGlobalWrappedRootForRequestExampleClient.request_body_type :json
+    OverrideGlobalWrappedRootForRequestExampleClient.wrapped id:1234, debug:true, test:'foo'
+  end
+
   context "Parameter preparation" do
     method = {url: "http://www.example.com", method: :get}
     object = nil

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: flexirest
 version: !ruby/object:Gem::Version
-  version: 1.10.1
+  version: 1.10.6
 platform: ruby
 authors:
 - Andy Jeffries
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-10-12 00:00:00.000000000 Z
+date: 2021-06-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -176,14 +176,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.8.0
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.8.0
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: mime-types
   requirement: !ruby/object:Gem::Requirement