pact_broker 2.105.0 → 2.107.0.beta.1

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

@@ -1,121 +1,34 @@
-require "dry-validation"
-require "pact_broker/api/contracts/dry_validation_workarounds"
-require "pact_broker/api/contracts/dry_validation_predicates"
-require "pact_broker/messages"
+require "pact_broker/api/contracts/base_contract"
+require "pact_broker/api/contracts/publish_contracts_contract_contract"
 
 module PactBroker
   module Api
     module Contracts
-      class PublishContractsSchema
-        extend DryValidationWorkarounds
-        using PactBroker::HashRefinements
-        extend PactBroker::Messages
-
-        SCHEMA = Dry::Validation.Schema do
-          configure do
-            predicates(DryValidationPredicates)
-            config.messages_file = File.expand_path("../../../locale/en.yml", __FILE__)
-          end
-
-          required(:pacticipantName).filled(:str?, :not_blank?)
-          required(:pacticipantVersionNumber).filled(:not_blank?, :single_line?)
-          optional(:tags).each(:not_blank?, :single_line?)
-          optional(:branch).maybe(:not_blank?, :single_line?)
-          optional(:buildUrl).maybe(:single_line?)
-
-          required(:contracts).each do
-            required(:consumerName).filled(:str?, :not_blank?)
-            required(:providerName).filled(:str?, :not_blank?)
-            required(:content).filled(:str?)
-            required(:contentType).filled(included_in?: ["application/json"])
-            required(:specification).filled(included_in?: ["pact"])
-            optional(:onConflict).filled(included_in?:["overwrite", "merge"])
-          end
-        end
-
-        def self.call(params)
-          dry_results = SCHEMA.call(params&.symbolize_keys).messages(full: true)
-          dry_results.then do | results |
-            add_cross_field_validation_errors(params&.symbolize_keys, results)
-          end.then do | results |
-            select_first_message(results)
-          end.then do | results |
-            flatten_indexed_messages(results)
-          end
-        end
-
-        def self.add_cross_field_validation_errors(params, errors)
-          if params[:contracts].is_a?(Array)
-            params[:contracts].each_with_index do | contract, i |
-              if contract.is_a?(Hash)
-                validate_consumer_name(params, contract, i, errors)
-                validate_consumer_name_in_content(params, contract, i, errors)
-                validate_provider_name_in_content(contract, i, errors)
-                validate_encoding(contract, i, errors)
-                validate_content_matches_content_type(contract, i, errors)
-              end
+      class PublishContractsSchema < BaseContract
+        json do
+          required(:pacticipantName).filled(:string)
+          required(:pacticipantVersionNumber).filled(:string)
+          optional(:tags).maybe{ array? & each { filled? } }
+          optional(:branch).maybe(:string)
+          optional(:buildUrl).maybe(:string)
+          required(:contracts).array(:hash)
+        end
+
+        rule(:pacticipantName).validate(:not_blank_if_present)
+        rule(:pacticipantVersionNumber).validate(:not_blank_if_present, :not_multiple_lines)
+        rule(:branch).validate(:not_blank_if_present, :not_multiple_lines)
+        rule(:buildUrl).validate(:not_multiple_lines)
+        rule(:tags).validate(:array_values_not_blank_if_any)
+
+        rule(:contracts).validate(validate_each_with_contract: PublishContractsContractContract)
+
+        # validate_consumer_name_matches_pacticipant_name
+        rule(:contracts, :pacticipantName) do
+          values[:contracts]&.each_with_index do | contract, index |
+            if values[:pacticipantName] && contract[:consumerName] && (contract[:consumerName] != values[:pacticipantName])
+              key([:contracts, index]).failure(validation_message("consumer_name_in_contract_mismatch_pacticipant_name", { consumer_name_in_contract: contract[:consumerName], pacticipant_name: values[:pacticipantName] }))
             end
           end
-          errors
-        end
-
-        def self.validate_consumer_name(params, contract, i, errors)
-          if params[:pacticipantName] && contract[:consumerName] && (contract[:consumerName] != params[:pacticipantName])
-            add_contract_error(:consumerName, validation_message("consumer_name_in_contract_mismatch_pacticipant_name", { consumer_name_in_contract: contract[:consumerName], pacticipant_name: params[:pacticipantName] } ), i, errors)
-          end
-        end
-
-        def self.validate_consumer_name_in_content(params, contract, i, errors)
-          consumer_name_in_content = contract.dig(:decodedParsedContent, :consumer, :name)
-          if consumer_name_in_content && consumer_name_in_content != params[:pacticipantName]
-            add_contract_error(:consumerName, validation_message("consumer_name_in_content_mismatch_pacticipant_name", { consumer_name_in_content: consumer_name_in_content, pacticipant_name: params[:pacticipantName] } ), i, errors)
-          end
-        end
-
-        def self.validate_provider_name_in_content(contract, i, errors)
-          provider_name_in_content = contract.dig(:decodedParsedContent, :provider, :name)
-          if provider_name_in_content && provider_name_in_content != contract[:providerName]
-            add_contract_error(:providerName, validation_message("provider_name_in_content_mismatch", { provider_name_in_content: provider_name_in_content, provider_name: contract[:providerName] } ), i, errors)
-          end
-        end
-
-        def self.validate_encoding(contract, i, errors)
-          if contract[:decodedContent].nil?
-            add_contract_error(:content, message("errors.base64?", scope: nil), i, errors)
-          end
-        end
-
-        def self.validate_content_matches_content_type(contract, i, errors)
-          if contract[:decodedParsedContent].nil? && contract[:contentType]
-            add_contract_error(:content, validation_message("invalid_content_for_content_type", { content_type: contract[:contentType]}), i, errors)
-          end
-        end
-
-
-        def self.add_contract_error(field, message, i, errors)
-          errors[:contracts] ||= {}
-          errors[:contracts][i] ||= {}
-          errors[:contracts][i][field] ||= []
-          errors[:contracts][i][field] << message
-          errors
-        end
-
-        # Need to fix this whole dry-validation eff up
-        def self.select_first_message(results)
-          case results
-          when Hash then results.each_with_object({}) { |(key, value), new_hash| new_hash[key] = select_first_message(value) }
-          when Array then select_first_message_from_array(results)
-          else
-            results
-          end
-        end
-
-        def self.select_first_message_from_array(results)
-          if results.all?{ |value| value.is_a?(String) }
-            results[0...1]
-          else
-            results.collect { |value| select_first_message(value) }
-          end
         end
       end
     end

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

@@ -1,45 +1,40 @@
 require "pact_broker/api/contracts/base_contract"
+require "pact_broker/api/contracts/validation_helpers"
 
 module PactBroker
   module Api
     module Contracts
       class PutPacticipantNameContract < BaseContract
-        property :name
-        property :name_in_pact
-        property :pacticipant
-        property :message_args
+        json do
+          required(:name).maybe(:string)
+          required(:name_in_pact).maybe(:string)
+        end
 
-        validation do
-          configure do
-            config.messages_file = File.expand_path("../../../locale/en.yml", __FILE__)
+        rule(:name, :name_in_pact) do
+          if name_in_pact_does_not_match_name_in_url_path?(values)
+            key.failure(validation_message("pact_name_in_path_mismatch_name_in_pact", name_in_pact: values[:name_in_pact], name_in_path: values[:name]))
           end
+        end
 
-          required(:name).maybe
-          required(:name_in_pact).maybe
-
-          rule(name_in_path_matches_name_in_pact?: [:name, :name_in_pact]) do |name, name_in_pact|
-            name_in_pact.filled?.then(name.eql?(value(:name_in_pact)))
-          end
+        def name_in_pact_does_not_match_name_in_url_path?(values)
+          provided?(values[:name_in_pact]) && values[:name] != values[:name_in_pact]
         end
       end
 
       class PutPactParamsContract < BaseContract
-        property :consumer_version_number
-        property :consumer, form: PutPacticipantNameContract
-        property :provider, form: PutPacticipantNameContract
+        json do
+          required(:consumer).filled(:hash)
+          required(:provider).filled(:hash)
+          required(:consumer_version_number).filled(:string)
+        end
 
-        validation do
-          configure do
-            config.messages_file = File.expand_path("../../../locale/en.yml", __FILE__)
+        rule(:consumer).validate(validate_with_contract: PutPacticipantNameContract)
+        rule(:provider).validate(validate_with_contract: PutPacticipantNameContract)
 
-            def valid_consumer_version_number?(value)
-              return true if PactBroker.configuration.order_versions_by_date
-              parsed_version_number = PactBroker.configuration.version_parser.call(value)
-              !parsed_version_number.nil?
-            end
-          end
+        rule(:consumer_version_number).validate(:not_blank_if_present)
 
-          required(:consumer_version_number).filled(:valid_consumer_version_number?)
+        rule(:consumer_version_number) do
+          validate_version_number(value, key) if !rule_error?(:consumer_version_number)
         end
       end
     end

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

@@ -0,0 +1,19 @@
+module PactBroker
+  module Api
+    module Contracts
+      module UTF8Validation
+        extend self
+
+        def fragment_before_invalid_utf_8_char(string)
+          string.force_encoding("UTF-8").each_char.with_index do | char, index |
+            if !char.valid_encoding?
+              fragment = index < 100 ? string[0...index] : string[index-100...index]
+              return index + 1, fragment
+            end
+          end
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+require "pact_broker/services"
+require "pact_broker/string_refinements"
+require "pact_broker/configuration"
+require "uri"
+
+module PactBroker
+  module Api
+    module Contracts
+      module ValidationHelpers
+        extend self
+        using PactBroker::StringRefinements
+
+        def multiple_lines?(value)
+          value && value.is_a?(String) && value.include?("\n")
+        end
+
+        def includes_space?(value)
+          value && value.is_a?(String) && value.include?(" ")
+        end
+
+        # @return true if there is a value present, and it only contains whitespace
+        def blank?(value)
+          value&.blank?
+        end
+
+        # The tins gem has screwed up the present? method by not using refinements
+        # Return true if the object is not nil, and if a String, is not blank.
+        # @param [Object]
+        def provided?(value)
+          if value.is_a?(String)
+            value.strip.size > 0
+          else
+            !value.nil?
+          end
+        end
+
+        def not_provided?(value)
+          !provided?(value)
+        end
+
+        def valid_url?(url)
+          URI(url)
+        rescue URI::InvalidURIError, ArgumentError
+          false
+        end
+
+        def valid_http_method?(http_method)
+          Net::HTTP.const_defined?(http_method.capitalize)
+        rescue StandardError
+          false
+        end
+
+        def pacticipant_with_name_exists?(value)
+          PactBroker::Services.pacticipant_service.find_pacticipant_by_name(value)
+        end
+
+        def environment_with_name_exists?(value)
+          PactBroker::Services.environment_service.find_by_name(value)
+        end
+
+        def valid_version_number?(value)
+          if PactBroker.configuration.order_versions_by_date
+            true
+          else
+            !!PactBroker.configuration.version_parser.call(value)
+          end
+        end
+      end
+    end
+  end
+end

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,180 +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)
-              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