pact 1.67.5 → 2.0.1

data/lib/pact/hal/entity.rb

@@ -1,110 +0,0 @@
-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

@@ -1,146 +0,0 @@
-require 'pact/retry'
-require 'pact/hal/authorization_header_redactor'
-require 'net/http'
-require 'rack'
-require 'openssl'
-
-module Pact
-  module Hal
-    class RetriableHttpStatusError < StandardError
-      RETRIABLE_STATUS_CODES = [502, 503, 504].freeze
-
-      attr_reader :status_code, :response_body
-
-      def initialize status_code, response_body
-        @status_code = status_code
-        @response_body = response_body
-        super("HTTP #{status_code} error: #{response_body}")
-      end
-    end
-
-    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
-          result = http.start do |http|
-            http.request request
-          end
-
-          # Raise error on specific 5xx status codes to trigger retry
-          status_code = result.code.to_i
-          raise RetriableHttpStatusError.new(status_code, result.body) if RetriableHttpStatusError::RETRIABLE_STATUS_CODES.include?(status_code)
-
-          result
-        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

@@ -1,112 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,112 +0,0 @@
-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

@@ -1,103 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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