pact-support 1.4.0 → 1.8.0

data/spec/fixtures/pact-http-v3.json

@@ -0,0 +1,36 @@
+{
+  "consumer": {
+    "name": "consumer"
+  },
+  "interactions": [
+    {
+      "description": "a test request",
+      "providerState": "the weather is sunny",
+      "request": {
+        "method": "get",
+        "path": "/foo"
+      },
+      "response": {
+        "body": {
+          "foo": "bar"
+        },
+        "matchingRules": {
+          "body": {
+            "$.foo": {
+              "matchers": [{ "match": "type" }]
+            }
+          }
+        },
+        "status": 200
+      }
+    }
+  ],
+  "provider": {
+    "name": "provider"
+  },
+  "metadata": {
+    "pactSpecification": {
+      "version": "3.0"
+    }
+  }
+}

data/spec/integration/matching_rules_extract_and_merge_spec.rb

@@ -1,7 +1,9 @@
 require 'pact/term'
 require 'pact/something_like'
 require 'pact/matching_rules/extract'
+require 'pact/matching_rules/v3/extract'
 require 'pact/matching_rules/merge'
+require 'pact/matching_rules/v3/merge'
 require 'pact/reification'
 
 describe "converting Pact::Term and Pact::SomethingLike to matching rules and back again" do
@@ -10,6 +12,9 @@ describe "converting Pact::Term and Pact::SomethingLike to matching rules and ba
   let(:matching_rules) { Pact::MatchingRules::Extract.(expected) }
   let(:recreated_expected) { Pact::MatchingRules::Merge.(example, matching_rules)}
 
+  let(:recreated_expected_v3) { Pact::MatchingRules::V3::Merge.(example, matching_rules_v3) }
+  let(:matching_rules_v3) { Pact::MatchingRules::V3::Extract.(expected) }
+
   context "with a Pact::Term" do
     let(:expected) do
       {
@@ -21,9 +26,29 @@ describe "converting Pact::Term and Pact::SomethingLike to matching rules and ba
       }
     end
 
-    it "recreates the same object hierarchy" do
+    it "recreates the same object hierarchy with v2 matching" do
+      expect(recreated_expected).to eq expected
+    end
+
+    it "recreates the same object hierarchy with v3 matching" do
+      expect(recreated_expected_v3).to eq expected
+    end
+  end
+
+  context "with a Pact::SomethingLike containing a Pact::ArrayLike" do
+    let(:expected) do
+      {
+        body: Pact::SomethingLike.new(children: Pact::ArrayLike.new("foo", min: 2))
+      }
+    end
+
+    it "recreates the same object hierarchy with v2 matching" do
       expect(recreated_expected).to eq expected
     end
+
+    it "recreates the same object hierarchy with v3 matching" do
+      expect(recreated_expected_v3).to eq expected
+    end
   end
 
   context "with a Pact::SomethingLike" do
@@ -37,9 +62,13 @@ describe "converting Pact::Term and Pact::SomethingLike to matching rules and ba
       }
     end
 
-    it "recreates the same object hierarchy" do
+    it "recreates the same object hierarchy with v2 matching" do
       expect(recreated_expected).to eq expected
     end
+
+    it "recreates the same object hierarchy with v3 matching" do
+      expect(recreated_expected_v3).to eq expected
+    end
   end
 
   context "with a Pact::SomethingLike containing a Hash" do
@@ -61,9 +90,13 @@ describe "converting Pact::Term and Pact::SomethingLike to matching rules and ba
       }
     end
 
-    it "recreates the same object hierarchy" do
+    it "recreates the same object hierarchy with v2 matching" do
       expect(recreated_expected).to eq expected
     end
+
+    it "recreates the same object hierarchy with v3 matching" do
+      expect(recreated_expected_v3).to eq expected
+    end
   end
 
   context "with a Pact::SomethingLike containing an Array" do
@@ -83,8 +116,12 @@ describe "converting Pact::Term and Pact::SomethingLike to matching rules and ba
       }
     end
 
-    it "recreates the same object hierarchy" do
+    it "recreates the same object hierarchy with v2 matching" do
       expect(recreated_expected).to eq expected
     end
+
+    it "recreates the same object hierarchy with v3 matching" do
+      expect(recreated_expected_v3).to eq expected
+    end
   end
 end

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

@@ -38,12 +38,14 @@ module Pact
 
       describe "matches_criteria?" do
         subject { InteractionFactory.create(:description => 'a request for food') }
+
         context "by description" do
           context "when the interaction matches" do
             it "returns true" do
               expect(subject.matches_criteria?(:description => /request.*food/)).to be true
             end
           end
+
           context "when the interaction does not match" do
             it "returns false" do
               expect(subject.matches_criteria?(:description => /blah/)).to be false
@@ -52,33 +54,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
-
         let(:interaction) { Interaction.new(request: request, response: response)}
 
         subject { interaction.request_modifies_resource_without_checking_response_body?}

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

@@ -0,0 +1,54 @@
+require 'pact/consumer_contract/interaction_v2_parser'
+
+module Pact
+  describe InteractionV2Parser do
+    describe ".call" do
+      let(:interaction_hash) do
+        {
+          "description" => "description",
+          "request" => { "method" => "GET", "path" => "/" },
+          "response" => { "status" => 200 },
+          "providerState" => "foo"
+        }
+      end
+
+      let(:options) do
+        {
+          pact_specification_version: Pact::SpecificationVersion.new("3.0")
+        }
+      end
+
+      subject { InteractionV2Parser.call(interaction_hash, options) }
+
+      describe "provider_states" do
+        it "returns an array of provider states with size 1" do
+          expect(subject.provider_states.size).to eq 1
+        end
+
+        it "sets the name of the provider state to the string provided" do
+          expect(subject.provider_states.first.name)
+        end
+
+        it "sets the params to an empty hash" do
+          expect(subject.provider_states.first.params).to eq({})
+        end
+
+        context "when the providerState is nil" do
+          before do
+            interaction_hash["providerState"] = nil
+          end
+
+          it "returns an empty list" do
+            expect(subject.provider_states).to be_empty
+          end
+        end
+      end
+
+      describe "provider_state" do
+        it "sets the name from the hash" do
+          expect(subject.provider_state).to eq "foo"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+require 'pact/consumer_contract/interaction_v3_parser'
+
+module Pact
+  describe InteractionV3Parser do
+    describe ".call" do
+
+      let(:interaction_hash) do
+        {
+          "description" => "description",
+          "request" => { "method" => "GET", "path" => "/" },
+          "response" => { "status" => 200 },
+          "providerStates" => [{
+            "name" => "foo",
+            "params" => {"a" => "b"}
+          }]
+        }
+      end
+
+      let(:options) do
+        {
+          pact_specification_version: Pact::SpecificationVersion.new("3.0")
+        }
+      end
+
+      subject { InteractionV3Parser.call(interaction_hash, options) }
+
+      describe "provider_states" do
+        it "parses the array of provider states" do
+          expect(subject.provider_states.size).to eq 1
+        end
+
+        it "parses the name of each" do
+          expect(subject.provider_states.first.name)
+        end
+
+        it "parses the params of each" do
+          expect(subject.provider_states.first.params).to eq "a" => "b"
+        end
+      end
+
+      describe "provider_state" do
+        it "sets the provider_state string to the name of the first providerState for backwards compatibility while we implement v3" do
+          expect(subject.provider_state).to eq "foo"
+        end
+      end
+    end
+  end
+end

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