pact_broker 2.46.0 → 2.47.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4afa0b6a3444f1fdf6ea852bed8016f63cccd1a5373aa0903be0d206f528bc6
-  data.tar.gz: cd86a0d032bb39ffe2f4318116cc9e51886fc3d3e84bf8c537d6bae5ee0f9d52
+  metadata.gz: c54fb8ff19038af9dd5d0a09105244459a18febe23333bf5203ef77424eb97a3
+  data.tar.gz: f380f9f5e9939d9844e88f09b5807a5e1f094cc368adfa22c104ee8ad55d9f97
 SHA512:
-  metadata.gz: 217a6da9c4b27d6959695eefa1c6b8c13526c827222d114cb6527d20fc9fceec194498ffa84ee6f10e574f96a353429bfdacf18f6b6494826e12aea5d58fc7ba
-  data.tar.gz: 1632aac1111449205a45ca9367093d2e4557e75a163a8c516248486f7a7e884cbf9205302ba8c5e1f4c01c8ff604bbebdaeef6729a1bc03e9dd97ec7f0afa850
+  metadata.gz: ebfc52497d4d877c0adb715bd1bf39c1be9513893ffaf032e142d160b4aa12be04c5b01d0c698f7b94ea6aadca1a416cddd53e3a0f304bb9c2821d128cf894a2
+  data.tar.gz: 41184e2249f9bde504a6f9258bf44ff2f33a8374d6a2d05ebe59536c8113461c79f41319a9b337f1db58c83e31ff652951ffca7466988626150dab7e09002abb

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+<a name="v2.47.0"></a>
+### v2.47.0 (2020-01-31)
+
+
+#### Features
+
+* include the webhook context in the execution logs	 ([29f65bef](/../../commit/29f65bef))
+
+
 <a name="v2.46.0"></a>
 ### v2.46.0 (2020-01-30)
 

data/Dockerfile

@@ -12,6 +12,7 @@ RUN apk update \
       "sqlite>=3.28" \
       "tzdata>=2019" \
       "mariadb-dev>=10.3" \
+      "git" \
     && rm -rf /var/cache/apk/*
 
 WORKDIR /app

data/lib/pact_broker/api/resources/provider_pacts_for_verification.rb

@@ -40,7 +40,10 @@ module PactBroker
             provider_name,
             parsed_query_params.provider_version_tags,
             parsed_query_params.consumer_version_selectors,
-            { include_wip_pacts_since: parsed_query_params.include_wip_pacts_since }
+            {
+              include_wip_pacts_since: parsed_query_params.include_wip_pacts_since,
+              include_pending_status: parsed_query_params.include_pending_status
+            }
           )
         end
 

data/lib/pact_broker/api/resources/verification.rb

@@ -33,11 +33,11 @@ module PactBroker
         end
 
         def to_json
-          decorator_for(verification).to_json(user_options: {base_url: base_url})
+          decorator_for(verification).to_json(user_options: { base_url: base_url })
         end
 
         def to_extended_json
-          extended_decorator_for(verification).to_json(user_options: {base_url: base_url})
+          extended_decorator_for(verification).to_json(user_options: { base_url: base_url })
         end
 
         private

data/lib/pact_broker/api/resources/verifications.rb

@@ -49,7 +49,7 @@ module PactBroker
 
         def from_json
           verification = verification_service.create(next_verification_number, params_with_string_keys, pact, webhook_options)
-          response.body = decorator_for(verification).to_json(user_options: {base_url: base_url})
+          response.body = decorator_for(verification).to_json(user_options: { base_url: base_url })
           true
         end
 

data/lib/pact_broker/domain/webhook.rb

@@ -53,14 +53,14 @@ module PactBroker
       end
 
       def execute pact, verification, options
-        logger.info "Executing #{self}"
+        logger.info "Executing #{self} webhook_context=#{options.fetch(:webhook_context)}"
         webhook_request = request.build(template_parameters(pact, verification, options))
         http_response, error = execute_request(webhook_request)
 
         PactBroker::Webhooks::WebhookExecutionResult.new(
           webhook_request.http_request,
           http_response,
-          generate_logs(webhook_request, http_response, error, options.fetch(:logging_options)),
+          generate_logs(webhook_request, http_response, error, options[:webhook_context], options.fetch(:logging_options)),
           error
         )
       end
@@ -110,13 +110,14 @@ module PactBroker
         PactBroker::Webhooks::PactAndVerificationParameters.new(pact, verification, options.fetch(:webhook_context)).to_hash
       end
 
-      def generate_logs(webhook_request, http_response, error, logging_options)
+      def generate_logs(webhook_request, http_response, error, webhook_context, logging_options)
         webhook_request_logger = PactBroker::Webhooks::WebhookRequestLogger.new(logging_options)
         webhook_request_logger.log(
           uuid,
           webhook_request,
           http_response,
-          error
+          error,
+          webhook_context
         )
       end
     end

data/lib/pact_broker/pacts/repository.rb

@@ -14,6 +14,8 @@ require 'pact_broker/matrix/head_row'
 require 'pact_broker/pacts/latest_pact_publication_id_for_consumer_version'
 require 'pact_broker/pacts/verifiable_pact'
 require 'pact_broker/repositories/helpers'
+require 'pact_broker/pacts/selected_pact'
+require 'pact_broker/pacts/selector'
 
 module PactBroker
   module Pacts
@@ -127,12 +129,13 @@ module PactBroker
         end
       end
 
-      def find_all_pact_versions_for_provider_with_tags provider_name, consumer_version_tag_names
+      def find_all_pact_versions_for_provider_with_consumer_version_tags provider_name, consumer_version_tag_names
         provider = pacticipant_repository.find_by_name(provider_name)
 
         PactPublication
           .select_all_qualified
           .select_append(Sequel[:cv][:order].as(:consumer_version_order))
+          .select_append(Sequel[:ct][:name].as(:consumer_version_tag_name))
           .remove_overridden_revisions
           .join_consumer_versions(:cv)
           .join_consumer_version_tags_with_names(consumer_version_tag_names)
@@ -144,8 +147,12 @@ module PactBroker
           .all
           .group_by(&:pact_version_id)
           .values
-          .collect{ | pacts| pacts.sort_by{|pact| pact.values.fetch(:consumer_version_order) }.last }
-          .collect(&:to_domain)
+          .collect do | pact_publications |
+            selector_tag_names = pact_publications.collect{ | p| p.values.fetch(:consumer_version_tag_name) }
+            latest_pact_publication = pact_publications.sort_by{ |p| p.values.fetch(:consumer_version_order) }.last
+            selectors = selector_tag_names.collect{ | tag_name | Selector.one_of_tag(tag_name) }
+            SelectedPact.new(latest_pact_publication.to_domain, selectors)
+          end
       end
 
       # To find the work in progress pacts for this verification execution:
@@ -339,29 +346,67 @@ module PactBroker
 
       # Returns a list of Domain::Pact objects the represent pact publications
       def find_for_verification(provider_name, consumer_version_selectors)
-        find_pacts_for_which_the_latest_version_or_latest_version_for_the_tag_is_required(provider_name, consumer_version_selectors) +
+        selected_pacts = find_pacts_for_which_the_latest_version_is_required(provider_name, consumer_version_selectors) +
+        find_pacts_for_which_the_latest_version_for_the_tag_is_required(provider_name, consumer_version_selectors) +
         find_pacts_for_which_all_versions_for_the_tag_are_required(provider_name, consumer_version_selectors)
+        selected_pacts
+          .group_by(&:pact_version_sha)
+          .values
+          .collect do | selected_pacts_for_pact_version_id |
+            SelectedPact.merge(selected_pacts_for_pact_version_id)
+          end
       end
 
       private
 
-      def find_pacts_for_which_the_latest_version_or_latest_version_for_the_tag_is_required(provider_name, consumer_version_selectors)
+      def find_pacts_for_which_the_latest_version_is_required(provider_name, consumer_version_selectors)
+        if consumer_version_selectors.empty?
+          LatestPactPublications
+            .provider(provider_name)
+            .order_ignore_case(:consumer_name)
+            .collect do | latest_pact_publication |
+              pact_publication = PactPublication.find(id: latest_pact_publication.id)
+              SelectedPact.new(pact_publication.to_domain, [Selector.overall_latest])
+            end
+        else
+          []
+        end
+      end
+
+      def find_pacts_for_which_the_latest_version_for_the_tag_is_required(provider_name, consumer_version_selectors)
         # The tags for which only the latest version is specified
-        latest_tags = consumer_version_selectors.any? ?
-          consumer_version_selectors.select(&:latest).collect(&:tag) :
-          nil
+        latest_tags = consumer_version_selectors.select(&:latest).collect(&:tag).compact.uniq
 
-        find_latest_pact_versions_for_provider(provider_name, latest_tags)
+        # TODO make this an efficient query!
+        # These are not yet de-duped. Should make the behaviour consistent between this and find_pacts_for_which_all_versions_for_the_tag_are_required ?
+        if latest_tags.any?
+          LatestTaggedPactPublications
+            .provider(provider_name)
+            .order_ignore_case(:consumer_name)
+            .where(tag_name: latest_tags)
+            .all
+            .group_by(&:pact_version_id)
+            .values
+            .collect do | pact_publications |
+              selector_tag_names = pact_publications.collect(&:tag_name)
+              last_pact_publication = pact_publications.sort_by(&:consumer_version_order).last
+              pact_publication = PactPublication.find(id: last_pact_publication.id)
+              SelectedPact.new(
+                pact_publication.to_domain,
+                selector_tag_names.collect{ | tag_name| Selector.latest_for_tag(tag_name) }
+              )
+            end
+        else
+          []
+        end
       end
 
       def find_pacts_for_which_all_versions_for_the_tag_are_required(provider_name, consumer_version_selectors)
         # The tags for which all versions are specified
-        all_tags = consumer_version_selectors.any? ?
-          consumer_version_selectors.reject(&:latest).collect(&:tag) :
-          nil
+        all_tags = consumer_version_selectors.reject(&:latest).collect(&:tag)
 
-        if all_tags
-          find_all_pact_versions_for_provider_with_tags(provider_name, all_tags)
+        if all_tags.any?
+          find_all_pact_versions_for_provider_with_consumer_version_tags(provider_name, all_tags)
         else
           []
         end

data/lib/pact_broker/pacts/selected_pact.rb

@@ -0,0 +1,46 @@
+require 'delegate'
+
+module PactBroker
+  module Pacts
+    class SelectedPact < SimpleDelegator
+      attr_reader :pact, :selectors
+
+      def initialize(pact, selectors)
+        super(pact)
+        @pact = pact
+        @selectors = selectors
+      end
+
+      # might actually be, but this code doesn't know it.
+      def overall_latest?
+        selectors.any?(&:overall_latest?)
+      end
+
+      def latest_for_tag?
+        selectors.any?(&:latest_for_tag?)
+      end
+
+      def self.merge(selected_pacts)
+        latest_selected_pact = selected_pacts.sort_by(&:consumer_version_order).last
+        selectors = selected_pacts.collect(&:selectors).flatten.uniq
+        SelectedPact.new(latest_selected_pact.pact, selectors)
+      end
+
+      def merge(other)
+        if pact_version_sha != other.pact_version_sha
+          raise "These two pacts do not have the same pact_version_sha. They cannot be merged. #{pact_version_sha} and #{other.pact_version_sha}"
+        else
+          SelectedPact.new()
+        end
+      end
+
+      def tag_names_for_selectors_for_latest_pacts
+        selectors.select(&:latest_for_tag?).collect(&:tag)
+      end
+
+      def consumer_version_order
+        pact.consumer_version.order
+      end
+    end
+  end
+end

data/lib/pact_broker/pacts/selector.rb

@@ -0,0 +1,43 @@
+module PactBroker
+  module Pacts
+    class Selector < Hash
+      def initialize(options)
+        merge!(options)
+      end
+
+      def self.overall_latest
+        Selector.new(latest: true)
+      end
+
+      def self.latest_for_tag(tag)
+        Selector.new(latest: true, tag: tag)
+      end
+
+      def self.one_of_tag(tag)
+        Selector.new(tag: tag)
+      end
+
+      def tag
+        self[:tag]
+      end
+
+      def overall_latest?
+        !!(latest && !tag)
+      end
+
+      def latest_for_tag?
+        !!(latest && tag)
+      end
+
+      private
+
+      def latest?
+        self[:latest]
+      end
+
+      def latest
+        self[:latest]
+      end
+    end
+  end
+end

data/lib/pact_broker/pacts/service.rb

@@ -118,10 +118,8 @@ module PactBroker
       def find_for_verification(provider_name, provider_version_tags, consumer_version_selectors, options)
         verifiable_pacts_specified_in_request = pact_repository
           .find_for_verification(provider_name, consumer_version_selectors)
-          .group_by(&:pact_version_sha)
-          .values
-          .collect do | head_pacts |
-            squash_pacts_for_verification(provider_version_tags, head_pacts)
+          .collect do | selected_pact |
+            squash_pacts_for_verification(provider_version_tags, selected_pact, options[:include_pending_status])
           end
 
         verifiable_wip_pacts = if options[:include_wip_pacts_since]

data/lib/pact_broker/pacts/squash_pacts_for_verification.rb

@@ -5,28 +5,38 @@
 module PactBroker
   module Pacts
     module SquashPactsForVerification
-      def self.call(provider_version_tags, head_pacts)
-        domain_pact = head_pacts.first.pact
-        pending_provider_tags = []
-        pending = nil
-        if provider_version_tags.any?
-          pending_provider_tags = domain_pact.select_pending_provider_version_tags(provider_version_tags)
-          pending = pending_provider_tags.any?
+      def self.call(provider_version_tags, selected_pact, include_pending_status = false)
+        domain_pact = selected_pact.pact
+
+        if include_pending_status
+          pending_provider_tags = []
+          non_pending_provider_tags = []
+          pending = nil
+          if provider_version_tags.any?
+            pending_provider_tags = domain_pact.select_pending_provider_version_tags(provider_version_tags)
+            pending = pending_provider_tags.any?
+          else
+            pending = domain_pact.pending?
+          end
+          non_pending_provider_tags = provider_version_tags - pending_provider_tags
+          VerifiablePact.new(
+            domain_pact,
+            pending,
+            pending_provider_tags,
+            non_pending_provider_tags,
+            selected_pact.tag_names_for_selectors_for_latest_pacts,
+            selected_pact.overall_latest?
+          )
         else
-          pending = domain_pact.pending?
+          VerifiablePact.new(
+            domain_pact,
+            nil,
+            [],
+            [],
+            selected_pact.tag_names_for_selectors_for_latest_pacts,
+            selected_pact.overall_latest?
+          )
         end
-
-        non_pending_provider_tags = provider_version_tags - pending_provider_tags
-
-        head_consumer_tags = head_pacts.collect(&:tag)
-        overall_latest = head_consumer_tags.include?(nil)
-        VerifiablePact.new(domain_pact,
-          pending,
-          pending_provider_tags,
-          non_pending_provider_tags,
-          head_consumer_tags.compact,
-          overall_latest
-        )
       end
 
       def squash_pacts_for_verification(*args)

data/lib/pact_broker/pacts/verifiable_pact_messages.rb

@@ -6,13 +6,23 @@ module PactBroker
       READ_MORE_PENDING = "Read more at https://pact.io/pending"
       READ_MORE_WIP = "Read more at https://pact.io/wip"
 
-      delegate [:consumer_name, :provider_name, :head_consumer_tags, :pending_provider_tags, :non_pending_provider_tags, :pending?, :wip?] => :verifiable_pact
+      delegate [:consumer_name, :provider_name, :consumer_version_number, :head_consumer_tags, :pending_provider_tags, :non_pending_provider_tags, :pending?, :wip?] => :verifiable_pact
 
       def initialize(verifiable_pact, pact_version_url)
         @verifiable_pact = verifiable_pact
         @pact_version_url = pact_version_url
       end
 
+      def pact_description
+        position_descs = if head_consumer_tags.empty?
+          ["latest"]
+        else
+          head_consumer_tags.collect { | tag | "latest #{tag}"}
+        end
+
+        "Pact between #{consumer_name} and #{provider_name}, consumer version #{consumer_version_number}, #{position_descs.join(",")}"
+      end
+
       def inclusion_reason
         version_text = head_consumer_tags.size == 1 ? "version" : "versions"
         if wip?

data/lib/pact_broker/version.rb

@@ -1,3 +1,3 @@
 module PactBroker
-  VERSION = '2.46.0'
+  VERSION = '2.47.0'
 end

data/lib/pact_broker/webhooks/service.rb

@@ -110,7 +110,8 @@ module PactBroker
         webhooks = webhook_repository.find_by_consumer_and_or_provider_and_event_name pact.consumer, pact.provider, event_name
 
         if webhooks.any?
-          run_later(webhooks, pact, verification, event_name, options)
+          webhook_execution_configuration = options.fetch(:webhook_execution_configuration).with_webhook_context(event_name: event_name)
+          run_later(webhooks, pact, verification, event_name, options.merge(webhook_execution_configuration: webhook_execution_configuration))
         else
           logger.info "No enabled webhooks found for consumer \"#{pact.consumer.name}\" and provider \"#{pact.provider.name}\" and event #{event_name}"
         end
@@ -122,6 +123,7 @@ module PactBroker
           begin
             triggered_webhook = webhook_repository.create_triggered_webhook(trigger_uuid, webhook, pact, verification, RESOURCE_CREATION)
             logger.info "Scheduling job for webhook with uuid #{webhook.uuid}"
+            logger.debug "Schedule webhook with options #{options}"
             job_data = { triggered_webhook: triggered_webhook }.deep_merge(options)
             # Delay slightly to make sure the request transaction has finished before we execute the webhook
             Job.perform_in(5, job_data)

data/lib/pact_broker/webhooks/webhook_request_logger.rb

@@ -29,8 +29,9 @@ module PactBroker
         @options = options
       end
 
-      def log(uuid, webhook_request, http_response, error)
+      def log(uuid, webhook_request, http_response, error, webhook_context)
         safe_response = http_response ? HttpResponseWithUtf8SafeBody.new(http_response) : nil
+        log_webhook_context(webhook_context)
         log_request(webhook_request)
         log_response(uuid, safe_response) if safe_response
         log_error(uuid, error) if error
@@ -42,6 +43,11 @@ module PactBroker
 
       attr_reader :log_stream
 
+      def log_webhook_context(webhook_context)
+        execution_logger.debug "Webhook context #{webhook_context.to_json}"
+        logger.debug("Webhook context #{webhook_context.to_json}")
+      end
+
       def log_request(webhook_request)
         http_request = HttpRequestWithRedactedHeaders.new(webhook_request.http_request)
         logger.info "Making webhook #{webhook_request.uuid} request #{http_request.method.upcase} URI=#{webhook_request.url} (headers and body in debug logs)"

data/pact_broker.gemspec

@@ -74,7 +74,7 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency 'webmock', '~>2.3'
   gem.add_development_dependency 'rspec', '~>3.0'
   gem.add_development_dependency 'rspec-its', '~>1.2'
-  gem.add_development_dependency 'database_cleaner', '~>1.6'
+  gem.add_development_dependency 'database_cleaner', '~>1.8', '>= 1.8.1'
   gem.add_development_dependency 'pg', '~>0.21'
   gem.add_development_dependency 'conventional-changelog', '~>1.3'
   gem.add_development_dependency 'bump', '~> 0.5'

data/spec/lib/pact_broker/api/resources/provider_pacts_for_verification_spec.rb

@@ -18,7 +18,7 @@ module PactBroker
           {
             provider_version_tags: ['master'],
             consumer_version_selectors: [ { tag: 'dev', latest: 'true' }],
-            include_pending_status: false,
+            include_pending_status: 'true',
             include_wip_pacts_since: '2018-01-01'
           }
         end
@@ -32,7 +32,11 @@ module PactBroker
               "Bar",
               ["master"],
               [OpenStruct.new(tag: "dev", latest: true)],
-              { include_wip_pacts_since: DateTime.parse('2018-01-01') })
+              {
+                include_wip_pacts_since: DateTime.parse('2018-01-01'),
+                include_pending_status: true
+              }
+            )
             subject
           end
 
@@ -54,8 +58,8 @@ module PactBroker
             {
               providerVersionTags: ['master'],
               consumerVersionSelectors: [ { tag: 'dev', latest: true }],
-              includePendingStatus: false,
-              includeWipPactsSince: '2018-01-01'
+              includePendingStatus: true,
+              includeWipPactsSince: '2018-01-01',
             }
           end
 
@@ -74,7 +78,11 @@ module PactBroker
               "Bar",
               ["master"],
               [OpenStruct.new(tag: "dev", latest: true)],
-              { include_wip_pacts_since: DateTime.parse('2018-01-01') })
+              {
+                include_wip_pacts_since: DateTime.parse('2018-01-01'),
+                include_pending_status: true
+              }
+            )
             subject
           end
 
@@ -94,7 +102,7 @@ module PactBroker
         it "uses the correct options for the decorator" do
           expect(decorator).to receive(:to_json) do | options |
             expect(options[:user_options][:title]).to eq "Pacts to be verified by provider Bar"
-            expect(options[:user_options][:include_pending_status]).to eq false
+            expect(options[:user_options][:include_pending_status]).to eq true
           end
           subject
         end

data/spec/lib/pact_broker/domain/webhook_spec.rb

@@ -81,7 +81,7 @@ module PactBroker
         end
 
         it "generates the execution logs" do
-          expect(webhook_request_logger).to receive(:log).with(uuid, webhook_request, http_response, nil)
+          expect(webhook_request_logger).to receive(:log).with(uuid, webhook_request, http_response, nil, webhook_context)
           execute
         end
 
@@ -106,7 +106,7 @@ module PactBroker
           end
 
           it "generates the execution logs" do
-            expect(webhook_request_logger).to receive(:log).with(uuid, webhook_request, nil, instance_of(error_class))
+            expect(webhook_request_logger).to receive(:log).with(uuid, webhook_request, nil, instance_of(error_class), webhook_context)
             execute
           end
 

data/spec/lib/pact_broker/pacts/repository_find_for_verification_spec.rb

@@ -15,32 +15,48 @@ module PactBroker
           subject.find{ |pact| pact.consumer_name == consumer_name && pact.consumer_version_number == consumer_version_number }
         end
 
-        before do
-          td.create_pact_with_hierarchy("Foo", "foo-latest-prod-version", "Bar")
-            .create_consumer_version_tag("prod")
-            .create_consumer_version("not-latest-dev-version", tag_names: ["dev"])
-            .comment("next pact not selected")
-            .create_pact
-            .create_consumer_version("foo-latest-dev-version", tag_names: ["dev"])
-            .create_pact
-            .create_consumer("Baz")
-            .create_consumer_version("baz-latest-dev-version", tag_names: ["dev"])
-            .create_pact
-        end
 
         subject { Repository.new.find_for_verification("Bar", consumer_version_selectors) }
 
         context "when there are no selectors" do
+          before do
+            td.create_pact_with_hierarchy("Foo", "foo-latest-prod-version", "Bar")
+              .create_consumer_version_tag("prod")
+              .create_consumer_version("not-latest-dev-version", tag_names: ["dev"])
+              .comment("next pact not selected")
+              .create_pact
+              .create_consumer_version("foo-latest-dev-version", tag_names: ["dev"])
+              .create_pact
+              .create_consumer("Baz")
+              .create_consumer_version("baz-latest-dev-version", tag_names: ["dev"])
+              .create_pact
+          end
+
           let(:consumer_version_selectors) { [] }
 
           it "returns the latest pact for each consumer" do
             expect(subject.size).to eq 2
             expect(find_by_consumer_name_and_consumer_version_number("Foo", "foo-latest-dev-version")).to_not be nil
             expect(find_by_consumer_name_and_consumer_version_number("Baz", "baz-latest-dev-version")).to_not be nil
+            expect(subject.all?(&:overall_latest?)).to be true
           end
         end
 
-        context "when consumer tag names are specified" do
+        context "when the latest consumer tag names are specified" do
+          before do
+            td.create_pact_with_hierarchy("Foo", "foo-latest-prod-version", "Bar")
+              .create_consumer_version_tag("prod")
+              .create_consumer_version("not-latest-dev-version", tag_names: ["dev"])
+              .comment("next pact not selected")
+              .create_pact
+              .create_consumer_version("foo-latest-dev-version", tag_names: ["dev"])
+              .create_pact
+              .create_consumer("Baz")
+              .create_consumer_version("baz-latest-dev-version", tag_names: ["dev"])
+              .create_consumer_version_tag("prod")
+              .create_pact
+          end
+
           let(:pact_selector_1) { double('selector', tag: 'dev', latest: true) }
           let(:pact_selector_2) { double('selector', tag: 'prod', latest: true) }
           let(:consumer_version_selectors) do
@@ -48,47 +64,78 @@ module PactBroker
           end
 
           it "returns the latest pact with the specified tags for each consumer" do
-            expect(find_by_consumer_version_number("foo-latest-prod-version")).to_not be nil
-            expect(find_by_consumer_version_number("foo-latest-dev-version")).to_not be nil
-            expect(find_by_consumer_version_number("baz-latest-dev-version")).to_not be nil
+            expect(find_by_consumer_version_number("foo-latest-prod-version").selectors).to eq [Selector.latest_for_tag('prod')]
+            expect(find_by_consumer_version_number("foo-latest-dev-version").selectors).to eq [Selector.latest_for_tag('dev')]
+            expect(find_by_consumer_version_number("baz-latest-dev-version").selectors.sort_by{ |s| s[:tag] }).to eq [{ tag: 'dev', latest: true }, { tag: 'prod', latest: true }]
             expect(subject.size).to eq 3
           end
 
           it "sets the latest_consumer_version_tag_names" do
-            expect(find_by_consumer_version_number("foo-latest-prod-version").tag).to eq 'prod'
+            expect(find_by_consumer_version_number("foo-latest-prod-version").selectors.collect(&:tag)).to eq ['prod']
+          end
+        end
+
+        context "when all versions with a given tag are requested" do
+          before do
+            td.create_pact_with_hierarchy("Foo2", "prod-version-1", "Bar2")
+              .create_consumer_version_tag("prod")
+              .create_consumer_version("not-prod-version", tag_names: %w[master])
+              .create_pact
+              .create_consumer_version("prod-version-2", tag_names: %w[prod])
+              .create_pact
+          end
+
+          let(:consumer_version_selectors) { [pact_selector_1] }
+          let(:pact_selector_1) { double('selector', tag: 'prod', latest: nil) }
+
+          subject { Repository.new.find_for_verification("Bar2", consumer_version_selectors) }
+
+          it "returns all the versions with the specified tag" do
+            expect(subject.size).to be 2
+            expect(find_by_consumer_version_number("prod-version-1").selectors.collect(&:tag)).to eq %w[prod]
+            expect(find_by_consumer_version_number("prod-version-2").selectors.collect(&:tag)).to eq %w[prod]
           end
 
-          context "when all versions with a given tag are requested" do
-            before do
-              td.create_pact_with_hierarchy("Foo2", "prod-version-1", "Bar2")
-                .create_consumer_version_tag("prod")
-                .create_consumer_version("not-prod-version", tag_names: %w[master])
-                .create_pact
-                .create_consumer_version("prod-version-2", tag_names: %w[prod])
-                .create_pact
-            end
-
-            let(:consumer_version_selectors) { [pact_selector_1] }
-            let(:pact_selector_1) { double('selector', tag: 'prod', latest: nil) }
-
-            subject { Repository.new.find_for_verification("Bar2", consumer_version_selectors) }
-
-            it "returns all the versions with the specified tag" do
-              expect(subject.size).to be 2
-              expect(find_by_consumer_version_number("prod-version-1")).to_not be nil
-              expect(find_by_consumer_version_number("prod-version-2")).to_not be nil
-            end
-
-            it "dedupes them to ensure that each pact version is only verified once" do
-              td.create_consumer_version("prod-version-3", tag_names: %w[prod])
-                .republish_same_pact
-              expect(subject.size).to be 2
-              expect(subject.collect(&:consumer_version_number)).to eq %w[prod-version-1 prod-version-3]
-            end
+          it "dedupes them to ensure that each pact version is only verified once" do
+            td.create_consumer_version("prod-version-3", tag_names: %w[prod])
+              .republish_same_pact
+            expect(subject.size).to be 2
+            expect(subject.collect(&:consumer_version_number)).to eq %w[prod-version-1 prod-version-3]
+          end
+        end
+
+        context "when a pact version has been selected by two different selectors" do
+          before do
+            td.create_pact_with_hierarchy("Foo", "1", "Bar")
+              .create_consumer_version_tag("dev")
+              .create_consumer_version_tag("prod")
+          end
+
+          let(:consumer_version_selectors) { [pact_selector_1, pact_selector_2] }
+          let(:pact_selector_1) { double('selector1', tag: 'prod', latest: nil) }
+          let(:pact_selector_2) { double('selector2', tag: 'dev', latest: true) }
+          let(:consumer_version_selectors) { [pact_selector_1, pact_selector_2] }
+
+          it "returns a single selected pact with multiple selectors" do
+            expect(subject.size).to eq 1
+            expect(subject.first.selectors.size).to eq 2
           end
         end
 
         context "when no selectors are specified" do
+          before do
+            td.create_pact_with_hierarchy("Foo", "foo-latest-prod-version", "Bar")
+              .create_consumer_version_tag("prod")
+              .create_consumer_version("not-latest-dev-version", tag_names: ["dev"])
+              .comment("next pact not selected")
+              .create_pact
+              .create_consumer_version("foo-latest-dev-version", tag_names: ["dev"])
+              .create_pact
+              .create_consumer("Baz")
+              .create_consumer_version("baz-latest-dev-version", tag_names: ["dev"])
+              .create_pact
+          end
+
           let(:consumer_version_selectors) { [] }
 
           it "returns the latest pact for each provider" do
@@ -98,7 +145,7 @@ module PactBroker
           end
 
           it "does not set the tag name" do
-            expect(find_by_consumer_version_number("foo-latest-dev-version").tag).to be nil
+            expect(find_by_consumer_version_number("foo-latest-dev-version").selectors).to eq [{ latest: true }]
             expect(find_by_consumer_version_number("foo-latest-dev-version").overall_latest?).to be true
           end
         end

data/spec/lib/pact_broker/pacts/squash_pacts_for_verification_spec.rb

@@ -4,7 +4,7 @@ module PactBroker
   module Pacts
     module SquashPactsForVerification
       describe ".call" do
-        let(:head_pacts) { [pact_1, pact_2] }
+        let(:selected_pact) { pact_1 }
         let(:head_tag_1) { "dev" }
         let(:head_tag_2) { "feat-x" }
         let(:pact_version_sha_1) { "1" }
@@ -15,42 +15,23 @@ module PactBroker
             select_pending_provider_version_tags: pending_provider_version_tags
           )
         end
-        let(:domain_pact_2) { double('pact2', pending?: pending_2) }
         let(:pending_1) { false }
-        let(:pending_2) { false }
         let(:pending_provider_version_tags) { [] }
 
         let(:pact_1) do
-          double("HeadPact",
-            tag: head_tag_1,
-            pact_version_sha: pact_version_sha_1,
-            pact: domain_pact_1
+          double("SelectedPact",
+            tag_names_for_selectors_for_latest_pacts: %w[dev feat-x],
+            pact: domain_pact_1,
+            overall_latest?: false
           )
         end
 
-        let(:pact_2) do
-          double("HeadPact",
-            tag: head_tag_2,
-            pact_version_sha: pact_version_sha_2,
-            pact: domain_pact_2
-          )
-        end
-
-        let(:provider_name) { "Bar" }
         let(:provider_version_tags) { [] }
 
-        subject { SquashPactsForVerification.call(provider_version_tags, head_pacts) }
+        subject { SquashPactsForVerification.call(provider_version_tags, selected_pact, true) }
 
-        context "when all of the consumer tags are not nil" do
-          its(:head_consumer_tags) { is_expected.to eq %w[dev feat-x] }
-          its(:overall_latest?) { is_expected.to be false }
-        end
-
-        context "when one of the consumer tags is nil" do
-          let(:head_tag_2) { nil }
-          its(:head_consumer_tags) { is_expected.to eq %w[dev] }
-          its(:overall_latest?) { is_expected.to be true }
-        end
+        its(:head_consumer_tags) { is_expected.to eq %w[dev feat-x] }
+        its(:overall_latest?) { is_expected.to be false }
 
         context "when there are no provider tags" do
           context "when the pact version is not pending" do

data/spec/lib/pact_broker/pacts/verifiable_pact_messages_spec.rb

@@ -13,6 +13,7 @@ module PactBroker
         double(VerifiablePact,
           head_consumer_tags: head_consumer_tags,
           consumer_name: "Foo",
+          consumer_version_number: "123",
           provider_name: "Bar",
           pending_provider_tags: pending_provider_tags,
           non_pending_provider_tags: non_pending_provider_tags,
@@ -32,6 +33,7 @@ module PactBroker
         context "when there is 1 head consumer tags" do
           let(:head_consumer_tags) { %w[dev] }
           its(:inclusion_reason) { is_expected.to include "The pact at http://pact is being verified because it is the pact for the latest version of Foo tagged with 'dev'" }
+          its(:pact_description) { is_expected.to eq "Pact between Foo and Bar, consumer version 123, latest dev"}
         end
 
         context "when there are 2 head consumer tags" do

data/spec/lib/pact_broker/webhooks/service_spec.rb

@@ -152,14 +152,16 @@ module PactBroker
         let(:provider) { PactBroker::Domain::Pacticipant.new(name: 'Provider') }
         let(:webhooks) { [instance_double(PactBroker::Domain::Webhook, description: 'description', uuid: '1244')]}
         let(:triggered_webhook) { instance_double(PactBroker::Webhooks::TriggeredWebhook) }
+        let(:webhook_execution_configuration) { double('webhook_execution_configuration') }
         let(:options) do
           { database_connector: double('database_connector'),
-            webhook_context: {},
+            webhook_execution_configuration: webhook_execution_configuration,
             logging_options: {}
           }
         end
 
         before do
+          allow(webhook_execution_configuration).to receive(:with_webhook_context).and_return(webhook_execution_configuration)
           allow_any_instance_of(PactBroker::Webhooks::Repository).to receive(:find_by_consumer_and_or_provider_and_event_name).and_return(webhooks)
           allow_any_instance_of(PactBroker::Webhooks::Repository).to receive(:create_triggered_webhook).and_return(triggered_webhook)
           allow(Job).to receive(:perform_in)
@@ -177,6 +179,11 @@ module PactBroker
             expect(Service).to receive(:run_later).with(webhooks, pact, verification, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, options)
             subject
           end
+
+          it "merges the event name in the options" do
+            expect(webhook_execution_configuration).to receive(:with_webhook_context).with(event_name: PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED)
+            subject
+          end
         end
 
         context "when no webhooks are found" do

data/spec/lib/pact_broker/webhooks/webhook_request_logger_spec.rb

@@ -50,9 +50,11 @@ module PactBroker
         }
       end
 
+      let(:webhook_context) { { consumer_version_number: "123" } }
+
       let(:webhook_request_logger) { WebhookRequestLogger.new(options) }
 
-      subject(:logs) { webhook_request_logger.log(uuid, webhook_request, response, error) }
+      subject(:logs) { webhook_request_logger.log(uuid, webhook_request, response, error, webhook_context) }
 
       describe "application logs" do
         it "logs the request" do
@@ -69,6 +71,9 @@ module PactBroker
       end
 
       describe "execution logs" do
+        it "logs the application context" do
+          expect(logs).to include webhook_context.to_json
+        end
 
         it "logs the request method and path" do
           expect(logs).to include "POST http://example.org/hook"

data/spec/support/ssl_webhook_server.rb

@@ -11,10 +11,12 @@ if __FILE__ == $0
   def webrick_opts port
     certificate = OpenSSL::X509::Certificate.new(File.read(SSL_CERT))
     cert_name = certificate.subject.to_a.collect{|a| a[0..1] }
+    logger_stream = ENV['DEBUG'] ? $stderr : StringIO.new
     {
       Port: port,
       Host: "0.0.0.0",
       AccessLog: [],
+      Logger: WEBrick::Log.new(logger_stream,WEBrick::Log::INFO),
       SSLCertificate: certificate,
       SSLPrivateKey: OpenSSL::PKey::RSA.new(File.read(SSL_KEY)),
       SSLEnable: true,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pact_broker
 version: !ruby/object:Gem::Version
-  version: 2.46.0
+  version: 2.47.0
 platform: ruby
 authors:
 - Bethany Skurrie
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-30 00:00:00.000000000 Z
+date: 2020-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -480,14 +480,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '1.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '1.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.1
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -1051,6 +1057,8 @@ files:
 - lib/pact_broker/pacts/parse.rb
 - lib/pact_broker/pacts/placeholder_pact.rb
 - lib/pact_broker/pacts/repository.rb
+- lib/pact_broker/pacts/selected_pact.rb
+- lib/pact_broker/pacts/selector.rb
 - lib/pact_broker/pacts/service.rb
 - lib/pact_broker/pacts/sort_content.rb
 - lib/pact_broker/pacts/squash_pacts_for_verification.rb
@@ -1604,7 +1612,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubyforge_project: 
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: See description