pact_broker 2.82.0 → 2.83.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a0cf4f6c970fd0fa0535eca1d44605e3e40d79407e6edf5e06f6ceea7160ece
-  data.tar.gz: bb6533b81dd28846a3ccda8d3fe2479c1621cd2117814ee63d5f6cf55f500079
+  metadata.gz: 36d8ba30424126875c015264b7ba7e8fd7feb281a019f3436b5c714c7c5ddd0a
+  data.tar.gz: 4858eeee386bb44f6d9880b79a92b71d3760b8307fb5faebe07efa8f773fb2ba
 SHA512:
-  metadata.gz: c5f7da8fe0a477ee49d54a3d2e034be142d3af6b7a942b47818e2809ae34c1d3add710ba316871d41001e4a1ec708769d51de176b37a47b4785b81778c729a0c
-  data.tar.gz: cd91ad22fb076907f240deb3322701f272b802839f2c1a6c3f44e232a452eb17fa5d5f61fe6ef0cfab3ac912d2b9700c5f33e30b918ba6bd1125735ace3af743
+  metadata.gz: 23a3f387f860177de7cfdc7152127fd295aa124b415e0d1b7b66c657947c0b89ea06decff7bf2b840d75b690b844bd0fb2999ddb14deb4b269d21e9e5cc7d736
+  data.tar.gz: 98c2642b548b2b08ac71fe55a66c18981392ea575bc6c2ca389c19c1f283b134c814cf2479e03d7899bb70a8d244c1987fca10556833df5c3c506e45dfd5ee07

data/.gitignore

@@ -42,3 +42,4 @@ db/test/backwards_compatibility/pact_broker_database.sqlite3
 spec/examples.txt
 .approvals
 regression/fixtures/approvals
+config/pact_broker.local.yml

data/CHANGELOG.md

@@ -1,3 +1,19 @@
+<a name="v2.83.0"></a>
+### v2.83.0 (2021-08-19)
+
+#### Features
+
+* **clean**
+  * update default selectors for clean task to include deployed, released and branch head versions	 ([aaffe71f](/../../commit/aaffe71f))
+  * support keeping currently deployed and released versions, and the latest version for each branch	 ([e4fbd766](/../../commit/e4fbd766))
+
+* add index to verifications table to improve performance of 'latest verification' query	 ([02eeb424](/../../commit/02eeb424))
+
+#### Bug Fixes
+
+* use provider_version_number from webhook context	 ([3cf421ac](/../../commit/3cf421ac))
+* validate matrix query limit	 ([ac5e0890](/../../commit/ac5e0890))
+
 <a name="v2.82.0"></a>
 ### v2.82.0 (2021-08-14)
 

data/db/migrations/20210815_add_provider_version_id_index_to_verifications.rb

@@ -0,0 +1,7 @@
+Sequel.migration do
+  change do
+    alter_table(:verifications) do
+      add_index([:pact_version_id, :id], name: "verifications_pact_version_id_id_index")
+    end
+  end
+end

data/db/migrations/20210818_add_consumer_version_selectors_to_verification.rb

@@ -0,0 +1,8 @@
+Sequel.migration do
+  change do
+    alter_table(:verifications) do
+      add_column(:consumer_version_selector_hashes, String)
+      add_column(:tag_names, String)
+    end
+  end
+end

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

@@ -51,7 +51,8 @@ module PactBroker
 
         def from_json
           handle_webhook_events do
-            verification = verification_service.create(next_verification_number, verification_params, pact, event_context)
+            verified_pacts = pact_service.find_for_verification_publication(pact_params, event_context[:consumer_version_selectors])
+            verification = verification_service.create(next_verification_number, verification_params, verified_pacts, event_context)
             response.body = decorator_for(verification).to_json(decorator_options)
           end
           true

data/lib/pact_broker/db/clean/selector.rb

@@ -0,0 +1,54 @@
+require "pact_broker/hash_refinements"
+
+module PactBroker
+  module DB
+    class Clean
+      class Selector
+        using PactBroker::HashRefinements
+
+        ATTRIBUTES = [:pacticipant_name, :latest, :tag, :branch, :environment_name, :max_age, :deployed, :released, :main_branch]
+
+        attr_accessor(*ATTRIBUTES)
+
+        def initialize(attributes = {})
+          attributes.each do | (name, value) |
+            instance_variable_set("@#{name}", value) if respond_to?(name)
+          end
+          @source_hash = attributes[:source_hash]
+        end
+
+        def self.from_hash(hash)
+          standard_hash = hash.symbolize_keys.snakecase_keys
+          new_hash = standard_hash.slice(*ATTRIBUTES)
+          new_hash[:pacticipant_name] ||= standard_hash[:pacticipant] if standard_hash[:pacticipant]
+          new_hash[:environment_name] ||= standard_hash[:environment] if standard_hash[:environment]
+          new_hash[:source_hash] = hash
+          new(new_hash.compact)
+        end
+
+        def to_hash
+          ATTRIBUTES.each_with_object({}) do | key, hash |
+            hash[key] = send(key)
+          end.compact
+        end
+        alias_method :to_h, :to_hash
+
+        def to_json
+          (@source_hash || to_hash).to_json
+        end
+
+        def currently_deployed?
+          !!deployed
+        end
+
+        def currently_supported?
+          !!released
+        end
+
+        def latest?
+          !!latest
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/db/clean.rb

@@ -2,6 +2,7 @@ require "sequel"
 require "pact_broker/project_root"
 require "pact_broker/pacts/latest_tagged_pact_publications"
 require "pact_broker/logging"
+require "pact_broker/db/clean/selector"
 
 module PactBroker
   module DB
@@ -24,7 +25,12 @@ module PactBroker
       end
 
       def keep
-        options[:keep] || [PactBroker::Matrix::UnresolvedSelector.new(tag: true, latest: true), PactBroker::Matrix::UnresolvedSelector.new(latest: true)]
+        @keep ||= if options[:keep]
+                    # Could be a Matrix::UnresolvedSelector from the docker image, convert it
+                    options[:keep].collect { | unknown_thing | Selector.from_hash(unknown_thing.to_hash) }
+                  else
+                    [Selector.new(tag: true, latest: true), Selector.new(branch: true, latest: true), Selector.new(latest: true), Selector.new(deployed: true), Selector.new(released: true)]
+                  end
       end
 
       def resolve_ids(query, column_name = :id)

data/lib/pact_broker/db/clean_incremental.rb

@@ -1,15 +1,18 @@
 require "pact_broker/logging"
 require "pact_broker/matrix/unresolved_selector"
 require "pact_broker/date_helper"
-
+require "pact_broker/db/clean/selector"
 
 module PactBroker
   module DB
     class CleanIncremental
       DEFAULT_KEEP_SELECTORS = [
-        PactBroker::Matrix::UnresolvedSelector.new(tag: true, latest: true),
-        PactBroker::Matrix::UnresolvedSelector.new(latest: true),
-        PactBroker::Matrix::UnresolvedSelector.new(max_age: 90)
+        PactBroker::DB::Clean::Selector.new(tag: true, latest: true),
+        PactBroker::DB::Clean::Selector.new(branch: true, latest: true),
+        PactBroker::DB::Clean::Selector.new(latest: true),
+        PactBroker::DB::Clean::Selector.new(deployed: true),
+        PactBroker::DB::Clean::Selector.new(released: true),
+        PactBroker::DB::Clean::Selector.new(max_age: 90)
       ]
       TABLES = [:versions, :pact_publications, :pact_versions, :verifications, :triggered_webhooks, :webhook_executions]
 
@@ -27,7 +30,12 @@ module PactBroker
       end
 
       def keep
-        options[:keep] || DEFAULT_KEEP_SELECTORS
+        @keep ||= if options[:keep]
+                    # Could be a Matrix::UnresolvedSelector from the docker image, convert it
+                    options[:keep].collect { | unknown_thing | PactBroker::DB::Clean::Selector.from_hash(unknown_thing.to_hash) }
+                  else
+                    DEFAULT_KEEP_SELECTORS
+                  end
       end
 
       def limit

data/lib/pact_broker/diagnostic/resources/base_resource.rb

@@ -16,6 +16,10 @@ module PactBroker
           return false if PactBroker.configuration.authorize.nil?
           !PactBroker.configuration.authorize.call(self, {})
         end
+
+        def base_url
+          request.env["pactbroker.base_url"] || request.base_uri.to_s.chomp("/")
+        end
       end
     end
   end

data/lib/pact_broker/diagnostic/resources/dependencies.rb

@@ -27,7 +27,7 @@ module PactBroker
             "database" => report,
             "_links" => {
               "self" => {
-                "href" => request.uri.to_s
+                "href" => base_url + "/diagnostic/status/dependencies"
               }
             }
           }.to_json

data/lib/pact_broker/diagnostic/resources/heartbeat.rb

@@ -4,7 +4,6 @@ module PactBroker
   module Diagnostic
     module Resources
       class Heartbeat < BaseResource
-
         def allowed_methods
           ["GET"]
         end
@@ -14,11 +13,11 @@ module PactBroker
         end
 
         def to_json
-          @@json ||= {
+          {
             "ok" => true,
             "_links" => {
               "self" => {
-                "href" => request.uri.to_s
+                "href" => base_url + "/diagnostic/status/heartbeat"
               }
             }
           }.to_json

data/lib/pact_broker/domain/verification.rb

@@ -9,6 +9,8 @@ module PactBroker
   module Domain
     class Verification < Sequel::Model
       using Sequel::SymbolAref
+      TO_JSON = lambda { | thing | Sequel.object_to_json(thing) }
+      FROM_JSON_WITH_SYMBOL_KEYS = lambda { | json | JSON.parse(json, symbolize_names: true) }
 
       set_primary_key :id
       associate(:many_to_one, :pact_version, class: "PactBroker::Pacts::PactVersion", key: :pact_version_id, primary_key: :id)
@@ -16,7 +18,8 @@ module PactBroker
       associate(:many_to_one, :provider, class: "PactBroker::Domain::Pacticipant", key: :provider_id, primary_key: :id)
       associate(:many_to_one, :consumer, class: "PactBroker::Domain::Pacticipant", key: :consumer_id, primary_key: :id)
       associate(:one_to_many, :provider_version_tags, :class => "PactBroker::Domain::Tag", primary_key: :provider_version_id, key: :version_id)
-      plugin :serialization, :json, :test_results
+      plugin :serialization, :json, :test_results, :tag_names
+      serialize_attributes [TO_JSON, FROM_JSON_WITH_SYMBOL_KEYS], :consumer_version_selector_hashes
 
       def before_create
         super

data/lib/pact_broker/domain/version.rb

@@ -115,6 +115,16 @@ module PactBroker
           where(id: supported_version_query.select(:version_id))
         end
 
+        def currently_deployed
+          deployed_version_query = PactBroker::Deployments::DeployedVersion.currently_deployed
+          where(id: deployed_version_query.select(:version_id))
+        end
+
+        def currently_supported
+          supported_version_query = PactBroker::Deployments::ReleasedVersion.currently_supported
+          where(id: supported_version_query.select(:version_id))
+        end
+
         def where_tag(tag)
           if tag == true
             join(:tags, Sequel[:tags][:version_id] => Sequel[first_source_alias][:id])
@@ -129,7 +139,19 @@ module PactBroker
         end
 
         def where_branch(branch)
-          where(branch: branch)
+          if branch == true
+            exclude(branch: nil)
+          else
+            where(branch: branch)
+          end
+        end
+
+        def for_main_branches
+          pacticipants_join = {
+            Sequel[:versions][:pacticipant_id] => Sequel[:pacticipants][:id],
+            Sequel[:pacticipants][:main_branch] => Sequel[:versions][:branch]
+          }
+          where(id: select(Sequel[:versions][:id]).join(:pacticipants, pacticipants_join))
         end
 
         def where_number(number)
@@ -161,10 +183,13 @@ module PactBroker
           query = self
           query = query.where_pacticipant_name(selector.pacticipant_name) if selector.pacticipant_name
           query = query.currently_in_environment(selector.environment_name, selector.pacticipant_name) if selector.environment_name
+          query = query.currently_deployed if selector.respond_to?(:currently_deployed?) && selector.currently_deployed?
+          query = query.currently_supported if selector.respond_to?(:currently_supported?) && selector.currently_supported?
           query = query.where_tag(selector.tag) if selector.tag
           query = query.where_branch(selector.branch) if selector.branch
-          query = query.where_number(selector.pacticipant_version_number) if selector.pacticipant_version_number
-          query = query.where_age_less_than(selector.max_age) if selector.max_age
+          query = query.for_main_branches if selector.respond_to?(:main_branch) && selector.main_branch
+          query = query.where_number(selector.pacticipant_version_number) if selector.respond_to?(:pacticipant_version_number) && selector.pacticipant_version_number
+          query = query.where_age_less_than(selector.max_age) if selector.respond_to?(:max_age) && selector.max_age
 
           if selector.latest
             calculate_max_version_order_and_join_back_to_versions(query, selector)
@@ -232,6 +257,10 @@ module PactBroker
       def latest_for_pacticipant?
         latest_version_for_pacticipant == self
       end
+
+      def tag_names
+        tags.collect(&:name)
+      end
     end
   end
 end

data/lib/pact_broker/locale/en.yml

@@ -87,6 +87,7 @@ en:
         invalid_content_for_content_type: "The content could not be parsed as %{content_type}"
         cannot_set_currently_deployed_true: The currentlyDeployed property cannot be set back to true. Please record a new deployment.
         cannot_set_currently_supported_true: The currentlySupported property cannot be set back to true. Please record a new deployment.
+        invalid_limit: The limit must be 1 or greater.
       duplicate_pacticipant: |
         This is the first time a pact has been published for "%{new_name}".
         The name "%{new_name}" is very similar to the following existing consumers/providers:

data/lib/pact_broker/matrix/service.rb

@@ -100,6 +100,10 @@ module PactBroker
           error_messages << message("errors.validation.environment_with_name_not_found", name: options[:environment_name])
         end
 
+        if options[:limit] && options[:limit].to_i < 1
+          error_messages << message("errors.validation.invalid_limit")
+        end
+
         error_messages
       end
       # rubocop: enable Metrics/CyclomaticComplexity, Metrics/MethodLength

data/lib/pact_broker/matrix/unresolved_selector.rb

@@ -10,7 +10,7 @@ module PactBroker
       end
 
       def self.from_hash(hash)
-        new(hash.symbolize_keys.snakecase_keys.slice(:pacticipant_name, :pacticipant_version_number, :latest, :tag, :branch, :environment_name, :max_age))
+        new(hash.symbolize_keys.snakecase_keys.slice(:pacticipant_name, :pacticipant_version_number, :latest, :tag, :branch, :environment_name))
       end
 
       def pacticipant_name
@@ -26,7 +26,7 @@ module PactBroker
       end
 
       def overall_latest?
-        latest? && !tag && !max_age
+        latest? && !tag && !branch
       end
 
       def latest
@@ -69,6 +69,7 @@ module PactBroker
         self[:pacticipant_version_number] = pacticipant_version_number
       end
 
+      # TODO delete this once docker image uses new selector class for clean
       def max_age= max_age
         self[:max_age] = max_age
       end

data/lib/pact_broker/pacts/metadata.rb

@@ -10,6 +10,7 @@ module PactBroker
         [:wip, "w"],
         [:consumer_version_selectors, "s"],
         [:tag, "t"],
+        [:branch, "b"],
         [:latest, "l"]
       ]
 
@@ -52,9 +53,11 @@ module PactBroker
             "w" => true
           }
         else
+          # TODO support deployed and released
           {
             "s" => verifiable_pact.selectors.collect do | selector |
               {
+                "b" => selector.branch,
                 "t" => selector.tag,
                 "l" => selector.latest,
                 "cv" => selector.consumer_version.id

data/lib/pact_broker/pacts/pact_version.rb

@@ -1,6 +1,7 @@
 require "sequel"
 require "pact_broker/repositories/helpers"
 require "pact_broker/verifications/latest_verification_for_pact_version"
+require "pact_broker/verifications/latest_verification_id_for_pact_version_and_provider_version"
 
 module PactBroker
   module Pacts
@@ -17,7 +18,7 @@ module PactBroker
       one_to_one(:latest_verification,
         class: "PactBroker::Domain::Verification",
         read_only: true,
-        dataset: lambda { PactBroker::Domain::Verification.where(id: PactBroker::Domain::Verification.select(Sequel.function(:max, :id)).where(pact_version_id: id)) },
+        dataset: lambda { PactBroker::Domain::Verification.where(id: PactBroker::Verifications::LatestVerificationIdForPactVersionAndProviderVersion.select(Sequel.function(:max, :verification_id)).where(pact_version_id: id)) },
         key: :pact_version_id, primary_key: :id,
         eager_block: lambda { | ds | ds.latest_by_pact_version }
       )

data/lib/pact_broker/pacts/pacts_for_verification_repository.rb

@@ -183,13 +183,7 @@ module PactBroker
       end
 
       def merge_selected_pacts(selected_pacts)
-        selected_pacts
-          .group_by{ |p| [p.consumer_name, p.pact_version_sha] }
-          .values
-          .collect do | selected_pacts_for_pact_version_id |
-            SelectedPact.merge(selected_pacts_for_pact_version_id)
-          end
-          .sort
+        SelectedPact.merge_by_pact_version_sha(selected_pacts)
       end
 
       # TODO ? find the WIP pacts by consumer branch

data/lib/pact_broker/pacts/repository.rb

@@ -321,6 +321,10 @@ module PactBroker
         end
       end
 
+      def find_pact_version(consumer, provider, pact_version_sha)
+        PactBroker::Pacts::PactVersion.where(consumer_id: consumer.id, provider_id: provider.id, sha: pact_version_sha).single_record
+      end
+
       private
 
       def find_previous_distinct_pact_by_sha pact

data/lib/pact_broker/pacts/selected_pact.rb

@@ -11,6 +11,26 @@ module PactBroker
         @selectors = selectors
       end
 
+      def self.merge_by_pact_version_sha(selected_pacts)
+        selected_pacts
+          .group_by{ |p| [p.consumer_name, p.pact_version_sha] }
+          .values
+          .collect do | selected_pacts_for_pact_version_id |
+            SelectedPact.merge(selected_pacts_for_pact_version_id)
+          end
+          .sort
+      end
+
+      def self.merge_by_consumer_version_number(selected_pacts)
+        selected_pacts
+          .group_by{ |p| [p.consumer_name, p.consumer_version_number] }
+          .values
+          .collect do | selected_pacts_for_consumer_version_number |
+            SelectedPact.merge(selected_pacts_for_consumer_version_number)
+          end
+          .sort
+      end
+
       def self.merge(selected_pacts)
         latest_selected_pact = selected_pacts.sort_by(&:consumer_version_order).last
         selectors = selected_pacts.collect(&:selectors).reduce(&:+).sort

data/lib/pact_broker/pacts/service.rb

@@ -6,10 +6,12 @@ require "pact_broker/pacts/verifiable_pact"
 require "pact_broker/pacts/squash_pacts_for_verification"
 require "pact_broker/events/publisher"
 require "pact_broker/messages"
+require "pact_broker/hash_refinements"
 
 module PactBroker
   module Pacts
     module Service
+      using PactBroker::HashRefinements
 
       extend self
       extend PactBroker::Events::Publisher
@@ -133,6 +135,25 @@ module PactBroker
         explicitly_specified_verifiable_pacts + verifiable_wip_pacts
       end
 
+      def find_for_verification_publication(pact_params, consumer_version_selector_hashes)
+        if consumer_version_selector_hashes&.any?
+          selected_pacts = consumer_version_selector_hashes.collect do | consumer_version_selector_hash |
+            find_pact_params = {
+              consumer_name: pact_params.consumer_name,
+              provider_name: pact_params.provider_name,
+              pact_version_sha: pact_params.pact_version_sha,
+              consumer_version_number: consumer_version_selector_hash[:consumer_version_number]
+            }
+            pact = find_pact(find_pact_params)
+            resolved_selector = Selector.new(consumer_version_selector_hash.without(:consumer_version_number)).resolve(pact.consumer_version)
+            SelectedPact.new(pact, Selectors.new(resolved_selector))
+          end
+          SelectedPact.merge_by_consumer_version_number(selected_pacts)
+        else
+          [SelectedPact.new(find_pact(pact_params), Selectors.new)]
+        end
+      end
+
       # Overwriting an existing pact with the same consumer/provider/consumer version number
       def update_pact params, existing_pact
         logger.info "Updating existing pact publication with params #{params.reject{ |k, _v| k == :json_content}}"

data/lib/pact_broker/test/http_test_data_builder.rb

@@ -120,7 +120,7 @@ module PactBroker
         self
       end
 
-      def get_pacts_for_verification(provider: last_provider_name, provider_version_tag: nil, provider_version_branch: nil, consumer_version_selectors:, enable_pending: false, include_wip_pacts_since: nil)
+      def get_pacts_for_verification(provider: last_provider_name, provider_version_tag: nil, provider_version_branch: nil, consumer_version_selectors: [], enable_pending: false, include_wip_pacts_since: nil)
         @last_provider_name = provider
         @last_provider_version_tag = provider_version_tag
         @last_provder_version_branch = provider_version_branch
@@ -149,7 +149,8 @@ module PactBroker
             puts({
               "url" => pact["_links"]["self"]["href"],
               "wip" => pact["verificationProperties"]["wip"],
-              "pending" => pact["verificationProperties"]["pending"]
+              "pending" => pact["verificationProperties"]["pending"],
+              "why" => pact["verificationProperties"]["notices"].select { | n | n["when"] == "before_verification" }.collect{ | n | n["text"] }
             }.to_yaml)
           end
         end
@@ -166,7 +167,7 @@ module PactBroker
         self
       end
 
-      def verify_pact(index: 0, success:, provider: last_provider_name, provider_version_tag: last_provider_version_tag, provider_version_branch: last_provider_version_branch, provider_version: )
+      def verify_pact(index: 0, success: true, provider: last_provider_name, provider_version_tag: last_provider_version_tag, provider_version_branch: last_provider_version_branch, provider_version: )
         @last_provider_name = provider
         @last_provider_version_tag = provider_version_tag
         @last_provider_version_branch = provider_version_branch

data/lib/pact_broker/test/test_data_builder.rb

@@ -373,7 +373,8 @@ module PactBroker
         parameters = default_parameters.merge(parameters)
         parameters.delete(:provider_version)
         verification = PactBroker::Domain::Verification.new(parameters)
-        @verification = PactBroker::Verifications::Repository.new.create(verification, provider_version_number, @pact)
+        pact_version = PactBroker::Pacts::Repository.new.find_pact_version(@consumer, @provider, pact.pact_version_sha)
+        @verification = PactBroker::Verifications::Repository.new.create(verification, provider_version_number, pact_version)
         @provider_version = PactBroker::Domain::Version.where(pacticipant_id: @provider.id, number: provider_version_number).single_record
         @provider_version.update(branch: branch) if branch
 

data/lib/pact_broker/verifications/repository.rb

@@ -19,14 +19,13 @@ module PactBroker
         Sequence.next_val
       end
 
-      def create verification, provider_version_number, pact
-        provider = pacticipant_repository.find_by_name(pact.provider_name)
-        consumer = pacticipant_repository.find_by_name(pact.consumer_name)
-        version = version_repository.find_by_pacticipant_id_and_number_or_create(provider.id, provider_version_number)
-        verification.pact_version_id = pact_version_id_for(pact)
+      def create verification, provider_version_number, pact_version
+        version = version_repository.find_by_pacticipant_id_and_number_or_create(pact_version.provider_id, provider_version_number)
+        verification.pact_version_id = pact_version.id
         verification.provider_version = version
-        verification.provider_id = provider.id
-        verification.consumer_id = consumer.id
+        verification.provider_id = pact_version.provider_id
+        verification.consumer_id = pact_version.consumer_id
+        verification.tag_names = version.tag_names # TODO pass this in from contracts service
         verification.save
         update_latest_verification_id(verification)
         verification
@@ -150,10 +149,6 @@ module PactBroker
         provider = pacticipant_repository.find_by_name!(options.fetch(:and))
         PactBroker::Domain::Verification.where(provider: provider, consumer: consumer).delete
       end
-
-      def pact_version_id_for pact
-        PactBroker::Pacts::PactPublication.select(:pact_version_id).where(id: pact.id)
-      end
     end
   end
 end

data/lib/pact_broker/verifications/service.rb

@@ -27,16 +27,21 @@ module PactBroker
         verification_repository.next_number
       end
 
-      def create next_verification_number, params, pact, event_context
-        logger.info "Creating verification #{next_verification_number} for pact_id=#{pact.id}", payload: params.reject{ |k,_| k == "testResults"}
+      # verified_pacts is an array of SelectedPact objects
+      def create next_verification_number, params, verified_pacts, event_context
+        first_verified_pact = verified_pacts.first
+        logger.info "Creating verification #{next_verification_number} for pact_version_sha=#{first_verified_pact.pact_version_sha}", payload: params.reject{ |k,_| k == "testResults"}
         verification = PactBroker::Domain::Verification.new
         provider_version_number = params.fetch("providerApplicationVersion")
         PactBroker::Api::Decorators::VerificationDecorator.new(verification).from_hash(params)
         verification.wip = params.fetch("wip")
         verification.number = next_verification_number
-        verification = verification_repository.create(verification, provider_version_number, pact)
-
-        broadcast_events(verification, pact, event_context)
+        verification.consumer_version_selector_hashes = event_context[:consumer_version_selectors]
+        pact_version = pact_repository.find_pact_version(first_verified_pact.consumer, first_verified_pact.provider, first_verified_pact.pact_version_sha)
+        verification = verification_repository.create(verification, provider_version_number, pact_version)
+        # TODO set the latest_verification_id on each PactPublication
+        # TODO broadcast the verified_pacts for the webhooks
+        broadcast_events(verification, first_verified_pact.pact, event_context)
 
         verification
       end

data/lib/pact_broker/version.rb

@@ -1,3 +1,3 @@
 module PactBroker
-  VERSION = "2.82.0"
+  VERSION = "2.83.0"
 end

data/lib/pact_broker/webhooks/pact_and_verification_parameters.rb

@@ -52,7 +52,7 @@ module PactBroker
           PACT_URL => pact ? PactBroker::Api::PactBrokerUrls.pact_version_url_with_webhook_metadata(pact, base_url) : "",
           VERIFICATION_RESULT_URL => verification_url,
           CONSUMER_VERSION_NUMBER => consumer_version_number,
-          PROVIDER_VERSION_NUMBER => verification ? verification.provider_version_number : "",
+          PROVIDER_VERSION_NUMBER => provider_version_number,
           PROVIDER_VERSION_TAGS => provider_version_tags,
           PROVIDER_VERSION_BRANCH => provider_version_branch,
           CONSUMER_VERSION_TAGS => consumer_version_tags,
@@ -146,6 +146,14 @@ module PactBroker
         end
       end
 
+      def provider_version_number
+        if webhook_context[:provider_version_number]
+          webhook_context[:provider_version_number]
+        else
+          verification ? verification.provider_version_number : ""
+        end
+      end
+
       def provider_version_branch
         if webhook_context[:provider_version_branch]
           webhook_context[:provider_version_branch]

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

@@ -62,11 +62,14 @@ module PactBroker
 
             before do
               allow(Pacts::Service).to receive(:find_pact).and_return(pact)
+              allow(Pacts::Service).to receive(:find_for_verification_publication).and_return(verified_pacts)
               allow(PactBroker::Verifications::Service).to receive(:next_number).and_return(next_verification_number)
               allow(PactBroker::Api::Decorators::VerificationDecorator).to receive(:new).and_return(decorator)
               allow(PactBroker.configuration).to receive(:show_webhook_response?).and_return("some-boolean")
             end
 
+            let(:verified_pacts) { double("verified pacts") }
+
             it "parses the webhook metadata" do
               expect(PactBrokerUrls).to receive(:decode_pact_metadata).with("abcd")
               subject
@@ -84,7 +87,7 @@ module PactBroker
               expect(PactBroker::Verifications::Service).to receive(:create).with(
                 next_verification_number,
                 hash_including("some" => "params", "wip" => false),
-                pact,
+                verified_pacts,
                 parsed_metadata
               )
               subject

data/spec/lib/pact_broker/db/clean_spec.rb

@@ -14,8 +14,8 @@ module PactBroker
       let(:db) { PactBroker::DB.connection }
 
       subject { Clean.call(PactBroker::DB.connection, options) }
-      let(:latest_dev_selector) { PactBroker::Matrix::UnresolvedSelector.new(tag: "dev", latest: true) }
-      let(:all_prod_selector) { PactBroker::Matrix::UnresolvedSelector.new(tag: "prod") }
+      let(:latest_dev_selector) { { tag: "dev", latest: true } }
+      let(:all_prod_selector) { { tag: "prod" } }
 
       describe ".call"do
         context "when there are specified versions to keep" do

data/spec/lib/pact_broker/diagnostic/resources/dependencies_spec.rb

@@ -5,22 +5,22 @@ module PactBroker
   module Diagnostic
     module Resources
       describe Dependencies do
-
         describe "GET /diagnostic/status/dependencies" do
-
           include Rack::Test::Methods
 
+          let(:rack_env) { { "pactbroker.base_url" => "http://pact-broker"} }
           let(:app) { PactBroker::Diagnostic::App.new }
           let(:parsed_response_body) { JSON.parse(subject.body) }
 
-          subject { get "/diagnostic/status/dependencies"; last_response }
+
+          subject { get("/diagnostic/status/dependencies", nil, rack_env) }
 
           it "returns application/hal+json" do
             expect(subject.headers["Content-Type"]).to eq "application/hal+json"
           end
 
           it "returns a link to itself" do
-            expect(parsed_response_body["_links"]["self"]["href"]).to eq "http://example.org/diagnostic/status/dependencies"
+            expect(parsed_response_body["_links"]["self"]["href"]).to eq "http://pact-broker/diagnostic/status/dependencies"
           end
 
           context "when we can connect to the database" do

data/spec/lib/pact_broker/diagnostic/resources/heartbeat_spec.rb

@@ -6,16 +6,15 @@ module PactBroker
   module Diagnostic
     module Resources
       describe Heartbeat do
-
         include Rack::Test::Methods
 
         let(:app) { PactBroker::Diagnostic::App.new }
 
         describe "GET /diagnostic/status/heartbeat" do
-
+          let(:rack_env) { { "pactbroker.base_url" => "http://pact-broker"} }
           let(:parsed_response_body) { JSON.parse(subject.body) }
 
-          subject { get "/diagnostic/status/heartbeat"; last_response }
+          subject { get("/diagnostic/status/heartbeat", nil, rack_env) }
 
           it "returns a 200" do
             expect(subject.status).to eq 200
@@ -26,7 +25,7 @@ module PactBroker
           end
 
           it "returns a link to itself" do
-            expect(parsed_response_body["_links"]["self"]["href"]).to eq "http://example.org/diagnostic/status/heartbeat"
+            expect(parsed_response_body["_links"]["self"]["href"]).to eq "http://pact-broker/diagnostic/status/heartbeat"
           end
         end
       end

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

@@ -1,4 +1,5 @@
 require "pact_broker/domain/version"
+require "pact_broker/db/clean/selector"
 
 module PactBroker
   module Domain
@@ -131,7 +132,7 @@ module PactBroker
               .create_consumer_version("3", tag_names: %w{master})
           end
 
-          let(:selector) { PactBroker::Matrix::UnresolvedSelector.new(tag: "master", max_age: max_age) }
+          let(:selector) { PactBroker::DB::Clean::Selector.new(tag: "master", max_age: max_age) }
 
           let(:max_age) { 3 }
           let(:four_days_ago) { Date.today - 4 }
@@ -141,6 +142,76 @@ module PactBroker
           end
         end
 
+        context "when selecting the latest version for each branch" do
+          before do
+            td.create_consumer("Foo")
+              .create_consumer_version("1", branch: "main")
+              .create_consumer_version("2", branch: "main")
+              .create_consumer("Bar")
+              .create_consumer_version("3", branch: "main")
+          end
+
+          let(:selector) { PactBroker::DB::Clean::Selector.new(branch: true, latest: true) }
+
+          it "selects the consumer versions that are the latest for their branches" do
+            expect(version_numbers).to eq %w{2 3}
+          end
+        end
+
+        context "when selecting all versions with a branch" do
+          before do
+            td.create_consumer("Foo")
+              .create_consumer_version("1", branch: "main")
+              .create_consumer_version("2")
+              .create_consumer("Bar")
+              .create_consumer_version("3", branch: "main")
+          end
+
+          let(:selector) { PactBroker::DB::Clean::Selector.new(branch: true, latest: true) }
+
+          it "selects the consumer versions that are the latest for their branches" do
+            expect(version_numbers).to eq %w{1 3}
+          end
+        end
+
+        context "when selecting the latest versions from the main branches" do
+          before do
+            td.create_consumer("Foo", main_branch: "main")
+              .create_consumer_version("1", branch: "main")
+              .create_consumer_version("2", branch: "main")
+              .create_consumer_version("3", branch: "not-main")
+              .create_consumer("Bar", main_branch: "develop")
+              .create_consumer_version("4", branch: "develop")
+              .create_consumer_version("5", branch: "develop")
+              .create_consumer_version("6", branch: "main")
+          end
+
+          let(:selector) { PactBroker::DB::Clean::Selector.new(main_branch: true, latest: true) }
+
+          it "selects the consumer versions that are the latest for their branches" do
+            expect(version_numbers).to eq %w{2 5}
+          end
+        end
+
+        context "when selecting all versions from the main branches" do
+          before do
+            td.create_consumer("Foo", main_branch: "main")
+              .create_consumer_version("1", branch: "main")
+              .create_consumer_version("2", branch: "main")
+              .create_consumer_version("3", branch: "not-main")
+              .create_consumer("Bar", main_branch: "develop")
+              .create_consumer_version("4", branch: "develop")
+              .create_consumer_version("5", branch: "develop")
+              .create_consumer_version("6", branch: "main")
+          end
+
+          let(:selector) { PactBroker::DB::Clean::Selector.new(main_branch: true) }
+
+          it "selects the consumer versions that are the latest for their branches" do
+            expect(version_numbers).to eq %w{1 2 4 5}
+          end
+        end
+
         context "when selecting all versions of a pacticipant currently deployed to an environment" do
           let(:selector) { PactBroker::Matrix::UnresolvedSelector.new(environment_name: "prod", pacticipant_name: "Foo") }
 
@@ -194,6 +265,60 @@ module PactBroker
           end
         end
 
+        context "when selecting all currently deployed versions" do
+          let(:selector) { PactBroker::DB::Clean::Selector.new(deployed: true) }
+
+          before do
+            td.create_environment("test")
+              .create_consumer("Foo")
+              .create_consumer_version("1")
+              .create_deployed_version_for_consumer_version(target: "1")
+              .create_consumer_version("2")
+              .create_environment("prod")
+              .create_deployed_version_for_consumer_version(target: "2")
+              .create_consumer_version("3")
+              .create_consumer_version("5")
+              .create_consumer("Bar")
+              .create_consumer_version("10")
+              .create_deployed_version_for_consumer_version(target: "3")
+              .create_consumer_version("11")
+              .create_deployed_version_for_consumer_version(currently_deployed: false)
+              .create_consumer_version("12")
+              .create_released_version_for_consumer_version
+          end
+
+          it "returns the versions that are currently deployed" do
+            expect(version_numbers).to eq %w{1 2 10}
+          end
+        end
+
+        context "when selecting all currently released+supported versions" do
+          let(:selector) { PactBroker::DB::Clean::Selector.new(released: true) }
+
+          before do
+            td.create_environment("test")
+              .create_consumer("Foo")
+              .create_consumer_version("1")
+              .create_released_version_for_consumer_version
+              .create_consumer_version("2")
+              .create_environment("prod")
+              .create_released_version_for_consumer_version
+              .create_consumer_version("3")
+              .create_consumer_version("5")
+              .create_consumer("Bar")
+              .create_consumer_version("10")
+              .create_released_version_for_consumer_version
+              .create_consumer_version("11")
+              .create_released_version_for_consumer_version(currently_supported: false)
+              .create_consumer_version("12")
+              .create_deployed_version_for_consumer_version
+          end
+
+          it "returns the versions that are currently released+supported" do
+            expect(version_numbers).to eq %w{1 2 10}
+          end
+        end
+
         context "selecting versions for a branch" do
           before do
             td.create_consumer("Foo")

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

@@ -12,7 +12,7 @@ module PactBroker
 
         subject { Service.validate_selectors(selectors, options) }
 
-        let(:options) { {} }
+        let(:options) { { limit: "1" } }
 
         context "when there are no selectors" do
           let(:selectors) { [] }
@@ -145,6 +145,15 @@ module PactBroker
             expect(subject.last).to include "Please specify the pacticipant name to ignore"
           end
         end
+
+        context "with an invalid limit" do
+          let(:options) { { limit: "limit" } }
+          let(:selectors) { [] }
+
+          it "returns an error message" do
+            expect(subject.last).to include "The limit"
+          end
+        end
       end
 
       describe "find_for_consumer_and_provider_with_tags integration test" do

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

@@ -131,7 +131,6 @@ module PactBroker
           it "expands the key names" do
             expect(Metadata.parse_metadata(incoming_metadata)).to eq parsed_metadata
           end
-
         end
       end
     end

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

@@ -289,6 +289,67 @@ module PactBroker
           end
         end
       end
+
+      describe "find_for_verification_publication integration test" do
+        before do
+          json_content = { interactions: [] }.to_json
+          td.create_pact_with_hierarchy("Foo", "1", "Bar", json_content)
+            .create_pact_with_hierarchy("Foo", "2", "Bar", json_content)
+        end
+
+        let(:consumer_version_selector_hashes) do
+          [
+            { tag: "foo", latest: true, consumer_version_number: "1"},
+            { tag: "bar", latest: true, consumer_version_number: "1"},
+            { branch: "beep", latest: true, consumer_version_number: "2"}
+          ]
+        end
+
+        let(:pact_params) do
+          PactParams.new(
+            consumer_name: "Foo",
+            provider_name: "Bar",
+            pact_version_sha: td.and_return(:pact).pact_version_sha
+          )
+        end
+
+        subject { Service.find_for_verification_publication(pact_params, consumer_version_selector_hashes) }
+
+        it "deduplicates the pacts by consumer version number" do
+          expect(subject.size).to eq 2
+        end
+
+        it "sets the selectors" do
+          expect(subject.first.selectors.size).to eq 2
+          expect(subject.first.selectors.first).to have_attributes(latest: true, tag: "bar")
+          expect(subject.first.selectors.first.consumer_version).to have_attributes(number: "1")
+
+          expect(subject.first.selectors.last).to have_attributes(latest: true, tag: "foo")
+          expect(subject.first.selectors.last.consumer_version).to have_attributes(number: "1")
+
+          expect(subject.last.selectors.size).to eq 1
+          expect(subject.last.selectors.first).to have_attributes(latest: true, branch: "beep")
+          expect(subject.last.selectors.last.consumer_version).to have_attributes(number: "2")
+        end
+
+        context "when there are no consumer version selectors" do
+          let(:consumer_version_selector_hashes) { nil }
+
+          it "returns the latest pact for the sha" do
+            expect(subject.size).to eq 1
+            expect(subject.first.consumer_version_number).to eq "2"
+          end
+        end
+
+        context "when the consumer version selectors is empty" do
+          let(:consumer_version_selector_hashes) { [] }
+
+          it "returns the latest pact for the sha" do
+            expect(subject.size).to eq 1
+            expect(subject.first.consumer_version_number).to eq "2"
+          end
+        end
+      end
     end
   end
 end

data/spec/lib/pact_broker/verifications/repository_spec.rb

@@ -4,16 +4,23 @@ module PactBroker
   module Verifications
     describe Repository do
       describe "#create" do
+        before do
+          td.create_pact_with_hierarchy("Foo", "1", "Bar").and_return(:pact)
+        end
+
         let(:verification) do
-          PactBroker::Domain::Verification.new(success: true)
+          PactBroker::Domain::Verification.new(
+            success: true,
+            consumer_version_selector_hashes: [{ foo: "bar" }]
+          )
         end
 
         let(:provider_version_number) { "2" }
-        let(:pact) do
-          td.create_pact_with_hierarchy("Foo", "1", "Bar").and_return(:pact)
+        let(:pact_version) do
+          PactBroker::Pacts::PactVersion.first
         end
 
-        subject { Repository.new.create verification, provider_version_number, pact}
+        subject { Repository.new.create(verification, provider_version_number, pact_version) }
 
         it "creates a LatestVerificationIdForPactVersionAndProviderVersion" do
           expect { subject }.to change { LatestVerificationIdForPactVersionAndProviderVersion.count }.by(1)
@@ -22,27 +29,39 @@ module PactBroker
         it "sets the created_at of the LatestVerificationIdForPactVersionAndProviderVersion to the same as the verification" do
           expect(subject.created_at).to eq LatestVerificationIdForPactVersionAndProviderVersion.first.created_at
         end
+
+        context "when the provider version already exists" do
+          before do
+            td.create_provider_version(provider_version_number, tag_names: ["foo", "bar"], branch: "main")
+          end
+
+          it "sets the tag names" do
+            expect(subject.reload.tag_names).to eq ["foo", "bar"]
+          end
+
+          it "saves the consumer_version_selector_hashes" do
+            expect(subject.reload.consumer_version_selector_hashes).to eq [{ foo: "bar" }]
+          end
+        end
       end
 
       describe "#find" do
         let!(:pact) do
-          builder = TestDataBuilder.new
-          pact = builder
+
+          pact = td
             .create_provider("Provider1")
             .create_consumer("Consumer1")
             .create_consumer_version("1.0.0")
             .create_pact
             .and_return(:pact)
 
-          builder
-            .create_verification(number: 1)
+          td.create_verification(number: 1)
             .create_verification(number: 2, provider_version: "3.7.4")
             .create_consumer_version("1.2.3")
             .create_pact
             .create_verification(number: 1)
 
-            TestDataBuilder.new
-            .create_provider("Provider3")
+          td.create_provider("Provider3")
             .create_consumer("Consumer2")
             .create_consumer_version("1.2.3")
             .create_pact
@@ -62,8 +81,7 @@ module PactBroker
 
       describe "#find_latest_verifications_for_consumer_version" do
         before do
-          TestDataBuilder.new
-            .create_provider("Provider1")
+          td.create_provider("Provider1")
             .create_consumer("Consumer1")
             .create_consumer_version("1.0.0")
             .create_pact
@@ -76,8 +94,7 @@ module PactBroker
             .create_pact
             .create_verification(number: 1, provider_version: "6.5.4")
 
-            TestDataBuilder.new
-            .create_provider("Provider3")
+          td.create_provider("Provider3")
             .create_consumer("Consumer2")
             .create_consumer_version("1.2.3")
             .create_pact
@@ -94,8 +111,7 @@ module PactBroker
 
       describe "#search_for_latest" do
         before do
-          TestDataBuilder.new
-            .create_pact_with_hierarchy("Foo", "1", "Bar")
+          td.create_pact_with_hierarchy("Foo", "1", "Bar")
             .create_verification(provider_version: "2")
             .create_verification(provider_version: "3", number: 2)
             .create_provider("Wiffle")
@@ -131,8 +147,7 @@ module PactBroker
       describe "#find_latest_verification_for" do
         context "when there is a revision" do
           before do
-            TestDataBuilder.new
-              .create_provider("Provider1")
+            td.create_provider("Provider1")
               .create_consumer("Consumer1")
               .create_consumer_version("1.2.3")
               .create_pact
@@ -151,8 +166,7 @@ module PactBroker
         context "when no tag is specified" do
           before do
             PactBroker.configuration.order_versions_by_date = false
-            TestDataBuilder.new
-              .create_provider("Provider1")
+            td.create_provider("Provider1")
               .create_consumer("Consumer1")
               .create_consumer_version("1.2.3")
               .create_pact
@@ -177,8 +191,7 @@ module PactBroker
 
         context "when a tag is specified" do
           before do
-            TestDataBuilder.new
-              .create_provider("Provider1")
+            td.create_provider("Provider1")
               .create_consumer("Consumer1")
               .create_consumer_version("1.0.0")
               .create_consumer_version_tag("prod")
@@ -216,8 +229,7 @@ module PactBroker
 
         context "when the latest untagged verification is required" do
           before do
-            TestDataBuilder.new
-              .create_provider("Provider1")
+            td.create_provider("Provider1")
               .create_consumer("Consumer1")
               .create_consumer_version("1.0.0")
               .create_pact
@@ -249,8 +261,7 @@ module PactBroker
       describe "find_latest_verification_for_tags" do
         context "with no revisions" do
           before do
-            TestDataBuilder.new
-              .create_pact_with_hierarchy("Foo", "1", "Bar")
+            td.create_pact_with_hierarchy("Foo", "1", "Bar")
               .create_consumer_version_tag("feat-x")
               .create_verification(provider_version: "5")
               .use_provider_version("5")
@@ -276,8 +287,7 @@ module PactBroker
           let(:content_2) { { content: 2 }.to_json }
 
           before do
-            TestDataBuilder.new
-              .create_pact_with_hierarchy("Foo", "1", "Bar", content_1)
+            td.create_pact_with_hierarchy("Foo", "1", "Bar", content_1)
               .create_consumer_version_tag("develop")
               .create_verification(provider_version: "5", number: 1, tag_name: "develop", comment: "not this because pact revised")
               .create_verification(provider_version: "6", number: 2, tag_name: "develop", comment: "not this because pact revised")
@@ -319,8 +329,7 @@ module PactBroker
 
       describe "delete_by_provider_version_id" do
         let!(:provider_version) do
-          TestDataBuilder.new
-            .create_consumer
+          td.create_consumer
             .create_provider
             .create_consumer_version
             .create_pact

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

@@ -4,7 +4,6 @@ require "pact_broker/webhooks/execution_configuration"
 require "pact_broker/webhooks/trigger_service"
 
 module PactBroker
-
   module Verifications
     describe Service do
       before do
@@ -20,7 +19,7 @@ module PactBroker
           allow(Service).to receive(:broadcast)
         end
 
-        let(:event_context) { { some: "data" } }
+        let(:event_context) { { some: "data", consumer_version_selectors: [{ foo: "bar" }] } }
         let(:expected_event_context) { { some: "data", provider_version_tags: ["dev"] } }
         let(:params) { { "success" => success, "providerApplicationVersion" => "4.5.6", "wip" => true, "testResults" => { "some" => "results" }} }
         let(:success) { true }
@@ -30,7 +29,8 @@ module PactBroker
             .create_provider_version_tag("dev")
             .and_return(:pact)
         end
-        let(:create_verification) { subject.create 3, params, pact, event_context }
+        let(:selected_pacts) { [PactBroker::Pacts::SelectedPact.new(pact, PactBroker::Pacts::Selectors.new)]}
+        let(:create_verification) { subject.create 3, params, selected_pacts, event_context }
 
         it "logs the creation" do
           expect(logger).to receive(:info).with(/.*verification.*3/, payload: {"providerApplicationVersion"=>"4.5.6", "success"=>true, "wip"=>true})
@@ -43,6 +43,8 @@ module PactBroker
           expect(verification.success).to be true
           expect(verification.number).to eq 3
           expect(verification.test_results).to eq "some" => "results"
+          expect(verification.consumer_version_selector_hashes).to eq [{ foo: "bar" }]
+          expect(verification.tag_names).to eq ["dev"]
         end
 
         it "sets the pact content for the verification" do

data/spec/service_consumers/pact_helper.rb

@@ -17,6 +17,8 @@ Dir.glob(File.join(File.dirname(__FILE__), "provider_states_for*.rb")).each do |
   require path
 end
 
+PactBroker.configuration.base_urls = ["http://example.org"]
+
 pact_broker = PactBroker::App.new { |c| c.database_connection = DB::PACT_BROKER_DB }
 app_to_verify = HalRelationProxyApp.new(pact_broker)
 

data/spec/spec_helper.rb

@@ -5,7 +5,7 @@ return if ENV["REGRESSION"] == "true"
 $: << File.expand_path("../../", __FILE__)
 
 RACK_ENV = ENV["RACK_ENV"] = "test"
-ENV["PACT_BROKER_LOG_LEVEL"] ||= "info"
+ENV["PACT_BROKER_LOG_LEVEL"] ||= "fatal"
 require "spec/support/simplecov"
 
 require "support/logging"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pact_broker
 version: !ruby/object:Gem::Version
-  version: 2.82.0
+  version: 2.83.0
 platform: ruby
 authors:
 - Bethany Skurrie
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-08-14 00:00:00.000000000 Z
+date: 2021-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -577,6 +577,8 @@ files:
 - db/migrations/20210712_add_interaction_count_to_pact_versions.rb
 - db/migrations/20210722_add_index_to_triggered_webhooks_webhook_uuid.rb
 - db/migrations/20210810_set_allow_contract_modification.rb
+- db/migrations/20210815_add_provider_version_id_index_to_verifications.rb
+- db/migrations/20210818_add_consumer_version_selectors_to_verification.rb
 - db/migrations/migration_helper.rb
 - db/test/backwards_compatibility/.rspec
 - db/test/backwards_compatibility/Appraisals
@@ -815,6 +817,7 @@ files:
 - lib/pact_broker/date_helper.rb
 - lib/pact_broker/db.rb
 - lib/pact_broker/db/clean.rb
+- lib/pact_broker/db/clean/selector.rb
 - lib/pact_broker/db/clean_incremental.rb
 - lib/pact_broker/db/data_migrations/delete_deprecated_webhook_executions.rb
 - lib/pact_broker/db/data_migrations/helpers.rb
@@ -1711,7 +1714,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.25
+rubygems_version: 3.2.26
 signing_key: 
 specification_version: 4
 summary: See description