nice_http 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 609d0cfed9e68d29af972ceb77095bfae7591899aa2715ce59987ea22298e98d
-  data.tar.gz: 4bcaecdde1849f12198487e0a619759b5c56c907dda577fc6518d2efed21c8d0
+  metadata.gz: e13c6fcc544ad6f967b3d4a4d9f0efd945b798e7acf2caa5edefcc764902c1e0
+  data.tar.gz: b0b66d1cf1951a94b3d032774990f29d40dd6036ff54f313b8155c1d862d5299
 SHA512:
-  metadata.gz: a29e0ae4d2d40f650a43abfc4be521bb7933c923b3f6852e373582de52629999d2bce1102978b831288fd586e7ad773d114b3f877e7c2adf8d7d590510afdbb0
-  data.tar.gz: 279c1f0bd6bf5f760038f7bbf3bdfd242ccbdf133af3239eaf6f6466f824de8f0d9352ce0fbbe0075354c5ce8f0948cefca86136bff072da0baed617aeb5072c
+  metadata.gz: af513dc9bafc301fed7f282f4472c6c8f1449a01c0bd82de7d7fece8baa26df169767ee08697907a41d927a89b17f49fad4a3ab85ff99c02148fef676b780faa
+  data.tar.gz: 35a853fc116ba4c56d21ce006108db0b950789d6917f7bba1a70289821cbab1456658ede6eb7ca2f00843b5c7ef59b95b91f3817a8f81257f90a5cd9dfbaf444

data/lib/nice_http.rb

@@ -1,1176 +1,1195 @@
-require 'logger'
-require 'nice_hash'
-require_relative 'nice_http/utils'
-
-  ######################################################
-  # 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,
-                  :active, :auto_redirect
-  end
-  @host = nil
-  @port = 80
-  @ssl = false
-  @headers  = {}
-  @debug = false
-  @log = :fix_file
-  @proxy_host = nil
-  @proxy_port = nil
-  @last_request=nil
-  @last_response=nil
-  @request_id=""
-  @use_mocks = false
-  @connections = []
-  @active=0
-  @auto_redirect = true
-  
-  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)
-    @ssl = par[:ssl] if par.key?(:ssl)
-    @headers = par[:headers] if par.key?(:headers)
-    @debug = par[:debug] if par.key?(:debug)
-    @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)
-    @use_mocks = par[:use_mocks] if par.key?(:use_mocks)
-    @auto_redirect = par[:auto_redirect] if par.key?(:auto_redirect)
-  end
-
-  ######################################################
-  # Creates a new http connection. 
-  #
-  # @param args [] If no parameter supplied, by default will access how is setup on defaults
-  # @example 
-  #   http = NiceHttp.new()
-  # @param args [String]. The url to create the connection.
-  # @example 
-  #   http = NiceHttp.new("https://www.example.com")
-  # @example 
-  #   http = NiceHttp.new("example.com:8999")
-  # @example 
-  #   http = NiceHttp.new("localhost:8322")
-  # @param args [Hash] containing these possible keys:
-  #
-  #             host -- example.com. (default blank screen)
-  #
-  #             port -- port for the connection. 80 (default)
-  #
-  #             ssl -- true, false (default)
-  #
-  #             headers -- hash with the headers
-  #
-  #             debug -- true, false (default)
-  #
-  #             log -- :no, :screen, :file, :fix_file (default).
-  #
-  #                 A string with a path can be supplied.
-  #
-  #                 If :fix_file: nice_http.log
-  #
-  #                 In case :file it will be generated a log file with name: nice_http_YY-mm-dd-HHMMSS.log
-  #
-  #             proxy_host
-  #
-  #             proxy_port
-  # @example
-  #   http2 = NiceHttp.new( host: "reqres.in", port: 443, ssl: true )
-  # @example
-  #   my_server = {host: "example.com", 
-  #                port: 80, 
-  #                headers: {"api-key": "zdDDdjkck"}
-  #               } 
-  #   http3 = NiceHttp.new my_server
-  ######################################################
-  def initialize(args = {})
-    require 'net/http'
-    require 'net/https'
-    @host = NiceHttp.host
-    @port = NiceHttp.port
-    @ssl = NiceHttp.ssl
-    @headers = NiceHttp.headers
-    @debug = NiceHttp.debug
-    @log = NiceHttp.log
-    @proxy_host = NiceHttp.proxy_host
-    @proxy_port = NiceHttp.proxy_port
-    @use_mocks = NiceHttp.use_mocks
-    @auto_redirect=false #set it up at the end of initialize
-    auto_redirect = NiceHttp.auto_redirect
-    @num_redirects=0
-
-    #todo: set only the cookies for the current domain
-    #key: path, value: hash with key is the name of the cookie and value the value
-    # we set the default value for non existing keys to empty Hash {} so in case of merge there is no problem
-    @cookies=Hash.new {|h, k| h[k] = {}} 
-    
-    begin
-      if args.is_a?(String)
-        uri = URI.parse(args)
-        @host = uri.host unless uri.host.nil?
-        @port = uri.port unless uri.port.nil?
-        @ssl = true if !uri.scheme.nil? && (uri.scheme == 'https')
-      elsif args.is_a?(Hash) && !args.keys.empty?
-        @host = args[:host] if args.keys.include?(:host)
-        @port = args[:port] if args.keys.include?(:port)
-        @ssl = args[:ssl] if args.keys.include?(:ssl)
-        @headers = args[:headers] if args.keys.include?(:headers)
-        @debug = args[:debug] if args.keys.include?(:debug)
-        @log = args[:log] if args.keys.include?(:log)
-        @proxy_host = args[:proxy_host] if args.keys.include?(:proxy_host)
-        @proxy_port = args[:proxy_port] if args.keys.include?(:proxy_port)
-        @use_mocks = args[:use_mocks] if args.keys.include?(:use_mocks)
-        @auto_redirect = args[:auto_redirect] if args.keys.include?(:auto_redirect)
-      end
-
-      if @host.to_s!="" and (@host.include?("http:") or @host.include?("https:"))
-        uri = URI.parse(@host)
-        @host = uri.host unless uri.host.nil?
-        @port = uri.port unless uri.port.nil?
-        @ssl = true if !uri.scheme.nil? && (uri.scheme == 'https')
-      end
-
-      if @host.nil? or @host.to_s=="" or @port.nil? or @port.to_s==""
-        message = "It was not possible to create the http connection!!!\n"
-        message += "Wrong host or port, remember to supply http:// or https:// in case you specify an url to create the http connection, for example:\n"
-        message += "http = NiceHttp.new('http://example.com')"
-        raise message
-      end
-
-      if !@proxy_host.nil? && !@proxy_port.nil?
-        @http = Net::HTTP::Proxy(@proxy_host, @proxy_port).new(@host, @port)
-        @http.use_ssl = @ssl
-        @http.set_debug_output $stderr if @debug
-        @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-        @http.start
-      else
-        @http = Net::HTTP.new(@host, @port)
-        @http.use_ssl = @ssl
-        @http.set_debug_output $stderr if @debug
-        @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-        @http.start
-      end
-
-      if @log.kind_of?(String)
-        @logger = Logger.new File.new(@log, "w")
-      elsif @log==:fix_file
-        @logger = Logger.new File.new("nice_http.log", "w")
-      elsif @log==:file
-        @logger = Logger.new File.new("nice_http_#{Time.now.strftime('%Y-%m-%d-%H%M%S')}.log", 'w')
-      elsif @log==:screen
-        @logger = Logger.new STDOUT
-      elsif @log==:no
-        @logger = Logger.new nil
-      end
-      @logger.level = Logger::INFO
-      
-      @message_server="(#{self.object_id}):"
-  
-        log_message="(#{self.object_id}): Http connection created. host:#{@host},  port:#{@port},  ssl:#{@ssl}, mode:#{@mode}, proxy_host: #{@proxy_host.to_s()}, proxy_port: #{@proxy_port.to_s()} "
-
-        @logger.info(log_message)
-        @message_server+=" Http connection: "
-        if @ssl then
-          @message_server+="https://"
-        else
-          @message_server+="http://"
-        end
-        @message_server+="#{@host}:#{@port}"
-        if @proxy_host.to_s!="" then
-          @message_server+=" proxy:#{@proxy_host}:#{@proxy_port}"
-        end
-        @auto_redirect = auto_redirect
-    rescue Exception => stack
-      if @logger.nil?
-        puts stack
-        @logger = Logger.new nil
-      else
-        @logger.fatal stack
-      end
-    end
-
-    NiceHttp.active+=1
-    NiceHttp.connections.push(self)
-
-  end
-
-      ######################################################
-      # Get data from path
-      #
-      # @param arg [Hash] containing at least key :path 
-      # @param arg [String] the path 
-      #
-      # @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.
-      #   In case of fatal error returns { fatal_error: "the error description", code: nil, message: nil, data: '' }
-      #
-      # @example 
-      #   resp = @http.get(Requests::Customer.get_profile)
-      #   assert resp.code == 200
-      # @example 
-      #   resp = @http.get("/customers/1223")
-      #   assert resp.message == "OK"
-      ######################################################
-      def get(arg)
-        begin
-          path, data, headers_t=manage_request(arg)
-          @start_time = Time.now if @start_time.nil?
-          if @use_mocks and arg.kind_of?(Hash) and arg.keys.include?(:mock_response) then
-            data=""
-            if arg[:mock_response].keys.include?(:data) then
-              data=arg[:mock_response][:data]
-              if data.kind_of?(Hash) #to json
-                begin
-                  require 'json'
-                  data=data.to_json
-                rescue
-                  @logger.fatal "There was a problem converting to json: #{data}"
-                end
-              end
-            end
-            @logger.warn "Pay attention!!! This is a mock response:"
-            @start_time_net = Time.now if @start_time_net.nil?
-            manage_response(arg[:mock_response], data.to_s)
-            return @response
-          end
-          begin
-            if path.start_with?("http:") or path.start_with?("https:") then #server included on path problably because of a redirection to a different server
-              require 'uri'
-              uri = URI.parse(path)
-              ssl=false
-              ssl=true if path.include?("https:")
-  
-  
-              server="http://"
-              server="https://" if path.include?("https:")
-              if uri.port!=443 then
-                server+="#{uri.host}:#{uri.port}"
-              else
-                server+="#{uri.host}"
-              end
-  
-              http_redir=nil
-              NiceHttp.connections.each {|conn|
-                if conn.host == uri.host and conn.port==uri.port then
-                  http_redir=conn
-                  break
-                end
-              }
-  
-              if !http_redir.nil?
-                path, data, headers_t=manage_request(arg)
-                http_redir.cookies.merge!(@cookies)
-                http_redir.headers.merge!(headers_t)
-                resp=http_redir.get(path.gsub(server, "")) #todo: remove only the server at the begining in case in query is the server it will be replaced when it should not be
-                @response=http_redir.response
-              else
-                @logger.warn "It seems like the http connection cannot redirect to #{server} because there is no active connection for that server. You need to create previously one."
-              end
-  
-            else
-              @start_time_net = Time.now if @start_time_net.nil?
-              resp=@http.get(path, headers_t)
-              data=resp.body
-              manage_response(resp, data)
-            end
-          rescue Exception => stack
-            @logger.warn stack
-            @logger.warn "The connection seems to be closed in the host machine. Trying to reconnect"
-            @http.finish()
-            @http.start()
-            @start_time_net = Time.now if @start_time_net.nil?
-            resp=@http.get(path)
-            data=resp.body
-            manage_response(resp, data)
-          end
-          if @auto_redirect and @response[:code].to_i>=300 and @response[:code].to_i<400 and @response.include?(:location) then
-            if @num_redirects<=30 then
-              @num_redirects+=1
-              current_server="http"
-              current_server+="s" if @ssl==true
-              current_server+="://#{@host}"
-              location=@response[:location].gsub(current_server, "")
-              @logger.info "(#{@num_redirects}) Redirecting NiceHttp to #{location}"
-              get(location)
-            else
-              @logger.fatal "(#{@num_redirects}) Maximum number of redirections for a single request reached. Be sure everything is correct, it seems there is a non ending loop"
-              @num_redirects=0
-            end
-          else
-            @num_redirects=0
-          end
-          return @response
-        rescue Exception => stack
-          @logger.fatal stack
-          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. 
-      #   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.
-      #   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
-      # @example
-      #   resp = http.post( {
-      #                       path: "/api/users",
-      #                       data: {name: "morpheus", job: "leader"} 
-      #                      } )
-      #   pp resp.data.json
-      ######################################################
-      def post(*arguments)
-        begin
-          path, data, headers_t=manage_request(*arguments)
-          @start_time = Time.now if @start_time.nil?
-          if arguments.size>0 and arguments[0].kind_of?(Hash) then
-            arg=arguments[0]
-            if @use_mocks and arg.kind_of?(Hash) and arg.keys.include?(:mock_response) then
-              data=""
-              if arg[:mock_response].keys.include?(:data) then
-                data=arg[:mock_response][:data]
-                if data.kind_of?(Hash) #to json
-                  begin
-                    require 'json'
-                    data=data.to_json
-                  rescue
-                    @logger.fatal "There was a problem converting to json: #{data}"
-                  end
-                end
-              end
-              @logger.warn "Pay attention!!! This is a mock response:"
-              @start_time_net = Time.now if @start_time_net.nil?
-              manage_response(arg[:mock_response], data.to_s)
-              return @response
-            end
-          end
-  
-          begin
-            @start_time_net = Time.now if @start_time_net.nil?
-            if headers_t["Content-Type"] == "multipart/form-data" then
-              require 'net/http/post/multipart'
-              headers_t.each {|key, value|
-                arguments[0][:data].add_field(key, value) #add to Headers
-              }
-              resp=@http.request(arguments[0][:data])
-            else
-              resp=@http.post(path, data, headers_t)
-              data=resp.body
-            end
-          rescue Exception => stack
-            @logger.warn stack
-            @logger.warn "The connection seems to be closed in the host machine. Trying to reconnect"
-            @http.finish()
-            @http.start()
-            @start_time_net = Time.now if @start_time_net.nil?
-            resp, data=@http.post(path, data, headers_t)
-          end
-          manage_response(resp, data)
-          if @auto_redirect and @response[:code].to_i>=300 and @response[:code].to_i<400 and @response.include?(:location) then
-            if @num_redirects<=30 then
-              @num_redirects+=1
-              current_server="http"
-              current_server+="s" if @ssl==true
-              current_server+="://#{@host}"
-              location=@response[:location].gsub(current_server, "")
-              @logger.info "(#{@num_redirects}) Redirecting NiceHttp to #{location}"
-              get(location)
-            else
-              @logger.fatal "(#{@num_redirects}) Maximum number of redirections for a single request reached. Be sure everything is correct, it seems there is a non ending loop"
-              @num_redirects=0
-            end
-          else
-            @num_redirects=0
-          end
-          return @response
-        rescue Exception => stack
-          @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.
-      #   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.
-      #   In case of fatal error returns { fatal_error: "the error description", code: nil, message: nil, data: '' }
-      # @example
-      #   resp = @http.put(Requests::Customer.remove_phone)
-      ######################################################
-      def put(*arguments)
-        begin
-          path, data, headers_t=manage_request(*arguments)
-          @start_time = Time.now if @start_time.nil?
-          if arguments.size>0 and arguments[0].kind_of?(Hash) then
-            arg=arguments[0]
-            if @use_mocks and arg.kind_of?(Hash) and arg.keys.include?(:mock_response) then
-              data=""
-              if arg[:mock_response].keys.include?(:data) then
-                data=arg[:mock_response][:data]
-                if data.kind_of?(Hash) #to json
-                  begin
-                    require 'json'
-                    data=data.to_json
-                  rescue
-                    @logger.fatal "There was a problem converting to json: #{data}"
-                  end
-                end
-              end
-              @logger.warn "Pay attention!!! This is a mock response:"
-              @start_time_net = Time.now if @start_time_net.nil?
-              manage_response(arg[:mock_response], data.to_s)
-              return @response
-            end
-          end
-  
-          begin
-            @start_time_net = Time.now if @start_time_net.nil?
-            resp=@http.send_request("PUT", path, data, headers_t)
-            data=resp.body
-          rescue Exception => stack
-            @logger.warn stack
-            @logger.warn "The connection seems to be closed in the host machine. Trying to reconnect"
-            @http.finish()
-            @http.start()
-            @start_time_net = Time.now if @start_time_net.nil?
-            resp, data=@http.send_request("PUT", path, data, headers_t)
-          end
-          manage_response(resp, data)
-  
-          return @response
-        rescue Exception => stack
-          @logger.fatal stack
-          return {fatal_error: stack.to_s, code: nil, message: nil, data: ''}
-        end
-  
-      end
-
-  
-      ######################################################
-      # Patch data to path
-      # @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.
-      #   In case of fatal error returns { fatal_error: "the error description", code: nil, message: nil, data: '' }
-      # @example
-      #   resp = @http.patch(Requests::Customer.unrelease_account)
-      ######################################################
-      def patch(*arguments)
-        begin
-          path, data, headers_t=manage_request(*arguments)
-          @start_time = Time.now if @start_time.nil?
-          if arguments.size>0 and arguments[0].kind_of?(Hash) then
-            arg=arguments[0]
-            if @use_mocks and arg.kind_of?(Hash) and arg.keys.include?(:mock_response) then
-              data=""
-              if arg[:mock_response].keys.include?(:data) then
-                data=arg[:mock_response][:data]
-                if data.kind_of?(Hash) #to json
-                  begin
-                    require 'json'
-                    data=data.to_json
-                  rescue
-                    @logger.fatal "There was a problem converting to json: #{data}"
-                  end
-                end
-              end
-              @logger.warn "Pay attention!!! This is a mock response:"
-              @start_time_net = Time.now if @start_time_net.nil?
-              manage_response(arg[:mock_response], data.to_s)
-              return @response
-            end
-          end
-  
-          begin
-            @start_time_net = Time.now if @start_time_net.nil?
-            resp=@http.patch(path, data, headers_t)
-            data=resp.body
-          rescue Exception => stack
-            @logger.warn stack
-            @logger.warn "The connection seems to be closed in the host machine. Trying to reconnect"
-            @http.finish()
-            @http.start()
-            @start_time_net = Time.now if @start_time_net.nil?
-            resp, data=@http.patch(path, data, headers_t)
-          end
-          manage_response(resp, data)
-          if @auto_redirect and @response[:code].to_i>=300 and @response[:code].to_i<400 and @response.include?(:location) then
-            if @num_redirects<=30 then
-              @num_redirects+=1
-              current_server="http"
-              current_server+="s" if @ssl==true
-              current_server+="://#{@host}"
-              location=@response[:location].gsub(current_server, "")
-              @logger.info "(#{@num_redirects}) Redirecting NiceHttp to #{location}"
-              get(location)
-            else
-              @logger.fatal "(#{@num_redirects}) Maximum number of redirections for a single request reached. Be sure everything is correct, it seems there is a non ending loop"
-              @num_redirects=0
-            end
-          else
-            @num_redirects=0
-          end
-          return @response
-        rescue Exception => stack
-          @logger.fatal stack
-          return {fatal_error: stack.to_s, code: nil, message: nil, data: ''}
-        end
-  
-      end
-
-      ######################################################
-      # Delete an existing resource
-      # @param arg [Hash] containing at least key :path 
-      # @param arg [String] the path 
-      #
-      # @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.
-      #   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
-      ######################################################
-      def delete(argument)
-        begin
-          if argument.kind_of?(String) then
-            argument={:path => argument}
-          end
-          path, data, headers_t=manage_request(argument)
-          @start_time = Time.now if @start_time.nil?
-          if argument.kind_of?(Hash) then
-            arg=argument
-            if @use_mocks and arg.kind_of?(Hash) and arg.keys.include?(:mock_response) then
-              data=""
-              if arg[:mock_response].keys.include?(:data) then
-                data=arg[:mock_response][:data]
-                if data.kind_of?(Hash) #to json
-                  begin
-                    require 'json'
-                    data=data.to_json
-                  rescue
-                    @logger.fatal "There was a problem converting to json: #{data}"
-                  end
-                end
-              end
-              @logger.warn "Pay attention!!! This is a mock response:"
-              @start_time_net = Time.now if @start_time_net.nil?
-              manage_response(arg[:mock_response], data.to_s)
-              return @response
-            end
-          end
-  
-          begin
-            @start_time_net = Time.now if @start_time_net.nil?
-            resp=@http.delete(path, headers_t)
-            data=resp.body
-          rescue Exception => stack
-            @logger.warn stack
-            @logger.warn "The connection seems to be closed in the host machine. Trying to reconnect"
-            @http.finish()
-            @http.start()
-            @start_time_net = Time.now if @start_time_net.nil?
-            resp, data=@http.delete(path)
-          end
-          manage_response(resp, data)
-  
-          return @response
-        rescue Exception => stack
-          @logger.fatal stack
-          return {fatal_error: stack.to_s, code: nil, message: nil, data: ''}
-        end
-  
-      end
-
-      ######################################################
-      # Implementation of the http HEAD method.
-      # Asks for the response identical to the one that would correspond to a GET request, but without the response body. 
-      # This is useful for retrieving meta-information written in response headers, without having to transport the entire content.
-      # @param arg [Hash] containing at least key :path 
-      # @param arg [String] the path 
-      #
-      # @return [Hash] response
-      #   Including at least the symbol keys:
-      #     :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.
-      #   In case of fatal error returns { fatal_error: "the error description", code: nil, message: nil }
-      ######################################################
-      def head(argument)
-        begin
-          if argument.kind_of?(String) then
-            argument={:path => argument}
-          end
-          path, data, headers_t=manage_request(argument)
-          @start_time = Time.now if @start_time.nil?
-          if argument.kind_of?(Hash) then
-            arg=argument
-            if @use_mocks and arg.kind_of?(Hash) and arg.keys.include?(:mock_response) then
-              data=""
-              if arg[:mock_response].keys.include?(:data) then
-                data=arg[:mock_response][:data]
-                if data.kind_of?(Hash) #to json
-                  begin
-                    require 'json'
-                    data=data.to_json
-                  rescue
-                    @logger.fatal "There was a problem converting to json: #{data}"
-                  end
-                end
-              end
-              @logger.warn "Pay attention!!! This is a mock response:"
-              @start_time_net = Time.now if @start_time_net.nil?
-              manage_response(arg[:mock_response], data.to_s)
-              return @response
-            end
-          end
-  
-          begin
-            @start_time_net = Time.now if @start_time_net.nil?
-            resp=@http.head(path, headers_t)
-            data=resp.body
-          rescue Exception => stack
-            @logger.warn stack
-            @logger.warn "The connection seems to be closed in the host machine. Trying to reconnect"
-            @http.finish()
-            @http.start()
-            @start_time_net = Time.now if @start_time_net.nil?
-            resp, data=@http.head(path)
-          end
-          manage_response(resp, data)
-          return @response
-        rescue Exception => stack
-          @logger.fatal stack
-          return {fatal_error: stack.to_s, code: nil, message: nil}
-        end
-      end
-
-
-      ######################################################
-      # Close HTTP connection
-      ######################################################
-      def close
-        begin
-          pos=0
-          found=false
-          NiceHttp.connections.each {|conn|
-            if conn.object_id == self.object_id then
-              found=true
-              break
-            end
-            pos+=1
-          }
-          if found
-            NiceHttp.connections.delete_at(pos)
-          end
-  
-          unless @closed
-            if !@http.nil? then
-              @http.finish()
-              @http=nil
-                @logger.info "the HTTP connection was closed: #{@message_server}"
-            else
-              @http=nil
-              @logger.fatal "It was not possible to close the HTTP connection: #{@message_server}"
-            end
-            @closed=true
-          else
-            @logger.warn "It was not possible to close the HTTP connection, already closed: #{@message_server}"
-          end
-        rescue Exception => stack
-          @logger.fatal stack
-        end
-        NiceHttp.active-=1
-      end
-
-
-      ######################################################
-      # private method to manage Request
-      #   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
-      ######################################################
-      def manage_request(*arguments)
-        require 'json'
-        begin
-          content_type_included=false
-          path=""
-          data=""
-  
-          @response=Hash.new()
-          headers_t=@headers.dup()
-          cookies_to_set_str=""
-          if arguments.size==3 then
-            path=arguments[0]
-          elsif arguments.size==1 and arguments[0].kind_of?(Hash) then
-            path=arguments[0][:path]
-          elsif arguments.size==1 and arguments[0].kind_of?(String) then
-            path=arguments[0].to_s()
-          end
-          @cookies.each {|cookie_path, cookies_hash|
-            cookie_path="" if cookie_path=="/"
-            path_to_check=path
-            if path=="/" or path[-1]!="/" then
-              path_to_check+="/"
-            end
-            if path_to_check.scan(/^#{cookie_path}\//).size>0 then
-              cookies_hash.each {|key, value|
-                cookies_to_set_str+="#{key}=#{value}; "
-              }
-            end
-          }
-          headers_t["Cookie"]=cookies_to_set_str
-  
-          method_s=caller[0].to_s().scan(/:in `(.*)'/).join
-  
-          if arguments.size==3 then
-            data=arguments[1]
-            if arguments[2].kind_of?(Hash) then
-              headers_t.merge!(arguments[2])
-            end
-          elsif arguments.size==1 and arguments[0].kind_of?(Hash) then
-            if arguments[0][:data].nil? then
-              if arguments[0].keys.include?(:data) then
-                data=""
-              elsif arguments[0].keys.include?(:data_examples) and 
-                arguments[0][:data_examples].kind_of?(Array) then
-                data=arguments[0][:data_examples][0] #the first example by default
-              else
-                data=""
-              end
-  
-            else
-              data=arguments[0][:data]
-            end
-            if arguments[0].include?(:headers) then
-              headers_t.merge!(arguments[0][:headers])
-            end
-  
-            if headers_t["Content-Type"].to_s()=="" and headers_t["content-type"].to_s()=="" and 
-              headers_t[:"content-type"].to_s()=="" and headers_t[:"Content-Type"].to_s()=="" then
-              content_type_included=false
-            elsif headers_t["content-type"].to_s()!="" then
-              content_type_included=true
-              headers_t["Content-Type"]=headers_t["content-type"]
-            elsif headers_t[:"content-type"].to_s()!="" then
-              content_type_included=true
-              headers_t["Content-Type"]=headers_t[:"content-type"]
-              headers_t.delete(:"content-type")
-            elsif headers_t[:"Content-Type"].to_s()!="" then
-              content_type_included=true
-              headers_t["Content-Type"]=headers_t[:"Content-Type"]
-              headers_t.delete(:"Content-Type")
-            elsif headers_t["Content-Type"].to_s()!="" then
-              content_type_included=true
-            end
-
-            if !content_type_included and data.kind_of?(Hash)
-              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_for)
-              arguments[0][:values_for] = 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_for) then
-                arguments[0][:values_for].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_for) then
-                  arguments[0][:values_for].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,
-                    data.gsub!(/(( *|^)"?#{key.to_s()}"? *: *[^"])([^"].*)([^"] * *$)/, '\1' + value+ '\4') # "key":456 or key:456
-                  }
-                end
-              elsif data.kind_of?(Hash) then
-                data_n=Hash.new()
-                data.each {|key, value|
-                  data_n[key.to_s()]=value
-                }
-                if arguments[0].include?(:values_for) then
-                  #req[:values_for][:loginName] or req[:values_for]["loginName"]
-                  new_values_hash=Hash.new()
-                  arguments[0][:values_for].each {|kv, vv|
-                    if data_n.keys.include?(kv.to_s()) then
-                      new_values_hash[kv.to_s()]=vv
-                    end
-                  }
-                  data_n.merge!(new_values_hash)
-                end
-                data=data_n.to_json()
-              elsif data.kind_of?(Array) then
-                data_arr=Array.new()
-                data.each_with_index {|row, indx|
-                  unless row.kind_of?(Hash) then
-                    @logger.fatal("Wrong format on request application/json, be sure is a Hash, Array of Hashes or JSON string")
-                    return :error, :error, :error
-                  end
-                  data_n=Hash.new()
-                  row.each {|key, value|
-                    data_n[key.to_s()]=value
-                  }
-                  if arguments[0].include?(:values_for) then
-                    #req[:values_for][:loginName] or req[:values_for]["loginName"]
-                    new_values_hash=Hash.new()
-                    if arguments[0][:values_for].kind_of?(Hash) then #values[:mykey][3]
-                      arguments[0][:values_for].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_for].kind_of?(Array) then #values[5][:mykey]
-                      if !arguments[0][:values_for][indx].nil? then
-                        arguments[0][:values_for][indx].each {|kv, vv|
-                          if data_n.keys.include?(kv.to_s()) then
-                            new_values_hash[kv.to_s()]=vv
-                          end
-                        }
-                      end
-                    else
-                      @logger.fatal("Wrong format on request application/json when supplying values, the data is an array of Hashes but the values supplied are not")
-                      return :error, :error, :error
-                    end
-                    data_n.merge!(new_values_hash)
-                  end
-                  data_arr.push(data_n)
-                }
-                data=data_arr.to_json()
-              else
-                @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_for) then
-              if arguments[0][:values_for].kind_of?(Hash) and arguments[0][:values_for].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_for key given without a valid content-type or data for request. No values modified on the request")
-                end
-              end
-            end
-          elsif arguments.size==1 and arguments[0].kind_of?(String) then
-            #path=arguments[0].to_s()
-            data=""
-          else
-            @logger.fatal("Invalid number of arguments or wrong arguments in #{method_s}")
-            return :error, :error, :error
-          end
-          if headers_t.keys.include?("Content-Type") and !headers_t["Content-Type"]["multipart/form-data"].nil? and headers_t["Content-Type"]!=["multipart/form-data"] then #only for the case raw multipart request
-            encoding="UTF-8"
-            data_s=""
-          else
-            encoding=data.to_s().scan(/encoding='(.*)'/i).join
-            if encoding.to_s()=="" then
-              encoding=data.to_s().scan(/charset='(.*)'/i).join
-            end
-            if encoding.to_s()=="" and headers_t.include?("Content-Type") then
-              encoding=headers_t["Content-Type"].scan(/charset='?(.*)'?/i).join
-              if encoding.to_s()=="" then
-                encoding=headers_t["Content-Type"].scan(/encoding='?(.*)'?/i).join
-              end
-            end
-  
-            begin
-              data_s=JSON.pretty_generate(JSON.parse(data))
-            rescue
-              data_s=data
-            end
-            data_s=data_s.to_s().gsub("<", "&lt;")
-          end
-          if headers_t.keys.include?("Accept-Encoding")
-            headers_t["Accept-Encoding"].gsub!("gzip","")#removed so the response is in plain text
-          end
-  
-          headers_ts=""
-          headers_t.each {|key, val| headers_ts+=key.to_s + ":" + val.to_s() + ", "}
-          message="#{method_s} REQUEST: \npath= " + path.to_s() + "\n"
-          message+="headers= " + headers_ts.to_s() + "\n"
-          message+="data= " + data_s.to_s() + "\n"
-          message=@message_server+"\n"+message
-          if path.to_s().scan(/^https?:\/\//).size>0 and path.to_s().scan(/^https?:\/\/#{@host}/).size==0 then
-            # the path is for another server than the current
-          else
-            NiceHttp.last_request=message
-            @logger.info(message)
-          end
-  
-          if data.to_s()!="" and encoding.to_s().upcase!="UTF-8" and encoding!="" then
-            data=data.to_s().encode(encoding, "UTF-8")
-          end
-          return path, data, headers_t
-        rescue Exception => stack
-          @logger.fatal(stack)
-          @logger.fatal("manage_request Error on method #{method_s} . path:#{path.to_s()}. data:#{data.to_s()}. headers:#{headers_t.to_s()}")
-          return :error
-        end
-      end
-
-      ######################################################
-      # private method to manage Response
-      #   input:
-      #     resp
-      #     data
-      #   output:
-      #     @response updated
-      ######################################################
-      def manage_response(resp, data)
-        require 'json'
-        begin
-          if @start_time.kind_of?(Time)
-            @response[:time_elapsed_total]=Time.now-@start_time
-            @start_time = nil
-          else
-            @response[:time_elapsed_total]=nil
-          end
-          if @start_time_net.kind_of?(Time)
-            @response[:time_elapsed]=Time.now-@start_time_net
-            @start_time_net = nil
-          else
-            @response[:time_elapsed]=nil
-          end
-          begin
-            # this is to be able to access all keys as symbols
-            new_resp=Hash.new()
-            resp.each {|key, value|
-              if key.kind_of?(String) then
-                new_resp[key.to_sym]=value
-              end
-            }
-            new_resp.each {|key, value|
-              resp[key]=value
-            }
-          rescue
-          end
-          #for mock_responses to be able to add outside of the header like content-type for example
-          if resp.kind_of?(Hash) and !resp.has_key?(:header) then
-            resp[:header]={}
-          end
-          if resp.kind_of?(Hash)
-            resp.each {|k, v|
-              if k!=:code and k!=:message and k!=:data and k!=:'set-cookie' and k!=:header
-                resp[:header][k]=v
-              end
-            }
-            resp[:header].each {|k, v|
-              resp.delete(k) if resp.has_key?(k)
-            }
-          end
-  
-          method_s=caller[0].to_s().scan(/:in `(.*)'/).join
-          if resp.header.kind_of?(Hash) and (resp.header["content-type"].to_s()=="application/x-deflate" or resp.header[:"content-type"].to_s()=="application/x-deflate") then
-            data=Zlib::Inflate.inflate(data)
-          end
-          encoding_response=""
-          if resp.header.kind_of?(Hash) and (resp.header["content-type"].to_s()!="" or resp.header[:"content-type"].to_s()!="") then
-            encoding_response=resp.header["content-type"].scan(/;charset=(.*)/i).join if resp.header.has_key?("content-type")
-            encoding_response=resp.header[:"content-type"].scan(/;charset=(.*)/i).join if resp.header.has_key?(:"content-type")
-          end
-          if encoding_response.to_s()=="" then
-            encoding_response="UTF-8"
-          end
-  
-          if encoding_response.to_s()!="" and encoding_response.to_s().upcase!="UTF-8" then
-            data.encode!("UTF-8", encoding_response.to_s())
-          end
-          if encoding_response!="" and encoding_response.to_s().upcase!="UTF-8" then
-            @response[:message]=resp.message.to_s().encode("UTF-8", encoding_response.to_s())
-            #todo: response data in here for example is convert into string, verify if that is correct or needs to maintain the original data type (hash, array...)
-            resp.each {|key, val| @response[key]=val.to_s().encode("UTF-8", encoding_response.to_s())}
-          else
-            @response[:message]=resp.message
-            resp.each {|key, val| @response[key]=val}
-          end
-          if !defined?(Net::HTTP::Post::Multipart) or (defined?(Net::HTTP::Post::Multipart) and !data.kind_of?(Net::HTTP::Post::Multipart))
-            @response[:data]=data
-          else
-            @response[:data]=""
-          end
-  
-          @response[:code]=resp.code
-  
-          unless @response.nil? then
-            message="\nRESPONSE: \n" + @response[:code].to_s()+ ":" + @response[:message].to_s()
-            if @debug then
-              NiceHttp.last_response=message
-              @response.each {|key, value|
-                if value.to_s()!="" then
-                  value_orig=value
-                  if key.kind_of?(Symbol) then
-                    if key==:code or key==:data or key==:header or key==:message then
-                      if key==:data then
-                        begin
-                          JSON.parse(value_orig)
-                          data_s=JSON.pretty_generate(JSON.parse(value_orig))
-                        rescue
-                          data_s=value_orig
-                        end
-                        NiceHttp.last_response+="\nresponse." + key.to_s() + " = '" + data_s.gsub("<", "&lt;") + "'\n"
-                        if value_orig != value then
-                          message+="\nresponse." + key.to_s() + " = '" + value.gsub("<", "&lt;") + "'\n"
-                        else
-                          message+="\nresponse." + key.to_s() + " = '" + data_s.gsub("<", "&lt;") + "'\n"
-                        end
-                      else
-                        NiceHttp.last_response+="\nresponse." + key.to_s() + " = '" + value.to_s().gsub("<", "&lt;") + "'"
-                        message+="\nresponse." + key.to_s() + " = '" + value.to_s().gsub("<", "&lt;") + "'"
-                      end
-                    else
-                      NiceHttp.last_response+="\nresponse[:" + key.to_s() + "] = '" + value.to_s().gsub("<", "&lt;") + "'"
-                      message+="\nresponse[:" + key.to_s() + "] = '" + value.to_s().gsub("<", "&lt;") + "'"
-                    end
-                  elsif !@response.include?(key.to_sym)
-                    NiceHttp.last_response+="\nresponse['" + key.to_s() + "'] = '" + value.to_s().gsub("<", "&lt;") + "'"
-                    message+="\nresponse['" + key.to_s() + "'] = '" + value.to_s().gsub("<", "&lt;") + "'"
-                  end
-                end
-              }
-  
-            end
-            @logger.info message
-            if @response.kind_of?(Hash) then
-              if @response.keys.include?(:requestid) then
-                @headers["requestId"]=@response[:requestid]
-                NiceHttp.request_id=@response[:requestid]
-                @logger.info "requestId was found on the response header and it has been added to the headers for the next request"
-              end
-            end
-          end
-  
-          if resp[:'set-cookie'].to_s()!="" then
-            if resp.kind_of?(Hash) then #mock_response
-              cookies_to_set=resp[:'set-cookie'].to_s().split(", ")
-            else #Net::Http
-              cookies_to_set=resp.get_fields('set-cookie')
-            end
-            cookies_to_set.each {|cookie|
-              cookie_pair=cookie.split('; ')[0].split("=")
-              cookie_path=cookie.scan(/; path=([^;]+)/i).join
-              @cookies[cookie_path]=Hash.new() unless @cookies.keys.include?(cookie_path)
-              @cookies[cookie_path][cookie_pair[0]]=cookie_pair[1]
-            }
-  
-              @logger.info "set-cookie added to Cookie header as required"
-  
-              if @headers.has_key?("X-CSRFToken") then
-                csrftoken=resp[:"set-cookie"].to_s().scan(/csrftoken=([\da-z]+);/).join
-                if csrftoken.to_s()!="" then
-                  @headers["X-CSRFToken"]=csrftoken
-                  @logger.info "X-CSRFToken exists on headers and has been overwritten"
-                end
-              else
-                csrftoken=resp[:"set-cookie"].to_s().scan(/csrftoken=([\da-z]+);/).join
-                if csrftoken.to_s()!="" then
-                  @headers["X-CSRFToken"]=csrftoken
-                  @logger.info "X-CSRFToken added to header as required"
-                end
-  
-              end
-          end
-  
-        rescue Exception => stack
-          @logger.fatal stack
-          @logger.fatal "manage_response Error on method #{method_s} "
-        end
-      end
-      
-      private :manage_request, :manage_response
-end
-
+require "logger"
+require "nice_hash"
+require_relative "nice_http/utils"
+
+######################################################
+# 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
+  Error = Class.new StandardError
+
+  InfoMissing = Class.new Error do
+    attr_reader :attribute
+
+    def initialize(attribute)
+      @attribute = attribute
+      message = "It was not possible to create the http connection!!!\n"
+      message += "Wrong #{attribute}, remember to supply http:// or https:// in case you specify an url to create the http connection, for example:\n"
+      message += "http = NiceHttp.new('http://example.com')"
+      super message
+    end
+  end
+
+  class << self
+    attr_accessor :host, :port, :ssl, :headers, :debug, :log, :proxy_host, :proxy_port,
+                  :last_request, :last_response, :request_id, :use_mocks, :connections,
+                  :active, :auto_redirect
+  end
+
+  ######################################################
+  # to reset to the original defaults
+  ######################################################
+  def self.reset!
+    @host = nil
+    @port = 80
+    @ssl = false
+    @headers = {}
+    @debug = false
+    @log = :fix_file
+    @proxy_host = nil
+    @proxy_port = nil
+    @last_request = nil
+    @last_response = nil
+    @request_id = ""
+    @use_mocks = false
+    @connections = []
+    @active = 0
+    @auto_redirect = true
+  end
+  reset!
+
+  ######################################################
+  # If inheriting from NiceHttp class
+  ######################################################
+  def self.inherited(subclass)
+    subclass.reset!
+  end
+
+  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)
+    @ssl = par[:ssl] if par.key?(:ssl)
+    @headers = par[:headers].dup if par.key?(:headers)
+    @debug = par[:debug] if par.key?(:debug)
+    @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)
+    @use_mocks = par[:use_mocks] if par.key?(:use_mocks)
+    @auto_redirect = par[:auto_redirect] if par.key?(:auto_redirect)
+  end
+
+  ######################################################
+  # Creates a new http connection.
+  #
+  # @param args [] If no parameter supplied, by default will access how is setup on defaults
+  # @example
+  #   http = NiceHttp.new()
+  # @param args [String]. The url to create the connection.
+  # @example
+  #   http = NiceHttp.new("https://www.example.com")
+  # @example
+  #   http = NiceHttp.new("example.com:8999")
+  # @example
+  #   http = NiceHttp.new("localhost:8322")
+  # @param args [Hash] containing these possible keys:
+  #
+  #             host -- example.com. (default blank screen)
+  #
+  #             port -- port for the connection. 80 (default)
+  #
+  #             ssl -- true, false (default)
+  #
+  #             headers -- hash with the headers
+  #
+  #             debug -- true, false (default)
+  #
+  #             log -- :no, :screen, :file, :fix_file (default).
+  #
+  #                 A string with a path can be supplied.
+  #
+  #                 If :fix_file: nice_http.log
+  #
+  #                 In case :file it will be generated a log file with name: nice_http_YY-mm-dd-HHMMSS.log
+  #
+  #             proxy_host
+  #
+  #             proxy_port
+  # @example
+  #   http2 = NiceHttp.new( host: "reqres.in", port: 443, ssl: true )
+  # @example
+  #   my_server = {host: "example.com",
+  #                port: 80,
+  #                headers: {"api-key": "zdDDdjkck"}
+  #               }
+  #   http3 = NiceHttp.new my_server
+  ######################################################
+  def initialize(args = {})
+    require "net/http"
+    require "net/https"
+    @host = self.class.host
+    @port = self.class.port
+    @ssl = self.class.ssl
+    @headers = self.class.headers.dup
+    @debug = self.class.debug
+    @log = self.class.log
+    @proxy_host = self.class.proxy_host
+    @proxy_port = self.class.proxy_port
+    @use_mocks = self.class.use_mocks
+    @auto_redirect = false #set it up at the end of initialize
+    auto_redirect = self.class.auto_redirect
+    @num_redirects = 0
+
+    #todo: set only the cookies for the current domain
+    #key: path, value: hash with key is the name of the cookie and value the value
+    # we set the default value for non existing keys to empty Hash {} so in case of merge there is no problem
+    @cookies = Hash.new { |h, k| h[k] = {} }
+
+    if args.is_a?(String)
+      uri = URI.parse(args)
+      @host = uri.host unless uri.host.nil?
+      @port = uri.port unless uri.port.nil?
+      @ssl = true if !uri.scheme.nil? && (uri.scheme == "https")
+    elsif args.is_a?(Hash) && !args.keys.empty?
+      @host = args[:host] if args.keys.include?(:host)
+      @port = args[:port] if args.keys.include?(:port)
+      @ssl = args[:ssl] if args.keys.include?(:ssl)
+      @headers = args[:headers].dup if args.keys.include?(:headers)
+      @debug = args[:debug] if args.keys.include?(:debug)
+      @log = args[:log] if args.keys.include?(:log)
+      @proxy_host = args[:proxy_host] if args.keys.include?(:proxy_host)
+      @proxy_port = args[:proxy_port] if args.keys.include?(:proxy_port)
+      @use_mocks = args[:use_mocks] if args.keys.include?(:use_mocks)
+      auto_redirect = args[:auto_redirect] if args.keys.include?(:auto_redirect)
+    end
+
+    begin
+      if @log.kind_of?(String)
+        @logger = Logger.new File.new(@log, "w")
+      elsif @log == :fix_file
+        @logger = Logger.new File.new("nice_http.log", "w")
+      elsif @log == :file
+        @logger = Logger.new File.new("nice_http_#{Time.now.strftime("%Y-%m-%d-%H%M%S")}.log", "w")
+      elsif @log == :screen
+        @logger = Logger.new STDOUT
+      elsif @log == :no
+        @logger = Logger.new nil
+      else 
+        raise InfoMissing, :log
+      end
+      @logger.level = Logger::INFO
+    rescue Exception => stack
+      raise InfoMissing, :log
+      @logger = Logger.new nil
+    end
+
+
+    if @host.to_s != "" and (@host.include?("http:") or @host.include?("https:"))
+      uri = URI.parse(@host)
+      @host = uri.host unless uri.host.nil?
+      @port = uri.port unless uri.port.nil?
+      @ssl = true if !uri.scheme.nil? && (uri.scheme == "https")
+    end
+
+    raise InfoMissing, :port if @port.to_s == ""
+    raise InfoMissing, :host if @host.to_s == ""
+    raise InfoMissing, :ssl unless @ssl.is_a?(TrueClass) or @ssl.is_a?(FalseClass)
+    raise InfoMissing, :debug unless @debug.is_a?(TrueClass) or @debug.is_a?(FalseClass)
+    raise InfoMissing, :auto_redirect unless auto_redirect.is_a?(TrueClass) or auto_redirect.is_a?(FalseClass)
+    raise InfoMissing, :use_mocks unless @use_mocks.is_a?(TrueClass) or @use_mocks.is_a?(FalseClass)
+    raise InfoMissing, :headers unless @headers.is_a?(Hash)
+    
+    begin
+      if !@proxy_host.nil? && !@proxy_port.nil?
+        @http = Net::HTTP::Proxy(@proxy_host, @proxy_port).new(@host, @port)
+        @http.use_ssl = @ssl
+        @http.set_debug_output $stderr if @debug
+        @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        @http.start
+      else
+        @http = Net::HTTP.new(@host, @port)
+        @http.use_ssl = @ssl
+        @http.set_debug_output $stderr if @debug
+        @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        @http.start
+      end
+
+      @message_server = "(#{self.object_id}):"
+
+      log_message = "(#{self.object_id}): Http connection created. host:#{@host},  port:#{@port},  ssl:#{@ssl}, mode:#{@mode}, proxy_host: #{@proxy_host.to_s()}, proxy_port: #{@proxy_port.to_s()} "
+
+      @logger.info(log_message)
+      @message_server += " Http connection: "
+      if @ssl
+        @message_server += "https://"
+      else
+        @message_server += "http://"
+      end
+      @message_server += "#{@host}:#{@port}"
+      if @proxy_host.to_s != ""
+        @message_server += " proxy:#{@proxy_host}:#{@proxy_port}"
+      end
+      @auto_redirect = auto_redirect
+
+      self.class.active += 1
+      self.class.connections.push(self)
+    rescue Exception => stack
+      puts stack
+      @logger.fatal stack
+    end
+  end
+
+  ######################################################
+  # Get data from path
+  #
+  # @param arg [Hash] containing at least key :path
+  # @param arg [String] the path
+  #
+  # @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.
+  #   In case of fatal error returns { fatal_error: "the error description", code: nil, message: nil, data: '' }
+  #
+  # @example
+  #   resp = @http.get(Requests::Customer.get_profile)
+  #   assert resp.code == 200
+  # @example
+  #   resp = @http.get("/customers/1223")
+  #   assert resp.message == "OK"
+  ######################################################
+  def get(arg)
+    begin
+      path, data, headers_t = manage_request(arg)
+      
+      @start_time = Time.now if @start_time.nil?
+      if @use_mocks and arg.kind_of?(Hash) and arg.keys.include?(:mock_response)
+        data = ""
+        if arg[:mock_response].keys.include?(:data)
+          data = arg[:mock_response][:data]
+          if data.kind_of?(Hash) #to json
+            begin
+              require "json"
+              data = data.to_json
+            rescue
+              @logger.fatal "There was a problem converting to json: #{data}"
+            end
+          end
+        end
+        @logger.warn "Pay attention!!! This is a mock response:"
+        @start_time_net = Time.now if @start_time_net.nil?
+        manage_response(arg[:mock_response], data.to_s)
+        return @response
+      end
+      begin
+        if path.start_with?("http:") or path.start_with?("https:") #server included on path problably because of a redirection to a different server
+          require "uri"
+          uri = URI.parse(path)
+          ssl = false
+          ssl = true if path.include?("https:")
+
+          server = "http://"
+          server = "https://" if path.include?("https:")
+          if uri.port != 443
+            server += "#{uri.host}:#{uri.port}"
+          else
+            server += "#{uri.host}"
+          end
+
+          http_redir = nil
+          self.class.connections.each { |conn|
+            if conn.host == uri.host and conn.port == uri.port
+              http_redir = conn
+              break
+            end
+          }
+
+          if !http_redir.nil?
+            path, data, headers_t = manage_request(arg)
+            http_redir.cookies.merge!(@cookies)
+            http_redir.headers.merge!(headers_t)
+            resp = http_redir.get(path.gsub(server, "")) #todo: remove only the server at the begining in case in query is the server it will be replaced when it should not be
+            @response = http_redir.response
+          else
+            @logger.warn "It seems like the http connection cannot redirect to #{server} because there is no active connection for that server. You need to create previously one."
+          end
+        else
+          @start_time_net = Time.now if @start_time_net.nil?
+          resp = @http.get(path, headers_t)
+          data = resp.body
+          manage_response(resp, data)
+        end
+      rescue Exception => stack
+        @logger.warn stack
+        @logger.warn "The connection seems to be closed in the host machine. Trying to reconnect"
+        @http.finish()
+        @http.start()
+        @start_time_net = Time.now if @start_time_net.nil?
+        resp = @http.get(path)
+        data = resp.body
+        manage_response(resp, data)
+      end
+
+      if @auto_redirect and @response[:code].to_i >= 300 and @response[:code].to_i < 400 and @response.include?(:location)
+        if @num_redirects <= 30
+          @num_redirects += 1
+          current_server = "http"
+          current_server += "s" if @ssl == true
+          current_server += "://#{@host}"
+          location = @response[:location].gsub(current_server, "")
+          @logger.info "(#{@num_redirects}) Redirecting NiceHttp to #{location}"
+          get(location)
+        else
+          @logger.fatal "(#{@num_redirects}) Maximum number of redirections for a single request reached. Be sure everything is correct, it seems there is a non ending loop"
+          @num_redirects = 0
+        end
+      else
+        @num_redirects = 0
+      end
+      return @response
+    rescue Exception => stack
+      @logger.fatal stack
+      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.
+  #   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.
+  #   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
+  # @example
+  #   resp = http.post( {
+  #                       path: "/api/users",
+  #                       data: {name: "morpheus", job: "leader"}
+  #                      } )
+  #   pp resp.data.json
+  ######################################################
+  def post(*arguments)
+    begin
+      path, data, headers_t = manage_request(*arguments)
+      @start_time = Time.now if @start_time.nil?
+      if arguments.size > 0 and arguments[0].kind_of?(Hash)
+        arg = arguments[0]
+        if @use_mocks and arg.kind_of?(Hash) and arg.keys.include?(:mock_response)
+          data = ""
+          if arg[:mock_response].keys.include?(:data)
+            data = arg[:mock_response][:data]
+            if data.kind_of?(Hash) #to json
+              begin
+                require "json"
+                data = data.to_json
+              rescue
+                @logger.fatal "There was a problem converting to json: #{data}"
+              end
+            end
+          end
+          @logger.warn "Pay attention!!! This is a mock response:"
+          @start_time_net = Time.now if @start_time_net.nil?
+          manage_response(arg[:mock_response], data.to_s)
+          return @response
+        end
+      end
+
+      begin
+        @start_time_net = Time.now if @start_time_net.nil?
+        if headers_t["Content-Type"] == "multipart/form-data"
+          require "net/http/post/multipart"
+          headers_t.each { |key, value|
+            arguments[0][:data].add_field(key, value) #add to Headers
+          }
+          resp = @http.request(arguments[0][:data])
+        else
+          resp = @http.post(path, data, headers_t)
+          data = resp.body
+        end
+      rescue Exception => stack
+        @logger.warn stack
+        @logger.warn "The connection seems to be closed in the host machine. Trying to reconnect"
+        @http.finish()
+        @http.start()
+        @start_time_net = Time.now if @start_time_net.nil?
+        resp, data = @http.post(path, data, headers_t)
+      end
+      manage_response(resp, data)
+      if @auto_redirect and @response[:code].to_i >= 300 and @response[:code].to_i < 400 and @response.include?(:location)
+        if @num_redirects <= 30
+          @num_redirects += 1
+          current_server = "http"
+          current_server += "s" if @ssl == true
+          current_server += "://#{@host}"
+          location = @response[:location].gsub(current_server, "")
+          @logger.info "(#{@num_redirects}) Redirecting NiceHttp to #{location}"
+          get(location)
+        else
+          @logger.fatal "(#{@num_redirects}) Maximum number of redirections for a single request reached. Be sure everything is correct, it seems there is a non ending loop"
+          @num_redirects = 0
+        end
+      else
+        @num_redirects = 0
+      end
+      return @response
+    rescue Exception => stack
+      @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.
+  #   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.
+  #   In case of fatal error returns { fatal_error: "the error description", code: nil, message: nil, data: '' }
+  # @example
+  #   resp = @http.put(Requests::Customer.remove_phone)
+  ######################################################
+  def put(*arguments)
+    begin
+      path, data, headers_t = manage_request(*arguments)
+      @start_time = Time.now if @start_time.nil?
+      if arguments.size > 0 and arguments[0].kind_of?(Hash)
+        arg = arguments[0]
+        if @use_mocks and arg.kind_of?(Hash) and arg.keys.include?(:mock_response)
+          data = ""
+          if arg[:mock_response].keys.include?(:data)
+            data = arg[:mock_response][:data]
+            if data.kind_of?(Hash) #to json
+              begin
+                require "json"
+                data = data.to_json
+              rescue
+                @logger.fatal "There was a problem converting to json: #{data}"
+              end
+            end
+          end
+          @logger.warn "Pay attention!!! This is a mock response:"
+          @start_time_net = Time.now if @start_time_net.nil?
+          manage_response(arg[:mock_response], data.to_s)
+          return @response
+        end
+      end
+
+      begin
+        @start_time_net = Time.now if @start_time_net.nil?
+        resp = @http.send_request("PUT", path, data, headers_t)
+        data = resp.body
+      rescue Exception => stack
+        @logger.warn stack
+        @logger.warn "The connection seems to be closed in the host machine. Trying to reconnect"
+        @http.finish()
+        @http.start()
+        @start_time_net = Time.now if @start_time_net.nil?
+        resp, data = @http.send_request("PUT", path, data, headers_t)
+      end
+      manage_response(resp, data)
+
+      return @response
+    rescue Exception => stack
+      @logger.fatal stack
+      return {fatal_error: stack.to_s, code: nil, message: nil, data: ""}
+    end
+  end
+
+  ######################################################
+  # Patch data to path
+  # @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.
+  #   In case of fatal error returns { fatal_error: "the error description", code: nil, message: nil, data: '' }
+  # @example
+  #   resp = @http.patch(Requests::Customer.unrelease_account)
+  ######################################################
+  def patch(*arguments)
+    begin
+      path, data, headers_t = manage_request(*arguments)
+      @start_time = Time.now if @start_time.nil?
+      if arguments.size > 0 and arguments[0].kind_of?(Hash)
+        arg = arguments[0]
+        if @use_mocks and arg.kind_of?(Hash) and arg.keys.include?(:mock_response)
+          data = ""
+          if arg[:mock_response].keys.include?(:data)
+            data = arg[:mock_response][:data]
+            if data.kind_of?(Hash) #to json
+              begin
+                require "json"
+                data = data.to_json
+              rescue
+                @logger.fatal "There was a problem converting to json: #{data}"
+              end
+            end
+          end
+          @logger.warn "Pay attention!!! This is a mock response:"
+          @start_time_net = Time.now if @start_time_net.nil?
+          manage_response(arg[:mock_response], data.to_s)
+          return @response
+        end
+      end
+
+      begin
+        @start_time_net = Time.now if @start_time_net.nil?
+        resp = @http.patch(path, data, headers_t)
+        data = resp.body
+      rescue Exception => stack
+        @logger.warn stack
+        @logger.warn "The connection seems to be closed in the host machine. Trying to reconnect"
+        @http.finish()
+        @http.start()
+        @start_time_net = Time.now if @start_time_net.nil?
+        resp, data = @http.patch(path, data, headers_t)
+      end
+      manage_response(resp, data)
+      if @auto_redirect and @response[:code].to_i >= 300 and @response[:code].to_i < 400 and @response.include?(:location)
+        if @num_redirects <= 30
+          @num_redirects += 1
+          current_server = "http"
+          current_server += "s" if @ssl == true
+          current_server += "://#{@host}"
+          location = @response[:location].gsub(current_server, "")
+          @logger.info "(#{@num_redirects}) Redirecting NiceHttp to #{location}"
+          get(location)
+        else
+          @logger.fatal "(#{@num_redirects}) Maximum number of redirections for a single request reached. Be sure everything is correct, it seems there is a non ending loop"
+          @num_redirects = 0
+        end
+      else
+        @num_redirects = 0
+      end
+      return @response
+    rescue Exception => stack
+      @logger.fatal stack
+      return {fatal_error: stack.to_s, code: nil, message: nil, data: ""}
+    end
+  end
+
+  ######################################################
+  # Delete an existing resource
+  # @param arg [Hash] containing at least key :path
+  # @param arg [String] the path
+  #
+  # @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.
+  #   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
+  ######################################################
+  def delete(argument)
+    begin
+      if argument.kind_of?(String)
+        argument = {:path => argument}
+      end
+      path, data, headers_t = manage_request(argument)
+      @start_time = Time.now if @start_time.nil?
+      if argument.kind_of?(Hash)
+        arg = argument
+        if @use_mocks and arg.kind_of?(Hash) and arg.keys.include?(:mock_response)
+          data = ""
+          if arg[:mock_response].keys.include?(:data)
+            data = arg[:mock_response][:data]
+            if data.kind_of?(Hash) #to json
+              begin
+                require "json"
+                data = data.to_json
+              rescue
+                @logger.fatal "There was a problem converting to json: #{data}"
+              end
+            end
+          end
+          @logger.warn "Pay attention!!! This is a mock response:"
+          @start_time_net = Time.now if @start_time_net.nil?
+          manage_response(arg[:mock_response], data.to_s)
+          return @response
+        end
+      end
+
+      begin
+        @start_time_net = Time.now if @start_time_net.nil?
+        resp = @http.delete(path, headers_t)
+        data = resp.body
+      rescue Exception => stack
+        @logger.warn stack
+        @logger.warn "The connection seems to be closed in the host machine. Trying to reconnect"
+        @http.finish()
+        @http.start()
+        @start_time_net = Time.now if @start_time_net.nil?
+        resp, data = @http.delete(path)
+      end
+      manage_response(resp, data)
+
+      return @response
+    rescue Exception => stack
+      @logger.fatal stack
+      return {fatal_error: stack.to_s, code: nil, message: nil, data: ""}
+    end
+  end
+
+  ######################################################
+  # Implementation of the http HEAD method.
+  # Asks for the response identical to the one that would correspond to a GET request, but without the response body.
+  # This is useful for retrieving meta-information written in response headers, without having to transport the entire content.
+  # @param arg [Hash] containing at least key :path
+  # @param arg [String] the path
+  #
+  # @return [Hash] response
+  #   Including at least the symbol keys:
+  #     :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.
+  #   In case of fatal error returns { fatal_error: "the error description", code: nil, message: nil }
+  ######################################################
+  def head(argument)
+    begin
+      if argument.kind_of?(String)
+        argument = {:path => argument}
+      end
+      path, data, headers_t = manage_request(argument)
+      @start_time = Time.now if @start_time.nil?
+      if argument.kind_of?(Hash)
+        arg = argument
+        if @use_mocks and arg.kind_of?(Hash) and arg.keys.include?(:mock_response)
+          data = ""
+          if arg[:mock_response].keys.include?(:data)
+            data = arg[:mock_response][:data]
+            if data.kind_of?(Hash) #to json
+              begin
+                require "json"
+                data = data.to_json
+              rescue
+                @logger.fatal "There was a problem converting to json: #{data}"
+              end
+            end
+          end
+          @logger.warn "Pay attention!!! This is a mock response:"
+          @start_time_net = Time.now if @start_time_net.nil?
+          manage_response(arg[:mock_response], data.to_s)
+          return @response
+        end
+      end
+
+      begin
+        @start_time_net = Time.now if @start_time_net.nil?
+        resp = @http.head(path, headers_t)
+        data = resp.body
+      rescue Exception => stack
+        @logger.warn stack
+        @logger.warn "The connection seems to be closed in the host machine. Trying to reconnect"
+        @http.finish()
+        @http.start()
+        @start_time_net = Time.now if @start_time_net.nil?
+        resp, data = @http.head(path)
+      end
+      manage_response(resp, data)
+      return @response
+    rescue Exception => stack
+      @logger.fatal stack
+      return {fatal_error: stack.to_s, code: nil, message: nil}
+    end
+  end
+
+  ######################################################
+  # Close HTTP connection
+  ######################################################
+  def close
+    begin
+      pos = 0
+      found = false
+      self.class.connections.each { |conn|
+        if conn.object_id == self.object_id
+          found = true
+          break
+        end
+        pos += 1
+      }
+      if found
+        self.class.connections.delete_at(pos)
+      end
+
+      unless @closed
+        if !@http.nil?
+          @http.finish()
+          @http = nil
+          @logger.info "the HTTP connection was closed: #{@message_server}"
+        else
+          @http = nil
+          @logger.fatal "It was not possible to close the HTTP connection: #{@message_server}"
+        end
+        @closed = true
+      else
+        @logger.warn "It was not possible to close the HTTP connection, already closed: #{@message_server}"
+      end
+    rescue Exception => stack
+      @logger.fatal stack
+    end
+    self.class.active -= 1
+  end
+
+  ######################################################
+  # private method to manage Request
+  #   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
+  ######################################################
+  def manage_request(*arguments)
+    require "json"
+    begin
+      content_type_included = false
+      path = ""
+      data = ""
+
+      @response = Hash.new()
+      headers_t = @headers.dup()
+      cookies_to_set_str = ""
+      if arguments.size == 3
+        path = arguments[0]
+      elsif arguments.size == 1 and arguments[0].kind_of?(Hash)
+        path = arguments[0][:path]
+      elsif arguments.size == 1 and arguments[0].kind_of?(String)
+        path = arguments[0].to_s()
+      end
+      @cookies.each { |cookie_path, cookies_hash|
+        cookie_path = "" if cookie_path == "/"
+        path_to_check = path
+        if path == "/" or path[-1] != "/"
+          path_to_check += "/"
+        end
+        if path_to_check.scan(/^#{cookie_path}\//).size > 0
+          cookies_hash.each { |key, value|
+            cookies_to_set_str += "#{key}=#{value}; "
+          }
+        end
+      }
+      headers_t["Cookie"] = cookies_to_set_str
+
+      method_s = caller[0].to_s().scan(/:in `(.*)'/).join
+
+      if arguments.size == 3
+        data = arguments[1]
+        if arguments[2].kind_of?(Hash)
+          headers_t.merge!(arguments[2])
+        end
+      elsif arguments.size == 1 and arguments[0].kind_of?(Hash)
+        if arguments[0][:data].nil?
+          if arguments[0].keys.include?(:data)
+            data = ""
+          elsif arguments[0].keys.include?(:data_examples) and
+                arguments[0][:data_examples].kind_of?(Array)
+            data = arguments[0][:data_examples][0] #the first example by default
+          else
+            data = ""
+          end
+        else
+          data = arguments[0][:data]
+        end
+        if arguments[0].include?(:headers)
+          headers_t.merge!(arguments[0][:headers])
+        end
+
+        if headers_t["Content-Type"].to_s() == "" and headers_t["content-type"].to_s() == "" and
+           headers_t[:"content-type"].to_s() == "" and headers_t[:"Content-Type"].to_s() == ""
+          content_type_included = false
+        elsif headers_t["content-type"].to_s() != ""
+          content_type_included = true
+          headers_t["Content-Type"] = headers_t["content-type"]
+        elsif headers_t[:"content-type"].to_s() != ""
+          content_type_included = true
+          headers_t["Content-Type"] = headers_t[:"content-type"]
+          headers_t.delete(:"content-type")
+        elsif headers_t[:"Content-Type"].to_s() != ""
+          content_type_included = true
+          headers_t["Content-Type"] = headers_t[:"Content-Type"]
+          headers_t.delete(:"Content-Type")
+        elsif headers_t["Content-Type"].to_s() != ""
+          content_type_included = true
+        end
+
+        if !content_type_included and data.kind_of?(Hash)
+          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_for)
+          arguments[0][:values_for] = 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?)
+          if arguments[0].include?(:values_for)
+            arguments[0][:values_for].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() != ""
+          require "json"
+          if data.kind_of?(String)
+            if arguments[0].include?(:values_for)
+              arguments[0][:values_for].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,
+                data.gsub!(/(( *|^)"?#{key.to_s()}"? *: *[^"])([^"].*)([^"] * *$)/, '\1' + value + '\4') # "key":456 or key:456
+              }
+            end
+          elsif data.kind_of?(Hash)
+            data_n = Hash.new()
+            data.each { |key, value|
+              data_n[key.to_s()] = value
+            }
+            if arguments[0].include?(:values_for)
+              #req[:values_for][:loginName] or req[:values_for]["loginName"]
+              new_values_hash = Hash.new()
+              arguments[0][:values_for].each { |kv, vv|
+                if data_n.keys.include?(kv.to_s())
+                  new_values_hash[kv.to_s()] = vv
+                end
+              }
+              data_n.merge!(new_values_hash)
+            end
+            data = data_n.to_json()
+          elsif data.kind_of?(Array)
+            data_arr = Array.new()
+            data.each_with_index { |row, indx|
+              unless row.kind_of?(Hash)
+                @logger.fatal("Wrong format on request application/json, be sure is a Hash, Array of Hashes or JSON string")
+                return :error, :error, :error
+              end
+              data_n = Hash.new()
+              row.each { |key, value|
+                data_n[key.to_s()] = value
+              }
+              if arguments[0].include?(:values_for)
+                #req[:values_for][:loginName] or req[:values_for]["loginName"]
+                new_values_hash = Hash.new()
+                if arguments[0][:values_for].kind_of?(Hash) #values[:mykey][3]
+                  arguments[0][:values_for].each { |kv, vv|
+                    if data_n.keys.include?(kv.to_s()) and !vv[indx].nil?
+                      new_values_hash[kv.to_s()] = vv[indx]
+                    end
+                  }
+                elsif arguments[0][:values_for].kind_of?(Array) #values[5][:mykey]
+                  if !arguments[0][:values_for][indx].nil?
+                    arguments[0][:values_for][indx].each { |kv, vv|
+                      if data_n.keys.include?(kv.to_s())
+                        new_values_hash[kv.to_s()] = vv
+                      end
+                    }
+                  end
+                else
+                  @logger.fatal("Wrong format on request application/json when supplying values, the data is an array of Hashes but the values supplied are not")
+                  return :error, :error, :error
+                end
+                data_n.merge!(new_values_hash)
+              end
+              data_arr.push(data_n)
+            }
+            data = data_arr.to_json()
+          else
+            @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_for)
+          if arguments[0][:values_for].kind_of?(Hash) and arguments[0][:values_for].keys.size > 0
+            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"
+              @logger.warn(":values_for key given without a valid content-type or data for request. No values modified on the request")
+            end
+          end
+        end
+      elsif arguments.size == 1 and arguments[0].kind_of?(String)
+        #path=arguments[0].to_s()
+        data = ""
+      else
+        @logger.fatal("Invalid number of arguments or wrong arguments in #{method_s}")
+        return :error, :error, :error
+      end
+      if headers_t.keys.include?("Content-Type") and !headers_t["Content-Type"]["multipart/form-data"].nil? and headers_t["Content-Type"] != ["multipart/form-data"] #only for the case raw multipart request
+        encoding = "UTF-8"
+        data_s = ""
+      else
+        encoding = data.to_s().scan(/encoding='(.*)'/i).join
+        if encoding.to_s() == ""
+          encoding = data.to_s().scan(/charset='(.*)'/i).join
+        end
+        if encoding.to_s() == "" and headers_t.include?("Content-Type")
+          encoding = headers_t["Content-Type"].scan(/charset='?(.*)'?/i).join
+          if encoding.to_s() == ""
+            encoding = headers_t["Content-Type"].scan(/encoding='?(.*)'?/i).join
+          end
+        end
+
+        begin
+          data_s = JSON.pretty_generate(JSON.parse(data))
+        rescue
+          data_s = data
+        end
+        data_s = data_s.to_s().gsub("<", "&lt;")
+      end
+      if headers_t.keys.include?("Accept-Encoding")
+        headers_t["Accept-Encoding"].gsub!("gzip", "") #removed so the response is in plain text
+      end
+
+      headers_ts = ""
+      headers_t.each { |key, val| headers_ts += key.to_s + ":" + val.to_s() + ", " }
+      message = "#{method_s} REQUEST: \npath= " + path.to_s() + "\n"
+      message += "headers= " + headers_ts.to_s() + "\n"
+      message += "data= " + data_s.to_s() + "\n"
+      message = @message_server + "\n" + message
+      if path.to_s().scan(/^https?:\/\//).size > 0 and path.to_s().scan(/^https?:\/\/#{@host}/).size == 0
+        # the path is for another server than the current
+      else
+        self.class.last_request = message
+        @logger.info(message)
+      end
+
+      if data.to_s() != "" and encoding.to_s().upcase != "UTF-8" and encoding != ""
+        data = data.to_s().encode(encoding, "UTF-8")
+      end
+      return path, data, headers_t
+    rescue Exception => stack
+      @logger.fatal(stack)
+      @logger.fatal("manage_request Error on method #{method_s} . path:#{path.to_s()}. data:#{data.to_s()}. headers:#{headers_t.to_s()}")
+      return :error
+    end
+  end
+
+  ######################################################
+  # private method to manage Response
+  #   input:
+  #     resp
+  #     data
+  #   output:
+  #     @response updated
+  ######################################################
+  def manage_response(resp, data)
+    require "json"
+    begin
+      if @start_time.kind_of?(Time)
+        @response[:time_elapsed_total] = Time.now - @start_time
+        @start_time = nil
+      else
+        @response[:time_elapsed_total] = nil
+      end
+      if @start_time_net.kind_of?(Time)
+        @response[:time_elapsed] = Time.now - @start_time_net
+        @start_time_net = nil
+      else
+        @response[:time_elapsed] = nil
+      end
+      begin
+        # this is to be able to access all keys as symbols
+        new_resp = Hash.new()
+        resp.each { |key, value|
+          if key.kind_of?(String)
+            new_resp[key.to_sym] = value
+          end
+        }
+        new_resp.each { |key, value|
+          resp[key] = value
+        }
+      rescue
+      end
+      #for mock_responses to be able to add outside of the header like content-type for example
+      if resp.kind_of?(Hash) and !resp.has_key?(:header)
+        resp[:header] = {}
+      end
+      if resp.kind_of?(Hash)
+        resp.each { |k, v|
+          if k != :code and k != :message and k != :data and k != :'set-cookie' and k != :header
+            resp[:header][k] = v
+          end
+        }
+        resp[:header].each { |k, v|
+          resp.delete(k) if resp.has_key?(k)
+        }
+      end
+
+      method_s = caller[0].to_s().scan(/:in `(.*)'/).join
+      if resp.header.kind_of?(Hash) and (resp.header["content-type"].to_s() == "application/x-deflate" or resp.header[:"content-type"].to_s() == "application/x-deflate")
+        data = Zlib::Inflate.inflate(data)
+      end
+      encoding_response = ""
+      if resp.header.kind_of?(Hash) and (resp.header["content-type"].to_s() != "" or resp.header[:"content-type"].to_s() != "")
+        encoding_response = resp.header["content-type"].scan(/;charset=(.*)/i).join if resp.header.has_key?("content-type")
+        encoding_response = resp.header[:"content-type"].scan(/;charset=(.*)/i).join if resp.header.has_key?(:"content-type")
+      end
+      if encoding_response.to_s() == ""
+        encoding_response = "UTF-8"
+      end
+
+      if encoding_response.to_s() != "" and encoding_response.to_s().upcase != "UTF-8"
+        data.encode!("UTF-8", encoding_response.to_s())
+      end
+      if encoding_response != "" and encoding_response.to_s().upcase != "UTF-8"
+        @response[:message] = resp.message.to_s().encode("UTF-8", encoding_response.to_s())
+        #todo: response data in here for example is convert into string, verify if that is correct or needs to maintain the original data type (hash, array...)
+        resp.each { |key, val| @response[key] = val.to_s().encode("UTF-8", encoding_response.to_s()) }
+      else
+        @response[:message] = resp.message
+        resp.each { |key, val| @response[key] = val }
+      end
+      if !defined?(Net::HTTP::Post::Multipart) or (defined?(Net::HTTP::Post::Multipart) and !data.kind_of?(Net::HTTP::Post::Multipart))
+        @response[:data] = data
+      else
+        @response[:data] = ""
+      end
+
+      @response[:code] = resp.code
+
+      unless @response.nil?
+        message = "\nRESPONSE: \n" + @response[:code].to_s() + ":" + @response[:message].to_s()
+        if @debug
+          self.class.last_response = message
+          @response.each { |key, value|
+            if value.to_s() != ""
+              value_orig = value
+              if key.kind_of?(Symbol)
+                if key == :code or key == :data or key == :header or key == :message
+                  if key == :data
+                    begin
+                      JSON.parse(value_orig)
+                      data_s = JSON.pretty_generate(JSON.parse(value_orig))
+                    rescue
+                      data_s = value_orig
+                    end
+                    self.class.last_response += "\nresponse." + key.to_s() + " = '" + data_s.gsub("<", "&lt;") + "'\n"
+                    if value_orig != value
+                      message += "\nresponse." + key.to_s() + " = '" + value.gsub("<", "&lt;") + "'\n"
+                    else
+                      message += "\nresponse." + key.to_s() + " = '" + data_s.gsub("<", "&lt;") + "'\n"
+                    end
+                  else
+                    self.class.last_response += "\nresponse." + key.to_s() + " = '" + value.to_s().gsub("<", "&lt;") + "'"
+                    message += "\nresponse." + key.to_s() + " = '" + value.to_s().gsub("<", "&lt;") + "'"
+                  end
+                else
+                  self.class.last_response += "\nresponse[:" + key.to_s() + "] = '" + value.to_s().gsub("<", "&lt;") + "'"
+                  message += "\nresponse[:" + key.to_s() + "] = '" + value.to_s().gsub("<", "&lt;") + "'"
+                end
+              elsif !@response.include?(key.to_sym)
+                self.class.last_response += "\nresponse['" + key.to_s() + "'] = '" + value.to_s().gsub("<", "&lt;") + "'"
+                message += "\nresponse['" + key.to_s() + "'] = '" + value.to_s().gsub("<", "&lt;") + "'"
+              end
+            end
+          }
+        end
+        @logger.info message
+        if @response.kind_of?(Hash)
+          if @response.keys.include?(:requestid)
+            @headers["requestId"] = @response[:requestid]
+            self.class.request_id = @response[:requestid]
+            @logger.info "requestId was found on the response header and it has been added to the headers for the next request"
+          end
+        end
+      end
+
+      if resp[:'set-cookie'].to_s() != ""
+        if resp.kind_of?(Hash) #mock_response
+          cookies_to_set = resp[:'set-cookie'].to_s().split(", ")
+        else #Net::Http
+          cookies_to_set = resp.get_fields("set-cookie")
+        end
+        cookies_to_set.each { |cookie|
+          cookie_pair = cookie.split("; ")[0].split("=")
+          cookie_path = cookie.scan(/; path=([^;]+)/i).join
+          @cookies[cookie_path] = Hash.new() unless @cookies.keys.include?(cookie_path)
+          @cookies[cookie_path][cookie_pair[0]] = cookie_pair[1]
+        }
+
+        @logger.info "set-cookie added to Cookie header as required"
+
+        if @headers.has_key?("X-CSRFToken")
+          csrftoken = resp[:"set-cookie"].to_s().scan(/csrftoken=([\da-z]+);/).join
+          if csrftoken.to_s() != ""
+            @headers["X-CSRFToken"] = csrftoken
+            @logger.info "X-CSRFToken exists on headers and has been overwritten"
+          end
+        else
+          csrftoken = resp[:"set-cookie"].to_s().scan(/csrftoken=([\da-z]+);/).join
+          if csrftoken.to_s() != ""
+            @headers["X-CSRFToken"] = csrftoken
+            @logger.info "X-CSRFToken added to header as required"
+          end
+        end
+      end
+    rescue Exception => stack
+      @logger.fatal stack
+      @logger.fatal "manage_response Error on method #{method_s} "
+    end
+  end
+
+  private :manage_request, :manage_response
+end