spaceborne 0.1.36 → 0.1.40

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8aff74d5d3bedfe5854840e95db163e1c1cd71849172d21f01067ec952b29451
-  data.tar.gz: 6bbc1007251b0c9415d74dd838c5ea9182a9d3063d778f3c15791026a10f4537
+  metadata.gz: c11204f7139c5e5507dfae5c022cfbacaa4f09d9311b85c3e32824497b5e0828
+  data.tar.gz: 785da01072d57bb89c32fc9c021c42a0b188c1f2a188843b5c86e011a1bbac69
 SHA512:
-  metadata.gz: 57eefe3812beebd37b2a6e879ce8b518c99fff0cb434779a122dab68b911c7ba355306009421455bac34f02ee1becde5b1bb237908678cf7b6f5d527a7973e75
-  data.tar.gz: e9bb102e8fe35b2e65046c7bd8e7b25ff60f8bcce8173bf88da60816ea14add4df1019cd62530fd31aefe147966ead18a2675d57afd48af940fb54aaa001c695
+  metadata.gz: '090ba089dd166f14cd0dc259fc9887982493e4e433beafd12bb0e645e6fa2deaaade5d183868463e5325ab926508dd799e42bed866cc337004a0f196f2a8b87e'
+  data.tar.gz: a537d9b3bc27c998931ed409481f39cea26c2efcda803d5556848dc8f8fcca8559628ef03223b02db214cc17970794c3f6f6c0469187af91933f4ccdffc7f7a1

data/.rubocop.yml

@@ -1,3 +1,6 @@
+AllCops:
+  SuggestExtensions: false
+
 Style/FrozenStringLiteralComment:
   Enabled: false
 
@@ -23,7 +26,7 @@ Metrics/ClassLength:
   Exclude:
     - 'bin/*'
 
-Metrics/LineLength:
+Layout/LineLength:
   Exclude:
     - 'spec/airborne/**/*.rb'
 

data/README.md

@@ -206,26 +206,36 @@ 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" }]}],
+  "not_an_array":  null
 }
 ```
 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/version.rb

@@ -1,3 +1,3 @@
 module Spaceborne
-  VERSION = '0.1.36'.freeze
+  VERSION = '0.1.40'.freeze
 end

data/lib/spaceborne.rb

@@ -51,7 +51,7 @@ module Spaceborne
   rescue Exception => e
     raise e unless response
 
-    raise RSpec::Expectations::ExpectationNotMetError.new(e.message + request_info)
+    raise RSpec::Expectations::ExpectationNotMetError, e.message + request_info
   end
 end
 
@@ -156,6 +156,24 @@ module Airborne
 
   # Extend airborne's expectations
   module RequestExpectations
+    # class used for holding an optional path
+    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|
@@ -204,17 +222,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'
@@ -227,44 +246,76 @@ module Airborne
     end
 
     def handle_type(type, path, json, &block)
-      if type == '*'
+      case type.to_s
+      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 shortcut_validation(path, json)
+      json.nil? && path.is_a?(Airborne::OptionalPathExpectations)
+    end
+
+    def get_by_path(path, json, type: false, &block)
       iterate_path(path) do |parts, part, index|
-        if %w[* ?].include?(part)
-          ensure_array_or_hash(path, json)
+        return if shortcut_validation(path, json)
+
+        if %w[* ?].include?(part.to_s)
           type = part
-          walk_with_path(type, index, path, parts, json, &block) && return if index < parts.length.pred
+          walk_with_path(type.to_s, 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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spaceborne
 version: !ruby/object:Gem::Version
-  version: 0.1.36
+  version: 0.1.40
 platform: ruby
 authors:
 - Keith Williams
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-07-12 00:00:00.000000000 Z
+date: 2021-08-23 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