spaceborne 0.1.33 → 0.1.37

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f58273cad226d88a4d39c7065f1c1628990f779024ca7e4c4a5456b8381c033d
-  data.tar.gz: 19eae317b4a2cd4a69a14b5e2afe8f721c08728ead59ff6a6cba732c4722afbd
+  metadata.gz: 8713e4121c4170d47c98acc0c85efbd98bdc8d891f7f977fc792cbeddacc7435
+  data.tar.gz: 147f591492eb63348d02e0c88cb19086fd39e8d61851e6d82d86d0f3d45ae62d
 SHA512:
-  metadata.gz: 41c07d21fdd9bad257bff28db8c911e3339846e1691cf72ebeedb26d0ab1afd3253a731d7d847af00f9b32a15b7cf4f8e6bda9eab5271c8a32388858e9858333
-  data.tar.gz: e60a31d5d9ad75915c4ef6d31615b96e8ca45c22b40dd0eb3ad77c7f91fcf4163a6f95c1ce4abff8c98b35b717d978c6d968223a7200368849b84cef28a2e2a8
+  metadata.gz: a29ff847e0b2c67e3d55799b3b933e6d448cc817a6a2e1365b23f0b92a1cb65fc8ece56d6142cb8eaf13baf1e84e090875b17fc641137942669174b78761ce66
+  data.tar.gz: 77b947419bc8c04318e0cb07ac47d122844f5e0a3ad1c0ceb993264f4966e99e54b0ca38b974a112dc9d94578b8a29547b0acaa9a09f2083546899d04d5b3276

data/README.md

@@ -206,26 +206,35 @@ Validation for headers follows the same pattern as above, although nesting of mu
 5. It is possible to use non-json data in a request
 6. Expectations on a response with an array of hashes with keys that are unknown, but that have a defined structure are supported (using the '*' in a path)
 7. Responses that have header with Content-Encoding of gzip are gunzip'd in json_body
+8. For type checks specified in a path containing array(s), you can make the path optional, so that if the data is present it is type checked, but an empty array or element without the array is fine
 
-The following example shows how extension # 6 works
+The following example shows how extensions # 6 & 8 work
 
 ```ruby
 { "array_of_hashes": [
-   { "husband": {"first": "fred", "last": "flinstone"}},
-   { "buddy": {"first": "barney", "last": "rubble"}},
-   { "wife": {"first": "wilma", "last": "flinstone"}}
+    { "husband": {"first": "fred", "last": "flinstone"}},
+    { "buddy": {"first": "barney", "last": "rubble"}},
+    { "wife": {"first": "wilma", "last": "flinstone"}}
   ],
   "hash_of_hashes": 
-   { "husband": {"first": "fred", "last": "flinstone"},
-     "buddy": {"first": "barney", "last": "rubble"},
-     "wife": {"first": "wilma", "last": "flinstone"}
-  }
+  { "husband": {"first": "fred", "last": "flinstone"},
+    "buddy": {"first": "barney", "last": "rubble"},
+    "wife": {"first": "wilma", "last": "flinstone"}
+  },
+  "lowest_array": [{ "array": [{ "present": "name" }]},
+		   { "array": null },
+		   { "array": [] },
+		   { "foo": "bar" }],
+  "highest_array": [ null,
+		     { "array": [{ "present": "name" }]}]
 }
 ```
 You can now validate the fact that each element in the collection has a key which is variant, but a value that has a defined format (the first and last field values are strings).
 
     expect_json_types('array_of_hashes.*.*', first: :string, last: :string)
     expect_json_types('hash_of_hashes.*', first: :string, last: :string)
+	expect_json_types(optional('lowest_array.*.array.*'), present: :string)
+	expect_json_types(optional('highest_array.*.array.*'), present: :string)
 
 
 ## Development

data/lib/spaceborne.rb

@@ -26,7 +26,7 @@ module Spaceborne
   end
 
   def add_response
-    "RESPONSE: #{response.code}\n"\
+    "\nRESPONSE: #{response.code}\n"\
     "  HEADERS:\n#{JSON.pretty_generate(response.headers)}\n"\
     << response_body
   end
@@ -51,8 +51,7 @@ module Spaceborne
   rescue Exception => e
     raise e unless response
 
-    e.message << request_info
-    raise e
+    raise RSpec::Expectations::ExpectationNotMetError, e.message + request_info
   end
 end
 
@@ -228,44 +227,75 @@ module Airborne
     end
 
     def handle_type(type, path, json, &block)
-      if type == '*'
+      case type
+      when '*'
         handle_container(json, &block)
-      elsif type == '?'
+      when '?'
         expect_one(path, json, &block)
       else
         yield json
       end
     end
 
+    def path_to_s(path)
+      path.is_a?(Airborne::OptionalHashTypeExpectations) ? path.hash.to_s : path
+    end
+
+    def make_path_optional(path, sub_path)
+      if path.is_a?(Airborne::OptionalHashTypeExpectations)
+        Airborne::OptionalHashTypeExpectations.new(sub_path)
+      else
+        sub_path
+      end
+    end
+
     def iterate_path(path)
-      raise PathError, "Invalid Path, contains '..'" if /\.\./ =~ path
+      raise PathError, "Invalid Path, contains '..'" if /\.\./ =~ path_to_s(path)
 
-      parts = path.to_s.split('.')
+      parts = path_to_s(path).to_s.split('.')
       parts.each_with_index do |part, index|
-        yield(parts, part, index)
+        use_part = make_path_optional(path, part)
+        yield(parts, use_part, index)
       end
     end
 
-    def get_by_path(path, json, type = false, &block)
+    def get_by_path(path, json, type: false, &block)
       iterate_path(path) do |parts, part, index|
-        if %w[* ?].include?(part)
+        if %w[* ?].include?(path_to_s(part))
           ensure_array_or_hash(path, json)
           type = part
           walk_with_path(type, index, path, parts, json, &block) && return if index < parts.length.pred
 
           next
         end
-        json = do_process_json(part, json)
+        json = do_process_json(path_to_s(part), json)
       end
       handle_type(type, path, json, &block)
     end
 
     def ensure_array_or_hash(path, json)
-      return if json.class == Array || json.class == Hash
+      return if json.instance_of?(Array) || json.instance_of?(Hash)
 
       raise RSpec::Expectations::ExpectationNotMetError,
             "Expected #{path} to be array or hash, got #{json.class}"\
             ' from JSON response'
     end
+
+    def walk_with_path(type, index, path, parts, json, &block)
+      last_error = nil
+      item_count = json.length
+      error_count = 0
+      json.each do |element|
+        begin
+          sub_path = parts[(index.next)...(parts.length)].join('.')
+          get_by_path(make_path_optional(path, sub_path), element, &block)
+        rescue Exception => e
+          last_error = e
+          error_count += 1
+        end
+        ensure_match_all(last_error) if type == '*'
+        ensure_match_one(path, item_count, error_count) if type == '?'
+      end
+    end
   end
 end

data/lib/spaceborne/version.rb

@@ -1,3 +1,3 @@
 module Spaceborne
-  VERSION = '0.1.33'.freeze
+  VERSION = '0.1.37'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spaceborne
 version: !ruby/object:Gem::Version
-  version: 0.1.33
+  version: 0.1.37
 platform: ruby
 authors:
 - Keith Williams
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-07-01 00:00:00.000000000 Z
+date: 2021-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -200,7 +200,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
+rubygems_version: 3.0.9
 signing_key:
 specification_version: 4
 summary: Gem supporting API testing