pact 1.4.0.rc4 → 1.4.0

data/spec/integration/pact/provider_configuration_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-require 'pact/provider/rspec'
-
-describe "provider side" do
-   describe "configure" do
-
-      class TestHelper
-         include Pact::Provider::RSpec::InstanceMethods
-      end
-
-      let(:application) { double("App")}
-
-      before do
-         app_block = ->{ application }
-         Pact.service_provider "My Provider" do
-            app &app_block
-         end
-      end
-
-      it "makes the app available to the tests" do
-         expect(TestHelper.new.app).to be(application)
-      end
-
-   end
-end

data/spec/lib/pact/cli_spec.rb

@@ -1,47 +0,0 @@
-require 'spec_helper'
-require 'pact/cli'
-
-module Pact
-  describe SpecCriteria do
-
-    describe "#spec_criteria" do
-
-      let(:env_description) { "pact description set in ENV"}
-      let(:env_provider_state) { "provider state set in ENV"}
-      let(:env_criteria){ {:description=>/#{env_description}/, :provider_state=>/#{env_provider_state}/} }
-
-      let(:defaults) { {:description => default_description, :provider_state => default_provider_state} }
-
-      let(:subject) { Pact::App.new }
-
-      context "when ENV variables are defined" do
-        before do
-          allow(ENV).to receive(:[])
-          allow(ENV).to receive(:[]).with("PACT_DESCRIPTION").and_return(env_description)
-          allow(ENV).to receive(:[]).with("PACT_PROVIDER_STATE").and_return(env_provider_state)
-        end
-
-        it "returns the env vars as regexes" do
-          expect(SpecCriteria.call).to eq(env_criteria)
-        end
-      end
-
-      context "when ENV variables are not defined" do
-        it "returns an empty hash" do
-          expect(SpecCriteria.call).to eq({})
-        end
-      end
-
-      context "when provider state is an empty string" do
-        before do
-          allow(ENV).to receive(:[]).with(anything).and_return(nil)
-          allow(ENV).to receive(:[]).with("PACT_PROVIDER_STATE").and_return('')
-        end
-
-        it "returns a nil provider state so that it matches a nil provider state on the interaction" do
-          expect(SpecCriteria.call[:provider_state]).to be_nil
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact/configuration_spec.rb

@@ -1,297 +0,0 @@
-require 'spec_helper'
-require 'pact/configuration'
-
-describe Pact do
-
-  before do
-    Pact.clear_configuration
-  end
-
-  describe "configure" do
-    KEY_VALUE_PAIRS = {pact_dir: 'a path', log_dir: 'a dir', logger: 'a logger'}
-
-    KEY_VALUE_PAIRS.each do | key, value |
-      it "should allow configuration of #{key}" do
-        Pact.configure do | config |
-          config.send("#{key}=".to_sym, value)
-        end
-
-        expect(Pact.configuration.send(key)).to eql(value)
-      end
-    end
-
-  end
-
-  describe Pact::Configuration do
-    let(:configuration) { Pact::Configuration.new }
-
-    describe "log_dir" do
-      it "sets the location of the logs" do
-        expect(Logger).to receive(:new).with("./tmp/logs/pact.log").and_call_original
-        Pact.configure do | config |
-          config.log_dir = "./tmp/logs"
-        end
-        Pact.configuration.logger
-      end
-    end
-
-    describe "logger" do
-      it "sets the location of the logs to log_dir by default" do
-        expect(Logger).to receive(:new).with(File.expand_path("./log/pact.log")).and_call_original
-        Pact.configuration.logger
-      end
-      it "defaults to DEBUG" do
-        expect(Pact.configuration.logger.level).to eq Logger::DEBUG
-      end
-    end
-
-    describe "doc_dir" do
-      it "defaults to ./doc/pacts" do
-        expect(Pact.configuration.doc_dir).to eq File.expand_path("./doc/pacts")
-      end
-
-      it "can be changed" do
-        Pact.configuration.doc_dir = "newdir"
-        expect(Pact.configuration.doc_dir).to eq "newdir"
-      end
-    end
-
-    describe "doc_generator" do
-
-      context "with a symbol" do
-        it "allows configuration of a doc_generator" do
-          Pact.configuration.doc_generator = :markdown
-          expect(Pact.configuration.doc_generators).to eq [Pact::Doc::Markdown::Generator]
-        end
-      end
-
-      context "with anything that responds to 'call'" do
-
-        it "allows configuration of a doc_generator" do
-          Pact.configuration.doc_generator = lambda { | pact_dir, doc_dir | "doc" }
-          expect(Pact.configuration.doc_generators.size).to be 1
-          expect(Pact.configuration.doc_generators.first.call('doc','pacts')).to eq ("doc")
-        end
-
-      end
-
-      context "with something that does not respond to call and doesn't have a matching doc_generator" do
-        it "raises an error" do
-          expect { Pact.configuration.doc_generator = Object.new }.to raise_error "Pact.configuration.doc_generator needs to respond to call, or be in the preconfigured list: [:markdown]"
-        end
-      end
-
-    end
-
-    describe "#diff_formatter_for_content_type" do
-
-      let(:subject) { Pact::Configuration.new }
-
-      it "returns the Pact::Matchers::UnixDiffFormatter by default" do
-        expect(subject.diff_formatter_for_content_type 'anything').to eq(Pact::Matchers::UnixDiffFormatter)
-      end
-
-      Pact::Configuration::DIFF_FORMATTERS.each_pair do | key, diff_formatter |
-
-        context "when set to :#{key}" do
-
-          before do
-            subject.diff_formatter = key
-          end
-
-          it "sets the diff_formatter to #{diff_formatter}" do
-            expect(subject.diff_formatter_for_content_type nil).to be diff_formatter
-          end
-        end
-
-      end
-
-      context "when set to an object that responds to call" do
-
-        let(:diff_formatter) { lambda{ | diff| } }
-
-        before do
-          subject.diff_formatter = diff_formatter
-        end
-
-        it "sets the diff_formatter to the object" do
-          expect(subject.diff_formatter_for_content_type nil).to be diff_formatter
-        end
-      end
-
-      context "when set to an object that does not respond to call and isn't a known default option" do
-        it "raises an error" do
-          expect { subject.diff_formatter = Object.new }.to raise_error "Pact diff_formatter needs to respond to call, or be in the preconfigured list: [:embedded, :unix, :list]"
-          expect { subject.diff_formatter = Object.new }.to raise_error "Pact diff_formatter needs to respond to call, or be in the preconfigured list: [:embedded, :unix, :list]"
-        end
-      end
-
-    end
-
-    describe "diff_formatter_for_content_type" do
-      let(:diff_formatter) { lambda { |expected, actual| }}
-      context "with the default configuration" do
-        context "when the content type is nil" do
-          it "returns the UnixDiffFormatter" do
-            expect(Pact.configuration.diff_formatter_for_content_type nil).to eq Pact::Matchers::UnixDiffFormatter
-          end
-        end
-        context "when the content type is application/json" do
-          it "returns the UnixDiffFormatter" do
-            expect(Pact.configuration.diff_formatter_for_content_type nil).to eq Pact::Matchers::UnixDiffFormatter
-          end
-        end
-        context "when the content type is text/plain" do
-          it "returns the UnixDiffFormatter" do
-            expect(Pact.configuration.diff_formatter_for_content_type nil).to eq Pact::Matchers::UnixDiffFormatter
-          end
-        end
-      end
-      context "with a custom diff_formatter registered for nil content type" do
-        context "when the content_type is nil" do
-          it "returns the custom diff_formatter" do
-            Pact.configuration.register_diff_formatter nil, diff_formatter
-            expect(Pact.configuration.diff_formatter_for_content_type nil).to eq diff_formatter
-          end
-        end
-      end
-      context "with a custom diff_formatter registered for json content type" do
-        context "when the content_type is application/json" do
-          it "returns the custom diff_formatter" do
-            Pact.configuration.register_diff_formatter /json/, diff_formatter
-            expect(Pact.configuration.diff_formatter_for_content_type 'application/json').to eq diff_formatter
-          end
-        end
-      end
-    end
-
-    describe "register_body_differ" do
-
-      let(:differ) { lambda{ |expected, actual| } }
-
-      context "with a string for a content type" do
-        it "configures the differ for the given content type" do
-          Pact.configure do | config |
-            config.register_body_differ 'application/xml', differ
-          end
-
-          expect(Pact.configuration.body_differ_for_content_type 'application/xml').to be differ
-        end
-      end
-
-      context "with a regexp for a content type" do
-        it "returns a matching differ" do
-          Pact.configuration.register_body_differ /application\/.*xml/, differ
-          expect(Pact.configuration.body_differ_for_content_type 'application/hal+xml').to be differ
-        end
-      end
-
-      context "when a non string or regexp is used to register a differ" do
-        it "raises an error" do
-          expect { Pact.configuration.register_body_differ 1, differ }.to raise_error /Invalid/
-        end
-      end
-
-      context "when something that does not respond to call is sumbitted as a differ" do
-        it "raises an error" do
-          expect { Pact.configuration.register_body_differ 'thing', Object.new }.to raise_error /responds to call/
-        end
-      end
-
-      context "when a nil content type is registered for responses without a content type header" do
-        it "returns that differ if the differ for a nil content type is requested" do
-          Pact.configuration.register_body_differ nil, differ
-          expect(Pact.configuration.body_differ_for_content_type(nil)).to be differ
-        end
-      end
-
-    end
-
-    describe "body_differ_for_content_type" do
-
-      let(:differ) { lambda { |expected, actual| }}
-
-      context "when 2 potentially matching content types have a differ registered" do
-        let(:differ_1) { lambda{ |expected, actual| } }
-        let(:differ_2) { lambda{ |expected, actual| } }
-
-        it "returns the differ that was configured first" do
-          Pact.configuration.register_body_differ /application\/.*xml/, differ_2
-          Pact.configuration.register_body_differ /application\/hal\+xml/, differ_1
-          expect(Pact.configuration.body_differ_for_content_type 'application/hal+xml').to be differ_2
-        end
-      end
-
-      context "when a nil content type is given" do
-        it "returns the text differ" do
-          expect(Pact.configuration.body_differ_for_content_type nil).to be Pact::TextDiffer
-        end
-      end
-
-      context "when no matching content type is found" do
-        it "returns the text differ" do
-          expect(Pact.configuration.body_differ_for_content_type 'blah').to be Pact::TextDiffer
-        end
-      end
-
-      context "when the nil content type has a custom differ configured" do
-        it "returns the custom differ" do
-          Pact.configuration.register_body_differ nil, differ
-          expect(Pact.configuration.body_differ_for_content_type(nil)).to be differ
-        end
-      end
-
-      context "when a custom differ is registered for a content type that has a default differ" do
-        it "returns the custom differ" do
-          Pact.configuration.register_body_differ /application\/json/, differ
-          expect(Pact.configuration.body_differ_for_content_type 'application/json').to be differ
-        end
-      end
-    end
-
-    describe "pactfile_write_mode" do
-      context "when @pactfile_write_mode is :overwrite" do
-        it 'returns :overwrite' do
-          configuration.pactfile_write_mode = :overwrite
-          expect(configuration.pactfile_write_mode).to eq :overwrite
-        end
-      end
-      context "when @pactfile_write_mode is :update" do
-        it 'returns :overwrite' do
-          configuration.pactfile_write_mode = :update
-          expect(configuration.pactfile_write_mode).to eq :update
-        end
-      end
-      context "when @pactfile_write_mode is :smart" do
-        before do
-          configuration.pactfile_write_mode = :smart
-          expect(configuration).to receive(:is_rake_running?).and_return(is_rake_running)
-        end
-        context "when rake is running" do
-          let(:is_rake_running) { true }
-          it "returns :overwrite" do
-            expect(configuration.pactfile_write_mode).to eq :overwrite
-          end
-        end
-        context "when rake is not running" do
-          let(:is_rake_running) { false }
-          it "returns :update" do
-            expect(configuration.pactfile_write_mode).to eq :update
-          end
-        end
-      end
-    end
-  end
-    describe "default_configuration" do
-      it "should have a default pact_dir" do
-        expect(Pact.configuration.pact_dir).to eql File.expand_path('./spec/pacts')
-      end
-      it "should have a default log_dir" do
-        expect(Pact.configuration.log_dir).to eql File.expand_path('./log')
-      end
-      it "should have a default logger configured" do
-        expect(Pact.configuration.logger).to be_instance_of Logger
-      end
-    end
-
-end

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

@@ -1,41 +0,0 @@
-require 'spec_helper'
-
-module Pact::Consumer
-  describe AppManager do
-    before do
-      AppManager.instance.clear_all
-    end
-
-    describe "start_service_for" do
-      before do
-        allow_any_instance_of(AppRegistration).to receive(:spawn) # Don't want process actually spawning during the tests
-      end
-      let(:name) { 'some_service'}
-      context "for http://localhost" do
-        let(:url) { 'http://localhost:1234'}
-        it "starts a mock service at the given port on localhost" do
-          expect_any_instance_of(AppRegistration).to receive(:spawn)
-          AppManager.instance.register_mock_service_for name, url
-          AppManager.instance.spawn_all
-        end
-
-        it "registers the mock service as running on the given port" do
-          AppManager.instance.register_mock_service_for name, url
-          expect(AppManager.instance.app_registered_on?(1234)).to eq true
-        end
-      end
-      context "for https://" do
-        let(:url) { 'https://localhost:1234'}
-        it "should throw an unsupported error" do
-          expect { AppManager.instance.register_mock_service_for name, url }.to raise_error "Currently only http is supported"
-        end
-      end
-      context "for a host other than localhost" do
-        let(:url) { 'http://aserver:1234'}
-        it "should throw an unsupported error" do
-          expect { AppManager.instance.register_mock_service_for name, url }.to raise_error "Currently only services on localhost are supported"
-        end
-      end
-    end
-  end
-end

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

@@ -1,57 +0,0 @@
-require 'spec_helper'
-require 'pact/consumer/configuration'
-
-module Pact::Consumer::Configuration
-
-   describe MockService do
-
-      let(:world) { Pact::Consumer::World.new }
-      before do
-         Pact.clear_configuration
-         allow(Pact::Consumer::AppManager.instance).to receive(:register_mock_service_for)
-         allow(Pact).to receive(:consumer_world).and_return(world)
-      end
-
-      describe "configure_consumer_contract_builder" do
-         let(:consumer_name) {'consumer'}
-         subject {
-            MockService.build :mock_service, consumer_name, provider_name do
-               port 1234
-               standalone true
-               verify true
-            end
-         }
-
-         let(:provider_name) { 'Mock Provider' }
-         let(:consumer_contract_builder) { instance_double('Pact::Consumer::ConsumerContractBuilder') }
-         let(:url) { "http://localhost:1234" }
-
-         it "adds a verification to the Pact configuration" do
-            allow(Pact::Consumer::ConsumerContractBuilder).to receive(:new).and_return(consumer_contract_builder)
-            subject.finalize
-            expect(consumer_contract_builder).to receive(:verify)
-            Pact.configuration.provider_verifications.first.call
-         end
-
-         context "when standalone" do
-            it "does not register the app with the AppManager" do
-               expect(Pact::Consumer::AppManager.instance).to_not receive(:register_mock_service_for)
-               subject.finalize
-            end
-         end
-         context "when not standalone" do
-            subject {
-               MockService.build :mock_service, consumer_name, provider_name do
-                  port 1234
-                  standalone false
-                  verify true
-               end
-            }
-            it "registers the app with the AppManager" do
-               expect(Pact::Consumer::AppManager.instance).to receive(:register_mock_service_for).with(provider_name, url)
-               subject.finalize
-            end
-         end
-      end
-   end
-end