pact-v2 2.0.0.pre.preview1

data/lib/pact/hal/entity.rb

@@ -0,0 +1,110 @@
+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(href, data, http_client, response = nil)
+        @href = href
+        @data = data
+        @links = (@data || {}).fetch("_links", {})
+        @client = http_client
+        @response = response
+      end
+
+      def get(key, *args)
+        _link(key).get(*args)
+      end
+
+      def get!(key, *args)
+        _link(key).get!(*args)
+      end
+
+      def post(key, *args)
+        _link(key).post(*args)
+      end
+
+      def put(key, *args)
+        _link(key).put(*args)
+      end
+
+      def can?(key)
+        @links.key? key.to_s
+      end
+
+      def follow(key, http_method, *args)
+        Link.new(@links[key].merge(method: http_method), @client).run(*args)
+      end
+
+      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
+
+      def response
+        @response
+      end
+
+      def fetch(key, fallback_key = nil)
+        @links[key] || (fallback_key && @links[fallback_key])
+      end
+
+      def method_missing(method_name, *args, &block)
+        if @data.key?(method_name.to_s)
+          @data[method_name.to_s]
+        elsif @links.key?(method_name)
+          Link.new(@links[method_name], @client).run(*args)
+        else
+          super
+        end
+      end
+
+      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(href, data, http_client, response = nil)
+        @href = href
+        @data = data
+        @links = {}
+        @client = http_client
+        @response = response
+      end
+
+      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

@@ -0,0 +1,128 @@
+require 'pact/retry'
+require 'pact/hal/authorization_header_redactor'
+require 'net/http'
+require 'rack'
+require 'openssl'
+
+module Pact
+  module Hal
+    class HttpClient
+      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 = {}
+        uri = URI(href)
+        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
+
+      def put href, body = nil, headers = {}
+        uri = URI(href)
+        perform_request(create_request(uri, 'Put', body, headers), uri)
+      end
+
+      def post href, body = nil, headers = {}
+        uri = URI(href)
+        perform_request(create_request(uri, 'Post', body, headers), uri)
+      end
+
+      def create_request uri, http_method, body = nil, headers = {}
+        request = Net::HTTP.const_get(http_method).new(uri.request_uri)
+        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(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'] != ''
+
+          if x509_certificate?
+            http.cert = OpenSSL::X509::Certificate.new(x509_client_cert_file)
+            http.key = OpenSSL::PKey::RSA.new(x509_client_key_file)
+          end
+
+          if disable_ssl_verification?
+            if verbose?
+              Pact.configuration.output_stream.puts("SSL verification is disabled")
+            end
+            http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          end
+          http.start do |http|
+            http.request request
+          end
+        end
+        Response.new(response)
+      end
+
+      def output_stream
+        AuthorizationHeaderRedactor.new(Pact.configuration.output_stream)
+      end
+
+      def verbose?
+        verbose || ENV['VERBOSE'] == 'true'
+      end
+
+      def x509_certificate?
+        ENV['X509_CLIENT_CERT_FILE'] && ENV['X509_CLIENT_CERT_FILE'] != '' &&
+          ENV['X509_CLIENT_KEY_FILE'] && ENV['X509_CLIENT_KEY_FILE'] != ''
+      end
+
+      def x509_client_cert_file
+        File.read(ENV['X509_CLIENT_CERT_FILE'])
+      end
+
+      def x509_client_key_file
+        File.read(ENV['X509_CLIENT_KEY_FILE'])
+      end
+
+      def disable_ssl_verification?
+        ENV['PACT_DISABLE_SSL_VERIFICATION'] == 'true' || ENV['PACT_BROKER_DISABLE_SSL_VERIFICATION'] == 'true'
+      end
+
+      class Response < SimpleDelegator
+        def body
+          bod = raw_body
+          if bod && bod != ''
+            JSON.parse(bod)
+          else
+            nil
+          end
+        end
+
+        def raw_body
+          __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
+end

data/lib/pact/hal/link.rb

@@ -0,0 +1,112 @@
+require 'erb'
+require 'delegate'
+
+module Pact
+  module Hal
+    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
+        @href = attrs.fetch('href')
+        @http_client = http_client
+      end
+
+      def run(payload = nil)
+        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(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(href, @http_client.put(href, payload ? payload.to_json : nil, DEFAULT_POST_HEADERS.merge(headers)))
+      end
+
+      def post(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)
+      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
+
+      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?
+          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(href, http_response.raw_body, @http_client, http_response)
+        end
+      end
+
+      def expand_url(params, url)
+        params.inject(url) do | url, (key, value) |
+          url.gsub('{' + key.to_s + '}', ERB::Util.url_encode(value))
+        end
+      end
+    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/hash_refinements.rb

@@ -0,0 +1,17 @@
+module Pact
+  module HashRefinements
+    refine Hash do
+      def compact
+        h = {}
+        each do |key, value|
+          h[key] = value unless value == nil
+        end
+        h
+      end unless Hash.method_defined? :compact
+
+      def compact!
+        reject! {|_key, value| value == nil}
+      end unless Hash.method_defined? :compact!
+    end
+  end
+end

data/lib/pact/pact_broker/fetch_pact_uris_for_verification.rb

@@ -0,0 +1,112 @@
+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'
+require "pact/hash_refinements"
+
+module Pact
+  module PactBroker
+    class FetchPactURIsForVerification
+      using Pact::HashRefinements
+
+      include PactSelectionDescription
+      attr_reader :provider, :consumer_version_selectors, :provider_version_branch, :provider_version_tags, :broker_base_url, :http_client_options, :http_client, :options
+
+      PACTS_FOR_VERIFICATION_RELATION = 'pb:provider-pacts-for-verification'.freeze
+      PACTS_FOR_VERIFICATION_RELATION_BETA = '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_branch, provider_version_tags, broker_base_url, http_client_options, options = {})
+        @provider = provider
+        @consumer_version_selectors = consumer_version_selectors || []
+        @provider_version_branch = provider_version_branch
+        @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_branch, provider_version_tags, broker_base_url, http_client_options, options = {})
+        new(provider, consumer_version_selectors, provider_version_branch, provider_version_tags, broker_base_url, http_client_options, options).call
+      end
+
+      def call
+        handling_no_pacts_found do
+          if index.can?(PACTS_FOR_VERIFICATION_RELATION) || index.can?(PACTS_FOR_VERIFICATION_RELATION_BETA)
+            log_message
+            pacts_for_verification
+          else
+            old_selectors = consumer_version_selectors.collect do | selector |
+              { name: selector[:tag], all: !selector[:latest], fallback: selector[:fallbackTag]}
+            end
+            # Fall back to old method of fetching pacts
+            FetchPacts.call(provider, old_selectors, broker_base_url, http_client_options)
+          end
+        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, PACTS_FOR_VERIFICATION_RELATION_BETA)
+          .expand(provider: provider)
+          .post!(query)
+      end
+
+      def query
+        q = {}
+        q["includePendingStatus"] = 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["providerVersionBranch"] = provider_version_branch
+        q["includeWipPactsSince"] = options[:include_wip_pacts_since]
+        q.compact
+      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
+
+      def handling_no_pacts_found
+        pacts_found = yield
+        raise "No pacts found to verify" if pacts_found.empty? && options[:fail_if_no_pacts_found] != false
+        if pacts_found.empty? && options[:fail_if_no_pacts_found] == false
+          Pact.configuration.output_stream.puts "WARN: No pacts found to verify & fail_if_no_pacts_found is set to false."
+        end
+        pacts_found
+      end
+    end
+  end
+end

data/lib/pact/pact_broker/fetch_pacts.rb

@@ -0,0 +1,103 @@
+require 'pact/hal/entity'
+require 'pact/hal/http_client'
+require 'pact/provider/pact_uri'
+require 'pact/errors'
+
+module Pact
+  module PactBroker
+    class FetchPacts
+      attr_reader :provider, :tags, :broker_base_url, :http_client_options, :http_client, :index_entity
+
+      ALL_PROVIDER_TAG_RELATION = 'pb:provider-pacts-with-tag'.freeze
+      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)
+        @provider = provider
+        @tags = (tags || []).collect do |tag|
+          if tag.is_a?(String)
+            { name: tag, all: false, fallback: nil }
+          else
+            tag
+          end
+        end
+        @http_client_options = http_client_options
+        @broker_base_url = broker_base_url
+        @http_client = Pact::Hal::HttpClient.new(http_client_options)
+      end
+
+      def self.call(provider, tags, broker_base_url, http_client_options)
+        new(provider, tags, broker_base_url, http_client_options).call
+      end
+
+      def call
+        log_message
+        if index.success?
+          if any_tags?
+            tagged_pacts_for_provider
+          else
+            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}")
+        end
+      end
+
+      private
+
+      def any_tags?
+        tags && tags.any?
+      end
+
+      def tagged_pacts_for_provider
+        tags.collect do |tag|
+          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 link_for(tag)
+        if !tag[:all]
+          index_entity._link!(LATEST_PROVIDER_TAG_RELATION)
+        else
+          index_entity._link!(ALL_PROVIDER_TAG_RELATION)
+        end
+      end
+
+      def index
+        @index_entity ||= Pact::Hal::Link.new({ "href" => broker_base_url }, http_client).get.assert_success!
+      end
+
+      def latest_pacts_for_provider
+        link = index_entity._link!(LATEST_PROVIDER_RELATION)
+        pact_urls(link.expand(provider: provider).get.assert_success!)
+      end
+
+      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
+
+      def log_message
+        message = "INFO: Fetching pacts for #{provider} from #{broker_base_url}"
+        if tags.any?
+          desc = tags.collect do |tag|
+            all_or_latest = tag[:all] ? "all" : "latest"
+            name = tag[:fallback] ? "#{tag[:name]} (or #{tag[:fallback]} if not found)" : tag[:name]
+            "#{all_or_latest} #{name}"
+          end.join(", ")
+          message << " for tags: #{desc}"
+        end
+        Pact.configuration.output_stream.puts message
+      end
+    end
+  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