pact-support 1.4.0 → 1.7.0

data/spec/lib/pact/consumer_contract/consumer_contract_spec.rb

@@ -3,50 +3,73 @@ require 'pact/consumer_contract'
 
 module Pact
   describe ConsumerContract do
+    describe "from_uri" do
+      context "when the URL does not point to a valid pact" do
+        subject { ConsumerContract.from_uri('spec/fixtures/not-a-pact.json') }
+
+        it "raises a helpful error" do
+          expect { subject }.to raise_error UnrecognizePactFormatError, /Please check that spec/
+        end
+      end
+    end
+
+    describe "from_hash" do
+      context "when the hash is not a valid pact" do
+        subject { ConsumerContract.from_hash({'foo' => 'bar'}) }
+
+        it "raises a helpful error" do
+          expect { subject }.to raise_error UnrecognizePactFormatError, 'This document does not use a recognised Pact format: {"foo"=>"bar"}'
+        end
+      end
+    end
 
     describe ".from_json" do
+
       let(:loaded_pact) { ConsumerContract.from_json(string) }
-      context "when the top level object is a ConsumerContract" do
-        let(:string) { '{"interactions":[{"request": {"path":"/path", "method" : "get"}, "response": {"status" : 200}}], "consumer": {"name" : "Bob"} , "provider": {"name" : "Mary"} }' }
 
-        it "should create a Pact" do
-          expect(loaded_pact).to be_instance_of ConsumerContract
-        end
+      context "with an HTTP contract" do
+        context "when the top level object is a ConsumerContract" do
+          let(:string) { '{"interactions":[{"request": {"path":"/path", "method" : "get"}, "response": {"status" : 200}}], "consumer": {"name" : "Bob"} , "provider": {"name" : "Mary"} }' }
 
-        it "should have interactions" do
-          expect(loaded_pact.interactions).to be_instance_of Array
-        end
+          it "should create a Pact" do
+            expect(loaded_pact).to be_instance_of ConsumerContract
+          end
 
-        it "should have a consumer" do
-          expect(loaded_pact.consumer).to be_instance_of Pact::ServiceConsumer
-        end
+          it "should have interactions" do
+            expect(loaded_pact.interactions).to be_instance_of Array
+          end
 
-        it "should have a provider" do
-          expect(loaded_pact.provider).to be_instance_of Pact::ServiceProvider
-        end
-      end
+          it "should have a consumer" do
+            expect(loaded_pact.consumer).to be_instance_of Pact::ServiceConsumer
+          end
 
-      context "with old 'producer' key" do
-        let(:string) { File.read('./spec/support/a_consumer-a_producer.json')}
-        it "should create a Pact" do
-          expect(loaded_pact).to be_instance_of ConsumerContract
+          it "should have a provider" do
+            expect(loaded_pact.provider).to be_instance_of Pact::ServiceProvider
+          end
         end
 
-        it "should have interactions" do
-          expect(loaded_pact.interactions).to be_instance_of Array
-        end
+        context "with old 'producer' key" do
+          let(:string) { File.read('./spec/support/a_consumer-a_producer.json')}
+          it "should create a Pact" do
+            expect(loaded_pact).to be_instance_of ConsumerContract
+          end
 
-        it "should have a consumer" do
-          expect(loaded_pact.consumer).to be_instance_of Pact::ServiceConsumer
-        end
+          it "should have interactions" do
+            expect(loaded_pact.interactions).to be_instance_of Array
+          end
 
-        it "should have a provider" do
-          expect(loaded_pact.provider).to be_instance_of Pact::ServiceProvider
-          expect(loaded_pact.provider.name).to eq "an old producer"
-        end
+          it "should have a consumer" do
+            expect(loaded_pact.consumer).to be_instance_of Pact::ServiceConsumer
+          end
 
-        it "should have a provider_state" do
-          expect(loaded_pact.interactions.first.provider_state).to eq 'state one'
+          it "should have a provider" do
+            expect(loaded_pact.provider).to be_instance_of Pact::ServiceProvider
+            expect(loaded_pact.provider.name).to eq "an old producer"
+          end
+
+          it "should have a provider_state" do
+            expect(loaded_pact.interactions.first.provider_state).to eq 'state one'
+          end
         end
       end
     end

data/spec/lib/pact/consumer_contract/http_consumer_contract_parser_spec.rb

@@ -0,0 +1,25 @@
+require 'pact/consumer_contract/http_consumer_contract_parser'
+
+module Pact
+  describe HttpConsumerContractParser do
+    describe "#call integration test" do
+      subject { HttpConsumerContractParser.new.call(pact_hash) }
+
+      context "with a v2 pact" do
+        let(:pact_hash) { load_json_fixture('pact-http-v2.json') }
+
+        it "correctly parses the pact" do
+          expect(subject.interactions.first.response.headers['Content-Type']).to be_a(Pact::Term)
+        end
+      end
+
+      context "with a v3 pact" do
+        let(:pact_hash) { load_json_fixture('pact-http-v3.json') }
+
+        it "correctly parses the pact" do
+          expect(subject.interactions.first.response.body['foo']).to be_a(Pact::SomethingLike)
+        end
+      end
+    end
+  end
+end

data/spec/lib/pact/consumer_contract/interaction_parser_spec.rb

@@ -0,0 +1,62 @@
+require 'pact/consumer_contract/interaction_parser'
+
+module Pact
+  describe InteractionParser do
+    describe ".call" do
+
+      let(:request) { {method: 'get', path: 'path'} }
+      let(:response) { {} }
+
+      context "when providerState has been used instead of provider_state" do
+
+        subject { InteractionParser.call('response' => response, 'request' => request, 'providerState' => 'some state') }
+
+        it "recognises the provider state" do
+          expect(subject.provider_state).to eq 'some state'
+        end
+      end
+
+      context "when there are matching rules" do
+        let(:hash) { load_json_fixture 'interaction-with-matching-rules.json' }
+
+        subject { InteractionParser.call(hash, pact_specification_version: Pact::SpecificationVersion.new("2")) }
+
+        it "merges the rules with the example for the request" do
+          expect(subject.request.body['name']).to be_instance_of(Pact::Term)
+        end
+
+        it "merges the rules with the example for the response" do
+          expect(subject.response.body['_links']['self']['href']).to be_instance_of(Pact::Term)
+        end
+      end
+
+      context "when the request body is a String" do
+        let(:hash) { { 'request' => request, 'response' => response } }
+        subject { InteractionParser.call(hash, pact_specification_version: Pact::SpecificationVersion.new("3")) }
+
+        let(:request) { { 'method' => 'get', 'path' => 'path' , 'body' => "<xml></xml>", 'matchingRules' => {"body" => {"foo" => "bar"} } } }
+
+        it "returns an interaction with an StringWithMatchingRules in the request" do
+          expect(subject.request.body).to be_a(Pact::StringWithMatchingRules)
+          expect(subject.request.body).to eq "<xml></xml>"
+          expect(subject.request.body.matching_rules).to eq "foo" => "bar"
+          expect(subject.request.body.pact_specification_version).to eq Pact::SpecificationVersion.new("3")
+        end
+      end
+
+      context "when the response body is a String" do
+        let(:hash) { { 'request' => request, 'response' => response } }
+        subject { InteractionParser.call(hash, pact_specification_version: Pact::SpecificationVersion.new("3")) }
+
+        let(:response) { { 'status' => '200', 'body' => "<xml></xml>", 'matchingRules' => {"body" => {"foo" => "bar"} } } }
+
+        it "returns an interaction with an StringWithMatchingRules in the response" do
+          expect(subject.response.body).to be_a(Pact::StringWithMatchingRules)
+          expect(subject.response.body).to eq "<xml></xml>"
+          expect(subject.response.body.matching_rules).to eq "foo" => "bar"
+          expect(subject.response.body.pact_specification_version).to eq Pact::SpecificationVersion.new("3")
+        end
+      end
+    end
+  end
+end

data/spec/lib/pact/consumer_contract/interaction_spec.rb

@@ -52,30 +52,7 @@ module Pact
         end
       end
 
-      describe "from_hash" do
-        context "when providerState has been used instead of provider_state" do
 
-          subject { Interaction.from_hash('response' => response, 'request' => request, 'providerState' => 'some state') }
-
-          it "recognises the provider state" do
-            expect(subject.provider_state).to eq 'some state'
-          end
-        end
-
-        context "when there are matching rules" do
-          let(:hash) { load_json_fixture 'interaction-with-matching-rules.json' }
-
-          subject { Interaction.from_hash hash }
-
-          it "merges the rules with the example for the request" do
-            expect(subject.request.body['name']).to be_instance_of(Pact::Term)
-          end
-
-          it "merges the rules with the example for the response" do
-            expect(subject.response.body['_links']['self']['href']).to be_instance_of(Pact::Term)
-          end
-        end
-      end
 
       describe "request_modifies_resource_without_checking_response_body?" do
 

data/spec/lib/pact/consumer_contract/pact_file_spec.rb

@@ -25,6 +25,15 @@ module Pact
         end
       end
 
+      describe 'with backslashes to a local path' do
+        let(:windows_path) { 'spec\support\a_consumer-a_provider.json' }
+        let(:unix_path) { 'spec/support/a_consumer-a_provider.json' }
+
+        it 'transforms them to forward slashes' do
+          expect(PactFile.read(windows_path)).to eq PactFile.read(unix_path)
+        end
+      end
+
       context 'without basic authentication' do
         before do
           stub_request(:get, uri_without_userinfo).to_return(body: pact_content)

data/spec/lib/pact/consumer_contract/query_hash_spec.rb

@@ -72,6 +72,15 @@ module Pact
             expect(subject.difference(other).keys).to contain_exactly(:"param[a]", :"param[a][aa]", :"param[a][bb]")
           end
         end
+
+        context "when there is an ArrayLike" do
+          let(:query) { { param: Pact.each_like("1") } }
+          let(:other) { QueryString.new('param=1&param=2') }
+
+          it 'returns an empty diff' do
+            expect(subject.difference(other)).to be_empty
+          end
+        end
       end
     end
 
@@ -82,6 +91,20 @@ module Pact
     end
 
     describe "#to_json" do
+      context "when the query contains an ArrayLike" do
+        let(:query) { { foo: Pact.each_like("1"), bar: "2" } }
+        let(:expected_json) do
+          {
+            foo: Pact.each_like("1"),
+            bar: ["2"]
+          }.to_json
+        end
+
+        it "serialises the ArrayLike without wrapping an array around it" do
+          expect(subject.to_json).to eq expected_json
+        end
+      end
+
       context "when the query contains a Pact::Term" do
         let(:term) { Pact::Term.new(generate: "thing", matcher: /th/) }
         let(:query) { { param: term } }

data/spec/lib/pact/matchers/multipart_form_diff_formatter_spec.rb

@@ -0,0 +1,36 @@
+require 'pact/matchers/multipart_form_diff_formatter'
+
+module Pact
+  module Matchers
+    describe MultipartFormDiffFormatter do
+      describe ".call" do
+        subject { MultipartFormDiffFormatter.call(diff, options)}
+
+        let(:diff) do
+          {
+            headers: header_diff,
+            body: body_diff
+          }
+        end
+
+        let(:header_diff) do
+          {
+            "Content-Type" => Difference.new("foo", "bar", "Wrong header")
+          }
+        end
+
+        let(:body_diff) do
+          Difference.new("foo", "bar", "A message")
+        end
+
+        let(:options) { {} }
+
+        let(:expected_output) { File.read("spec/fixtures/multipart-form-diff.txt")}
+
+        it "formats the diff" do
+          expect(subject).to eq expected_output
+        end
+      end
+    end
+  end
+end

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)
+        end
+
         let(:expected) do
           {
             "name" => "Mary"
@@ -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" => {
@@ -178,6 +192,7 @@ module Pact
               "$.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'
@@ -259,6 +274,10 @@ module Pact
         end
 
         describe "with an example array with more than one item" do
+          before do
+            allow(Pact.configuration.error_stream).to receive(:puts)
+          end
+
           let(:expected) do
             {
 
@@ -277,13 +296,7 @@ module Pact
             }
           end
 
-          xit "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

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