pact 0.1.28 → 1.3.3

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

@@ -0,0 +1,180 @@
+require 'spec_helper'
+require 'pact/consumer_contract'
+
+module Pact
+  describe ConsumerContract do
+    describe "as_json" do
+
+      class MockInteraction
+        def as_json(options ={})
+          {:mock => "interaction"}
+        end
+      end
+
+      before do
+        allow(DateTime).to receive(:now).and_return(DateTime.strptime("2013-08-15T13:27:13+10:00"))
+      end
+
+      let(:service_consumer) { double('ServiceConsumer', :as_json => {:a => 'consumer'}) }
+      let(:service_provider) { double('ServiceProvider', :as_json => {:a => 'provider'}) }
+      let(:pact) { ConsumerContract.new({:interactions => [MockInteraction.new], :consumer => service_consumer, :provider => service_provider }) }
+      let(:expected_as_json) { {:provider=>{:a=>"provider"}, :consumer=>{:a=>"consumer"}, :interactions=>[{:mock=>"interaction"}], :metadata=>{:pactSpecificationVersion=> "1.0.0" }} }
+
+      it "should return a hash representation of the Pact" do
+        expect(pact.as_json).to eq expected_as_json
+      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"}}], "consumer": {"name" : "Bob"} , "provider": {"name" : "Mary"} }' }
+
+        it "should create a Pact" do
+          expect(loaded_pact).to be_instance_of ConsumerContract
+        end
+
+        it "should have interactions" do
+          expect(loaded_pact.interactions).to be_instance_of Array
+        end
+
+        it "should have a consumer" do
+          expect(loaded_pact.consumer).to be_instance_of Pact::ServiceConsumer
+        end
+
+        it "should have a provider" do
+          expect(loaded_pact.provider).to be_instance_of Pact::ServiceProvider
+        end
+      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 interactions" do
+          expect(loaded_pact.interactions).to be_instance_of Array
+        end
+
+        it "should have a consumer" do
+          expect(loaded_pact.consumer).to be_instance_of Pact::ServiceConsumer
+        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 provider_state" do
+          expect(loaded_pact.interactions.first.provider_state).to eq 'state one'
+        end
+      end
+    end
+
+    describe "find_interactions" do
+      let(:consumer) { double('Pact::ServiceConsumer', :name => 'Consumer')}
+      let(:provider) { double('Pact::ServiceProvider', :name => 'Provider')}
+      let(:interaction) { double('Pact::Interaction') }
+      subject { ConsumerContract.new(:interactions => [interaction], :consumer => consumer, :provider => provider) }
+      let(:criteria) { {:description => /blah/} }
+      before do
+        expect(interaction).to receive(:matches_criteria?).with(criteria).and_return(matches)
+      end
+      context "by description" do
+        context "when no interactions are found" do
+          let(:matches) { false }
+          it "returns an empty array" do
+            expect(subject.find_interactions(criteria)).to eql []
+          end
+        end
+        context "when interactions are found" do
+          let(:matches) { true }
+          it "returns an array of the matching interactions" do
+            expect(subject.find_interactions(criteria)).to eql [interaction]
+          end
+        end
+      end
+    end
+
+    describe "find_interaction" do
+      let(:consumer) { double('Pact::ServiceConsumer', :name => 'Consumer')}
+      let(:provider) { double('Pact::ServiceProvider', :name => 'Provider')}
+      let(:interaction1) { double('Pact::Interaction') }
+      let(:interaction2) { double('Pact::Interaction') }
+      let(:criteria) { {:description => /blah/} }
+
+      before do
+        expect(interaction1).to receive(:matches_criteria?).with(criteria).and_return(matches1)
+        expect(interaction2).to receive(:matches_criteria?).with(criteria).and_return(matches2)
+      end
+
+      subject { ConsumerContract.new(:interactions => [interaction1, interaction2], :consumer => consumer, :provider => provider) }
+      context "by description" do
+        context "when a match is found" do
+          let(:matches1) { true }
+          let(:matches2) { false }
+
+          it "returns the interaction" do
+            expect(subject.find_interaction criteria).to eql interaction1
+          end
+        end
+        context "when more than one match is found" do
+          let(:matches1) { true }
+          let(:matches2) { true }
+          it "raises an error" do
+            expect{ subject.find_interaction(criteria) }.to raise_error "Found more than 1 interaction matching {:description=>/blah/} in pact file between Consumer and Provider."
+          end
+        end
+        context "when a match is not found" do
+          let(:matches1) { false }
+          let(:matches2) { false }
+          it "raises an error" do
+            expect{ subject.find_interaction(criteria) }.to raise_error "Could not find interaction matching {:description=>/blah/} in pact file between Consumer and Provider."
+          end
+        end
+      end
+    end
+
+    describe "update_pactfile" do
+      let(:pacts_dir) { Pathname.new("./tmp/pactfiles") }
+      let(:expected_pact_path) { pacts_dir + "test_consumer-test_service.json" }
+      let(:expected_pact_string) do <<-eos
+{
+  "provider": {
+    "name": "test_service"
+  },
+  "consumer": {
+    "name": "test_consumer"
+  },
+  "interactions": [
+    "something"
+  ],
+  "metadata": {
+    "pactSpecificationVersion": "1.0.0"
+  }
+}
+eos
+      end
+      let(:consumer) { Pact::ServiceConsumer.new(:name => 'test_consumer')}
+      let(:provider) { Pact::ServiceProvider.new(:name => 'test_service')}
+      let(:interactions) { [double("interaction", as_json: "something")]}
+      subject { ConsumerContract.new(:consumer => consumer, :provider => provider, :interactions => interactions) }
+      before do
+        allow(Pact.configuration).to receive(:pact_dir).and_return(Pathname.new("./tmp/pactfiles"))
+        FileUtils.rm_rf pacts_dir
+        FileUtils.mkdir_p pacts_dir
+        subject.update_pactfile
+      end
+
+      it "should write to a file specified by the consumer and provider name" do
+        expect(File.exist?(expected_pact_path)).to eq true
+      end
+
+      it "should write the interactions to the file" do
+        expect(File.read(expected_pact_path)).to eql expected_pact_string.strip
+      end
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+require 'spec_helper'
+require 'pact/consumer_contract/consumer_contract_writer'
+
+module Pact
+
+  describe ConsumerContractWriter do
+
+    let(:support_pact_file) { './spec/support/a_consumer-a_provider.json' }
+    let(:consumer_name) { 'a consumer' }
+    let(:provider_name) { 'a provider' }
+
+    before do
+      Pact.clear_configuration
+      allow(Pact.configuration).to receive(:pact_dir).and_return(File.expand_path(tmp_pact_dir))
+      FileUtils.rm_rf tmp_pact_dir
+      FileUtils.mkdir_p tmp_pact_dir
+      FileUtils.cp support_pact_file, "#{tmp_pact_dir}/a_consumer-a_provider.json"
+    end
+
+    let(:existing_interactions) { ConsumerContract.from_json(File.read(support_pact_file)).interactions }
+    let(:new_interactions) { [InteractionFactory.create] }
+    let(:tmp_pact_dir) {"./tmp/pacts"}
+    let(:logger) { double("logger").as_null_object }
+    let(:pactfile_write_mode) {:overwrite}
+    let(:consumer_contract_details) {
+      {
+          consumer: {name: consumer_name},
+          provider: {name: provider_name},
+          pactfile_write_mode: pactfile_write_mode,
+          interactions: new_interactions
+      }
+    }
+
+    let(:consumer_contract_writer) { ConsumerContractWriter.new(consumer_contract_details, logger) }
+
+    describe "consumer_contract" do
+
+      let(:subject) { consumer_contract_writer.consumer_contract }
+
+      context "when overwriting pact" do
+
+        it "it uses only the interactions from the current test run" do
+          expect(consumer_contract_writer.consumer_contract.interactions).to eq new_interactions
+        end
+
+      end
+
+      context "when updating pact" do
+
+        let(:pactfile_write_mode) {:update}
+
+        it "merges the interactions from the current test run with the interactions from the existing file" do
+          allow_any_instance_of(ConsumerContractWriter).to receive(:info_and_puts)
+          expect(consumer_contract_writer.consumer_contract.interactions).to eq  existing_interactions + new_interactions
+        end
+
+        let(:line0) { /\*/ }
+        let(:line1) { /Updating existing file/ }
+        let(:line2) { /Only interactions defined in this test run will be updated/ }
+        let(:line3) { /As interactions are identified by description and provider state/ }
+
+        it "logs a description message" do
+          expect($stdout).to receive(:puts).with(line0).twice
+          expect($stdout).to receive(:puts).with(line1)
+          expect($stdout).to receive(:puts).with(line2)
+          expect($stdout).to receive(:puts).with(line3)
+          expect(logger).to receive(:info).with(line0).twice
+          expect(logger).to receive(:info).with(line1)
+          expect(logger).to receive(:info).with(line2)
+          expect(logger).to receive(:info).with(line3)
+          consumer_contract_writer.consumer_contract
+        end
+      end
+
+      context "when an error occurs deserializing the existing pactfile" do
+
+        let(:pactfile_write_mode) {:update}
+        let(:error) { RuntimeError.new('some error')}
+        let(:line1) { /Could not load existing consumer contract from .* due to some error/ }
+        let(:line2) {'Creating a new file.'}
+
+        before do
+          allow(ConsumerContract).to receive(:from_json).and_raise(error)
+          allow($stderr).to receive(:puts)
+          allow(logger).to receive(:puts)
+        end
+
+        it "logs the error" do
+          expect($stderr).to receive(:puts).with(line1)
+          expect($stderr).to receive(:puts).with(line2)
+          expect(logger).to receive(:warn).with(line1)
+          expect(logger).to receive(:warn).with(line2)
+          consumer_contract_writer.consumer_contract
+        end
+
+        it "uses the new interactions" do
+          expect(consumer_contract_writer.consumer_contract.interactions).to eq new_interactions
+        end
+      end
+    end
+
+    describe "write" do
+      it "writes the pact file" do
+        expect_any_instance_of(ConsumerContract).to receive(:update_pactfile)
+        consumer_contract_writer.write
+      end
+    end
+
+  end
+
+end

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

@@ -0,0 +1,107 @@
+require 'spec_helper'
+require 'pact/consumer_contract/headers'
+
+module Pact
+  describe Headers do
+
+    describe "initialize" do
+
+      context "with duplicate headers" do
+
+        subject { Headers.new('Content-Type' => 'application/hippo', 'CONTENT-TYPE' => 'application/giraffe') }
+
+        it "raises an error" do
+          expect { subject }.to raise_error DuplicateHeaderError, /Content\-Type.*CONTENT\-TYPE/
+        end
+
+      end
+
+      context "with a symbol as a header name" do
+
+        subject { Headers.new(:'content-type' => 'application/hippo') }
+
+        it "converts the header name to a String" do
+          expect( subject.to_hash ).to eq 'content-type' => 'application/hippo'
+        end
+
+      end
+
+      context "with a nil header name" do
+
+        subject { Headers.new(nil => 'application/hippo') }
+
+        it "raises an error" do
+          expect{ subject }.to raise_error InvalidHeaderNameTypeError
+        end
+
+      end
+
+      context "with a boolean header name" do
+
+        subject { Headers.new(false => 'application/hippo') }
+
+        it "raises an error" do
+          expect{ subject }.to raise_error InvalidHeaderNameTypeError
+        end
+
+      end
+
+    end
+
+    describe "[]" do
+
+      subject { Headers.new 'Content-Type' => 'application/hippo' }
+
+      it "is case insensitive as HTTP headers are case insensitive" do
+        expect(subject['Content-Type']).to eq('application/hippo')
+        expect(subject['CONTENT-TYPE']).to eq('application/hippo')
+        expect(subject['content-type']).to eq('application/hippo')
+      end
+
+    end
+
+    describe "fetch" do
+
+      subject { Headers.new 'Content-Type' => 'application/hippo' }
+
+      it "is case insensitive as HTTP headers are case insensitive" do
+        expect(subject.fetch('Content-Type')).to eq('application/hippo')
+        expect(subject.fetch('CONTENT-TYPE')).to eq('application/hippo')
+        expect(subject.fetch('content-type')).to eq('application/hippo')
+        expect(subject.fetch('Content-Length','1')).to eq('1')
+        expect { subject.fetch('Content-Length')}.to raise_error KeyError
+      end
+
+    end
+
+    describe "key?" do
+
+      subject { Headers.new 'Content-Type' => 'application/hippo' }
+
+      it "is case insensitive as HTTP headers are case insensitive" do
+        expect(subject.key?('CONTENT-TYPE')).to be true
+        expect(subject.key?('CONTENT-LENGTH')).to be false
+      end
+    end
+
+    describe "has_key?" do
+
+      subject { Headers.new 'Content-Type' => 'application/hippo' }
+
+      it "is case insensitive as HTTP headers are case insensitive" do
+        expect(subject.has_key?('CONTENT-TYPE')).to be true
+        expect(subject.has_key?('CONTENT-LENGTH')).to be false
+      end
+    end
+
+    describe "[]=" do
+
+      subject { Headers.new }
+
+      it "does not allow modification" do
+        expect{ subject['Content-Type'] = 'application/hippo' }.to raise_error /frozen/
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+require 'spec_helper'
+require 'pact/reification'
+require 'pact/consumer_contract/interaction'
+
+module Pact
+  module Consumer
+
+    describe Interaction do
+
+      let(:request) { {method: 'get', path: 'path'} }
+      let(:response) { {} }
+
+      describe "==" do
+        subject { InteractionFactory.create }
+        context "when other is the same" do
+          let(:other) { InteractionFactory.create }
+          it "returns true" do
+            expect(subject == other).to be true
+          end
+        end
+        context "when other is not the same" do
+          let(:other) { InteractionFactory.create(:request => {:path => '/a_different_path'}) }
+          it "returns false" do
+            expect(subject == other).to be false
+          end
+        end
+      end
+
+      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
+            end
+          end
+        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
+      end
+
+      describe "to JSON" do
+        let(:request) do
+          {
+            method: 'post',
+            path: '/foo',
+            body: Term.new(generate: 'waffle', matcher: /ffl/),
+            headers: { 'Content-Type' => 'application/json' },
+            query: '',
+          }
+        end
+
+        let(:response) do
+          { baz: /qux/, wiffle: Term.new(generate: 'wiffle', matcher: /iff/) }
+        end
+
+        let(:parsed_result) do
+          JSON.load(subject.to_json)
+        end
+
+        subject { Interaction.from_hash('response' => response, 'request' => request) }
+
+        it "contains the request" do
+          expect(parsed_result['request']).to eq({
+              'method' => 'post',
+              'path' => '/foo',
+              'headers' => {
+                'Content-Type' => 'application/json'
+              },
+              'body' => Term.new(generate: 'waffle', matcher: /ffl/),
+              'query' => ''
+            })
+        end
+
+        describe "response" do
+
+          it "serialises regexes" do
+            expect(parsed_result['response']['baz']).to eql /qux/
+          end
+
+          it "serialises terms" do
+            term = Term.new(generate:'wiffle', matcher: /iff/)
+            parsed_term = parsed_result['response']['wiffle']
+            expect(term.matcher).to eql parsed_term.matcher
+            expect(term.generate).to eql parsed_term.generate
+          end
+
+        end
+
+      end
+    end
+  end
+end