pact 0.1.28 → 1.3.3

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

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'pact/provider/pact_helper_locator'
+
+module Pact::Provider
+
+  describe PactHelperLocater do
+    describe "pact_helper_path", :fakefs => true do
+
+      subject { PactHelperLocater.pact_helper_path }
+
+      def make_pactfile dir
+        FileUtils.mkdir_p ".#{dir}"
+        FileUtils.touch ".#{dir}/pact_helper.rb"
+      end
+
+      PACT_HELPER_FILE_DIRS = [
+        '/spec/blah/service-consumers',
+        '/spec/consumers',
+        '/spec/blah/service_consumers',
+        '/spec/serviceconsumers',
+        '/spec/consumer',
+        '/spec',
+        '/blah',
+        '/blah/consumer',
+        ''
+      ]
+
+      PACT_HELPER_FILE_DIRS.each do | dir |
+        context "the pact_helper is stored in #{dir}" do
+          it "finds the pact_helper" do
+            make_pactfile dir
+            expect(subject).to eq File.join(Dir.pwd, dir, 'pact_helper.rb')
+          end
+        end
+      end
+
+      context "when more than one pact_helper exists" do
+        it "returns the one that matches the most explict search pattern" do
+          make_pactfile '/spec/consumer'
+          FileUtils.touch 'pact_helper.rb'
+          expect(subject).to eq File.join(Dir.pwd, '/spec/consumer/pact_helper.rb')
+        end
+      end
+
+      context "when a file exists ending in pact_helper.rb" do
+        it "is not identifed as a pact helper" do
+          FileUtils.mkdir_p './spec'
+          FileUtils.touch './spec/not_pact_helper.rb'
+          expect { subject }.to raise_error /Please create a pact_helper.rb file/
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'pact/provider/print_missing_provider_states'
+
+module Pact
+  module Provider
+    describe PrintMissingProviderStates do
+
+      describe "text" do
+        let(:missing_provider_states) { {'Consumer 1' => ['state1','state2'], 'Consumer 2' => ['state3']} }
+        let(:expected_output) { File.read("./spec/support/missing_provider_states_output.txt")}
+        subject { PrintMissingProviderStates.text missing_provider_states }
+        it "returns the text" do
+          expect(subject).to include expected_output
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+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

@@ -0,0 +1,68 @@
+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

@@ -0,0 +1,72 @@
+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

@@ -0,0 +1,55 @@
+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

@@ -0,0 +1,89 @@
+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

@@ -0,0 +1,80 @@
+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