pact_broker 2.105.0 → 2.107.0.beta.1

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

@@ -0,0 +1,71 @@
+require "pact_broker/api/contracts/validation_helpers"
+
+module PactBroker
+  module Api
+    module Contracts
+      module DryValidationMethods
+        extend self
+
+        def validation_message(key, params = {})
+          PactBroker::Messages.validation_message(key, params)
+        end
+
+        def provided?(value)
+          ValidationHelpers.provided?(value)
+        end
+
+        def not_provided?(value)
+          ValidationHelpers.not_provided?(value)
+        end
+
+        def validate_version_number(value, key)
+          if !PactBroker::Api::Contracts::ValidationHelpers.valid_version_number?(value)
+            key.failure(PactBroker::Messages.validation_message("invalid_version_number", value: value))
+          end
+        end
+
+        def validate_url(value, key)
+          if PactBroker::Api::Contracts::ValidationHelpers.valid_url?(value)
+            key.failure(PactBroker::Messages.validation_message("invalid_url"))
+          end
+        end
+
+        def validate_pacticipant_with_name_exists(value, key)
+          if ValidationHelpers.provided?(value) && !ValidationHelpers.pacticipant_with_name_exists?(value)
+            key.failure(PactBroker::Messages.validation_message("pacticipant_with_name_not_found"))
+          end
+        end
+
+        def validate_environment_with_name_exists(value, key)
+          if ValidationHelpers.provided?(value) && !ValidationHelpers.environment_with_name_exists?(value)
+            key.failure(PactBroker::Messages.validation_message("environment_not_found", value: value))
+          end
+        end
+
+        def validate_not_blank_if_present(value, key)
+          if value && ValidationHelpers.blank?(value)
+            key.failure(PactBroker::Messages.validation_message("blank"))
+          end
+        end
+
+        def validate_no_spaces_if_present(value, key)
+          if value && ValidationHelpers.includes_space?(value)
+            key.failure(PactBroker::Messages.validation_message("no_spaces"))
+          end
+        end
+
+        def validate_not_multiple_lines(value, key)
+          if value && ValidationHelpers.multiple_lines?(value)
+            key.failure(PactBroker::Messages.validation_message("single_line"))
+          end
+        end
+
+        def validate_valid_url(value, key)
+          if value && !ValidationHelpers.valid_url?(value)
+            key.failure(PactBroker::Messages.validation_message("invalid_url"))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,48 +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"
 
 module PactBroker
   module Api
     module Contracts
-      class EnvironmentSchema
-        extend DryValidationWorkarounds
-        extend PactBroker::Messages
-        using PactBroker::HashRefinements
-
-        SCHEMA = Dry::Validation.Schema do
-          configure do
-            predicates(DryValidationPredicates)
-            config.messages_file = File.expand_path("../../../locale/en.yml", __FILE__)
-          end
-          required(:name).filled(:str?, :single_line?, :no_spaces?)
-          optional(:displayName).maybe(:str?, :single_line?)
+      class EnvironmentSchema < BaseContract
+        json do
+          optional(:uuid)
+          required(:name).filled(:string)
+          optional(:displayName).maybe(:string)
           required(:production).filled(included_in?: [true, false])
-          optional(:contacts).each do
-            schema do
-              required(:name).filled(:str?, :single_line?)
-              optional(:details).schema do
-              end
-            end
+          optional(:contacts).array(:hash) do
+            required(:name).filled(:string)
+            optional(:details).hash
           end
         end
 
-        def self.call(params_with_string_keys)
-          params = params_with_string_keys&.symbolize_keys
-          results = select_first_message(flatten_indexed_messages(SCHEMA.call(params).messages(full: true)))
-          validate_name(params, results)
-          results
-        end
+        rule(:name).validate(:not_multiple_lines, :no_spaces_if_present)
+        rule(:displayName).validate(:not_multiple_lines)
 
-        def self.validate_name(params, results)
-          if (environment_with_same_name = PactBroker::Deployments::EnvironmentService.find_by_name(params[:name]))
-            if environment_with_same_name.uuid != params[:uuid]
-              results[:name] ||= []
-              results[:name] << message("errors.validation.environment_name_must_be_unique", name: params[:name])
+        rule(:name, :uuid) do
+          if (environment_with_same_name = PactBroker::Deployments::EnvironmentService.find_by_name(values[:name]))
+            if environment_with_same_name.uuid != values[:uuid]
+              key.failure(validation_message("environment_name_must_be_unique", name: values[:name]))
             end
           end
         end
+
+        rule(:contacts).each do
+          validate_not_multiple_lines(value[:name], key(path.keys + [:name]))
+        end
       end
     end
   end

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

@@ -3,25 +3,12 @@ require "pact_broker/api/contracts/pacticipant_schema"
 module PactBroker
   module Api
     module Contracts
-      class PacticipantCreateSchema
-        extend DryValidationWorkarounds
-        extend PactBroker::Messages
-        using PactBroker::HashRefinements
-
-        SCHEMA = Dry::Validation.Schema do
-          configure do
-            predicates(DryValidationPredicates)
-            config.messages_file = File.expand_path("../../../locale/en.yml", __FILE__)
-          end
-          required(:name).filled(:str?, :single_line?)
+      class PacticipantCreateSchema < PactBroker::Api::Contracts::PacticipantSchema
+        json do
+          required(:name).filled(:string)
         end
 
-        def self.call(params_with_string_keys)
-          params = params_with_string_keys&.symbolize_keys
-          update_errors = PacticipantSchema::SCHEMA.call(params).messages(full: true)
-          create_errors = SCHEMA.call(params).messages(full: true)
-          select_first_message(flatten_indexed_messages(update_errors.merge(create_errors)))
-        end
+        rule(:name).validate(:not_blank_if_present, :not_multiple_lines)
       end
     end
   end

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

@@ -1,33 +1,24 @@
-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"
 
 module PactBroker
   module Api
     module Contracts
-      class PacticipantSchema
-        extend DryValidationWorkarounds
-        extend PactBroker::Messages
-        using PactBroker::HashRefinements
-
-        SCHEMA = Dry::Validation.Schema do
-          configure do
-            predicates(DryValidationPredicates)
-            config.messages_file = File.expand_path("../../../locale/en.yml", __FILE__)
-          end
-          optional(:name).filled(:str?, :single_line?)
-          optional(:displayName).maybe(:str?, :single_line?, :not_blank?)
-          optional(:mainBranch).maybe(:str?, :single_line?, :no_spaces?)
-          optional(:repositoryUrl).maybe(:str?, :single_line?)
-          optional(:repositoryName).maybe(:str?, :single_line?)
-          optional(:repositoryNamespace).maybe(:str?, :single_line?)
+      class PacticipantSchema < BaseContract
+        json do
+          optional(:name).filled(:string)
+          optional(:displayName).maybe(:string)
+          optional(:mainBranch).maybe(:string)
+          optional(:repositoryUrl).maybe(:string)
+          optional(:repositoryName).maybe(:string)
+          optional(:repositoryNamespace).maybe(:string)
         end
 
-        def self.call(params_with_string_keys)
-          params = params_with_string_keys&.symbolize_keys
-          select_first_message(flatten_indexed_messages(SCHEMA.call(params).messages(full: true)))
-        end
+        rule(:name).validate(:not_multiple_lines, :not_blank_if_present)
+        rule(:displayName).validate(:not_multiple_lines, :not_blank_if_present)
+        rule(:mainBranch).validate(:not_multiple_lines, :no_spaces_if_present, :not_blank_if_present)
+        rule(:repositoryUrl).validate(:not_multiple_lines)
+        rule(:repositoryName).validate(:not_multiple_lines)
+        rule(:repositoryNamespace).validate(:not_multiple_lines)
       end
     end
   end

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

@@ -1,161 +1,52 @@
-require "dry-validation"
-require "pact_broker/hash_refinements"
-require "pact_broker/string_refinements"
-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/consumer_version_selector_contract"
+require "pact_broker/logging"
 
 module PactBroker
   module Api
     module Contracts
-      class PactsForVerificationJSONQuerySchema
-        extend DryValidationWorkarounds
-        extend PactBroker::Messages
-
-        using PactBroker::HashRefinements
-        using PactBroker::StringRefinements
-
-        BRANCH_KEYS = [:latest, :tag, :fallbackTag, :branch, :fallbackBranch, :matchingBranch]
-        ENVIRONMENT_KEYS = [:environment, :deployed, :released, :deployedOrReleased]
-        ALL_KEYS = BRANCH_KEYS + ENVIRONMENT_KEYS
-
-        SCHEMA = Dry::Validation.Schema do
-          configure do
-            predicates(DryValidationPredicates)
-            config.messages_file = File.expand_path("../../../locale/en.yml", __FILE__)
-          end
+      class PactsForVerificationJSONQuerySchema < BaseContract
+        json do
+          optional(:providerVersionBranch).maybe(:string)
           optional(:providerVersionTags).maybe(:array?)
-          optional(:consumerVersionSelectors).each do
-            schema do
-              # configure do
-              #   def self.messages
-              #     super.merge(en: { errors: { fallbackTagMustBeForLatest: 'can only be set if latest=true' }})
-              #   end
-              # end
-
-              optional(:mainBranch).filled(included_in?: [true])
-              optional(:tag).filled(:str?)
-              optional(:branch).filled(:str?)
-              optional(:matchingBranch).filled(included_in?: [true])
-              optional(:latest).filled(included_in?: [true, false])
-              optional(:fallbackTag).filled(:str?)
-              optional(:fallbackBranch).filled(:str?)
-              optional(:consumer).filled(:str?, :not_blank?)
-              optional(:deployed).filled(included_in?: [true])
-              optional(:released).filled(included_in?: [true])
-              optional(:deployedOrReleased).filled(included_in?: [true])
-              optional(:environment).filled(:str?, :environment_with_name_exists?)
-
-              # rule(fallbackTagMustBeForLatest: [:fallbackTag, :latest]) do | fallback_tag, latest |
-              #   fallback_tag.filled?.then(latest.eql?(true))
-              # end
-            end
-          end
+          optional(:consumerVersionSelectors).array(:hash)
           optional(:includePendingStatus).filled(included_in?: [true, false])
-          optional(:includeWipPactsSince).filled(:date?)
+          optional(:includeWipPactsSince).filled(:date)
         end
 
-        def self.call(params)
-          symbolized_params = params&.symbolize_keys
-          results = select_first_message(flatten_indexed_messages(SCHEMA.call(symbolized_params).messages(full: true)))
-          add_cross_field_validation_errors(symbolized_params, results)
-          results
-        end
-
-        def self.add_cross_field_validation_errors(params, results)
-          # This is a ducking joke. Need to get rid of dry-validation
-          if params[:consumerVersionSelectors].is_a?(Array)
-            errors = params[:consumerVersionSelectors].each_with_index.flat_map do | selector, index |
-              validate_consumer_version_selector(selector, index, params)
-            end
-            if errors.any?
-              results[:consumerVersionSelectors] ||= []
-              results[:consumerVersionSelectors].concat(errors)
+        # The original implementation of pacts-for-verification unfortunately went out without any validation on the
+        # providerVersionBranch at all (most likely unintentionally.)
+        # When we added
+        #   optional(:providerVersionBranch).filled(:string)
+        # during the dry-validation upgrade, we discovered that some users/pact clients were requesting pacts for verification
+        # with an empty string in the providerVersionBranch
+        # This complicated logic tries to not break those customers as much as possible, while still raising an error
+        # when the blank string is most likely a configuration error
+        # (eg. when the request performs logic that uses the provider version branch)
+        # It allows the providerVersionBranch to be unspecified/nil, as that most likely means the user did not
+        # specify the branch at all.
+        rule(:providerVersionBranch, :providerVersionTags, :includePendingStatus, :includeWipPactsSince) do
+          branch = values[:providerVersionBranch]
+
+          # a space is a clear user error - don't bother checking further
+          if branch && branch.size > 0
+            validate_not_blank_if_present(branch, key)
+          end
+
+          if !rule_error?
+            tags = values[:providerVersionTags]
+            include_pending = values[:includePendingStatus]
+            wip = values[:includeWipPactsSince]
+
+            # There are no tags, the user specified wip or pending, and they set a branch, but the branch is an empty or blank string...
+            if !tags&.any? && (wip || include_pending) && branch && ValidationHelpers.blank?(branch)
+              # most likely a user error - return a message
+              key.failure(validation_message("pacts_for_verification_selector_provider_version_branch_empty"))
             end
           end
-        end
-
-        def self.not_provided?(value)
-          value.nil? || value.blank?
-        end
-
-        # when setting a tag, latest=true and latest=false are both valid
-        # when setting the branch, it doesn't make sense to verify all pacts for a branch,
-        # so latest is not required, but cannot be set to false
-        # rubocop: disable Metrics/CyclomaticComplexity, Metrics/MethodLength
-        def self.validate_consumer_version_selector(selector, index, params)
-          errors = []
-
-          if selector[:fallbackTag] && !selector[:latest]
-            errors << "fallbackTag can only be set if latest is true (at index #{index})"
-          end
-
-          if selector[:fallbackBranch] && selector[:latest] == false
-            errors << "fallbackBranch can only be set if latest is true (at index #{index})"
-          end
-
-          if not_provided?(selector[:mainBranch]) &&
-              not_provided?(selector[:tag]) &&
-              not_provided?(selector[:branch]) &&
-              not_provided?(selector[:environment]) &&
-              selector[:matchingBranch] != true &&
-              selector[:deployed] != true &&
-              selector[:released] != true &&
-              selector[:deployedOrReleased] != true &&
-              selector[:latest] != true
-            errors << "must specify a value for environment or tag or branch, or specify mainBranch=true, matchingBranch=true, latest=true, deployed=true, released=true or deployedOrReleased=true (at index #{index})"
-          end
-
-          if selector[:mainBranch] && selector.slice(*ALL_KEYS - [:consumer, :mainBranch]).any?
-            errors << "cannot specify mainBranch=true with any other criteria apart from consumer (at index #{index})"
-          end
-
-          if selector[:matchingBranch] && selector.slice(*ALL_KEYS - [:consumer, :matchingBranch]).any?
-            errors << "cannot specify matchingBranch=true with any other criteria apart from consumer (at index #{index})"
-          end
-
-          if selector[:tag] && selector[:branch]
-            errors << "cannot specify both a tag and a branch (at index #{index})"
-          end
-
-          if selector[:fallbackBranch] && !selector[:branch]
-            errors << "a branch must be specified when a fallbackBranch is specified (at index #{index})"
-          end
-
-          if selector[:fallbackTag] && !selector[:tag]
-            errors << "a tag must be specified when a fallbackTag is specified (at index #{index})"
-          end
-
-          if selector[:branch] && selector[:latest] == false
-            errors << "cannot specify a branch with latest=false (at index #{index})"
-          end
-
-          if selector[:deployed] && selector[:released]
-            errors << "cannot specify both deployed=true and released=true (at index #{index})"
-          end
-
-          if selector[:deployed] && selector[:deployedOrReleased]
-            errors << "cannot specify both deployed=true and deployedOrReleased=true (at index #{index})"
-          end
-
-          if selector[:released] && selector[:deployedOrReleased]
-            errors << "cannot specify both released=true and deployedOrReleased=true (at index #{index})"
-          end
-
-          if selector[:matchingBranch] && not_provided?(params[:providerVersionBranch])
-            errors << "the providerVersionBranch must be specified when the selector matchingBranch=true is used (at index #{index})"
-          end
-
-          non_environment_fields = selector.slice(*BRANCH_KEYS).keys.sort
-          environment_related_fields = selector.slice(*ENVIRONMENT_KEYS).keys.sort
-
-          if (non_environment_fields.any? && environment_related_fields.any?)
-            errors << "cannot specify the #{pluralize("field", non_environment_fields.count)} #{non_environment_fields.join("/")} with the #{pluralize("field", environment_related_fields.count)} #{environment_related_fields.join("/")} (at index #{index})"
-          end
 
-          errors
         end
-        # rubocop: enable Metrics/CyclomaticComplexity, Metrics/MethodLength
+        rule(:consumerVersionSelectors).validate(validate_each_with_contract: ConsumerVersionSelectorContract)
       end
     end
   end

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

@@ -1,34 +1,21 @@
-require "dry-validation"
-require "pact_broker/api/contracts/dry_validation_workarounds"
-require "pact_broker/api/contracts/dry_validation_predicates"
+require "pact_broker/api/contracts/base_contract"
 
 module PactBroker
   module Api
     module Contracts
-      class PactsForVerificationQueryStringSchema
-        extend DryValidationWorkarounds
-        using PactBroker::HashRefinements
-
-        SCHEMA = Dry::Validation.Schema do
-          configure do
-            predicates(DryValidationPredicates)
-            config.messages_file = File.expand_path("../../../locale/en.yml", __FILE__)
-          end
+      class PactsForVerificationQueryStringSchema < BaseContract
+        params do
           optional(:provider_version_tags).maybe(:array?)
           optional(:consumer_version_selectors).each do
             schema do
-              required(:tag).filled(:str?)
+              required(:tag).filled(:string)
               optional(:latest).filled(included_in?: ["true", "false"])
-              optional(:fallback_tag).filled(:str?)
-              optional(:consumer).filled(:str?, :not_blank?)
+              optional(:fallback_tag).filled(:string)
+              optional(:consumer).filled(:string)
             end
           end
           optional(:include_pending_status).filled(included_in?: ["true", "false"])
-          optional(:include_wip_pacts_since).filled(:date?)
-        end
-
-        def self.call(params)
-          select_first_message(flatten_indexed_messages(SCHEMA.call(params&.symbolize_keys).messages(full: true)))
+          optional(:include_wip_pacts_since).filled(:date)
         end
       end
     end

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

@@ -0,0 +1,62 @@
+require "pact_broker/api/contracts/base_contract"
+require "pact_broker/api/contracts/utf_8_validation"
+
+# The contract for the contract object in the publish contracts request
+module PactBroker
+  module Api
+    module Contracts
+      class PublishContractsContractContract < BaseContract
+        json do
+          required(:consumerName).filled(:string)
+          required(:providerName).filled(:string)
+          required(:content).filled(:string)
+          required(:contentType).filled(included_in?: ["application/json"])
+          required(:specification).filled(included_in?: ["pact"])
+          optional(:onConflict).filled(included_in?:["overwrite", "merge"])
+          optional(:decodedParsedContent) # set in the resource
+          optional(:decodedContent) # set in the resource
+        end
+
+        rule(:consumerName).validate(:not_blank_if_present)
+        rule(:providerName).validate(:not_blank_if_present)
+
+        # validate_consumer_name_in_content
+        rule(:decodedParsedContent, :consumerName, :specification) do
+          consumer_name_in_content = values.dig(:decodedParsedContent, :consumer, :name)
+          if consumer_name_in_content && consumer_name_in_content != values[:consumerName]
+            base.failure(validation_message("consumer_name_in_content_mismatch", { consumer_name_in_content: consumer_name_in_content, consumer_name: values[:consumerName] }))
+          end
+        end
+
+        # validate_provider_name_in_content
+        rule(:decodedParsedContent, :providerName) do
+          provider_name_in_content = values.dig(:decodedParsedContent, :provider, :name)
+          if provider_name_in_content && provider_name_in_content != values[:providerName]
+            base.failure(validation_message("provider_name_in_content_mismatch", { provider_name_in_content: provider_name_in_content, provider_name: values[:providerName] }))
+          end
+        end
+
+        # validate_encoding
+        rule(:decodedContent) do
+          if value.nil?
+            base.failure(validation_message("base64"))
+          end
+
+          if value
+            char_number, fragment = PactBroker::Api::Contracts::UTF8Validation.fragment_before_invalid_utf_8_char(value)
+            if char_number
+              base.failure(validation_message("non_utf_8_char_in_contract", char_number: char_number, fragment: fragment))
+            end
+          end
+        end
+
+        # validate_content_matches_content_type
+        rule(:decodedParsedContent, :contentType) do
+          if values[:decodedParsedContent].nil? && values[:contentType]
+            base.failure(validation_message("invalid_content_for_content_type", { content_type: values[:contentType] }))
+          end
+        end
+      end
+    end
+  end
+end