pact 1.3.3 → 1.4.0

data/spec/lib/pact/matchers/unix_diff_formatter_spec.rb

@@ -1,216 +0,0 @@
-require 'spec_helper'
-require 'pact/matchers/unix_diff_formatter'
-require 'pact/matchers/expected_type'
-require 'pact/matchers/actual_type'
-
-module Pact
-  module Matchers
-    describe UnixDiffFormatter do
-
-      describe ".call" do
-
-        let(:key_lines_count) { 4 }
-        let(:colour) { false }
-        subject { UnixDiffFormatter.call(diff, {colour: colour}) }
-
-        let(:line_count) { subject.split("\n").size }
-
-        context "when colour = false" do
-          let(:diff) { {thing: {alligator: Difference.new({name: 'Mary'}, "Joe" )}} }
-          it "does not include colour" do
-            expect(subject).to_not include("[0m")
-          end
-        end
-
-        context "when colour = true" do
-          let(:colour) { true }
-          let(:diff) { {thing: {alligator: Difference.new({name: 'Mary'}, "Joe" )}} }
-          it "uses colour" do
-            expect(subject).to include("[0m")
-          end
-        end
-
-        context "with class based matching" do
-          let(:diff) { {thing: TypeDifference.new(ExpectedType.new("fred"), ActualType.new(1))}}
-          let(:output) { <<-EOF
- {
--  "thing": String
-+  "thing": Fixnum
- }
-EOF
-          }
-
-          it "displays nicely" do
-            expect(remove_ansicolor subject).to include output
-          end
-        end
-
-        context "with an incorrect value in a hash" do
-          let(:diff) { {thing: {alligator: Difference.new({name: 'Mary'}, "Joe" )}} }
-
-          it "displays '+' next to the unexpected value, and '-' next to the missing one" do
-            expect(subject).to match /alligator/
-            expect(subject).to match /\-.*Mary/
-            expect(subject).to match /\+.*Joe/
-          end
-
-          it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 9 + key_lines_count
-          end
-
-        end
-
-        context "with an incorrect value in an array" do
-          let(:diff) { [NoDiffIndicator.new, Difference.new({name: 'Mary'}, "Joe"), NoDiffIndicator.new] }
-
-          it "displays '+' next to the incorrect values and '-' next to the missing ones" do
-            expect(subject).to match /no difference here!/
-            expect(subject).to match /\-.*{/
-            expect(subject).to match /\-.*}/
-            expect(subject).to match /\-.*Mary/
-            expect(subject).to match /\+.*Joe/
-            expect(subject).to match /no.*Mary.*Joe.*no/m
-          end
-
-          it "doesn't display the no difference indicator as a change" do
-            expect(subject).to match(/^\s+no difference here!,$/)
-          end
-
-          it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 9 + key_lines_count
-          end
-
-        end
-
-        context "with a regular expression that was not matched" do
-          let(:regexp) { %r{http://.*/thing/1234} }
-          let(:diff) { {thing: RegexpDifference.new(regexp, "pear")} }
-
-          it "displays the regular expression" do
-            expect(subject).to include(regexp.inspect)
-            expect(subject).to include(regexp.inspect)
-            expect(subject).to match /\-.*thing/
-            expect(subject).to match /\+.*pear/
-          end
-
-          it "does not put quotes around the regular expression" do
-            expect(subject).to match /\/$/
-            expect(subject).to match /: \//
-          end
-
-          it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 5 + key_lines_count
-          end
-
-        end
-
-        context "with a missing key" do
-
-          let(:diff) { {thing: {alligator: Difference.new({name: 'Mary'}, KeyNotFound.new )}} }
-
-          it "it displays '-' next to the missing key and its value" do
-            expect(subject).to match /\-.*{/
-            expect(subject).to match /\-.*}/
-            expect(subject).to match /\-.*alligator/
-            expect(subject).to match /\-.*name/
-            expect(subject).to match /\-.*Mary/
-          end
-
-          it "does not display the missing key in the actual output" do
-            expect(subject).to_not match /\+.*alligator/
-          end
-
-          it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 8 + key_lines_count
-          end
-        end
-
-        context "with an unexpected key" do
-          let(:diff) { {thing: {alligator: Difference.new(UnexpectedKey.new, {name: 'Mary'} )}} }
-
-          it "displays '+' next to the unexpected key and its value" do
-            expect(subject).to match /\+.*name/
-            expect(subject).to match /\+.*Mary/
-            expect(subject).to match /\+.*alligator/
-            expect(subject).to match /\+.*}/
-            expect(subject).to match /\+.*{/
-          end
-
-          it "does not display the unexpected key in the expected output" do
-            expect(subject).to_not match /\-.*alligator/
-          end
-
-          it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 8 + key_lines_count
-          end
-
-        end
-
-        context "with a missing index" do
-          let(:diff) { [NoDiffIndicator.new, Difference.new({name: 'Mary'}, IndexNotFound.new)] }
-
-          it "displays '-' next to the missing items" do
-            expect(subject).to match /\-.*Mary/
-            expect(subject).to match /\-.*{/
-            expect(subject).to match /\-.*}/
-          end
-
-          it "does not display IndexNotFound" do
-            expect(subject).to_not match /#{IndexNotFound.new.to_s}/
-          end
-
-          it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 8 + key_lines_count
-          end
-
-        end
-
-        context "with an unexpected index" do
-          let(:diff) { [NoDiffIndicator.new, Difference.new(UnexpectedIndex.new, {name: 'Mary'})] }
-
-          it "displays '+' next to the unexpected item" do
-            expect(subject).to match /\+.*{/
-            expect(subject).to match /\+.*}/
-            expect(subject).to match /\+.*name/
-            expect(subject).to match /\+.*Mary/
-          end
-
-          xit "doesn't mark the 'no difference' as a change" do
-            expect(subject).to match /#{NoDiffIndicator.new.to_s},/
-            expect(subject).to_not match /\-.*#{NoDiffIndicator.new.to_s}/
-            expect(subject).to_not match /\+.*#{NoDiffIndicator.new.to_s}/
-          end
-
-          it "does not display the UnexpectedIndex" do
-            expect(subject).to_not match UnexpectedIndex.new.to_s
-          end
-
-          it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 8 + key_lines_count
-          end
-
-        end
-
-        context "with 2 unexpected indexes" do
-          let(:diff) { [NoDiffIndicator.new, Difference.new(UnexpectedIndex.new, {name: 'Mary'}), Difference.new(UnexpectedIndex.new, {name: 'Joe'})] }
-
-          it "displays '+' next to the unexpected item" do
-            expect(subject).to match /\+.*Mary/
-            expect(subject).to match /\+.*Joe/
-          end
-
-          it "does not display the UnexpectedIndex" do
-            expect(subject).to_not match UnexpectedIndex.new.to_s
-          end
-
-          it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 11 + key_lines_count
-          end
-
-        end
-
-      end
-
-    end
-  end
-end

data/spec/lib/pact/provider/configuration/configuration_extension_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-require 'pact/provider/configuration/configuration_extension'
-
-module Pact
-
-  module Provider
-
-    module Configuration
-
-      describe ConfigurationExtension do
-
-        subject { Object.new.extend(ConfigurationExtension) }
-
-        describe "#color_enabled" do
-
-          it "sets color_enabled to be true by default" do
-            expect(subject.color_enabled).to be true
-          end
-
-          it "allows configuration of colour_enabled" do
-            subject.color_enabled = false
-            expect(subject.color_enabled).to be false
-          end
-
-        end
-
-      end
-    end
-  end
-end

data/spec/lib/pact/provider/configuration/pact_verification_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-require 'pact/provider/configuration/pact_verification'
-
-module Pact
-  module Provider
-    module Configuration
-      describe PactVerification do
-
-        describe 'create_verification' do
-          let(:url) {'http://some/uri'}
-          let(:consumer_name) {'some consumer'}
-          let(:ref) {:prod}
-          let(:options) { {:ref => :prod} }
-          context "with valid values" do
-            subject do
-              uri = url
-              PactVerification.build(consumer_name, options) do
-                pact_uri uri
-              end
-            end
-
-            it "creates a Verification" do
-              expect(Pact::Provider::PactVerification).to receive(:new).with(consumer_name, url, ref)
-              subject
-            end
-          end
-
-          context "with a nil uri" do
-            subject do
-              PactVerification.build(consumer_name, options) do
-                pact_uri nil
-              end
-            end
-
-            it "raises a validation error" do
-              expect{ subject }.to raise_error /Please provide a pact_uri/
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact/provider/configuration/service_provider_config_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-require 'pact/provider/configuration/service_provider_config'
-
-module Pact
-  module Provider
-    module Configuration
-      describe ServiceProviderConfig do
-
-        describe "app" do
-
-          subject { ServiceProviderConfig.new { Object.new } }
-
-          it "should execute the app_block each time" do
-            expect(subject.app.object_id).to_not equal(subject.app.object_id)
-          end
-
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact/provider/configuration/service_provider_dsl_spec.rb

@@ -1,108 +0,0 @@
-require 'spec_helper'
-require 'pact/provider/configuration/service_provider_dsl'
-
-module Pact
-
-  module Provider
-
-    module Configuration
-
-      describe ServiceProviderDSL do
-
-        describe "initialize" do
-
-          context "with an object instead of a block" do
-            subject do
-              ServiceProviderDSL.build 'name' do
-                app 'blah'
-              end
-            end
-            it "raises an error" do
-              expect{ subject }.to raise_error /wrong number of arguments/
-            end
-          end
-
-        end
-
-        describe "validate" do
-          context "when no name is provided" do
-            subject do
-              ServiceProviderDSL.new ' ' do
-                app { Object.new }
-              end
-            end
-            it "raises an error" do
-              expect{ subject.send(:validate)}.to raise_error("Please provide a name for the Provider")
-            end
-          end
-          context "when nil name is provided" do
-            subject do
-              ServiceProviderDSL.new nil do
-                app { Object.new }
-              end
-            end
-            it "raises an error" do
-              expect{ subject.send(:validate)}.to raise_error("Please provide a name for the Provider")
-            end
-          end
-        end
-
-        describe 'honours_pact_with' do
-          before do
-            Pact.clear_configuration
-          end
-
-          context "with no optional params" do
-            subject do
-              ServiceProviderDSL.build 'some-provider' do
-                app {}
-                honours_pact_with 'some-consumer' do
-                  pact_uri 'blah'
-                end
-              end
-            end
-            it 'adds a verification to the Pact.configuration' do
-              subject
-              expect(Pact.configuration.pact_verifications.first).to eq(Pact::Provider::PactVerification.new('some-consumer', 'blah', :head))
-            end
-          end
-
-          context "with all params specified" do
-            subject do
-              ServiceProviderDSL.build 'some-provider' do
-                app {}
-                honours_pact_with 'some-consumer', :ref => :prod do
-                  pact_uri 'blah'
-                end
-              end
-            end
-            it 'adds a verification to the Pact.configuration' do
-              subject
-              expect(Pact.configuration.pact_verifications.first).to eq(Pact::Provider::PactVerification.new('some-consumer', 'blah', :prod))
-            end
-
-          end
-
-        end
-
-        describe "CONFIG_RU_APP" do
-          context "when a config.ru file does not exist" do
-
-            let(:path_that_does_not_exist) { './tmp/this/path/does/not/exist/probably' }
-
-            before do
-              allow(Pact.configuration).to receive(:config_ru_path).and_return(path_that_does_not_exist)
-            end
-
-            it "raises an error with some helpful text" do
-              expect{ ServiceProviderDSL::CONFIG_RU_APP.call }.to raise_error /Could not find config\.ru file.*#{Regexp.escape(path_that_does_not_exist)}/
-            end
-
-          end
-        end
-      end
-
-    end
-  end
-end
-

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

@@ -1,50 +0,0 @@
-require 'spec_helper'
-require 'pact/provider/configuration'
-
-module Pact::Provider::Configuration
-
-  describe ConfigurationExtension do
-
-    before do
-      Pact.clear_configuration
-    end
-
-    describe "service_provider" do
-
-      context "when a provider is configured" do
-
-        before do
-          Pact.service_provider "Fred" do
-            app { "An app" }
-          end
-        end
-
-        it "should allow configuration of the test app" do
-          expect(Pact.configuration.provider.app).to eql "An app"
-        end
-
-      end
-
-      context "when a provider is not configured" do
-
-        it "raises an error" do
-          expect{ Pact.configuration.provider }.to raise_error(/Please configure your provider/)
-        end
-
-      end
-
-      context "when a provider is configured without an app" do
-
-        before do
-          Pact.service_provider "Fred" do
-          end
-        end
-
-        it "uses the app from config.ru" do
-          expect( Pact.configuration.provider.app ).to be(AppForConfigRu)
-        end
-
-      end
-    end
-  end
-end

data/spec/lib/pact/provider/matchers/messages_spec.rb

@@ -1,116 +0,0 @@
-require 'spec_helper'
-require 'pact/provider/matchers/messages'
-
-module Pact
-  module Matchers
-    describe Messages do
-
-      include Messages
-
-      describe "#match_term_failure_message" do
-
-        let(:diff_formatter) { Pact::Matchers::UnixDiffFormatter }
-        let(:message) { "line1\nline2"}
-        let(:output_message) { "Actual: actual\n\n#{message}"}
-        let(:output_message_with_resets) { "Actual: actual\n\n#{r}line1\n#{r}line2"}
-        let(:r) { ::Term::ANSIColor.reset }
-        let(:diff) { double("diff") }
-        let(:actual) { "actual" }
-        let(:color_enabled) { true }
-        let(:ansi_reset_at_start_of_line) { /^#{Regexp.escape ::Term::ANSIColor.reset}/ }
-        let(:message_line_count) { message.split("\n").size }
-
-        before do
-          allow(diff_formatter).to receive(:call).and_return(message)
-        end
-
-        subject { match_term_failure_message diff, actual, diff_formatter, color_enabled }
-
-        it "creates a message using the diff_formatter" do
-          expect(diff_formatter).to receive(:call).with(diff)
-          subject
-        end
-
-        context "when color_enabled is true" do
-
-          it "returns the message with ANSI reset at the start of each line" do
-            expect(subject).to eq(output_message_with_resets)
-          end
-
-        end
-
-        context "when the actual is not a string" do
-
-          let(:actual) { {the: "actual"} }
-
-          it "includes the actual as json" do
-            expect(subject).to include(actual.to_json)
-          end
-        end
-
-        context "when color_enabled is false" do
-
-          let(:color_enabled) { false }
-
-          it "returns the message unmodified" do
-            expect(subject).to eq(output_message)
-          end
-
-        end
-
-      end
-
-      describe "#match_header_failure_message" do
-
-        let(:header_name) { "Content-Type" }
-        let(:expected) { "application/json" }
-        let(:actual) { "text/plain" }
-
-        subject { match_header_failure_message header_name, expected, actual }
-
-        context "when the expected value is a string" do
-
-          let(:expected_message) { "Expected header \"Content-Type\" to match \"application/json\", but was \"text/plain\"" }
-
-          it "creates a message" do
-            expect(subject).to eq(expected_message)
-          end
-
-        end
-
-        context "when the actual is nil" do
-
-          let(:actual) { nil }
-          let(:expected_message) { "Expected header \"Content-Type\" to match \"application/json\", but was nil" }
-
-          it "creates a message" do
-            expect(subject).to eq(expected_message)
-          end
-
-        end
-
-        context "when the expected is nil" do
-
-          let(:expected) { nil }
-          let(:expected_message) { "Expected header \"Content-Type\" to be nil, but was \"text/plain\"" }
-
-          it "creates a message" do
-            expect(subject).to eq(expected_message)
-          end
-
-        end
-
-        context "when the expected is a regexp" do
-
-          let(:expected) { /hal/ }
-          let(:expected_message) { "Expected header \"Content-Type\" to match /hal/, but was \"text/plain\"" }
-
-          it "creates a message with the term's matcher" do
-            expect(subject).to eq(expected_message)
-          end
-
-        end
-      end
-    end
-  end
-end

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

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

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