pact-support 1.4.0 → 1.8.0

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

@@ -0,0 +1,462 @@
+require 'pact/matching_rules/v3/merge'
+
+module Pact
+  module MatchingRules
+    module V3
+      describe Merge do
+        subject { Merge.(expected, matching_rules) }
+
+        before do
+          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 rule deletion in Merge."
+          end
+        end
+
+        describe "no recognised rules" do
+          before do
+            allow($stderr).to receive(:puts)
+          end
+
+          let(:expected) do
+            {
+              "_links" => {
+                "self" => {
+                  "href" => "http://localhost:1234/thing"
+                }
+              }
+            }
+          end
+
+          let(:matching_rules) do
+            {
+              "$._links.self.href" => {
+                "matchers" => [{ "type" => "unknown" }]
+              }
+            }
+          end
+
+          it "returns the object at that path unaltered" do
+            expect(subject["_links"]["self"]["href"]).to eq "http://localhost:1234/thing"
+          end
+
+          it "it logs the rules it has ignored" do
+            expect($stderr).to receive(:puts) do | message |
+              expect(message).to include("WARN")
+              expect(message).to include("type")
+              expect(message).to include("unknown")
+              expect(message).to include("$['_links']")
+            end
+            subject
+          end
+
+        end
+
+        describe "with nil rules" do
+          let(:expected) do
+            {
+              "_links" => {
+                "self" => {
+                  "href" => "http://localhost:1234/thing"
+                }
+              }
+            }
+          end
+
+          let(:matching_rules) { nil }
+
+          it "returns the example unaltered" do
+            expect(subject["_links"]["self"]["href"]).to eq "http://localhost:1234/thing"
+          end
+
+        end
+
+        describe "type based matching" do
+          before do
+            allow($stderr).to receive(:puts)
+          end
+
+          let(:expected) do
+            {
+              "name" => "Mary"
+            }
+          end
+
+          let(:matching_rules) do
+            {
+              "$.name" => {
+                "matchers" => [{ "match" => "type", "ignored" => "matchingrule" }]
+              }
+            }
+          end
+
+          it "creates a SomethingLike at the appropriate path" do
+            expect(subject['name']).to be_instance_of(Pact::SomethingLike)
+          end
+
+          it "it logs the rules it has ignored" do
+            expect($stderr).to receive(:puts).once.with(/ignored.*matchingrule/)
+            subject
+          end
+
+          it "does not alter the passed in rules hash" do
+            original_matching_rules = JSON.parse(matching_rules.to_json)
+            subject
+            expect(matching_rules).to eq original_matching_rules
+          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
+              allow($stderr).to receive(:puts)
+            end
+
+            let(:expected) do
+              {
+                "_links" => {
+                  "self" => {
+                    "href" => "http://localhost:1234/thing"
+                  }
+                }
+              }
+            end
+
+            let(:matching_rules) do
+              {
+                "$._links.self.href" => {
+                  "matchers" => [{ "regex" => "http:\\/\\/.*\\/thing", "match" => "regex", "ignored" => "somerule" }]
+                }
+              }
+            end
+
+            it "creates a Pact::Term at the appropriate path" do
+              expect(subject["_links"]["self"]["href"]).to be_instance_of(Pact::Term)
+              expect(subject["_links"]["self"]["href"].generate).to eq "http://localhost:1234/thing"
+              expect(subject["_links"]["self"]["href"].matcher.inspect).to eq "/http:\\/\\/.*\\/thing/"
+            end
+
+            it "it logs the rules it has ignored" do
+              expect($stderr).to receive(:puts) do | message |
+                expect(message).to match /ignored.*"somerule"/
+                expect(message).to_not match /regex/
+                expect(message).to_not match /"match"/
+              end
+              subject
+            end
+          end
+
+          describe "with an array" do
+
+            let(:expected) do
+              {
+                "_links" => {
+                  "self" => [{
+                      "href" => "http://localhost:1234/thing"
+                  }]
+                }
+              }
+            end
+
+            let(:matching_rules) do
+              {
+                "$._links.self[0].href" => {
+                  "matchers" => [{ "regex" => "http:\\/\\/.*\\/thing" }]
+                }
+              }
+            end
+
+            it "creates a Pact::Term at the appropriate path" do
+              expect(subject["_links"]["self"][0]["href"]).to be_instance_of(Pact::Term)
+              expect(subject["_links"]["self"][0]["href"].generate).to eq "http://localhost:1234/thing"
+              expect(subject["_links"]["self"][0]["href"].matcher.inspect).to eq "/http:\\/\\/.*\\/thing/"
+            end
+          end
+
+          describe "with an ArrayLike containing a Term" do
+            let(:expected) do
+              ["foo"]
+            end
+
+            let(:matching_rules) do
+              {
+                "$" => {"matchers" => [{"min" => 1}]},
+                "$[*].*" => {"matchers" => [{"match" => "type"}]},
+                "$[*]" => {"matchers" => [{"match" => "regex", "regex"=>"f"}]}
+              }
+            end
+
+            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 parent element and there is no min specified" do
+          let(:expected) do
+            {
+              'alligators' => [{'name' => 'Mary'}]
+            }
+          end
+
+          let(:matching_rules) do
+            {
+              "$.alligators" => {
+                "matchers" => [{ 'match' => 'type' }]
+              }
+            }
+          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 the child elements" do
+          let(:expected) do
+            {
+              'alligators' => [{'name' => 'Mary'}]
+            }
+          end
+
+          let(:matching_rules) do
+            {
+              "$.alligators" => {
+                "matchers" => [{ 'min' => 2}]
+              },
+              "$.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
+
+          let(:matching_rules) do
+            {
+              "$.alligators" => {
+                "matchers" => [{ 'min' => 2, 'match' => 'type' }]
+              },
+              "$.alligators[*].*" => {
+                "matchers" => [{ '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
+
+        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
+
+          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::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 nested inside another array where all elements should match by type" do
+          let(:expected) do
+            {
+
+              'alligators' => [
+                {
+                  'name' => 'Mary',
+                  'children' => [
+                    'age' => 9
+                  ]
+                }
+              ]
+
+            }
+          end
+
+          let(:matching_rules) do
+            {
+              "$.alligators" => { "matchers" => [{ 'min' => 2, 'match' => 'type' }] },
+              "$.alligators[*].children" => { "matchers" => [{ 'min' => 1, 'match' => 'type' }]},
+            }
+          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
+        end
+
+        describe "with an example array with more than one item" do
+          before do
+            allow($stderr).to receive(:puts)
+          end
+
+          let(:expected) do
+            {
+
+              'alligators' => [
+                {'name' => 'Mary'},
+                {'name' => 'Joe'}
+              ]
+
+            }
+          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
+
+        describe "using bracket notation for a Hash" do
+          let(:expected) do
+            {
+              "name" => "Mary"
+            }
+          end
+
+          let(:matching_rules) do
+            {
+              "$['name']" => { "matchers" => [{"match" => "type"}] }
+            }
+          end
+
+          it "applies the rule" do
+            expect(subject['name']).to be_instance_of(Pact::SomethingLike)
+          end
+        end
+
+        describe "with a dot in the path" do
+          let(:expected) do
+            {
+              "first.name" => "Mary"
+            }
+          end
+
+          let(:matching_rules) do
+            {
+              "$['first.name']" => { "matchers" => [{ "match" => "type" }] }
+            }
+          end
+
+          it "applies the rule" do
+            expect(subject['first.name']).to be_instance_of(Pact::SomethingLike)
+          end
+        end
+
+        describe "with an @ in the path" do
+          let(:expected) do
+            {
+              "@name" => "Mary"
+            }
+          end
+
+          let(:matching_rules) do
+            {
+              "$['@name']" => { "matchers" => [ { "match" => "type" }] }
+            }
+          end
+
+          it "applies the rule" do
+            expect(subject['@name']).to be_instance_of(Pact::SomethingLike)
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/lib/pact/matching_rules_spec.rb

@@ -0,0 +1,82 @@
+require 'pact/matching_rules'
+
+module Pact
+  module MatchingRules
+    describe ".merge" do
+      before do
+        allow(V3::Merge).to receive(:call)
+        allow(Merge).to receive(:call)
+        allow(Pact.configuration.error_stream).to receive(:puts)
+      end
+
+      let(:object) { double('object') }
+      let(:rules) { double('rules') }
+      let(:options) { { pact_specification_version: Pact::SpecificationVersion.new(pact_specification_version) } }
+
+      subject { MatchingRules.merge(object, rules, options)}
+
+      context "when the pact_specification_version is nil" do
+        let(:options) { { pact_specification_version: nil } }
+
+        it "calls Merge" do
+          expect(Merge).to receive(:call)
+          subject
+        end
+      end
+
+      context "when the pact_specification_version starts with '1.'" do
+        let(:pact_specification_version) { "1.0" }
+
+        it "calls Merge" do
+          expect(Merge).to receive(:call)
+          subject
+        end
+      end
+
+      context "when the pact_specification_version is with '1'" do
+        let(:pact_specification_version) { "1" }
+
+        it "calls Merge" do
+          expect(Merge).to receive(:call)
+          subject
+        end
+      end
+
+      context "when the pact_specification_version starts with '2.'" do
+        let(:pact_specification_version) { "2.0" }
+
+        it "calls Merge" do
+          expect(Merge).to receive(:call)
+          subject
+        end
+      end
+
+      context "when the pact_specification_version starts with '3.'" do
+        let(:pact_specification_version) { "3.0" }
+
+        it "calls V3::Merge" do
+          expect(V3::Merge).to receive(:call)
+          subject
+        end
+      end
+
+      context "when the pact_specification_version starts with '4.'" do
+        let(:pact_specification_version) { "4.0" }
+
+        it "calls V3::Merge" do
+          expect(V3::Merge).to receive(:call)
+          subject
+        end
+      end
+
+      context "when the pact_specification_version is with '11'" do
+        let(:pact_specification_version) { "11" }
+
+        it "calls V3::Merge" do
+          expect(V3::Merge).to receive(:call)
+          subject
+        end
+      end
+    end
+  end
+end

data/spec/lib/pact/reification_spec.rb

@@ -122,10 +122,9 @@ module Pact
     end
 
     context "when Hash Query with UTF-8 string" do
-
       subject { Reification.from_term(query)}
 
-      let(:query) { QueryHash.new( {param: 'ILove', extra: '寿司'})}
+      let(:query) { QueryHash.new(param: 'ILove', extra: '寿司') }
 
       it "returns the hash with escaping UTF-8 string" do
         expect(subject).to eq("param=ILove&extra=%E5%AF%BF%E5%8F%B8")
@@ -133,7 +132,6 @@ module Pact
     end
 
     context "when Hash Query with embeded terms" do
-
       subject { Reification.from_term(query)}
 
       let(:query) { QueryHash.new( {param: 'hello', extra: Pact::Term.new(generate: "wonderworld", matcher: /\w+world/)})}
@@ -141,10 +139,9 @@ module Pact
       it "returns the hash in the natural order, and fills in Terms appropriately" do
         expect(subject).to eq("param=hello&extra=wonderworld")
       end
-
     end
-    context "when Hash Query with Arrays and multiple params with the same name" do
 
+    context "when Hash Query with Arrays and multiple params with the same name" do
       subject { Reification.from_term(query)}
 
       let(:query) { QueryHash.new( {param: 'hello', double: [Pact::Term.new(generate: "wonder", matcher: /\w+/), 'world'], simple: 'bye'})}
@@ -152,8 +149,24 @@ module Pact
       it "returns the hash in the natural order, and fills in Terms appropriately" do
         expect(subject).to eq("param=hello&double=wonder&double=world&simple=bye")
       end
+    end
 
+    context "when Hash Query with an ArrayLike" do
+      subject { Reification.from_term(query)}
+
+      let(:query) { QueryHash.new(param: Pact.each_like("1", min: 2)) }
+
+      it "turns the hash into a string with the right number of params" do
+        expect(subject).to eq("param=1&param=1")
+      end
     end
 
+    context "with a StringWithMatchingRules" do
+      subject { Reification.from_term(StringWithMatchingRules.new("foo", Pact::SpecificationVersion.new("3"), {}))}
+
+      it "returns a String" do
+        expect(subject.class).to be String
+      end
+    end
   end
 end

data/spec/lib/pact/shared/multipart_form_differ_spec.rb

@@ -0,0 +1,39 @@
+require 'pact/shared/multipart_form_differ'
+
+module Pact
+  describe MultipartFormDiffer do
+
+    describe ".call" do
+
+      let(:expected_body) do
+        "-------------RubyMultipartPost-1e4912957c7bb64de3c444568326663b\r\nContent-Disposition: form-data; name=\"file\"; filename=\"text.txt\"\r\nContent-Length: 14\r\nContent-Type: text/plain\r\nContent-Transfer-Encoding: binary\r\n\r\nThis is a file\r\n-------------RubyMultipartPost-1e4912957c7bb64de3c444568326663b--\r\n\r\n"
+      end
+
+      let(:actual_body) do
+        "-------------RubyMultipartPost-1e4912957c7bb64de3c4445683266XXX\r\nContent-Disposition: form-data; name=\"file\"; filename=\"text.txt\"\r\nContent-Length: 14\r\nContent-Type: text/plain\r\nContent-Transfer-Encoding: binary\r\n\r\nThis is a file\r\n-------------RubyMultipartPost-1e4912957c7bb64de3c4445683266XXX--\r\n\r\n"
+      end
+
+      let(:options) do
+        {}
+      end
+
+      subject { MultipartFormDiffer.call(expected_body, actual_body, options) }
+
+      context "when the bodies are the same apart from the boundary" do
+        it "returns an empty diff" do
+          expect(subject).to eq({})
+        end
+      end
+
+      context "when the bodies are not the same" do
+        let(:actual_body) do
+          "-------------RubyMultipartPost-1e4912957c7bb64de3c4445683266XXX\r\nContent-Disposition: form-data; name=\"file\"; filename=\"bar.txt\"\r\nContent-Length: 14\r\nContent-Type: text/plain\r\nContent-Transfer-Encoding: binary\r\n\r\nThis is a file\r\n-------------RubyMultipartPost-1e4912957c7bb64de3c4445683266XXX--\r\n\r\n"
+        end
+
+        it "returns a text diff" do
+          expect(subject).to_not eq({})
+        end
+      end
+    end
+  end
+end

data/spec/support/factories.rb

@@ -40,6 +40,11 @@ class InteractionFactory
             'body' => {a: 'response body'}
         }
     }
+
+    if hash.key?(:provider_states) || hash.key?('provider_states')
+      defaults.delete('provider_state')
+    end
+
     Pact::Interaction.from_hash(stringify_keys(deep_merge(defaults, stringify_keys(hash))))
   end
 end

data/tasks/spec.rake

@@ -12,4 +12,3 @@ task :spec_with_active_support => [:set_active_support_on] do
 end
 
 task :default => [:spec, :spec_with_active_support]
-