pact 1.28.0 → 1.53.0

data/lib/pact/hal/authorization_header_redactor.rb

@@ -0,0 +1,32 @@
+require 'delegate'
+
+module Pact
+  module Hal
+    class AuthorizationHeaderRedactor < SimpleDelegator
+      def puts(*args)
+        __getobj__().puts(*redact_args(args))
+      end
+
+      def print(*args)
+        __getobj__().puts(*redact_args(args))
+      end
+
+      def <<(*args)
+        __getobj__().send(:<<, *redact_args(args))
+      end
+
+      private
+
+      attr_reader :redactions
+
+      def redact_args(args)
+        args.collect{ | s| redact(s) }
+      end
+
+      def redact(string)
+        return string unless string.is_a?(String)
+        string.gsub(/Authorization: .*\\r\\n/, "Authorization: [redacted]\\r\\n")
+      end
+    end
+  end
+end

data/lib/pact/hal/entity.rb

@@ -1,11 +1,18 @@
 require 'uri'
 require 'delegate'
 require 'pact/hal/link'
+require 'pact/errors'
 
 module Pact
   module Hal
+    class RelationNotFoundError < ::Pact::Error; end
+
+    class ErrorResponseReturned < ::Pact::Error; end
+
     class Entity
-      def initialize(data, http_client, response = nil)
+
+      def initialize(href, data, http_client, response = nil)
+        @href = href
         @data = data
         @links = (@data || {}).fetch("_links", {})
         @client = http_client
@@ -32,14 +39,20 @@ module Pact
         Link.new(@links[key].merge(method: http_method), @client).run(*args)
       end
 
-      def _link(key)
+      def _link(key, fallback_key = nil)
         if @links[key]
           Link.new(@links[key], @client)
+        elsif fallback_key && @links[fallback_key]
+          Link.new(@links[fallback_key], @client)
         else
           nil
         end
       end
 
+      def _link!(key)
+        _link(key) or raise RelationNotFoundError.new("Could not find relation '#{key}' in resource at #{@href}")
+      end
+
       def success?
         true
       end
@@ -48,8 +61,8 @@ module Pact
         @response
       end
 
-      def fetch(key)
-        @links[key]
+      def fetch(key, fallback_key = nil)
+        @links[key] || (fallback_key && @links[fallback_key])
       end
 
       def method_missing(method_name, *args, &block)
@@ -65,11 +78,16 @@ module Pact
       def respond_to_missing?(method_name, include_private = false)
         @data.key?(method_name) || @links.key?(method_name)
       end
+
+      def assert_success!
+        self
+      end
     end
 
     class ErrorEntity < Entity
 
-      def initialize(data, http_client, response = nil)
+      def initialize(href, data, http_client, response = nil)
+        @href = href
         @data = data
         @links = {}
         @client = http_client
@@ -79,6 +97,10 @@ module Pact
       def success?
         false
       end
+
+      def assert_success!
+        raise ErrorResponseReturned.new("Error retrieving #{@href} status=#{response ? response.code: nil} #{response ? response.raw_body : ''}")
+      end
     end
   end
 end

data/lib/pact/hal/http_client.rb

@@ -1,20 +1,26 @@
 require 'pact/retry'
+require 'pact/hal/authorization_header_redactor'
+require 'net/http'
+require 'rack'
 
 module Pact
   module Hal
     class HttpClient
-      attr_accessor :username, :password, :verbose
+      attr_accessor :username, :password, :verbose, :token
 
       def initialize options
         @username = options[:username]
         @password = options[:password]
         @verbose = options[:verbose]
+        @token = options[:token]
       end
 
       def get href, params = {}, headers = {}
-        query = params.collect{ |(key, value)| "#{CGI::escape(key)}=#{CGI::escape(value)}" }.join("&")
         uri = URI(href)
-        uri.query = query
+        if params && params.any?
+          existing_params = Rack::Utils.parse_nested_query(uri.query)
+          uri.query = Rack::Utils.build_nested_query(existing_params.merge(params))
+        end
         perform_request(create_request(uri, 'Get', nil, headers), uri)
       end
 
@@ -30,22 +36,22 @@ module Pact
 
       def create_request uri, http_method, body = nil, headers = {}
         request = Net::HTTP.const_get(http_method).new(uri.request_uri)
-        request['Content-Type'] = "application/json" if ['Post', 'Put', 'Patch'].include?(http_method)
-        request['Accept'] = "application/hal+json"
         headers.each do | key, value |
           request[key] = value
         end
-
         request.body = body if body
         request.basic_auth username, password if username
+        request['Authorization'] = "Bearer #{token}" if token
         request
       end
 
       def perform_request request, uri
         response = Retry.until_true do
           http = Net::HTTP.new(uri.host, uri.port, :ENV)
-          http.set_debug_output(Pact.configuration.output_stream) if verbose
+          http.set_debug_output(output_stream) if verbose
           http.use_ssl = (uri.scheme == 'https')
+          http.ca_file = ENV['SSL_CERT_FILE'] if ENV['SSL_CERT_FILE'] && ENV['SSL_CERT_FILE'] != ''
+          http.ca_path = ENV['SSL_CERT_DIR'] if ENV['SSL_CERT_DIR'] && ENV['SSL_CERT_DIR'] != ''
           http.start do |http|
             http.request request
           end
@@ -53,6 +59,10 @@ module Pact
         Response.new(response)
       end
 
+      def output_stream
+        AuthorizationHeaderRedactor.new(Pact.configuration.output_stream)
+      end
+
       class Response < SimpleDelegator
         def body
           bod = raw_body
@@ -67,9 +77,17 @@ module Pact
           __getobj__().body
         end
 
+        def status
+          code.to_i
+        end
+
         def success?
           __getobj__().code.start_with?("2")
         end
+
+        def json?
+          self['content-type'] && self['content-type'] =~ /json/
+        end
       end
     end
   end

data/lib/pact/hal/link.rb

@@ -1,4 +1,4 @@
-require 'uri'
+require 'erb'
 require 'delegate'
 
 module Pact
@@ -6,6 +6,15 @@ module Pact
     class Link
       attr_reader :request_method, :href
 
+      DEFAULT_GET_HEADERS = {
+        "Accept" => "application/hal+json"
+      }.freeze
+
+      DEFAULT_POST_HEADERS = {
+        "Accept" => "application/hal+json",
+        "Content-Type" => "application/json"
+      }.freeze
+
       def initialize(attrs, http_client)
         @attrs = attrs
         @request_method = attrs.fetch(:method, :get).to_sym
@@ -14,51 +23,89 @@ module Pact
       end
 
       def run(payload = nil)
-        response = case request_method
-          when :get
-            get(payload)
-          when :put
-            put(payload)
-          when :post
-            post(payload)
-          end
+        case request_method
+        when :get
+          get(payload)
+        when :put
+          put(payload)
+        when :post
+          post(payload)
+        end
+      end
+
+      def title_or_name
+        title || name
+      end
+
+      def title
+        @attrs['title']
+      end
+
+      def name
+        @attrs['name']
       end
 
       def get(payload = {}, headers = {})
-        wrap_response(@http_client.get(href, payload, headers))
+        wrap_response(href, @http_client.get(href, payload, DEFAULT_GET_HEADERS.merge(headers)))
+      end
+
+      def get!(*args)
+        get(*args).assert_success!
       end
 
       def put(payload = nil, headers = {})
-        wrap_response(@http_client.put(href, payload ? JSON.dump(payload) : nil, headers))
+        wrap_response(href, @http_client.put(href, payload ? payload.to_json : nil, DEFAULT_POST_HEADERS.merge(headers)))
       end
 
       def post(payload = nil, headers = {})
-        wrap_response(@http_client.post(href, payload ? JSON.dump(payload) : nil, headers))
+        wrap_response(href, @http_client.post(href, payload ? payload.to_json : nil, DEFAULT_POST_HEADERS.merge(headers)))
+      end
+
+      def post!(payload = nil, headers = {})
+        post(payload, headers).assert_success!
       end
 
       def expand(params)
         expanded_url = expand_url(params, href)
         new_attrs = @attrs.merge('href' => expanded_url)
-        Link.new(new_attrs, @http_client)
+        Link.new(new_attrs, http_client)
+      end
+
+      def with_query(query)
+        if query && query.any?
+          uri = URI(href)
+          existing_query_params = Rack::Utils.parse_nested_query(uri.query)
+          uri.query = Rack::Utils.build_nested_query(existing_query_params.merge(query))
+          new_attrs = attrs.merge('href' => uri.to_s)
+          Link.new(new_attrs, http_client)
+        else
+          self
+        end
       end
 
       private
 
-      def wrap_response(http_response)
+      attr_reader :attrs, :http_client
+
+      def wrap_response(href, http_response)
         require 'pact/hal/entity' # avoid circular reference
+        require 'pact/hal/non_json_entity'
+
         if http_response.success?
-          Entity.new(http_response.body, @http_client, http_response)
+          if http_response.json?
+            Entity.new(href, http_response.body, @http_client, http_response)
+          else
+            NonJsonEntity.new(href, http_response.raw_body, @http_client, http_response)
+          end
         else
-          ErrorEntity.new(http_response.raw_body, @http_client, http_response)
+          ErrorEntity.new(href, http_response.raw_body, @http_client, http_response)
         end
       end
 
       def expand_url(params, url)
-        new_url = url
-        params.each do | key, value |
-          new_url = new_url.gsub('{' + key.to_s + '}', URI.escape(value))
+        params.inject(url) do | url, (key, value) |
+          url.gsub('{' + key.to_s + '}', ERB::Util.url_encode(value))
         end
-        new_url
       end
     end
   end

data/lib/pact/hal/non_json_entity.rb

@@ -0,0 +1,28 @@
+module Pact
+  module Hal
+    class NonJsonEntity
+      def initialize(href, body, http_client, response = nil)
+        @href = href
+        @body = body
+        @client = http_client
+        @response = response
+      end
+
+      def success?
+        true
+      end
+
+      def response
+        @response
+      end
+
+      def body
+        @body
+      end
+
+      def assert_success!
+        self
+      end
+    end
+  end
+end

data/lib/pact/pact_broker/fetch_pact_uris_for_verification.rb

@@ -0,0 +1,93 @@
+require 'pact/hal/entity'
+require 'pact/hal/http_client'
+require 'pact/provider/pact_uri'
+require 'pact/errors'
+require 'pact/pact_broker/fetch_pacts'
+require 'pact/pact_broker/notices'
+require 'pact/pact_broker/pact_selection_description'
+
+module Pact
+  module PactBroker
+    class FetchPactURIsForVerification
+      include PactSelectionDescription
+      attr_reader :provider, :consumer_version_selectors, :provider_version_tags, :broker_base_url, :http_client_options, :http_client, :options
+
+      PACTS_FOR_VERIFICATION_RELATION = 'beta:provider-pacts-for-verification'.freeze
+      PACTS = 'pacts'.freeze
+      HREF = 'href'.freeze
+      LINKS = '_links'.freeze
+      SELF = 'self'.freeze
+      EMBEDDED = '_embedded'.freeze
+
+      def initialize(provider, consumer_version_selectors, provider_version_tags, broker_base_url, http_client_options, options = {})
+        @provider = provider
+        @consumer_version_selectors = consumer_version_selectors || []
+        @provider_version_tags = [*provider_version_tags]
+        @http_client_options = http_client_options
+        @broker_base_url = broker_base_url
+        @http_client = Pact::Hal::HttpClient.new(http_client_options)
+        @options = options
+      end
+
+      def self.call(provider, consumer_version_selectors, provider_version_tags, broker_base_url, http_client_options, options = {})
+        new(provider, consumer_version_selectors, provider_version_tags, broker_base_url, http_client_options, options).call
+      end
+
+      def call
+        if index.can?(PACTS_FOR_VERIFICATION_RELATION)
+          log_message
+          pacts_for_verification
+        else
+          # Fall back to old method of fetching pacts
+          consumer_version_tags = consumer_version_selectors.collect{ | selector | selector[:tag] }
+          FetchPacts.call(provider, consumer_version_tags, broker_base_url, http_client_options)
+        end
+      end
+
+      private
+
+      def index
+        @index_entity ||= Pact::Hal::Link.new({ "href" => broker_base_url }, http_client).get.assert_success!
+      end
+
+      def pacts_for_verification
+        pacts_for_verification_entity.response.body[EMBEDDED][PACTS].collect do | pact |
+          metadata = {
+            pending: pact["verificationProperties"]["pending"],
+            notices: extract_notices(pact),
+            short_description: pact["shortDescription"]
+          }
+          Pact::Provider::PactURI.new(pact[LINKS][SELF][HREF], http_client_options, metadata)
+        end
+      end
+
+      def pacts_for_verification_entity
+        index
+          ._link(PACTS_FOR_VERIFICATION_RELATION)
+          .expand(provider: provider)
+          .post!(query)
+      end
+
+      def query
+        q = {}
+        q["includePendingStatus"] = true if options[:include_pending_status]
+        q["consumerVersionSelectors"] = consumer_version_selectors if consumer_version_selectors.any?
+        q["providerVersionTags"] = provider_version_tags if provider_version_tags.any?
+        q["includeWipPactsSince"] = options[:include_wip_pacts_since] if options[:include_wip_pacts_since]
+        q
+      end
+
+      def extract_notices(pact)
+        Notices.new((pact["verificationProperties"]["notices"] || []).collect{ |notice| symbolize_keys(notice) })
+      end
+
+      def symbolize_keys(hash)
+        hash.each_with_object({}){ |(k,v), h| h[k.to_sym] = v }
+      end
+
+      def log_message
+        Pact.configuration.output_stream.puts "INFO: #{pact_selection_description(provider, consumer_version_selectors, options, broker_base_url)}"
+      end
+    end
+  end
+end

data/lib/pact/pact_broker/fetch_pacts.rb

@@ -1,6 +1,7 @@
 require 'pact/hal/entity'
 require 'pact/hal/http_client'
 require 'pact/provider/pact_uri'
+require 'pact/errors'
 
 module Pact
   module PactBroker
@@ -11,6 +12,7 @@ module Pact
       LATEST_PROVIDER_TAG_RELATION = 'pb:latest-provider-pacts-with-tag'.freeze
       LATEST_PROVIDER_RELATION = 'pb:latest-provider-pacts'.freeze
       PACTS = 'pacts'.freeze
+      PB_PACTS = 'pb:pacts'.freeze
       HREF = 'href'.freeze
 
       def initialize(provider, tags, broker_base_url, http_client_options)
@@ -33,11 +35,11 @@ module Pact
 
       def call
         log_message
-        if get_index.success?
+        if index.success?
           if any_tags?
-            get_tagged_pacts_for_provider
+            tagged_pacts_for_provider
           else
-            get_latest_pacts_for_provider
+            latest_pacts_for_provider
           end
         else
           raise Pact::Error.new("Error retrieving #{broker_base_url} status=#{index_entity.response.code} #{index_entity.response.raw_body}")
@@ -50,36 +52,36 @@ module Pact
         tags && tags.any?
       end
 
-      def get_tagged_pacts_for_provider
+      def tagged_pacts_for_provider
         tags.collect do |tag|
-          link = get_link(tag)
-          urls = get_pact_urls(link.expand(provider: provider, tag: tag[:name]).get)
-          if urls == [] && tag[:fallback]
-            urls = get_pact_urls(link.expand(provider: provider, tag: tag[:fallback]).get)
+          link = link_for(tag)
+          urls = pact_urls(link.expand(provider: provider, tag: tag[:name]).get)
+          if urls.empty? && tag[:fallback]
+            urls = pact_urls(link.expand(provider: provider, tag: tag[:fallback]).get)
           end
           urls
         end.flatten
       end
 
-      def get_link(tag)
+      def link_for(tag)
         if !tag[:all]
-          index_entity._link(LATEST_PROVIDER_TAG_RELATION)
+          index_entity._link!(LATEST_PROVIDER_TAG_RELATION)
         else
-          index_entity._link(ALL_PROVIDER_TAG_RELATION)
+          index_entity._link!(ALL_PROVIDER_TAG_RELATION)
         end
       end
 
-      def get_index
-        @index_entity = Pact::Hal::Link.new({ "href" => broker_base_url }, http_client).get
+      def index
+        @index_entity ||= Pact::Hal::Link.new({ "href" => broker_base_url }, http_client).get.assert_success!
       end
 
-      def get_latest_pacts_for_provider
-        link = index_entity._link(LATEST_PROVIDER_RELATION)
-        get_pact_urls(link.expand(provider: provider).get)
+      def latest_pacts_for_provider
+        link = index_entity._link!(LATEST_PROVIDER_RELATION)
+        pact_urls(link.expand(provider: provider).get.assert_success!)
       end
 
-      def get_pact_urls(link_by_provider)
-        link_by_provider.fetch(PACTS).collect do |pact|
+      def pact_urls(link_by_provider)
+        link_by_provider.assert_success!.fetch(PB_PACTS, PACTS).collect do |pact|
           Pact::Provider::PactURI.new(pact[HREF], http_client_options)
         end
       end

data/lib/pact/pact_broker/notices.rb

@@ -0,0 +1,34 @@
+module Pact
+  module PactBroker
+    class Notices < Array
+      def before_verification_notices
+        select { | notice | notice[:when].nil? || notice[:when].start_with?('before_verification') }
+      end
+
+      def before_verification_notices_text
+        before_verification_notices.collect{ | notice | notice[:text] }
+      end
+
+      def after_verification_notices(success, published)
+        select { | notice | notice[:when] == "after_verification:success_#{success}_published_#{published}" || notice[:when] == "after_verification" }
+          .collect do | notice |
+            notice.merge(:when => simplify_notice_when(notice[:when]))
+          end
+      end
+
+      def after_verification_notices_text(success, published)
+        after_verification_notices(success, published).collect{ | notice | notice[:text] }
+      end
+
+      def all_notices(success, published)
+        before_verification_notices + after_verification_notices(success, published)
+      end
+
+      private
+
+      def simplify_notice_when(when_key)
+        when_key.split(":").first
+      end
+    end
+  end
+end

data/lib/pact/pact_broker/pact_selection_description.rb

@@ -0,0 +1,24 @@
+module Pact
+  module PactBroker
+    module PactSelectionDescription
+      def pact_selection_description(provider, consumer_version_selectors, options, broker_base_url)
+        latest = consumer_version_selectors.any? ? "" : "latest "
+        message = "Fetching pacts for #{provider} from #{broker_base_url} with the selection criteria: "
+        if consumer_version_selectors.any?
+          desc = consumer_version_selectors.collect do |selector|
+            all_or_latest = !selector[:latest] ? "all for tag" : "latest for tag"
+            # TODO support fallback
+            fallback = selector[:fallback] || selector[:fallbackTag]
+            name = fallback ? "#{selector[:tag]} (or #{fallback} if not found)" : selector[:tag]
+            "#{all_or_latest} #{name}"
+          end.join(", ")
+          if options[:include_wip_pacts_since]
+            desc = "#{desc}, work in progress pacts created after #{options[:include_wip_pacts_since]}"
+          end
+          message << "#{desc}"
+        end
+        message
+      end
+    end
+  end
+end

data/lib/pact/pact_broker.rb

@@ -0,0 +1,25 @@
+require 'pact/pact_broker/fetch_pacts'
+require 'pact/pact_broker/fetch_pact_uris_for_verification'
+require 'pact/provider/pact_uri'
+
+#
+# @public Used by Pact Provider Verifier
+#
+module Pact
+  module PactBroker
+    extend self
+
+    # Keep for backwards compatibility with pact-provider-verifier < 1.23.1
+    def fetch_pact_uris *args
+      Pact::PactBroker::FetchPacts.call(*args).collect(&:uri)
+    end
+
+    def fetch_pact_uris_for_verification *args
+      Pact::PactBroker::FetchPactURIsForVerification.call(*args)
+    end
+
+    def build_pact_uri(*args)
+      Pact::Provider::PactURI.new(*args)
+    end
+  end
+end

data/lib/pact/provider/configuration/dsl.rb

@@ -1,4 +1,5 @@
 require 'pact/provider/configuration/service_provider_dsl'
+require 'pact/provider/configuration/message_provider_dsl'
 
 module Pact
 
@@ -8,6 +9,10 @@ module Pact
       def service_provider name, &block
         Configuration::ServiceProviderDSL.build(name, &block)
       end
+
+      def message_provider name, &block
+        Configuration::MessageProviderDSL.build(name, &block)
+      end
     end
   end
-end
+end