pact-support 1.4.0 → 1.8.0

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

@@ -7,10 +7,16 @@ module Pact
       subject { Merge.(expected, matching_rules, "$.body") }
 
       before do
-        allow($stderr).to receive(:puts)
+        allow($stderr).to receive(:puts) do | message |
+          raise "Was not expecting stderr to receive #{message.inspect} in this spec. This may be because of a missed call to log_used_rule in Merge."
+        end
       end
 
       describe "no recognised rules" do
+        before do
+          allow($stderr).to receive(:puts)
+        end
+
         let(:expected) do
           {
             "_links" => {
@@ -63,6 +69,10 @@ module Pact
       end
 
       describe "type based matching" do
+        before do
+          allow($stderr).to receive(:puts).and_call_original
+        end
+
         let(:expected) do
           {
             "name" => "Mary"
@@ -80,7 +90,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
 
@@ -89,6 +99,10 @@ module Pact
       describe "regular expressions" do
 
         describe "in a hash" do
+          before do
+            allow($stderr).to receive(:puts)
+          end
+
           let(:expected) do
             {
               "_links" => {
@@ -146,150 +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
-          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
+        let(:matching_rules) do
+          {
+            "$.body.alligators" => { 'match' => 'type' }
+          }
         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
-            {
-              "$.body.alligators" => { 'min' => 2, 'match' => 'type' },
-              "$.body.alligators[*].*" => { 'match' => 'type'}
-            }
-          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
 
-          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
+        let(:matching_rules) do
+          {
+            "$.body.alligators" => { 'min' => 2 },
+            "$.body.alligators[*].*" => { 'match' => 'type'}
+          }
         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
+        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
 
-          let(:matching_rules) do
-            {
-              "$.body.alligators" => { 'min' => 2, 'match' => 'type' },
-            }
-          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::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
+        let(:matching_rules) do
+          {
+            "$.body.alligators" => { 'min' => 2, 'match' => 'type' },
+            "$.body.alligators[*].*" => { 'match' => 'type'}
+          }
         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
-            {
+        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
 
-              'alligators' => [
-                {
-                  'name' => 'Mary',
-                  'children' => [
-                    'age' => 9
-                  ]
-                }
-              ]
+      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
 
-            }
-          end
+        let(:matching_rules) do
+          {
+            "$.body.alligators" => { 'min' => 2, 'match' => 'type' },
+          }
+        end
 
-          let(:matching_rules) do
-            {
-              "$.body.alligators" => { 'min' => 2 },
-              "$.body.alligators[*].*" => { 'match' => 'type'},
-              "$.body.alligators[*].children" => { 'min' => 1 },
-              "$.body.alligators[*].children[*].*" => { '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
 
-          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
+      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
+          {
+
+            'alligators' => [
+              {
+                'name' => 'Mary',
+                'children' => [
+                  'age' => 9
+                ]
+              }
+            ]
+
+          }
         end
 
-        describe "with an example array with more than one item" 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'},
-                {'name' => 'Joe'}
-              ]
+        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
 
-            }
-          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'}
-            }
-          end
+        let(:expected) do
+          {
 
-          xit "doesn't warn about the min size being ignored" do
-            expect(Pact.configuration.error_stream).to receive(:puts).once
-            subject
-          end
+            'alligators' => [
+              {'name' => 'Mary'},
+              {'name' => 'Joe'}
+            ]
 
-          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
+
+        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
           {
@@ -343,6 +376,61 @@ module Pact
           expect(subject['@name']).to be_instance_of(Pact::SomethingLike)
         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(body: 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(body: 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)
+        end
+
+        let(:matching_rules) do
+          Extract.call(body: original_definition)
+        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
     end
   end
 end

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

@@ -0,0 +1,238 @@
+require 'pact/matching_rules/v3/extract'
+require 'pact/support'
+
+module Pact
+  module MatchingRules::V3
+    describe Extract do
+
+      describe ".call" do
+
+        subject { Extract.call(matchable) }
+
+        context "with a Pact::SomethingLike" do
+          let(:matchable) do
+            {
+              body: Pact::SomethingLike.new(foo: 'bar', alligator: { name: 'Mary' })
+            }
+          end
+
+          let(:rules) do
+            {
+              "$.body" => {
+                "matchers" => [ {"match" => "type"} ]
+              }
+            }
+          end
+
+          it "creates a rule that matches by type" do
+            expect(subject).to eq rules
+          end
+        end
+
+        context "with a Pact::Term" do
+          let(:matchable) do
+            {
+              body: {
+                alligator: {
+                  name: Pact::Term.new(generate: 'Mary', matcher: /.*a/)
+                }
+              }
+            }
+          end
+
+          let(:rules) do
+            {
+              "$.body.alligator.name" => {
+                "matchers" => [ {"match" => "regex", "regex" => ".*a"} ]
+              }
+            }
+          end
+
+          it "creates a rule that matches by regex" do
+            expect(subject).to eq rules
+          end
+        end
+
+        context "with a Pact::SomethingLike containing a Term" do
+          let(:matchable) do
+            {
+              body: Pact::SomethingLike.new(
+                foo: 'bar',
+                alligator: { name: Pact::Term.new(generate: 'Mary', matcher: /.*a/) }
+              )
+            }
+          end
+
+          let(:rules) do
+            {
+              "$.body" => {
+                "matchers" => [ {"match" => "type"} ]
+              },
+              "$.body.alligator.name" => {
+                "matchers" => [ {"match" => "regex", "regex"=>".*a"} ]
+              },
+            }
+          end
+
+          it "the match:regex overrides the match:type" do
+            expect(subject).to eq rules
+          end
+        end
+
+        context "with a Pact::SomethingLike containing an array" do
+          let(:matchable) do
+            {
+              body: Pact::SomethingLike.new(
+                alligators: [
+                  {name: 'Mary'},
+                  {name: 'Betty'}
+                ]
+              )
+            }
+          end
+
+          let(:rules) do
+            {
+              "$.body" => {
+                "matchers" => [ {"match" => "type"} ]
+              }
+            }
+          end
+
+          it "lists a rule for each item" do
+            expect(subject).to eq rules
+          end
+        end
+
+        context "with an ArrayLike" do
+          let(:matchable) do
+            {
+              body: {
+                alligators: Pact::ArrayLike.new(
+                  name: 'Fred'
+                )
+              }
+            }
+          end
+
+          let(:rules) do
+            {
+              "$.body.alligators" => {
+                "matchers" => [ {"min" => 1} ]
+              },
+              "$.body.alligators[*].*" => {
+                "matchers" => [ {"match" => "type"} ]
+              }
+            }
+          end
+
+          it "lists a rule for all items" do
+            expect(subject).to eq rules
+          end
+        end
+
+        context "with an ArrayLike with a Pact::Term inside" do
+          let(:matchable) do
+            {
+              body: {
+                alligators: Pact::ArrayLike.new(
+                  name: 'Fred',
+                  phoneNumber: Pact::Term.new(generate: '1234567', matcher: /\d+/)
+                )
+              }
+            }
+          end
+
+          let(:rules) do
+            {
+              "$.body.alligators" => {
+                "matchers" => [ {"min" => 1} ]
+                },
+              "$.body.alligators[*].*" => {
+                "matchers" => [ {"match" => "type"} ]
+                },
+              "$.body.alligators[*].phoneNumber" => {
+                "matchers" => [ {"match" => "regex", "regex" => "\\d+"} ]
+              }
+            }
+          end
+
+          it "lists a rule that specifies that the regular expression must match" do
+            expect(subject).to eq rules
+          end
+        end
+
+        context "with a Pact::QueryString containing a Pact::Term" do
+          let(:matchable) do
+            {
+              query: Pact::QueryString.new(Pact::Term.new(generate: 'foobar', matcher: /foo/))
+            }
+          end
+
+          let(:rules) do
+            {
+              "$.query" => {
+                "matchers" => [ {"match" => "regex", "regex" => "foo"} ]
+              }
+            }
+          end
+
+          it "lists a rule that specifies that the regular expression must match" do
+            expect(subject).to eq rules
+          end
+        end
+
+        context "with a Pact::QueryHash containing a Pact::Term" do
+          let(:matchable) do
+            {
+              query: Pact::QueryHash.new(bar: Pact::Term.new(generate: 'foobar', matcher: /foo/))
+            }
+          end
+
+          let(:rules) do
+            {
+              "$.query.bar[0]" => {
+                "matchers" => [ {"match" => "regex", "regex" => "foo"} ]
+              }
+            }
+          end
+
+          it "lists a rule that specifies that the regular expression must match" do
+            expect(subject).to eq rules
+          end
+        end
+
+        context "with no special matching" do
+          let(:matchable) do
+            {
+              body: { alligator: { name: 'Mary' } }
+            }
+          end
+
+          let(:rules) do
+            {}
+          end
+
+
+          it "does not create any rules" do
+            expect(subject).to eq rules
+          end
+        end
+
+        context "with a key containing a dot" do
+          let(:matchable) do
+            {
+              "key" => {
+                "key.with.dots" => Pact::SomethingLike.new("foo")
+              }
+            }
+          end
+
+          it "uses square brackets notation for the key with dots" do
+            expect(subject.keys).to include "$.key['key.with.dots']"
+          end
+        end
+      end
+    end
+  end
+end