Merge branch 'master' into feat/message-contracts

Author: bethesque

CHANGELOG.md

@@ -1,3 +1,13 @@
+<a name="v1.21.0"></a>
+### v1.21.0 (2018-03-19)
+
+
+#### Features
+
+* update pact-support to ~>1.3	 ([17cfbf8](/../../commit/17cfbf8))
+* do not create reports/pacts/help.md when executing verify from a wrapper language	 ([ea6de47](/../../commit/ea6de47))
+
+
 <a name="v1.20.0"></a>
 ### v1.20.0 (2017-12-10)
 

lib/pact/provider/rspec.rb

@@ -145,15 +145,17 @@ def describe_response expected_response, interaction_context
             let(:diff_options) { { with: differ, diff_formatter: diff_formatter } }
 
             if expected_response.status
-              it "has status code #{expected_response.status}" do
+              it "has status code #{expected_response.status}" do | example |
+                set_metadata(example, :pact_actual_status, response_status)
                 expect(response_status).to eql expected_response_status
               end
             end
 
             if expected_response.headers
               describe "includes headers" do
                 expected_response.headers.each do |name, expected_header_value|
-                  it "\"#{name}\" which #{expected_desc_for_it(expected_header_value)}" do
+                  it "\"#{name}\" which #{expected_desc_for_it(expected_header_value)}" do  | example |
+                    set_metadata(example, :pact_actual_headers, response.headers)
                     header_value = response.headers[name]
                     expect(header_value).to match_header(name, expected_header_value)
                   end
@@ -162,8 +164,9 @@ def describe_response expected_response, interaction_context
             end
 
             if expected_response.body
-              it "has a matching body" do
-                expect(response_body).to match_term expected_response_body, diff_options
+              it "has a matching body" do | example |
+                set_metadata(example, :pact_actual_body, response_body)
+                expect(response_body).to match_term expected_response_body, diff_options, example
               end
             end
           end
@@ -176,7 +179,6 @@ def description_for interaction
         def interaction_description_for_rerun_command interaction
           description_for(interaction).capitalize + ( interaction.provider_state ? " given #{interaction.provider_state}" : "")
         end
-
       end
 
       # The "arrange" and "act" parts of the test really only need to be run once,

lib/pact/provider/rspec/matchers.rb

@@ -4,11 +4,9 @@
 require 'pact/rspec'
 require 'pact/shared/json_differ'
 
-
 module Pact
   module RSpec
     module Matchers
-
       module RSpec2Delegator
         # For backwards compatiblity with rspec-2
         def method_missing(method, *args, &block)
@@ -21,33 +19,40 @@ def method_missing(method, *args, &block)
       end
 
       class MatchTerm
-
         include Pact::Matchers::Messages
         include RSpec2Delegator
 
-        def initialize expected, differ, diff_formatter
+        def initialize expected, differ, diff_formatter, example
           @expected = expected
           @differ = differ
           @diff_formatter = diff_formatter
+          @example = example
         end
 
         def matches? actual
           @actual = actual
-          (@difference = @differ.call(@expected, @actual)).empty?
+          @difference = @differ.call(@expected, @actual)
+          unless @difference.empty?
+            Pact::RSpec.with_rspec_3 do
+              @example.metadata[:pact_diff] = @difference
+            end
+            Pact::RSpec.with_rspec_2 do
+              @example.example.metadata[:pact_diff] = @difference
+            end
+          end
+          @difference.empty?
         end
 
         def failure_message
           match_term_failure_message @difference, @actual, @diff_formatter, Pact::RSpec.color_enabled?
         end
-
       end
 
-      def match_term expected, options
-        MatchTerm.new(expected, options.fetch(:with), options.fetch(:diff_formatter))
+      def match_term expected, options, example
+        MatchTerm.new(expected, options.fetch(:with), options.fetch(:diff_formatter), example)
       end
 
       class MatchHeader
-
         include Pact::Matchers
         include Pact::Matchers::Messages
         include RSpec2Delegator
@@ -65,33 +70,11 @@ def matches? actual
         def failure_message
           match_header_failure_message @header_name, @expected, @actual
         end
-
       end
 
       def match_header header_name, expected
         MatchHeader.new(header_name, expected)
       end
-
     end
   end
 end
-
-
-# RSpec::Matchers.define :match_header do |header_name, expected|
-
-#   include Pact::Matchers
-#   include Pact::Matchers::Messages
-
-#   match do |actual|
-#     diff(expected, actual).empty?
-#   end
-
-#   def failure_message_for_should(actual)
-#     match_header_failure_message header_name, expected, actual
-#   end
-
-#   # failure_message_for_should do | actual |
-#   #   match_header_failure_message header_name, expected, actual
-#   # end
-
-# end

lib/pact/provider/rspec/pact_broker_formatter.rb

@@ -1,6 +1,7 @@
 require 'rspec/core/formatters'
 require 'pact/provider/verification_results/publish_all'
 require 'term/ansicolor'
+require 'pact/matchers/extract_diff_messages'
 
 module Pact
   module Provider
@@ -59,6 +60,24 @@ def format_example(example)
                 message: ::Term::ANSIColor.uncolor(example.exception.message)
               }
             end
+
+            if example.metadata[:pact_actual_status]
+              hash[:actualStatus] = example.metadata[:pact_actual_status]
+            end
+
+            if example.metadata[:pact_actual_headers]
+              hash[:actualHeaders] = example.metadata[:pact_actual_headers]
+            end
+
+            if example.metadata[:pact_actual_body]
+              hash[:actualBody] = example.metadata[:pact_actual_body]
+            end
+
+            if example.metadata[:pact_diff]
+              hash[:differences] = Pact::Matchers::ExtractDiffMessages.call(example.metadata[:pact_diff])
+                                    .to_a
+                                    .collect{ | description | {description: description} }
+            end
           end
         end
       end

lib/pact/provider/test_methods.rb

@@ -41,6 +41,16 @@ def set_up_provider_state provider_state_name, consumer, options = {}
       def tear_down_provider_state provider_state_name, consumer, options = {}
         Pact.configuration.provider_state_tear_down.call(provider_state_name, consumer, options)
       end
+
+      def set_metadata example, key, value
+        Pact::RSpec.with_rspec_3 do
+          example.metadata[key] = value
+        end
+
+        Pact::RSpec.with_rspec_2 do
+          example.example.metadata[key] = value
+        end
+      end
     end
   end
 end

lib/pact/version.rb

@@ -1,4 +1,4 @@
 # Remember to bump pact-provider-proxy when this changes major version
 module Pact
-  VERSION = "1.20.1"
+  VERSION = "1.21.0"
 end

pact.gemspec

@@ -28,7 +28,7 @@ Gem::Specification.new do |gem|
   gem.add_runtime_dependency 'webrick'
   gem.add_runtime_dependency 'term-ansicolor', '~> 1.0'
 
-  gem.add_runtime_dependency 'pact-support', '~> 1.2', '>= 1.2.4'
+  gem.add_runtime_dependency 'pact-support', '~> 1.4'
   gem.add_runtime_dependency 'pact-mock_service', '~> 2.0'
 
   gem.add_development_dependency 'rake', '~> 10.0.3'

spec/lib/pact/provider/rspec_spec.rb

@@ -8,53 +8,53 @@
 
   let(:diff_formatter) { Pact::Matchers::UnixDiffFormatter }
 
-  it 'does not match a hash to an array' do
+  it 'does not match a hash to an array' do  | example |
     expect({})
-      .to_not match_term([], with: Pact::JsonDiffer, diff_formatter: diff_formatter)
+      .to_not match_term([], { with: Pact::JsonDiffer, diff_formatter: diff_formatter }, example)
   end
 
-  it 'does not match an array to a hash' do
+  it 'does not match an array to a hash' do  | example |
     expect([])
-      .to_not match_term({}, with: Pact::JsonDiffer, diff_formatter: diff_formatter)
+      .to_not match_term({}, { with: Pact::JsonDiffer, diff_formatter: diff_formatter }, example)
   end
 
-  it 'matches regular expressions' do
+  it 'matches regular expressions' do  | example |
     expect('blah')
-      .to match_term(/[a-z]*/, with: Pact::JsonDiffer, diff_formatter: diff_formatter)
+      .to match_term(/[a-z]*/, { with: Pact::JsonDiffer, diff_formatter: diff_formatter }, example)
   end
 
-  it 'matches pact terms' do
+  it 'matches pact terms' do  | example |
     expect('wootle')
-      .to match_term Pact.term(generate: 'wootle', matcher: /woot../), with: Pact::JsonDiffer, diff_formatter: diff_formatter
+      .to match_term Pact.term(generate: 'wootle', matcher: /woot../), { with: Pact::JsonDiffer, diff_formatter: diff_formatter }, example
   end
 
-  it 'matches all elements of arrays' do
+  it 'matches all elements of arrays' do  | example |
     expect(['one', 'two', ['three']])
-      .to match_term [/one/, 'two', [Pact.term(generate: 'three', matcher: /thr../)]], with: Pact::JsonDiffer, diff_formatter: diff_formatter
+      .to match_term [/one/, 'two', [Pact.term(generate: 'three', matcher: /thr../)]], { with: Pact::JsonDiffer, diff_formatter: diff_formatter }, example
   end
 
-  it 'matches all values of hashes' do
+  it 'matches all values of hashes' do  | example |
     expect({ 1 => 'one', 2 => 2, 3 => 'three' })
-      .to match_term({ 1 => /one/, 2 => 2, 3 => Pact.term(generate: 'three', matcher: /thr../) }, with: Pact::JsonDiffer, diff_formatter: diff_formatter)
+      .to match_term({ 1 => /one/, 2 => 2, 3 => Pact.term(generate: 'three', matcher: /thr../) }, { with: Pact::JsonDiffer, diff_formatter: diff_formatter }, example)
   end
 
-  it 'matches all other objects using ==' do
-    expect('wootle').to match_term 'wootle', with: Pact::JsonDiffer, diff_formatter: diff_formatter
+  it 'matches all other objects using ==' do  | example |
+    expect('wootle').to match_term 'wootle', { with: Pact::JsonDiffer, diff_formatter: diff_formatter }, example
   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)
+  it 'is confused by an empty hash' do  | example |
+    expect(hello: 'everyone').to match_term({}, { with: Pact::JsonDiffer, diff_formatter: diff_formatter }, example)
   end
 
-  it 'should not be confused by an empty array' do
-    expect(['blah']).to_not match_term([], with: Pact::JsonDiffer, diff_formatter: diff_formatter)
+  it 'should not be confused by an empty array' do  | example |
+    expect(['blah']).to_not match_term([], { with: Pact::JsonDiffer, diff_formatter: diff_formatter }, example)
   end
 
-  it "should allow matches on an array where each item in the array only contains a subset of the actual" do
+  it "should allow matches on an array where each item in the array only contains a subset of the actual" do  | example |
     expect([{ name: 'Fred', age: 12 }, { name: 'John', age: 13 }])
-      .to match_term([{ name: 'Fred' }, { name: 'John' }], with: Pact::JsonDiffer, diff_formatter: diff_formatter)
+      .to match_term([{ name: 'Fred' }, { name: 'John' }], { with: Pact::JsonDiffer, diff_formatter: diff_formatter }, example)
   end
 end