pact-support 1.7.1 → 1.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fc9f8683f2295ada09a03f4726ac8c8532d2def6
-  data.tar.gz: c5796a44f6c28c2070cb37e1ae8d6341e2118463
+  metadata.gz: 6c575784ba0803bdeccb12e271ffdec723771497
+  data.tar.gz: a81a629772d07d9ba46da3be40d461a4906c667c
 SHA512:
-  metadata.gz: fb794ca126e1566123ab1c7333fb32d3e66851aed50b7f2489b6979380baf802e09cda256fa2806ebffeba3a93371e5627029aa6d515c6e4912b125e457758a8
-  data.tar.gz: 862c5fc5b00ddc050e22337565acbae72a72bcd9845767dffed811aca2cdbeb79b124d3a681d40ab0b5fdf6cdec6705970694c6794aac6b7189880a2bef2ac61
+  metadata.gz: af8f2fd481a2b5886b6369883d1f4ea696406d16cfc55024958116cc2b170548e4271a1a37125ceddba76be643bf2a8c58ac7d4e5fd17f2fc887002e085a360d
+  data.tar.gz: 31127041531129db0c31928c8c17bedf54566133bf886725e6db5285a9676c19185767f5f86ff784a7a5a1cfdcf059564e5eae08a5b693c63ce77d5d247e8bc5

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+<a name="v1.7.2"></a>
+### v1.7.2 (2018-08-09)
+
+
+#### Bug Fixes
+
+* correctly handle Pact.like and Pact.each_like at top level of body	 ([f37c283](/../../commit/f37c283))
+
+
 <a name="v1.7.1"></a>
 ### v1.7.1 (2018-08-09)
 

data/lib/pact/matching_rules/v3/merge.rb

@@ -31,36 +31,44 @@ module Pact
         end
 
         def recurse expected, path
-          case expected
+          recursed = case expected
           when Hash then recurse_hash(expected, path)
           when Array then recurse_array(expected, path)
           else
             expected
           end
+          wrap(recursed, path)
         end
 
         def recurse_hash hash, path
           hash.each_with_object({}) do | (k, v), new_hash |
             new_path = path + "['#{k}']"
-            new_hash[k] = recurse(wrap(v, new_path), new_path)
+            new_hash[k] = recurse(v, new_path)
           end
         end
 
         def recurse_array array, path
-
-          parent_match_rule = @matching_rules[path] && @matching_rules[path]['matchers'] && @matching_rules[path]['matchers'].first && @matching_rules[path]['matchers'].first.delete('match')
+          # This assumes there is only one rule! TODO make this find the appropriate rule.
+          parent_match_rule = @matching_rules[path]['matchers'].first['match'] rescue nil
           array_like_children_path = "#{path}[*]*"
-          children_match_rule = @matching_rules[array_like_children_path] && @matching_rules[array_like_children_path]['matchers'] && @matching_rules[array_like_children_path]['matchers'].first && @matching_rules[array_like_children_path]['matchers'].first.delete('match')
-          min = @matching_rules[path] && @matching_rules[path]['matchers'] && @matching_rules[path]['matchers'].first && @matching_rules[path]['matchers'].first.delete('min')
+          children_match_rule = @matching_rules[array_like_children_path]['matchers'].first['match'] rescue nil
+          min = @matching_rules[path]['matchers'].first['min'] rescue nil
 
-          if min && (children_match_rule == 'type' || (children_match_rule.nil? && parent_match_rule == 'type'))
+          if min && children_match_rule == 'type'
+            @matching_rules[path]['matchers'].first.delete('min')
+            @matching_rules[array_like_children_path]['matchers'].first.delete('match')
+            warn_when_not_one_example_item(array, path)
+            Pact::ArrayLike.new(recurse(array.first, "#{path}[*]"), min: min)
+          elsif min && parent_match_rule == 'type'
+            @matching_rules[path]['matchers'].first.delete('min')
+            @matching_rules[path]['matchers'].first.delete('match')
             warn_when_not_one_example_item(array, path)
             Pact::ArrayLike.new(recurse(array.first, "#{path}[*]"), min: min)
           else
             new_array = []
             array.each_with_index do | item, index |
               new_path = path + "[#{index}]"
-              new_array << recurse(wrap(item, new_path), new_path)
+              new_array << recurse(item, new_path)
             end
             new_array
           end
@@ -82,14 +90,13 @@ module Pact
           elsif rules['regex']
             handle_regex(object, path, rules)
           else
-            #log_ignored_rules(path, rules, {})
             object
           end
         end
 
         def handle_match_type object, path, rules
           rules.delete('match')
-          Pact::SomethingLike.new(recurse(object, path))
+          Pact::SomethingLike.new(object)
         end
 
         def handle_regex object, path, rules

data/lib/pact/support/version.rb

@@ -1,5 +1,5 @@
 module Pact
   module Support
-    VERSION = "1.7.1"
+    VERSION = "1.7.2"
   end
 end

data/spec/lib/pact/matching_rules/merge_spec.rb

@@ -160,149 +160,169 @@ module Pact
           end
         end
 
-        describe "with an array where all elements should match by type and the rule is specified on the parent element and there is no min specified" do
+        describe "with an ArrayLike containing a Term" do
           let(:expected) do
-            {
-              'alligators' => [{'name' => 'Mary'}]
-            }
+            ["foo"]
           end
 
           let(:matching_rules) do
             {
-              "$.body.alligators" => { 'match' => 'type' }
+              "$.body" => {"min" => 1},
+              "$.body[*].*" => {"match" => "type"},
+              "$.body[*]" => {"match" => "regex", "regex"=>"f"}
             }
           end
 
-          it "creates a Pact::SomethingLike at the appropriate path" do
-            expect(subject["alligators"]).to be_instance_of(Pact::SomethingLike)
-            expect(subject["alligators"].contents).to eq ['name' => 'Mary']
+          it "it creates an ArrayLike with a Pact::Term as the contents" do
+            expect(subject).to be_a(Pact::ArrayLike)
+            expect(subject.contents).to be_a(Pact::Term)
           end
         end
+      end
 
-        describe "with an array where all elements should match by type and the rule is specified on the child elements" do
-          let(:expected) do
-            {
-              'alligators' => [{'name' => 'Mary'}]
-            }
-          end
+      describe "with an array where all elements should match by type and the rule is specified on the parent element and there is no min specified" do
+        let(:expected) do
+          {
+            'alligators' => [{'name' => 'Mary'}]
+          }
+        end
 
-          let(:matching_rules) do
-            {
-              "$.body.alligators" => { 'min' => 2 },
-              "$.body.alligators[*].*" => { 'match' => 'type'}
-            }
-          end
+        let(:matching_rules) do
+          {
+            "$.body.alligators" => { 'match' => 'type' }
+          }
+        end
 
-          it "creates a Pact::ArrayLike at the appropriate path" do
-            expect(subject["alligators"]).to be_instance_of(Pact::ArrayLike)
-            expect(subject["alligators"].contents).to eq 'name' => 'Mary'
-            expect(subject["alligators"].min).to eq 2
-          end
+        it "creates a Pact::SomethingLike at the appropriate path" do
+          expect(subject["alligators"]).to be_instance_of(Pact::SomethingLike)
+          expect(subject["alligators"].contents).to eq ['name' => 'Mary']
         end
+      end
 
-        describe "with an array where all elements should match by type and the rule is specified on both the parent element and the child elements" do
-          let(:expected) do
-            {
-              'alligators' => [{'name' => 'Mary'}]
-            }
-          end
+      describe "with an array where all elements should match by type and the rule is specified on the child elements" do
+        let(:expected) do
+          {
+            'alligators' => [{'name' => 'Mary'}]
+          }
+        end
 
-          let(:matching_rules) do
-            {
-              "$.body.alligators" => { 'min' => 2, 'match' => 'type' },
-              "$.body.alligators[*].*" => { 'match' => 'type'}
-            }
-          end
+        let(:matching_rules) do
+          {
+            "$.body.alligators" => { 'min' => 2 },
+            "$.body.alligators[*].*" => { 'match' => 'type'}
+          }
+        end
 
-          it "creates a Pact::ArrayLike at the appropriate path" do
-            expect(subject["alligators"]).to be_instance_of(Pact::ArrayLike)
-            expect(subject["alligators"].contents).to eq 'name' => 'Mary'
-            expect(subject["alligators"].min).to eq 2
-          end
+        it "creates a Pact::ArrayLike at the appropriate path" do
+          expect(subject["alligators"]).to be_instance_of(Pact::ArrayLike)
+          expect(subject["alligators"].contents).to eq 'name' => 'Mary'
+          expect(subject["alligators"].min).to eq 2
         end
+      end
 
-        describe "with an array where all elements should match by type and there is only a match:type on the parent element" do
-          let(:expected) do
-            {
-              'alligators' => [{'name' => 'Mary'}]
-            }
-          end
+      describe "with an array where all elements should match by type and the rule is specified on both the parent element and the child elements" do
+        let(:expected) do
+          {
+            'alligators' => [{'name' => 'Mary'}]
+          }
+        end
 
-          let(:matching_rules) do
-            {
-              "$.body.alligators" => { 'min' => 2, 'match' => 'type' },
-            }
-          end
+        let(:matching_rules) do
+          {
+            "$.body.alligators" => { 'min' => 2, 'match' => 'type' },
+            "$.body.alligators[*].*" => { 'match' => 'type'}
+          }
+        end
 
-          it "creates a Pact::ArrayLike at the appropriate path" do
-            expect(subject["alligators"]).to be_instance_of(Pact::ArrayLike)
-            expect(subject["alligators"].contents).to eq 'name' => 'Mary'
-            expect(subject["alligators"].min).to eq 2
-          end
+        it "creates a Pact::ArrayLike at the appropriate path" do
+          expect(subject["alligators"]).to be_instance_of(Pact::ArrayLike)
+          expect(subject["alligators"].contents).to eq 'name' => 'Mary'
+          expect(subject["alligators"].min).to eq 2
+        end
+      end
+
+      describe "with an array where all elements should match by type and there is only a match:type on the parent element" do
+        let(:expected) do
+          {
+            'alligators' => [{'name' => 'Mary'}]
+          }
         end
 
-        describe "with an array where all elements should match by type nested inside another array where all elements should match by type" do
-          let(:expected) do
-            {
+        let(:matching_rules) do
+          {
+            "$.body.alligators" => { 'min' => 2, 'match' => 'type' },
+          }
+        end
 
-              'alligators' => [
-                {
-                  'name' => 'Mary',
-                  'children' => [
-                    'age' => 9
-                  ]
-                }
-              ]
+        it "creates a Pact::ArrayLike at the appropriate path" do
+          expect(subject["alligators"]).to be_instance_of(Pact::ArrayLike)
+          expect(subject["alligators"].contents).to eq 'name' => 'Mary'
+          expect(subject["alligators"].min).to eq 2
+        end
+      end
 
-            }
-          end
+      describe "with an array where all elements should match by type nested inside another array where all elements should match by type" do
+        let(:expected) do
+          {
 
-          let(:matching_rules) do
-            {
-              "$.body.alligators" => { 'min' => 2 },
-              "$.body.alligators[*].*" => { 'match' => 'type'},
-              "$.body.alligators[*].children" => { 'min' => 1 },
-              "$.body.alligators[*].children[*].*" => { 'match' => 'type'}
-            }
-          end
+            'alligators' => [
+              {
+                'name' => 'Mary',
+                'children' => [
+                  'age' => 9
+                ]
+              }
+            ]
 
-          it "creates a Pact::ArrayLike at the appropriate path" do
-            expect(subject["alligators"].contents['children']).to be_instance_of(Pact::ArrayLike)
-            expect(subject["alligators"].contents['children'].contents).to eq 'age' => 9
-            expect(subject["alligators"].contents['children'].min).to eq 1
-          end
+          }
         end
 
-        describe "with an example array with more than one item" do
-          before do
-            allow(Pact.configuration.error_stream).to receive(:puts)
-          end
+        let(:matching_rules) do
+          {
+            "$.body.alligators" => { 'min' => 2 },
+            "$.body.alligators[*].*" => { 'match' => 'type'},
+            "$.body.alligators[*].children" => { 'min' => 1 },
+            "$.body.alligators[*].children[*].*" => { 'match' => 'type'}
+          }
+        end
 
-          let(:expected) do
-            {
+        it "creates a Pact::ArrayLike at the appropriate path" do
+          expect(subject["alligators"].contents['children']).to be_instance_of(Pact::ArrayLike)
+          expect(subject["alligators"].contents['children'].contents).to eq 'age' => 9
+          expect(subject["alligators"].contents['children'].min).to eq 1
+        end
+      end
 
-              'alligators' => [
-                {'name' => 'Mary'},
-                {'name' => 'Joe'}
-              ]
+      describe "with an example array with more than one item" do
+        before do
+          allow(Pact.configuration.error_stream).to receive(:puts)
+        end
 
-            }
-          end
+        let(:expected) do
+          {
 
-          let(:matching_rules) do
-            {
-              "$.body.alligators" => { 'min' => 2 },
-              "$.body.alligators[*].*" => { 'match' => 'type'}
-            }
-          end
+            'alligators' => [
+              {'name' => 'Mary'},
+              {'name' => 'Joe'}
+            ]
 
-          it "warns that the other items will be ignored" do
-            expect(Pact.configuration.error_stream).to receive(:puts).with(/WARN: Only the first item/)
-            subject
-          end
+          }
+        end
+
+        let(:matching_rules) do
+          {
+            "$.body.alligators" => { 'min' => 2 },
+            "$.body.alligators[*].*" => { 'match' => 'type'}
+          }
+        end
+
+        it "warns that the other items will be ignored" do
+          expect(Pact.configuration.error_stream).to receive(:puts).with(/WARN: Only the first item/)
+          subject
         end
       end
 
+
       describe "using bracket notation for a Hash" do
         let(:expected) do
           {

data/spec/lib/pact/matching_rules/v3/merge_spec.rb

@@ -94,7 +94,7 @@ module Pact
           end
 
           it "it logs the rules it has ignored" do
-            expect($stderr).to receive(:puts).with(/ignored.*matchingrule/)
+            expect($stderr).to receive(:puts).once.with(/ignored.*matchingrule/)
             subject
           end
 
@@ -105,6 +105,61 @@ module Pact
           end
         end
 
+        describe "when a Pact.like is nested inside a Pact.each_like which is nested inside a Pact.like" do
+          let(:original_definition) do
+            Pact.like('foos' => Pact.each_like(Pact.like('name' => "foo1")))
+          end
+
+          let(:expected) do
+            Pact::Reification.from_term(original_definition)
+          end
+
+          let(:matching_rules) do
+            Extract.call(original_definition)
+          end
+
+          it "creates a Pact::SomethingLike containing a Pact::ArrayLike containing a Pact::SomethingLike" do
+            expect(subject.to_hash).to eq original_definition.to_hash
+          end
+        end
+
+        describe "when a Pact.array_like is the top level object" do
+          let(:original_definition) do
+            Pact.each_like('foos')
+          end
+
+          let(:expected) do
+            Pact::Reification.from_term(original_definition)
+          end
+
+          let(:matching_rules) do
+            Extract.call(original_definition)
+          end
+
+          it "creates a Pact::ArrayLike" do
+            expect(subject.to_hash).to eq original_definition.to_hash
+          end
+        end
+
+        describe "when a Pact.like containing an array is the top level object" do
+          let(:original_definition) do
+            Pact.like(['foos'])
+          end
+
+          let(:expected) do
+            Pact::Reification.from_term(original_definition).tap { |it| puts it }
+          end
+
+          let(:matching_rules) do
+            Extract.call(original_definition).tap { |it| puts it }
+          end
+
+          it "creates a Pact::SomethingLike" do
+            expect(subject).to be_a(Pact::SomethingLike)
+            expect(subject.to_hash).to eq original_definition.to_hash
+          end
+        end
+
         describe "regular expressions" do
           describe "in a hash" do
             before do
@@ -172,158 +227,178 @@ module Pact
             end
           end
 
-          describe "with an array where all elements should match by type and the rule is specified on the parent element and there is no min specified" do
+          describe "with an ArrayLike containing a Term" do
             let(:expected) do
-              {
-                'alligators' => [{'name' => 'Mary'}]
-              }
+              ["foo"]
             end
 
             let(:matching_rules) do
               {
-                "$.alligators" => {
-                  "matchers" => [{ 'match' => 'type' }]
-                }
+                "$" => {"matchers" => [{"min" => 1}]},
+                "$[*].*" => {"matchers" => [{"match" => "type"}]},
+                "$[*]" => {"matchers" => [{"match" => "regex", "regex"=>"f"}]}
               }
             end
 
-            it "creates a Pact::SomethingLike at the appropriate path" do
-              expect(subject["alligators"]).to be_instance_of(Pact::SomethingLike)
-              expect(subject["alligators"].contents).to eq ['name' => 'Mary']
+            it "it creates an ArrayLike with a Pact::Term as the contents" do
+              expect(subject).to be_a(Pact::ArrayLike)
+              expect(subject.contents).to be_a(Pact::Term)
             end
           end
+        end
 
-          describe "with an array where all elements should match by type and the rule is specified on the child elements" do
-            let(:expected) do
-              {
-                'alligators' => [{'name' => 'Mary'}]
-              }
-            end
+        describe "with an array where all elements should match by type and the rule is specified on the parent element and there is no min specified" do
+          let(:expected) do
+            {
+              'alligators' => [{'name' => 'Mary'}]
+            }
+          end
 
-            let(:matching_rules) do
-              {
-                "$.alligators" => {
-                  "matchers" => [{ 'min' => 2, 'match' => 'type' }]
-                },
-                "$.alligators[*].*" => {
-                  "matchers" => [{ 'match' => 'type'}]
-                }
+          let(:matching_rules) do
+            {
+              "$.alligators" => {
+                "matchers" => [{ 'match' => 'type' }]
               }
-            end
-            it "creates a Pact::ArrayLike at the appropriate path" do
-              expect(subject["alligators"]).to be_instance_of(Pact::ArrayLike)
-              expect(subject["alligators"].contents).to eq 'name' => 'Mary'
-              expect(subject["alligators"].min).to eq 2
-            end
+            }
           end
 
-          describe "with an array where all elements should match by type and the rule is specified on both the parent element and the child elements" do
-            let(:expected) do
-              {
-                'alligators' => [{'name' => 'Mary'}]
-              }
-            end
+          it "creates a Pact::SomethingLike at the appropriate path" do
+            expect(subject["alligators"]).to be_instance_of(Pact::SomethingLike)
+            expect(subject["alligators"].contents).to eq ['name' => 'Mary']
+          end
+        end
 
-            let(:matching_rules) do
-              {
-                "$.alligators" => {
-                  "matchers" => [{ 'min' => 2, 'match' => 'type' }]
-                },
-                "$.alligators[*].*" => {
-                  "matchers" => [{ 'match' => 'type' }]
-                }
+        describe "with an array where all elements should match by type and the rule is specified on the child elements" do
+          let(:expected) do
+            {
+              'alligators' => [{'name' => 'Mary'}]
+            }
+          end
+
+          let(:matching_rules) do
+            {
+              "$.alligators" => {
+                "matchers" => [{ 'min' => 2}]
+              },
+              "$.alligators[*].*" => {
+                "matchers" => [{ 'match' => 'type'}]
               }
-            end
+            }
+          end
+          it "creates a Pact::ArrayLike at the appropriate path" do
+            expect(subject["alligators"]).to be_instance_of(Pact::ArrayLike)
+            expect(subject["alligators"].contents).to eq 'name' => 'Mary'
+            expect(subject["alligators"].min).to eq 2
+          end
+        end
 
-            it "creates a Pact::ArrayLike at the appropriate path" do
-              expect(subject["alligators"]).to be_instance_of(Pact::ArrayLike)
-              expect(subject["alligators"].contents).to eq 'name' => 'Mary'
-              expect(subject["alligators"].min).to eq 2
-            end
+        describe "with an array where all elements should match by type and the rule is specified on both the parent element and the child elements" do
+          let(:expected) do
+            {
+              'alligators' => [{'name' => 'Mary'}]
+            }
           end
 
-          describe "with an array where all elements should match by type and there is only a match:type on the parent element" do
-            let(:expected) do
-              {
-                'alligators' => [{'name' => 'Mary'}]
+          let(:matching_rules) do
+            {
+              "$.alligators" => {
+                "matchers" => [{ 'min' => 2, 'match' => 'type' }]
+              },
+              "$.alligators[*].*" => {
+                "matchers" => [{ 'match' => 'type' }]
               }
-            end
+            }
+          end
 
-            let(:matching_rules) do
-              {
-                "$.alligators" => { 'matchers' => [{'min' => 2, 'match' => 'type'}] },
-              }
-            end
+          it "creates a Pact::ArrayLike at the appropriate path" do
+            expect(subject["alligators"]).to be_instance_of(Pact::SomethingLike)
+            expect(subject["alligators"].contents).to be_instance_of(Pact::ArrayLike)
+            expect(subject["alligators"].contents.contents).to eq 'name' => 'Mary'
+            expect(subject["alligators"].contents.min).to eq 2
+          end
+        end
 
-            it "creates a Pact::ArrayLike at the appropriate path" do
-              expect(subject["alligators"]).to be_instance_of(Pact::ArrayLike)
-              expect(subject["alligators"].contents).to eq 'name' => 'Mary'
-              expect(subject["alligators"].min).to eq 2
-            end
+        describe "with an array where all elements should match by type and there is only a match:type on the parent element" do
+          let(:expected) do
+            {
+              'alligators' => [{'name' => 'Mary'}]
+            }
           end
 
-          describe "with an array where all elements should match by type nested inside another array where all elements should match by type" do
-            let(:expected) do
-              {
+          let(:matching_rules) do
+            {
+              "$.alligators" => { 'matchers' => [{'min' => 2, 'match' => 'type'}] },
+            }
+          end
 
-                'alligators' => [
-                  {
-                    'name' => 'Mary',
-                    'children' => [
-                      'age' => 9
-                    ]
-                  }
-                ]
+          it "creates a Pact::ArrayLike at the appropriate path" do
+            expect(subject["alligators"]).to be_instance_of(Pact::ArrayLike)
+            expect(subject["alligators"].contents).to eq 'name' => 'Mary'
+            expect(subject["alligators"].min).to eq 2
+          end
+        end
 
-              }
-            end
+        describe "with an array where all elements should match by type nested inside another array where all elements should match by type" do
+          let(:expected) do
+            {
 
-            let(:matching_rules) do
-              {
-                "$.alligators" => { "matchers" => [{ 'min' => 2, 'match' => 'type' }] },
-                "$.alligators[*].children" => { "matchers" => [{ 'min' => 1, 'match' => 'type' }]},
-              }
-            end
+              'alligators' => [
+                {
+                  'name' => 'Mary',
+                  'children' => [
+                    'age' => 9
+                  ]
+                }
+              ]
 
-            it "creates a Pact::ArrayLike at the appropriate path" do
-              expect(subject["alligators"].contents['children']).to be_instance_of(Pact::ArrayLike)
-              expect(subject["alligators"].contents['children'].contents).to eq 'age' => 9
-              expect(subject["alligators"].contents['children'].min).to eq 1
-            end
+            }
           end
 
-          describe "with an example array with more than one item" do
-            before do
-              allow($stderr).to receive(:puts)
-            end
+          let(:matching_rules) do
+            {
+              "$.alligators" => { "matchers" => [{ 'min' => 2, 'match' => 'type' }] },
+              "$.alligators[*].children" => { "matchers" => [{ 'min' => 1, 'match' => 'type' }]},
+            }
+          end
 
-            let(:expected) do
-              {
+          it "creates a Pact::ArrayLike at the appropriate path" do
+            expect(subject["alligators"].contents['children']).to be_instance_of(Pact::ArrayLike)
+            expect(subject["alligators"].contents['children'].contents).to eq 'age' => 9
+            expect(subject["alligators"].contents['children'].min).to eq 1
+          end
+        end
 
-                'alligators' => [
-                  {'name' => 'Mary'},
-                  {'name' => 'Joe'}
-                ]
+        describe "with an example array with more than one item" do
+          before do
+            allow($stderr).to receive(:puts)
+          end
 
-              }
-            end
+          let(:expected) do
+            {
 
-            let(:matching_rules) do
-              {
-                "$.alligators" => { "matchers" => [{'min' => 2, 'match' => 'type'}] }
-              }
-            end
+              'alligators' => [
+                {'name' => 'Mary'},
+                {'name' => 'Joe'}
+              ]
 
-            it "doesn't warn about the min size being ignored" do
-              expect(Pact.configuration.error_stream).to receive(:puts).once
-              subject
-            end
+            }
+          end
 
-            it "warns that the other items will be ignored" do
-              allow(Pact.configuration.error_stream).to receive(:puts)
-              expect(Pact.configuration.error_stream).to receive(:puts).with(/WARN: Only the first item/)
-              subject
-            end
+          let(:matching_rules) do
+            {
+              "$.alligators" => { "matchers" => [{'min' => 2, 'match' => 'type'}] }
+            }
+          end
+
+          it "doesn't warn about the min size being ignored" do
+            expect(Pact.configuration.error_stream).to receive(:puts).once
+            subject
+          end
+
+          it "warns that the other items will be ignored" do
+            allow(Pact.configuration.error_stream).to receive(:puts)
+            expect(Pact.configuration.error_stream).to receive(:puts).with(/WARN: Only the first item/)
+            subject
           end
         end
 
@@ -380,6 +455,7 @@ module Pact
             expect(subject['@name']).to be_instance_of(Pact::SomethingLike)
           end
         end
+
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pact-support
 version: !ruby/object:Gem::Version
-  version: 1.7.1
+  version: 1.7.2
 platform: ruby
 authors:
 - James Fraser
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-08-09 00:00:00.000000000 Z
+date: 2018-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: randexp