rspec-resembles_json_matchers 0.5.0

data/lib/rspec/resembles_json_matchers.rb

@@ -0,0 +1,57 @@
+require "rspec/resembles_json_matchers/version"
+
+module RSpec
+  module ResemblesJsonMatchers
+    autoload :AttributeMatcher, "rspec/resembles_json_matchers/attribute_matcher"
+    # autoload :ResemblesMatcher, "rspec/resembles_json_matchers/resembles_matcher"
+    autoload :JsonMatcher,      "rspec/resembles_json_matchers/json_matcher"
+    autoload :Helpers,          "rspec/resembles_json_matchers/helpers"
+    # autoload :Matcherizer,      "rspec/resembles_json_matchers/matcherizer"
+
+    autoload :ResemblesHashMatcher,    "rspec/resembles_json_matchers/resembles_hash_matcher"
+    autoload :ResemblesArrayMatcher,   "rspec/resembles_json_matchers/resembles_array_matcher"
+    autoload :ResemblesAnyOfMatcher,   "rspec/resembles_json_matchers/resembles_any_of_matcher"
+    autoload :ResemblesRouteMatcher,   "rspec/resembles_json_matchers/resembles_route_matcher"
+    autoload :ResemblesDateMatcher,    "rspec/resembles_json_matchers/resembles_date_matcher"
+    autoload :ResemblesNumericMatcher, "rspec/resembles_json_matchers/resembles_numeric_matcher"
+    autoload :ResemblesStringMatcher,  "rspec/resembles_json_matchers/resembles_string_matcher"
+    autoload :ResemblesClassMatcher,   "rspec/resembles_json_matchers/resembles_class_matcher"
+
+    def iso8601_timestamp
+      match(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z/)
+    end
+
+    def match_json(*a)
+      JsonMatcher.new(*a)
+    end
+
+    def have_attribute(*a)
+      AttributeMatcher.new(*a)
+    end
+
+    def resembles(*a)
+      RSpec::ResemblesJsonMatchers.resembles_matcher_for(*a).new(*a)
+    end
+    alias resemble resembles
+    alias resemble_json resembles
+
+    def self.resembles_matcher_candidates
+      # Order matters
+      @candidates ||= [
+        ResemblesHashMatcher,
+        #ResemblesArrayMatcher,
+        ResemblesAnyOfMatcher,
+        ResemblesRouteMatcher,
+        ResemblesDateMatcher,
+        ResemblesNumericMatcher,
+        ResemblesStringMatcher,
+        ResemblesClassMatcher
+      ].freeze
+    end
+
+    def self.resembles_matcher_for(expected, **a)
+      resembles_matcher_candidates.detect { |candidate| candidate.can_match?(expected) }
+    end
+
+  end
+end

data/lib/rspec/resembles_json_matchers/attribute_matcher.rb

@@ -0,0 +1,85 @@
+require "active_support/core_ext/hash/indifferent_access"
+
+module RSpec::ResemblesJsonMatchers
+
+  class AttributeMatcher
+    include RSpec::ResemblesJsonMatchers::Helpers
+
+    attr_reader :attribute_name, :expected, :document
+
+    def initialize(attribute_name, expected = NullMatcher)
+      @attribute_name, @expected = attribute_name, expected
+    end
+
+    def description
+      sentencize "have attribute #{attribute_name.inspect} #{expected.description}"
+    end
+
+    def matches?(document)
+      @document = document.with_indifferent_access
+
+      @document.key?(attribute_name) &&
+        expected.matches?(@document.fetch(attribute_name, nil))
+    end
+
+    def failure_message
+      if expected === NullMatcher
+        msgs = ["Expected attribute",
+                attribute_name.inspect,
+                "to be present"]
+      else
+        msgs = ["Expected value of attribute",
+                attribute_name.inspect,
+                "to",
+                expected.description,
+                "but it was",
+                document[attribute_name].inspect]
+      end
+      sentencize(*msgs)
+    end
+
+    def failure_message_when_negated
+      sentencize "Expected attribute #{attribute_name.inspect}",
+                 expected.description,
+                 "to be absent"
+    end
+
+    NullMatcher = Class.new do
+      def matches?(*_args)
+        true
+      end
+
+      def failure_message
+        ""
+      end
+      alias_method :failure_message_for_should, :failure_message
+
+      def description
+        "be present"
+      end
+
+      def ===(_other)
+        true
+      end
+    end.new
+
+    def matcherize(expected)
+      if matcher? expected
+        expected
+
+      elsif expected.respond_to? :===
+        RSpec::Matchers::Builtin::Match.new(expected)
+
+      else
+        RSpec::Matchers::Builtin::Eq.new(expected)
+      end
+    end
+
+    def matcher?(obj)
+      obj.respond_to(:matches?) && (obj.respond_to?(:failure_message) ||
+                                     obj.respond_to?(:failure_message_for_should))
+    end
+
+  end
+
+end

data/lib/rspec/resembles_json_matchers/helpers.rb

@@ -0,0 +1,29 @@
+require "json"
+
+module RSpec::ResemblesJsonMatchers
+  module Helpers
+    # Returns string composed of the specified clauses with proper
+    # spacing between them. Empty and nil clauses are ignored.
+    def sentencize(*clauses)
+      clauses
+        .flatten
+        .compact
+        .reject(&:empty?)
+        .map(&:strip)
+        .join(" ")
+    end
+
+    def matcherize(expected)
+      if is_matcher? expected
+        expected
+      else
+        RSpec::ResemblesJsonMatchers.resembles_matcher_for(expected).new(expected)
+      end
+    end
+
+    def is_matcher?(obj)
+      obj.respond_to?(:matches?) && obj.respond_to?(:description)
+    end
+
+  end
+end

data/lib/rspec/resembles_json_matchers/json_matcher.rb

@@ -0,0 +1,85 @@
+require "active_support/core_ext/string/indent" # indent
+require "active_support/core_ext/hash/keys"     # stringify_keys
+
+require "json"
+
+module RSpec::ResemblesJsonMatchers
+  class JsonMatcher
+    include RSpec::Matchers::Composable
+    include RSpec::ResemblesJsonMatchers::Helpers
+
+    def initialize(expected_json)
+      @expected_json = expected_json.stringify_keys
+      @failed_matchers = {}
+    end
+
+    def matches?(actual_json)
+      @actual_json = actual_json
+      expected_matchers.each do |expected_key, value_matcher|
+        attr_matcher = AttributeMatcher.new(expected_key, value_matcher)
+        match = attr_matcher.matches?(@actual_json)
+        @failed_matchers[expected_key] = attr_matcher unless match
+      end
+      @failed_matchers.size == 0
+    end
+
+    def description
+      # TODO Figure out how to discover the right indent level
+      "have json that looks like\n#{expected_formatted.indent(6)}"
+    end
+
+    def failure_message
+      msgs = [ "Expected:",
+                pretty_actual.indent(2),
+                "To match:",
+                expected_formatted.indent(2),
+                "Failures:",
+                pretty_errors.indent(2) ]
+      msgs.join("\n")
+    end
+
+    def pretty_json(obj)
+      JSON.pretty_generate(obj)
+    end
+
+    def expected_formatted
+      pretty_json(@expected_json)
+    end
+
+    def pretty_actual
+      pretty_json(@actual_json)
+    end
+
+    def expected_matchers
+      @expected_matchers ||= {}.tap do |hsh|
+        @expected_json.each do |k,v|
+          hsh[k] = v.respond_to?(:description) ? v : RSpec::Matchers::BuiltIn::Eq.new(v)
+        end
+      end
+    end
+
+    def expected_formatted
+      out = "{\n"
+      out << expected_matchers.map do |k,v|
+        case v
+        when RSpec::Matchers::BuiltIn::Eq
+          %{"#{k}": #{v.expected_formatted}}.indent(2)
+        else
+          %{"#{k}": #{v.description}}.indent(2)
+        end
+      end.join(",\n")
+      out << "\n}"
+    end
+
+    def pretty_errors
+      out = "{\n"
+      out << @failed_matchers.map do |k,v|
+        %{"#{k}": #{v.failure_message}}.indent(2)
+      end.join(",\n")
+      out << "\n}"
+    end
+
+  end
+end
+
+

data/lib/rspec/resembles_json_matchers/matcherizer.rb

@@ -0,0 +1,25 @@
+module RSpec::ResemblesJsonMatchers
+
+  module Matcherizer
+    def matcherize(expected)
+      if matcher? expected
+        expected
+
+      elsif expected.is_a?(Hash)
+        RSpec::ResemblesJsonMatchers::JsonMatcher.new(expected)
+
+      elsif expected.respond_to? :===
+        RSpec::Matchers::BuiltIn::Match.new(expected)
+
+      else
+        RSpec::Matchers::BuiltIn::Eq.new(expected)
+      end
+    end
+
+    def matcher?(obj)
+      obj.respond_to?(:matches?) && obj.respond_to?(:description)
+    end
+  end
+
+end
+

data/lib/rspec/resembles_json_matchers/resembles_any_of_matcher.rb

@@ -0,0 +1,61 @@
+require "active_support/core_ext/array/wrap"
+
+module RSpec::ResemblesJsonMatchers
+  class ResemblesAnyOfMatcher
+    include Helpers
+
+    def self.can_match?(array)
+      array.is_a? Array
+    end
+
+    def initialize(expected)
+      @expected = expected
+    end
+
+    def matches?(actual)
+      Array.wrap(actual).flatten.all? do |a|
+        expected_matchers.any? { |m| m.matches? a }
+      end
+    end
+
+    def description
+      if @expected.size == 1
+        "have every item #{expected_matchers.first.description}"
+      else
+        "have every item match one of:\n#{expected_formatted}"
+      end
+    end
+
+    def failure_message
+      sentencize ["Expected every item to match one of:\n",
+                  expected_formatted,
+                  "The item at",
+                  # failed_item_indexes,
+                  "did not because:\n",
+                  failure_messages]
+
+    end
+
+    def expected_matchers
+      @expected.map { |e| matcherize(e) }
+    end
+
+    def expected_formatted
+      "".tap do |out|
+        out << expected_matchers.map do |v|
+          case v
+          when RSpec::Matchers::BuiltIn::Eq
+            "should #{v.description}".indent(2)
+          else
+            "should #{v.description}".indent(2)
+          end
+        end.join("\n")
+      end << "\n"
+    end
+
+    def failure_messages
+    end
+
+  end
+
+end

data/lib/rspec/resembles_json_matchers/resembles_array_matcher.rb

@@ -0,0 +1,35 @@
+
+module RSpec::ResemblesJsonMatchers
+  class ResemblesArrayMatcher
+    include Helpers
+
+    def self.can_match?(array)
+      array.is_a? Array
+    end
+
+    def initialize(expected)
+      @expected = expected
+    end
+
+    def description
+      "resemble #{@expected.inspect}"
+    end
+
+    def matches?(actual)
+      actual.is_a?(Array) && actual.all? do |a|
+        expected_matchers.any? do |e|
+          e.matches? a
+        end
+      end
+    end
+
+    def expected_matchers
+      @expected.map { |e| matcherize(e) }
+    end
+
+    def failure_message
+    end
+  end
+
+
+end

data/lib/rspec/resembles_json_matchers/resembles_class_matcher.rb

@@ -0,0 +1,29 @@
+
+module RSpec::ResemblesJsonMatchers
+  class ResemblesClassMatcher
+    def self.can_match?(klass)
+      klass.is_a? Class
+    end
+
+    def initialize(expected)
+      @expected = expected
+    end
+
+    def description
+      "resemble #{@expected}"
+    end
+
+    def matches?(actual)
+      @actual = actual
+      actual.kind_of? @expected
+    end
+
+    def expected_formatted
+      @expected
+    end
+
+    def failure_message
+      "#{@actual.inspect} does not resemble a #{@expected}"
+    end
+  end
+end

data/lib/rspec/resembles_json_matchers/resembles_date_matcher.rb

@@ -0,0 +1,44 @@
+require "time"
+
+module RSpec::ResemblesJsonMatchers
+  class ResemblesDateMatcher
+    DATE_REGEX = /\A\d{4}-\d{2}-\d{2}\Z/.freeze
+    ISO8601_REGEX = /\A\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z\Z/.freeze
+    def self.can_match?(date_or_str)
+      case date_or_str
+      when Date, Time, DateTime
+        true
+      when DATE_REGEX, ISO8601_REGEX
+        true
+      when String
+        begin
+          Time.iso8601(date_or_str)
+          true
+        rescue ArgumentError
+          false
+        end
+      end
+    end
+
+    def initialize(expected)
+      @expected = expected
+    end
+
+    def description
+      "resemble date #{@expected.inspect}"
+    end
+
+    def matches?(actual)
+      @actual = actual
+      self.class.can_match?(actual)
+    end
+
+    def expected_formatted
+      @expected.inspect.to_s
+    end
+
+    def failure_message
+      "#{@actual.inspect} does not resemble a Date or Timestamp"
+    end
+  end
+end