pact-v2 2.0.0.pre.preview1

data/lib/pact/provider/help/pact_diff.rb

@@ -0,0 +1,43 @@
+require 'pact/hal/entity'
+
+module Pact
+  module Provider
+    module Help
+      class PactDiff
+        class PrintPactDiffError < StandardError; end
+
+        attr_reader :pact_source, :output
+
+        def initialize pact_source
+          @pact_source = pact_source
+        end
+
+        def self.call pact_source
+          new(pact_source).call
+        end
+
+        def call
+          begin
+            header + "\n" + get_diff
+          rescue PrintPactDiffError => e
+            return e.message
+          end
+        end
+
+        private
+
+        def header
+          "The following changes have been made since the previous distinct version of this pact, and may be responsible for verification failure:\n"
+        end
+
+        def get_diff
+          begin
+            pact_source.hal_entity._link!("pb:diff-previous-distinct").get!(nil, "Accept" => "text/plain").body
+          rescue StandardError => e
+            raise PrintPactDiffError.new("Tried to retrieve diff with previous pact, but received error #{e.class} #{e.message}.")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact/provider/help/prompt_text.rb

@@ -0,0 +1,49 @@
+require 'pact/consumer/configuration'
+require 'rainbow'
+require 'pathname'
+
+module Pact
+  module Provider
+    module Help
+      class PromptText
+
+        def self.call reports_dir = Pact.configuration.reports_dir, options = {color: Pact.configuration.color_enabled}
+          new(reports_dir, options).call
+        end
+
+        def initialize reports_dir, options
+          @reports_dir = File.expand_path(reports_dir)
+          @options = options
+        end
+
+        def call
+          options[:color] ? prompt_text_colored : prompt_text_plain
+        end
+
+        private
+
+        attr_reader :reports_dir, :options
+
+        def prompt_text_plain
+          "For assistance debugging failures, run `bundle exec rake pact:verify:help#{rake_args}`\n"
+        end
+
+        def prompt_text_colored
+          Rainbow(prompt_text_plain).yellow
+        end
+
+        def rake_args
+          if reports_dir == Pact.configuration.default_reports_dir
+            ''
+          else
+            "[#{relative_reports_dir}]"
+          end
+        end
+
+        def relative_reports_dir
+          Pathname.new(reports_dir).relative_path_from(Pathname.new(Dir.pwd))
+        end
+      end
+    end
+  end
+end

data/lib/pact/provider/help/write.rb

@@ -0,0 +1,56 @@
+require 'pact/provider/help/content'
+require 'fileutils'
+require 'pact/consumer/configuration'
+
+module Pact
+  module Provider
+    module Help
+      class Write
+
+        HELP_FILE_NAME = 'help.md'
+
+        def self.call pact_sources, reports_dir = Pact.configuration.reports_dir
+          new(pact_sources, reports_dir).call
+        end
+
+        def initialize pact_sources, reports_dir
+          @pact_sources = pact_sources
+          @reports_dir = File.expand_path(reports_dir)
+        end
+
+        def call
+          clean_reports_dir
+          write
+        rescue StandardError => e
+          Pact.configuration.error_stream.puts("ERROR: Error generating help output - #{e.class} #{e.message} \n" + e.backtrace.join("\n"))
+        end
+
+        private
+
+        attr_reader :reports_dir, :pact_sources
+
+        def clean_reports_dir
+          raise "Cleaning report dir #{reports_dir} would delete project!" if reports_dir_contains_pwd
+          FileUtils.rm_rf reports_dir
+          FileUtils.mkdir_p reports_dir
+        end
+
+        def reports_dir_contains_pwd
+          Dir.pwd.start_with?(reports_dir)
+        end
+
+        def write
+          File.open(help_path, "w") { |file| file << help_text }
+        end
+
+        def help_path
+          File.join(reports_dir, 'help.md')
+        end
+
+        def help_text
+          Content.new(pact_sources).text
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+require 'rainbow'
+require 'pact/term'
+
+module Pact
+  module Matchers
+    module Messages
+
+      def match_term_failure_message diff, actual, diff_formatter, color_enabled
+        actual_string = String === actual ? actual : actual.to_json
+        maybe_coloured_string = color_enabled ? Rainbow(actual_string).white : actual_string
+        message = "Actual: #{maybe_coloured_string}\n\n"
+        formatted_diff = diff_formatter.call(diff)
+        message + colorize_if_enabled(formatted_diff, color_enabled)
+      end
+
+      def match_header_failure_message header_name, expected, actual
+        "Expected header \"#{header_name}\" to #{expected_desc(expected)}, but was #{actual_desc(actual)}"
+      end
+
+      def expected_desc_for_it expected
+        case expected
+        when NilClass then "is nil"
+        when Regexp
+          "matches #{expected.inspect}"
+        when Pact::Term
+          "matches #{expected.matcher.inspect}"
+        when Pact::SomethingLike
+          "is an instance of #{Pact::Reification.from_term(expected).class}"
+        else
+          "equals #{expected.inspect}"
+        end
+      end
+
+      private
+
+      def colorize_if_enabled formatted_diff, color_enabled
+        if color_enabled
+          # RSpec wraps each line in the failure message with failure_color, turning it red.
+          # To ensure the lines in the diff that should be white, stay white, put an
+          # ANSI reset at the start of each line.
+          formatted_diff.split("\n").collect{ |line|"\e[0m#{line}" }.join("\n")
+        else
+          formatted_diff
+        end
+      end
+
+      def expected_desc expected
+        case expected
+        when NilClass then "be nil"
+        when Regexp
+          "match #{expected.inspect}"
+        when Pact::Term
+          "match #{expected.matcher.inspect}"
+        when Pact::SomethingLike
+          "be an instance of #{Pact::Reification.from_term(expected).class}"
+        else
+          "equal #{expected.inspect}"
+        end
+      end
+
+      def actual_desc actual
+        actual.nil? ? 'nil' : '"' + actual + '"'
+      end
+    end
+  end
+end

data/lib/pact/provider/pact_helper_locator.rb

@@ -0,0 +1,24 @@
+module Pact
+  module Provider
+    module PactHelperLocater
+      PACT_HELPER_FILE_PATTERNS = [
+        "spec/**/*service*consumer*/pact_helper.rb",
+        "spec/**/*consumer*/pact_helper.rb",
+        "spec/**/pact_helper.rb",
+        "test/**/*service*consumer*/pact_helper.rb",
+        "test/**/*consumer*/pact_helper.rb",
+        "test/**/pact_helper.rb",
+        "**/pact_helper.rb"
+      ]
+
+      NO_PACT_HELPER_FOUND_MSG = "Please create a pact_helper.rb file that can be found using one of the following patterns: #{PACT_HELPER_FILE_PATTERNS.join(", ")}"
+
+      def self.pact_helper_path
+        pact_helper_search_results = []
+        PACT_HELPER_FILE_PATTERNS.find { | pattern | (pact_helper_search_results.concat(Dir.glob(pattern))).any? }
+        raise NO_PACT_HELPER_FOUND_MSG if pact_helper_search_results.empty?
+        File.join(Dir.pwd, pact_helper_search_results[0])
+      end
+    end
+  end
+end

data/lib/pact/provider/pact_source.rb

@@ -0,0 +1,40 @@
+require 'pact/consumer_contract/pact_file'
+require 'pact/hal/http_client'
+require 'pact/hal/entity'
+require 'pact/consumer_contract'
+
+module Pact
+  module Provider
+    class PactSource
+
+      attr_reader :uri # PactURI class
+
+      def initialize uri
+        @uri = uri
+      end
+
+      def pact_json
+        @pact_json ||= Pact::PactFile.read(uri.uri, uri.options)
+      end
+
+      def pact_hash
+        @pact_hash ||= JSON.load(pact_json, nil, { max_nesting: 50 })
+      end
+
+      def pending?
+        uri.metadata[:pending]
+      end
+
+      def consumer_contract
+        @consumer_contract ||= Pact::ConsumerContract.from_json(pact_json)
+      end
+
+      def hal_entity
+        http_client_keys = [:username, :password, :token]
+        http_client_options = uri.options.reject{ |k, _| !http_client_keys.include?(k) }
+        http_client = Pact::Hal::HttpClient.new(http_client_options)
+        Pact::Hal::Entity.new(uri, pact_hash, http_client)
+      end
+    end
+  end
+end

data/lib/pact/provider/pact_spec_runner.rb

@@ -0,0 +1,188 @@
+require 'open-uri'
+require 'rspec'
+require 'rspec/core'
+require 'rspec/core/formatters/documentation_formatter'
+require 'pact/provider/pact_helper_locator'
+require 'pact/project_root'
+require 'pact/rspec'
+require 'pact/provider/pact_source'
+require 'pact/provider/help/write'
+require 'pact/provider/verification_results/publish_all'
+require 'pact/provider/rspec/pact_broker_formatter'
+require 'pact/provider/rspec/json_formatter'
+require 'pact/provider/rspec'
+require 'pact/provider/rspec/calculate_exit_code'
+require 'pact/utils/metrics'
+
+module Pact
+  module Provider
+    class PactSpecRunner
+
+      include Pact::Provider::RSpec::ClassMethods
+
+      attr_reader :pact_urls
+      attr_reader :options
+
+      def initialize pact_urls, options = {}
+        @pact_urls = pact_urls
+        @options = options
+        @results = nil
+      end
+
+      def run
+        begin
+          configure_rspec
+          initialize_specs
+          run_specs
+        ensure
+          ::RSpec.reset
+          Pact.clear_provider_world
+          Pact.clear_consumer_world
+        end
+      end
+
+      private
+
+      def configure_rspec
+        monkey_patch_backtrace_formatter
+
+        config = ::RSpec.configuration
+
+        config.color = true
+        config.pattern = "pattern which doesn't match any files"
+        config.backtrace_inclusion_patterns = [Regexp.new(Dir.getwd), /pact.*main/]
+
+        config.extend Pact::Provider::RSpec::ClassMethods
+        config.include Pact::Provider::RSpec::InstanceMethods
+        config.include Pact::Provider::TestMethods
+
+        if options[:silent]
+          config.output_stream = StringIO.new
+          config.error_stream = StringIO.new
+        else
+          config.error_stream = Pact.configuration.error_stream
+          config.output_stream = Pact.configuration.output_stream
+        end
+
+        configure_output
+
+        config.before(:suite) do
+          # Preload app before suite so the classes loaded in memory are consistent for
+          # before :each and after :each hooks.
+          # Otherwise the app and all its dependencies are loaded between the first before :each
+          # and the first after :each, leading to inconsistent behaviour
+          # (eg. with database_cleaner transactions)
+          Pact.configuration.provider.app
+        end
+
+        # For the Pact::Provider::RSpec::PactBrokerFormatter
+        Pact.provider_world.verbose = options[:verbose]
+        Pact.provider_world.pact_sources = pact_sources
+        jsons = pact_jsons
+        executing_with_ruby = executing_with_ruby?
+
+        config.after(:suite) do | suite |
+          Pact.provider_world.failed_examples = suite.reporter.failed_examples
+          Pact::Provider::Help::Write.call(Pact.provider_world.pact_sources) if executing_with_ruby
+        end
+      end
+
+      def run_specs
+        exit_code = if Pact::RSpec.runner_defined?
+          ::RSpec::Core::Runner.run(rspec_runner_options)
+        else
+          ::RSpec::Core::CommandLine.new(NoConfigurationOptions.new)
+            .run(::RSpec.configuration.output_stream, ::RSpec.configuration.error_stream)
+        end
+
+        if options[:ignore_failures]
+          0
+        else
+          Pact::Provider::RSpec::CalculateExitCode.call(pact_sources, Pact.provider_world.failed_examples)
+        end
+      end
+
+      def rspec_runner_options
+        ["--options", Pact.project_root.join("lib/pact/provider/rspec/custom_options_file").to_s]
+      end
+
+      def monkey_patch_backtrace_formatter
+        Pact::RSpec.with_rspec_3 do
+          require 'pact/provider/rspec/backtrace_formatter'
+        end
+      end
+
+      def pact_sources
+        @pact_sources ||= begin
+          pact_urls.collect do | pact_url |
+            Pact::Provider::PactSource.new(pact_url)
+          end
+        end
+      end
+
+      def pact_jsons
+        pact_sources.collect(&:pact_json)
+      end
+
+      def initialize_specs
+        pact_sources.each do | pact_source |
+          spec_options = {
+            criteria: options[:criteria],
+            ignore_failures: options[:ignore_failures],
+            request_customizer: options[:request_customizer]
+          }
+          Pact::Utils::Metrics.report_metric("Pacts verified", "ProviderTest", "Completed")
+
+          honour_pactfile pact_source, ordered_pact_json(pact_source.pact_json), spec_options
+        end
+      end
+
+      def configure_output
+        Pact::RSpec.with_rspec_3 do
+          ::RSpec.configuration.add_formatter Pact::Provider::RSpec::PactBrokerFormatter, StringIO.new
+        end
+
+        output = options[:out] || Pact.configuration.output_stream
+        if options[:format]
+          formatter = options[:format] == 'json' ? Pact::Provider::RSpec::JsonFormatter : options[:format]
+          # Send formatted output to $stdout for parsing, unless a file is specified
+          output = options[:out] || $stdout
+          ::RSpec.configuration.add_formatter formatter, output
+          # Don't want to mess up the JSON parsing with INFO and DEBUG messages to stdout, so send it to stderr
+          Pact.configuration.output_stream = Pact.configuration.error_stream if !options[:out]
+        else
+          # Sometimes the formatter set in the cli.rb get set with an output of StringIO.. don't know why
+          formatter_class = Pact::RSpec.formatter_class
+          pact_formatter = ::RSpec.configuration.formatters.find {|f| f.class == formatter_class && f.output == ::RSpec.configuration.output_stream}
+          ::RSpec.configuration.add_formatter(formatter_class, output) unless pact_formatter
+        end
+
+        ::RSpec.configuration.full_backtrace = @options[:full_backtrace]
+      end
+
+      def ordered_pact_json(pact_json)
+        return pact_json if Pact.configuration.interactions_replay_order == :recorded
+
+        consumer_contract = JSON.parse(pact_json)
+        consumer_contract["interactions"] = consumer_contract["interactions"].shuffle
+        consumer_contract.to_json
+      end
+
+      def class_exists? name
+        Kernel.const_get name
+      rescue NameError
+        false
+      end
+
+      def executing_with_ruby?
+        ENV['PACT_EXECUTING_LANGUAGE'] == 'ruby'
+      end
+
+      class NoConfigurationOptions
+        def method_missing(method, *args, &block)
+          # Do nothing!
+        end
+      end
+    end
+  end
+end

data/lib/pact/provider/pact_uri.rb

@@ -0,0 +1,55 @@
+module Pact
+  module Provider
+    class PactURI
+      attr_reader :uri, :options, :metadata
+
+      def initialize(uri, options = nil, metadata = nil)
+        @uri = uri
+        @options = options || {}
+        @metadata = metadata || {} # make sure it's not nil if nil is passed in
+      end
+
+      def == other
+        other.is_a?(PactURI) &&
+          uri == other.uri &&
+          options == other.options &&
+          metadata == other.metadata
+      end
+
+      def basic_auth?
+        !!username && !!password
+      end
+
+      def username
+        options[:username]
+      end
+
+      def password
+        options[:password]
+      end
+
+      def to_s
+        if basic_auth? && http_or_https_uri?
+          begin
+            URI(@uri).tap { |x| x.userinfo="#{username}:*****"}.to_s
+          rescue URI::InvalidComponentError
+            URI(@uri).tap { |x| x.userinfo="*****:*****"}.to_s
+          end
+        elsif personal_access_token? && http_or_https_uri?
+          URI(@uri).tap { |x| x.userinfo="*****"}.to_s
+        else
+          uri
+        end
+      end
+
+      private def personal_access_token?
+        !!username && !password
+      end
+
+      private def http_or_https_uri?
+        uri.start_with?('http://', 'https://')
+      end
+
+    end
+  end
+end

data/lib/pact/provider/pact_verification.rb

@@ -0,0 +1,17 @@
+module Pact::Provider
+  class PactVerification
+    attr_reader :consumer_name, :uri, :ref
+    def initialize consumer_name, uri, ref
+      @consumer_name = consumer_name
+      @uri = uri
+      @ref = ref
+    end
+
+    def == other
+      other.is_a?(PactVerification) &&
+        consumer_name == other.consumer_name &&
+        uri == other.uri &&
+        ref == other.ref
+    end
+  end
+end

data/lib/pact/provider/print_missing_provider_states.rb

@@ -0,0 +1,35 @@
+require 'rainbow'
+
+module Pact
+  module Provider
+    class PrintMissingProviderStates
+
+      # Hash of consumer names to array of names of missing provider states
+      def self.call missing_provider_states, output
+        if missing_provider_states.any?
+          output.puts colorize(text(missing_provider_states))
+        end
+      end
+
+      def self.colorize string
+        lines = string.split("\n")
+        first_line = Rainbow(lines[0]).cyan.underline
+        other_lines = Rainbow(lines[1..-1].join("\n")).cyan
+        first_line + "\n" + other_lines
+      end
+
+      def self.text missing_provider_states
+        create_provider_states_for(missing_provider_states)
+      end
+
+      def self.create_provider_states_for consumers
+        ERB.new(template_string).result(binding)
+      end
+
+      def self.template_string
+        File.read(File.expand_path( '../../templates/provider_state.erb', __FILE__))
+      end
+
+    end
+  end
+end

data/lib/pact/provider/request.rb

@@ -0,0 +1,77 @@
+require 'json'
+require 'pact/reification'
+require 'pact/shared/null_expectation'
+require 'pact/generators'
+
+module Pact
+  module Provider
+    module Request
+      class Replayable
+
+        # See https://github.com/rack/rack/blob/e7d741c6282ca4cf4e01506f5681e6e6b14c0b32/SPEC#L87-89
+        NO_HTTP_PREFIX = ["CONTENT-TYPE", "CONTENT-LENGTH"]
+
+        def initialize expected_request, state_params = nil
+          @expected_request = expected_request
+          @state_params = state_params
+        end
+
+        def method
+          expected_request.method
+        end
+
+        def path
+          Pact::Generators.apply_generators(expected_request, "path", expected_request.full_path, @state_params)
+        end
+
+        def body
+          case expected_request.body
+          when String then expected_request.body
+          when NullExpectation then ''
+          else
+            Pact::Generators.apply_generators(expected_request, "body", reified_body, @state_params)
+          end
+        end
+
+        def headers
+          request_headers = {}
+          # https://github.com/pact-foundation/pact-ruby/pull/327
+          request_headers.merge!('HOST' => 'localhost') if defined?(Sinatra)
+          return request_headers if expected_request.headers.is_a?(Pact::NullExpectation)
+
+          expected_request.headers.each do |key, value|
+            request_headers[key] = Pact::Reification.from_term(value)
+          end
+
+          request_headers = Pact::Generators.apply_generators(expected_request, "header", request_headers, @state_params)
+          request_headers.map{ |key,value| [rack_request_header_for(key), value]}.to_h
+        end
+
+        private
+
+        attr_reader :expected_request
+
+        def reified_body
+          rb = Pact::Reification.from_term(expected_request.body)
+          if rb.is_a?(String)
+            rb
+          else
+            JSON.dump(rb)
+          end
+        end
+
+        def rack_request_header_for header
+          with_http_prefix(header.to_s.upcase).tr('-', '_')
+        end
+
+        def rack_request_value_for value
+          Array(value).join("\n")
+        end
+
+        def with_http_prefix header
+          NO_HTTP_PREFIX.include?(header) ? header : "HTTP_#{header}"
+        end
+      end
+    end
+  end
+end