pact_broker 2.77.0 → 2.80.0

data/lib/pact_broker/contracts/contracts_publication_results.rb

@@ -0,0 +1,14 @@
+module PactBroker
+  module Contracts
+    ContractsPublicationResults = Struct.new(:pacticipant, :version, :tags, :contracts, :notices) do
+      def self.from_hash(params)
+        new(params[:pacticipant],
+          params[:version],
+          params[:tags],
+          params[:contracts],
+          params[:notices]
+        )
+      end
+    end
+  end
+end

data/lib/pact_broker/contracts/contracts_to_publish.rb

@@ -0,0 +1,11 @@
+module PactBroker
+  module Contracts
+    ContractsToPublish = Struct.new(:pacticipant_name, :pacticipant_version_number, :tags, :branch, :build_url, :contracts) do
+      # rubocop: disable Metrics/ParameterLists
+      def self.from_hash(pacticipant_name: nil, pacticipant_version_number: nil, tags: nil, branch: nil, build_url: nil, contracts: nil)
+        new(pacticipant_name, pacticipant_version_number, tags, branch, build_url, contracts)
+      end
+      # rubocop: enable Metrics/ParameterLists
+    end
+  end
+end

data/lib/pact_broker/contracts/notice.rb

@@ -0,0 +1,21 @@
+module PactBroker
+  module Contracts
+    Notice = Struct.new(:type, :text) do
+      def self.info(text)
+        Notice.new("info", text)
+      end
+
+      def self.debug(text)
+        Notice.new("debug", text)
+      end
+
+      def self.warning(text)
+        Notice.new("warning", text)
+      end
+
+      def self.success(text)
+        Notice.new("success", text)
+      end
+    end
+  end
+end

data/lib/pact_broker/contracts/service.rb

@@ -0,0 +1,264 @@
+require "pact_broker/logging"
+require "pact_broker/repositories"
+require "pact_broker/services"
+require "pact_broker/messages"
+require "pact_broker/contracts/contracts_publication_results"
+require "pact_broker/contracts/notice"
+require "pact_broker/events/subscriber"
+require "pact_broker/api/pact_broker_urls"
+
+module PactBroker
+  module Contracts
+    module Service
+      extend self
+      extend PactBroker::Repositories
+      extend PactBroker::Services
+      include PactBroker::Logging
+      extend PactBroker::Messages
+
+      class TriggeredWebhooksCreatedListener
+        attr_reader :detected_events
+
+        def initialize
+          @detected_events = []
+        end
+
+        def triggered_webhooks_created_for_event(params)
+          detected_events << params.fetch(:event)
+        end
+      end
+
+      def publish(parsed_contracts, base_url: )
+        version, version_notices = create_version(parsed_contracts)
+        tags = create_tags(parsed_contracts, version)
+        pacts, pact_notices = create_pacts(parsed_contracts, base_url)
+        notices = version_notices + pact_notices
+        ContractsPublicationResults.from_hash(
+          pacticipant: version.pacticipant,
+          version: version,
+          tags: tags,
+          contracts: pacts,
+          notices: notices
+        )
+      end
+
+      def create_version(parsed_contracts)
+        version_params = {
+          build_url: parsed_contracts.build_url,
+          branch: parsed_contracts.branch
+        }.compact
+
+        existing_version = find_existing_version(parsed_contracts)
+        version = create_or_update_version(parsed_contracts, version_params)
+        return version, notices_for_version_creation(existing_version, parsed_contracts)
+      end
+
+      private :create_version
+
+      def find_existing_version(parsed_contracts)
+        version_service.find_by_pacticipant_name_and_number(
+          pacticipant_name: parsed_contracts.pacticipant_name,
+          pacticipant_version_number: parsed_contracts.pacticipant_version_number
+        )
+      end
+
+      private :find_existing_version
+
+      def create_or_update_version(parsed_contracts, version_params)
+        version_service.create_or_update(
+          parsed_contracts.pacticipant_name,
+          parsed_contracts.pacticipant_version_number,
+          OpenStruct.new(version_params)
+        )
+      end
+
+      private :create_or_update_version
+
+      def create_tags(parsed_contracts, version)
+        (parsed_contracts.tags || []).collect do | tag_name |
+          tag_repository.create(version: version, name: tag_name)
+        end
+      end
+
+      private :create_tags
+
+      def create_pacts(parsed_contracts, base_url)
+        notices = []
+        pacts = parsed_contracts.contracts.select(&:pact?).collect do | contract_to_publish |
+          pact_params = create_pact_params(parsed_contracts, contract_to_publish)
+          existing_pact = pact_service.find_pact(pact_params)
+          listener = TriggeredWebhooksCreatedListener.new
+          created_pact = create_or_merge_pact(contract_to_publish.merge?, existing_pact, pact_params, listener)
+          notices.concat(notices_for_pact(parsed_contracts, contract_to_publish, existing_pact, created_pact, listener, base_url))
+          created_pact
+        end
+        return pacts, notices
+      end
+
+      private :create_pacts
+
+      def create_pact_params(parsed_contracts, contract_to_publish)
+        PactBroker::Pacts::PactParams.new(
+          consumer_name: parsed_contracts.pacticipant_name,
+          provider_name: contract_to_publish.provider_name,
+          consumer_version_number: parsed_contracts.pacticipant_version_number,
+          json_content: contract_to_publish.decoded_content
+        )
+      end
+
+      private :create_pact_params
+
+      def create_or_merge_pact(merge, existing_pact, pact_params, listener)
+        PactBroker::Events.subscribe(listener) do
+          if merge && existing_pact
+            pact_service.merge_pact(pact_params)
+          else
+            pact_service.create_or_update_pact(pact_params)
+          end
+        end
+      end
+
+      private :create_or_merge_pact
+
+      def notices_for_version_creation(existing_version, parsed_contracts)
+        notices = []
+        message_params = parsed_contracts.to_h
+        if parsed_contracts.tags&.any?
+          message_params[:tags] = parsed_contracts.tags.join(", ")
+        end
+        message_params[:action] = existing_version ? "Updated" : "Created"
+        notices << Notice.debug(message(message_key_for_version_creation(parsed_contracts), message_params))
+        if parsed_contracts.branch.nil?
+          notices << Notice.warning("  Next steps:\n    " + message("messages.next_steps.version_branch"))
+        end
+        notices
+      end
+
+      private :notices_for_version_creation
+
+      def message_key_for_version_creation(parsed_contracts)
+        if parsed_contracts.branch && parsed_contracts.tags&.any?
+          "messages.version.created_for_branch_with_tags"
+        elsif parsed_contracts.branch
+          "messages.version.created_for_branch"
+        elsif parsed_contracts.tags&.any?
+          "messages.version.created_with_tags"
+        else
+          "messages.version.created"
+        end
+      end
+
+      private :message_key_for_version_creation
+
+      # rubocop: disable Metrics/ParameterLists
+      def notices_for_pact(parsed_contracts, contract_to_publish, existing_pact, created_pact, listener, base_url)
+        notices = []
+        notices << notice_for_pact_publication(parsed_contracts, contract_to_publish.merge?, existing_pact, created_pact)
+        notices << notice_for_pact_url(created_pact, base_url)
+        notices.concat(event_and_webhook_notices(listener, created_pact))
+        notices.concat(next_steps_notices(created_pact))
+        notices
+      end
+      # rubocop: enable Metrics/ParameterLists
+
+      private :notices_for_pact
+
+      def notice_for_pact_publication(parsed_contracts, merge, existing_pact, created_pact)
+        message_params = {
+          consumer_name: parsed_contracts.pacticipant_name,
+          consumer_version_number: parsed_contracts.pacticipant_version_number,
+          provider_name: created_pact.provider_name
+        }
+        if merge
+          if existing_pact
+            Notice.success(message("messages.contract.pact_merged", message_params))
+          else
+            Notice.success(message("messages.contract.pact_published", message_params))
+          end
+        else
+          if existing_pact
+            if existing_pact.pact_version_sha != created_pact.pact_version_sha
+              Notice.warning(message("messages.contract.pact_modified_for_same_version", message_params))
+            else
+              Notice.success(message("messages.contract.same_pact_content_published", message_params))
+            end
+          else
+            Notice.success(message("messages.contract.pact_published", message_params))
+          end
+        end
+      end
+
+      private :notice_for_pact_publication
+
+      def notice_for_pact_url(pact, base_url)
+        Notice.debug("  View the published pact at #{PactBroker::Api::PactBrokerUrls.pact_url(base_url, pact)}")
+      end
+
+      private :notice_for_pact_url
+
+      def event_and_webhook_notices(listener, pact)
+        event_descriptions(listener) + triggered_webhook_notices(listener, pact)
+      end
+
+      private :event_and_webhook_notices
+
+      def event_descriptions(listener)
+        event_descriptions = listener.detected_events.collect{ | event | event.name + (event.comment ? " (#{event.comment})" : "") }
+        if event_descriptions.any?
+          [Notice.debug("  Events detected: " + event_descriptions.join(", "))]
+        else
+          []
+        end
+      end
+
+      private :event_descriptions
+
+      # TODO add can-i-deploy and record-deployment
+      def next_steps_notices(pact)
+        notices = []
+        if !verification_service.any_verifications?(pact.consumer, pact.provider)
+          notices << Notice.warning("    * " + message("messages.next_steps.verifications", provider_name: pact.provider_name))
+        end
+
+        if !webhook_service.any_webhooks_configured_for_pact?(pact)
+          notices << Notice.warning("    * " + message("messages.next_steps.webhooks", provider_name: pact.provider_name))
+        end
+
+        if notices.any?
+          notices.unshift(Notice.warning("  Next steps:"))
+        end
+
+        notices
+      end
+
+      private :next_steps_notices
+
+      def triggered_webhook_notices(listener, pact)
+        triggered_webhooks = listener.detected_events.flat_map(&:triggered_webhooks)
+        if triggered_webhooks.any?
+          triggered_webhooks.collect do | triggered_webhook |
+            base_url = triggered_webhook.event_context[:base_url]
+            triggered_webhooks_notices_url = url_for_triggered_webhook(triggered_webhook, base_url)
+            text_2_params = { webhook_description: triggered_webhook.webhook.description&.inspect || triggered_webhook.webhook_uuid, event_name: triggered_webhook.event_name }
+            text_1 = message("messages.webhooks.webhook_triggered_for_event", text_2_params)
+            text_2 = message("messages.webhooks.triggered_webhook_see_logs", url: triggered_webhooks_notices_url)
+            Notice.debug("  #{text_1}\n    #{text_2}")
+          end
+        else
+          if webhook_service.any_webhooks_configured_for_pact?(pact)
+            # There are some webhooks, just not any for this particular event
+            [Notice.debug("  " + message("messages.webhooks.no_webhooks_enabled_for_event"))]
+          else
+            []
+          end
+        end
+      end
+
+      def url_for_triggered_webhook(triggered_webhook, base_url)
+        PactBroker::Api::PactBrokerUrls.triggered_webhook_logs_url(triggered_webhook, base_url)
+      end
+
+      private :url_for_triggered_webhook
+    end
+  end
+end

data/lib/pact_broker/date_helper.rb

@@ -3,10 +3,10 @@ module PactBroker
 
     extend self
 
-    #Ripped from actionview/lib/action_view/helpers/date_helper.rb
+    # Ripped from actionview/lib/action_view/helpers/date_helper.rb
 
     def local_date_in_words datetime
-      datetime.to_time.localtime.to_datetime.strftime("%a %d %b %Y, %l:%M%P %:z").gsub('  ', ' ')
+      datetime.to_time.localtime.to_datetime.strftime("%a %d %b %Y, %l:%M%P %:z").gsub("  ", " ")
     end
 
     class Locale
@@ -19,6 +19,7 @@ module PactBroker
       end
     end
 
+    # rubocop: disable Metrics/CyclomaticComplexity, Metrics/MethodLength
     def distance_of_time_in_words(from_time, to_time = 0, options = {})
       options = {
         scope: :'datetime.distance_in_words'
@@ -35,59 +36,60 @@ module PactBroker
       # locale = I18n.with_options :locale => options[:locale], :scope => options[:scope]
       locale = Locale.new(:locale => options[:locale], :scope => options[:scope])
       case distance_in_minutes
-        when 0..1
-          return distance_in_minutes == 0 ?
-                 locale.t(:less_than_x_minutes, :count => 1) :
-                 locale.t(:x_minutes, :count => distance_in_minutes) unless options[:include_seconds]
+      when 0..1
+        return distance_in_minutes == 0 ?
+          locale.t(:less_than_x_minutes, :count => 1) :
+          locale.t(:x_minutes, :count => distance_in_minutes) unless options[:include_seconds]
 
-          case distance_in_seconds
-            when 0..4   then locale.t :less_than_x_seconds, :count => 5
-            when 5..9   then locale.t :less_than_x_seconds, :count => 10
-            when 10..19 then locale.t :less_than_x_seconds, :count => 20
-            when 20..39 then locale.t :half_a_minute
-            when 40..59 then locale.t :less_than_x_minutes, :count => 1
-            else             locale.t :x_minutes,           :count => 1
-          end
+        case distance_in_seconds
+        when 0..4   then locale.t :less_than_x_seconds, :count => 5
+        when 5..9   then locale.t :less_than_x_seconds, :count => 10
+        when 10..19 then locale.t :less_than_x_seconds, :count => 20
+        when 20..39 then locale.t :half_a_minute
+        when 40..59 then locale.t :less_than_x_minutes, :count => 1
+        else             locale.t :x_minutes,           :count => 1
+        end
 
-        when 2...45           then locale.t :x_minutes,      :count => distance_in_minutes
-        when 45...90          then locale.t :about_x_hours,  :count => 1
+      when 2...45           then locale.t :x_minutes,      :count => distance_in_minutes
+      when 45...90          then locale.t :about_x_hours,  :count => 1
         # 90 mins up to 24 hours
-        when 90...1440        then locale.t :about_x_hours,  :count => (distance_in_minutes.to_f / 60.0).round
+      when 90...1440        then locale.t :about_x_hours,  :count => (distance_in_minutes.to_f / 60.0).round
         # 24 hours up to 42 hours
-        when 1440...2520      then locale.t :x_days,         :count => 1
+      when 1440...2520      then locale.t :x_days,         :count => 1
         # 42 hours up to 30 days
-        when 2520...43200     then locale.t :x_days,         :count => (distance_in_minutes.to_f / 1440.0).round
+      when 2520...43200     then locale.t :x_days,         :count => (distance_in_minutes.to_f / 1440.0).round
         # 30 days up to 60 days
-        when 43200...86400    then locale.t :about_x_months, :count => (distance_in_minutes.to_f / 43200.0).round
+      when 43200...86400    then locale.t :about_x_months, :count => (distance_in_minutes.to_f / 43200.0).round
         # 60 days up to 365 days
-        when 86400...525600   then locale.t :x_months,       :count => (distance_in_minutes.to_f / 43200.0).round
+      when 86400...525600   then locale.t :x_months,       :count => (distance_in_minutes.to_f / 43200.0).round
+      else
+        if from_time.respond_to?(:acts_like_time?) && to_time.respond_to?(:acts_like_time?)
+          fyear = from_time.year
+          fyear += 1 if from_time.month >= 3
+          tyear = to_time.year
+          tyear -= 1 if to_time.month < 3
+          leap_years = (fyear > tyear) ? 0 : (fyear..tyear).count{|x| Date.leap?(x)}
+          minute_offset_for_leap_year = leap_years * 1440
+          # Discount the leap year days when calculating year distance.
+          # e.g. if there are 20 leap year days between 2 dates having the same day
+          # and month then the based on 365 days calculation
+          # the distance in years will come out to over 80 years when in written
+          # English it would read better as about 80 years.
+          minutes_with_offset = distance_in_minutes - minute_offset_for_leap_year
+        else
+          minutes_with_offset = distance_in_minutes
+        end
+        remainder                   = (minutes_with_offset % 525600)
+        distance_in_years           = (minutes_with_offset.div 525600)
+        if remainder < 131400
+          locale.t(:about_x_years,  :count => distance_in_years)
+        elsif remainder < 394200
+          locale.t(:over_x_years,   :count => distance_in_years)
         else
-          if from_time.respond_to?(:acts_like_time?) && to_time.respond_to?(:acts_like_time?)
-            fyear = from_time.year
-            fyear += 1 if from_time.month >= 3
-            tyear = to_time.year
-            tyear -= 1 if to_time.month < 3
-            leap_years = (fyear > tyear) ? 0 : (fyear..tyear).count{|x| Date.leap?(x)}
-            minute_offset_for_leap_year = leap_years * 1440
-            # Discount the leap year days when calculating year distance.
-            # e.g. if there are 20 leap year days between 2 dates having the same day
-            # and month then the based on 365 days calculation
-            # the distance in years will come out to over 80 years when in written
-            # English it would read better as about 80 years.
-            minutes_with_offset = distance_in_minutes - minute_offset_for_leap_year
-          else
-            minutes_with_offset = distance_in_minutes
-          end
-          remainder                   = (minutes_with_offset % 525600)
-          distance_in_years           = (minutes_with_offset.div 525600)
-          if remainder < 131400
-            locale.t(:about_x_years,  :count => distance_in_years)
-          elsif remainder < 394200
-            locale.t(:over_x_years,   :count => distance_in_years)
-          else
-            locale.t(:almost_x_years, :count => distance_in_years + 1)
-          end
+          locale.t(:almost_x_years, :count => distance_in_years + 1)
         end
       end
+    end
+    # rubocop: enable Metrics/CyclomaticComplexity, Metrics/MethodLength
   end
 end

data/lib/pact_broker/db.rb

@@ -1,9 +1,9 @@
-require 'sequel'
-require 'pact_broker/db/validate_encoding'
-require 'pact_broker/db/migrate'
-require 'pact_broker/db/migrate_data'
-require 'pact_broker/db/version'
-require 'pact_broker/db/table_dependency_calculator'
+require "sequel"
+require "pact_broker/db/validate_encoding"
+require "pact_broker/db/migrate"
+require "pact_broker/db/migrate_data"
+require "pact_broker/db/version"
+require "pact_broker/db/table_dependency_calculator"
 
 Sequel.datetime_class = DateTime
 
@@ -32,13 +32,17 @@ module PactBroker
       Sequel::TimestampMigrator.is_current?(database_connection, PactBroker::DB::MIGRATIONS_DIR, options)
     end
 
+    def self.check_current database_connection, options = {}
+      Sequel::TimestampMigrator.check_current(database_connection, PactBroker::DB::MIGRATIONS_DIR, options)
+    end
+
     def self.truncate database_connection, options = {}
       exceptions = options[:except] || []
       TableDependencyCalculator.call(database_connection).each do | table_name |
         if !exceptions.include?(table_name)
           begin
             database_connection[table_name].truncate
-          rescue StandardError => e
+          rescue StandardError => _ex
             puts "Could not truncate table #{table_name}"
           end
         end