pact 1.3.3 → 1.4.0

data/spec/lib/pact/provider/request_spec.rb

@@ -1,78 +0,0 @@
-require 'spec_helper'
-require 'pact/provider/request'
-
-describe Pact::Provider::Request::Replayable do
-
-  let(:path) { '/path?something' }
-  let(:body) { {a: 'body'} }
-  let(:headers) { {} }
-  let(:expected_request) do
-    instance_double('Pact::Request::Expected',
-      :method => 'post',
-      :full_path => path,
-      :body => body,
-      :headers => headers)
-  end
-
-  subject { described_class.new(expected_request)}
-
-  describe "method" do
-    it 'returns the method' do
-      expect(subject.method).to eq 'post'
-    end
-  end
-  describe "path" do
-    it "returns the full path" do
-      expect(subject.path).to eq(path)
-    end
-  end
-
-  describe "body" do
-    context "when body is a NullExpectation" do
-      let(:body) { Pact::NullExpectation.new }
-      it "returns an empty string, not sure if it should do this or return nil???" do
-        expect(subject.body).to eq ""
-      end
-    end
-    context "when body is an empty string" do
-      let(:body) { '' }
-      it "returns an empty string" do
-        expect(subject.body).to eq ""
-      end
-    end
-    context "when body is a string" do
-      let(:body) { 'a string'}
-      it "returns the string" do
-        expect(subject.body).to eq body
-      end
-    end
-    context "when body is a Term" do
-      let(:body) { Pact::Term.new(generate: 'a', matcher: /a/) }
-      it "returns the generated value" do
-        expect(subject.body).to eq "a"
-      end
-    end
-    context "when body is not a string" do
-      let(:body) { {a: 'body'} }
-      it "returns the object as a json string" do
-        expect(subject.body).to eq body.to_json
-      end
-    end
-  end
-
-  describe "headers" do
-    context "when headers are expected" do
-      let(:headers) { {"Content-Type" => "text/plain", "Content-Length" => "123", "X-Content-Type" => "special", "Access-Control-Request-Method" => "POST"} }
-      let(:expected_headers) { {"CONTENT_TYPE" => "text/plain", "CONTENT_LENGTH" => "123", "HTTP_ACCESS_CONTROL_REQUEST_METHOD" => "POST", "HTTP_X_CONTENT_TYPE" => "special"} }
-      it "transforms the headers into Rack format" do
-        expect(subject.headers).to eq( expected_headers )
-      end
-    end
-    context "when headers are not specified" do
-      let(:headers) { Pact::NullExpectation.new }
-      it "returns an empty hash" do
-        expect(subject.headers).to eq({})
-      end
-    end
-  end
-end

data/spec/lib/pact/provider/rspec/formatter_rspec_2_spec.rb

@@ -1,68 +0,0 @@
-require 'spec_helper'
-require 'pact/provider/rspec/formatter_rspec_2'
-require './spec/support/factories'
-require './spec/support/spec_support'
-
-module Pact
-  module Provider
-    module RSpec
-      describe Formatter2 do
-
-        Pact::RSpec.with_rspec_3 do
-
-          # These methods don't exist in RSpec3
-          class Formatter2
-            def failure_color arg ; arg; end
-            def detail_color arg ; arg; end
-          end
-
-        end
-
-        let(:interaction) { InteractionFactory.create 'provider_state' => 'a state', 'description' => 'a description'}
-        let(:pactfile_uri) { 'pact_file_uri' }
-        let(:description) { 'an interaction' }
-        let(:metadata) { {pact_interaction: interaction, pactfile_uri: pactfile_uri, pact_interaction_example_description: description}}
-        let(:example) { double("Example", metadata: metadata) }
-        let(:failed_examples) { [example, example] }
-        let(:output) { StringIO.new }
-        let(:rerun_command) { "rake pact:verify:at[pact_file_uri] PACT_DESCRIPTION=\"a description\" PACT_PROVIDER_STATE=\"a state\" # an interaction" }
-        let(:missing_provider_states) { 'missing_provider_states'}
-
-        subject { Formatter2.new output }
-
-        let(:output_result) { Pact::SpecSupport.remove_ansicolor output.string }
-
-        before do
-          allow(PrintMissingProviderStates).to receive(:call)
-          allow(subject).to receive(:failed_examples).and_return(failed_examples)
-          allow(Pact.provider_world.provider_states).to receive(:missing_provider_states).and_return(missing_provider_states)
-          subject.dump_commands_to_rerun_failed_examples
-        end
-
-        describe "#dump_commands_to_rerun_failed_examples" do
-          it "prints a list of rerun commands" do
-            expect(output_result).to include(rerun_command)
-          end
-
-          it "only prints unique commands" do
-            expect(output_result.scan(rerun_command).size).to eq 1
-          end
-
-          it "prints a message about the logs" do
-            expect(output_result).to include("For assistance debugging failures")
-          end
-
-          it "prints missing provider states" do
-            expect(PrintMissingProviderStates).to receive(:call).with(missing_provider_states, output)
-            subject.dump_commands_to_rerun_failed_examples
-          end
-        end
-
-      end
-
-    end
-
-  end
-end
-
-

data/spec/lib/pact/provider/rspec/formatter_rspec_3_spec.rb

@@ -1,72 +0,0 @@
-require 'spec_helper'
-require 'pact/provider/rspec/formatter_rspec_3'
-require './spec/support/factories'
-require './spec/support/spec_support'
-
-Pact::RSpec.with_rspec_3 do
-  module Pact
-    module Provider
-      module RSpec
-        describe Formatter do
-
-          let(:interaction) { InteractionFactory.create 'provider_state' => 'a state', 'description' => 'a description'}
-          let(:pactfile_uri) { 'pact_file_uri' }
-          let(:description) { 'an interaction' }
-          let(:metadata) { {pact_interaction: interaction, pactfile_uri: pactfile_uri, pact_interaction_example_description: description}}
-          let(:metadata_2) { metadata.merge(pact_interaction_example_description: 'another interaction')}
-          let(:example) { double("Example", metadata: metadata) }
-          let(:example_2) { double("Example", metadata: metadata_2) }
-          let(:failed_examples) { [example, example] }
-          let(:examples) { [example, example, example_2]}
-          let(:output) { StringIO.new }
-          let(:rerun_command) { "rake pact:verify:at[pact_file_uri] PACT_DESCRIPTION=\"a description\" PACT_PROVIDER_STATE=\"a state\" # an interaction" }
-          let(:missing_provider_states) { 'missing_provider_states'}
-          let(:summary) { double("summary", failure_count: 1, failed_examples: failed_examples, examples: examples)}
-
-          subject { Formatter.new output }
-
-          let(:output_result) { Pact::SpecSupport.remove_ansicolor output.string }
-
-          before do
-            allow(PrintMissingProviderStates).to receive(:call)
-            allow(subject).to receive(:failed_examples).and_return(failed_examples)
-            allow(Pact.provider_world.provider_states).to receive(:missing_provider_states).and_return(missing_provider_states)
-            subject.dump_summary summary
-          end
-
-          describe "#dump_summary" do
-            it "prints a list of rerun commands" do
-              expect(output_result).to include(rerun_command)
-            end
-
-            it "only prints unique commands" do
-              expect(output_result.scan(rerun_command).size).to eq 1
-            end
-
-            it "prints a message about the logs" do
-              expect(output_result).to include("For assistance debugging failures")
-            end
-
-            it "prints the number of interactions" do
-              expect(output_result).to include("2 interactions")
-            end
-
-            it "prints the number of failures" do
-              expect(output_result).to include("1 failure")
-            end
-
-            it "prints missing provider states" do
-              expect(PrintMissingProviderStates).to receive(:call).with(missing_provider_states, output)
-              subject.dump_summary summary
-            end
-          end
-
-        end
-
-      end
-
-    end
-  end
-end
-
-

data/spec/lib/pact/provider/rspec_spec.rb

@@ -1,55 +0,0 @@
-require 'pact/provider/rspec/matchers'
-require 'pact/shared/json_differ'
-require 'pact/matchers/unix_diff_formatter'
-
-
-describe "the match_term matcher" do
-
-  include Pact::RSpec::Matchers
-
-  let(:diff_formatter) { Pact::Matchers::UnixDiffFormatter }
-
-  it 'does not match a hash to an array' do
-    expect({}).to_not match_term([], with: Pact::JsonDiffer, diff_formatter: diff_formatter)
-  end
-
-  it 'does not match an array to a hash' do
-    expect([]).to_not match_term({}, with: Pact::JsonDiffer, diff_formatter: diff_formatter)
-  end
-
-  it 'matches regular expressions' do
-    expect('blah').to match_term(/[a-z]*/, with: Pact::JsonDiffer, diff_formatter: diff_formatter)
-  end
-
-  it 'matches pact terms' do
-    expect('wootle').to match_term Pact::Term.new(generate:'wootle', matcher:/woot../), with: Pact::JsonDiffer, diff_formatter: diff_formatter
-  end
-
-  it 'matches all elements of arrays' do
-    expect(['one', 'two', ['three']]).to match_term [/one/, 'two', [Pact::Term.new(generate:'three', matcher:/thr../)]], with: Pact::JsonDiffer, diff_formatter: diff_formatter
-  end
-
-  it 'matches all values of hashes' do
-    expect({1 => 'one', 2 => 2, 3 => 'three'}).to match_term({1 => /one/, 2 => 2, 3 => Pact::Term.new(generate:'three', matcher:/thr../)}, with: Pact::JsonDiffer, diff_formatter: diff_formatter)
-  end
-
-  it 'matches all other objects using ==' do
-    expect('wootle').to match_term 'wootle', with: Pact::JsonDiffer, diff_formatter: diff_formatter
-  end
-
-  # Note: because a consumer specifies only the keys it cares about, the pact ignores keys that are returned
-  # by the provider, but not are not specified in the pact. This means that any hash will match an
-  # expected empty hash, because there is currently no way for a consumer to expect an absence of keys.
-  it 'is confused by an empty hash' do
-    expect({:hello => 'everyone'}).to match_term({}, with: Pact::JsonDiffer, diff_formatter: diff_formatter)
-  end
-
-  it 'should not be confused by an empty array' do
-    expect(['blah']).to_not match_term([], with: Pact::JsonDiffer, diff_formatter: diff_formatter)
-  end
-
-  it "should allow matches on an array where each item in the array only contains a subset of the actual" do
-    expect([{name: 'Fred', age: 12}, {name: 'John', age: 13}]).to match_term([{name: 'Fred'}, {name: 'John'}], with: Pact::JsonDiffer, diff_formatter: diff_formatter)
-  end
-
-end

data/spec/lib/pact/provider/state/provider_state_manager_spec.rb

@@ -1,89 +0,0 @@
-require 'spec_helper'
-require 'pact/provider/state/provider_state_manager'
-
-module Pact::Provider::State
-
-
-  describe ProviderStateManager do
-
-    PROVIDER_STATE_MESSAGES = []
-
-    before do
-      PROVIDER_STATE_MESSAGES.clear
-      Pact.clear_provider_world
-
-      Pact.set_up do
-        PROVIDER_STATE_MESSAGES << :global_base_set_up
-      end
-
-      Pact.tear_down do
-        PROVIDER_STATE_MESSAGES << :global_base_tear_down
-      end
-
-      Pact.provider_states_for "a consumer with provider states" do
-        set_up do
-          PROVIDER_STATE_MESSAGES << :consumer_base_set_up
-        end
-
-        tear_down do
-          PROVIDER_STATE_MESSAGES << :consumer_base_tear_down
-        end
-
-        provider_state "a custom state" do
-          set_up do
-            PROVIDER_STATE_MESSAGES << :custom_consumer_state_set_up
-          end
-
-          tear_down do
-            PROVIDER_STATE_MESSAGES << :custom_consumer_state_tear_down
-          end
-        end
-
-      end
-    end
-
-    let(:provider_state_manager) { ProviderStateManager.new("a custom state", "a consumer with provider states") }
-
-    describe "set_up_provider_state" do
-
-      subject { provider_state_manager.set_up_provider_state }
-
-      it "sets up the global base state" do
-        subject
-        expect(PROVIDER_STATE_MESSAGES[0]).to eq :global_base_set_up
-      end
-
-      it "sets up the consumer base state" do
-        subject
-        expect(PROVIDER_STATE_MESSAGES[1]).to eq :consumer_base_set_up
-      end
-
-      it "sets up the consumer custom state" do
-        subject
-        expect(PROVIDER_STATE_MESSAGES[2]).to eq :custom_consumer_state_set_up
-      end
-    end
-
-    describe "tear_down_provider_state" do
-
-      subject { provider_state_manager.tear_down_provider_state }
-
-      it "tears down the consumer custom state" do
-        subject
-        expect(PROVIDER_STATE_MESSAGES[0]).to eq :custom_consumer_state_tear_down
-      end
-
-      it "tears down the consumer base state" do
-        subject
-        expect(PROVIDER_STATE_MESSAGES[1]).to eq :consumer_base_tear_down
-      end
-
-      it "tears down the global base state" do
-        subject
-        expect(PROVIDER_STATE_MESSAGES[2]).to eq :global_base_tear_down
-      end
-    end
-
-  end
-
-end

data/spec/lib/pact/provider/state/provider_state_proxy_spec.rb

@@ -1,80 +0,0 @@
-require 'spec_helper'
-require 'pact/provider/state/provider_state_proxy'
-
-module Pact
-  module Provider::State
-    describe ProviderStateProxy do
-
-      let(:provider_state_proxy) { ProviderStateProxy.new }
-
-      let(:options) { { :for => 'some consumer'} }
-      let(:provider_state) { double("provider_state")}
-
-      describe "get" do
-        let(:name) { "some state" }
-
-        subject { provider_state_proxy.get name, options }
-
-        before do
-          allow(ProviderStates).to receive(:get).and_return(provider_state)
-        end
-
-        context "when the provider state exists" do
-
-          it "retrieves the provider state from ProviderState" do
-            expect(ProviderStates).to receive(:get).with(name, options).and_return(provider_state)
-            subject
-          end
-
-          it "returns the state" do
-            expect(subject).to eq provider_state
-          end
-
-        end
-
-        context "when the state does not exist" do
-
-          let(:provider_state) { nil }
-          let(:expected_missing_provider_states) { {"some consumer" => ["some state"]} }
-
-          it "raises an error" do
-            expect { subject }.to raise_error /Could not find.*some state.*consumer.*/
-          end
-
-          it "records the provider state as missing" do
-            subject rescue nil
-            expect(provider_state_proxy.missing_provider_states).to eq expected_missing_provider_states
-          end
-
-          context "when the same missing provider state is requested" do
-            it "ensures the list only contains unique entries" do
-              subject rescue nil
-              subject rescue nil
-              expect(provider_state_proxy.missing_provider_states['some consumer'].size).to eq 1
-            end
-          end
-        end
-
-
-      end
-
-      describe "get_base" do
-
-        before do
-          allow(ProviderStates).to receive(:get_base).and_return(provider_state)
-        end
-
-        subject { provider_state_proxy.get_base options }
-
-        it "calls through to ProviderStates" do
-          expect(ProviderStates).to receive(:get_base).with(options)
-          subject
-        end
-
-        it "returns the state" do
-          expect(subject).to eq provider_state
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact/provider/state/provider_state_spec.rb

@@ -1,213 +0,0 @@
-require 'spec_helper'
-require 'pact/provider/state/provider_state'
-
-module Pact
-  module Provider::State
-
-    describe ProviderStates do
-      MESSAGES = []
-
-      before do
-        MESSAGES.clear
-      end
-
-      describe 'global ProviderState' do
-
-
-        Pact.provider_state :no_alligators do
-          set_up do
-            MESSAGES << 'set_up'
-          end
-          tear_down do
-            MESSAGES << 'tear_down'
-          end
-        end
-
-        Pact.provider_state 'some alligators' do
-          no_op
-        end
-
-
-        subject { ProviderStates.get('no_alligators') }
-
-        describe 'set_up' do
-          it 'should call the block passed to set_up' do
-            subject.set_up
-            expect(MESSAGES).to eq ['set_up']
-          end
-        end
-
-        describe 'tear_down' do
-          it 'should call the block passed to set_up' do
-            subject.tear_down
-            expect(MESSAGES).to eq ['tear_down']
-          end
-        end
-
-        describe '.get' do
-          context 'when the name is a matching symbol' do
-            it 'will return the ProviderState' do
-              expect(ProviderStates.get('no_alligators')).to_not be_nil
-            end
-          end
-          context 'when the name is a matching string' do
-            it 'will return the ProviderState' do
-              expect(ProviderStates.get('some alligators')).to_not be_nil
-            end
-          end
-        end
-      end
-
-      describe 'no_op' do
-        context "when a no_op is defined instead of a set_up or tear_down" do
-          it "treats set_up and tear_down as empty blocks" do
-            Pact.provider_state 'with_no_op' do
-              no_op
-            end
-            ProviderStates.get('with_no_op').set_up
-            ProviderStates.get('with_no_op').tear_down
-          end
-        end
-        context "when a no_op is defined with a set_up" do
-          it "raises an error" do
-            expect do
-              Pact.provider_state 'with_no_op_and_set_up' do
-                no_op
-                set_up do
-
-                end
-              end.to raise_error(/Provider state \"with_no_op_and_set_up\" has been defined as a no_op but it also has a set_up block. Please remove one or the other./)
-            end
-          end
-        end
-        context "when a no_op is defined with a tear_down" do
-          it "raises an error" do
-            expect do
-              Pact.provider_state 'with_no_op_and_set_up' do
-                no_op
-                tear_down do
-
-                end
-              end.to raise_error(/Provider state \"with_no_op_and_set_up\" has been defined as a no_op but it also has a tear_down block. Please remove one or the other./)
-            end
-          end
-        end
-
-      end
-
-
-      describe 'namespaced ProviderStates' do
-
-        NAMESPACED_MESSAGES = []
-
-        Pact.provider_states_for 'a consumer' do
-          provider_state 'the weather is sunny' do
-            set_up do
-              NAMESPACED_MESSAGES << 'sunny!'
-            end
-          end
-        end
-
-        Pact.provider_state 'the weather is cloudy' do
-          set_up do
-            NAMESPACED_MESSAGES << 'cloudy :('
-          end
-        end
-
-        before do
-          NAMESPACED_MESSAGES.clear
-        end
-
-        describe '.get' do
-          context 'for a consumer' do
-            it 'has a namespaced name' do
-              expect(ProviderStates.get('the weather is sunny', :for => 'a consumer')).to_not be_nil
-            end
-
-            it 'falls back to a global state of the same name if one is not found for the specified consumer' do
-              expect(ProviderStates.get('the weather is cloudy', :for => 'a consumer')).to_not be_nil
-            end
-          end
-
-        end
-
-        describe 'set_up' do
-          context 'for a consumer' do
-            it 'runs its own setup' do
-              ProviderStates.get('the weather is sunny', :for => 'a consumer').set_up
-              expect(NAMESPACED_MESSAGES).to eq ['sunny!']
-            end
-          end
-        end
-      end
-
-      describe "base_provider_state" do
-        Pact.provider_states_for "a consumer with base state" do
-          set_up do
-            MESSAGES << "setting up base provider state"
-          end
-        end
-
-        context "when the base state has been declared" do
-          it "creates a base state for the provider" do
-            ProviderStates.get_base(:for => "a consumer with base state").set_up
-            expect(MESSAGES).to eq ["setting up base provider state"]
-          end
-
-        end
-
-        context "when a base state has not been declared" do
-          it "returns a no op state" do
-            ProviderStates.get_base(:for => "a consumer that does not exist").set_up
-            ProviderStates.get_base(:for => "a consumer that does not exist").tear_down
-          end
-        end
-
-      end
-
-      describe "global base_provider_state" do
-
-        before(:all) do
-          Pact.set_up do
-            MESSAGES << "setting up global base provider state"
-          end
-        end
-
-        context "when the base state has been declared" do
-          it "creates a base state for the provider" do
-            ProviderStates.get_base.set_up
-            expect(MESSAGES).to eq ["setting up global base provider state"]
-          end
-
-        end
-
-        context "when a base state has not been declared" do
-          it "returns a no op state" do
-            ProviderStates.get_base.set_up
-            ProviderStates.get_base.tear_down
-          end
-        end
-      end
-
-      describe "invalid provider state" do
-        context "when no set_up or tear_down is provided" do
-          it "raises an error to prevent someone forgetting about the set_up and putting the set_up code directly in the provider_state block and wasting 20 minutes trying to work out why their provider states aren't working properly" do
-            expect do
-              Pact.provider_state 'invalid' do
-              end
-            end.to raise_error(/Please provide a set_up or tear_down block for provider state \"invalid\"/)
-          end
-        end
-        context "when a no_op is defined" do
-          it "does not raise an error" do
-            expect do
-              Pact.provider_state 'valid' do
-                no_op
-              end
-            end.not_to raise_error
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact/provider/world_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-load 'pact/provider/world.rb'
-
-describe Pact do
-  describe ".provider_world" do
-    it "returns a world" do
-      expect(Pact.provider_world).to be_instance_of Pact::Provider::World
-    end
-    it "returns the same world each time" do
-      expect(Pact.provider_world).to be Pact.provider_world
-    end
-  end
-
-  describe ".clear_provider_world" do
-    it "clears the world" do
-      original_world = Pact.provider_world
-      Pact.clear_provider_world
-      expect(original_world).to_not be Pact.provider_world
-    end
-  end
-
-end
-
-module Pact
-  module Provider
-    describe World do
-
-      subject { World.new }
-      describe "provider_states" do
-        it "returns a provider state proxy" do
-          expect(subject.provider_states).to be_instance_of State::ProviderStateProxy
-        end
-        it "returns the same object each time" do
-          expect(subject.provider_states).to be subject.provider_states
-        end
-
-      end
-
-    end
-  end
-end