pact_broker-client 1.14.1 → 1.15.0

data/lib/pact_broker/client/base_client.rb

@@ -48,7 +48,7 @@ module PactBroker
       end
 
       def default_request_headers
-        {'Accept' => 'application/json, application/hal+json'}
+        {'Accept' => 'application/hal+json, application/json'}
       end
 
       def default_get_headers

data/lib/pact_broker/client/cli/broker.rb

@@ -14,6 +14,7 @@ module PactBroker
     module CLI
       # Thor::Error will have its backtrace hidden
       class PactPublicationError < ::Thor::Error; end
+      class WebhookCreationError < ::Thor::Error; end
 
       class Broker < CustomThor
         desc 'can-i-deploy', ''
@@ -99,6 +100,68 @@ module PactBroker
           exit(1) unless result.success
         end
 
+        method_option :request, aliases: "-X", desc: "HTTP method", required: true
+        method_option :header, aliases: "-H", type: :array, desc: "Header"
+        method_option :data, aliases: "-d", desc: "Data"
+        method_option :user, aliases: "-u", desc: "Basic auth username and password eg. username:password"
+        method_option :consumer, desc: "Consumer name"
+        method_option :provider, desc: "Provider name"
+        method_option :broker_base_url, required: true, aliases: "-b", desc: "The base URL of the Pact Broker"
+        method_option :broker_username, aliases: "-u", desc: "Pact Broker basic auth username"
+        method_option :broker_password, aliases: "-p", desc: "Pact Broker basic auth password"
+        method_option :contract_content_changed, type: :boolean, desc: "Trigger this webhook when the pact content changes"
+        method_option :provider_verification_published, type: :boolean, desc: "Trigger this webhook when a provider verification result is published"
+        method_option :verbose, aliases: "-v", type: :boolean, default: false, required: false, desc: "Verbose output. Default: false"
+
+        desc 'create-webhook URL', 'Creates a webhook using the same switches as a curl request.'
+        long_desc File.read(File.join(File.dirname(__FILE__), 'create_webhook_long_desc.txt'))
+        def create_webhook webhook_url
+          require 'pact_broker/client/webhooks/create'
+
+          if !(options.contract_content_changed || options.provider_verification_published)
+            raise PactBroker::Client::Error.new("You must select at least one of --contract-content-changed or --provider-verification-published")
+          end
+
+          username = options.user ? options.user.split(":", 2).first : nil
+          password = options.user ? options.user.split(":", 2).last : nil
+
+          headers = (options.header || []).each_with_object({}) { | header, headers | headers[header.split(":", 2).first.strip] = header.split(":", 2).last.strip }
+
+          body = options.data
+          if body && body.start_with?("@")
+            filepath = body[1..-1]
+            begin
+              body = File.read(filepath)
+            rescue StandardError => e
+              raise PactBroker::Client::Error.new("Couldn't read data from file \"#{filepath}\" due to #{e.class} #{e.message}")
+            end
+          end
+
+          events = []
+          events << 'contract_content_changed' if options.contract_content_changed
+          events << 'provider_verification_published' if options.provider_verification_published
+
+          params = {
+            http_method: options.request,
+            url: webhook_url,
+            headers: headers,
+            username: username,
+            password: password,
+            body: body,
+            consumer: options.consumer,
+            provider: options.provider,
+            events: events
+          }
+
+          begin
+            result = PactBroker::Client::Webhooks::Create.call(params, options.broker_base_url, pact_broker_client_options)
+            $stdout.puts result.message
+            exit(1) unless result.success
+          rescue PactBroker::Client::Error => e
+            raise WebhookCreationError, "#{e.class} - #{e.message}"
+          end
+        end
+
         desc 'version', "Show the pact_broker-client gem version"
         def version
           $stdout.puts PactBroker::Client::VERSION

data/lib/pact_broker/client/cli/can_i_deploy_long_desc.txt

@@ -1,6 +1,6 @@
 Returns exit code 0 or 1, indicating whether or not the specified pacticipant versions are compatible. Prints out the relevant pact/verification details.
 
-The environment variables PACT_BROKER_BASE_URL_BASE_URL, PACT_BROKER_BASE_URL_USERNAME and PACT_BROKER_BASE_URL_PASSWORD may be used instead of their respective command line options.
+The environment variables PACT_BROKER_BASE_URL, PACT_BROKER_BASE_URL_USERNAME and PACT_BROKER_BASE_URL_PASSWORD may be used instead of their respective command line options.
 
 SCENARIOS
 

data/lib/pact_broker/client/cli/create_webhook_long_desc.txt

@@ -0,0 +1 @@
+Create a curl command that executes the request that you want your webhook to execute, then replace "curl" with "pact-broker create-webhook" and add the consumer, provider, event types and broker details. Note that the URL must be the first parameter when executing create-webhook.

data/lib/pact_broker/client/command_result.rb

@@ -0,0 +1,12 @@
+module PactBroker
+  module Client
+    class CommandResult
+      attr_reader :success, :message
+
+      def initialize success, message = nil
+        @success = success
+        @message = message
+      end
+    end
+  end
+end

data/lib/pact_broker/client/hal.rb

@@ -0,0 +1,4 @@
+require 'pact_broker/client/hal/link'
+require 'pact_broker/client/hal/entry_point'
+require 'pact_broker/client/hal/http_client'
+require 'pact_broker/client/hal/entity'

data/lib/pact_broker/client/hal/entity.rb

@@ -0,0 +1,78 @@
+require 'uri'
+require 'delegate'
+require 'pact_broker/client/hal/link'
+
+module PactBroker
+  module Client
+    module Hal
+      class Entity
+        def initialize(data, http_client, response = nil)
+          @data = data
+          @links = (@data || {}).fetch("_links", {})
+          @client = http_client
+          @response = response
+        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)
+          if @links[key]
+            Link.new(@links[key], @client)
+          else
+            nil
+          end
+        end
+
+        def success?
+          true
+        end
+
+        def response
+          @response
+        end
+
+        def fetch(key)
+          @links[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
+      end
+
+      class ErrorEntity < Entity
+        def success?
+          false
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/client/hal/entry_point.rb

@@ -0,0 +1,13 @@
+require 'pact_broker/client/hal/link'
+
+module PactBroker
+  module Client
+    module Hal
+      class EntryPoint < Link
+        def initialize(url, http_client)
+          super({ "href" => url }, http_client)
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/client/hal/http_client.rb

@@ -0,0 +1,82 @@
+require 'pact_broker/client/retry'
+
+module PactBroker
+  module Client
+    module Hal
+      class HttpClient
+        attr_reader :username, :password, :verbose
+
+        def initialize options
+          @username = options[:username]
+          @password = options[:password]
+          @verbose = options[:verbose]
+        end
+
+        def get href, params = {}, headers = {}
+          query = params.collect{ |(key, value)| "#{CGI::escape(key)}=#{CGI::escape(value)}" }.join("&")
+          uri = URI(href)
+          uri.query = query
+          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)
+          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
+        end
+
+        def perform_request request, uri
+          response = Retry.until_true do
+            http = Net::HTTP.new(uri.host, uri.port, :ENV)
+            http.set_debug_output($stderr) if verbose
+            http.use_ssl = (uri.scheme == 'https')
+            http.start do |http|
+              http.request request
+            end
+          end
+          Response.new(response)
+        end
+
+        class Response < SimpleDelegator
+          def body
+            bod = __getobj__().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
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/client/hal/link.rb

@@ -0,0 +1,79 @@
+require 'uri'
+require 'delegate'
+
+module PactBroker
+  module Client
+    module Hal
+      class Link
+        attr_reader :request_method, :href
+
+        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)
+          response = 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))
+        end
+
+        def put(payload = nil, headers = {})
+          wrap_response(@http_client.put(href, payload ? JSON.dump(payload) : nil, headers))
+        end
+
+        def post(payload = nil, headers = {})
+          wrap_response(@http_client.post(href, payload ? JSON.dump(payload) : nil, headers))
+        end
+
+        def expand(params)
+          expanded_url = expand_url(params, href)
+          new_attrs = @attrs.merge('href' => expanded_url)
+          Link.new(new_attrs, @http_client)
+        end
+
+        private
+
+        def wrap_response(http_response)
+          require 'pact_broker/client/hal/entity' # avoid circular reference
+          if http_response.success?
+            Entity.new(http_response.body, @http_client, http_response)
+          else
+            ErrorEntity.new(http_response.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))
+          end
+          new_url
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/client/pacts.rb

@@ -49,7 +49,7 @@ module PactBroker
         url = get_latest_provider_contracts(options)
         response = self.class.get(url, headers: {})
         handle_response(response) do
-          map_latest_provider_pacts_to_hash JSON.parse(response.body)["_links"]["pacts"]
+          map_latest_provider_pacts_to_hash(pact_links(response))
         end
       end
 
@@ -63,6 +63,12 @@ module PactBroker
 
       private
 
+      def pact_links response
+        body = JSON.parse(response.body)
+        # pacts relation is deprecated
+        body["_links"]["pb:pacts"] || body["_links"]["pacts"]
+      end
+
       #TODO Move into mapper class
       def map_pact_list_to_hash pacts_list
         pacts_list.collect do | pact_hash |

data/lib/pact_broker/client/version.rb

@@ -1,5 +1,5 @@
 module PactBroker
   module Client
-    VERSION = '1.14.1'
+    VERSION = '1.15.0'
   end
 end

data/lib/pact_broker/client/versions.rb

@@ -14,7 +14,6 @@ module PactBroker
       end
 
       def latest options
-        puts options
         url = if options[:tag]
           url_for_relation('pb:latest-tagged-version', pacticipant: options.fetch(:pacticipant), tag: options.fetch(:tag))
         else

data/lib/pact_broker/client/webhooks/create.rb

@@ -0,0 +1,114 @@
+require 'uri'
+require 'pact_broker/client/hal'
+require 'ostruct'
+require 'json'
+require 'pact_broker/client/command_result'
+
+module PactBroker
+  module Client
+    module Webhooks
+      class Create
+
+        WEBHOOKS_WITH_OPTIONAL_PACTICICPANTS_NOT_SUPPORTED = "Your version of the Pact Broker requires that both consumer and provider are specified for a webhook. Please upgrade your broker to >= 2.22.0 to create a webhook with optional consumer and provider."
+
+        attr_reader  :params, :pact_broker_base_url, :basic_auth_options, :verbose
+
+        def self.call(params, pact_broker_base_url, pact_broker_client_options)
+          new(params, pact_broker_base_url, pact_broker_client_options).call
+        end
+
+        def initialize(params, pact_broker_base_url, pact_broker_client_options)
+          @params = OpenStruct.new(params)
+          @pact_broker_base_url = pact_broker_base_url
+          @basic_auth_options = pact_broker_client_options[:basic_auth] || {}
+          @verbose = pact_broker_client_options[:verbose]
+          @http_client = PactBroker::Client::Hal::HttpClient.new(basic_auth_options.merge(verbose: verbose))
+        end
+
+        def call
+          if params.consumer && params.provider
+            create_webhook_with_consumer_and_provider
+          else
+            create_webhook_with_optional_consumer_and_provider
+          end
+        end
+
+        private
+
+        attr_reader :http_client
+
+        def create_webhook_with_consumer_and_provider
+          webhook_entity = webhook_link.expand(consumer: params.consumer, provider: params.provider).post(request_body)
+          handle_response(webhook_entity)
+        end
+
+        def create_webhook_with_optional_consumer_and_provider
+          webhook_entity = index_link.get._link("pb:webhooks").post(request_body_with_optional_consumer_and_provider)
+
+          if webhook_entity.response.status == 405
+            raise PactBroker::Client::Error.new(WEBHOOKS_WITH_OPTIONAL_PACTICICPANTS_NOT_SUPPORTED)
+          end
+
+          handle_response(webhook_entity)
+        end
+
+        def request_body
+          webhook_request_body = JSON.parse(params.body) rescue params.body
+          {
+            events: params.events.collect{ | event | { "name" => event }},
+            request: {
+              url: params.url,
+              method: params.http_method,
+              headers: params.headers,
+              body: webhook_request_body,
+              username: params.username,
+              password: params.password
+            }
+          }
+        end
+
+        def request_body_with_optional_consumer_and_provider
+          body = request_body
+
+          if params.consumer
+            body[:consumer] = { name: params.consumer }
+          end
+
+          if params.provider
+            body[:provider] = { name: params.provider }
+          end
+
+          body
+        end
+
+        def webhook_for_consumer_and_provider_url
+          "#{pact_broker_base_url.chomp("/")}/webhooks/provider/{provider}/consumer/{consumer}"
+        end
+
+        def handle_response(webhook_entity)
+          if webhook_entity.success?
+            success_result(webhook_entity)
+          else
+            error_result(webhook_entity)
+          end
+        end
+
+        def success_result(webhook_entity)
+          CommandResult.new(true, "Webhook #{webhook_entity._link('self').title_or_name.inspect} created")
+        end
+
+        def error_result(webhook_entity)
+          CommandResult.new(false, "Error creating webhook. response status=#{webhook_entity.response.status} body=#{webhook_entity.response.raw_body}")
+        end
+
+        def index_link
+          PactBroker::Client::Hal::EntryPoint.new(pact_broker_base_url, http_client)
+        end
+
+        def webhook_link
+          PactBroker::Client::Hal::EntryPoint.new(webhook_for_consumer_and_provider_url, http_client)
+        end
+      end
+    end
+  end
+end