pact-mock_service 0.2.2 → 0.2.3.pre.rc1

data/spec/lib/pact/consumer/mock_service_client_spec.rb

@@ -1,88 +0,0 @@
-require 'spec_helper'
-require 'pact/consumer/mock_service_client'
-
-module Pact
-  module Consumer
-    describe MockServiceClient do
-
-      subject { MockServiceClient.new(4444) }
-
-      let(:administration_headers) { {'X-Pact-Mock-Service' => 'true'} }
-
-      describe "#add_expected_interaction" do
-        let(:interaction) { InteractionFactory.create }
-        let(:request_body) { Pact::MockService::InteractionDecorator.new(interaction).to_json }
-
-        context "when successful" do
-          let!(:post_interaction) do
-            stub_request(:post, "localhost:4444/interactions").
-              with(body: request_body, headers: administration_headers.merge('Content-Type' => "application/json")).
-              to_return(status: 200)
-          end
-
-          it "sets up the expected interaction on the mock server" do
-            subject.add_expected_interaction interaction
-            expect(post_interaction).to have_been_made
-          end
-        end
-
-      end
-
-      describe "#verify" do
-
-        context "when all interactions are successfully verified" do
-
-          let!(:get_verification) do
-            stub_request(:get, "localhost:4444/interactions/verification?example_description=some%20example").
-              with(headers: administration_headers).
-              to_return(status: 200)
-          end
-
-          it "does not throw an error" do
-            subject.verify "some example"
-            expect(get_verification).to have_been_made
-          end
-        end
-      end
-
-      describe ".clear_interactions" do
-        let!(:delete_verifications) do
-          stub_request(:delete, "localhost:4444/interactions?example_description=some%20example").
-            with(headers: administration_headers).
-            to_return(status: 200)
-        end
-
-        it "deletes the interactions" do
-          MockServiceClient.clear_interactions 4444, "some example"
-          expect(delete_verifications).to have_been_made
-        end
-      end
-
-      describe "#write_pact" do
-        let(:consumer_contract_details) { {consumer: {name: 'Consumer'}, provider: {name: 'Provider'}, pactfile_write_mode: 'update'} }
-        let(:pact) { {a: 'pact'}.to_json }
-
-        let!(:post_pact) do
-          stub_request(:post, "localhost:4444/pact").
-            with(headers: administration_headers.merge('Content-Type' => "application/json"), body: consumer_contract_details).
-            to_return(status: 200, body: pact)
-        end
-
-        it "deletes the interactions" do
-          expect(subject.write_pact(consumer_contract_details)).to eq pact
-          expect(post_pact).to have_been_made
-        end
-
-      end
-
-      describe "#log" do
-        it "sends a log request to the mock server"
-      end
-
-      describe "#wait_for_interactions" do
-        it "waits until there are no missing interactions"
-      end
-    end
-  end
-end
-

data/spec/lib/pact/consumer/service_consumer_spec.rb

@@ -1,11 +0,0 @@
-require 'spec_helper'
-
-module Pact
-   describe ServiceConsumer do
-      describe "as_json" do
-         it "returns a hash representation of the object" do
-            expect(ServiceConsumer.new(:name => "Bob").as_json).to eq :name => "Bob"
-         end
-      end
-   end
-end   

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

@@ -1,128 +0,0 @@
-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' }
-    let(:target_pact_file_location) { "#{tmp_pact_dir}/a_consumer-a_provider.json" }
-
-    before do
-      Pact.clear_configuration
-      FileUtils.rm_rf tmp_pact_dir
-      FileUtils.mkdir_p tmp_pact_dir
-      FileUtils.cp support_pact_file, target_pact_file_location
-    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,
-          pact_dir: tmp_pact_dir
-      }
-    }
-
-    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 to the pact_dir" do
-        FileUtils.rm_rf target_pact_file_location
-        consumer_contract_writer.write
-        expect(File.exist?(target_pact_file_location)).to be true
-      end
-
-      context "when the pact_dir is not specified" do
-        let(:consumer_contract_details) {
-          {
-              consumer: { name: consumer_name },
-              provider: { name: provider_name },
-              pactfile_write_mode: pactfile_write_mode,
-              interactions: new_interactions
-          }
-        }
-
-        it "raises an error" do
-          expect{ consumer_contract_writer.write }.to raise_error ConsumerContractWriterError, /Please indicate the directory/
-        end
-      end
-    end
-
-  end
-
-end

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

@@ -1,77 +0,0 @@
-require 'spec_helper'
-require 'pact/consumer_contract/request_decorator'
-require 'pact/consumer/request'
-
-module Pact
-  describe RequestDecorator do
-
-    let(:body) { {some: "bod"} }
-    let(:headers) { {some: "header"} }
-    let(:request_params) do
-      {
-        method: :get,
-        headers: headers,
-        path: "/",
-        body: body
-      }
-    end
-
-    let(:request) { Pact::Request::Expected.from_hash(request_params) }
-
-    subject { RequestDecorator.new(request) }
-
-    describe "#to_json" do
-
-      let(:parsed_json) { JSON.parse subject.to_json, symbolize_names: true }
-
-      context "body" do
-
-        context "with a Content-Type of form and body specified as a hash with a Pact::Term" do
-          let(:headers) { { 'Content-Type' => 'application/x-www-form-urlencoded' } }
-          let(:body) { {"param" => Pact::Term.new(generate: 'apple', matcher: /a/ )} }
-
-          it "reifies the body for compatibility with pact-specification 1.0.0" do
-            expect(parsed_json[:body]).to eq "param=apple"
-          end
-        end
-
-        context "with a Content-Type of form and body specified as a hash with an array value" do
-          let(:headers) { { 'Content-Type' => 'application/x-www-form-urlencoded' } }
-          let(:body) { {"param" => ['pear', Pact::Term.new(generate: 'apple', matcher: /a/ )] } }
-
-          it "reifies the body for compatibility with pact-specification 1.0.0" do
-            expect(parsed_json[:body]).to eq "param=pear&param=apple"
-          end
-        end
-
-        context "with no Content-Type and a body specified as a Hash" do
-          it "renders the body as JSON" do
-            expect(parsed_json[:body]).to eq body
-          end
-        end
-
-        context "with a Pact::Term in the JSON body" do
-          let(:body) { {"param" => Pact::Term.new(generate: 'apple', matcher: /a/ )} }
-          it "reifes the body for compatibility with pact-specification 1.0.0" do
-            expect(parsed_json[:body]).to eq param: 'apple'
-          end
-        end
-
-        context "with a Pact::Term as the body" do
-          let(:body) { Pact::Term.new(generate: 'apple', matcher: /a/ ) }
-          it "reifes the body for compatibility with pact-specification 1.0.0" do
-            expect(parsed_json[:body]).to eq 'apple'
-          end
-        end
-
-        context "with a String body" do
-          let(:body) { "a body" }
-          it "renders the String body" do
-            expect(parsed_json[:body]).to eq body
-          end
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,69 +0,0 @@
-require 'spec_helper'
-require 'pact/consumer_contract/request_decorator'
-require 'pact/consumer/request'
-
-module Pact
-  describe RequestDecorator do
-
-    let(:headers) { { some: "header" } }
-    let(:request_params) do
-      {
-        method: :get,
-        headers: headers,
-        path: "/"
-      }
-    end
-
-    let(:request) { Pact::Request::Expected.from_hash(request_params) }
-
-    subject { RequestDecorator.new(request) }
-
-    describe "#to_json" do
-
-      let(:parsed_json) { JSON.parse subject.to_json, symbolize_names: true }
-
-      context "headers" do
-
-        it "renders the headers" do
-          expect(parsed_json[:headers][:some]).to eq "header"
-        end
-
-        context "with a Pact::Term in the headers" do
-          let(:headers) { { 'X-Zebra' => Pact::Term.new(generate: 'zebra', matcher: /z/) } }
-
-          it "reifies the headers" do
-            expect(parsed_json[:headers][:'X-Zebra']).to eq 'zebra'
-          end
-        end
-
-        context "with no headers specified" do
-          let(:request_params) do
-            {
-              method: :get,
-              path: "/"
-            }
-          end
-
-          it "does not include the key" do
-            expect(parsed_json).to_not have_key(:headers)
-          end
-        end
-
-       context "with nil headers specified" do
-         let(:request_params) do
-           {
-             method: :get,
-             path: "/",
-             headers: nil
-           }
-         end
-
-         it "renders the headers as nil, but this would really be silly and will probably cause problems down the line" do
-           expect(parsed_json.fetch(:headers)).to be nil
-         end
-       end
-
-      end
-    end
-  end
-end

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

@@ -1,42 +0,0 @@
-require 'spec_helper'
-require 'pact/consumer_contract/request_decorator'
-require 'pact/consumer/request'
-
-module Pact
-  describe RequestDecorator do
-
-    let(:path) { "/zebras/1" }
-    let(:request_params) do
-      {
-        method: :get,
-        path: path
-      }
-    end
-
-    let(:request) { Pact::Request::Expected.from_hash(request_params) }
-
-    subject { RequestDecorator.new(request) }
-
-    describe "#to_json" do
-
-      let(:parsed_json) { JSON.parse subject.to_json, symbolize_names: true }
-
-      context "path" do
-
-        context "with a String path" do
-          it "renders the path" do
-            expect(parsed_json[:path]).to eq path
-          end
-        end
-
-        context "with a Pact::Term path", pending: "Pact::Terms for paths are not implemented yet"  do
-          let(:path) { Pact::Term.new(generate: "/zebras/1", matcher: %r{/zebras/\d})  }
-
-          it "reifies the path for compatibility with pact-specification 1.0.0" do
-            expect(parsed_json[:path]).to eq path
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,74 +0,0 @@
-require 'spec_helper'
-require 'pact/consumer_contract/request_decorator'
-require 'pact/consumer/request'
-
-module Pact
-  describe RequestDecorator do
-
-    let(:headers) { {some: "header"} }
-    let(:query) { "param=foo" }
-    let(:request_params) do
-      {
-        method: :get,
-        query: query,
-        headers: headers,
-        path: "/"
-      }
-    end
-
-    let(:request) { Pact::Request::Expected.from_hash(request_params) }
-
-    subject { RequestDecorator.new(request) }
-
-    describe "#to_json" do
-
-      let(:parsed_json) { JSON.parse subject.to_json, symbolize_names: true }
-
-      context "query" do
-        context "with a query hash containing a Pact::Term" do
-          let(:query) { { param: Pact::Term.new(generate: 'apple', matcher: /a/) } }
-
-          it "reifies the query for compatibility with pact-specification 1.0.0" do
-            expect(parsed_json[:query]).to eq "param=apple"
-          end
-        end
-
-        context "with a Pact::Term query" do
-          let(:query) { Pact::Term.new(generate: 'param=apple', matcher: /param=a/) }
-
-          it "reifies the query for compatibility with the pact-specification 1.0.0" do
-            expect(parsed_json[:query]).to eq 'param=apple'
-          end
-        end
-
-        context "when the query is not specified" do
-          let(:request_params) do
-            {
-              method: :get,
-              path: "/"
-            }
-          end
-
-          it "does not include the key" do
-            expect(parsed_json).to_not have_key(:query)
-          end
-        end
-
-        context "when the query is nil" do
-          let(:request_params) do
-            {
-              method: :get,
-              path: "/",
-              query: nil
-            }
-          end
-
-          it "includes the query as nil" do
-            expect(parsed_json.fetch(:query)).to be nil
-          end
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-require 'spec_helper'
-require 'pact/consumer_contract/request_decorator'
-require 'pact/consumer/request'
-
-module Pact
-  describe RequestDecorator do
-
-    let(:options) { { some: 'opts' } }
-    let(:body) { { some: "bod" } }
-    let(:headers) { { some: "header" } }
-    let(:query) { "param=foo" }
-    let(:request_params) do
-      {
-        method: :get,
-        query: query,
-        headers: headers,
-        path: "/",
-        body: body,
-        options: options
-      }
-    end
-
-    let(:request) { Pact::Request::Expected.from_hash(request_params) }
-
-    subject { RequestDecorator.new(request) }
-
-    describe "#to_json" do
-
-      let(:parsed_json) { JSON.parse subject.to_json, symbolize_names: true }
-
-      it "renders the keys in a meaningful order" do
-        expect(subject.to_json).to match(/method.*path.*query.*headers.*body/)
-      end
-
-      it "does not render the options" do
-        expect(subject.to_json).to_not include('options')
-      end
-
-    end
-  end
-end

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

@@ -1,10 +0,0 @@
-require 'pact/consumer_contract/response_decorator'
-require 'support/shared_examples_for_response_decorator'
-
-module Pact
-  describe ResponseDecorator do
-
-    include_examples "request decorator to_json"
-
-  end
-end

data/spec/lib/pact/mock_service/interaction_decorator_spec.rb

@@ -1,74 +0,0 @@
-require 'spec_helper'
-require 'pact/mock_service/interaction_decorator'
-
-module Pact
-  module MockService
-    describe InteractionDecorator do
-
-      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
-          { body: { baz: /qux/, wiffle: Term.new(generate: 'wiffle', matcher: /iff/) } }
-        end
-
-        let(:interaction) do
-          Interaction.from_hash(
-            'description' => 'description',
-            'provider_state' => 'provider_state',
-            'response' => response,
-            'request' => request)
-        end
-
-        subject { InteractionDecorator.new(interaction)  }
-
-        let(:parsed_result) do
-          JSON.load(subject.to_json)
-        end
-
-        it "contains the request" do
-          expect(parsed_result).to have_key('request')
-        end
-
-        it "contains the response" do
-          expect(parsed_result).to have_key('request')
-        end
-
-        it "contains the description" do
-          expect(parsed_result['description']).to eq 'description'
-        end
-
-        context "with a provider state" do
-          it "contains the provider_state" do
-            expect(parsed_result['provider_state']).to eq 'provider_state'
-          end
-        end
-
-        context "without a provider state" do
-
-          let(:interaction) do
-            Interaction.from_hash(
-              'description' => 'description',
-              'response' => response,
-              'request' => request)
-          end
-
-          it "does not contain the provider_state" do
-            expect(parsed_result).to_not have_key 'provider_state'
-          end
-        end
-
-      end
-
-    end
-  end
-end

data/spec/lib/pact/mock_service/request_decorator_spec.rb

@@ -1,76 +0,0 @@
-require 'spec_helper'
-require 'pact/mock_service/request_decorator'
-require 'pact/consumer_contract/request'
-
-
-module Pact
-  module MockService
-    describe RequestDecorator do
-
-      let(:options) { {} }
-      let(:body) { {some: "bod"} }
-      let(:headers) { {some: "header"} }
-      let(:request_params) do
-        {
-          method: :get,
-          query: "param=foo",
-          headers: headers,
-          path: "/",
-          body: body
-        }
-      end
-
-      let(:request) { Pact::Request::Expected.from_hash(request_params) }
-
-      subject { RequestDecorator.new(request) }
-
-      describe "#to_json" do
-
-        let(:parsed_json) { JSON.parse subject.to_json, symbolize_names: true}
-
-        it "renders the keys in a meaningful order" do
-          expect(subject.to_json).to match(/method.*path.*query.*headers.*body/)
-        end
-
-        context "with a body specified as a Hash" do
-          it "serialises the body as a Hash" do
-            expect(parsed_json[:body]).to eq body
-          end
-        end
-
-        context "with a body specified as a Hash containing a Pact::Term" do
-          let(:body) { { some: Pact::Term.new(generate: 'apple', matcher: /a/) } }
-
-          it "serialises the Pact::Term to Ruby specific JSON that is not compatible with pact-specification 1.0.0" do
-            expect(subject.to_json).to include "Pact::Term"
-          end
-        end
-      end
-
-      describe "#as_json" do
-        context "without options" do
-          it "does not include the options key" do
-            expect(subject.as_json.key?(:options)).to be false
-          end
-        end
-
-        context "with options" do
-          let(:request_params) do
-            {
-              method: :get,
-              path: "/",
-              options: options
-            }
-          end
-
-          let(:options) { {:opts => 'blah'} }
-
-          it "includes the options in the request hash" do
-            expect(subject.as_json[:options]).to eq options
-          end
-        end
-      end
-
-    end
-  end
-end