pact_broker 2.106.0 → 2.107.0

data/lib/pact_broker/api/contracts/verification_contract.rb

@@ -1,41 +1,22 @@
 require "pact_broker/api/contracts/base_contract"
-require "uri"
 
 module PactBroker
   module Api
     module Contracts
       class VerificationContract < BaseContract
+        json do
+          required(:success).filled(:bool)
+          required(:providerApplicationVersion).filled(:string)
+          optional(:buildUrl).maybe(:string)
+        end
 
-        property :success
-        property :provider_version, as: :providerApplicationVersion
-        property :build_url, as: :buildUrl
-
-        validation do
-          configure do
-            config.messages_file = File.expand_path("../../../locale/en.yml", __FILE__)
-
-            def not_blank? value
-              value && value.to_s.strip.size > 0
-            end
-
-            def valid_url? url
-              URI(url)
-            rescue URI::InvalidURIError, ArgumentError
-              nil
-            end
-
-            def valid_version_number?(value)
-              return true if PactBroker.configuration.order_versions_by_date
-
-              parsed_version_number = PactBroker.configuration.version_parser.call(value)
-              !!parsed_version_number
-            end
-          end
+        rule(:providerApplicationVersion).validate(:not_blank_if_present)
 
-          required(:success).filled(:bool?)
-          required(:provider_version) { not_blank? & valid_version_number? }
-          optional(:build_url).maybe(:valid_url?)
+        rule(:providerApplicationVersion) do
+          validate_version_number(value, key) unless rule_error?(:providerApplicationVersion)
         end
+
+        rule(:buildUrl).validate(:valid_url_if_present)
       end
     end
   end

data/lib/pact_broker/api/contracts/webhook_contract.rb

@@ -1,7 +1,6 @@
 require "pact_broker/api/contracts/base_contract"
-require "pact_broker/webhooks/check_host_whitelist"
-require "pact_broker/webhooks/render"
-require "pact_broker/pacticipants/service"
+require "pact_broker/api/contracts/webhook_request_contract"
+require "pact_broker/api/contracts/webhook_pacticipant_contract"
 require "pact_broker/webhooks/webhook_event"
 
 module PactBroker
@@ -9,182 +8,31 @@ module PactBroker
     module Contracts
       class WebhookContract < BaseContract
 
-        def validate(*)
-          result = super
-          # I just cannot seem to get the validation to stop on the first error.
-          # If one rule fails, they all come back failed, and it's driving me nuts.
-          # Why on earth would I want that behaviour?
-          # I cannot believe I have to do this shit.
-          @first_errors = errors
-          @first_errors.messages.keys.each do | key |
-            @first_errors.messages[key] = @first_errors.messages[key][0...1]
-          end
-
-          # rubocop: disable Lint/NestedMethodDefinition
-          def self.errors; @first_errors end
-          # rubocop: enable Lint/NestedMethodDefinition
-
-          result
-        end
-
-        validation do
-          configure do
-            config.messages_file = File.expand_path("../../../locale/en.yml", __FILE__)
-          end
-
-          optional(:consumer)
-          optional(:provider)
-          required(:request).filled
-          optional(:events).maybe(min_size?: 1)
-        end
-
-        property :consumer do
-          property :name
-          property :label
-
-          validation do
-            configure do
-              config.messages_file = File.expand_path("../../../locale/en.yml", __FILE__)
-
-              def pacticipant_exists?(name)
-                !!PactBroker::Pacticipants::Service.find_pacticipant_by_name(name)
-              end
-            end
-
-            optional(:name)
-              .maybe(:pacticipant_exists?)
-              .when(:none?) { value(:label).filled? }
-
-            optional(:label)
-              .maybe(:str?)
-              .when(:none?) { value(:name).filled? }
-
-            rule(label: [:name, :label]) do |name, label|
-              (name.filled? & label.filled?) > label.none?
-            end
-          end
-        end
-
-        property :provider do
-          property :name
-          property :label
-
-          validation do
-            configure do
-              config.messages_file = File.expand_path("../../../locale/en.yml", __FILE__)
-
-              def pacticipant_exists?(name)
-                !!PactBroker::Pacticipants::Service.find_pacticipant_by_name(name)
-              end
-            end
+        UUID_REGEX = /^[A-Za-z0-9_\-]{16,}$/
 
-            optional(:name)
-              .maybe(:pacticipant_exists?)
-              .when(:none?) { value(:label).filled? }
-
-            optional(:label)
-              .maybe(:str?)
-              .when(:none?) { value(:name).filled? }
-
-            rule(label: [:name, :label]) do |name, label|
-              (name.filled? & label.filled?) > label.none?
-            end
+        class EventContract < BaseContract
+          json do
+            required(:name).filled(included_in?: PactBroker::Webhooks::WebhookEvent::EVENT_NAMES)
           end
         end
 
-        property :request do
-          property :url
-          property :http_method
-
-          validation do
-            configure do
-              config.messages_file = File.expand_path("../../../locale/en.yml", __FILE__)
-
-              def self.messages
-                super.merge(
-                  en: {
-                    errors: {
-                      allowed_webhook_method?: http_method_error_message,
-                      allowed_webhook_scheme?: scheme_error_message,
-                      allowed_webhook_host?: host_error_message
-                    }
-                  }
-                )
-              end
-
-              def self.http_method_error_message
-                if PactBroker.configuration.webhook_http_method_whitelist.size == 1
-                  "must be #{PactBroker.configuration.webhook_http_method_whitelist.first}. See /doc/webhooks#whitelist for more information."
-                else
-                  "must be one of #{PactBroker.configuration.webhook_http_method_whitelist.join(", ")}. See /doc/webhooks#whitelist for more information."
-                end
-              end
-
-              def self.scheme_error_message
-                "scheme must be #{PactBroker.configuration.webhook_scheme_whitelist.join(", ")}. See /doc/webhooks#whitelist for more information."
-              end
-
-              def self.host_error_message
-                "host must be in the whitelist #{PactBroker.configuration.webhook_host_whitelist.join(",")}. See /doc/webhooks#whitelist for more information."
-              end
-
-              def valid_method?(http_method)
-                Net::HTTP.const_defined?(http_method.capitalize)
-              rescue StandardError
-                false
-              end
-
-              def valid_url?(url)
-                uri = parse_uri(url)
-                uri.scheme && uri.host
-              rescue URI::InvalidURIError, ArgumentError
-                nil
-              end
-
-              def allowed_webhook_method?(http_method)
-                PactBroker.configuration.webhook_http_method_whitelist.any? do | allowed_method |
-                  http_method.downcase == allowed_method.downcase
-                end
-              end
-
-              def allowed_webhook_scheme?(url)
-                scheme = parse_uri(url).scheme
-                PactBroker.configuration.webhook_scheme_whitelist.any? do | allowed_scheme |
-                  scheme.downcase == allowed_scheme.downcase
-                end
-              end
-
-              def allowed_webhook_host?(url)
-                if host_whitelist.any?
-                  PactBroker::Webhooks::CheckHostWhitelist.call(parse_uri(url).host, host_whitelist).any?
-                else
-                  true
-                end
-              end
-
-              def non_templated_host?(url)
-                parse_uri(url).host == parse_uri(url, "differentplaceholder").host
-              end
-
-              def host_whitelist
-                PactBroker.configuration.webhook_host_whitelist
-              end
-
-              def parse_uri(uri_string, placeholder = "placeholder")
-                URI(PactBroker::Webhooks::Render.render_with_placeholder(uri_string, placeholder))
-              end
-            end
-
-            required(:http_method).filled(:valid_method?, :allowed_webhook_method?)
-            required(:url).filled(:valid_url?, :allowed_webhook_scheme?, :allowed_webhook_host?, :non_templated_host?)
-          end
+        json do
+          optional(:uuid).maybe(:string) # set in resource class from the path info - doesn't come in in the request body
+          optional(:consumer).maybe(:hash)
+          optional(:provider).maybe(:hash)
+          required(:request).filled(:hash)
+          optional(:events).maybe(min_size?: 1)
+          optional(:enabled).filled(:bool)
         end
 
-        collection :events do
-          property :name
+        rule(:consumer).validate(validate_with_contract: WebhookPacticipantContract)
+        rule(:provider).validate(validate_with_contract: WebhookPacticipantContract)
+        rule(:request).validate(validate_with_contract: WebhookRequestContract)
+        rule(:events).validate(validate_each_with_contract: EventContract)
 
-          validation do
-            required(:name).filled(included_in?: PactBroker::Webhooks::WebhookEvent::EVENT_NAMES)
+        rule(:uuid) do
+          if value && !(value =~ UUID_REGEX)
+            key.failure(validation_message("invalid_webhook_uuid"))
           end
         end
       end

data/lib/pact_broker/api/contracts/webhook_pacticipant_contract.rb

@@ -0,0 +1,33 @@
+require "pact_broker/api/contracts/base_contract"
+
+module PactBroker
+  module Api
+    module Contracts
+      class WebhookPacticipantContract < BaseContract
+        json do
+          optional(:name).maybe(:string)
+          optional(:label).maybe(:string)
+        end
+
+        register_macro(:name_or_label_required) do
+          if !provided?(values[:name]) && !provided?(values[:label])
+            key(path.keys).failure(validation_message("blank"))
+          end
+        end
+
+        register_macro(:name_and_label_exclusive) do
+          if provided?(values[:name]) && provided?(values[:label])
+            key([:label]).failure(validation_message("cannot_be_provided_at_same_time", name_1: "name", name_2: "label"))
+          end
+        end
+
+        rule(:name, :label).validate(:name_or_label_required)
+        rule(:name, :label).validate(:name_and_label_exclusive)
+
+        rule(:name) do
+          validate_pacticipant_with_name_exists(value, key) if provided?(value)
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/api/contracts/webhook_request_contract.rb

@@ -0,0 +1,125 @@
+require "pact_broker/api/contracts/base_contract"
+require "pact_broker/webhooks/render"
+require "pact_broker/webhooks/check_host_whitelist"
+require "pact_broker/api/contracts/validation_helpers"
+
+module PactBroker
+  module Api
+    module Contracts
+      class WebhookRequestContract < BaseContract
+        include ValidationHelpers
+
+        json do
+          required(:method).filled(:string)
+          required(:url).filled(:string)
+        end
+
+        rule(:url) do
+          if !valid_webhook_url?(value)
+            key.failure(validation_message("invalid_url"))
+          end
+        end
+
+        rule(:method) do
+          if !valid_http_method?(value)
+            key.failure(validation_message("invalid_http_method"))
+          end
+        end
+
+        rule(:method) do
+          if_still_valid(self) do
+            if !allowed_webhook_method?(value)
+              key.failure(http_method_error_message)
+            end
+          end
+        end
+
+        rule(:url) do
+          if_still_valid(self) do
+            if templated_host?(value)
+              key.failure(validation_message("webhook_templated_host_not_allowed"))
+            end
+          end
+        end
+
+        rule(:url) do
+          if_still_valid(self) do
+            if !allowed_webhook_scheme?(value)
+              key.failure(scheme_error_message)
+            end
+          end
+        end
+
+        rule(:url) do
+          if_still_valid(self) do
+            if !allowed_webhook_host?(value)
+              key.failure(host_error_message)
+            end
+          end
+        end
+
+        def allowed_webhook_method?(http_method)
+          PactBroker.configuration.webhook_http_method_whitelist.any? do | allowed_method |
+            http_method.downcase == allowed_method.downcase
+          end
+        end
+
+        def http_method_error_message
+          if PactBroker.configuration.webhook_http_method_whitelist.size == 1
+            "must be #{PactBroker.configuration.webhook_http_method_whitelist.first}. See /doc/webhooks#whitelist for more information."
+          else
+            "must be one of #{PactBroker.configuration.webhook_http_method_whitelist.join(", ")}. See /doc/webhooks#whitelist for more information."
+          end
+        end
+
+        def allowed_webhook_scheme?(url)
+          scheme = parse_uri(url).scheme
+          PactBroker.configuration.webhook_scheme_whitelist.any? do | allowed_scheme |
+            scheme.downcase == allowed_scheme.downcase
+          end
+        end
+
+        def scheme_error_message
+          "scheme must be #{PactBroker.configuration.webhook_scheme_whitelist.join(", ")}. See /doc/webhooks#whitelist for more information."
+        end
+
+        def parse_uri(uri_string, placeholder = "placeholder")
+          URI(PactBroker::Webhooks::Render.render_with_placeholder(uri_string, placeholder))
+        end
+
+        def allowed_webhook_host?(url)
+          if host_whitelist.any?
+            PactBroker::Webhooks::CheckHostWhitelist.call(parse_uri(url).host, host_whitelist).any?
+          else
+            true
+          end
+        end
+
+        def host_whitelist
+          PactBroker.configuration.webhook_host_whitelist
+        end
+
+        def host_error_message
+          "host must be in the whitelist #{PactBroker.configuration.webhook_host_whitelist.collect(&:inspect).join(", ")}. See /doc/webhooks#whitelist for more information."
+        end
+
+        def valid_webhook_url?(url)
+          uri = parse_uri(url)
+          uri.scheme && uri.host
+        rescue URI::InvalidURIError, ArgumentError
+          nil
+        end
+
+        def templated_host?(url)
+          parse_uri(url).host != parse_uri(url, "differentplaceholder").host
+        end
+
+        def if_still_valid(context)
+          if !context.rule_error?(context.path.keys)
+            yield
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/api/contracts.rb

@@ -0,0 +1,3 @@
+Dir.glob(File.expand_path(File.join(__FILE__, "..", "contracts", "*.rb"))).sort.each do | path |
+  require path
+end

data/lib/pact_broker/api/decorators/custom_error_problem_json_decorator.rb

@@ -17,18 +17,18 @@ module PactBroker
         end
 
         # @return [Hash]
-        def to_hash(decorator_options = {})
+        def to_hash(user_options: {}, **__other)
           {
             "title" => @title,
-            "type" => "#{decorator_options.dig(:user_options, :base_url)}/problem/#{@type}",
+            "type" => "#{user_options[:base_url]}/problem/#{@type}",
             "detail" => @detail,
             "status" => @status
           }
         end
 
         # @return [String] JSON
-        def to_json(decorator_options = {})
-          to_hash(decorator_options).to_json
+        def to_json(*args, **kwargs)
+          to_hash(*args, **kwargs).to_json
         end
       end
     end

data/lib/pact_broker/api/decorators/dashboard_text_decorator.rb

@@ -17,8 +17,8 @@ module PactBroker
           to_hash(options).to_json
         end
 
-        def to_text(options)
-          data = items(index_items, options[:user_options][:base_url])
+        def to_text(user_options:, **_other)
+          data = items(index_items, user_options[:base_url])
           printer = TablePrint::Printer.new(data)
           printer.table_print + "\n"
         end

data/lib/pact_broker/api/decorators/extended_pact_decorator.rb

@@ -32,7 +32,7 @@ module PactBroker
 
         # TODO rather than remove the contract keys that we added in the super class,
         # it would be better to inherit from a shared super class
-        def to_hash(options = {})
+        def to_hash(*)
           keys_to_remove = represented.content_hash.keys
           super.each_with_object({}) do | (key, value), new_hash |
             new_hash[key] = value unless keys_to_remove.include?(key)

data/lib/pact_broker/api/decorators/matrix_decorator.rb

@@ -16,18 +16,18 @@ module PactBroker
           @query_results_with_deployment_status_summary = query_results_with_deployment_status_summary
         end
 
-        def to_json(options)
-          to_hash(options).to_json
+        def to_json(*args, **kwargs)
+          to_hash(*args, **kwargs).to_json
         end
 
-        def to_hash(options)
+        def to_hash(user_options:, **_other)
           {
             summary: {
               deployable: deployable,
               reason: reason
             },
             notices: notices,
-            matrix: matrix(options[:user_options][:base_url])
+            matrix: matrix(user_options[:base_url])
           }.tap do | hash |
             hash[:summary].merge!(query_results_with_deployment_status_summary.deployment_status_summary.counts)
           end

data/lib/pact_broker/api/decorators/matrix_text_decorator.rb

@@ -14,7 +14,7 @@ module PactBroker
           @lines = lines
         end
 
-        def to_text(_options)
+        def to_text(**_options)
           json_decorator = PactBroker::Api::Decorators::MatrixDecorator.new(lines)
           data = lines.collect do | line |
             Line.new(line.consumer_name, line.consumer_version_number, line.pact_revision_number, line.provider_name, line.provider_version_number, line.verification_number, line.success)

data/lib/pact_broker/api/decorators/pact_decorator.rb

@@ -9,7 +9,7 @@ module PactBroker
 
         include Timestamps
 
-        def to_hash(options = {})
+        def to_hash(*)
           parsed_content = represented.content_hash
           if parsed_content.is_a?(::Hash)
             parsed_content.merge super

data/lib/pact_broker/api/decorators/pacticipant_collection_decorator.rb

@@ -37,7 +37,7 @@ module PactBroker
       end
 
       class DeprecatedPacticipantDecorator < PactBroker::Api::Decorators::PacticipantDecorator
-        property :title, getter: ->(_something) { "DEPRECATED - Please use the embedded pacticipants collection" }
+        property :title, getter: ->(_) { "DEPRECATED - Please use the embedded pacticipants collection" }
       end
 
       class NonEmbeddedPacticipantCollectionDecorator < BaseDecorator
@@ -46,7 +46,7 @@ module PactBroker
 
       # TODO deprecate this - breaking change for v 3.0
       class DeprecatedPacticipantCollectionDecorator < PacticipantCollectionDecorator
-        def to_hash(options = {})
+        def to_hash(options)
           embedded_pacticipant_hash = super
           non_embedded_pacticipant_hash = NonEmbeddedPacticipantCollectionDecorator.new(represented).to_hash(options)
           embedded_pacticipant_hash.merge(non_embedded_pacticipant_hash)

data/lib/pact_broker/api/decorators/pacticipant_decorator.rb

@@ -106,7 +106,8 @@ module PactBroker
           }]
         end
 
-        def to_hash options
+        # representable passes through the kwargs from to_json as normal args
+        def to_hash(options)
           h = super
           dasherized = DasherizedVersionDecorator.new(represented).to_hash(options)
           if dasherized["_embedded"]

data/lib/pact_broker/api/decorators/pacts_for_verification_query_decorator.rb

@@ -15,7 +15,10 @@ module PactBroker
         property :provider_version_branch
 
         collection :consumer_version_selectors, default: PactBroker::Pacts::Selectors.new, class: PactBroker::Pacts::Selector do
-          property :main_branch
+          property :main_branch, setter: -> (fragment:, represented:, **) {
+            represented.main_branch = fragment
+            represented.latest = true
+          }
           property :tag
           property :branch, setter: -> (fragment:, represented:, **) {
             represented.branch = fragment

data/lib/pact_broker/api/decorators/pagination_links.rb

@@ -8,13 +8,13 @@ module PactBroker
         include Roar::JSON::HAL
         include Roar::JSON::HAL::Links
 
-        property :page, getter: lambda { |context|
-          if context[:represented].respond_to?(:current_page)
+        property :page, getter: lambda { |represented:, **|
+          if represented.respond_to?(:current_page)
             {
-              number: context[:represented].current_page,
-              size: context[:represented].page_size,
-              totalElements: context[:represented].pagination_record_count,
-              totalPages: context[:represented].page_count,
+              number: represented.current_page,
+              size: represented.page_size,
+              totalElements: represented.pagination_record_count,
+              totalPages: represented.page_count,
             }
           end
         }

data/lib/pact_broker/api/decorators/runtime_error_problem_json_decorator.rb

@@ -11,18 +11,18 @@ module PactBroker
         end
 
         # @return [Hash]
-        def to_hash(decorator_options = {})
+        def to_hash(user_options:, **)
           {
             "title" => "Server error",
-            "type" => "#{decorator_options.dig(:user_options, :base_url)}/problems/server_error",
+            "type" => "#{user_options[:base_url]}/problems/server_error",
             "detail" => message,
             "status" => 500
           }
         end
 
         # @return [String] JSON
-        def to_json(decorator_options = {})
-          to_hash(decorator_options).to_json
+        def to_json(*args, **kwargs)
+          to_hash(*args, **kwargs).to_json
         end
 
         private

data/lib/pact_broker/api/decorators/validation_errors_problem_json_decorator.rb

@@ -15,12 +15,12 @@ module PactBroker
         end
 
         # @return [Hash]
-        def to_hash(decorator_options = {})
+        def to_hash(user_options:, **)
           error_list = []
-          walk_errors(errors, error_list, "", decorator_options.dig(:user_options, :base_url))
+          walk_errors(errors, error_list, "", user_options[:base_url])
           {
             "title" => "Validation errors",
-            "type" => "#{decorator_options.dig(:user_options, :base_url)}/problems/validation-error",
+            "type" => "#{user_options[:base_url]}/problems/validation-error",
             "status" => 400,
             "instance" => "/",
             "errors" => error_list
@@ -28,8 +28,8 @@ module PactBroker
         end
 
         # @return [String] JSON
-        def to_json(decorator_options = {})
-          to_hash(decorator_options).to_json
+        def to_json(*args, **kwargs)
+          to_hash(*args, **kwargs).to_json
         end
 
         private
@@ -57,7 +57,7 @@ module PactBroker
             "detail" => message,
             "status" => 400
           }
-          error["pointer"] = path if path.present?
+          error["pointer"] = path.tr(".", "/") if path.present?
           list << error
         end
       end

data/lib/pact_broker/api/decorators/verifiable_pact_decorator.rb

@@ -9,17 +9,17 @@ module PactBroker
       class VerifiablePactDecorator < BaseDecorator
         include PactBroker::Pacts::Metadata
 
-        property :shortDescription, getter: -> (context) { PactBroker::Pacts::VerifiablePactMessages.new(context[:represented], nil).pact_version_short_description }
+        property :shortDescription, getter: lambda { | represented:, ** | PactBroker::Pacts::VerifiablePactMessages.new(represented, nil).pact_version_short_description }
 
         nested :verificationProperties do
           include PactBroker::Api::PactBrokerUrls
 
           property :pending,
-            if: ->(context) { context[:options][:user_options][:include_pending_status] }
+            if: ->(options:, **_other) { options.dig(:user_options, :include_pending_status) }
           property :wip,
-            if: -> (context) { context[:represented].wip }
+            if: -> (represented:, **_other) { represented.wip }
           property :notices,
-            getter: -> (context) { context[:decorator].notices(context[:options][:user_options]) }
+            getter: -> (decorator:, options:, **) { decorator.notices(options[:user_options]) }
 
           def notices(user_options)
             metadata = represented.wip ? { wip: true } : nil