pact 0.1.28 → 1.3.3

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

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

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

data/spec/lib/pact/reification_spec.rb

@@ -39,5 +39,29 @@ module Pact
 
     end
 
+    context "when reifying a Request" do
+
+      let(:request){ Pact::Request::Expected.from_hash(method: 'get', path: '/', body: Pact::Term.new(generate: "sunny", matcher: /sun/))}
+
+      subject { Reification.from_term(request) }
+
+      it "turns it into a hash before reifying it" do
+        expect(subject[:body]).to eq("sunny")
+      end
+
+    end
+
+    context "when SomethingLike" do
+
+      let(:request) { Pact::SomethingLike.new({a: 'String'})}
+
+      subject { Reification.from_term(request)}
+
+      it "returns the contents of the SomethingLike" do
+        expect(subject).to eq({a: 'String'})
+      end
+
+    end
+
   end
 end

data/spec/lib/pact/shared/dsl_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+require 'pact/shared/dsl'
+require 'support/dsl_spec_support'
+
+module Pact
+  describe DSL do
+
+    class TestDSL
+      extend DSL
+      attr_accessor :thing, :blah, :global, :the_block, :another_block, :finalized
+
+      dsl do
+        def with_thing thing
+          self.thing = thing
+        end
+        def with_blah blah
+          self.blah = blah
+        end
+        def with_global global
+          self.global = global
+        end
+
+        def with_block &the_block
+          self.the_block = the_block
+        end
+
+        def with_another_block &the_block
+          self.another_block = the_block
+        end
+
+      end
+
+      def finalize
+        @finalized = true
+      end
+    end
+
+    describe "build" do
+       before do
+          def my_local_method
+             'LA LA LA'
+          end
+
+          my_local_var = 123
+
+          local_app = "I'm a local app"
+
+          @test = TestDSL.build do
+            with_thing my_local_method
+            with_blah my_local_var
+            with_global global_method
+            with_block do
+              global_app
+            end
+            with_another_block do
+              local_app
+            end
+          end
+       end
+
+       it "supports using a local variable" do
+          expect(@test.blah).to eq 123
+       end
+
+       it "supports using a local method" do
+          expect(@test.thing).to eq 'LA LA LA'
+       end
+
+       it "supports using global methods from other files" do
+         expect(@test.global).to eq "I'm global"
+       end
+
+       it "supports using a local method to provide the app" do
+         expect(@test.another_block.call).to eq("I'm a local app")
+       end
+
+       it "should support using a global method to provide the app but it doesn't" do
+         expect(@test.the_block.call).to eq("I'm a global app")
+       end
+
+       it "calls finalize" do
+        expect(@test.finalized).to be true
+       end
+    end
+  end
+end

data/spec/lib/pact/shared/json_differ_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'pact/shared/json_differ'
+
+module Pact
+  describe JsonDiffer do
+
+    describe ".call" do
+
+      let(:expected) { {'a' => 'b'} }
+
+      subject { JsonDiffer.call(expected, actual) }
+
+      context "when the actual is valid JSON" do
+
+        let(:actual) { {'a' => 'c'} }
+        let(:difference) { {'a' => Pact::Matchers::Difference.new('b', 'c')} }
+
+        context "when the actual does not equal the expected" do
+          it "parses the JSON and returns a diff" do
+            expect(subject).to eq(difference)
+          end
+        end
+
+        context "when the actual equals the expected" do
+          let(:actual) { expected }
+          it "parses the JSON and returns an empty diff" do
+            expect(subject.any?).to be false
+          end
+        end
+
+      end
+
+    end
+
+  end
+end

data/spec/lib/pact/shared/key_not_found_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require 'pact/shared/key_not_found'
+
+module Pact
+  describe KeyNotFound do
+
+    describe "#as_json" do
+      it "returns a string representation of the object" do
+        expect(subject.as_json).to eq subject.to_s
+      end
+    end
+
+    describe "#to_json" do
+      it "serialises the object to JSON" do
+        expect(subject.to_json).to eq "\"#{subject.to_s}\""
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,111 @@
+require 'spec_helper'
+require 'pact/shared/request'
+require 'pact/shared/key_not_found'
+
+module Pact
+
+  module Request
+
+    describe Base do
+
+      class TestRequest < Base
+
+        def self.key_not_found
+          Pact::KeyNotFound.new
+        end
+
+      end
+
+      subject { TestRequest.new("get", "/", {some: "things"}, {some: "things"} , "some=things") }
+
+      describe "#to_json" do
+        it "renders the keys in a sensible order" do
+          expect(subject.to_json).to match(/method.*path.*query.*headers.*body/)
+        end
+      end
+
+      describe "#full_path" do
+
+        subject { TestRequest.new("get", "/something", {}, {some: "things"} , query).full_path }
+
+        context "with a query that is a Pact::Term" do
+          let(:query) { Pact::Term.new(generate: "some=things", matcher: /some/) }
+          it "reifies and appends the query" do
+            expect(subject).to eq("/something?some=things")
+          end
+        end
+
+        context "with a query that is a string" do
+          let(:query) { "some=things" }
+          it "appends the query" do
+            expect(subject).to eq("/something?some=things")
+          end
+        end
+
+        context "with an empty query" do
+          let(:query) { "" }
+          it "does include a query" do
+            expect(subject).to eq("/something")
+          end
+        end
+
+        context "with a nil query" do
+          let(:query) { nil }
+          it "does not include a query" do
+            expect(subject).to eq("/something")
+          end
+        end
+      end
+
+      describe "#method_and_path" do
+        context "with an empty path" do
+          subject { TestRequest.new("get", "", {}, {} , "").method_and_path }
+
+          it "includes a slash" do
+            expect(subject).to eq("GET /")
+          end
+        end
+
+        context "with a path" do
+          subject { TestRequest.new("get", "/something", {}, {} , "").method_and_path }
+
+          it "includes the path" do
+            expect(subject).to eq("GET /something")
+          end
+        end
+
+        context "with a query" do
+          subject { TestRequest.new("get", "/something", {}, {} , "test=query").method_and_path }
+
+          it "includes the query" do
+            expect(subject).to eq("GET /something?test=query")
+          end
+        end
+      end
+
+      describe "#content_type" do
+
+        subject { TestRequest.new("get", "/something", headers, {} , "") }
+        context "when there are no expected headers" do
+          let(:headers) { Pact::KeyNotFound.new }
+          it "returns nil" do
+            expect(subject.send(:content_type)).to be nil
+          end
+        end
+        context "when there is no Content-Type header" do
+          let(:headers) { {} }
+          it "returns the content-type" do
+            expect(subject.send(:content_type)).to be nil
+          end
+        end
+        context "when there is a content-type header (" do
+          let(:headers) { {'content-type' => 'blah'} }
+          it "returns the content-type" do
+            expect(subject.send(:content_type)).to eq 'blah'
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/lib/pact/shared/text_differ_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'pact/shared/text_differ'
+
+module Pact
+  describe TextDiffer do
+
+    describe ".call" do
+
+      subject { TextDiffer.call expected, actual }
+
+      let(:expected) { "This is the string you are looking for" }
+
+      context "when the expected and actual are both strings" do
+
+        context "when they equal each other" do
+          let(:actual) { "This is the string you are looking for" }
+
+          it "returns an empty diff" do
+            expect(subject.any?).to be false
+          end
+        end
+
+        context "when they don't equal each other" do
+          let(:actual) { "This is not the string you are looking for" }
+
+          it "returns the diff" do
+            expect(subject).to eq Pact::Matchers::Difference.new(expected, actual)
+          end
+        end
+      end
+
+      context "when the actual is not a String" do
+        let(:actual) { {some: 'hash'} }
+        let(:difference) { Pact::Matchers::Difference.new(expected, actual)}
+        it "returns the diff" do
+          expect(subject)
+        end
+      end
+
+      context "when the expected and actual are both objects" do
+        let(:actual) { {some: 'hash', blah: 'blah'} }
+        let(:expected) { {some: 'hash'} }
+        let(:difference) { Pact::Matchers::Difference.new(expected, actual)}
+
+        it "returns the diff using the JSON matching logic, allowing extra keys. But should it really if the expected Content-Type isn't actually JSON?" do
+          expect(subject)
+        end
+
+        it "potentially should treat both expected and actual as Strings"
+      end
+
+    end
+  end
+end

data/spec/lib/pact/something_like_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+module Pact
+  describe SomethingLike do
+    describe 'json_create' do
+      let(:json) do
+'
+{
+    "json_class": "Pact::SomethingLike",
+    "contents" : { "thing" : "blah" }
+}
+'
+      end
+      subject { SomethingLike.json_create(JSON.parse(json)) }
+      it "creates a SomethingLike object from json" do
+        expect(subject).to eq(SomethingLike.new({"thing" => "blah"}))
+      end
+    end
+  end
+
+end

data/spec/lib/pact/tasks/task_helper_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+require 'pact/tasks/task_helper'
+require 'rake/file_utils'
+
+module Pact
+  describe TaskHelper do
+
+
+    describe ".execute_pact_verify" do
+      let(:ruby_path) { "/path/to/ruby" }
+      let(:pact_uri) { "/pact/uri" }
+      let(:default_pact_helper_path) { "/pact/helper/path.rb" }
+
+      before do
+        stub_const("FileUtils::RUBY", ruby_path)
+        allow(Pact::Provider::PactHelperLocater).to receive(:pact_helper_path).and_return(default_pact_helper_path)
+      end
+
+      context "with no pact_helper or pact URI" do
+        let(:command) { "SPEC_OPTS='' #{ruby_path} -S pact verify -h #{default_pact_helper_path}" }
+        it "executes the command" do
+          expect(TaskHelper).to receive(:execute_cmd).with(command)
+          TaskHelper.execute_pact_verify
+        end
+      end
+
+      context "with a pact URI" do
+        let(:command) { "SPEC_OPTS='' #{ruby_path} -S pact verify -h #{default_pact_helper_path} -p #{pact_uri}" }
+        it "executes the command" do
+          expect(TaskHelper).to receive(:execute_cmd).with(command)
+          TaskHelper.execute_pact_verify(pact_uri)
+        end
+      end
+
+      context "with a pact URI and a pact_helper" do
+        let(:custom_pact_helper_path) { '/custom/pact_helper.rb' }
+        let(:command) { "SPEC_OPTS='' #{ruby_path} -S pact verify -h #{custom_pact_helper_path} -p #{pact_uri}" }
+        it "executes the command" do
+          expect(TaskHelper).to receive(:execute_cmd).with(command)
+          TaskHelper.execute_pact_verify(pact_uri, custom_pact_helper_path)
+        end
+      end
+
+      context "with a pact_helper with no .rb on the end" do
+        let(:custom_pact_helper_path) { '/custom/pact_helper' }
+        let(:command) { "SPEC_OPTS='' #{ruby_path} -S pact verify -h #{custom_pact_helper_path}.rb -p #{pact_uri}" }
+        it "executes the command" do
+          expect(TaskHelper).to receive(:execute_cmd).with(command)
+          TaskHelper.execute_pact_verify(pact_uri, custom_pact_helper_path)
+        end
+      end
+
+      context "with a pact URI and a nil pact_helper" do
+        let(:command) { "SPEC_OPTS='' #{ruby_path} -S pact verify -h #{default_pact_helper_path} -p #{pact_uri}" }
+        it "executes the command" do
+          expect(TaskHelper).to receive(:execute_cmd).with(command)
+          TaskHelper.execute_pact_verify(pact_uri, nil)
+        end
+      end
+
+      context "with rspec_opts" do
+        it "includes the rspec_opts as SPEC_OPTS in the command" do
+          expect(TaskHelper).to receive(:execute_cmd) do | command |
+            expect(command).to start_with("SPEC_OPTS=--reporter\\ SomeReporter #{ruby_path}")
+          end
+          TaskHelper.execute_pact_verify(pact_uri, nil, "--reporter SomeReporter")
+        end
+      end
+
+    end
+
+
+  end
+end