pact_broker 2.82.0 → 2.85.1

data/lib/pact_broker/domain/index_item.rb

@@ -5,23 +5,25 @@ module PactBroker
   module Domain
     class IndexItem
       attr_reader :consumer,
-        :provider,
-        :latest_pact,
-        :latest_verification,
-        :webhooks,
-        :triggered_webhooks,
-        :latest_verification_latest_tags
+                  :provider,
+                  :consumer_version,
+                  :latest_pact,
+                  :latest_verification,
+                  :webhooks,
+                  :triggered_webhooks,
+                  :latest_verification_latest_tags,
 
       # rubocop:disable Metrics/ParameterLists
-      def self.create(consumer, provider, latest_pact, latest, latest_verification, webhooks = [], triggered_webhooks = [], tags = [], latest_verification_latest_tags = [], latest_for_branch = nil)
-        new(consumer, provider, latest_pact, latest, latest_verification, webhooks, triggered_webhooks, tags, latest_verification_latest_tags, latest_for_branch)
+      def self.create(consumer, provider, consumer_version, latest_pact, latest, latest_verification, webhooks = [], triggered_webhooks = [], tags = [], latest_verification_latest_tags = [], latest_for_branch = nil)
+        new(consumer, provider, consumer_version, latest_pact, latest, latest_verification, webhooks, triggered_webhooks, tags, latest_verification_latest_tags, latest_for_branch)
       end
       # rubocop:enable Metrics/ParameterLists
 
       # rubocop:disable Metrics/ParameterLists
-      def initialize(consumer, provider, latest_pact = nil, latest = true, latest_verification = nil, webhooks = [], triggered_webhooks = [], tags = [], latest_verification_latest_tags = [], latest_for_branch = nil)
+      def initialize(consumer, provider, consumer_version = nil, latest_pact = nil, latest = true, latest_verification = nil, webhooks = [], triggered_webhooks = [], tags = [], latest_verification_latest_tags = [], latest_for_branch = nil)
         @consumer = consumer
         @provider = provider
+        @consumer_version = consumer_version
         @latest_pact = latest_pact
         @latest = latest
         @latest_verification = latest_verification
@@ -68,12 +70,8 @@ module PactBroker
         consumer_version.order
       end
 
-      def consumer_version
-        @latest_pact.consumer_version
-      end
-
-      def consumer_version_branch
-        consumer_version.branch
+      def consumer_version_branches
+        consumer_version.branch_heads.collect(&:branch_name)
       end
 
       def consumer_version_environment_names
@@ -92,8 +90,8 @@ module PactBroker
         @latest_verification ? @latest_verification.provider_version_number : nil
       end
 
-      def provider_version_branch
-        provider_version&.branch
+      def provider_version_branches
+        provider_version&.branch_heads&.collect(&:branch_name) || []
       end
 
       def provider_version_environment_names

data/lib/pact_broker/domain/pacticipant.rb

@@ -22,6 +22,8 @@ module PactBroker
       one_to_many :labels, :order => :name, :reciprocal => :pacticipant
       one_to_many :pacts
       one_to_one :latest_version, :class => "PactBroker::Versions::LatestVersion", primary_key: :id, key: :pacticipant_id
+      one_to_many :branch_heads, class: "PactBroker::Versions::BranchHead", primary_key: :id, key: :pacticipant_id
+      one_to_many :branches, class: "PactBroker::Versions::Branch", primary_key: :id, key: :pacticipant_id
 
       dataset_module do
         include PactBroker::Repositories::Helpers
@@ -38,6 +40,10 @@ module PactBroker
         def find_by_name(name)
           where(name_like(:name, name))
         end
+
+        def where_name(name)
+          where(name_like(:name, name))
+        end
       end
 
       def before_destroy
@@ -66,6 +72,10 @@ module PactBroker
       def any_versions?
         PactBroker::Domain::Version.where(pacticipant: self).any?
       end
+
+      def branch_head_for(branch_name)
+        branch_heads.find{ | branch_head | branch_head.branch_name == branch_name }
+      end
     end
   end
 end
@@ -87,6 +97,7 @@ end
 #  pacticipants_name_key | UNIQUE btree (name)
 #  ndx_ppt_name          | btree (name)
 # Referenced By:
+#  branches                                                     | branches_pacticipant_id_fkey                                    | (pacticipant_id) REFERENCES pacticipants(id) ON DELETE CASCADE
 #  currently_deployed_version_ids                               | currently_deployed_version_ids_pacticipant_id_fkey              | (pacticipant_id) REFERENCES pacticipants(id) ON DELETE CASCADE
 #  labels                                                       | labels_pacticipant_id_fkey                                      | (pacticipant_id) REFERENCES pacticipants(id)
 #  latest_pact_publication_ids_for_consumer_versions            | latest_pact_publication_ids_for_consumer_versi_consumer_id_fkey | (consumer_id) REFERENCES pacticipants(id) ON DELETE CASCADE

data/lib/pact_broker/domain/tag.rb

@@ -130,6 +130,7 @@ module PactBroker
 
       # rubocop: disable Metrics/CyclomaticComplexity
       def before_save
+        super
         if version
           if version.order && self.version_order.nil?
             self.version_order = version.order
@@ -146,8 +147,6 @@ module PactBroker
 
         if version_order.nil? || pacticipant_id.nil?
           raise PactBroker::Error.new("Need to set version_order and pacticipant_id for tags now")
-        else
-          super
         end
       end
       # rubocop: enable Metrics/CyclomaticComplexity

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
@@ -203,6 +206,15 @@ module PactBroker
         @pact_content_with_test_results = PactBroker::Pacts::Content.from_json(pact_version.content).with_test_results(test_results)
       end
 
+      # Whether the pact content was pending at the time the verification was run
+      def pact_pending?
+        pact_pending
+      end
+
+      def failed_and_pact_pending?
+        !success && pact_pending
+      end
+
       # So consumer_version_tag_name can be accessed by method name
       def method_missing(m, *args, &block)
         if values.key?(m) && args.size == 0
@@ -219,23 +231,26 @@ end
 
 # Table: verifications
 # Columns:
-#  id                  | integer                     | PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY
-#  number              | integer                     |
-#  success             | boolean                     | NOT NULL
-#  provider_version    | text                        |
-#  build_url           | text                        |
-#  pact_version_id     | integer                     | NOT NULL
-#  execution_date      | timestamp without time zone | NOT NULL
-#  created_at          | timestamp without time zone | NOT NULL
-#  provider_version_id | integer                     |
-#  test_results        | text                        |
-#  consumer_id         | integer                     |
-#  provider_id         | integer                     |
-#  wip                 | boolean                     | NOT NULL DEFAULT false
+#  id                               | integer                     | PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY
+#  number                           | integer                     |
+#  success                          | boolean                     | NOT NULL
+#  provider_version                 | text                        |
+#  build_url                        | text                        |
+#  pact_version_id                  | integer                     | NOT NULL
+#  execution_date                   | timestamp without time zone | NOT NULL
+#  created_at                       | timestamp without time zone | NOT NULL
+#  provider_version_id              | integer                     |
+#  test_results                     | text                        |
+#  consumer_id                      | integer                     |
+#  provider_id                      | integer                     |
+#  wip                              | boolean                     | NOT NULL DEFAULT false
+#  consumer_version_selector_hashes | text                        |
+#  tag_names                        | text                        |
 # Indexes:
 #  verifications_pkey                          | PRIMARY KEY btree (id)
 #  verifications_pact_version_id_number_index  | UNIQUE btree (pact_version_id, number)
 #  verifications_consumer_id_index             | btree (consumer_id)
+#  verifications_pact_version_id_id_index      | btree (pact_version_id, id)
 #  verifications_provider_id_consumer_id_index | btree (provider_id, consumer_id)
 #  verifications_provider_id_index             | btree (provider_id)
 # Foreign key constraints:

data/lib/pact_broker/domain/version.rb

@@ -3,7 +3,6 @@ require "pact_broker/domain/order_versions"
 require "pact_broker/repositories/helpers"
 require "pact_broker/tags/tag_with_latest_flag"
 require "pact_broker/versions/eager_loaders"
-require "pact_broker/versions/lazy_loaders"
 
 module PactBroker
   module Domain
@@ -22,7 +21,9 @@ module PactBroker
       end
     end
 
-    class Version < Sequel::Model
+    VERSION_COLUMNS = [:id, :number, :repository_ref, :pacticipant_id, :order, :created_at, :updated_at, :build_url]
+
+    class Version < Sequel::Model(Sequel::Model.db[:versions].select(*VERSION_COLUMNS.collect{ | column | Sequel.qualify(:versions, column) }))
       plugin :timestamps, update_on_create: true
       plugin :upsert, { identifying_columns: [:pacticipant_id, :number], ignore_columns_on_update: [:id, :created_at, :order] }
 
@@ -30,6 +31,8 @@ module PactBroker
       one_to_many :pact_publications, order: :revision_number, class: "PactBroker::Pacts::PactPublication", key: :consumer_version_id
       associate(:many_to_one, :pacticipant, :class => "PactBroker::Domain::Pacticipant", :key => :pacticipant_id, :primary_key => :id)
       one_to_many :tags, :reciprocal => :version, order: :created_at
+      one_to_many :branch_versions, :reciprocal => :branch_version, class: "PactBroker::Versions::BranchVersion", order: [:created_at, :id]
+      one_to_many :branch_heads, reciprocal: :branch_head, class: "PactBroker::Versions::BranchHead", order: :branch_id
       one_to_many :current_deployed_versions, class: "PactBroker::Deployments::DeployedVersion", key: :version_id, primary_key: :id, order: [:created_at, :id] do | ds |
         ds.currently_deployed
       end
@@ -44,16 +47,15 @@ module PactBroker
         dataset: lambda { Version.latest_version_for_pacticipant(pacticipant) },
         eager_loader: PactBroker::Versions::EagerLoaders::LatestVersionForPacticipant
 
-      many_to_one :latest_version_for_branch, read_only: true, key: :id,
-        class: Version,
-        dataset: PactBroker::Versions::LazyLoaders::LATEST_VERSION_FOR_BRANCH,
-        eager_loader: PactBroker::Versions::EagerLoaders::LatestVersionForBranch
-
       dataset_module do
         include PactBroker::Repositories::Helpers
 
-        def with_branch_set
-          exclude(branch: nil)
+        def with_branch
+          where(id: PactBroker::Versions::BranchVersion.select(:version_id))
+        end
+
+        def with_user_created_branch
+          where(id: PactBroker::Versions::BranchVersion.select(:version_id).where(auto_created: false))
         end
 
         def latest_version_for_pacticipant(pacticipant)
@@ -71,20 +73,16 @@ module PactBroker
         end
 
         def first_for_pacticipant_id_and_branch(pacticipant_id, branch)
-          where(pacticipant_id: pacticipant_id, branch: branch).order(:created_at).first
+          first_version_id = PactBroker::Versions::BranchVersion
+                              .select(:version_id)
+                              .where(pacticipant_id: pacticipant_id, branch_name: branch)
+                              .order(:created_at)
+                              .limit(1)
+          where(id: first_version_id).single_record
         end
 
-        def latest_versions_for_pacticipant_branches(pacticipant_id, branches)
-          query = Version.where(Sequel[:versions][:pacticipant_id] => pacticipant_id, Sequel[:versions][:branch] => branches)
-
-          self_join = {
-            Sequel[:versions][:pacticipant_id] => Sequel[:versions_2][:pacticipant_id],
-            Sequel[:versions][:branch] => Sequel[:versions_2][:branch]
-          }
-          query.select_all_qualified.left_join(query, self_join, table_alias: :versions_2) do
-            Sequel[:versions_2][:order] > Sequel[:versions][:order]
-          end
-          .where(Sequel[:versions_2][:order] => nil)
+        def latest_versions_for_pacticipant_branches(pacticipant_id, branch_names)
+          where(id: PactBroker::Versions::BranchHead.where(pacticipant_id: pacticipant_id, branch_name: branch_names).select(:version_id))
         end
 
         def where_pacticipant_name(pacticipant_name)
@@ -115,6 +113,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])
@@ -128,8 +136,46 @@ module PactBroker
           end
         end
 
-        def where_branch(branch)
-          where(branch: branch)
+        def where_branch_name(branch_name)
+          if branch_name == true
+            where(id: PactBroker::Versions::BranchVersion.select(:version_id))
+          else
+            matching_branch_ids = PactBroker::Versions::Branch.select(:id).where(name: branch_name)
+            matching_branch_version_ids = PactBroker::Versions::BranchVersion
+                                            .select(:version_id)
+                                            .where(branch_id: matching_branch_ids)
+            where(id: matching_branch_version_ids)
+          end
+        end
+
+        def where_branch_head_name(branch_name)
+          if branch_name == true
+            where(id: PactBroker::Versions::BranchHead.select(:version_id))
+          else
+            where(id: PactBroker::Versions::BranchHead.select(:version_id).where(branch_name: branch_name))
+          end
+        end
+
+
+        def for_main_branches
+          matching_branch_version_ids = PactBroker::Versions::BranchVersion
+                                          .select(:version_id)
+                                          .join(:pacticipants, { Sequel[:branch_versions][:pacticipant_id] => Sequel[:pacticipants][:id] })
+                                          .join(:branches, { Sequel[:branches][:id] => Sequel[:branch_versions][:branch_id], Sequel[:branches][:name] => Sequel[:pacticipants][:main_branch] })
+
+          where(id: matching_branch_version_ids)
+        end
+
+        def latest_for_main_branches
+          pacticipants_join = {
+            Sequel[:branch_heads][:pacticipant_id] => Sequel[:pacticipants][:id],
+            Sequel[:branch_heads][:branch_name] => Sequel[:pacticipants][:main_branch]
+          }
+          matching_branch_version_ids = PactBroker::Versions::BranchHead
+                                          .select(:version_id)
+                                          .join(:pacticipants, pacticipants_join)
+
+          where(id: matching_branch_version_ids)
         end
 
         def where_number(number)
@@ -161,12 +207,33 @@ 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.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
+          latest_applied = false
+
+          if selector.respond_to?(:main_branch) && selector.main_branch
+            if selector.latest
+              latest_applied = true
+              query = query.latest_for_main_branches
+            else
+              query = query.for_main_branches
+            end
+          end
+
+          if selector.branch
+            if selector.latest
+              latest_applied = true
+              query = query.where_branch_head_name(selector.branch)
+            else
+              query = query.where_branch_name(selector.branch)
+            end
+          end
+
+          if selector.latest && !latest_applied
             calculate_max_version_order_and_join_back_to_versions(query, selector)
           else
             query
@@ -226,12 +293,28 @@ module PactBroker
       end
 
       def latest_for_branch?
-        branch ? latest_version_for_branch.order == order : nil
+        branch_heads.any?
       end
 
       def latest_for_pacticipant?
         latest_version_for_pacticipant == self
       end
+
+      def branch_version_for_branch(branch)
+        branch_versions.find { | branch_version | branch_version.branch_id == branch.id }
+      end
+
+      def branch_version_for_branch_name(branch_name)
+        branch_versions.find { | branch_version | branch_version.branch_name == branch_name }
+      end
+
+      def branch_names
+        branch_versions.collect(&:branch_name)
+      end
+
+      def tag_names
+        tags.collect(&:name)
+      end
     end
   end
 end
@@ -245,7 +328,6 @@ end
 #  order          | integer                     |
 #  created_at     | timestamp without time zone | NOT NULL
 #  updated_at     | timestamp without time zone | NOT NULL
-#  branch         | text                        |
 #  build_url      | text                        |
 # Indexes:
 #  versions_pkey                              | PRIMARY KEY btree (id)
@@ -258,6 +340,7 @@ end
 # Foreign key constraints:
 #  versions_pacticipant_id_fkey | (pacticipant_id) REFERENCES pacticipants(id)
 # Referenced By:
+#  branch_versions                                              | branch_versions_versions_fk                                     | (version_id) REFERENCES versions(id) ON DELETE CASCADE
 #  currently_deployed_version_ids                               | currently_deployed_version_ids_version_id_fkey                  | (version_id) REFERENCES versions(id) ON DELETE CASCADE
 #  deployed_versions                                            | deployed_versions_version_id_fkey                               | (version_id) REFERENCES versions(id)
 #  latest_pact_publication_ids_for_consumer_versions            | latest_pact_publication_ids_for_consum_consumer_version_id_fkey | (consumer_version_id) REFERENCES versions(id) ON DELETE CASCADE

data/lib/pact_broker/domain/webhook.rb

@@ -50,17 +50,12 @@ module PactBroker
       def execute pact, verification, event_context, options
         logger.info "Executing #{self} event_context=#{event_context}"
         template_params = template_parameters(pact, verification, event_context, options)
-        webhook_request = request.build(template_params)
+        webhook_request = request.build(template_params, options.fetch(:user_agent))
         http_response, error = execute_request(webhook_request)
-
-        logs = generate_logs(webhook_request, http_response, error, event_context, options.fetch(:logging_options))
+        success = success?(http_response, options)
         http_request = webhook_request.http_request
-        PactBroker::Webhooks::WebhookExecutionResult.new(
-          http_request,
-          http_response,
-          logs,
-          error
-        )
+        logs = generate_logs(webhook_request, http_response, success, error, event_context, options.fetch(:logging_options))
+        result(http_request, http_response, success, logs, error)
       end
 
       def to_s
@@ -116,16 +111,33 @@ module PactBroker
         PactBroker::Webhooks::PactAndVerificationParameters.new(pact, verification, event_context).to_hash
       end
 
-      def generate_logs(webhook_request, http_response, error, event_context, logging_options)
+      def success?(http_response, options)
+        !http_response.nil? && options.fetch(:http_success_codes).include?(http_response.code.to_i)
+      end
+
+      # rubocop: disable Metrics/ParameterLists
+      def generate_logs(webhook_request, http_response, success, error, event_context, logging_options)
         webhook_request_logger = PactBroker::Webhooks::WebhookRequestLogger.new(logging_options)
         webhook_request_logger.log(
           uuid,
           webhook_request,
           http_response,
+          success,
           error,
           event_context
         )
       end
+      # robocop: enable Metrics/ParameterLists
+
+      def result(http_request, http_response, success, logs, error)
+        PactBroker::Webhooks::WebhookExecutionResult.new(
+          http_request,
+          http_response,
+          success,
+          logs,
+          error
+        )
+      end
     end
   end
 end