@pact-foundation/pact-core 13.1.7 → 13.4.0

package/standalone/linux-ia32-1.88.80/pact/lib/vendor/ruby/2.2.0/gems/pact_broker-client-1.58.0/lib/pact_broker/client/deployments/record_release.rb

@@ -0,0 +1,103 @@
+require 'pact_broker/client/base_command'
+
+module PactBroker
+  module Client
+    module Deployments
+      class RecordRelease < PactBroker::Client::BaseCommand
+        def initialize(params, options, pact_broker_client_options)
+          super
+          @pacticipant_name = params.fetch(:pacticipant_name)
+          @version_number = params.fetch(:version_number)
+          @environment_name = params.fetch(:environment_name)
+        end
+
+        private
+
+        attr_reader :pacticipant_name, :version_number, :environment_name
+        attr_reader :deployed_version_resource
+
+        def do_call
+          record_action
+          PactBroker::Client::CommandResult.new(true, result_message)
+        end
+
+        def action
+          "release"
+        end
+
+        def action_relation_name
+          "pb:record-release"
+        end
+
+        def not_supported_message
+          if is_pactflow?
+            "This version of Pactflow does not support recording #{action}s, or you do not have the required permission to read environments. Please upgrade to the latest version if using Pactflow On-Premises, and ensure the user has the environment read permission."
+          else
+            "This version of the Pact Broker does not support recording #{action}s. Please upgrade to version 2.80.0 or later."
+          end
+        end
+
+        def environment_exists?
+          index_resource
+            ._link!("pb:environments")
+            .get!
+            ._links("pb:environments")
+            .find(environment_name)
+        end
+
+        def record_action
+          @deployed_version_resource =
+            get_record_action_relation
+            .post(record_action_request_body)
+            .assert_success!
+        end
+
+        def record_action_links
+          get_pacticipant_version._links(action_relation_name) or raise PactBroker::Client::Error.new(not_supported_message)
+        end
+
+        def get_record_action_relation
+          record_action_links.find(environment_name) or record_action_links.find!(environment_name, environment_relation_not_found_error_message)
+        end
+
+        def environment_relation_not_found_error_message
+          if environment_exists?
+            "Environment '#{environment_name}' is not an available option for recording a deployment of #{pacticipant_name}."
+          else
+            "No environment found with name '#{environment_name}'."
+          end
+        end
+
+        def get_pacticipant_version
+          index_resource
+            ._link!("pb:pacticipant-version")
+            .expand(pacticipant: pacticipant_name, version: version_number)
+            .get
+            .assert_success!(404 => "#{pacticipant_name} version #{version_number} not found")
+        end
+
+        def record_action_request_body
+          {}
+        end
+
+        def result_message
+          if json_output?
+            deployed_version_resource.response.raw_body
+          else
+            green("#{result_text_message} in #{pact_broker_name}.")
+          end
+        end
+
+        def result_text_message
+          "Recorded #{action} of #{pacticipant_name} version #{version_number} to #{environment_name} environment"
+        end
+
+        def check_if_command_supported
+          unless index_resource.can?("pb:environments")
+            raise PactBroker::Client::Error.new(not_supported_message)
+          end
+        end
+      end
+    end
+  end
+end

package/standalone/linux-ia32-1.88.80/pact/lib/vendor/ruby/2.2.0/gems/pact_broker-client-1.58.0/lib/pact_broker/client/deployments/record_undeployment.rb

@@ -0,0 +1,135 @@
+require 'pact_broker/client/base_command'
+
+module PactBroker
+  module Client
+    module Deployments
+      class RecordUndeployment < PactBroker::Client::BaseCommand
+        def initialize(params, options, pact_broker_client_options)
+          super
+          @pacticipant_name = params.fetch(:pacticipant_name)
+          @environment_name = params.fetch(:environment_name)
+          @application_instance = params.fetch(:application_instance)
+        end
+
+        private
+
+        def do_call
+          if undeployed_versions_resources.empty?
+            PactBroker::Client::CommandResult.new(false, error_result_message)
+          else
+            PactBroker::Client::CommandResult.new(undeployed_versions_resources.all?(&:success?), result_message)
+          end
+        end
+
+        attr_reader :pacticipant_name, :environment_name, :application_instance
+
+        def currently_deployed_versions_link
+          environment_resource._link("pb:currently-deployed-deployed-versions", "pb:currently-deployed-versions") or raise PactBroker::Client::Error.new(not_supported_message)
+        end
+
+        def currently_deployed_version_entities_for_pacticipant
+          @deployed_version_links ||= currently_deployed_versions_link.get!(pacticipant: pacticipant_name).embedded_entities!("deployedVersions")
+        end
+
+        def currently_deployed_version_entities_for_pacticipant_and_instance
+          currently_deployed_version_entities_for_pacticipant.select do | entity |
+            if application_instance
+              entity.applicationInstance == application_instance || entity.target == application_instance
+            else
+              entity.applicationInstance == nil && entity.target == nil
+            end
+
+          end
+        end
+
+        def undeployed_versions_resources
+          @undeployed_versions_resources ||= currently_deployed_version_entities_for_pacticipant_and_instance.collect do | entity |
+            entity._link!("self").patch(currentlyDeployed: false)
+          end
+        end
+
+        def action
+          "undeployment"
+        end
+
+        def environment_resource
+          index_resource
+            ._link!("pb:environments")
+            .get!
+            ._links("pb:environments")
+            .find!(environment_name, "No environment found with name '#{environment_name}'")
+            .get!
+        end
+
+        def result_message
+          if json_output?
+            undeployed_versions_resources.collect{ | resource | resource.response.body }.to_a.to_json
+          else
+            undeployed_versions_resources.collect do | undeployed_versions_resource |
+              if undeployed_versions_resource.success?
+                green("#{success_result_text_message(undeployed_versions_resource)} in #{pact_broker_name}.")
+              else
+                red(undeployed_versions_resource.error_message)
+              end
+            end.join("\n")
+          end
+        end
+
+        def success_result_text_message(undeployed_versions_resource)
+          version = undeployed_versions_resource.embedded_entity{ | embedded_entity| embedded_entity && embedded_entity['version'] }
+          message = "Recorded #{action} of #{pacticipant_name}"
+          message = "#{message} version #{version.number}" if (version && version.number)
+          message = "#{message} from #{environment_name} environment"
+          message = "#{message} (application instance #{application_instance})" if application_instance
+          message
+        end
+
+        def error_result_message
+          if json_output?
+            error_message_as_json(error_text)
+          else
+            red(error_text)
+          end
+        end
+
+        def error_text
+          if pacticipant_does_not_exist?
+            "No pacticipant with name '#{pacticipant_name}' found."
+          else
+            if currently_deployed_version_entities_for_pacticipant.any?
+              application_instance_does_not_match_message
+            else
+              "#{pacticipant_name} is not currently deployed to #{environment_name} environment. Cannot record undeployment."
+            end
+          end
+        end
+
+        def application_instance_does_not_match_message
+          potential_application_instances = currently_deployed_version_entities_for_pacticipant.collect{|e| e.applicationInstance || e.target }
+
+          if application_instance
+            omit_text = potential_application_instances.include?(nil) ? "omit the application instance" : nil
+            specify_text = potential_application_instances.compact.any? ? "specify one of the following application instances to record the undeployment from: #{potential_application_instances.compact.join(", ")}" : nil
+            "#{pacticipant_name} is not currently deployed to application instance '#{application_instance}' in #{environment_name} environment. Please #{[omit_text, specify_text].compact.join(" or ")}."
+          else
+            "Please specify one of the following application instances to record the undeployment from: #{potential_application_instances.compact.join(", ")}"
+          end
+        end
+
+        def not_supported_message
+          "This version of the Pact Broker does not support recording undeployments. Please upgrade to version 2.80.0 or later."
+        end
+
+        def pacticipant_does_not_exist?
+          index_resource._link("pb:pacticipant") && index_resource._link("pb:pacticipant").expand(pacticipant: pacticipant_name).get.does_not_exist?
+        end
+
+        def check_if_command_supported
+          unless index_resource.can?("pb:environments")
+            raise PactBroker::Client::Error.new(not_supported_message)
+          end
+        end
+      end
+    end
+  end
+end

package/standalone/linux-ia32-1.88.80/pact/lib/vendor/ruby/2.2.0/gems/pact_broker-client-1.58.0/lib/pact_broker/client/environments/environment_command.rb

@@ -0,0 +1,71 @@
+require 'pact_broker/client/base_command'
+
+module PactBroker
+  module Client
+    module Environments
+      class EnvironmentCommand < PactBroker::Client::BaseCommand
+        NOT_SUPPORTED_MESSAGE = "This version of the Pact Broker does not support environments. Please upgrade to version 2.80.0 or later."
+        PACTFLOW_NOT_SUPPORTED_MESSAGE = "This version of Pactflow does not support environments or you do not have the required permission to read them. Please upgrade to the latest version if using Pactflow On-Premises and ensure the user has the environment read permission."
+
+        private
+
+        def new_environment_body
+          {
+            "name" => params[:name],
+            "displayName" => params[:display_name],
+            "production" => params[:production],
+            "contacts" => contacts
+          }.compact
+        end
+
+        def environments_link
+          index_resource._link!("pb:environments")
+        end
+
+        def existing_environment_link
+          index_resource
+            ._link!("pb:environment")
+            .expand(uuid: params[:uuid])
+        end
+
+        def existing_environment_resource
+          @existing_environment_resource ||= existing_environment_link.get
+        end
+
+        def existing_environment_resource!
+          existing_environment_resource.assert_success!
+        end
+
+        def existing_environment_body
+          @existing_environment_params ||= existing_environment_resource!
+            .response
+            .body
+            .except("uuid", "_links", "_embedded", "createdAt", "updatedAt")
+        end
+
+        def contacts
+          if params[:contact_name] || params[:contact_email_address]
+            contact = {}
+            contact["name"] = params[:contact_name] || "unknown"
+            if params[:contact_email_address]
+              contact["details"] = { "emailAddress" => params[:contact_email_address] }
+            end
+            [contact]
+          else
+            nil
+          end
+        end
+
+        def check_if_command_supported
+          unless index_resource.can?("pb:environments")
+            if is_pactflow?
+              raise PactBroker::Client::Error.new(PACTFLOW_NOT_SUPPORTED_MESSAGE)
+            else
+              raise PactBroker::Client::Error.new(NOT_SUPPORTED_MESSAGE)
+            end
+          end
+        end
+      end
+    end
+  end
+end

package/standalone/linux-ia32-1.88.80/pact/lib/vendor/ruby/2.2.0/gems/pact_broker-client-1.58.0/lib/pact_broker/client/git.rb

@@ -0,0 +1,120 @@
+require 'pact_broker/client/error'
+require 'pact_broker/client/hash_refinements'
+
+=begin
+
+BUILDKITE_BRANCH BUILDKITE_COMMIT https://buildkite.com/docs/pipelines/environment-variables
+CIRCLE_BRANCH CIRCLE_SHA1 https://circleci.com/docs/2.0/env-vars/
+TRAVIS_COMMIT TRAVIS_BRANCH - TRAVIS_PULL_REQUEST_BRANCH TRAVIS_PULL_REQUEST_SHA https://docs.travis-ci.com/user/environment-variables/
+GIT_COMMIT GIT_BRANCH https://wiki.jenkins.io/display/JENKINS/Building+a+software+project
+GIT_COMMIT GIT_LOCAL_BRANCH https://hudson.eclipse.org/webtools/env-vars.html/
+APPVEYOR_REPO_COMMIT APPVEYOR_REPO_BRANCH       https://www.appveyor.com/docs/environment-variables/
+CI_COMMIT_REF_NAME https://docs.gitlab.com/ee/ci/variables/predefined_variables.html
+CI_BRANCH CI_COMMIT_ID https://documentation.codeship.com/pro/builds-and-configuration/environment-variables/
+bamboo.repository.git.branch https://confluence.atlassian.com/bamboo/bamboo-variables-289277087.html
+BITBUCKET_BRANCH BITBUCKET_COMMIT https://confluence.atlassian.com/bitbucket/variables-in-pipelines-794502608.html
+
+=end
+
+# Keep in sync with pact-provider-verifier/lib/pact/provider_verifier/git.rb
+
+# `git name-rev --name-only HEAD` provides "tags/v1.35.0^0"
+module PactBroker
+  module Client
+    module Git
+      using PactBroker::Client::HashRefinements
+
+      COMMAND = 'git rev-parse --abbrev-ref HEAD'.freeze
+      BRANCH_ENV_VAR_NAMES = %w{GITHUB_REF BUILDKITE_BRANCH CIRCLE_BRANCH TRAVIS_BRANCH GIT_BRANCH GIT_LOCAL_BRANCH APPVEYOR_REPO_BRANCH CI_COMMIT_REF_NAME BITBUCKET_BRANCH}.freeze
+      COMMIT_ENV_VAR_NAMES = %w{GITHUB_SHA BUILDKITE_COMMIT CIRCLE_SHA1 TRAVIS_COMMIT GIT_COMMIT APPVEYOR_REPO_COMMIT CI_COMMIT_ID BITBUCKET_COMMIT}
+      BUILD_URL_ENV_VAR_NAMES = %w{BUILDKITE_BUILD_URL CIRCLE_BUILD_URL TRAVIS_BUILD_WEB_URL BUILD_URL }
+
+      def self.commit
+        find_commit_from_env_vars
+      end
+
+      def self.branch(options)
+        find_branch_from_known_env_vars || find_branch_from_env_var_ending_with_branch || branch_from_git_command(options[:raise_error])
+      end
+
+      def self.build_url
+        github_build_url || BUILD_URL_ENV_VAR_NAMES.collect{ | name | value_from_env_var(name) }.compact.first
+      end
+
+      # private
+
+      def self.find_commit_from_env_vars
+        COMMIT_ENV_VAR_NAMES.collect { |env_var_name| value_from_env_var(env_var_name) }.compact.first
+      end
+
+      def self.find_branch_from_known_env_vars
+        val = BRANCH_ENV_VAR_NAMES.collect { |env_var_name| value_from_env_var(env_var_name) }.compact.first
+        val.gsub(%r{^refs/heads/}, "") if val
+      end
+
+      def self.find_branch_from_env_var_ending_with_branch
+        values = ENV.keys
+          .select{ |env_var_name| env_var_name.end_with?("_BRANCH") }
+          .collect{ |env_var_name| value_from_env_var(env_var_name) }.compact
+        if values.size == 1
+          values.first
+        else
+          nil
+        end
+      end
+
+      def self.value_from_env_var(env_var_name)
+        val = ENV[env_var_name]
+        if val && val.strip.size > 0
+          val
+        else
+          nil
+        end
+      end
+
+      def self.branch_from_git_command(raise_error)
+        branch_names = execute_and_parse_command(raise_error)
+        validate_branch_names(branch_names) if raise_error
+        branch_names.size == 1 ? branch_names[0] : nil
+      end
+
+      def self.validate_branch_names(branch_names)
+        if branch_names.size == 0
+          raise PactBroker::Client::Error, "Command `#{COMMAND}` didn't return anything that could be identified as the current branch."
+        end
+
+        if branch_names.size > 1
+          raise PactBroker::Client::Error, "Command `#{COMMAND}` returned multiple branches: #{branch_names.join(", ")}. You will need to get the branch name another way."
+        end
+      end
+
+      def self.execute_git_command
+        `#{COMMAND}`
+      end
+
+      def self.execute_and_parse_command(raise_error)
+        execute_git_command
+          .split("\n")
+          .collect(&:strip)
+          .reject(&:empty?)
+          .collect(&:split)
+          .collect(&:first)
+          .collect{ |line| line.gsub(/^origin\//, '') }
+          .reject{ |line| line == "HEAD" }
+      rescue StandardError => e
+        if raise_error
+          raise PactBroker::Client::Error, "Could not determine current git branch using command `#{COMMAND}`. #{e.class} #{e.message}"
+        else
+          return []
+        end
+      end
+
+      def self.github_build_url
+        parts = %w{GITHUB_SERVER_URL GITHUB_REPOSITORY GITHUB_RUN_ID}.collect{ | name | value_from_env_var(name) }
+        if parts.all?
+          [parts[0], parts[1], "actions", "runs", parts[2]].join("/")
+        end
+      end
+    end
+  end
+end

package/standalone/linux-ia32-1.88.80/pact/lib/vendor/ruby/2.2.0/gems/pact_broker-client-1.58.0/lib/pact_broker/client/hal/entity.rb

@@ -0,0 +1,198 @@
+require 'erb'
+require 'delegate'
+require 'pact_broker/client/error'
+require 'pact_broker/client/hal/link'
+require 'pact_broker/client/hal/links'
+
+module PactBroker
+  module Client
+    module Hal
+      class RelationNotFoundError < ::PactBroker::Client::Error; end
+      class EmbeddedEntityNotFoundError < ::PactBroker::Client::Error; end
+      class ErrorResponseReturned < ::PactBroker::Client::Error
+        attr_reader :entity
+
+        def initialize(message, entity)
+          super(message)
+          @entity = entity
+        end
+      end
+
+      class Entity
+        def initialize(href, data, http_client, response = nil)
+          @href = href
+          @data = data
+          @links = (@data || {}).fetch("_links", {})
+          @client = http_client
+          @response = response
+        end
+
+        def get(key, *args)
+          _link(key).get(*args)
+        end
+
+        def get!(key, *args)
+          get(key, *args).assert_success!
+        end
+
+        def post(key, *args)
+          _link(key).post(*args)
+        end
+
+        def post!(key, *args)
+          post(key, *args).assert_success!
+        end
+
+        def put(key, *args)
+          _link(key).put(*args)
+        end
+
+        def put!(key, *args)
+          put(key, *args).assert_success!
+        end
+
+        def patch(key, *args)
+          _link(key).patch(*args)
+        end
+
+        def patch!(key, *args)
+          patch(key, *args).assert_success!
+        end
+
+        def can?(key)
+          @links.key? key.to_s
+        end
+
+        def follow(key, http_method, *args)
+          Link.new(@links[key].merge(method: http_method), @client).run(*args)
+        end
+
+        def _link(key, fallback_key = nil)
+          if @links[key]
+            Link.new(@links[key], @client)
+          elsif fallback_key && @links[fallback_key]
+            Link.new(@links[fallback_key], @client)
+          else
+            nil
+          end
+        end
+
+        def _links(key)
+          if @links[key] && @links[key].is_a?(Array)
+            link_collection = @links[key].collect do | hash |
+              Link.new(hash, @client)
+            end
+            Links.new(@href, key, link_collection)
+          elsif @links[key].is_a?(Hash)
+            Links.new(@href, key, [Link.new(@links[key], @client)])
+          else
+            nil
+          end
+        end
+
+        def _link!(key)
+          _link(key) or raise RelationNotFoundError.new("Could not find relation '#{key}' in resource at #{@href}")
+        end
+
+        def _links!(key)
+          _links(key) or raise RelationNotFoundError.new("Could not find relation '#{key}' in resource at #{@href}")
+        end
+
+        def embedded_entity
+          embedded_ent = yield @data["_embedded"]
+          if embedded_ent
+            Entity.new(self_href(embedded_ent), embedded_ent, @client, response)
+          end
+        end
+
+        def embedded_entities!(key)
+          embedded_ents = (@data["_embedded"] && @data["_embedded"][key])
+          raise EmbeddedEntityNotFoundError.new("Could not find embedded entity with key '#{key}' in resource at #{@href}") unless embedded_ents
+          embedded_ents.collect do | embedded_ent |
+            Entity.new(self_href(embedded_ent), embedded_ent, @client, response)
+          end
+        end
+
+        def embedded_entities(key = nil)
+          embedded_ents = if key
+            @data["_embedded"][key]
+          else
+            yield @data["_embedded"]
+          end
+          embedded_ents.collect do | embedded_ent |
+            Entity.new(self_href(embedded_ent), embedded_ent, @client, response)
+          end
+        end
+
+        def success?
+          true
+        end
+
+        def does_not_exist?
+          false
+        end
+
+        def response
+          @response
+        end
+
+        def fetch(key, fallback_key = nil)
+          @links[key] || (fallback_key && @links[fallback_key])
+        end
+
+        def method_missing(method_name, *args, &block)
+          if @data.respond_to?(:key?) && @data.key?(method_name.to_s)
+            @data[method_name.to_s]
+          elsif @links.respond_to?(:key?) && @links.key?(method_name)
+            Link.new(@links[method_name], @client).run(*args)
+          else
+            nil
+          end
+        end
+
+        def respond_to_missing?(method_name, include_private = false)
+          @data.key?(method_name) || @links.key?(method_name)
+        end
+
+        def assert_success!(_ignored = nil)
+          self
+        end
+
+        def self_href(entity_hash)
+          entity_hash["_links"] && entity_hash["_links"]["self"] && entity_hash["_links"]["self"]["href"]
+        end
+      end
+
+      class ErrorEntity < Entity
+        def initialize(href, data, http_client, response = nil)
+          @href = href
+          @data = data
+          @links = {}
+          @client = http_client
+          @response = response
+        end
+
+        def does_not_exist?
+          response && response.status == 404
+        end
+
+        def success?
+          false
+        end
+
+        def error_message(messages = {})
+          default_message = "Error making request to #{@href} status=#{response ? response.status: nil} #{response ? response.raw_body : ''}".strip
+          message = if response && messages[response.status]
+            (messages[response.status] || "") + " (#{default_message})"
+          else
+            default_message
+          end
+        end
+
+        def assert_success!(messages = {})
+          raise ErrorResponseReturned.new(error_message(messages), self)
+        end
+      end
+    end
+  end
+end