rspec-hive 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e0ecaa7596db283e59f0ea63fbb677942e714d09
-  data.tar.gz: ae43c8734de7c85b0551454534fc1e339a74d2f5
+  metadata.gz: 0b75898c0b7364fe12b80f91a36da04a54c5bab6
+  data.tar.gz: 86e7fcbbb5a50fc536a0954ddc27fd4cb90ef915
 SHA512:
-  metadata.gz: 906bd8f828ba76a4646c535cee8679d60f3acf23714e8686c62789ee770d754f95f216930758d504bf57964a40c127e189b58dc17e03c674f12a283f181e83cf
-  data.tar.gz: 6cf54197ee350b05235eb08869226dd2b26c3e63f83764ad17356c5ef842379f8d5b5b2d4a8aafe63d212d91b02c91b78d64bcd0bb729c5bb37daf8a8da05084
+  metadata.gz: da919d5129641e77e15c5bfeed2bef2396e3d02dd3eaa93ef61dae7af099323d6a9106a8b9b8ac02644035ab39588a88c6cbabbe40f7f53832e961d499a7244f
+  data.tar.gz: 2ea4738a1f9bb1d84426ed4873a33bfb2b8f2480a1b557fbb73e2b5fe8821fbb266defffe8fab57c3114558d6c10c3e0a8f9ee3d11fc0fd0c5138de884c4748c

data/lib/rspec/hive/matchers.rb

@@ -2,28 +2,104 @@ require 'rspec/matchers'
 
 RSpec::Matchers.define :match_result_set do |expected|
   match do |actual|
-    return false if expected.size != actual.size
+    @diffable_actual = []
 
-    expected.each.with_index.all? do |expected_row, i|
+    @actual = actual.clone
+
+    expected.map.with_index do |expected_row, i|
       if expected_row.respond_to?(:each_pair)
         if @partial_match
-          selected_actual_values = actual[i].values_at(*expected_row.keys)
-          values_match?(expected_row.values, selected_actual_values)
+          result_set_match?(
+            actual[i], expected_row,
+            expected_transformer: ->(e) { e.values },
+            actual_transformer: ->(candidate) { candidate.values_at(*expected_row.keys) },
+            diffable_transformer: ->(candidate) { candidate.select { |k, _v| expected_row.keys.include?(k) } }
+          )
         else
-          values_match?(expected_row, actual[i])
+          result_set_match?(actual[i], expected_row)
         end
       elsif expected_row.respond_to?(:each)
         raise ArgumentError, "Can't use partially matcher with Arrays" if @partial_match
-        values_match?(expected_row, actual[i].values)
+        result_set_match?(
+          actual[i], expected_row,
+          actual_transformer: ->(candidate) { candidate.values }
+        )
       else
         raise ArgumentError, 'Unknown type'
       end
-    end
+    end.all? && expected.size == actual.size
   end
 
   chain :partially do
     @partial_match = true
   end
 
-  diffable
+  chain :unordered do
+    @unordered = true
+  end
+
+  def result_set_match?(
+    actual, expected_row,
+    expected_transformer: ->(expected) { expected },
+    actual_transformer: ->(candidate) { candidate },
+    diffable_transformer: actual_transformer
+  )
+    if @unordered
+      unordered_result_set_match?(expected_row, expected_transformer, actual_transformer, diffable_transformer)
+    else
+      ordered_result_set_match?(actual, expected_row, expected_transformer, actual_transformer, diffable_transformer)
+    end
+  end
+
+  def unordered_result_set_match?(expected_row, expected_transformer, actual_transformer, diffable_transformer)
+    found_index = @actual.find_index do |candidate|
+      values_match?(expected_transformer.call(expected_row), actual_transformer.call(candidate))
+    end
+    return false unless found_index
+    found = @actual[found_index]
+    @actual.delete_at(found_index)
+    @diffable_actual << diffable_transformer.call(found)
+    true
+  end
+
+  def ordered_result_set_match?(actual, expected_row, expected_transformer, actual_transformer, diffable_transformer)
+    @diffable_actual << diffable_transformer.call(actual)
+    values_match?(expected_transformer.call(expected_row), actual_transformer.call(actual))
+  end
+
+  failure_message do |actual|
+    "expected #{actual} to match result set #{expected}\n#{diff_message(expected)}"
+  end
+
+  failure_message_when_negated do |actual|
+    "expected #{actual} not to match result set #{expected}, but did\n#{diff_message(expected)}"
+  end
+
+  def diff_message(expected)
+    "Diff: #{differ.diff_as_object(@diffable_actual, expected)}"
+  end
+
+  def differ
+    RSpec::Support::Differ.new(
+      object_preparer: ->(object) { surface_descriptions_in(object) },
+      color: RSpec::Matchers.configuration.color?
+    )
+  end
+
+  # Copied and adapted from RSpec::Matchers::Composable
+  # rubocop:disable Style/CaseEquality
+  def surface_descriptions_in(item)
+    if RSpec::Matchers.is_a_describable_matcher?(item)
+      RSpec::Matchers::Composable::DescribableItem.new(item)
+    elsif Hash === item
+      Hash[surface_descriptions_in(item.to_a.sort)]
+    elsif Struct === item || unreadable_io?(item)
+      RSpec::Support::ObjectFormatter.format(item)
+    elsif should_enumerate?(item)
+      item.map { |subitem| surface_descriptions_in(subitem) }
+    else
+      item
+    end
+  end
+  # rubocop:enable Style/CaseEquality
 end

data/lib/rspec/hive/version.rb

@@ -1,5 +1,5 @@
 module RSpec
   module Hive
-    VERSION = '0.2.0'.freeze
+    VERSION = '0.3.0'.freeze
   end
 end

data/spec/lib/rspec/hive/matchers_spec.rb

@@ -8,9 +8,24 @@ RSpec.describe 'match_result_set' do
   let(:paul) { {first_name: 'Paul', last_name: 'McCartney', age: 73} }
 
   let(:full_match) { expect(actual_rows).to match_result_set(expected_rows) }
+  let(:unordered_match) { expect(actual_rows).to match_result_set(expected_rows).unordered }
   let(:partial_match) { expect(actual_rows).to match_result_set(expected_rows).partially }
+  let(:partial_unordered_match) { expect(actual_rows).to match_result_set(expected_rows).partially.unordered }
+
   let(:full_match_fails) { expect(actual_rows).not_to match_result_set(expected_rows) }
+  let(:unordered_match_fails) { expect(actual_rows).not_to match_result_set(expected_rows).unordered }
   let(:partial_match_fails) { expect(actual_rows).not_to match_result_set(expected_rows).partially }
+  let(:partial_unordered_match_fails) { expect(actual_rows).not_to match_result_set(expected_rows).partially.unordered }
+
+  let(:partial_match_raises_error) do
+    error_message = "Can't use partially matcher with Arrays"
+    aggregate_failures do
+      expect { partial_match }.to raise_error(ArgumentError, error_message)
+      expect { partial_match_fails }.to raise_error(ArgumentError, error_message)
+      expect { partial_unordered_match }.to raise_error(ArgumentError, error_message)
+      expect { partial_unordered_match_fails }.to raise_error(ArgumentError, error_message)
+    end
+  end
 
   context 'when the expected set has only one row' do
     context 'but the actual set has more rows' do
@@ -20,14 +35,17 @@ RSpec.describe 'match_result_set' do
         let(:expected_rows) { [john.values] }
 
         specify { full_match_fails }
-        specify { partial_match_fails }
+        specify { unordered_match_fails }
+        specify { partial_match_raises_error }
       end
 
       context 'when the row is given as a hash' do
         let(:expected_rows) { [john] }
 
         specify { full_match_fails }
+        specify { unordered_match_fails }
         specify { partial_match_fails }
+        specify { partial_unordered_match_fails }
       end
     end
 
@@ -39,24 +57,32 @@ RSpec.describe 'match_result_set' do
           let(:expected_rows) { [john.values << 'yoko'] }
 
           specify { full_match_fails }
+          specify { unordered_match_fails }
+          specify { partial_match_raises_error }
         end
 
         context 'when the actual and expected have are different' do
           let(:expected_rows) { [paul.values] }
 
           specify { full_match_fails }
+          specify { unordered_match_fails }
+          specify { partial_match_raises_error }
         end
 
         context 'when the actual and expected rows are equal' do
           let(:expected_rows) { [john.values] }
 
           specify { full_match }
+          specify { unordered_match }
+          specify { partial_match_raises_error }
         end
 
         context 'when the actual and expected rows are equal with rspec matchers' do
           let(:expected_rows) { [[a_string_matching('John'), a_string_matching(/lennon/i), 40]] }
 
           specify { full_match }
+          specify { unordered_match }
+          specify { partial_match_raises_error }
         end
       end
 
@@ -65,28 +91,106 @@ RSpec.describe 'match_result_set' do
           let(:expected_rows) { [john.dup.tap { |j| j[:ono] = 'yoko' }] }
 
           specify { full_match_fails }
+          specify { unordered_match_fails }
           specify { partial_match_fails }
+          specify { partial_unordered_match_fails }
         end
 
         context 'when the actual and expected have are different' do
           let(:expected_rows) { [john.dup.tap { |j| j[:first_name] = 'yoko' }] }
 
           specify { full_match_fails }
+          specify { unordered_match_fails }
           specify { partial_match_fails }
+          specify { partial_unordered_match_fails }
         end
 
         context 'when the actual and expected rows are equal' do
           let(:expected_rows) { [john] }
 
           specify { full_match }
+          specify { unordered_match }
           specify { partial_match }
+          specify { partial_unordered_match }
         end
 
         context 'when matching a subset of columns' do
           let(:expected_rows) { [{first_name: john[:first_name]}] }
 
           specify { full_match_fails }
+          specify { unordered_match_fails }
           specify { partial_match }
+          specify { partial_unordered_match }
+        end
+      end
+    end
+  end
+
+  context 'when the expected set has multiple rows' do
+    let(:ringo) { {first_name: 'Richard', last_name: 'Starkey', age: -75} }
+
+    context 'and the actual set has the same number of rows' do
+      let(:actual_rows) { [ringo, paul, john] }
+
+      context 'when the row is given as an array' do
+        context 'when rows are returned in order' do
+          let(:expected_rows) { [ringo.values, paul.values, john.values] }
+
+          specify { full_match }
+          specify { unordered_match }
+          specify { partial_match_raises_error }
+        end
+
+        context 'when rows are returned in different order' do
+          let(:expected_rows) { [paul.values, john.values, ringo.values] }
+
+          specify { full_match_fails }
+          specify { unordered_match }
+          specify { partial_match_raises_error }
+        end
+      end
+
+      context 'when the row is given as a hash' do
+        context 'when matching all columns' do
+          context 'when rows are returned in order' do
+            let(:expected_rows) { [ringo, paul, john] }
+
+            specify { full_match }
+            specify { unordered_match }
+            specify { partial_match }
+            specify { partial_unordered_match }
+          end
+
+          context 'when rows are returned in different order' do
+            let(:expected_rows) { [paul, john, ringo] }
+
+            specify { full_match_fails }
+            specify { unordered_match }
+            specify { partial_match_fails }
+            specify { partial_unordered_match }
+          end
+        end
+
+        context 'when matching a subset of columns' do
+          let(:expected_rows) { members.map { |member| {age: member[:age]} } }
+
+          context 'when rows are returned in order' do
+            let(:members) { [ringo, paul, john] }
+
+            specify { full_match_fails }
+            specify { unordered_match_fails }
+            specify { partial_match }
+            specify { partial_unordered_match }
+          end
+
+          context 'when rows are returned in different order' do
+            let(:members) { [john, paul, ringo] }
+
+            specify { full_match_fails }
+            specify { unordered_match_fails }
+            specify { partial_match_fails }
+            specify { partial_unordered_match }
+          end
         end
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rspec-hive
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Wojtek Mielczarek
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-09 00:00:00.000000000 Z
+date: 2016-05-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake