spaceborne 0.1.34 → 0.1.38

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed2b70eae7ff4cd66202c0ef963bf539cdac37d658f129477a6af64b4d67b539
-  data.tar.gz: 1d2a5c1459ceb279de96815c6943d792c21fc6cef570360798899022c44e3232
+  metadata.gz: d742ea06ad022126a7a61fb008131b02d0f0f1db485d832570b85f845299c655
+  data.tar.gz: d7d452c83c164adebc69df71aef6aa2f12d50375be2e354463f7b7789b07c290
 SHA512:
-  metadata.gz: b3202e108670a8f93f764c17fe2016ba6f424de12deb4f558cc130cfd0c0da77bfc0772f8f5a1b1f851fab6a557795fb95c45dc06d135b4b1ba2c52e6204c628
-  data.tar.gz: 283767a387e194d8b73ba03a031a576be66da89adc0ee4e69d6d625566d5121b34531fb50cfc254a55af4760d60eb90c9052a9c3fb08f95561e48b9d65f9827a
+  metadata.gz: 7e16b9d1bc60eabc5257afb91510d4a715bd8ce76acccc820a255a96ad4b19f87732360d98e3dfbfcfd0f53bd2d7524a72868602df29b2bc5fa871a15128e40e
+  data.tar.gz: 0bac75438755e532b9d39c10864d91430d9a7d281f7d89b9ee1d1943ab7951381432fb0e48ccd39bbc95725dafb8db93a99ba4edc9a53eebec3d6c4bc8e15e59

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

@@ -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
 
@@ -157,6 +156,22 @@ module Airborne
 
   # Extend airborne's expectations
   module RequestExpectations
+    class OptionalPathExpectations
+      def initialize(string)
+        @string = string
+      end
+      def to_s
+        @string.to_s
+      end
+    end
+
+    def do_process_json(part, json)
+      json = process_json(part, json)
+    rescue StandardError
+      raise PathError,
+            "Expected #{json.class}\nto be an object with property #{part}"
+    end
+
     def call_with_relative_path(data, args)
       if args.length == 2
         get_by_path(args[0], data) do |json_chunk|
@@ -205,17 +220,18 @@ module Airborne
         end
       end
     end
+
+    def optional(data)
+      if data.is_a?(Hash)
+        OptionalHashTypeExpectations.new(data)
+      else
+        OptionalPathExpectations.new(data)
+      end
+    end
   end
 
   # extension to handle hash value checking
   module PathMatcher
-    def do_process_json(part, json)
-      json = process_json(part, json)
-    rescue StandardError
-      raise PathError,
-            "Expected #{json.class}\nto be an object with property #{part}"
-    end
-
     def handle_container(json, &block)
       case json.class.name
       when 'Array'
@@ -228,44 +244,71 @@ 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 make_sub_path_optional(path, sub_path)
+      if path.is_a?(Airborne::OptionalPathExpectations)
+        Airborne::OptionalPathExpectations.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
 
       parts = path.to_s.split('.')
       parts.each_with_index do |part, index|
-        yield(parts, part, index)
+        use_part = make_sub_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?(part.to_s)
           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(part.to_s, 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_sub_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.34'.freeze
+  VERSION = '0.1.38'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spaceborne
 version: !ruby/object:Gem::Version
-  version: 0.1.34
+  version: 0.1.38
 platform: ruby
 authors:
 - Keith Williams
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-07-09 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