pact 1.3.3 → 1.4.0

data/spec/integration/consumer_spec.rb

@@ -1,212 +0,0 @@
-require 'spec_helper'
-require 'net/http'
-require 'pact/consumer'
-require 'pact/consumer/rspec'
-require 'faraday'
-load 'pact/consumer/world.rb'
-
-describe "A service consumer side of a pact", :pact => true  do
-
-  context "with more than one matching interaction found" do
-    let(:expected_response) do
-      {"message"=>"Multiple interaction found for GET /path", "matching_interactions"=>[{"description"=>"a request", "request"=>{"method"=>"get", "path"=>"/path", "body"=>{"a"=>"some body"}, "headers"=>{"Content-Type"=>"application/json"}}}, {"description"=>"an identical request", "request"=>{"method"=>"get", "path"=>"/path", "body"=>{"a"=>"some body"}, "headers"=>{"Content-Type"=>"application/json"}}}]}
-    end
-
-    it "returns an error" do
-      Pact.clear_configuration
-      Pact.clear_consumer_world
-
-      Pact.service_consumer "Consumer" do
-        has_pact_with "Mary Service" do
-          mock_service :mary_service do
-            verify false
-            port 1237
-          end
-        end
-      end
-
-      mary_service
-        .given("something")
-        .upon_receiving("a request")
-        .with(method: 'get', path: '/path', body: {a: 'some body'}, headers: {'Content-Type' => 'application/json'})
-        .will_respond_with(status: 200)
-
-
-      mary_service
-        .upon_receiving("an identical request")
-        .with(method: 'get', path: '/path', body: {a: 'some body'}, headers: {'Content-Type' => 'application/json'})
-        .will_respond_with(status: 200)
-
-      uri = URI('http://localhost:1237/path')
-      post_req = Net::HTTP::Get.new(uri.path)
-      post_req['Content-Type'] = "application/json"
-      post_req.body = {a: "some body"}.to_json
-      response = Net::HTTP.start(uri.hostname, uri.port) do |http|
-        http.request post_req
-      end
-
-      expect(JSON.load(response.body)).to eq expected_response
-    end
-
-  end
-
-  context "with no matching interaction found" do
-
-    let(:expected_response) do
-      {
-        "message"=>"No interaction found for GET /path",
-        "interaction_diffs"=>[{
-          "description" => "a request that will not be properly matched",
-          "provider_state" => "something",
-          "body"=>{
-            "a"=>{
-              "EXPECTED"=>"some body",
-              "ACTUAL"=>"not matching body"
-            }
-          }
-        }]
-      }
-    end
-
-    it "returns an error" do
-      Pact.clear_configuration
-
-      Pact.service_consumer "Consumer" do
-        has_pact_with "Mary Service" do
-          mock_service :mary_service do
-            verify false
-            port 1236
-          end
-        end
-      end
-
-      mary_service
-        .given("something")
-        .upon_receiving("a request that will not be properly matched")
-        .with(method: 'get', path: '/path', body: {a: 'some body'}, headers: {'Content-Type' => 'application/json'})
-        .will_respond_with(status: 200)
-
-      uri = URI('http://localhost:1236/path')
-      post_req = Net::HTTP::Get.new(uri.path)
-      post_req['Content-Type'] = "application/json"
-      post_req.body = {a: "not matching body"}.to_json
-      response = Net::HTTP.start(uri.hostname, uri.port) do |http|
-        http.request post_req
-      end
-
-      expect(JSON.load(response.body)).to eq expected_response
-    end
-  end
-
-  context "with a provider state" do
-    before do
-      Pact.clear_configuration
-
-      Pact.service_consumer "Consumer" do
-        has_pact_with "Zebra Service" do
-          mock_service :zebra_service do
-            verify false
-            port 1235
-          end
-        end
-      end
-    end
-
-    let(:body) { 'That is some good Mallory.' }
-
-    it "goes like this" do
-      zebra_service.
-        given(:the_zebras_are_here).
-        upon_receiving("a retrieve Mallory request").with({
-          method: :get,
-          path: '/mallory',
-          headers: {'Accept' => 'text/html'}
-        }).
-        will_respond_with({
-          status: 200,
-          headers: { 'Content-Type' => 'text/html' },
-          body: Pact::Term.new(matcher: /Mallory/, generate: body)
-        })
-
-      response = Faraday.get(zebra_service.mock_service_base_url + "/mallory", nil, {'Accept' => 'text/html'})
-      expect(response.body).to eq body
-
-      interactions = Pact::ConsumerContract.from_json(zebra_service.write_pact).interactions
-      expect(interactions.first.provider_state).to eq("the_zebras_are_here")
-    end
-  end
-
-  context "with multiple headers" do
-    before do
-      Pact.clear_configuration
-      Pact.service_consumer "Consumer" do
-        has_pact_with "Multi Headers Service" do
-          mock_service :multi_headers_service do
-            verify true
-            port 1240
-          end
-        end
-      end
-
-      multi_headers_service.
-        given("there are multiple headers").
-        upon_receiving("a request with multiple headers").
-        with(method: :get, path: '/something', headers: {'X-Something' => "1, 2"}).
-        will_respond_with(status: 200)
-
-        uri = URI('http://localhost:1240/something')
-        post_req = Net::HTTP::Get.new(uri.path)
-        post_req.add_field('X-Something', '1')
-        post_req.add_field('X-Something', '2')
-        response = Net::HTTP.start(uri.hostname, uri.port) do |http|
-          http.request post_req
-        end
-    end
-
-    it "handles multiple headers with the same name in a comma separated list" do
-      interactions = Pact::ConsumerContract.from_json(multi_headers_service.write_pact).interactions
-      expect(interactions.first.request.headers['X-Something']).to eq("1, 2")
-    end
-
-  end
-
-  context "with a async interaction with provider" do
-    before do
-      Pact.clear_configuration
-
-      Pact.service_consumer "Consumer" do
-        has_pact_with "Zebra Service" do
-          mock_service :zebra_service do
-            verify true
-            port 1239
-          end
-        end
-      end
-    end
-
-    it "goes like this" do
-      zebra_service.
-          given(:the_zebras_are_here).
-          upon_receiving("a retrieve Mallory request").
-          with({
-            method: :get,
-            path: '/mallory'
-          }).
-          will_respond_with({status: 200})
-
-      async_interaction { Net::HTTP.get_response(URI('http://localhost:1239/mallory'))}
-
-      zebra_service.wait_for_interactions wait_max_seconds: 1, poll_interval: 0.1
-    end
-
-    def async_interaction
-      Thread.new do
-        sleep 0.2
-        yield
-      end
-    end
-
-  end
-
-end
-

data/spec/integration/pact/consumer_configuration_spec.rb

@@ -1,66 +0,0 @@
-require 'spec_helper'
-require 'pact/configuration'
-require 'pact/consumer/configuration'
-
-describe "consumer side" do
-  describe "configure" do
-
-    class TestHelper
-      include Pact::Consumer::ConsumerContractBuilders
-    end
-
-    let(:application) { double("App")}
-    let(:world) { Pact::Consumer::World.new }
-
-    before do
-      Pact.clear_configuration
-      Pact::Consumer::AppManager.instance.clear_all
-      # Don't want processes actually spawning
-      allow_any_instance_of(Pact::Consumer::AppRegistration).to receive(:spawn)
-      allow(Pact).to receive(:consumer_world).and_return(world)
-
-      my_app = application
-
-      Pact.service_consumer "My Consumer" do
-        app my_app
-        port 1111
-
-        has_pact_with "My Service" do
-          mock_service :my_service do
-            port 1234
-            standalone true
-          end
-        end
-
-        has_pact_with "My Other Service" do
-          mock_service :my_other_service do
-            port 1235
-            standalone false
-          end
-        end
-      end
-
-    end
-
-    describe "providers" do
-
-      subject { TestHelper.new.my_service }
-
-      it "should have defined methods in MockServices for the providers" do
-        expect(subject).to be_instance_of(Pact::Consumer::ConsumerContractBuilder)
-      end
-
-      context "when standalone is true" do
-        it "is not registerd with the AppManager" do
-          expect(Pact::Consumer::AppManager.instance.app_registered_on?(1234)).to eq false
-        end
-      end
-
-      context "when standalone is false" do
-        it "should register the MockServices on their given ports if they are not" do
-          expect(Pact::Consumer::AppManager.instance.app_registered_on?(1235)).to eq true
-        end
-      end
-    end
-  end
-end

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