pact_broker 2.106.0 → 2.107.0

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

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

@@ -1,134 +1,35 @@
-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/utf_8_validation"
+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
-
-        class << self
-          include PactBroker::Api::Contracts::UTF8Validation
-        end
-
-        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
-            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
-
-          if contract[:decodedContent]
-            char_number, fragment = fragment_before_invalid_utf_8_char(contract[:decodedContent])
-            if char_number
-              error_message = message("errors.non_utf_8_char_in_contract", char_number: char_number, fragment: fragment)
-              add_contract_error(:content, error_message, i, errors)
+      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
         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
   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

@@ -2,6 +2,8 @@ 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?

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