pact_broker 2.15.0 → 2.16.0

data/lib/pact_broker/domain/index_item.rb

@@ -5,9 +5,9 @@ module PactBroker
   module Domain
     class IndexItem
 
-      attr_reader :consumer, :provider, :latest_pact, :latest_verification, :webhooks
+      attr_reader :consumer, :provider, :latest_pact, :latest_verification, :webhooks, :triggered_webhooks, :latest_verification_latest_tags
 
-      def initialize consumer, provider, latest_pact = nil, latest = true, latest_verification = nil, webhooks = [], triggered_webhooks = [], tags = []
+      def initialize consumer, provider, latest_pact = nil, latest = true, latest_verification = nil, webhooks = [], triggered_webhooks = [], tags = [], latest_verification_latest_tags = []
         @consumer = consumer
         @provider = provider
         @latest_pact = latest_pact
@@ -16,10 +16,11 @@ module PactBroker
         @webhooks = webhooks
         @triggered_webhooks = triggered_webhooks
         @tags = tags
+        @latest_verification_latest_tags = latest_verification_latest_tags
       end
 
-      def self.create consumer, provider, latest_pact, latest, latest_verification, webhooks = [], triggered_webhooks = [], tags = []
-        new consumer, provider, latest_pact, latest, latest_verification, webhooks, triggered_webhooks, tags
+      def self.create consumer, provider, latest_pact, latest, latest_verification, webhooks = [], triggered_webhooks = [], tags = [], latest_verification_latest_tags = []
+        new consumer, provider, latest_pact, latest, latest_verification, webhooks, triggered_webhooks, tags, latest_verification_latest_tags
       end
 
       def eq? other
@@ -54,10 +55,20 @@ module PactBroker
         @latest_pact.consumer_version_number
       end
 
+      def consumer_version
+        @latest_pact.consumer_version
+      end
+
+      def provider_version
+        @latest_verification ? @latest_verification.provider_version : nil
+      end
+
       def provider_version_number
         @latest_verification ? @latest_verification.provider_version_number : nil
       end
 
+      # these are the consumer tag names for which this pact publication
+      # is the latest with that tag
       def tag_names
         @tags
       end
@@ -117,7 +128,7 @@ module PactBroker
       end
 
       def to_s
-        "Pact between #{consumer_name} and #{provider_name}"
+        "Pact between #{consumer_name} #{consumer_version_number} and #{provider_name} #{provider_version_number}"
       end
 
       def to_a

data/lib/pact_broker/index/service.rb

@@ -1,6 +1,8 @@
 require 'pact_broker/repositories'
 require 'pact_broker/logging'
 require 'pact_broker/domain/index_item'
+require 'pact_broker/matrix/latest_row'
+require 'pact_broker/matrix/head_row'
 
 module PactBroker
 
@@ -12,10 +14,73 @@ module PactBroker
       extend PactBroker::Logging
 
       def self.find_index_items options = {}
-        pact_repository
-          .find_latest_pacts
-          .collect { | pact| build_index_item_rows(pact, tags_for(pact, options)) }
-          .flatten
+        rows = []
+        overall_latest_publication_ids = nil
+
+        rows = PactBroker::Matrix::HeadRow
+          .select_all_qualified
+          .eager(:latest_triggered_webhooks)
+          .eager(:webhooks)
+          .order(:consumer_name, :provider_name)
+          .eager(:consumer_version_tags)
+          .eager(:provider_version_tags)
+
+        if !options[:tags]
+          rows = rows.where(consumer_version_tag_name: nil).all
+          overall_latest_publication_ids = rows.collect(&:pact_publication_id)
+        end
+
+        if options[:tags]
+          if options[:tags].is_a?(Array)
+            rows = rows.where(consumer_version_tag_name: options[:tags]).or(consumer_version_tag_name: nil)
+          end
+
+          rows = rows.all
+          overall_latest_publication_ids = rows.select{|r| !r[:consumer_version_tag_name] }.collect(&:pact_publication_id).uniq
+
+          # Smoosh all the rows with matching pact publications together
+          # and collect their consumer_head_tag_names
+          rows = rows
+            .group_by(&:pact_publication_id)
+            .values
+            .collect{|group| [group.last, group.collect{|r| r[:consumer_version_tag_name]}.compact] }
+            .collect{ |(row, tag_names)| row.consumer_head_tag_names = tag_names; row }
+        end
+
+        index_items = []
+        rows.sort.each do | row |
+          tag_names = []
+          if options[:tags]
+            tag_names = row.consumer_version_tags.collect(&:name)
+          end
+
+          overall_latest = overall_latest_publication_ids.include?(row.pact_publication_id)
+          latest_verification = if overall_latest
+            verification_repository.find_latest_verification_for row.consumer_name, row.provider_name
+          else
+            tag_names.collect do | tag_name |
+              verification_repository.find_latest_verification_for row.consumer_name, row.provider_name, tag_name
+            end.compact.sort do | v1, v2 |
+              # Some provider versions have nil orders, not sure why
+              # Sort by execution_date instead of order
+              v1.execution_date <=> v2.execution_date
+            end.last
+          end
+
+          index_items << PactBroker::Domain::IndexItem.create(
+            row.consumer,
+            row.provider,
+            row.pact,
+            overall_latest,
+            latest_verification,
+            row.webhooks,
+            row.latest_triggered_webhooks,
+            row.consumer_head_tag_names,
+            row.provider_version_tags.select(&:latest?)
+          )
+        end
+
+        index_items
       end
 
       def self.tags_for(pact, options)

data/lib/pact_broker/matrix/head_row.rb

@@ -0,0 +1,11 @@
+require 'pact_broker/matrix/row'
+
+module PactBroker
+  module Matrix
+    # A row for each of the overall latest pacts, and a row for each of the latest tagged pacts
+    # Rows with a nil consumer_tag_name are the overall latest
+    class HeadRow < Row
+      set_dataset(:materialized_head_matrix)
+    end
+  end
+end

data/lib/pact_broker/matrix/latest_row.rb

@@ -2,23 +2,9 @@ require 'pact_broker/matrix/row'
 
 module PactBroker
   module Matrix
-    # Latest pact revision for each consumer version => latest verification
+    # Latest pact revision for each consumer version => latest verification for each provider version
     class LatestRow < Row
-      set_dataset(:latest_matrix)
-
-      # For some reason, with MySQL, the success column value
-      # comes back as an integer rather than a boolean
-      # for the latest_matrix view (but not the matrix view!)
-      # Maybe something to do with the union?
-      # Haven't investigated as this is an easy enough fix.
-      def success
-        value = super
-        value.nil? ? nil : value == true || value == 1
-      end
-
-      def values
-        super.merge(success: success)
-      end
+      set_dataset(:latest_matrix_for_consumer_version_and_provider_version)
     end
   end
 end

data/lib/pact_broker/matrix/repository.rb

@@ -1,8 +1,10 @@
 require 'pact_broker/repositories/helpers'
 require 'pact_broker/matrix/row'
 require 'pact_broker/matrix/latest_row'
+require 'pact_broker/matrix/head_row'
 require 'pact_broker/error'
 
+
 module PactBroker
   module Matrix
 
@@ -14,56 +16,84 @@ module PactBroker
 
       # TODO move latest verification logic in to database
 
+      TP_COLS = PactBroker::Matrix::Row::TP_COLS
+
       GROUP_BY_PROVIDER_VERSION_NUMBER = [:consumer_name, :consumer_version_number, :provider_name, :provider_version_number]
       GROUP_BY_PROVIDER = [:consumer_name, :consumer_version_number, :provider_name]
       GROUP_BY_PACT = [:consumer_name, :provider_name]
 
+      def refresh params
+        PactBroker::Matrix::Row.refresh(params)
+        PactBroker::Matrix::HeadRow.refresh(params)
+      end
+
       # Return the latest matrix row (pact/verification) for each consumer_version_number/provider_version_number
       def find selectors, options = {}
-        # The group with the nil provider_version_numbers will be the results of the left outer join
-        # that don't have verifications, so we need to include them all.
         lines = query_matrix(resolve_selectors(selectors, options), options)
         lines = apply_latestby(options, selectors, lines)
 
+        # This needs to be done after the latestby, so can't be done in the db unless
+        # the latestby logic is moved to the db
         if options.key?(:success)
           lines = lines.select{ |l| options[:success].include?(l.success) }
         end
 
-        lines.sort.collect(&:values)
+        lines.sort
       end
 
-      def apply_latestby options, selectors, lines
-        return lines unless options[:latestby] == 'cvp' || options[:latestby] == 'cp'
 
+
+      def apply_latestby options, selectors, lines
+        return lines unless options[:latestby]
         group_by_columns = case options[:latestby]
+        when 'cvpv' then GROUP_BY_PROVIDER_VERSION_NUMBER
         when 'cvp' then GROUP_BY_PROVIDER
         when 'cp' then GROUP_BY_PACT
         end
 
-        lines.group_by{|line| group_by_columns.collect{|key| line.send(key) }}
+        # The group with the nil provider_version_numbers will be the results of the left outer join
+        # that don't have verifications, so we need to include them all.
+        remove_overwritten_revisions(lines).group_by{|line| group_by_columns.collect{|key| line.send(key) }}
           .values
           .collect{ | lines | lines.first.provider_version_number.nil? ? lines : lines.first }
           .flatten
       end
 
+      def remove_overwritten_revisions lines
+        latest_revisions_keys = {}
+        latest_revisions = []
+        lines.each do | line |
+          key = "#{line.consumer_name}-#{line.provider_name}-#{line.consumer_version_number}"
+          if !latest_revisions_keys.key?(key) || latest_revisions_keys[key] == line.pact_revision_number
+            latest_revisions << line
+            latest_revisions_keys[key] ||= line.pact_revision_number
+          end
+        end
+        latest_revisions
+      end
+
       def find_for_consumer_and_provider pacticipant_1_name, pacticipant_2_name
         selectors = [{ pacticipant_name: pacticipant_1_name }, { pacticipant_name: pacticipant_2_name }]
         options = { latestby: 'cvpv' }
-        query_matrix(resolve_selectors(selectors, options), options).sort.collect(&:values)
+        find(selectors, options)
       end
 
       def find_compatible_pacticipant_versions selectors
-        find(selectors, latestby: 'cvpv').select{|line| line[:success] }
+        find(selectors, latestby: 'cvpv').select{|line| line.success }
       end
 
       def query_matrix selectors, options
         query = view_for(options).select_all.matching_selectors(selectors)
         query = query.limit(options[:limit]) if options[:limit]
-        query.order_by_names_ascending_most_recent_first.all
+        query
+          .order_by_names_ascending_most_recent_first
+          .eager(:consumer_version_tags)
+          .eager(:provider_version_tags)
+          .all
       end
 
       def view_for(options)
-        options[:latestby] ? LatestRow : Row
+        Row
       end
 
       def resolve_selectors(selectors, options)
@@ -95,8 +125,23 @@ module PactBroker
               pacticipant_version_number: version.number
             }
           else
-            selector
+            selector.dup
+          end
+        end.collect do | selector |
+          if selector[:pacticipant_name]
+            pacticipant = PactBroker::Domain::Pacticipant.find(name: selector[:pacticipant_name])
+            selector[:pacticipant_id] = pacticipant ? pacticipant.id : nil
+          end
+
+          if selector[:pacticipant_name] && selector[:pacticipant_version_number]
+            version = version_repository.find_by_pacticipant_name_and_number(selector[:pacticipant_name], selector[:pacticipant_version_number])
+            selector[:pacticipant_version_id] = version ? version.id : nil
+          end
+
+          if selector[:pacticipant_version_number].nil?
+            selector[:pacticipant_version_id] = nil
           end
+          selector
         end
       end
 

data/lib/pact_broker/matrix/row.rb

@@ -1,11 +1,61 @@
 require 'pact_broker/repositories/helpers'
+require 'pact_broker/webhooks/latest_triggered_webhook'
+require 'pact_broker/tags/tag_with_latest_flag'
+require 'pact_broker/logging'
 
 module PactBroker
   module Matrix
-    class Row < Sequel::Model(:matrix)
+    class Row < Sequel::Model(:materialized_matrix)
+
+      # Used when using table_print to output query results
+      TP_COLS = [ :consumer_version_number, :pact_revision_number, :provider_version_number, :verification_number]
+
+      associate(:one_to_many, :latest_triggered_webhooks, :class => "PactBroker::Webhooks::LatestTriggeredWebhook", primary_key: :pact_publication_id, key: :pact_publication_id)
+      associate(:one_to_many, :webhooks, :class => "PactBroker::Webhooks::Webhook", primary_key: [:consumer_id, :provider_id], key: [:consumer_id, :provider_id])
+      associate(:one_to_many, :consumer_version_tags, :class => "PactBroker::Tags::TagWithLatestFlag", primary_key: :consumer_version_id, key: :version_id)
+      associate(:one_to_many, :provider_version_tags, :class => "PactBroker::Tags::TagWithLatestFlag", primary_key: :provider_version_id, key: :version_id)
 
       dataset_module do
         include PactBroker::Repositories::Helpers
+        include PactBroker::Logging
+
+        def refresh params
+          logger.debug("Refreshing #{model.table_name} for #{params}")
+
+          db = model.db
+          table_name = model.table_name
+
+          source_view_name = model.table_name.to_s.gsub('materialized_', '').to_sym
+          if params[:consumer_name] || params[:provider_name]
+            criteria = {}
+            if params[:consumer_name]
+              pacticipant = PactBroker::Domain::Pacticipant.where(name_like(:name, params[:consumer_name])).single_record
+              criteria[:consumer_id] = pacticipant.id if pacticipant
+            end
+
+            if params[:provider_name]
+              pacticipant = PactBroker::Domain::Pacticipant.where(name_like(:name, params[:provider_name])).single_record
+              criteria[:provider_id] = pacticipant.id if pacticipant
+            end
+            if criteria.any?
+              db.transaction do
+                db[table_name].where(criteria).delete
+                db[table_name].insert(db[source_view_name].where(criteria).distinct)
+              end
+            end
+          end
+
+          if params[:pacticipant_name]
+            pacticipant = PactBroker::Domain::Pacticipant.where(name_like(:name, params[:pacticipant_name])).single_record
+            if pacticipant
+              db.transaction do
+                db[table_name].where(consumer_id: pacticipant.id).or(provider_id: pacticipant.id).delete
+                new_rows = db[source_view_name].where(consumer_id: pacticipant.id).or(provider_id: pacticipant.id).distinct
+                db[table_name].insert(new_rows)
+              end
+            end
+          end
+        end
 
         def matching_selectors selectors
           if selectors.size == 1
@@ -19,11 +69,24 @@ module PactBroker
           where{
             Sequel.&(
               Sequel.|(
-                *selectors.collect{ |s| s[:pacticipant_version_number] ? Sequel.&(consumer_name: s[:pacticipant_name], consumer_version_number: s[:pacticipant_version_number]) :  Sequel.&(consumer_name: s[:pacticipant_name]) }
+                *selectors.collect do |s|
+                  if s[:pacticipant_version_id]
+                    Sequel.&(consumer_id: s[:pacticipant_id], consumer_version_id: s[:pacticipant_version_id])
+                  else
+                    Sequel.&(consumer_id: s[:pacticipant_id])
+                  end
+                end
               ),
               Sequel.|(
-                *(selectors.collect{ |s| s[:pacticipant_version_number] ? Sequel.&(provider_name: s[:pacticipant_name], provider_version_number: s[:pacticipant_version_number]) :  Sequel.&(provider_name: s[:pacticipant_name]) } +
-                  selectors.collect{ |s| Sequel.&(provider_name: s[:pacticipant_name], provider_version_number: nil) })
+                *(selectors.collect do |s|
+                  if s[:pacticipant_version_id]
+                    Sequel.&(provider_id: s[:pacticipant_id], provider_version_id: s[:pacticipant_version_id])
+                  else
+                    Sequel.&(provider_id: s[:pacticipant_id])
+                  end
+                end + selectors.collect do |s|
+                  Sequel.&(provider_id: s[:pacticipant_id], provider_version_id: nil)
+                end)
               )
             )
           }
@@ -32,8 +95,8 @@ module PactBroker
         def where_consumer_or_provider_is s
           where{
             Sequel.|(
-              s[:pacticipant_version_number] ? Sequel.&(consumer_name: s[:pacticipant_name], consumer_version_number: s[:pacticipant_version_number]) :  Sequel.&(consumer_name: s[:pacticipant_name]),
-              s[:pacticipant_version_number] ? Sequel.&(provider_name: s[:pacticipant_name], provider_version_number: s[:pacticipant_version_number]) :  Sequel.&(provider_name: s[:pacticipant_name])
+              s[:pacticipant_version_id] ? Sequel.&(consumer_id: s[:pacticipant_id], consumer_version_id: s[:pacticipant_version_id]) :  Sequel.&(consumer_id: s[:pacticipant_id]),
+              s[:pacticipant_version_id] ? Sequel.&(provider_id: s[:pacticipant_id], provider_version_id: s[:pacticipant_version_id]) :  Sequel.&(provider_id: s[:pacticipant_id])
             )
           }
         end
@@ -49,10 +112,81 @@ module PactBroker
         end
       end
 
+      # Temporary method while we transition from returning Hashes to return Matrix objects
+      # from the repository find methods
+      # Need to make the object act as a hash and an object
+      def [] key
+        if key == :provider_version_tags || key == :consumer_version_tags
+          send(key)
+        else
+          super
+        end
+      end
+
+      # tags for which this pact publication is the latest of that tag
+      # this is set in the code rather than the database
+      def consumer_head_tag_names
+        @consumer_head_tag_names ||= []
+      end
+
+      def consumer_head_tag_names= consumer_head_tag_names
+        @consumer_head_tag_names = consumer_head_tag_names
+      end
+
+      # def latest_triggered_webhooks
+      #   @latest_triggered_webhooks ||= []
+      # end
+
       def summary
         "#{consumer_name}#{consumer_version_number} #{provider_name}#{provider_version_number || '?'} (r#{pact_revision_number}n#{verification_number || '?'})"
       end
 
+      def consumer
+        @consumer ||= OpenStruct.new(name: consumer_name, id: consumer_id)
+      end
+
+      def provider
+        @provider ||= OpenStruct.new(name: provider_name, id: provider_id)
+      end
+
+      def consumer_version
+        @consumer_version ||= OpenStruct.new(number: consumer_version_number, id: consumer_version_id, pacticipant: consumer)
+      end
+
+      def provider_version
+        if provider_version_number
+          @provider_version ||= OpenStruct.new(number: provider_version_number, id: provider_version_id, pacticipant: provider)
+        end
+      end
+
+      def pact
+        @pact ||= OpenStruct.new(consumer: consumer,
+          provider: provider,
+          consumer_version: consumer_version,
+          consumer_version_number: consumer_version_number,
+          created_at: pact_created_at,
+          revision_number: pact_revision_number,
+          pact_version_sha: pact_version_sha
+        )
+      end
+
+      def latest_verification
+        if verification_executed_at
+          @latest_verification ||= OpenStruct.new(
+            id: verification_id,
+            success: success,
+            number: verification_number,
+            execution_date: verification_executed_at,
+            created_at: verification_executed_at,
+            provider_version_number: provider_version_number,
+            build_url: verification_build_url,
+            provider_version: provider_version,
+            consumer_name: consumer_name,
+            provider_name: provider_name
+          )
+        end
+      end
+
       # Add logic for ignoring case
       def <=> other
         comparisons = [
@@ -72,6 +206,10 @@ module PactBroker
         name1 <=> name2
       end
 
+      def to_s
+        "#{consumer_name} v#{consumer_version_number} #{provider_name} #{provider_version_number} #{success}"
+      end
+
       def compare_number_desc number1, number2
         if number1 && number2
           number2 <=> number1
@@ -81,6 +219,28 @@ module PactBroker
           -1
         end
       end
+
+      # For some reason, with MySQL, the success column value
+      # comes back as an integer rather than a boolean
+      # for the latest_matrix view (but not the matrix view!)
+      # Maybe something to do with the union?
+      # Haven't investigated as this is an easy enough fix.
+      def success
+        value = super
+        value.nil? ? nil : value == true || value == 1
+      end
+
+      def values
+        super.merge(success: success)
+      end
+
+      # Need to overwrite eql? from lib/sequel/model/base.rb
+      # because it uses @values instead of self.values
+      # so the success boolean/integer problem mentioned above
+      # screws things up
+      def eql?(obj)
+        (obj.class == model) && (obj.values == values)
+      end
     end
   end
 end