nice_http 1.9.8 → 1.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e56d1f6e75e63e5fd77e1d17c8627a77774535b502b733abece896f6c29b655e
-  data.tar.gz: 79109fc2b1b42f154294130e245c93d7c670ce11a96993e3a5674a06670d4569
+  metadata.gz: 1059fecf29256a3b57fbe27257398501830f3385e947c7d2922cdc57c4aab031
+  data.tar.gz: 7961065317e4fc908cdc2d9a258e6a6b1614872a203254fa8a8f98bb9368feda
 SHA512:
-  metadata.gz: 4498833215e1541e72bff84657796a46573cbee713d3d84268bdd6505199dd347f115a750a05e192004e8eedb0164782ca2a933bfbb9d0a01b0bc17e649b7088
-  data.tar.gz: c4f5f63ce27bc8233c727c386d3c2fc346a3f83a94b4a618e05af0527f9554dcaef1475eb9e619e899011e797bd63266538ef830b2a509328bc45525a4bd3e21
+  metadata.gz: 34e4639b8c9a3b8c3dc25c4515d95e52d0ebe0dda4c2895bb4ef67a8db56401a06d0e9cc152d680b11e12aab4f29299fba3f17c0b924aa3851607f936a4bb1ef
+  data.tar.gz: 782a12d030df576799172bad7f46f01949940d8f4521fe4842a9f3379becb5628caff7b85f7c6a695a2e59946b0ee70692a5d3ec1fc1e044065daecf8a638682

data/README.md

@@ -20,34 +20,37 @@ NiceHttp is able to use hashes as requests data and uses the Request Hash struct
 
 **On the next link you have a full example using nice_http and RSpec to test REST APIs, Uber API and Reqres API: https://github.com/MarioRuiz/api-testing-example**
 
-To be able to generate random requests take a look at the documentation for nice_hash gem: https://github.com/MarioRuiz/nice_hash
-
-Example that creates 1000 good random and unique requests to register an user and test that the validation of the fields are correct by the user was able to be registered. Send 800 requests where just one field is wrong and verify the user was not able to be created: https://gist.github.com/MarioRuiz/824d7a462b62fd85f02c1a09455deefb
+**Related gems:** NiceHttp uses [nice_hash](https://github.com/MarioRuiz/nice_hash) (v1.19+) for request/response hashes (e.g. `resp.data.json`, `set_values`, `nice_merge`) and for generating headers. [string_pattern](https://github.com/MarioRuiz/string_pattern) (v2.4+) is used by nice_hash for pattern-based string generation and validation. To generate random or pattern-based request data, see the [nice_hash documentation](https://github.com/MarioRuiz/nice_hash). Example: 1000 valid requests + 800 with one wrong field to test validation — [gist](https://gist.github.com/MarioRuiz/824d7a462b62fd85f02c1a09455deefb).
 
 # Table of Contents
 
-- [Installation](#Installation)
-- [A very simple first example](#A-very-simple-first-example)
-- [Create a connection](#Create-a-connection)
-- [Creating requests](#Creating-requests)
-- [Responses](#Responses)
-    - [Async Responses](#Async-Responses)
-- [Special settings](#Special-settings)
-- [Authentication requests](#Authentication-requests)
-    - [Basic Authentication](#Basic-Authentication)
-    - [OpenID](#OpenID)
-    - [OAuth2](#OAuth2)
-    - [JWT Token](#JWT-Token)
+- [NiceHttp](#nicehttp)
+- [Table of Contents](#table-of-contents)
+  - [Installation](#installation)
+  - [A very simple first example](#a-very-simple-first-example)
+  - [Create a connection](#create-a-connection)
+  - [Creating requests](#creating-requests)
+  - [Responses](#responses)
+    - [Async responses](#async-responses)
+  - [Special settings](#special-settings)
+  - [Authentication requests](#authentication-requests)
+    - [Basic Authentication](#basic-authentication)
+    - [OpenID](#openid)
+    - [OAuth2](#oauth2)
+    - [JWT token](#jwt-token)
     - [lambda on headers](#lambda-on-headers)
-- [Http logs](#Http-logs)
-    - [Multithreading](#Multithreading)
-- [Http stats](#Http-stats)
-- [Tips](#Tips)
-    - [Download a file](#Download-a-file)
-    - [Send multipart content](#Send-multipart-content)
-    - [Send x-www-form-urlencoded](#Send-x-www-form-urlencoded)
-- [Contributing](#Contributing)
-- [License](#License)
+  - [Http logs](#http-logs)
+    - [Multithreading](#multithreading)
+  - [Http stats](#http-stats)
+  - [Testing with generated data](#testing-with-generated-data)
+  - [Validating API responses](#validating-api-responses)
+  - [Tips](#tips)
+    - [Download a file](#download-a-file)
+    - [Send multipart content](#send-multipart-content)
+    - [Send x-www-form-urlencoded](#send-x-www-form-urlencoded)
+  - [Running tests](#running-tests)
+  - [Contributing](#contributing)
+  - [License](#license)
 
 ## Installation
 
@@ -99,6 +102,9 @@ http3 = NiceHttp.new my_reqres_server
 ```
 
 
+**Connection errors ("Too many open files")**  
+If you see "Too many open files" when creating connections (e.g. with many threads), NiceHttp will retry connection creation a few times with backoff. You can set `NiceHttp.connection_retry_attempts` (default 3) and `NiceHttp.connection_retry_base_delay` (default 1.0 seconds), or pass `connection_retry_attempts` and `connection_retry_base_delay` in the options hash when creating a connection. For long-running or multi-threaded usage, prefer reusing one connection per thread and calling `close` when finished.
+
 You can specify all the defaults you will be using when creating connections by using the NiceHttp methods, in this example, http1 and http2 will be connecting to reqres.in with the default parameters and http3 to example.com:
 
 ```ruby
@@ -748,6 +754,46 @@ NiceHttp.add_stats(:customer, :create, started, Time.now, customer_name)
 
 This will generate an items key that will contain an array of the values you added.
 
+## Testing with generated data
+
+When you build request hashes with [nice_hash](https://github.com/MarioRuiz/nice_hash) patterns (in `data`, `headers`, or `values_for`), you can:
+
+* **Reproducible tests:** Use `seed` so the same request is generated every time:
+  ```ruby
+  req = { path: "/api/users", data: { name: :"10-20:L", email: :"20-40:@" } }
+  resp = http.post req.generate(seed: 42)  # same payload every run
+  ```
+
+* **Batch generation:** Generate many different request hashes in one go (e.g. for load or boundary tests):
+  ```ruby
+  template = { path: "/api/users", data: { name: :"10-20:L", job: :"leader|developer" } }
+  requests = template.generate_n(5, :correct)  # 5 different hashes
+  requests.each { |r| http.post r }
+  ```
+
+* **UUIDs:** Use the `:uuid` shorthand (string_pattern 2.4+) in your request data:
+  ```ruby
+  resp = http.post(path: "/api/items", data: { id: :uuid, name: "Item" })
+  ```
+
+## Validating API responses
+
+You can validate JSON responses against a structure or patterns using [nice_hash](https://github.com/MarioRuiz/nice_hash):
+
+* **Structure comparison:** Check that the response has the expected keys and nested structure:
+  ```ruby
+  expected = { user: { name: "xxx", id: 1 } }
+  NiceHash.compare_structure(expected, resp.data.json)  # => true/false
+  ```
+
+* **Diff for assertions:** Get dot-notation differences for clearer failure messages:
+  ```ruby
+  diff = NiceHash.diff(expected, resp.data.json)
+  # => { "user.name" => { expected: "Alice", got: "Bob" } } or {}
+  ```
+
+* **Pattern validation:** If your expected structure uses nice_hash patterns (e.g. `:"10:N"`, ranges), use `validate` to check that response values match those patterns.
+
 ## Tips
 
 ### Download a file
@@ -795,6 +841,17 @@ Example posting a csv file:
     }
 ```
 
+## Running tests
+
+Run the test suite with:
+
+```bash
+bundle install
+bundle exec rspec
+```
+
+By default, a **local Sinatra fake API** is started on ports 4567 and 4568 so specs do not depend on external services (reqres.in, Replit, example.com). Set `USE_FAKE_API=false` to use real external hosts instead (not recommended for CI).
+
 ## Contributing
 
 Bug reports are very welcome on GitHub at https://github.com/marioruiz/nice_http.

data/lib/nice_http/initialize.rb

@@ -33,6 +33,9 @@ class NiceHttp
   #             async_completed -- string (default empty string)
   #             async_resource -- string (default empty string)
   #             async_status -- string (default empty string)
+  #             connection_retry_attempts -- positive integer (default 3). When connection creation fails with "too many open files", retry up to this many times with backoff.
+  #             connection_retry_base_delay -- non-negative number, seconds (default 1.0). Base delay before each retry; jitter is added to avoid thundering herd.
+  # @note When connection creation fails with "too many open files" (EMFILE/ENFILE), the library retries up to connection_retry_attempts times with backoff. For sustained load or many threads, prefer reusing one connection per thread and calling close when done.
   # @example
   #   http2 = NiceHttp.new( host: "reqres.in", port: 443, ssl: true )
   # @example
@@ -69,7 +72,9 @@ class NiceHttp
     @async_completed = self.class.async_completed
     @async_resource = self.class.async_resource
     @async_status = self.class.async_status
-    
+    @connection_retry_attempts = self.class.connection_retry_attempts || 3
+    @connection_retry_base_delay = self.class.connection_retry_base_delay || 1.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
@@ -86,7 +91,11 @@ class NiceHttp
       @port = args[:port] if args.keys.include?(:port)
       @ssl = args[:ssl] if args.keys.include?(:ssl)
       @timeout = args[:timeout] if args.keys.include?(:timeout)
-      @headers = args[:headers].dup if args.keys.include?(:headers)
+      # Keep object reference when it has .generate (e.g. nice_hash); otherwise dup to avoid mutating caller's hash
+      if args.keys.include?(:headers)
+        h = args[:headers]
+        @headers = (h.is_a?(Hash) && h.respond_to?(:generate)) ? h : h.dup
+      end
       @values_for = args[:values_for].dup if args.keys.include?(:values_for)
       @debug = args[:debug] if args.keys.include?(:debug)
       @log = args[:log] if args.keys.include?(:log)
@@ -100,7 +109,9 @@ class NiceHttp
       @async_header = args[:async_header] if args.keys.include?(:async_header)
       @async_completed = args[:async_completed] if args.keys.include?(:async_completed)
       @async_resource = args[:async_resource] if args.keys.include?(:async_resource)
-      @async_status = args[:async_status] if args.keys.include?(:async_status)      
+      @async_status = args[:async_status] if args.keys.include?(:async_status)
+      @connection_retry_attempts = args[:connection_retry_attempts] if args.keys.include?(:connection_retry_attempts)
+      @connection_retry_base_delay = args[:connection_retry_base_delay] if args.keys.include?(:connection_retry_base_delay)
     end
 
     log_filename = ""
@@ -175,7 +186,7 @@ class NiceHttp
       raise InfoMissing, :log
     end
     @log_file = log_filename
-    @logger.level = Logger::INFO    
+    @logger.level = Logger::INFO
 
     if @host.to_s != "" and (@host.start_with?("http:") or @host.start_with?("https:"))
       uri = URI.parse(@host)
@@ -199,28 +210,45 @@ class NiceHttp
     raise InfoMissing, :async_completed unless @async_completed.is_a?(String) or @async_completed.nil?
     raise InfoMissing, :async_resource unless @async_resource.is_a?(String) or @async_resource.nil?
     raise InfoMissing, :async_status unless @async_status.is_a?(String) or @async_status.nil?
-    
+    raise InfoMissing, :connection_retry_attempts unless @connection_retry_attempts.is_a?(Integer) && @connection_retry_attempts >= 1
+    raise InfoMissing, :connection_retry_base_delay unless @connection_retry_base_delay.is_a?(Numeric) && @connection_retry_base_delay >= 0
+
     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
-        unless @timeout.nil?
-          @http.open_timeout = @timeout
-          @http.read_timeout = @timeout
-        end
-        @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
-        unless @timeout.nil?
-          @http.open_timeout = @timeout
-          @http.read_timeout = @timeout
+      attempt = 1
+      loop do
+        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
+            unless @timeout.nil?
+              @http.open_timeout = @timeout
+              @http.read_timeout = @timeout
+            end
+            @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
+            unless @timeout.nil?
+              @http.open_timeout = @timeout
+              @http.read_timeout = @timeout
+            end
+            @http.start
+          end
+          break
+        rescue Exception => e
+          if connection_retryable_error?(e) && attempt < @connection_retry_attempts
+            delay = @connection_retry_base_delay + rand(0.25)
+            @logger.warn "(#{self.object_id}): Too many open files (attempt #{attempt}/#{@connection_retry_attempts}), retrying in #{delay.round(2)}s..."
+            sleep(delay)
+            attempt += 1
+          else
+            raise
+          end
         end
-        @http.start
       end
 
       @message_server = "(#{self.object_id}):"
@@ -241,7 +269,11 @@ class NiceHttp
       @auto_redirect = auto_redirect
       # for the case we have headers following nice_hash implementation
       @headers_orig = @headers.dup
-      @headers = @headers.generate
+      @headers = if @headers.is_a?(Hash) && @headers.respond_to?(:generate)
+          @headers.generate
+        else
+          @headers.dup
+        end
 
       self.class.active += 1
       self.class.connections.push(self)
@@ -251,4 +283,19 @@ class NiceHttp
       raise stack
     end
   end
+
+  ######################################################
+  # Returns true if the exception indicates file-descriptor exhaustion (too many open files).
+  # Used to decide whether to retry connection creation.
+  ######################################################
+  def connection_retryable_error?(e)
+    return true if e.is_a?(Errno::EMFILE) || e.is_a?(Errno::ENFILE)
+    return true if e.message.to_s.downcase.include?("too many open files")
+    c = e.cause
+    return true if c && (c.is_a?(Errno::EMFILE) || c.is_a?(Errno::ENFILE))
+    return true if c && c.message.to_s.downcase.include?("too many open files")
+    false
+  end
+
+  private :connection_retryable_error?
 end

data/lib/nice_http/manage/response.rb

@@ -29,22 +29,6 @@ module NiceHttpManageResponse
 
       create_stats(resp) if @create_stats
 
-      begin
-        # this is to be able to access all keys as symbols on Ruby < 2.6.0
-        if RUBY_VERSION < "2.6.0"
-          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
-          }
-        end
-      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] = {}

data/lib/nice_http/reset.rb

@@ -50,5 +50,7 @@ class NiceHttp
     @async_completed = ""
     @async_resource = ""
     @async_status = ""
+    @connection_retry_attempts = 3
+    @connection_retry_base_delay = 1.0
   end
-end
+end

data/lib/nice_http/validate_response.rb

@@ -0,0 +1,56 @@
+class NiceHttp
+  ######################################################
+  # Validates that a response body matches an expected structure (keys and nesting).
+  # Uses NiceHash.compare_structure. Best for JSON responses.
+  #
+  # @param resp [Hash] Response object (e.g. from get/post). Must have :data (body string or Hash/Array).
+  # @param expected_structure [Hash, Array] Structure with expected keys and nesting (values can be placeholders).
+  # @param options [Hash] Optional. :include_diff => true to add a diff in the result when validation fails.
+  # @return [Hash] { ok: true } when structure matches, or { ok: false } or { ok: false, diff: Hash } when it does not.
+  # @example
+  #   resp = http.get("/api/users/1")
+  #   result = NiceHttp.validate_response(resp, { user: { name: "xxx", id: 1 } })
+  #   expect(result[:ok]).to be true
+  # @example
+  #   result = NiceHttp.validate_response(resp, expected, include_diff: true)
+  #   puts result[:diff] unless result[:ok]
+  ######################################################
+  def self.validate_response(resp, expected_structure, options = {})
+    data = resp.is_a?(Hash) ? resp[:data] : resp.data
+    parsed = if data.is_a?(String)
+        begin
+          require "json"
+          JSON.parse(data.to_s)
+        rescue JSON::ParserError
+          return { ok: false, error: "response data is not valid JSON" }
+        end
+      elsif data.is_a?(Hash) || data.is_a?(Array)
+        data
+      else
+        return { ok: false, error: "response data is missing or not JSON" }
+      end
+
+    # Normalize to symbol keys so compare_structure/diff match typical expected_structure (symbol keys)
+    parsed = deep_symbolize(parsed) if parsed.is_a?(Hash) || parsed.is_a?(Array)
+
+    ok = NiceHash.compare_structure(expected_structure, parsed)
+
+    result = { ok: ok }
+    if !ok && options[:include_diff]
+      result[:diff] = NiceHash.diff(expected_structure, parsed)
+    end
+    result
+  end
+
+  def self.deep_symbolize(obj)
+    case obj
+    when Hash
+      obj.each_with_object({}) { |(k, v), h| h[k.to_sym] = deep_symbolize(v) }
+    when Array
+      obj.map { |e| deep_symbolize(e) }
+    else
+      obj
+    end
+  end
+  private_class_method :deep_symbolize
+end

data/lib/nice_http.rb

@@ -23,13 +23,15 @@ require_relative "nice_http/inherited"
 require_relative "nice_http/save_stats"
 require_relative "nice_http/close"
 require_relative "nice_http/initialize"
+require_relative "nice_http/validate_response"
 
 ######################################################
-# Attributes you can access using NiceHttp.the_attribute:  
-#   :host, :port, :ssl, :timeout, :headers, :debug, :log, :log_headers, :proxy_host, :proxy_port,  
-#   :last_request, :last_response, :request_id, :use_mocks, :connections,  
+# Attributes you can access using NiceHttp.the_attribute:
+#   :host, :port, :ssl, :timeout, :headers, :debug, :log, :log_headers, :proxy_host, :proxy_port,
+#   :last_request, :last_response, :request_id, :use_mocks, :connections,
 #   :active, :auto_redirect, :values_for, :create_stats, :stats, :capture, :captured, :request, :requests,
-#   :async_wait_seconds, :async_header, :async_completed, :async_resource, :async_status
+#   :async_wait_seconds, :async_header, :async_completed, :async_resource, :async_status,
+#   :connection_retry_attempts, :connection_retry_base_delay
 #
 # @attr [String] host The host to be accessed
 # @attr [Integer] port The port number
@@ -38,12 +40,12 @@ require_relative "nice_http/initialize"
 # @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] log_path The path where the logs will be stored. By default empty string.
-# @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.  
-#   :file_run, will generate a log file with the name where the object was created and extension .log, fex: myfile.rb.log  
+# @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.
+#   :file_run, will generate a log file with the name where the object was created and extension .log, fex: myfile.rb.log
 #   String the path and file name where the logs will be stored.
 # @attr [String] log_file path and file name where the logs will be stored. (only reader)
 # @attr [Symbol] log_headers. :all, :partial, :none (default :all) If :all will log all the headers. If :partial will log the last 10 characters. If :none no headers.
@@ -61,10 +63,10 @@ require_relative "nice_http/initialize"
 # @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:  
+# @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"  
+# @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
 # @attr [Hash] values_for The default values to set on the data in case not specified others
 # @attr [Boolean] create_stats If true, NiceHttp will create stats of the http communication and store them on NiceHttp.stats hash
@@ -101,7 +103,8 @@ class NiceHttp
     attr_accessor :host, :port, :ssl, :timeout, :headers, :debug, :log_path, :log, :proxy_host, :proxy_port, :log_headers,
                   :last_request, :last_response, :request, :request_id, :use_mocks, :connections,
                   :active, :auto_redirect, :log_files, :values_for, :create_stats, :stats, :capture, :captured, :requests,
-                  :async_wait_seconds, :async_header, :async_completed, :async_resource, :async_status
+                  :async_wait_seconds, :async_header, :async_completed, :async_resource, :async_status,
+                  :connection_retry_attempts, :connection_retry_base_delay
   end
 
   at_exit do

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: nice_http
 version: !ruby/object:Gem::Version
-  version: 1.9.8
+  version: 1.10.0
 platform: ruby
 authors:
 - Mario Ruiz
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-23 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nice_hash
@@ -16,20 +15,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.18'
+        version: '1.19'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.18.4
+        version: 1.19.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.18'
+        version: '1.19'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.18.4
+        version: 1.19.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -87,6 +86,7 @@ files:
 - lib/nice_http/utils/get_value_xml_tag.rb
 - lib/nice_http/utils/set_lambdas.rb
 - lib/nice_http/utils/set_value_xml_tag.rb
+- lib/nice_http/validate_response.rb
 homepage: https://github.com/MarioRuiz/nice_http
 licenses:
 - MIT
@@ -106,8 +106,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.3
-signing_key:
+rubygems_version: 4.0.6
 specification_version: 4
 summary: NiceHttp -- simplest library for accessing and testing HTTP and REST resources.
   Get http logs and statistics automatically. Use hashes on your requests. Access