nice_http 1.0.4 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b7b94ecb393c3395796636b8e9308bcea20dde7ca9e314ddeae7dd3129ac8bd
-  data.tar.gz: c760b6830a3f2f6a1d681ef731df55d47f555c67a2a5b38709f1a61af5943ce9
+  metadata.gz: bc467413aa1e110d9ee4f26473a1a8777642836bc0c0187e00566fc2558fd80d
+  data.tar.gz: '04568929a3b8180fded025a5cc144ebdddfa25416ad0e16455aa076febb8b1ae'
 SHA512:
-  metadata.gz: 87ab72b2e991b77c83a82a12e114ed070544202805afa5aeceec1ae07fa0cd28a2ca514e5118b2a5bfb5a5832cb39477feeeb57df1f8bf156394a5e5a76b3db3
-  data.tar.gz: 30bbd18f121e0502e83ea5bacce0c998cc1aafcb7fa23162333028484873379653c054dfc7f203dadd74e37d5d2702913e453abe721a4d03ec5c45ee02ef8c39
+  metadata.gz: c6d3572e818f3939c9bade93bcd1d7b4e4198e0da5fa2913f346b32ecdc5694cdd7df29337784d1453c080b15190e4fe2e477ba591102e0459ca32925e0117bc
+  data.tar.gz: ab2b3cb27234d48fefea4b1c4ef61c123519450b202829dbc3d32bcfac1b91b29bebec1ae09dfa01160c77a9acd2e850e82114a45e1887ca65e7fe2d0651893c

data/README.md

@@ -64,10 +64,11 @@ http3 = NiceHttp.new my_reqres_server
 ```
 
 
-You can specify all the defaults you will be using when creating connections by using the NiceHttp methods, in this example, http1 and http2 will be connecting to reqres.in and http3 to example.com:
+You can specify all the defaults you will be using when creating connections by using the NiceHttp methods, in this example, http1 and http2 will be connecting to reqres.in with the default parameters and http3 to example.com:
 
 ```ruby
 
+# default parameters
 NiceHttp.host = 'reqres.in'
 NiceHttp.ssl = true
 NiceHttp.port = 443
@@ -83,6 +84,20 @@ http3 = NiceHttp.new("https://example.com")
 
 ```
 
+If you prefer to supply a hash to change the default settings for NiceHttp:
+
+```ruby
+NiceHttp.defaults = {
+    host: 'reqres.in',
+    ssl: true,
+    port: 443,
+    debug: false,
+    log: "./my_logs.log",
+    headers: {"api-key": "the api key"}
+}
+```
+
+
 ## Creating requests
 
 You can use hash requests to simplify the management of your requests, for example creating a file specifying all the requests for your Customers API.
@@ -161,12 +176,12 @@ pp resp.data.json(:job)
 ```
 
 
-In case you want to modify the request before sending it, for example just changing one field but the rest will be the same, you can supply a new key :values in the request hash that will contain a hash with the keys to be changed and NiceHttp will perform the necessary changes at any level:
+In case you want to modify the request before sending it, for example just changing one field but the rest will be the same, you can supply a new key :values_at in the request hash that will contain a hash with the keys to be changed and NiceHttp will perform the necessary changes at any level:
 
 ```ruby
 
 req = Requests::Example.create_user_hash
-req[:values] = {job: "developer"}
+req.values_at = {job: "developer"}
 
 resp = http.post req
 

data/lib/nice_http.rb

@@ -2,7 +2,43 @@ require 'logger'
 require 'nice_hash'
 require_relative 'nice_http/utils'
 
-class NiceHttp
+  ######################################################
+  # Attributes you can access using NiceHttp.the_attribute: 
+  #   :host, :port, :ssl, :headers, :debug, :log, :proxy_host, :proxy_port, 
+  #   :last_request, :last_response, :request_id, :use_mocks, :connections,
+  #   :active, :auto_redirect  
+  #
+  # @attr [String] host The host to be accessed
+  # @attr [Integer] port  The port number
+  # @attr [Boolean] ssl  If you use ssl or not
+  # @attr [Hash] headers Contains the headers you will be using on your connection 
+  # @attr [Boolean] debug In case true shows all the details of the communication with the host
+  # @attr [String, Symbol] log :fix_file, :no, :screen, :file, "path and file name".
+  #   :fix_file will log the communication on nice_http.log. (default).
+  #   :no will not generate any logs. 
+  #   :screen will print the logs on the screen.
+  #   :file will be generated a log file with name: nice_http_YY-mm-dd-HHMMSS.log.
+  #   String the path and file name where the logs will be stored.
+  # @attr [String] proxy_host the proxy host to be used
+  # @attr [Integer] proxy_port the proxy port to be used
+  # @attr [String] last_request The last request with all the content sent
+  # @attr [String] last_response Only in case :debug is true, the last response with all the content
+  # @attr [String] request_id If the response includes a requestId, will be stored here
+  # @attr [Boolean] use_mocks If true, in case the request hash includes a :mock_response key, it will be used as the response instead
+  # @attr [Array] connections It will include all the active connections (NiceHttp instances)
+  # @attr [Integer] active Number of active connections
+  # @attr [Boolean] auto_redirect If true, NiceHttp will take care of the auto redirections when required by the responses
+  # @attr [Hash] response Contains the full response hash
+  # @attr [Integer] num_redirects Number of consecutive redirections managed
+  # @attr [Hash] headers The updated headers of the communication 
+  # @attr [Hash] cookies Cookies set. The key is the path (String) where cookies are set and the value a Hash with pairs of cookie keys and values, example:
+  #   { '/' => { "cfid" => "d95adfas2550255", "amddom.settings" => "doom" } }
+  # @attr [Logger] logger An instance of the Logger class where logs will be stored. You can access on anytime to store specific data, for example: 
+  #   my_http.logger.info "add this to the log file"
+  #   @see https://ruby-doc.org/stdlib-2.5.0/libdoc/logger/rdoc/Logger.html
+  ######################################################
+  class NiceHttp
+
   class << self
     attr_accessor :host, :port, :ssl, :headers, :debug, :log, :proxy_host, :proxy_port, 
                   :last_request, :last_response, :request_id, :use_mocks, :connections,
@@ -27,6 +63,11 @@ class NiceHttp
   attr_reader :host, :port, :ssl, :debug, :log, :proxy_host, :proxy_port, :response, :num_redirects
   attr_accessor :headers, :cookies, :use_mocks, :auto_redirect, :logger
 
+  ######################################################
+  # Change the default values for NiceHttp supplying a Hash
+  #
+  # @param par [Hash] keys: :host, :port, :ssl, :headers, :debug, :log, :proxy_host, :proxy_port, :use_mocks, :auto_redirect
+  ######################################################
   def self.defaults=(par = {})
     @host = par[:host] if par.key?(:host)
     @port = par[:port] if par.key?(:port)
@@ -36,7 +77,7 @@ class NiceHttp
     @log = par[:log] if par.key?(:log)
     @proxy_host = par[:proxy_host] if par.key?(:proxy_host)
     @proxy_port = par[:proxy_port] if par.key?(:proxy_port)
-    @proxy_port = par[:use_mocks] if par.key?(:use_mocks)
+    @use_mocks = par[:use_mocks] if par.key?(:use_mocks)
     @auto_redirect = par[:auto_redirect] if par.key?(:auto_redirect)
   end
 
@@ -61,7 +102,7 @@ class NiceHttp
   #
   #             ssl -- true, false (default)
   #
-  #             headers -- hash with the header key:values
+  #             headers -- hash with the headers
   #
   #             debug -- true, false (default)
   #
@@ -208,8 +249,8 @@ class NiceHttp
       #     :message = plain text response.
       #     :code = code response (200=ok,500=wrong...).
       #   All keys in response are lowercase.
-      #   data, message and code can also be accessed as attributes like .message .code .data
-      # @return [Symbol] in case of error returns :error
+      #   data, message and code can also be accessed as attributes like .message .code .data.
+      #   In case of fatal error returns {fatal_error: "the error description", code: nil, message: nil, data: ''}
       #
       # @example 
       #   resp = @http.get(Requests::Customer.get_profile)
@@ -309,25 +350,26 @@ class NiceHttp
           return @response
         rescue Exception => stack
           @logger.fatal stack
-          return :error
+          return {fatal_error: stack.to_s, code: nil, message: nil, data: ''}
         end
       end
 
       ######################################################
       # Post data to path
-      # @param arguments [Hash] containing at least keys :data and :path
-      # @param arguments [Array<path, data ,additional_headers]
-      #   path (string)
-      #   data (json data for example)
-      #   additional_headers (Hash key=>value)
+      # @param arguments [Hash] containing at least keys :data and :path. 
+      #   In case :data not supplied and :data_examples array supplied, it will be taken the first example as :data.
+      # @param arguments [Array<path, data, additional_headers>]
+      #   path (string).
+      #   data (json data for example).
+      #   additional_headers (Hash key=>value).
       # @return [Hash] response
       #   Including at least the symbol keys:
       #     :data = the response data body.
       #     :message = plain text response.
       #     :code = code response (200=ok,500=wrong...).
       #   All keys in response are lowercase.
-      #   data, message and code can also be accessed as attributes like .message .code .data
-      # @return [Symbol] in case of error returns :error
+      #   data, message and code can also be accessed as attributes like .message .code .data.
+      #   In case of fatal error returns {fatal_error: "the error description", code: nil, message: nil, data: ''}
       # @example
       #   resp = @http.post(Requests::Customer.update_customer)
       #   assert resp.code == 201
@@ -403,27 +445,28 @@ class NiceHttp
           end
           return @response
         rescue Exception => stack
-          @logger.warn stack
-          return :error
+          @logger.fatal stack
+          return {fatal_error: stack.to_s, code: nil, message: nil, data: ''}
         end
   
       end
 
       ######################################################
       # Put data to path
-      # @param arguments [Hash] containing at least keys :data and :path
-      # @param arguments [Array<path, data ,additional_headers]
-      #   path (string)
-      #   data (json data for example)
-      #   additional_headers (Hash key=>value)
+      # @param arguments [Hash] containing at least keys :data and :path.
+      #   In case :data not supplied and :data_examples array supplied, it will be taken the first example as :data.
+      # @param arguments [Array<path, data, additional_headers>]
+      #   path (string).
+      #   data (json data for example).
+      #   additional_headers (Hash key=>value).
       # @return [Hash] response
       #   Including at least the symbol keys:
       #     :data = the response data body.
       #     :message = plain text response.
       #     :code = code response (200=ok,500=wrong...).
       #   All keys in response are lowercase.
-      #   data, message and code can also be accessed as attributes like .message .code .data
-      # @return [Symbol] in case of error returns :error
+      #   data, message and code can also be accessed as attributes like .message .code .data.
+      #   In case of fatal error returns {fatal_error: "the error description", code: nil, message: nil, data: ''}
       # @example
       #   resp = @http.put(Requests::Customer.remove_phone)
       ######################################################
@@ -469,8 +512,8 @@ class NiceHttp
   
           return @response
         rescue Exception => stack
-          @logger.fatal stack, self
-          return :error
+          @logger.fatal stack
+          return {fatal_error: stack.to_s, code: nil, message: nil, data: ''}
         end
   
       end
@@ -478,19 +521,20 @@ class NiceHttp
   
       ######################################################
       # Patch data to path
-      # @param arguments [Hash] containing at least keys :data and :path
-      # @param arguments [Array<path, data ,additional_headers]
-      #   path (string)
-      #   data (json data for example)
-      #   additional_headers (Hash key=>value)
+      # @param arguments [Hash] containing at least keys :data and :path.
+      #   In case :data not supplied and :data_examples array supplied, it will be taken the first example as :data.
+      # @param arguments [Array<path, data, additional_headers>]
+      #   path (string).
+      #   data (json data for example).
+      #   additional_headers (Hash key=>value).
       # @return [Hash] response
       #   Including at least the symbol keys:
       #     :data = the response data body.
       #     :message = plain text response.
       #     :code = code response (200=ok,500=wrong...).
       #   All keys in response are lowercase.
-      #   data, message and code can also be accessed as attributes like .message .code .data
-      # @return [Symbol] in case of error returns :error
+      #   data, message and code can also be accessed as attributes like .message .code .data.
+      #   In case of fatal error returns {fatal_error: "the error description", code: nil, message: nil, data: ''}
       # @example
       #   resp = @http.patch(Requests::Customer.unrelease_account)
       ######################################################
@@ -552,7 +596,7 @@ class NiceHttp
           return @response
         rescue Exception => stack
           @logger.fatal stack
-          return :error
+          return {fatal_error: stack.to_s, code: nil, message: nil, data: ''}
         end
   
       end
@@ -568,8 +612,8 @@ class NiceHttp
       #     :message = plain text response.
       #     :code = code response (200=ok,500=wrong...).
       #   All keys in response are lowercase.
-      #   data, message and code can also be accessed as attributes like .message .code .data
-      # @return [Symbol] in case of error returns :error
+      #   data, message and code can also be accessed as attributes like .message .code .data.
+      #   In case of fatal error returns {fatal_error: "the error description", code: nil, message: nil, data: ''}
       # @example
       #   resp = @http.delete(Requests::Customer.remove_session)
       #   assert resp.code == 204
@@ -620,7 +664,7 @@ class NiceHttp
           return @response
         rescue Exception => stack
           @logger.fatal stack
-          return :error
+          return {fatal_error: stack.to_s, code: nil, message: nil, data: ''}
         end
   
       end
@@ -637,8 +681,8 @@ class NiceHttp
       #     :message = plain text response.
       #     :code = code response (200=ok,500=wrong...).
       #   All keys in response are lowercase.
-      #   message and code can also be accessed as attributes like .message .code
-      # @return [Symbol] in case of error returns :error
+      #   message and code can also be accessed as attributes like .message .code.
+      #   In case of fatal error returns {fatal_error: "the error description", code: nil, message: nil}
       ######################################################
       def head(argument)
         begin
@@ -685,7 +729,7 @@ class NiceHttp
           return @response
         rescue Exception => stack
           @logger.fatal stack
-          return :error
+          return {fatal_error: stack.to_s, code: nil, message: nil}
         end
       end
 
@@ -733,6 +777,7 @@ class NiceHttp
       #   input:
       #     3 args: path, data, headers
       #     1 arg:  Hash containg at least keys :path and :data
+      #             In case :data not supplied and :data_examples array supplied, it will be taken the first example as :data.
       #   output:
       #     path, data, headers
       ######################################################
@@ -814,20 +859,23 @@ class NiceHttp
               headers_t['Content-Type'] = 'application/json'
               content_type_included=true
             end
-            
+            # to be backwards compatible since before was :values
+            if arguments[0].include?(:values) and !arguments[0].include?(:values_at)
+              arguments[0][:values_at] = arguments[0][:values]
+            end
             if content_type_included and (!headers_t["Content-Type"][/text\/xml/].nil? or 
               !headers_t["Content-Type"]["application/soap+xml"].nil? or 
               !headers_t["Content-Type"][/application\/jxml/].nil?) then
-              if arguments[0].include?(:values) then
-                arguments[0][:values].each {|key, value|
+              if arguments[0].include?(:values_at) then
+                arguments[0][:values_at].each {|key, value|
                   data=NiceHttpUtils.set_value_xml_tag(key.to_s(), data, value.to_s(), true)
                 }
               end
             elsif content_type_included and !headers_t["Content-Type"][/application\/json/].nil? and data.to_s()!="" then
               require 'json'
               if data.kind_of?(String) then
-                if arguments[0].include?(:values) then
-                  arguments[0][:values].each {|key, value|
+                if arguments[0].include?(:values_at) then
+                  arguments[0][:values_at].each {|key, value|
                     data.gsub!(/(( *|^)"?#{key.to_s()}"? *: *")(.*)(" *, *$)/, '\1' + value+ '\4') # "key":"value", or key:"value",
                     data.gsub!(/(( *|^)"?#{key.to_s()}"? *: *")(.*)(" *$)/, '\1' + value+ '\4') # "key":"value" or key:"value"
                     data.gsub!(/(( *|^)"?#{key.to_s()}"? *: *[^"])([^"].*)([^"] *, *$)/, '\1' + value+ '\4') # "key":456, or key:456,
@@ -839,10 +887,10 @@ class NiceHttp
                 data.each {|key, value|
                   data_n[key.to_s()]=value
                 }
-                if arguments[0].include?(:values) then
-                  #req[:values][:loginName] or req[:values]["loginName"]
+                if arguments[0].include?(:values_at) then
+                  #req[:values_at][:loginName] or req[:values_at]["loginName"]
                   new_values_hash=Hash.new()
-                  arguments[0][:values].each {|kv, vv|
+                  arguments[0][:values_at].each {|kv, vv|
                     if data_n.keys.include?(kv.to_s()) then
                       new_values_hash[kv.to_s()]=vv
                     end
@@ -861,18 +909,18 @@ class NiceHttp
                   row.each {|key, value|
                     data_n[key.to_s()]=value
                   }
-                  if arguments[0].include?(:values) then
-                    #req[:values][:loginName] or req[:values]["loginName"]
+                  if arguments[0].include?(:values_at) then
+                    #req[:values_at][:loginName] or req[:values_at]["loginName"]
                     new_values_hash=Hash.new()
-                    if arguments[0][:values].kind_of?(Hash) then #values[:mykey][3]
-                      arguments[0][:values].each {|kv, vv|
+                    if arguments[0][:values_at].kind_of?(Hash) then #values[:mykey][3]
+                      arguments[0][:values_at].each {|kv, vv|
                         if data_n.keys.include?(kv.to_s()) and !vv[indx].nil? then
                           new_values_hash[kv.to_s()]=vv[indx]
                         end
                       }
-                    elsif arguments[0][:values].kind_of?(Array) then #values[5][:mykey]
-                      if !arguments[0][:values][indx].nil? then
-                        arguments[0][:values][indx].each {|kv, vv|
+                    elsif arguments[0][:values_at].kind_of?(Array) then #values[5][:mykey]
+                      if !arguments[0][:values_at][indx].nil? then
+                        arguments[0][:values_at][indx].each {|kv, vv|
                           if data_n.keys.include?(kv.to_s()) then
                             new_values_hash[kv.to_s()]=vv
                           end
@@ -891,10 +939,10 @@ class NiceHttp
                 @logger.fatal("Wrong format on request application/json, be sure is a Hash, Array of Hashes or JSON string")
                 return :error, :error, :error
               end
-            elsif content_type_included and arguments[0].include?(:values) then
-              if arguments[0][:values].kind_of?(Hash) and arguments[0][:values].keys.size>0 then
+            elsif content_type_included and arguments[0].include?(:values_at) then
+              if arguments[0][:values_at].kind_of?(Hash) and arguments[0][:values_at].keys.size>0 then
                 if !headers_t.nil? and headers_t.kind_of?(Hash) and headers_t["Content-Type"]!="application/x-www-form-urlencoded" and headers_t["content-type"]!="application/x-www-form-urlencoded" then
-                  @logger.warn(":values key given without a valid content-type or data for request. No values modified on the request")
+                  @logger.warn(":values_at key given without a valid content-type or data for request. No values modified on the request")
                 end
               end
             end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nice_http
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.1.0
 platform: ruby
 authors:
 - Mario Ruiz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-14 00:00:00.000000000 Z
+date: 2019-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nice_hash
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.7.2
+        version: 1.7.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.7.2
+        version: 1.7.3
 description: NiceHttp -- simplest library for accessing and testing HTTP and REST
   resources. Manage different hosts on the fly. Easily get the value you want from
   the JSON strings. Use hashes on your requests.