rspec-json_matchers 0.1.0.alpha.3 → 0.1.0.alpha.4

data/.travis.yml

@@ -2,18 +2,27 @@
 # http://docs.travis-ci.com/user/workers/container-based-infrastructure/
 sudo: false
 language: ruby
+before_install:
+  # This is required since 2.6.8 has issue when installing `rainbow`
+  # https://github.com/sickill/rainbow/issues/48
+  - gem update --system
+  - gem --version
 cache:
   - bundler
 rvm:
-  - 2.0
-  - 2.1
-  - 2.2
+  - 2.1.10
+  - 2.2.6
+  - 2.3.3
+  - 2.4.0
   - ruby-head
 gemfile:
   - gemfiles/rspec_3_0.gemfile
   - gemfiles/rspec_3_1.gemfile
   - gemfiles/rspec_3_2.gemfile
   - gemfiles/rspec_3_3.gemfile
+  - gemfiles/rspec_3_4.gemfile
+  - gemfiles/rspec_3_5.gemfile
+  - gemfiles/rspec_3_6.gemfile
 matrix:
   fast_finish: true
   allow_failures:

data/Appraisals

@@ -1,16 +1,36 @@
 
 appraise "rspec_3_0" do
-  gem "rspec", "3.0"
+  gem "rspec", "~> 3.0.0"
+  # https://github.com/rspec/rspec-core/issues/2205
+  gem "rake", "< 12"
 end
 
 appraise "rspec_3_1" do
-  gem "rspec", "3.1"
+  gem "rspec", "~> 3.1.0"
+  # https://github.com/rspec/rspec-core/issues/2205
+  gem "rake", "< 12"
 end
 
 appraise "rspec_3_2" do
-  gem "rspec", "3.2"
+  gem "rspec", "~> 3.2.0"
+  # https://github.com/rspec/rspec-core/issues/2205
+  gem "rake", "< 12"
 end
 
 appraise "rspec_3_3" do
-  gem "rspec", "3.3"
+  gem "rspec", "~> 3.3.0"
+  # https://github.com/rspec/rspec-core/issues/2205
+  gem "rake", "< 12"
+end
+
+appraise "rspec_3_4" do
+  gem "rspec", "~> 3.4.0"
+end
+
+appraise "rspec_3_5" do
+  gem "rspec", "~> 3.5.0"
+end
+
+appraise "rspec_3_6" do
+  gem "rspec", ">= 3.6.0.beta2", "< 3.7.0"
 end

data/Gemfile

@@ -1,3 +1,4 @@
+# rubocop:disable Style/MethodCallWithArgsParentheses
 source "https://rubygems.org"
 
 # Specify your gem's dependencies in rspec-json_matchers.gemspec

data/README.md

@@ -114,14 +114,6 @@ specify { expect({a: 1, b: 2}.to_json).to be_json.with_content({a: 1}) }  # => p
 specify { expect({a: 1}.to_json).to be_json.with_content({a: 1, b: 2}) }  # => fail
 ```
 
-It's possible to make examples fail when the object represented by JSON string in `subject`
-contains more keys than that in expectation using `with_exact_keys`.
-
-```ruby
-# The spec can be set to fail when actual has more keys than expected
-specify { expect({a: 1, b: 2}.to_json).to be_json.with_content({a: 1}).with_exact_keys }  # => fail
-```
-
 A "path" can also be specified for testing deeply nested data.
 
 ```ruby
@@ -476,32 +468,57 @@ specify do
 end # => fail
 ```
 
+It's possible to make examples fail when the object represented by JSON string in `subject`
+contains more keys than that in expectation using `HashWithContent` & `#with_exact_keys`.  
+`HashWithContent` is the expectation class that is automatically used when a `Hash` is passed.
+
+
+```ruby
+# The spec can be set to fail when actual has more keys than expected
+specify do
+  expect({a: 1, b: 2}.to_json).
+    to be_json.
+    with_content(
+      expectations::HashWithContent[{a: 1}].with_exact_keys
+    )
+  # => fail
+end
+```
+
+#### Custom/Complex Expectations NOT included on purpose
+
+##### Date
+In [`airborne`](https://github.com/brooklynDev/airborne) you can validate the value as a "date" (and "time").  
+However "date/time" is not part of the JSON specification.  
+Some people use a string with a format specified in ISO to represent a time, but a [Unix time](https://en.wikipedia.org/wiki/Unix_time).  
+So this gem does not try to be "smart" to have a "generic" expectation for "date/time".  
+New expectations might be added in the future, to the core gem or a new extension gem, for common formats of "date" values.  
+There is no clear schedule for the addition yet, so you should try to add your own expectation class to suit your application.  
+
 
 ### Matcher `be_json.with_sizes`
 
-This is a more convenient version of using `be_json.with_sizes` only with `ArrayWithSize`.  
-Since you can just pass `Fixnum`, `Bignum` or `Range` without typing `ArrayWithSize`.  
-Things like `with_exact_keys` & `at_path` can still be used.  
+Used to have in earlier alpha versions.
+Indended to ease the migration from other gems but 
+it also makes the gem more difficult to maintain.
+Removed in later alpha version(s).
+
+Just use `ArrayWithSize`
+
 
 ```ruby
 specify do
   expect({a: [1]}.to_json).to be_json.
-    with_sizes(a: 1)
+    with_content(a: ArrayWithSize[1])
 end # => pass
 specify do
   expect({a: [1]}.to_json).to be_json.
-    with_sizes(a: (0..2))
+    with_content(a: ArrayWithSize[(0..2)])
 end # => pass
 specify do
   expect({a: [1]}.to_json).to be_json.
-    with_sizes(a: 1.1)
+    with_content(a: ArrayWithSize[1.1])
 end # => error
-
-# But you can no longer pass multiple "expectations" for `AnyOf` behaviour
-specify do
-  expect({a: [1]}.to_json).to be_json.
-    with_content(a: [0, 1, 3])
-end # => fail, expects {a: [[], [1], [1, 2, 3]])
 ```
 
 

data/Rakefile

@@ -1,3 +1,4 @@
+# rubocop:disable Style/MethodCallWithArgsParentheses
 require "appraisal"
 require "rubygems"
 require "bundler/gem_tasks"

data/gemfiles/rspec_3_0.gemfile

@@ -2,6 +2,7 @@
 
 source "https://rubygems.org"
 
-gem "rspec", "3.0"
+gem "rspec", "~> 3.0.0"
+gem "rake", "< 12"
 
 gemspec :path => "../"

data/gemfiles/rspec_3_1.gemfile

@@ -2,6 +2,7 @@
 
 source "https://rubygems.org"
 
-gem "rspec", "3.1"
+gem "rspec", "~> 3.1.0"
+gem "rake", "< 12"
 
 gemspec :path => "../"

data/gemfiles/rspec_3_2.gemfile

@@ -2,6 +2,7 @@
 
 source "https://rubygems.org"
 
-gem "rspec", "3.2"
+gem "rspec", "~> 3.2.0"
+gem "rake", "< 12"
 
 gemspec :path => "../"

data/gemfiles/rspec_3_3.gemfile

@@ -2,6 +2,7 @@
 
 source "https://rubygems.org"
 
-gem "rspec", "3.3"
+gem "rspec", "~> 3.3.0"
+gem "rake", "< 12"
 
 gemspec :path => "../"

data/gemfiles/rspec_3_4.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rspec", "~> 3.4.0"
+
+gemspec :path => "../"

data/gemfiles/rspec_3_5.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rspec", "~> 3.5.0"
+
+gemspec :path => "../"

data/gemfiles/rspec_3_6.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rspec", ">= 3.6.0.beta2", "< 3.7.0"
+
+gemspec :path => "../"

data/lib/rspec/json_matchers/expectation.rb

@@ -91,10 +91,13 @@ module RSpec
         OBJECT_CLASS_TO_EXPECTATION_HASH = {
           Regexp => -> (obj) { Expectations::Private::MatchingRegexp[obj] },
           Range => -> (obj) { Expectations::Private::InRange[obj] },
+          Hash => -> (obj) { Expectations::Mixins::BuiltIn::HashWithContent[obj] },
         }.freeze
         private_constant :OBJECT_CLASS_TO_EXPECTATION_HASH
 
-        attr_reader(*[:object])
+        attr_reader(
+          :object,
+        )
 
         def expectation_by_class
           if instance_variable_defined?(:@expectation_by_object_class)
@@ -104,7 +107,8 @@ module RSpec
           proc = OBJECT_CLASS_TO_EXPECTATION_HASH[object.class]
           return nil if proc.nil?
 
-          proc.call(object)
+          # Assign (cache) and return
+          @expectation_by_object_class = proc.call(object)
         end
 
         def expectation_by_ancestors

data/lib/rspec/json_matchers/expectations/mixins/built_in.rb

@@ -1,3 +1,4 @@
+require "set"
 require "abstract_class"
 
 require_relative "../core"
@@ -150,11 +151,22 @@ module RSpec
           class ArrayWithSize < AnyOf
             # `Fixnum` & `Bignum` will be returned instead of `Integer`
             # in `#class` for numbers
-            EXPECTED_VALUE_CLASS_TO_EXPECTATION_CLASS_MAPPING = {
-              Fixnum  => -> (v) { Expectations::Private::Eq[v] },
-              Bignum  => -> (v) { Expectations::Private::Eq[v] },
-              Range   => -> (v) { Expectations::Private::InRange[v] },
-            }.freeze
+            # But since 2.4.x it will be `Integer`
+            EXPECTED_VALUE_CLASS_TO_EXPECTATION_CLASS_MAPPING = begin
+              {
+                Range   => -> (v) { Expectations::Private::InRange[v] },
+                Integer => -> (v) { Expectations::Private::Eq[v] },
+              }.tap do |result_hash|
+                # This fix is similar to
+                # https://github.com/rails/rails/pull/26732
+                next if 1.class == Integer
+
+                result_hash.merge!(
+                  Fixnum => -> (v) { Expectations::Private::Eq[v] },
+                  Bignum => -> (v) { Expectations::Private::Eq[v] },
+                )
+              end
+            end.freeze
             private_constant :EXPECTED_VALUE_CLASS_TO_EXPECTATION_CLASS_MAPPING
 
             class << self
@@ -182,6 +194,73 @@ module RSpec
                 super(value.size)
             end
           end
+
+          # Takes a {Hash}
+          # Validates `value` to be {Hash} and
+          # contain expected keys & values
+          # Extra keys in `value` will not be treated as "unexpected"
+          # Unless {#with_exact_keys} is used
+          class HashWithContent < Expectations::Core::SingleValueCallableExpectation
+            EXPECTED_CLASS = ::Hash
+            private_constant :EXPECTED_CLASS
+
+            def expect?(value)
+              matches_expected_class?(value) &&
+                matches_content_expectations?(value) &&
+                matches_keys_exactly?(value)
+            end
+
+            # After calling this method
+            # Any extra key in `value` will be marked as "unexpected"
+            #
+            # By default the expectation won't care about extra keys in `value`
+            def with_exact_keys
+              @require_exact_key_matches = true
+              self
+            end
+
+            private
+
+            attr_reader :require_exact_key_matches
+            alias_method(
+              :require_exact_key_matches?,
+              :require_exact_key_matches,
+            )
+            attr_reader :expected_value
+
+            def matches_expected_class?(value)
+              value.is_a?(::Hash)
+            end
+
+            def matches_keys_exactly?(actual_value)
+              return true unless require_exact_key_matches?
+
+              ::Set.new(expected_value.keys.map(&:to_s)) ==
+                ::Set.new(actual_value.keys.map(&:to_s))
+            end
+
+            def matches_content_expectations?(actual_value)
+              expected_value.each_pair.all? do |exp_key, exp_value|
+                unless actual_value.key?(exp_key) ||
+                    actual_value.key?(exp_key.to_s)
+                  return false
+                end
+
+                value_from_actual = actual_value.fetch(exp_key) do
+                  actual_value.fetch(exp_key.to_s)
+                end
+                Expectation.build(exp_value).expect?(value_from_actual)
+              end
+            end
+
+            def initialize(value)
+              unless value.is_a?(::Hash)
+                fail ArgumentError, "a #{EXPECTED_CLASS} is required"
+              end
+
+              @expected_value = value
+            end
+          end
         end
       end
     end

data/lib/rspec/json_matchers/expectations/private.rb

@@ -135,8 +135,10 @@ module RSpec
 
           def initialize(value)
             unless value.respond_to?(:call)
-              fail ArgumentError,
-                "an object which respond to `:call` is required"
+              fail(
+                ArgumentError,
+                "an object which respond to `:call` is required",
+              )
             end
             @callable = value
           end

data/lib/rspec/json_matchers/matchers.rb

@@ -1,6 +1,5 @@
 require_relative "matchers/be_json_matcher"
 require_relative "matchers/be_json_with_content_matcher"
-require_relative "matchers/be_json_with_sizes_matcher"
 
 module RSpec
   module JsonMatchers

data/lib/rspec/json_matchers/matchers/be_json_matcher.rb

@@ -45,19 +45,6 @@ module RSpec
           BeJsonWithContentMatcher.new(expected)
         end
 
-        # @api
-        #
-        # Get a matcher that try to match the content of actual
-        # with nested expectations about array sizes
-        #
-        # @param expected [Hash, Array, Object]
-        #   the expectation object
-        #
-        # @return [BeJsonWithSizesMatcher] a matcher object
-        def with_sizes(expected)
-          BeJsonWithSizesMatcher.new(expected)
-        end
-
         # Expectation description in spec result summary
         #
         # @return [String]
@@ -95,4 +82,3 @@ end
 # since the classes are only required
 # on runtime but not load time
 require_relative "be_json_with_content_matcher"
-require_relative "be_json_with_sizes_matcher"

data/lib/rspec/json_matchers/matchers/be_json_with_content_matcher.rb

@@ -1,19 +1,158 @@
 require "json"
 require "awesome_print"
 
-require_relative "be_json_with_something_matcher"
-require_relative "../comparers"
+require_relative "be_json_matcher"
 require_relative "../utils"
 
 module RSpec
   module JsonMatchers
     module Matchers
       # @api private
-      class BeJsonWithContentMatcher < BeJsonWithSomethingMatcher
+      # @abstract
+      #
+      # Parent of matcher classes that requires {#at_path} & {#with_exact_keys}
+      # This is not merged with {BeJsonMatcher}
+      # since it should be able to be used alone
+      class BeJsonWithContentMatcher < BeJsonMatcher
+        attr_reader(
+          :path,
+        )
+
+        def initialize(expected)
+          @expected     = expected
+          @path         = JsonMatchers::Utils::KeyPath::Path.new("")
+        end
+
+        def matches?(*_args)
+          super && has_valid_path? && expected_and_actual_matched?
+        end
+
+        def does_not_match?(*args)
+          !matches?(*args) && has_valid_path?
+        end
+
+        # Override {BeJsonMatcher#actual}
+        # It return actual object extracted by {#path}
+        # And also detect & set state for path error
+        # (either it's invalid or fails to extract)
+        #
+        # @return [Object]
+        #   extracted object but could be object in the middle
+        #   when extraction failed
+        def actual
+          result = path.extract(super)
+          has_path_error! if result.failed?
+          result.object
+        end
+
+        # Sets the path to be used for object,
+        # to avoid passing a deep nested
+        # {Hash} or {Array} as expectation
+        # Defaults to "" (if this is not called)
+        #
+        # The path uses period (".") as separator for parts
+        # Also period cannot be used as path name as a side-effect
+        #
+        # This does NOT raise error if the path is invalid
+        # (like having 2 periods, 1 period at the start/end of string)
+        # But it will fail the example with both `should` & `should_not`
+        #
+        # @param path [String] the "path" to be used
+        #
+        # @return [BeJsonWithSomethingMatcher] the match itself
+        #
+        # @throw [TypeError] when input is not a string
+        def at_path(path)
+          @path = JsonMatchers::Utils::KeyPath::Path.new(path)
+          self
+        end
+
+        # Overrides {BeJsonMatcher#failure_message}
+        def failure_message
+          return super if has_parser_error?
+          failure_message_for(true)
+        end
+
+        # Overrides {BeJsonMatcher#failure_message_when_negated}
+        def failure_message_when_negated
+          return super if has_parser_error?
+          failure_message_for(false)
+        end
+
         private
 
-        def value_matching_proc
-          -> (expected, actual) { Expectation.build(expected).expect?(actual) }
+        attr_reader(
+          :expected,
+        )
+
+        def failure_message_for(should_match)
+          return invalid_path_message unless has_valid_path?
+          return path_error_message if has_path_error?
+
+          inspection_messages(should_match)
+        end
+
+        # @return [Bool] Whether `expected` & `parsed` are "equal"
+        def expected_and_actual_matched?
+          extracted_actual = actual
+          return false if has_path_error?
+
+          expectation = Expectation.build(expected)
+          expectation.expect?(extracted_actual)
+        end
+
+        def reasons
+          @reasons ||= []
+        end
+
+        def inspection_messages(should_match)
+          [
+            ["expected", inspection_messages_prefix(should_match), "to match:"].
+              compact.map(&:strip).join(" "),
+            expected.awesome_inspect(indent: -2),
+            "",
+            "actual:",
+            actual.awesome_inspect(indent: -2),
+            "",
+            inspection_message_for_reason,
+          ].join("\n")
+        end
+
+        def inspection_messages_prefix(should_match)
+          should_match ? nil : "not"
+        end
+
+        def inspection_message_for_reason
+          reasons.any? ? "reason/path: #{reasons.reverse.join('.')}" : nil
+        end
+
+        def original_actual
+          @actual
+        end
+
+        def has_path_error?
+          @has_path_error
+        end
+
+        def has_path_error!
+          @has_path_error = true
+        end
+
+        # For both positive and negative
+        def path_error_message
+          [
+            %(path "#{path}" does not exists in actual: ),
+            original_actual.awesome_inspect(indent: -2),
+          ].join("\n")
+        end
+
+        def has_valid_path?
+          (path.nil? || path.valid?)
+        end
+
+        # For both positive and negative
+        def invalid_path_message
+          %(path "#{path}" is invalid)
         end
       end
     end