pact 1.2.1.rc2 → 1.3.3

data/spec/lib/pact/consumer_contract/interaction_spec.rb

@@ -7,6 +7,9 @@ module Pact
 
     describe Interaction do
 
+      let(:request) { {method: 'get', path: 'path'} }
+      let(:response) { {} }
+
       describe "==" do
         subject { InteractionFactory.create }
         context "when other is the same" do
@@ -39,6 +42,17 @@ module Pact
         end
       end
 
+      describe "from_hash" do
+        context "when providerState has been used instead of provider_state" do
+
+          subject { Interaction.from_hash('response' => response, 'request' => request, 'providerState' => 'some state') }
+
+          it "recognises the provider state" do
+            expect(subject.provider_state).to eq 'some state'
+          end
+        end
+      end
+
       describe "to JSON" do
         let(:request) do
           {

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

@@ -76,6 +76,15 @@ module Pact
         end
       end
 
+      context "when the methods are the same but different case" do
+        let(:expected_method) { 'get' }
+        let(:actual_method) { 'GET' }
+
+        it "matches" do
+          expect(subject.matches? actual_request).to be true
+        end
+      end
+
       context "when the paths are different" do
         let(:expected_path) { '/foo' }
         let(:actual_path) { '/bar' }

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

@@ -1,11 +1,46 @@
 require 'spec_helper'
 require 'pact/matchers'
+require 'pact/consumer_contract/headers'
 
 module Pact::Matchers
 
   describe Pact::Matchers do
     include Pact::Matchers
 
+    # TODO this is an integration test
+    describe 'matching headers' do
+      let(:expected) { Pact::Headers.new('Content-Type' => 'application/hippo')}
+
+      context "when the headers match in a case insensitive way" do
+
+        context "when the values match" do
+          let(:actual) { Pact::Headers.new('CONTENT-TYPE' => 'application/hippo')}
+          it "returns an empty diff" do
+            expect(diff(expected, actual)).to be_empty
+          end
+        end
+
+        context "when the header values do not match" do
+          let(:actual) { Pact::Headers.new('CONTENT-TYPE' => 'application/alligator')}
+          let(:difference) { {"Content-Type" => Difference.new('application/hippo', 'application/alligator')} }
+          it "returns the diff" do
+            expect(diff(expected, actual)).to eq difference
+          end
+        end
+      end
+
+      context "when the headers do not match" do
+
+        let(:actual) { Pact::Headers.new('Content-Length' => '1')}
+        let(:difference) { {"Content-Type" => Difference.new('application/hippo', Pact::KeyNotFound.new)} }
+        it "returns a diff" do
+          expect(diff(expected, actual)).to eq difference
+        end
+
+      end
+
+    end
+
     describe 'matching with something like' do
 
       context 'when the actual is something like the expected' do

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

@@ -9,6 +9,7 @@ module Pact
 
       describe ".call" do
 
+        let(:key_lines_count) { 4 }
         let(:colour) { false }
         subject { UnixDiffFormatter.call(diff, {colour: colour}) }
 
@@ -54,7 +55,7 @@ EOF
           end
 
           it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 9
+            expect(line_count).to eq 9 + key_lines_count
           end
 
         end
@@ -76,7 +77,7 @@ EOF
           end
 
           it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 9
+            expect(line_count).to eq 9 + key_lines_count
           end
 
         end
@@ -98,7 +99,7 @@ EOF
           end
 
           it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 5
+            expect(line_count).to eq 5 + key_lines_count
           end
 
         end
@@ -120,7 +121,7 @@ EOF
           end
 
           it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 8
+            expect(line_count).to eq 8 + key_lines_count
           end
         end
 
@@ -140,7 +141,7 @@ EOF
           end
 
           it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 8
+            expect(line_count).to eq 8 + key_lines_count
           end
 
         end
@@ -159,7 +160,7 @@ EOF
           end
 
           it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 8
+            expect(line_count).to eq 8 + key_lines_count
           end
 
         end
@@ -185,7 +186,7 @@ EOF
           end
 
           it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 8
+            expect(line_count).to eq 8 + key_lines_count
           end
 
         end
@@ -203,7 +204,7 @@ EOF
           end
 
           it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 11
+            expect(line_count).to eq 11 + key_lines_count
           end
 
         end

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

@@ -84,6 +84,22 @@ module Pact
           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

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

@@ -9,6 +9,7 @@ module Pact
 
       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"}
@@ -20,13 +21,13 @@ module Pact
         let(:message_line_count) { message.split("\n").size }
 
         before do
-          allow(Pact.configuration.diff_formatter).to receive(:call).and_return(message)
+          allow(diff_formatter).to receive(:call).and_return(message)
         end
 
-        subject { match_term_failure_message diff, actual, color_enabled }
+        subject { match_term_failure_message diff, actual, diff_formatter, color_enabled }
 
-        it "creates a message using the configured diff_formatter" do
-          expect(Pact.configuration.diff_formatter).to receive(:call).with(diff)
+        it "creates a message using the diff_formatter" do
+          expect(diff_formatter).to receive(:call).with(diff)
           subject
         end
 

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

@@ -1,51 +1,55 @@
-require 'pact/provider/rspec'
 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([])
+    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({})
+    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]*/)
+    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../)
+    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../)]]
+    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../)})
+    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'
+    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({})
+    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([])
+    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'}])
+    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/reification_spec.rb

@@ -51,5 +51,17 @@ module Pact
 
     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/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/request_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require 'pact/shared/request'
+require 'pact/shared/key_not_found'
 
 module Pact
 
@@ -10,7 +11,7 @@ module Pact
       class TestRequest < Base
 
         def self.key_not_found
-          nil
+          Pact::KeyNotFound.new
         end
 
       end
@@ -82,6 +83,29 @@ module Pact
         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/support/options.json

@@ -0,0 +1,21 @@
+{
+    "consumer": {
+        "name": "Consumer"
+    },
+    "provider": {
+        "name": "Provider"
+    },
+    "interactions": [
+        {
+            "description": "an OPTIONS request",
+            "request": {
+                "method": "options",
+                "path": "/"
+            },
+            "response": {
+                "status": 200
+            },
+            "provider_state": null
+        }
+    ]
+}

data/spec/support/options_app.rb

@@ -0,0 +1,15 @@
+require 'pact/provider/rspec'
+
+class App
+  def self.call env
+    if env['REQUEST_METHOD'] == 'OPTIONS'
+      [200, {}, []]
+    else
+      [500, {}, ["Expected an options request"]]
+    end
+  end
+end
+
+Pact.service_provider 'Provider' do
+  app { App }
+end

data/spec/support/pact_helper.rb

@@ -11,6 +11,8 @@ module Pact
 					[200, {'Content-Type' => 'application/json'}, [{message: WEATHER[:current_state], :array => [{"foo"=> "blah"}]}.to_json]]
 				elsif env['PATH_INFO'] == '/sometext'
 					[200, {'Content-Type' => 'text/plain'}, ['some text']]
+				elsif env['PATH_INFO'] == '/content_type_is_important'
+						[200, {'Content-Type' => 'application/json'}, [{message: "A message", note: "This will cause verify to fail if it using the wrong content type differ."}.to_json]]
 				else
 					raise "unexpected path #{env['PATH_INFO']}!!!"
 				end

data/spec/support/test_app_with_right_content_type_differ.json

@@ -0,0 +1,23 @@
+{
+    "consumer": {
+        "name": "some-test-consumer"
+    },
+    "provider": {
+        "name": "the test app in the pact_helper file"
+    },
+    "interactions": [
+        {
+            "description": "a test request expecting an application/json response",
+            "request": {
+                "method": "get",
+                "path": "/content_type_is_important",
+                "query": ""
+            },
+            "response": {
+                "status": 200,
+                "headers" : {"Content-type": "application/json"},
+                "body": {"message" : "A message"}
+            }
+        }
+    ]
+}

data/tasks/pact-test.rake

@@ -5,6 +5,10 @@ Pact::VerificationTask.new(:stubbing) do | pact |
 	pact.uri './spec/support/stubbing.json', :pact_helper => './spec/support/stubbing_using_allow.rb'
 end
 
+Pact::VerificationTask.new(:options) do | pact |
+	pact.uri './spec/support/options.json', :pact_helper => './spec/support/options_app.rb'
+end
+
 Pact::VerificationTask.new(:pass) do | pact |
 	pact.uri './spec/support/test_app_pass.json'
 end
@@ -30,6 +34,10 @@ Pact::VerificationTask.new('test_app:pass') do | pact |
 	pact.uri './spec/support/test_app_pass.json'
 end
 
+Pact::VerificationTask.new('test_app:content_type') do | pact |
+	pact.uri './spec/support/test_app_with_right_content_type_differ.json'
+end
+
 Pact::VerificationTask.new('test_app:fail') do | pact |
 	pact.uri './spec/support/test_app_fail.json', pact_helper: './spec/support/pact_helper.rb'
 end
@@ -45,6 +53,8 @@ namespace :pact do
 		Rake::Task['pact:verify'].execute
 		Rake::Task['pact:verify:test_app:pass'].execute
 		Rake::Task['pact:test:fail'].execute
+		Rake::Task['pact:test:pactfile'].execute
+		Rake::Task['pact:verify:test_app:content_type'].execute
 	end
 
 	desc "All the verification tests with active support loaded"