pact_broker 2.40.0 → 2.41.0

data/lib/pact_broker/matrix/head_row.rb

@@ -19,7 +19,9 @@ module PactBroker
       # the query down.
       # This relation relies on consumer_version_tags already being loaded
       one_to_one :latest_verification_for_consumer_version_tag, :class => "PactBroker::Verifications::LatestVerificationForConsumerVersionTag", primary_keys: [], key: [], :eager_loader=>(proc do |eo_opts|
+        # create an index of provider_id/consumer_id/consumer_version_tag_name => row
         tag_to_row = eo_opts[:rows].each_with_object({}) { | row, map | map[[row.provider_id, row.consumer_id, row.consumer_version_tag_name]] = row }
+        # Initialise the association with nil - not sure why?
         eo_opts[:rows].each{|row| row.associations[:latest_verification_for_consumer_version_tag] = nil}
 
         # Need the all then the each to ensure the eager loading works

data/lib/pact_broker/matrix/quick_row.rb

@@ -41,15 +41,15 @@ module PactBroker
       .join(:versions, CONSUMER_VERSION_JOIN, { table_alias: :cv })
       .left_outer_join(:versions, PROVIDER_VERSION_JOIN, { table_alias: :pv } )
 
-    ALIASED_QUERY = Sequel.as(RAW_QUERY, :smart_rows)
+    ALIASED_QUERY = Sequel.as(RAW_QUERY, :quick_rows)
 
     class QuickRow < Sequel::Model(ALIASED_QUERY)
-      CONSUMER_ID = Sequel[:smart_rows][:consumer_id]
-      PROVIDER_ID = Sequel[:smart_rows][:provider_id]
-      CONSUMER_VERSION_ID = Sequel[:smart_rows][:consumer_version_id]
-      PROVIDER_VERSION_ID = Sequel[:smart_rows][:provider_version_id]
-      PACT_PUBLICATION_ID = Sequel[:smart_rows][:pact_publication_id]
-      VERIFICATION_ID = Sequel[:smart_rows][:verification_id]
+      CONSUMER_ID = Sequel[:quick_rows][:consumer_id]
+      PROVIDER_ID = Sequel[:quick_rows][:provider_id]
+      CONSUMER_VERSION_ID = Sequel[:quick_rows][:consumer_version_id]
+      PROVIDER_VERSION_ID = Sequel[:quick_rows][:provider_version_id]
+      PACT_PUBLICATION_ID = Sequel[:quick_rows][:pact_publication_id]
+      VERIFICATION_ID = Sequel[:quick_rows][:verification_id]
 
       associate(:many_to_one, :pact_publication, :class => "PactBroker::Pacts::PactPublication", :key => :pact_publication_id, :primary_key => :id)
       associate(:many_to_one, :provider, :class => "PactBroker::Domain::Pacticipant", :key => :provider_id, :primary_key => :id)

data/lib/pact_broker/matrix/repository.rb

@@ -74,7 +74,7 @@ module PactBroker
       end
 
       def find_compatible_pacticipant_versions selectors
-        find(selectors, latestby: 'cvpv').select{|line| line.success }
+        find(selectors, latestby: 'cvpv').select(&:success)
       end
 
       # If one pacticipant is specified, find all the integrations that involve that pacticipant
@@ -86,9 +86,7 @@ module PactBroker
           .matching_selectors(resolved_specified_selectors)
           .distinct
           .all
-          .collect do |row |
-            row.to_hash
-          end
+          .collect(&:to_hash)
           .uniq
           .collect do | hash |
             required = is_a_row_for_this_integration_required?(specified_pacticipant_names, hash[:consumer_name])

data/lib/pact_broker/pacticipants/repository.rb

@@ -55,7 +55,7 @@ module PactBroker
       end
 
       def pacticipant_names
-        PactBroker::Domain::Pacticipant.select(:name).order(:name).collect{ | pacticipant| pacticipant.name }
+        PactBroker::Domain::Pacticipant.select(:name).order(:name).collect(&:name)
       end
 
       def delete_if_orphan(pacticipant)

data/lib/pact_broker/pacts/pact_publication.rb

@@ -1,6 +1,8 @@
 require 'pact_broker/domain/pact'
 require 'pact_broker/pacts/pact_version'
 require 'pact_broker/repositories/helpers'
+require 'pact_broker/integrations/integration'
+require 'pact_broker/tags/head_pact_tags'
 
 module PactBroker
   module Pacts
@@ -16,6 +18,9 @@ module PactBroker
       associate(:many_to_one, :consumer, :class => "PactBroker::Domain::Pacticipant", :key => :consumer_id, :primary_key => :id)
       associate(:many_to_one, :consumer_version, :class => "PactBroker::Domain::Version", :key => :consumer_version_id, :primary_key => :id)
       associate(:many_to_one, :pact_version, class: "PactBroker::Pacts::PactVersion", :key => :pact_version_id, :primary_key => :id)
+      associate(:many_to_one, :integration, class: "PactBroker::Integrations::Integration", key: [:consumer_id, :provider_id], primary_key: [:consumer_id, :provider_id])
+      one_to_one(:latest_verification, class: "PactBroker::Verifications::LatestVerificationForPactVersion", key: :pact_version_id, primary_key: :pact_version_id)
+      one_to_many(:head_pact_tags, class: "PactBroker::Tags::HeadPactTag", primary_key: :id, key: :pact_publication_id)
 
       dataset_module do
         include PactBroker::Repositories::Helpers
@@ -49,21 +54,39 @@ module PactBroker
         PactBroker::Domain::Pact.new(
           id: id,
           provider: provider,
-          consumer: consumer_version.pacticipant,
+          consumer: consumer,
           consumer_version_number: consumer_version.number,
           consumer_version: to_version_domain,
           revision_number: revision_number,
           json_content: pact_version.content,
           pact_version_sha: pact_version.sha,
-          latest_verification: latest_verification,
+          latest_verification: nil,
+          created_at: created_at,
+          head_tag_names: [],
+          db_model: self
+          )
+      end
+
+      def to_domain_lightweight
+        PactBroker::Domain::Pact.new(
+          id: id,
+          provider: provider,
+          consumer: consumer,
+          consumer_version_number: consumer_version.number,
+          consumer_version: to_version_domain_lightweight,
+          revision_number: revision_number,
+          pact_version_sha: pact_version.sha,
           created_at: created_at,
-          head_tag_names: head_tag_names,
           db_model: self
           )
       end
 
       def to_version_domain
-        OpenStruct.new(number: consumer_version.number, pacticipant: consumer_version.pacticipant, tags: consumer_version.tags, order: consumer_version.order)
+        OpenStruct.new(number: consumer_version.number, pacticipant: consumer, tags: consumer_version.tags, order: consumer_version.order)
+      end
+
+      def to_version_domain_lightweight
+        OpenStruct.new(number: consumer_version.number, pacticipant: consumer, order: consumer_version.order)
       end
 
       def upsert

data/lib/pact_broker/pacts/repository.rb

@@ -125,29 +125,21 @@ module PactBroker
         end
       end
 
-      def find_wip_pact_versions_for_provider provider_name, provider_tags = []
+      def find_wip_pact_versions_for_provider provider_name, provider_tags = [], options = {}
         return [] if provider_tags.empty?
-        successfully_verified_pact_publication_ids_for_each_tag = provider_tags.collect do | provider_tag |
-          ids = LatestTaggedPactPublications
-            .join(:verifications, { pact_version_id: :pact_version_id })
-            .join(:tags, { Sequel[:verifications][:provider_version_id] => Sequel[:provider_tags][:version_id] }, {table_alias: :provider_tags})
-            .where(Sequel[:provider_tags][:name] => provider_tag)
-            .provider(provider_name)
-            .where(Sequel[:verifications][:success] => true)
-            .select(Sequel[:latest_tagged_pact_publications][:id].as(:id))
-            .collect(&:id)
-          [provider_tag, ids]
-        end
 
-        successfully_verified_pact_publication_ids_for_all_tags = successfully_verified_pact_publication_ids_for_each_tag.collect(&:last).reduce(:&)
-        pact_publication_ids = LatestTaggedPactPublications.provider(provider_name).exclude(id: successfully_verified_pact_publication_ids_for_all_tags).select_for_subquery(:id)
+        # Hash of provider tag names => list of pact_publication_ids
+        successfully_verified_head_pact_publication_ids_for_each_provider_tag = find_successfully_verified_head_pacts_by_provider_tag(provider_name, provider_tags, options)
+
+        pact_publication_ids = find_head_pacts_that_have_not_been_successfully_verified_by_all_provider_tags(
+          provider_name,
+          successfully_verified_head_pact_publication_ids_for_each_provider_tag.values.reduce(:&),
+          options)
 
         pacts = AllPactPublications.where(id: pact_publication_ids).order_ignore_case(:consumer_name).order_append(:consumer_version_order).collect(&:to_domain)
         pacts.collect do | pact|
-          pending_tags = successfully_verified_pact_publication_ids_for_each_tag.select do | (provider_tag, pact_publication_ids) |
-           !pact_publication_ids.include?(pact.id)
-          end.collect(&:first)
-          VerifiablePact.new(pact, true, pending_tags, [], pact.consumer_version_tag_names)
+          pending_tags = find_provider_tags_for_which_pact_publication_id_is_pending(pact.id, successfully_verified_head_pact_publication_ids_for_each_provider_tag)
+          VerifiablePact.new(pact, true, pending_tags, [], pact.consumer_version_tag_names, nil, true)
         end
       end
 
@@ -340,6 +332,37 @@ module PactBroker
         query = query.tag(options[:tag]) if options[:tag]
         query
       end
+
+      def find_provider_tags_for_which_pact_publication_id_is_pending(pact_publication_id, successfully_verified_head_pact_publication_ids_for_each_provider_tag)
+        successfully_verified_head_pact_publication_ids_for_each_provider_tag
+          .select do | provider_tag, pact_publication_ids |
+            !pact_publication_ids.include?(pact_publication_id)
+          end.keys
+      end
+
+      def find_head_pacts_that_have_not_been_successfully_verified_by_all_provider_tags(provider_name, pact_publication_ids_successfully_verified_by_all_provider_tags, options)
+        # Exclude the head pacts that have been successfully verified by all the specified provider tags
+        pact_publication_ids = LatestTaggedPactPublications
+          .provider(provider_name)
+          .exclude(id: pact_publication_ids_successfully_verified_by_all_provider_tags)
+          .where(Sequel.lit('latest_tagged_pact_publications.created_at > ?', options.fetch(:include_wip_pacts_since)))
+          .select_for_subquery(:id)
+      end
+
+      def find_successfully_verified_head_pacts_by_provider_tag(provider_name, provider_tags, options)
+        provider_tags.compact.each_with_object({}) do | provider_tag, tag_to_ids_hash |
+          ids = LatestTaggedPactPublications
+            .join(:verifications, { pact_version_id: :pact_version_id })
+            .join(:tags, { Sequel[:verifications][:provider_version_id] => Sequel[:provider_tags][:version_id] }, {table_alias: :provider_tags})
+            .where(Sequel[:provider_tags][:name] => provider_tag)
+            .provider(provider_name)
+            .where(Sequel[:verifications][:success] => true)
+            .where(Sequel.lit('latest_tagged_pact_publications.created_at > ?', options.fetch(:include_wip_pacts_since)))
+            .select(Sequel[:latest_tagged_pact_publications][:id].as(:id))
+            .collect(&:id)
+          tag_to_ids_hash[provider_tag] = ids
+        end
+      end
     end
   end
 end

data/lib/pact_broker/pacts/service.rb

@@ -62,7 +62,9 @@ module PactBroker
         consumer_version = version_repository.find_by_pacticipant_id_and_number_or_create consumer.id, params[:consumer_version_number]
         existing_pact = pact_repository.find_by_version_and_provider(consumer_version.id, provider.id)
 
-        params.merge!(json_content: Merger.merge_pacts(existing_pact.json_content, params[:json_content]))
+        params[:json_content] = Merger.merge_pacts(
+          existing_pact.json_content, params[:json_content]
+        )
 
         update_pact params, existing_pact, webhook_options
       end
@@ -113,18 +115,36 @@ module PactBroker
         distinct
       end
 
-      def find_for_verification(provider_name, provider_version_tags, consumer_version_selectors)
-        pact_repository
+      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)
           end
+
+        verifiable_wip_pacts = if options[:include_wip_pacts_since]
+          exclude_specified_pacts(
+            pact_repository.find_wip_pact_versions_for_provider(provider_name, provider_version_tags, options),
+            verifiable_pacts_specified_in_request)
+        else
+          []
+        end
+
+        verifiable_pacts_specified_in_request + verifiable_wip_pacts
       end
 
       private
 
+      def exclude_specified_pacts(wip_pacts, specified_pacts)
+        wip_pacts.select do | wip_pact |
+          !specified_pacts.any? do | specified_pacts |
+            wip_pact.pact_version_sha == specified_pacts.pact_version_sha
+          end
+        end
+      end
+
       # Overwriting an existing pact with the same consumer/provider/consumer version number
       def update_pact params, existing_pact, webhook_options
         logger.info "Updating existing pact publication with params #{params.reject{ |k, v| k == :json_content}}"

data/lib/pact_broker/pacts/verifiable_pact.rb

@@ -3,15 +3,17 @@ require 'delegate'
 module PactBroker
   module Pacts
     class VerifiablePact < SimpleDelegator
-      attr_reader :pending, :pending_provider_tags, :non_pending_provider_tags, :head_consumer_tags
+      attr_reader :pending, :pending_provider_tags, :non_pending_provider_tags, :head_consumer_tags, :wip
 
-      def initialize(pact, pending, pending_provider_tags = [], non_pending_provider_tags = [], head_consumer_tags = [], overall_latest = false)
+      # TODO refactor this constructor
+      def initialize(pact, pending, pending_provider_tags = [], non_pending_provider_tags = [], head_consumer_tags = [], overall_latest = false, wip = false)
         super(pact)
         @pending = pending
         @pending_provider_tags = pending_provider_tags
         @non_pending_provider_tags = non_pending_provider_tags
         @head_consumer_tags = head_consumer_tags
         @overall_latest = overall_latest
+        @wip = wip
       end
 
       def consumer_tags
@@ -25,6 +27,10 @@ module PactBroker
       def pending?
         pending
       end
+
+      def wip?
+        wip
+      end
     end
   end
 end

data/lib/pact_broker/pacts/verifiable_pact_messages.rb

@@ -3,28 +3,34 @@ module PactBroker
     class VerifiablePactMessages
       extend Forwardable
 
-      READ_MORE = "Read more at https://pact.io/pending"
+      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?] => :verifiable_pact
+      delegate [:consumer_name, :provider_name, :head_consumer_tags, :pending_provider_tags, :non_pending_provider_tags, :pending?, :wip?] => :verifiable_pact
 
       def initialize(verifiable_pact)
         @verifiable_pact = verifiable_pact
       end
 
       def inclusion_reason
-        if head_consumer_tags.any?
-          version_text = head_consumer_tags.size == 1 ? "version" : "versions"
-          "This pact is being verified because it is the pact for the latest #{version_text} of Foo tagged with #{joined_head_consumer_tags}"
+        version_text = head_consumer_tags.size == 1 ? "version" : "versions"
+        if wip?
+          # WIP pacts will always have tags, because it is part of the definition of being a WIP pact
+          "This pact is being verified because it is a 'work in progress' pact (ie. it is the pact for the latest #{version_text} of Foo tagged with #{joined_head_consumer_tags} and is still in pending state). #{READ_MORE_WIP}"
         else
-          "This pact is being verified because it is the latest pact between #{consumer_name} and #{provider_name}."
+          if head_consumer_tags.any?
+            "This pact is being verified because it is the pact for the latest #{version_text} of Foo tagged with #{joined_head_consumer_tags}"
+          else
+            "This pact is being verified because it is the latest pact between #{consumer_name} and #{provider_name}."
+          end
         end
       end
 
       def pending_reason
         if pending?
-          "This pact is in pending state because it has not yet been successfully verified by #{pending_provider_tags_description}. If this verification fails, it will not cause the overall build to fail. #{READ_MORE}"
+          "This pact is in pending state because it has not yet been successfully verified by #{pending_provider_tags_description}. If this verification fails, it will not cause the overall build to fail. #{READ_MORE_PENDING}"
         else
-          "This pact has previously been successfully verified by #{non_pending_provider_tags_description}. If this verification fails, it will fail the build. #{READ_MORE}"
+          "This pact has previously been successfully verified by #{non_pending_provider_tags_description}. If this verification fails, it will fail the build. #{READ_MORE_PENDING}"
         end
       end
 

data/lib/pact_broker/string_refinements.rb

@@ -8,6 +8,41 @@ module PactBroker
       def blank?
         self.strip.size == 0
       end
+
+      # ripped from rubyworks/facets, thank you
+      def snakecase
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+        .gsub(/([a-z\d])([A-Z])/,'\1_\2')
+        .tr('-', '_')
+        .gsub(/\s/, '_')
+        .gsub(/__+/, '_')
+        .downcase
+      end
+
+      # ripped from rubyworks/facets, thank you
+      def camelcase(*separators)
+        case separators.first
+        when Symbol, TrueClass, FalseClass, NilClass
+          first_letter = separators.shift
+        end
+
+        separators = ['_', '\s'] if separators.empty?
+
+        str = self.dup
+
+        separators.each do |s|
+          str = str.gsub(/(?:#{s}+)([a-z])/){ $1.upcase }
+        end
+
+        case first_letter
+        when :upper, true
+          str = str.gsub(/(\A|\s)([a-z])/){ $1 + $2.upcase }
+        when :lower, false
+          str = str.gsub(/(\A|\s)([A-Z])/){ $1 + $2.downcase }
+        end
+
+        str
+      end
     end
   end
-end
+end

data/lib/pact_broker/tags/head_pact_tags.rb

@@ -0,0 +1,12 @@
+require 'pact_broker/db'
+require 'pact_broker/repositories/helpers'
+
+module PactBroker
+  module Tags
+    class HeadPactTag < Sequel::Model
+      dataset_module do
+        include PactBroker::Repositories::Helpers
+      end
+    end
+  end
+end

data/lib/pact_broker/tags/tag_with_latest_flag.rb

@@ -5,7 +5,6 @@ module PactBroker
   module Tags
     # The tag associated with the latest verification for a given tag
     class TagWithLatestFlag < Sequel::Model(:tags_with_latest_flag)
-
       dataset_module do
         include PactBroker::Repositories::Helpers
       end

data/lib/pact_broker/test/test_data_builder.rb

@@ -203,7 +203,7 @@ module PactBroker
       def republish_same_pact params = {}
         params.delete(:comment)
         last_pact_version = PactBroker::Pacts::PactVersion.order(:id).last
-        create_pact json_content: last_pact_version.content
+        create_pact pact_version_sha: last_pact_version.sha, json_content: last_pact_version.content, created_at: params[:created_at]
         self
       end
 

data/lib/pact_broker/ui/controllers/index.rb

@@ -14,9 +14,30 @@ module PactBroker
           if params[:tags]
             tags = params[:tags] == 'true' ? true : [*params[:tags]].compact
           end
-          view_model = ViewDomain::IndexItems.new(index_service.find_index_items(tags: tags))
+          page_number = params[:page]&.to_i || 1
+          # Make page size smaller for data intensive query
+          page_size = params[:pageSize]&.to_i || (tags == true ? 30 : 100)
+          options = {
+            tags: tags,
+            page_number: page_number,
+            page_size: page_size
+          }
+
+          # TODO remove this code when verified
+          options[:optimised] = true unless params[:optimised] == 'false'
+          index_items = ViewDomain::IndexItems.new(index_service.find_index_items(options))
+
           page = tags ? :'index/show-with-tags' : :'index/show'
-          haml page, {locals: {index_items: view_model, title: "Pacts"}, layout: :'layouts/main'}
+          locals = {
+            title: "Pacts",
+            index_items: index_items,
+            page_number: page_number,
+            page_size: page_size,
+            pagination_record_count: index_items.pagination_record_count,
+            current_page_size: index_items.size
+          }
+
+          haml page, {locals: locals, layout: :'layouts/main'}
         end
 
         def set_headers

data/lib/pact_broker/ui/view_models/index_item.rb

@@ -27,6 +27,10 @@ module PactBroker
           PactBroker::Versions::AbbreviateNumber.call(@relationship.consumer_version_number)
         end
 
+        def consumer_version_order
+          @relationship.consumer_version_order
+        end
+
         def provider_version_number
           PactBroker::Versions::AbbreviateNumber.call(@relationship.provider_version_number)
         end
@@ -164,7 +168,9 @@ module PactBroker
         def <=> other
           comp = consumer_name.downcase <=> other.consumer_name.downcase
           return comp unless comp == 0
-          provider_name.downcase <=> other.provider_name.downcase
+          comp = provider_name.downcase <=> other.provider_name.downcase
+          return comp unless comp == 0
+          other.consumer_version_order <=> consumer_version_order
         end
 
         def short_version_number version_number