nice_http 1.10.1 → 1.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eba012b6fef9f47963dc8d88eef3f56138ce1ccdbd90a781d4aa0c399069b71f
-  data.tar.gz: 0a0c45f8082eb7fe65a6aa68eec0a7af0425502a911ec60d972e5621a2b9d7b9
+  metadata.gz: '08a3b0309aabfc6296d1bb905ae4dda3ea550702a08d6f5bc96aae80acbaf8b3'
+  data.tar.gz: c4b6b1b7e01b548d369b0acff34acf8a36f1b0cb9bad682aa4e293a52a2296ad
 SHA512:
-  metadata.gz: 0ee35fad14ffd5afee69bad03e927c860495d92b6772ab3060572e3353d07a124bf46ae366fa82217b6a076c693d10135cc40dc26f9c69368c72de31e591ef79
-  data.tar.gz: b67acb7553b2968bec31567578da6513e3819d274ae443a2f6ab30b9614bbe2782c81d0684324c4a3cd15f7ba01b0656fa0bbda0c8a59f03885df695180597b7
+  metadata.gz: 013f23c8d0df421fa63f8c00cd6948930040d0e4743d9a40a36c529e3b8a37243e8d6d5dd7017f3141e68a5e53c8b9d3ae044980074f91bf23ff2e367d67ee28
+  data.tar.gz: 02353a935cf0674d0ca05e3166f61775087debdb4595258d8508b17f5a99d0106c96f827c4dee9532e777a61f74c08236097754b75e6b1f714687e0a39d29891

data/README.md

@@ -20,7 +20,7 @@ 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**
 
-**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).
+**Related gems:** NiceHttp uses [nice_hash](https://github.com/MarioRuiz/nice_hash) (v1.21+) 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.5+) 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). Upgrading from nice_http 1.10: see [Compatibility with nice_hash 1.21](#compatibility-with-nice_hash-121).
 
 # Table of Contents
 
@@ -44,6 +44,7 @@ NiceHttp is able to use hashes as requests data and uses the Request Hash struct
   - [Http stats](#http-stats)
   - [Testing with generated data](#testing-with-generated-data)
   - [Validating API responses](#validating-api-responses)
+  - [Compatibility with nice_hash 1.21](#compatibility-with-nice_hash-121)
   - [Tips](#tips)
     - [Download a file](#download-a-file)
     - [Send multipart content](#send-multipart-content)
@@ -758,7 +759,7 @@ This will generate an items key that will contain an array of the values you add
 
 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:
+* **Reproducible tests:** Use `seed` so the same request is generated every time. Strings from a seed in nice_hash 1.19 will not match 1.21. `:uuid`, `:iban` and `:luhn` are not produced from the seed.
   ```ruby
   req = { path: "/api/users", data: { name: :"10-20:L", email: :"20-40:@" } }
   resp = http.post req.generate(seed: 42)  # same payload every run
@@ -771,10 +772,26 @@ When you build request hashes with [nice_hash](https://github.com/MarioRuiz/nice
   requests.each { |r| http.post r }
   ```
 
-* **UUIDs:** Use the `:uuid` shorthand (string_pattern 2.4+) in your request data:
+* **Shorthands on send:** A pattern symbol in `data`, in a nested hash, in an array of hashes, or in that request's headers is expanded on each call. Strings are left as written, so `"10:N"` is sent as the characters `10:N`. A symbol that is not a pattern, such as `:admin`, is sent as the text `"admin"`.
   ```ruby
-  resp = http.post(path: "/api/items", data: { id: :uuid, name: "Item" })
+  resp = http.post({
+    path: "/api/items",
+    data: {
+      id: :uuid,
+      email: :email,
+      iban: [:iban, "DE"],
+      card: [:luhn, 15],
+      tags: [:"3:L"],
+      age: 18..30,
+      created: DateTime,
+      active: Boolean,
+      token: /[A-Z0-9]{8}/,
+      code: "10:N",
+      role: :admin
+    }
+  })
   ```
+  The same values inside `values_for` are expanded after they are copied into `data`. Connection headers are still generated once, when the client is created, so a pattern there stays the same for every request on that client. A one-element pattern array in those headers becomes 1 to 5 strings for the life of the connection. A pattern header passed on a single request is generated again on the next request.
 
 ## Validating API responses
 
@@ -792,7 +809,23 @@ You can validate JSON responses against a structure or patterns using [nice_hash
   # => { "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.
+* **Pattern validation:** `NiceHttp.validate_response` compares the shape and, when the expected value is a pattern symbol, shorthand (`:uuid`, `:email`, `:iban`, `:luhn`), checksum pair (`[:iban, "DE"]`, `[:luhn, 15]`), one-element pattern array, range, regexp, `DateTime` or `Boolean`, checks that the response value matches. String keys and symbol keys are equivalent. A plain string in the expected structure is not treated as a pattern. A missing key still fails. `explain:` is present only when a pattern fails.
+  ```ruby
+  result = NiceHttp.validate_response(resp, { "id" => :uuid, email: :email }, explain: true)
+  result[:ok]          # => true / false
+  result[:explain]     # only when a pattern fails: { email: { valid:, errors:, message:, index: } }
+  ```
+
+## Compatibility with nice_hash 1.21
+
+nice_http 1.11 requires nice_hash 1.21 and string_pattern 2.5 (Ruby >= 3.0).
+
+* `generate(seed:)` / `generate_n(seed:)` do not repeat the strings from nice_hash 1.19. Do not assert `:uuid`, `:iban` or `:luhn` from a seed.
+* `StringPattern.block_list` matches literals. Set `StringPattern.block_list_regexp = true` when the list holds regular expressions.
+* A `Regexp` pattern must match the whole value.
+* `[:"3:L"]` generates 1 to 5 strings, including in connection headers.
+* Pattern symbols and shorthands in a request body or request header are expanded when the request is sent. `"10:N"` and `"a|b"` are not.
+* `validate_response` can return `ok: true` for string keys, and for pattern placeholders whose value matches, where 1.10 returned `ok: false`.
 
 ## Tips
 

data/lib/nice_http/manage/request.rb

@@ -11,7 +11,7 @@ module NiceHttpManageRequest
   ######################################################
   def manage_request(*arguments_param)    
     if arguments_param.size == 1 and arguments_param[0].kind_of?(Hash)
-      arguments = [arguments_param[0].deep_copy()]
+      arguments = [NiceHttpUtils.copy_request(arguments_param[0])]
     else
       arguments = arguments_param
     end    
@@ -146,16 +146,16 @@ module NiceHttpManageRequest
         values_for_orig = {}
         if @defaults_request.key?(:values_for) and @defaults_request.is_a?(Hash) and @defaults_request[:values_for].size > 0
           if arguments[0].include?(:values_for)
-            values_for_orig = arguments[0][:values_for].deep_copy
+            values_for_orig = NiceHttpUtils.copy_request(arguments[0][:values_for])
             arguments[0][:values_for] = @defaults_request[:values_for].nice_merge(arguments[0][:values_for])
           else
-            arguments[0][:values_for] = @defaults_request[:values_for].deep_copy
+            arguments[0][:values_for] = NiceHttpUtils.copy_request(@defaults_request[:values_for])
           end
         end
         
         if @values_for.size > 0
           if arguments[0][:values_for].nil?
-            arguments[0][:values_for] = @values_for.deep_copy
+            arguments[0][:values_for] = NiceHttpUtils.copy_request(@values_for)
           else
             arguments[0][:values_for] = @values_for.nice_merge(arguments[0][:values_for])
           end
@@ -186,13 +186,14 @@ module NiceHttpManageRequest
               }
             end
           elsif data.kind_of?(Hash)
-            data_orig = data.deep_copy
+            data_orig = NiceHttpUtils.copy_request(data)
             data.nice_merge!(@defaults_request[:data]) if @defaults_request.key?(:data)
             data = NiceHttpUtils.set_lambdas(data, data_orig)
 
             if arguments[0].include?(:values_for)
               data = data.set_values(arguments[0][:values_for])
             end
+            data = NiceHttpUtils.expand_patterns(data)
             data = data.to_json()
 
           elsif data.kind_of?(Array)
@@ -213,7 +214,7 @@ module NiceHttpManageRequest
               end
               data_arr.push(data_n)
             }
-            data = data_arr.to_json()
+            data = NiceHttpUtils.expand_patterns(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
@@ -254,6 +255,7 @@ module NiceHttpManageRequest
         end
         data_s = data_s.to_s().gsub("<", "&lt;")
       end
+      headers_t = NiceHttpUtils.expand_patterns(headers_t) if headers_t.is_a?(Hash)
       if headers_t.keys.include?("Accept-Encoding")
         headers_t["Accept-Encoding"].gsub!("gzip", "") #removed so the response is in plain text
       end

data/lib/nice_http/manage/response.rb

@@ -90,12 +90,13 @@ module NiceHttpManageResponse
             value_orig = value
             if key.kind_of?(Symbol)
               if key == :code or key == :data or key == :header or key == :message
-                if key == :data and !@response[:'content-type'].to_s.include?("text/html")
-                  if key == :data and
-                     (!@response[:'content-type'].include?("text") and
-                      !@response[:'content-type'].include?("json") and
-                      !@response[:'content-type'].include?("xml") and
-                      !@response[:'content-type'].include?("charset=utf-8"))
+                content_type = @response[:'content-type'].to_s
+                if key == :data and !content_type.include?("text/html")
+                  if key == :data and content_type != "" and
+                     (!content_type.include?("text") and
+                      !content_type.include?("json") and
+                      !content_type.include?("xml") and
+                      !content_type.include?("charset=utf-8"))
                     message += "\n data: It's not text data so won't be in the logs."
                   else
                     begin

data/lib/nice_http/methods/delete.rb

@@ -94,7 +94,8 @@ module NiceHttpHttpMethods
           @http.start()
           @headers_orig.each { |k, v| headers_t[k] = v.call if v.is_a?(Proc) and headers_t.key?(k) }
           @start_time_net = Time.now if @start_time_net.nil?
-          resp, data = @http.delete(path, headers_t)
+          resp = @http.delete(path, headers_t)
+          data = resp.body
         end
       end
       manage_response(resp, data)

data/lib/nice_http/methods/head.rb

@@ -59,7 +59,8 @@ module NiceHttpHttpMethods
           @http.start()
           @headers_orig.each { |k, v| headers_t[k] = v.call if v.is_a?(Proc) and headers_t.key?(k) }
           @start_time_net = Time.now if @start_time_net.nil?
-          resp, data = @http.head(path, headers_t)
+          resp = @http.head(path, headers_t)
+          data = resp.body
         end
       end
       manage_response(resp, data)

data/lib/nice_http/methods/patch.rb

@@ -74,7 +74,8 @@ module NiceHttpHttpMethods
           @http.start()
           @headers_orig.each { |k, v| headers_t[k] = v.call if v.is_a?(Proc) and headers_t.key?(k) }
           @start_time_net = Time.now if @start_time_net.nil?
-          resp, data = @http.patch(path, data, headers_t)
+          resp = @http.patch(path, data, headers_t)
+          data = resp.body
         end
       end
       manage_response(resp, data)

data/lib/nice_http/methods/post.rb

@@ -93,7 +93,8 @@ module NiceHttpHttpMethods
           @http.start()
           @start_time_net = Time.now if @start_time_net.nil?
           @headers_orig.each { |k, v| headers_t[k] = v.call if v.is_a?(Proc) and headers_t.key?(k) }
-          resp, data = @http.post(path, data, headers_t)
+          resp = @http.post(path, data, headers_t)
+          data = resp.body
         end
       end
       manage_response(resp, data)

data/lib/nice_http/methods/put.rb

@@ -73,7 +73,8 @@ module NiceHttpHttpMethods
           @http.start()
           @headers_orig.each { |k, v| headers_t[k] = v.call if v.is_a?(Proc) and headers_t.key?(k) }
           @start_time_net = Time.now if @start_time_net.nil?
-          resp, data = @http.send_request("PUT", path, data, headers_t)
+          resp = @http.send_request("PUT", path, data, headers_t)
+          data = resp.body
         end
       end
       manage_response(resp, data)

data/lib/nice_http/utils/expand_patterns.rb

@@ -0,0 +1,130 @@
+module NiceHttpUtils
+  PATTERN_SYMBOL = /\A!?\d+-?\d*:.+/
+  SELECTOR_SYMBOL = /\A(?:[\w\s\-]+\|)+[\w\s\-]+\z/
+  SHORTHANDS = [:uuid, :email, :iban, :luhn].freeze
+
+  # A value NiceHttp expands before sending, or that validate_response checks as a pattern.
+  # Plain strings are never patterns here, even when they look like "10:N" or "a|b".
+  def self.pattern_value?(value)
+    return true if pattern_symbol?(value)
+    return true if value.is_a?(Range) || value.is_a?(Regexp)
+    return true if defined?(DateTime) && value.is_a?(Class) && value == DateTime
+    return true if defined?(Boolean) && value.is_a?(Module) && value == Boolean
+    return true if checksum_array?(value)
+    return true if one_pattern_array?(value)
+
+    false
+  end
+
+  def self.contains_pattern?(obj)
+    return true if pattern_value?(obj)
+
+    case obj
+    when Hash
+      obj.any? { |_key, value| contains_pattern?(value) }
+    when Array
+      obj.any? { |value| contains_pattern?(value) }
+    else
+      false
+    end
+  end
+
+  # Copy of expected where pattern placeholders are replaced by the actual value,
+  # so compare_structure checks shape and leaves pattern checks to NiceHash.validate.
+  def self.structure_without_patterns(expected, actual)
+    if pattern_value?(expected)
+      return actual.nil? ? expected : actual
+    end
+
+    case expected
+    when Hash
+      expected.each_with_object({}) do |(key, value), copy|
+        child = actual.is_a?(Hash) ? actual[key] : nil
+        copy[key] = structure_without_patterns(value, child)
+      end
+    when Array
+      if expected.empty?
+        expected
+      else
+        child = actual.is_a?(Array) ? actual[0] : nil
+        [structure_without_patterns(expected[0], child)]
+      end
+    else
+      expected
+    end
+  end
+
+  # Copy a request without cloning Class or Module.
+  # DateTime.clone is an anonymous class and Boolean.clone is an anonymous module,
+  # so NiceHash.generate would no longer recognize them.
+  def self.copy_request(obj)
+    case obj
+    when Hash
+      obj.each_with_object({}) { |(key, value), copy| copy[key] = copy_request(value) }
+    when Array
+      obj.map { |value| copy_request(value) }
+    else
+      return obj if obj.is_a?(Module)
+
+      obj.clone
+    end
+  rescue StandardError
+    obj
+  end
+
+  # New hash or array. Strings, numbers, booleans, nil and procs are copied as they are.
+  def self.expand_patterns(obj)
+    case obj
+    when Hash
+      obj.each_with_object({}) { |(key, value), copy| copy[key] = expand_pattern_value(value) }
+    when Array
+      if pattern_value?(obj)
+        generate_pattern(obj)
+      else
+        obj.map { |value| expand_pattern_value(value) }
+      end
+    else
+      expand_pattern_value(obj)
+    end
+  end
+
+  def self.expand_pattern_value(value)
+    if pattern_value?(value)
+      generate_pattern(value)
+    elsif value.is_a?(Hash) || value.is_a?(Array)
+      expand_patterns(value)
+    else
+      value
+    end
+  end
+
+  def self.generate_pattern(value)
+    NiceHash.generate({ pattern: value })[:pattern]
+  end
+
+  def self.pattern_symbol?(value)
+    return false unless value.is_a?(Symbol)
+    return true if SHORTHANDS.include?(value)
+
+    text = value.to_s
+    text.match?(PATTERN_SYMBOL) || text.match?(SELECTOR_SYMBOL)
+  end
+
+  def self.checksum_array?(value)
+    value.is_a?(Array) && value.size.between?(1, 2) && [:iban, :luhn].include?(value[0])
+  end
+
+  def self.one_pattern_array?(value)
+    return false unless value.is_a?(Array) && value.size == 1
+    return false if checksum_array?(value)
+
+    element = value[0]
+    return false unless element.is_a?(Symbol)
+
+    StringPattern.analyze(element, silent: true).is_a?(StringPattern::Pattern)
+  rescue StandardError
+    false
+  end
+
+  private_class_method :expand_pattern_value, :generate_pattern, :pattern_symbol?, :checksum_array?, :one_pattern_array?
+end

data/lib/nice_http/validate_response.rb

@@ -5,8 +5,13 @@ class NiceHttp
   #
   # @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.
+  # @param options [Hash] Optional. :include_diff => true adds a diff when validation fails.
+  #   :explain => true adds NiceHash pattern errors when a pattern in expected_structure does not match.
+  #   String keys in expected_structure are treated the same as symbol keys.
+  #   Pattern checks run only when expected_structure contains pattern symbols, shorthands
+  #   (:uuid, :email, :iban, :luhn), checksum pairs, a one-element pattern array, a Range, a Regexp, DateTime or Boolean.
+  #   A plain string such as "10:N" stays a literal and is not validated as a pattern.
+  # @return [Hash] { ok: true } when it matches, or { ok: false } with optional :diff and :explain.
   # @example
   #   resp = http.get("/api/users/1")
   #   result = NiceHttp.validate_response(resp, { user: { name: "xxx", id: 1 } })
@@ -14,6 +19,9 @@ class NiceHttp
   # @example
   #   result = NiceHttp.validate_response(resp, expected, include_diff: true)
   #   puts result[:diff] unless result[:ok]
+  # @example
+  #   result = NiceHttp.validate_response(resp, { email: :email }, explain: true)
+  #   result[:explain][:email][:message] unless result[:ok]
   ######################################################
   def self.validate_response(resp, expected_structure, options = {})
     data = resp.is_a?(Hash) ? resp[:data] : resp.data
@@ -30,14 +38,31 @@ class NiceHttp
         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)
+    # Normalize to symbol keys so compare_structure/diff match either string or symbol keys
     parsed = deep_symbolize(parsed) if parsed.is_a?(Hash) || parsed.is_a?(Array)
+    expected = if expected_structure.is_a?(Hash) || expected_structure.is_a?(Array)
+        deep_symbolize(expected_structure)
+      else
+        expected_structure
+      end
 
-    ok = NiceHash.compare_structure(expected_structure, parsed)
+    pattern_errors = {}
+    if NiceHttpUtils.contains_pattern?(expected)
+      comparable = NiceHttpUtils.structure_without_patterns(expected, parsed)
+      ok = NiceHash.compare_structure(comparable, parsed)
+      wrapped = NiceHash.validate({ root: expected }, { root: parsed }, only_patterns: true, explain: options[:explain] ? true : false)
+      pattern_errors = wrapped.is_a?(Hash) && wrapped.key?(:root) ? wrapped[:root] : wrapped
+      ok &&= pattern_errors.respond_to?(:empty?) && pattern_errors.empty?
+    else
+      ok = NiceHash.compare_structure(expected, parsed)
+    end
 
     result = { ok: ok }
     if !ok && options[:include_diff]
-      result[:diff] = NiceHash.diff(expected_structure, parsed)
+      result[:diff] = NiceHash.diff(expected, parsed)
+    end
+    if !ok && options[:explain] && pattern_errors.respond_to?(:empty?) && !pattern_errors.empty?
+      result[:explain] = pattern_errors
     end
     result
   end

data/lib/nice_http.rb

@@ -16,6 +16,7 @@ require_relative "nice_http/utils/basic_authentication"
 require_relative "nice_http/utils/get_value_xml_tag"
 require_relative "nice_http/utils/set_value_xml_tag"
 require_relative "nice_http/utils/set_lambdas"
+require_relative "nice_http/utils/expand_patterns"
 require_relative "nice_http/reset"
 require_relative "nice_http/add_stats"
 require_relative "nice_http/defaults"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nice_http
 version: !ruby/object:Gem::Version
-  version: 1.10.1
+  version: 1.11.0
 platform: ruby
 authors:
 - Mario Ruiz
@@ -15,20 +15,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.19'
+        version: '1.21'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.19.0
+        version: 1.21.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.19'
+        version: '1.21'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.19.0
+        version: 1.21.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -83,6 +83,7 @@ files:
 - lib/nice_http/reset.rb
 - lib/nice_http/save_stats.rb
 - lib/nice_http/utils/basic_authentication.rb
+- lib/nice_http/utils/expand_patterns.rb
 - 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
@@ -99,7 +100,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.7'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="