pact_broker 2.83.0 → 2.84.0

data/lib/pact_broker/pacts/pact_publication_selector_dataset_module.rb

@@ -16,28 +16,31 @@ module PactBroker
         # Do the "latest" logic last so that the provider/consumer criteria get included in the "latest" query before the join, rather than after
         query = query.latest_for_main_branches if selector.latest_for_main_branch?
         query = query.latest_for_consumer_branch(selector.branch) if selector.latest_for_branch?
-        query = query.latest_for_consumer_tag(selector.tag) if selector.latest_for_tag?
+        query = query.for_latest_consumer_versions_with_tag(selector.tag) if selector.latest_for_tag?
         query = query.overall_latest if selector.overall_latest?
         query
       end
       # rubocop: enable Metrics/CyclomaticComplexity
 
+      # Updated logic - the pacts for the latest version of each main branch,
+      # not the latest pact that belongs to the main branch.
       def latest_for_main_branches
-        self_join = {
-          Sequel[:pact_publications][:provider_id] => Sequel[:pp2][:provider_id],
-          Sequel[:pact_publications][:consumer_id] => Sequel[:pp2][:consumer_id],
-          Sequel[:cv][:branch] => Sequel[:pp2][:branch]
-        }
-
-        base_query = join_consumers(:consumers)
-                      .join_consumer_versions(:cv, { Sequel[:cv][:branch] => Sequel[:consumers][:main_branch] })
+        consumers_join = { Sequel[:pact_publications][:consumer_id] => Sequel[:consumers][:id] }
 
-        base_query = base_query.select_all_qualified if no_columns_selected?
+        branch_heads_join = {
+          Sequel[:pact_publications][:consumer_version_id] => Sequel[:branch_heads][:version_id],
+          Sequel[:consumers][:main_branch] => Sequel[:branch_heads][:branch_name]
+        }
 
-        base_query.left_join(base_query.select(:provider_id, :consumer_id, Sequel[:cv][:branch], :consumer_version_order), self_join, { table_alias: :pp2 }) do
-          Sequel[:pp2][:consumer_version_order] > Sequel[:pact_publications][:consumer_version_order]
+        query = self
+        if no_columns_selected?
+          query = query.select_all_qualified.select_append(Sequel[:branch_heads][:branch_name].as(:branch_name))
         end
-        .where(Sequel[:pp2][:consumer_version_order] => nil)
+
+        query
+          .join(:pacticipants, consumers_join, { table_alias: :consumers })
+          .join(:branch_heads, branch_heads_join)
+          .remove_overridden_revisions_from_complete_query
       end
 
       def for_currently_deployed_versions(environment_name)
@@ -60,6 +63,7 @@ module PactBroker
           .join(:deployed_versions, deployed_versions_join)
           .join(:currently_deployed_version_ids, currently_deployed_versions_join)
           .join(:environments, environments_join)
+          .remove_overridden_revisions_from_complete_query
       end
 
       def for_currently_supported_versions(environment_name)
@@ -79,6 +83,7 @@ module PactBroker
         query
           .join(:released_versions, released_versions_join)
           .join(:environments, environments_join)
+          .remove_overridden_revisions_from_complete_query
       end
 
       def for_environment(environment_name)

data/lib/pact_broker/pacts/pact_publication_wip_dataset_module.rb

@@ -16,14 +16,22 @@ module PactBroker
         from_self(alias: :pp)
           .select(Sequel[:pp].*)
           .join_successful_non_wip_verifications_for_provider_id(provider_id)
-          .join_provider_versions_for_provider_id(provider_id) do
-            Sequel.lit("provider_versions.branch != ?", provider_version_branch)
-          end
+          .join_provider_versions_for_provider_id(provider_id)
+          .join_branch_versions_excluding_branch(provider_version_branch)
           .where(Sequel[:pp][:provider_id] => provider_id)
           .verified_before_creation_date_of(first_version_for_branch)
           .distinct
       end
 
+      def join_branch_versions_excluding_branch(branch_name)
+        branch_versions_join = {
+          Sequel[:provider_versions][:id] => Sequel[:branch_versions][:version_id]
+        }
+        join(:branch_versions, branch_versions_join) do
+          Sequel.lit("branch_versions.branch_name != ?", branch_name)
+        end
+      end
+
       def successfully_verified_by_provider_tag_when_not_wip(provider_id, provider_tag)
         from_self(alias: :pp)
           .select(Sequel[:pp].*)
@@ -80,10 +88,14 @@ module PactBroker
       def join_provider_versions_for_provider_id_and_branch(provider_id, provider_version_branch)
         versions_join = {
           Sequel[:verifications][:provider_version_id] => Sequel[:provider_versions][:id],
-          Sequel[:provider_versions][:branch] => provider_version_branch,
           Sequel[:provider_versions][:pacticipant_id] => provider_id
         }
+        branch_versions_join = {
+          Sequel[:provider_versions][:id] => Sequel[:branch_versions][:version_id],
+          Sequel[:branch_versions][:branch_name] => provider_version_branch
+        }
         join(:versions, versions_join, { table_alias: :provider_versions } )
+          .join(:branch_versions, branch_versions_join)
       end
 
       def join_provider_versions_for_provider_id(provider_id, &block)

data/lib/pact_broker/pacts/pact_version.rb

@@ -2,6 +2,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"
+require "pact_broker/pacts/content"
 
 module PactBroker
   module Pacts
@@ -125,6 +126,16 @@ module PactBroker
           .join_successful_verifications
           .any?
       end
+
+      def set_interactions_and_messages_counts!
+        if interactions_count.nil? || messages_count.nil?
+          content_object = PactBroker::Pacts::Content.from_json(content)
+          update(
+            messages_count: content_object.messages&.count || 0,
+            interactions_count: content_object.interactions&.count || 0
+          )
+        end
+      end
     end
   end
 end

data/lib/pact_broker/pacts/pacts_for_verification_repository.rb

@@ -215,7 +215,7 @@ module PactBroker
         if pact_publication.values[:tag_name]
           Selectors.create_for_latest_for_tag(pact_publication.values[:tag_name])
         else
-          Selectors.create_for_latest_for_branch(pact_publication.consumer_version.branch)
+          Selectors.create_for_latest_for_branch(pact_publication.values.fetch(:branch_name))
         end
       end
 
@@ -285,8 +285,8 @@ module PactBroker
         pact_publications_query.eager(:provider).eager(:consumer).eager(:consumer_version).order(:consumer_version_order).all.sort.collect do |p|
           suffix =  if p.values[:tag_name]
                       " (tag #{p.values[:tag_name]})"
-                    elsif p.values[:branch]
-                      " (branch #{p.values[:branch]})"
+                    elsif p.values[:branch_name]
+                      " (branch #{p.values[:branch_name]})"
                     else
                       ""
                     end

data/lib/pact_broker/pacts/selected_pact.rb

@@ -15,8 +15,8 @@ module PactBroker
         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)
+          .collect do | selected_pacts_for_pact_version_sha |
+            SelectedPact.merge(selected_pacts_for_pact_version_sha)
           end
           .sort
       end

data/lib/pact_broker/pacts/selector.rb

@@ -2,6 +2,7 @@ require "pact_broker/hash_refinements"
 
 module PactBroker
   module Pacts
+    # rubocop: disable Metrics/ClassLength
     class Selector < Hash
       using PactBroker::HashRefinements
 
@@ -266,51 +267,89 @@ module PactBroker
         other.class == self.class && super
       end
 
-      # rubocop: disable Metrics/CyclomaticComplexity, Metrics/MethodLength
+      # rubocop: disable Metrics/CyclomaticComplexity
       def <=> other
+        # elsif consumer || other.consumer
+        #   consumer_comparison(other)
         if overall_latest? || other.overall_latest?
-          if overall_latest? == other.overall_latest?
-            0
-          else
-            overall_latest? ? -1 : 1
-          end
+          overall_latest_comparison(other)
         elsif latest_for_branch? || other.latest_for_branch?
-          if latest_for_branch? == other.latest_for_branch?
-            branch <=> other.branch
-          else
-            latest_for_branch? ? -1 : 1
-          end
+          branch_comparison(other)
+        elsif latest_for_tag? || other.latest_for_tag?
+          latest_for_tag_comparison(other)
+        elsif tag || other.tag
+          tag_comparison(other)
         elsif currently_deployed? || other.currently_deployed?
-          if currently_deployed? == other.currently_deployed?
-            environment_name <=> other.environment_name
-          else
-            currently_deployed? ? -1 : 1
-          end
+          currently_deployed_comparison(other)
         elsif currently_supported? || other.currently_supported?
-          if currently_supported? == other.currently_supported?
-            environment_name <=> other.environment_name
-          else
-            currently_supported? ? -1 : 1
-          end
-        elsif latest_for_tag? || other.latest_for_tag?
-          if latest_for_tag? == other.latest_for_tag?
-            tag <=> other.tag
+          currently_supported_comparison(other)
+        else
+          0
+        end
+      end
+      # rubocop: enable Metrics/CyclomaticComplexity
+
+      private
+
+      def overall_latest_comparison(other)
+        if overall_latest? == other.overall_latest?
+          0
+        else
+          overall_latest? ? -1 : 1
+        end
+      end
+
+      def branch_comparison(other)
+        if latest_for_branch? == other.latest_for_branch?
+          branch <=> other.branch
+        else
+          latest_for_branch? ? -1 : 1
+        end
+      end
+
+      def currently_deployed_comparison(other)
+        if currently_deployed? == other.currently_deployed?
+          environment_name <=> other.environment_name
+        else
+          currently_deployed? ? -1 : 1
+        end
+      end
+
+      def currently_supported_comparison(other)
+        if currently_supported? == other.currently_supported?
+          environment_name <=> other.environment_name
+        else
+          currently_supported? ? -1 : 1
+        end
+      end
+
+      def latest_for_tag_comparison(other)
+        if latest_for_tag? == other.latest_for_tag?
+          tag <=> other.tag
+        else
+          latest_for_tag? ? -1 : 1
+        end
+      end
+
+      def tag_comparison(other)
+        if tag && other.tag
+          if tag == other.tag
+            consumer_comparison(other)
           else
-            latest_for_tag? ? -1 : 1
-          end
-        elsif consumer || other.consumer
-          if consumer == other.consumer
             tag <=> other.tag
-          else
-            consumer ? -1 : 1
           end
         else
-          tag <=> other.tag
+          tag ? -1 : 1
         end
       end
-      # rubocop: enable Metrics/CyclomaticComplexity, Metrics/MethodLength
 
-      private
+      def consumer_comparison(other)
+        if consumer == other.consumer
+          0
+        else
+          consumer ? -1 : 1
+        end
+      end
 
       def latest?
         !!self[:latest]
@@ -347,6 +386,32 @@ module PactBroker
           comparison
         end
       end
+
+      def currently_deployed_comparison(other)
+        if currently_deployed? == other.currently_deployed?
+          production_comparison(other)
+        else
+          currently_deployed? ? -1 : 1
+        end
+
+      end
+
+      def currently_supported_comparison(other)
+        if currently_supported? == other.currently_supported?
+          production_comparison(other)
+        else
+          currently_supported? ? -1 : 1
+        end
+      end
+
+      def production_comparison(other)
+        if environment.production? == other.environment.production?
+          environment.name <=> other.environment.name
+        else
+          environment.production? ? 1 : -1
+        end
+      end
     end
+    # rubocop: enable Metrics/ClassLength
   end
 end

data/lib/pact_broker/repositories.rb

@@ -42,6 +42,11 @@ module PactBroker
       Matrix::Repository.new
     end
 
+    def branch_version_repository
+      require "pact_broker/versions/branch_version_repository"
+      PactBroker::Versions::BranchVersionRepository.new
+    end
+
     extend self
   end
 end

data/lib/pact_broker/services.rb

@@ -89,6 +89,10 @@ module PactBroker
       get(:contract_service)
     end
 
+    def branch_service
+      get(:branch_service)
+    end
+
     # rubocop: disable Metrics/MethodLength
     def register_default_services
       register_service(:index_service) do
@@ -185,6 +189,11 @@ module PactBroker
         require "pact_broker/contracts/service"
         PactBroker::Contracts::Service
       end
+
+      register_service(:branch_service) do
+        require "pact_broker/versions/branch_service"
+        PactBroker::Versions::BranchService
+      end
     end
     # rubocop: enable Metrics/MethodLength
   end

data/lib/pact_broker/test/http_test_data_builder.rb

@@ -3,6 +3,7 @@ require "faraday_middleware"
 require "logger"
 require "erb"
 require "yaml"
+require "base64"
 
 module PactBroker
   module Test
@@ -53,11 +54,12 @@ module PactBroker
         self
       end
 
-      def create_version(pacticipant:, version:, branch:)
-        request_body = {
-          branch: branch
-        }
-        client.put("pacticipants/#{encode(pacticipant)}/versions/#{encode(version)}", request_body).tap { |response| check_for_error(response) }
+      def create_version(pacticipant:, version:, branch: nil)
+        if branch
+          client.put("pacticipants/#{encode(pacticipant)}/branches/#{encode(branch)}/versions/#{encode(version)}", {}).tap { |response| check_for_error(response) }
+        else
+          client.put("pacticipants/#{encode(pacticipant)}/versions/#{encode(version)}").tap { |response| check_for_error(response) }
+        end
         self
       end
 
@@ -100,6 +102,29 @@ module PactBroker
         self
       end
 
+      def publish_contract(consumer: last_consumer_name, consumer_version:, provider: last_provider_name, content_id:, tag: nil, branch: nil)
+        content = generate_content(consumer, provider, content_id)
+        request_body_hash = {
+          :pacticipantName => consumer,
+          :pacticipantVersionNumber => consumer_version,
+          :branch => branch,
+          :tags => tag ? [tag] : nil,
+          :contracts => [
+            {
+              :consumerName => consumer,
+              :providerName => provider,
+              :specification => "pact",
+              :contentType => "application/json",
+              :content => Base64.strict_encode64(content.to_json)
+            }
+          ]
+        }.compact
+        response = client.post("contracts/publish", request_body_hash).tap { |resp| check_for_error(resp) }
+        puts response.body["logs"].collect{ |log| log["message"]}
+        separate
+        self
+      end
+
       def publish_pact(consumer: last_consumer_name, consumer_version:, provider: last_provider_name, content_id:, tag: nil, branch: nil)
         @last_consumer_name = consumer
         @last_provider_name = provider
@@ -120,7 +145,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: nil, 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
@@ -258,7 +283,7 @@ module PactBroker
       def can_i_deploy(pacticipant:, version:, to: nil, to_environment: nil)
         can_i_deploy_response = client.get("can-i-deploy", { pacticipant: pacticipant, version: version, to: to, environment: to_environment}.compact ).tap { |response| check_for_error(response) }
         can = !!(can_i_deploy_response.body["summary"] || {})["deployable"]
-        puts "can-i-deploy #{pacticipant} version #{version} to #{to}: #{can ? 'yes' : 'no'}"
+        puts "can-i-deploy #{pacticipant} version #{version} to #{to || to_environment}: #{can ? 'yes' : 'no'}"
         summary = can_i_deploy_response.body["summary"]
         verification_result_urls = (can_i_deploy_response.body["matrix"] || []).collect do | row |
           row.dig("verificationResult", "_links", "self", "href")

data/lib/pact_broker/test/test_data_builder.rb

@@ -29,6 +29,7 @@ require "pact_broker/matrix/row"
 require "pact_broker/deployments/environment_service"
 require "pact_broker/deployments/deployed_version_service"
 require "pact_broker/deployments/released_version_service"
+require "pact_broker/versions/branch_version_repository"
 require "ostruct"
 
 module PactBroker
@@ -162,37 +163,17 @@ module PactBroker
       end
 
       def create_version version_number = "1.0.#{model_counter}", params = {}
-        params.delete(:comment)
-        @version = PactBroker::Domain::Version.create(:number => version_number, :pacticipant => @pacticipant)
+        @version = create_pacticipant_version(version_number, pacticipant, params)
         self
       end
 
       def create_consumer_version version_number = "1.0.#{model_counter}", params = {}
-        params.delete(:comment)
-        tag_names = [params.delete(:tag_names), params.delete(:tag_name)].flatten.compact
-        @consumer_version = PactBroker::Domain::Version.create(
-          number: version_number,
-          pacticipant: @consumer,
-          branch: params[:branch],
-          build_url: params[:build_url]
-        )
-        set_created_at_if_set params[:created_at], :versions, { id: @consumer_version.id }
-        tag_names.each do | tag_name |
-          tag = PactBroker::Domain::Tag.create(name: tag_name, version: consumer_version)
-          set_created_at_if_set(params[:created_at], :tags, { name: tag.name, version_id: consumer_version.id })
-        end
+        @consumer_version = create_pacticipant_version(version_number, consumer, params)
         self
       end
 
       def create_provider_version version_number = "1.0.#{model_counter}", params = {}
-        params.delete(:comment)
-        tag_names = [params.delete(:tag_names), params.delete(:tag_name)].flatten.compact
-        @version = PactBroker::Domain::Version.create(:number => version_number, :pacticipant => @provider, branch: params[:branch])
-        @provider_version = @version
-        tag_names.each do | tag_name |
-          tag = PactBroker::Domain::Tag.create(name: tag_name, version: provider_version)
-          set_created_at_if_set(params[:created_at], :tags, { name: tag.name, version_id: provider_version.id })
-        end
+        @provider_version = create_pacticipant_version(version_number, provider, params)
         self
       end
 
@@ -376,7 +357,7 @@ module PactBroker
         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
+        PactBroker::Versions::BranchVersionRepository.new.add_branch(@provider_version, branch) if branch
 
         set_created_at_if_set(parameters[:created_at], :verifications, id: @verification.id)
         set_created_at_if_set(parameters[:created_at], :versions, id: @provider_version.id)
@@ -542,6 +523,26 @@ module PactBroker
 
       private
 
+      def create_pacticipant_version(version_number, pacticipant, params = {})
+        params.delete(:comment)
+        tag_names = [params.delete(:tag_names), params.delete(:tag_name)].flatten.compact
+        args = {
+          number: version_number,
+          pacticipant_id: pacticipant.id,
+          branch: params[:branch],
+          build_url: params[:build_url]
+        }
+
+        version = PactBroker::Versions::Repository.new.create(args)
+
+        set_created_at_if_set params[:created_at], :versions, { id: version.id }
+        tag_names.each do | tag_name |
+          tag = PactBroker::Domain::Tag.create(name: tag_name, version: version)
+          set_created_at_if_set(params[:created_at], :tags, { name: tag.name, version_id: version.id })
+        end
+        version
+      end
+
       def create_deployed_version(uuid: , currently_deployed: , version:, environment_name: , target: nil, created_at: nil)
         env = find_environment(environment_name)
         @deployed_version = PactBroker::Deployments::DeployedVersionService.find_or_create(uuid, version, env, target)