rspec_deep_eq 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b8e7e2b845d478ad4db3d4633d7edd0ae38c2d626b0307c4c588a83d655bdfaf
+  data.tar.gz: 2105b476d66f1cea36f96690791a21d39be20a44fe60977f673b9c99bfd4f60f
+SHA512:
+  metadata.gz: d685dc53ee147d2cf72d7174684342dc2b9f1e545336c78fa01cafe13d476228daeded1f75608eaf02789bc34cb808cc30f3d351bdb74704f696200b464658ea
+  data.tar.gz: 32c8f8b3551af6992b9234b8aa5ca43ca187f99dab6ce503587c47d2a9e090b72d7716cf35fabc7c8f5690025bdfb6e9c5bb974453af7fe12c5c7df2cfb06420

data/README.md

@@ -0,0 +1,70 @@
+# RSpec Deep Eq Matches
+
+This gem adds an RSpec `deep_eq` matcher that recursively compares contents of `Hash` and `Array` data.
+
+## Installation
+Add gem to your `Gemfile`:
+```ruby
+gem 'rspec_deep_eq'
+```
+
+And run
+```
+bundle install
+```
+
+Or install it manually:
+```bash
+gem install rspec_deep_eq
+```
+
+## Getting started
+In `rails_helper` file, configure `deep_eq` matcher for RSpec:
+
+```ruby
+# rails_helper.rb
+
+require 'deep_eq'
+
+RSpec.configure do |config|
+  config.include DeepEq
+end
+
+```
+
+## Usage
+You can compare everything with `deep_eq` matcher, but it's created to compare complex structures like nested hashes and arrays.
+
+```ruby
+describe 'Deep Equal' do
+  it 'compares' do
+    data = prepare_data
+
+    expect(data).to deep_eq(
+      id: 1,
+      items: [
+        id: 3,
+        images: [
+          {
+            url: 'https://example.com/bass_guitar.png'
+          },
+          {
+            url: 'https://example.com/naked_lady.png'
+          }
+        ]
+      ],
+      author: {
+        name: 'John Doe'
+      }
+    )
+  end
+end
+```
+
+## Motivation
+Comparing complex data structures can be easily done using built-in RSpec matchers like `eq`, `match_array` or `hash_including`. But when something goes wrong, it displays hard-to-read error output. This matcher is created to make fixing such tests easier.
+
+Read more [here](MOTIVATION.md).
+
+## License
+Published under MIT license.

data/lib/deep_eq.rb

@@ -0,0 +1,7 @@
+require 'deep_eq/matcher'
+
+module DeepEq
+  def deep_eq(expected)
+    Matcher.new(expected)
+  end
+end

data/lib/deep_eq/deep_equal_checker.rb

@@ -0,0 +1,135 @@
+module DeepEq
+  class DeepEqualChecker
+    def initialize(current:, expected:, location:, matcher_object:)
+      @current = current
+      @expected = expected
+      @location = location
+      @matcher_object = matcher_object
+    end
+
+    def perform
+      case expected
+      when Array
+        return unless current_ensure_array
+        return unless current_ensure_count
+
+        expected.count.times do |index|
+          DeepEqualChecker.new(
+            current: current[index],
+            expected: expected[index],
+            location: location + "[#{index}]",
+            matcher_object: matcher_object
+          ).perform
+        end
+      when Hash
+        return unless current_ensure_hash
+        return unless current_ensure_keys
+
+        expected.keys.each do |key|
+          d = DeepEqualChecker.new(
+            current: current[key],
+            expected: expected[key],
+            location: location + "[#{key.inspect}]",
+            matcher_object: matcher_object
+          ).perform
+        end
+      else
+        compare_values
+      end
+    end
+
+    private
+
+    def compare_values
+      return if current == expected
+
+      add_error "#{location} is invalid (expected #{expected.inspect}, got #{current.inspect})"
+    end
+
+    def add_error(error)
+      matcher_object.add_error error
+      false
+    end
+
+    def current_ensure_hash
+      return true if current.is_a? Hash
+
+      add_type_mismatch_error('Hash')
+    end
+
+    def current_ensure_array
+      return true if current.is_a? Array
+
+      add_type_mismatch_error('Array')
+    end
+
+    def current_ensure_count
+      return true if current.count === expected.count
+
+      add_error "#{location} is expected to have length #{expected.count}, but has #{current.count}"
+    end
+
+    def current_ensure_keys
+      bad_keys = current.keys.reject { |key| expected.keys.include? key }
+
+      return true if bad_keys.empty?
+
+      add_error "#{location} is expected to not contain keys: #{bad_keys.map(&:inspect).join(', ')}"
+    end
+
+    def add_type_mismatch_error(expected_class)
+      add_error "#{location} is expected to be #{expected_class}, but #{current.class} found"
+    end
+
+    attr_reader :current, :expected, :location, :matcher_object
+  end
+end
+
+
+
+
+# module DeepEql
+#   module Matchers
+#
+#     def deep_eql(expected)
+#       DeepEql.new(expected)
+#     end
+#
+#     class DeepEql
+#
+#       def initialize(expectation)
+#         @expectation = expectation
+#       end
+#
+#       def matches?(target)
+#         result = true
+#         @target = target
+#         case @expectation
+#         when Hash
+#           result &&= @target.is_a?(Hash) && @target.keys.count == @expectation.keys.count
+#           @expectation.keys.each do |key|
+#             result &&= @target.has_key?(key) &&
+#             DeepEql.new(@expectation[key]).matches?(@target[key])
+#           end
+#         when Array
+#           result &&= @target.is_a?(Array) && @target.count == @expectation.count
+#           @expectation.each_index do |index|
+#             result &&= DeepEql.new(@expectation[index]).matches?(@target[index])
+#           end
+#         else
+#           result &&= @target == @expectation
+#         end
+#         result
+#       end
+#
+#       def failure_message_for_should
+#         "expected #{@target.inspect} to be deep_eql with #{@expectation.inspect}"
+#       end
+#
+#       def failure_message_for_should_not
+#         "expected #{@target.inspect} not to be in deep_eql with #{@expectation.inspect}"
+#       end
+#     end
+#
+#   end
+# end

data/lib/deep_eq/matcher.rb

@@ -0,0 +1,58 @@
+require_relative './deep_equal_checker'
+
+module DeepEq
+  class Matcher
+    def initialize(expected)
+      @expected = expected
+      @errors = []
+    end
+
+    def matches?(current)
+      @current = current
+
+      perform_deep_equal_check
+
+      errors.empty?
+    end
+
+    def failure_message
+      message = [
+        'Expected',
+        current.inspect,
+        "\nto be deep equal to",
+        expected.inspect,
+        '',
+        "\nFollowing errors found:"
+      ]
+
+      message.concat(errors).push("\r").join("\n")
+    end
+
+    def failure_message_when_negated
+      message = [
+        'Expected',
+        current.inspect,
+        "\nnot to be deep equal to",
+        expected.inspect,
+        "\nBut equal values found."
+      ].join("\n") + "\n"
+    end
+
+    def add_error(error)
+      errors.push error
+    end
+
+    private
+
+    attr_reader :errors, :current, :expected
+
+    def perform_deep_equal_check
+      DeepEqualChecker.new(
+        current: current,
+        expected: expected,
+        location: 'value',
+        matcher_object: self
+      ).perform
+    end
+  end
+end

data/lib/deep_eq/version.rb

@@ -0,0 +1,3 @@
+module DeepEq
+  VERSION = Gem::Version.new('0.0.1')
+end

data/spec/lib/deep_eq/matcher_spec.rb

@@ -0,0 +1,265 @@
+require 'spec_helper'
+
+describe DeepEq::Matcher do
+  describe 'deep_eq' do
+    let!(:matcher_object) { DeepEq::Matcher.new(expected) }
+    let(:errors) { [] }
+
+    before do
+      allow(DeepEq::Matcher).to receive(:new).and_return(matcher_object)
+      allow(matcher_object).to receive(:add_error).and_call_original
+    end
+
+    after do
+      expect(matcher_object).to have_received(:add_error).exactly(errors.count).times
+
+      errors.each do |error|
+        expect(matcher_object).to have_received(:add_error).with(error)
+      end
+    end
+
+    context 'equality check' do
+      after do
+        expect(current).to deep_eq expected
+      end
+
+      context 'when comparing integers' do
+        let(:current) { 2 }
+        let(:expected) { 2.0 }
+
+        it 'passes' do; end
+      end
+
+      context 'when comparing strings' do
+        let(:current) { 'abc' }
+        let(:expected) { 'abc' }
+
+        it 'passes' do; end
+      end
+
+      context 'when comparing symbols' do
+        let(:current) { :def }
+        let(:expected) { :"def" }
+
+        it 'passes' do; end
+      end
+
+      context 'when comparing objects' do
+        let(:current) { FakeRecord.new(value: 12) }
+        let(:expected) { FakeRecord.new(value: 12.0) }
+
+        it 'passes' do; end
+      end
+
+      context 'when comparing arrays' do
+        let(:current) { [1, 4, 2] }
+        let(:expected) { [1, 4, 2] }
+
+        it 'passes' do; end
+
+        context 'with arrays' do
+          let(:current) { [1, 2, [3, 4, 5], 6, [7]] }
+          let(:expected) { [1, 2, [3, 4, 5], 6, [7]] }
+
+          it 'passes' do; end
+        end
+
+        context 'with hashes' do
+          let(:current) { [1, 2, { foo: 'bar', baz: 1 }] }
+          let(:expected) { [1, 2, { baz: 1, foo: 'bar' }] }
+
+          it 'passes' do; end
+        end
+      end
+
+      context 'when comparing hashes' do
+        let(:current) { { one: 1, two: 2, three: 3 } }
+        let(:expected) { { one: 1, three: 3, two: 2 } }
+
+        it 'passes' do; end
+
+        context 'with arrays' do
+          let(:current) { { one: 1, two: [2, 3, 4]} }
+          let(:expected) { { two: [2, 3, 4], one: 1 } }
+
+          it 'passes' do; end
+        end
+
+        context 'with hashes' do
+          let(:current) { { one: 1, two: { full: 2.0, half: 2.5 } } }
+          let(:expected) { { two: { full: 2, half: 2.5 }, one: 1 } }
+
+          it 'passes' do; end
+        end
+      end
+    end
+
+    context 'inequality check' do
+      after do
+        expect(current).to_not deep_eq expected
+      end
+
+      context 'when comparing integers' do
+        let(:current) { 2 }
+        let(:expected) { 3.0 }
+        let(:errors) {
+          ['value is invalid (expected 3.0, got 2)']
+        }
+
+        it 'passes with errors' do; end
+      end
+
+      context 'when comparing strings' do
+        let(:current) { 'abc' }
+        let(:expected) { 'abx' }
+        let(:errors) {
+          ['value is invalid (expected "abx", got "abc")']
+        }
+
+        it 'passes with errors' do; end
+      end
+
+      context 'when comparing symbols' do
+        let(:current) { :def }
+        let(:expected) { :"defo" }
+        let(:errors) {
+          ['value is invalid (expected :defo, got :def)']
+        }
+
+        it 'passes with errors' do; end
+      end
+
+      context 'when comparing objects' do
+        let(:current) { FakeRecord.new(value: 12) }
+        let(:expected) { FakeRecord.new(value: 13) }
+        let(:errors) {
+          ['value is invalid (expected #<FakeRecord @value=13>, got #<FakeRecord @value=12>)']
+        }
+
+        it 'passes with errors' do; end
+      end
+
+      context 'when comparing arrays' do
+        context 'of integers' do
+          let(:current) { [1, 4, 2] }
+          let(:expected) { [1, 3, 2] }
+          let(:errors) {
+            ['value[1] is invalid (expected 3, got 4)']
+          }
+
+          it 'passes with errors' do; end
+        end
+
+        context 'with arrays' do
+          let(:current) { [1, 2, [3, 5, 7], 6, [7]] }
+          let(:expected) { [1, 2, [3, 4, 7], 6, [7]] }
+          let(:errors) {
+            ['value[2][1] is invalid (expected 4, got 5)']
+          }
+
+          it 'passes with errors' do; end
+        end
+
+        context 'with hashes' do
+          let(:current) { [1, 2, { foo: 'bar', baz: 1 }] }
+          let(:expected) { [1, 2, { foo: 'baz', baz: 1 }] }
+          let(:errors) {
+            ['value[2][:foo] is invalid (expected "baz", got "bar")']
+          }
+
+          it 'passes with errors' do; end
+        end
+      end
+
+      context 'when comparing hashes' do
+        context 'with integers' do
+          let(:current) { { one: 1, two: 2, three: 3 } }
+          let(:expected) { { one: 1, three: 30, two: 2 } }
+          let(:errors) {
+            ['value[:three] is invalid (expected 30, got 3)']
+          }
+
+          it 'passes with errors' do; end
+        end
+
+
+        context 'with arrays' do
+          let(:current) { { one: 1, two: [2, 3, 4] } }
+          let(:expected) { { two: [2, 3, 4], one: '1' } }
+          let(:errors) {
+            ['value[:one] is invalid (expected "1", got 1)']
+          }
+
+          it 'passes with errors' do; end
+        end
+
+        context 'with hashes' do
+          let(:current) { { one: 1, two: { full: 2.0, half: 2.5 } } }
+          let(:expected) { { two: { full: 2, half: 'e' }, one: 1 } }
+          let(:errors) {
+            ['value[:two][:half] is invalid (expected "e", got 2.5)']
+          }
+
+          it 'passes with errors' do; end
+        end
+      end
+
+      context 'when comparing hash with integer' do
+        let(:current) { {} }
+        let(:expected) { [] }
+        let(:errors) {
+          ['value is expected to be Array, but Hash found']
+        }
+
+        it 'passes with errors' do; end
+      end
+
+      context 'when comparing hash with incorrect key' do
+        let(:current) { { foo: { bar: { baz: 10 } } } }
+        let(:expected) { { foo: { bar: { 'baz' => 10 } } } }
+        let(:errors) {
+          ['value[:foo][:bar] is expected to not contain keys: :baz']
+        }
+
+        it 'passes with errors' do; end
+      end
+
+      context 'when comparing arrays of different length' do
+        context 'when expected is longer' do
+          let(:current) { [nil, [1, 2]] }
+          let(:expected) { [nil, [1, 2, 3, 4]] }
+          let(:errors) {
+            ['value[1] is expected to have length 4, but has 2']
+          }
+
+          it 'passes with errors' do; end
+        end
+
+        context 'when expected is shorter' do
+          let(:current) { [[1, 2, 3, 4]] }
+          let(:expected) { [[1, 2, 3]] }
+          let(:errors) {
+            ['value[0] is expected to have length 3, but has 4']
+          }
+
+          it 'passes with errors' do; end
+        end
+      end
+
+      context 'when comparing objects with multiple errors' do
+        let(:current) { [4, {}, [{ id: 10 }, { id: 15, name: 'Joe' }], { foo: { bar: :baz } }] }
+        let(:expected) { [3, [], [{ id: 10 }, { id: 150 }], { foo: { bar: :not_baz } }] }
+        let(:errors) {
+          [
+            'value[0] is invalid (expected 3, got 4)',
+            'value[1] is expected to be Array, but Hash found',
+            'value[2][1] is expected to not contain keys: :name',
+            'value[3][:foo][:bar] is invalid (expected :not_baz, got :baz)'
+          ]
+        }
+
+        it 'passes with errors' do; end
+      end
+    end
+  end
+end

data/spec/mocks/fake_record.rb

@@ -0,0 +1,17 @@
+class FakeRecord
+  def initialize(value:)
+    @value = value
+  end
+
+  def ==(another_record)
+    if another_record.is_a?(FakeRecord)
+      value == another_record.value
+    end
+  end
+
+  def inspect
+    "#<FakeRecord @value=#{value}>"
+  end
+
+  attr_reader :value
+end

data/spec/mocks/matcher.rb

@@ -0,0 +1,5 @@
+class DeepEq::Matcher
+  def inspect
+    "instance(DeepEq::Matcher)"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'rspec'
+require 'deep_eq'
+require 'pry-rails'
+require 'deep_eq'
+
+require_relative 'mocks/fake_record'
+require_relative 'mocks/matcher'
+
+module RSpec::Matchers
+  include DeepEq
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: rspec_deep_eq
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- polakowski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-08-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: RSpec deep_eq matcher
+email:
+- marek.polakowski@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/deep_eq.rb
+- lib/deep_eq/deep_equal_checker.rb
+- lib/deep_eq/matcher.rb
+- lib/deep_eq/version.rb
+- spec/lib/deep_eq/matcher_spec.rb
+- spec/mocks/fake_record.rb
+- spec/mocks/matcher.rb
+- spec/spec_helper.rb
+homepage: http://github.com/polakowski/rspec_deep_eq
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: RSpec deep_eq matcher
+test_files:
+- spec/mocks/fake_record.rb
+- spec/mocks/matcher.rb
+- spec/spec_helper.rb
+- spec/lib/deep_eq/matcher_spec.rb