pact-v2 2.0.0.pre.preview1

data/lib/pact/provider/rspec/backtrace_formatter.rb

@@ -0,0 +1,43 @@
+module RSpec
+  module Core
+
+    # RSpec 3 has a hardwired @system_exclusion_patterns which removes everything matching /bin\//
+    # This causes *all* the backtrace lines to be cleaned, as rake pact:verify now shells out
+    # to the executable `pact verify ...`
+    # which then causes *all* the lines to be included as the BacktraceFormatter will
+    # include all lines of the backtrace if all lines were filtered out.
+    # This monkey patch only shows lines including bin/pact and removes the
+    # "show all lines if no lines would otherwise be shown" logic.
+
+    class BacktraceFormatter
+
+
+      def format_backtrace(backtrace, options = {})
+        return backtrace if options[:full_backtrace]
+        backtrace.map { |l| backtrace_line(l) }.compact
+      end
+
+      def backtrace_line(line)
+        relative_path(line) unless exclude?(line)
+      rescue SecurityError
+        nil
+      end
+
+      def exclude?(line)
+        return false if @full_backtrace
+        relative_line = relative_path(line)
+        return true unless /bin\/pact/ =~ relative_line
+      end
+
+      # Copied from Metadata so a refactor can't break this overridden class
+      def relative_path(line)
+        line = line.sub(File.expand_path("."), ".")
+        line = line.sub(/\A([^:]+:\d+)$/, '\\1')
+        return nil if line == '-e:1'
+        line
+      rescue SecurityError
+        nil
+      end
+    end
+  end
+end

data/lib/pact/provider/rspec/calculate_exit_code.rb

@@ -0,0 +1,18 @@
+module Pact
+  module Provider
+    module RSpec
+      module CalculateExitCode
+        def self.call(pact_sources, failed_examples)
+          any_non_pending_failures = pact_sources.any? do |pact_source|
+            if pact_source.pending?
+              nil
+            else
+              failed_examples.select { |e| e.metadata[:pact_source] == pact_source }.any?
+            end
+          end
+          any_non_pending_failures ? 1 : 0
+        end
+      end
+    end
+  end
+end

data/lib/pact/provider/rspec/formatter_rspec_2.rb

@@ -0,0 +1,76 @@
+require 'pact/provider/print_missing_provider_states'
+require 'rspec/core/formatters/documentation_formatter'
+require 'rainbow'
+require 'pact/provider/help/prompt_text'
+
+module Pact
+  module Provider
+    module RSpec
+      class Formatter2 < ::RSpec::Core::Formatters::DocumentationFormatter
+
+        class NilFormatter < ::RSpec::Core::Formatters::DocumentationFormatter
+          def dump_commands_to_rerun_failed_examples
+          end
+        end
+
+        def dump_commands_to_rerun_failed_examples
+          return if failed_examples.empty?
+
+          print_rerun_commands
+          print_failure_message
+          print_missing_provider_states
+
+        end
+
+        private
+
+        def print_rerun_commands
+          output.puts("\n")
+          interaction_rerun_commands.each do | message |
+            output.puts(message)
+          end
+        end
+
+        def print_missing_provider_states
+          if executing_with_ruby?
+            PrintMissingProviderStates.call Pact.provider_world.provider_states.missing_provider_states, output
+          end
+        end
+
+        def interaction_rerun_commands
+          failed_examples.collect do |example|
+            interaction_rerun_command_for example
+          end.uniq
+        end
+
+        def interaction_rerun_command_for example
+          example_description = example.metadata[:pact_interaction_example_description]
+          if ENV['PACT_INTERACTION_RERUN_COMMAND']
+            cmd = String.new(ENV['PACT_INTERACTION_RERUN_COMMAND'])
+            provider_state = example.metadata[:pact_interaction].provider_state
+            description = example.metadata[:pact_interaction].description
+            pactfile_uri = example.metadata[:pactfile_uri]
+            cmd.gsub!("<PACT_URI>", pactfile_uri.to_s)
+            cmd.gsub!("<PACT_DESCRIPTION>", description)
+            cmd.gsub!("<PACT_PROVIDER_STATE>", "#{provider_state}")
+            failure_color(cmd) + " " + detail_color("# #{example_description}")
+          else
+            failure_color("* #{example_description}")
+          end
+        end
+
+        def print_failure_message
+          output.puts(failure_message) if executing_with_ruby?
+        end
+
+        def failure_message
+          "\n" + Pact::Provider::Help::PromptText.() + "\n"
+        end
+
+        def executing_with_ruby?
+          ENV['PACT_EXECUTING_LANGUAGE'] == 'ruby'
+        end
+      end
+    end
+  end
+end

data/lib/pact/provider/rspec/formatter_rspec_3.rb

@@ -0,0 +1,195 @@
+require 'pact/provider/print_missing_provider_states'
+require 'rspec/core/formatters'
+require 'rainbow'
+require 'pact/provider/help/prompt_text'
+
+module Pact
+  module Provider
+    module RSpec
+      class Formatter < ::RSpec::Core::Formatters::DocumentationFormatter
+
+        class NilFormatter < ::RSpec::Core::Formatters::BaseFormatter
+          Pact::RSpec.with_rspec_3 do
+            ::RSpec::Core::Formatters.register self, :start, :example_group_started, :close
+          end
+
+          def dump_summary(summary)
+          end
+        end
+
+        Pact::RSpec.with_rspec_3 do
+          ::RSpec::Core::Formatters.register self, :example_group_started, :example_group_finished,
+                                    :example_passed, :example_pending, :example_failed
+        end
+
+        def example_group_started(notification)
+          # This is the metadata on the top level "Verifying a pact between X and Y" describe block
+          if @group_level == 0
+            Pact.configuration.output_stream.puts
+            pact_uri = notification.group.metadata[:pactfile_uri]
+            ::RSpec.configuration.failure_color = pact_uri.metadata[:pending] ? :yellow : :red
+
+            if pact_uri.metadata[:notices]
+              pact_uri.metadata[:notices].before_verification_notices_text.each do | text |
+                Pact.configuration.output_stream.puts("DEBUG: #{text}")
+              end
+            end
+
+            criteria = notification.group.metadata[:pact_criteria]
+            Pact.configuration.output_stream.puts "DEBUG: Filtering interactions by: #{criteria}" if criteria && criteria.any?
+          end
+          super
+        end
+
+
+        def dump_summary(summary)
+          output.puts "\n" + colorized_totals_line(summary)
+          return if summary.failure_count == 0
+          print_rerun_commands summary
+          print_failure_message
+          print_missing_provider_states
+        end
+
+        private
+
+        def interactions_count(summary)
+          summary.examples.collect{ |e| interaction_unique_key(e) }.uniq.size
+        end
+
+        def failed_interactions_count(summary)
+          failed_interaction_examples(summary).size
+        end
+
+        def pending_interactions_count(summary)
+          pending_interaction_examples(summary).size
+        end
+
+        def failure_title summary
+          ::RSpec::Core::Formatters::Helpers.pluralize(failed_interactions_count(summary), "failure")
+        end
+
+        def totals_line summary
+          line = ::RSpec::Core::Formatters::Helpers.pluralize(interactions_count(summary), "interaction")
+          line << ", " << failure_title(summary)
+          pending_count = pending_interactions_count(summary)
+          line << ", " << "#{pending_count} pending" if pending_count > 0
+          line
+        end
+
+        def colorized_totals_line(summary)
+          colorizer.wrap(totals_line(summary), color_for_summary(summary))
+        end
+
+        def color_for_summary summary
+          summary.failure_count > 0 ? ::RSpec.configuration.failure_color : ::RSpec.configuration.success_color
+        end
+
+        def print_rerun_commands summary
+          if pending_interactions_count(summary) > 0
+            set_rspec_failure_color(:yellow)
+            output.puts("\nPending interactions: (Failures listed here are expected and do not affect your suite's status)\n\n")
+            interaction_rerun_commands(pending_interaction_examples(summary)).each do | message |
+              output.puts(message)
+            end
+            set_rspec_failure_color(:red)
+          end
+
+          if failed_interactions_count(summary) > 0
+            output.puts("\nFailed interactions:\n\n")
+            interaction_rerun_commands(failed_interaction_examples(summary)).each do | message |
+              output.puts(message)
+            end
+          end
+        end
+
+        def print_missing_provider_states
+          if executing_with_ruby?
+            PrintMissingProviderStates.call Pact.provider_world.provider_states.missing_provider_states, output
+          end
+        end
+
+        def pending_interaction_examples(summary)
+          one_failed_example_per_interaction(summary).select do | example |
+            example.metadata[:pactfile_uri].metadata[:pending]
+          end
+        end
+
+        def failed_interaction_examples(summary)
+          one_failed_example_per_interaction(summary).select do | example |
+            !example.metadata[:pactfile_uri].metadata[:pending]
+          end
+        end
+
+        def one_failed_example_per_interaction(summary)
+          summary.failed_examples.group_by{| e| interaction_unique_key(e)}.values.collect(&:first)
+        end
+
+        def interaction_rerun_commands examples
+          examples.collect do |example|
+            interaction_rerun_command_for example
+          end.compact.uniq
+        end
+
+        def interaction_unique_key(example)
+          # pending is just to make the counting easier, it isn't required for the unique key
+          {
+            pactfile_uri: example.metadata[:pactfile_uri],
+            index: example.metadata[:pact_interaction].index,
+          }
+        end
+
+        def interaction_rerun_command_for example
+          example_description = example.metadata[:pact_interaction_example_description]
+
+          _id = example.metadata[:pact_interaction]._id
+          index = example.metadata[:pact_interaction].index
+          provider_state = example.metadata[:pact_interaction].provider_state
+          description = example.metadata[:pact_interaction].description
+          pactfile_uri = example.metadata[:pactfile_uri]
+
+          if _id && ENV['PACT_INTERACTION_RERUN_COMMAND_FOR_BROKER']
+            cmd = String.new(ENV['PACT_INTERACTION_RERUN_COMMAND_FOR_BROKER'])
+            cmd.gsub!("<PACT_URI>", example.metadata[:pactfile_uri].to_s)
+            cmd.gsub!("<PACT_BROKER_INTERACTION_ID>", "#{_id}")
+            colorizer.wrap("#{cmd} ", ::RSpec.configuration.failure_color) + colorizer.wrap("# #{example_description}", ::RSpec.configuration.detail_color)
+          elsif ENV['PACT_INTERACTION_RERUN_COMMAND']
+            cmd = String.new(ENV['PACT_INTERACTION_RERUN_COMMAND'])
+            cmd.gsub!("<PACT_URI>", pactfile_uri.to_s)
+            cmd.gsub!("<PACT_DESCRIPTION>", description)
+            cmd.gsub!("<PACT_PROVIDER_STATE>", "#{provider_state}")
+            cmd.gsub!("<PACT_INTERACTION_INDEX>", "#{index}")
+            colorizer.wrap("#{cmd} ", ::RSpec.configuration.failure_color) + colorizer.wrap("# #{example_description}", ::RSpec.configuration.detail_color)
+          else
+            message = if _id
+              "* #{example_description} (to re-run just this interaction, set environment variable PACT_BROKER_INTERACTION_ID=\"#{_id}\")"
+            else
+              "* #{example_description} (to re-run just this interaction, set environment variables PACT_DESCRIPTION=\"#{description}\" PACT_PROVIDER_STATE=\"#{provider_state}\")"
+            end
+            colorizer.wrap(message, ::RSpec.configuration.failure_color)
+          end
+        end
+
+        def print_failure_message
+          output.puts(failure_message) if executing_with_ruby?
+        end
+
+        def failure_message
+          "\n" + Pact::Provider::Help::PromptText.() + "\n"
+        end
+
+        def colorizer
+          @colorizer ||= ::RSpec::Core::Formatters::ConsoleCodes
+        end
+
+        def executing_with_ruby?
+          ENV['PACT_EXECUTING_LANGUAGE'] == 'ruby'
+        end
+
+        def set_rspec_failure_color color
+          ::RSpec.configuration.failure_color = color
+        end
+      end
+    end
+  end
+end
+

data/lib/pact/provider/rspec/json_formatter.rb

@@ -0,0 +1,100 @@
+require 'rspec/core/formatters/json_formatter'
+
+module Pact
+  module Provider
+    module RSpec
+      class JsonFormatter < ::RSpec::Core::Formatters::JsonFormatter
+        ::RSpec::Core::Formatters.register self, :message, :dump_summary, :dump_profile, :stop, :seed, :close
+
+        def dump_summary(summary)
+          super(create_custom_summary(summary))
+          output_hash[:summary][:pacts] = pacts(summary)
+        end
+
+        def format_example(example)
+          {
+            :id => example.id,
+            :interaction_index => example.metadata[:pact_interaction].index,
+            :description => example.description,
+            :full_description => example.full_description,
+            :status => calculate_status(example),
+            :file_path => example.metadata[:file_path],
+            :line_number  => example.metadata[:line_number],
+            :run_time => example.execution_result.run_time,
+            :mismatches => extract_differences(example),
+            :pact_url => example.metadata[:pact_uri].uri
+          }
+        end
+
+        def stop(notification)
+          output_hash[:examples] = notification.examples.map do |example|
+            format_example(example).tap do |hash|
+              e = example.exception
+              if e
+                hash[:exception] =  {
+                  class: e.class.name,
+                  message: e.message,
+                }
+                # No point providing a backtrace for a mismatch, too much noise
+                if !e.is_a?(::RSpec::Expectations::ExpectationNotMetError)
+                  hash[:exception][:backtrace]
+                end
+              end
+            end
+          end
+        end
+
+        def calculate_status(example)
+          if example.execution_result.status == :failed && example.metadata[:pact_ignore_failures]
+            'pending'
+          else
+            example.execution_result.status.to_s
+          end
+        end
+
+        # There will most likely be only one pact associated with this RSpec execution, because
+        # the most likely user of this formatter is the Go implementation that parses the JSON
+        # and builds Go tests from them.
+        # If the JSON formatter is used by someone else and they have multiple pacts, all the notices
+        # for the pacts will be mushed together in one collection, so it will be hard to know which notice
+        # belongs to which pact.
+        def pacts(summary)
+          unique_pact_metadatas(summary).collect do | example_metadata |
+            pact_uri = example_metadata[:pact_uri]
+            notices = (pact_uri.metadata[:notices] && pact_uri.metadata[:notices].before_verification_notices) || []
+            {
+              notices: notices,
+              url: pact_uri.uri,
+              consumer_name: example_metadata[:pact_consumer_contract].consumer.name,
+              provider_name: example_metadata[:pact_consumer_contract].provider.name,
+              short_description: pact_uri.metadata[:short_description]
+            }
+          end
+        end
+
+        def unique_pact_metadatas(summary)
+          summary.examples.collect(&:metadata).group_by{ | metadata | metadata[:pact_uri].uri }.values.collect(&:first)
+        end
+
+        def create_custom_summary(summary)
+          ::RSpec::Core::Notifications::SummaryNotification.new(
+            summary.duration,
+            summary.examples,
+            summary.examples.select{ | example | example.execution_result.status == :failed && !example.metadata[:pact_ignore_failures] },
+            summary.examples.select{ | example | example.execution_result.status == :failed && example.metadata[:pact_ignore_failures] },
+            summary.load_time,
+            summary.errors_outside_of_examples_count
+          )
+        end
+
+        def extract_differences(example)
+          if example.metadata[:pact_diff]
+            Pact::Matchers::ExtractDiffMessages.call(example.metadata[:pact_diff]).to_a
+          else
+            []
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact/provider/rspec/matchers.rb

@@ -0,0 +1,80 @@
+require 'rspec'
+require 'pact/matchers'
+require 'pact/provider/matchers/messages'
+require 'pact/rspec'
+require 'pact/shared/json_differ'
+
+module Pact
+  module RSpec
+    module Matchers
+      module RSpec2Delegator
+        # For backwards compatibility with rspec-2
+        def method_missing(method, *args, &block)
+          if method_name == :failure_message_for_should
+            failure_message method, *args, &block
+          else
+            super
+          end
+        end
+      end
+
+      class MatchTerm
+        include Pact::Matchers::Messages
+        include RSpec2Delegator
+
+        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)
+          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, example
+        MatchTerm.new(expected, options.fetch(:with), options.fetch(:diff_formatter), example)
+      end
+
+      class MatchHeader
+        include Pact::Matchers
+        include Pact::Matchers::Messages
+        include RSpec2Delegator
+
+        def initialize header_name, expected
+          @header_name = header_name
+          @expected = expected
+        end
+
+        def matches? actual
+          @actual = actual
+          diff(@expected, @actual).empty?
+        end
+
+        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

data/lib/pact/provider/rspec/pact_broker_formatter.rb

@@ -0,0 +1,76 @@
+require 'rspec/core/formatters'
+require 'pact/provider/verification_results/publish_all'
+require 'rainbow'
+require 'pact/matchers/extract_diff_messages'
+
+module Pact
+  module Provider
+    module RSpec
+      class PactBrokerFormatter < ::RSpec::Core::Formatters::BaseFormatter
+        Pact::RSpec.with_rspec_3 do
+          ::RSpec::Core::Formatters.register self, :stop, :close
+        end
+
+        attr_reader :output_hash
+
+        def initialize(output)
+          super
+          @output_hash = {}
+        end
+
+        def stop(notification)
+          @output_hash[:tests] = notification
+                                  .examples
+                                  .map { |example| format_example(example) }
+        end
+
+        def close(_notification)
+          Pact::Provider::VerificationResults::PublishAll.call(Pact.provider_world.pact_sources, output_hash, { verbose: Pact.provider_world.verbose })
+        end
+
+      private
+
+        def format_example(example)
+          {
+            testDescription: example.description,
+            testFullDescription: example.full_description,
+            status: example.execution_result.status.to_s,
+            interactionProviderState: example.metadata[:pact_interaction].provider_state,
+            interactionDescription: example.metadata[:pact_interaction].description,
+            pact_uri: example.metadata[:pact_uri],
+            pact_interaction: example.metadata[:pact_interaction]
+          }.tap do |hash|
+            if example.exception
+              hash[:exception] =  {
+                class: example.exception.class.name,
+                message: "\e[0m#{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_actual_contents]
+              hash[:actualContents] = example.metadata[:pact_actual_contents]
+            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
+    end
+  end
+end