pact_broker 2.45.0 → 2.46.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '018d04fa3d6dbb44832534462f7fbb54d033ffdbabd390ed155507ee126b51d4'
-  data.tar.gz: 404a22118fe03caa9dc0891b610aaf92211cb7f3417a465ed7ed80a6f27abb94
+  metadata.gz: e4afa0b6a3444f1fdf6ea852bed8016f63cccd1a5373aa0903be0d206f528bc6
+  data.tar.gz: cd86a0d032bb39ffe2f4318116cc9e51886fc3d3e84bf8c537d6bae5ee0f9d52
 SHA512:
-  metadata.gz: 1f6e74be59f0704398d686b4de7f6ca8b3fda020b8ba7ba92c9743ead1b580cda709631bf03f325024b92755b6ee50eb969f961e5d97203a36f506101ee9456a
-  data.tar.gz: 9a3a640ce7ac8f942de1150d1641c29db951cc9947371bfd0bdd6d1dd7139e3a815fba0fd400b247e344737cb30447eae856cc0f157e25a934d53e2d49a342c1
+  metadata.gz: 217a6da9c4b27d6959695eefa1c6b8c13526c827222d114cb6527d20fc9fceec194498ffa84ee6f10e574f96a353429bfdacf18f6b6494826e12aea5d58fc7ba
+  data.tar.gz: 1632aac1111449205a45ca9367093d2e4557e75a163a8c516248486f7a7e884cbf9205302ba8c5e1f4c01c8ff604bbebdaeef6729a1bc03e9dd97ec7f0afa850

data/.travis.yml

@@ -27,16 +27,3 @@ script:
   - bundle exec rake
   - if [ "$DATABASE_ADAPTER" == "postgres" ]; then ./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT || true; fi
   # - if [ ! -z "$(ruby --version | grep '2\.4\.')" ]; then ./script/db-spec.sh; fi
-jobs:
-  include:
-    - stage: gem release
-      before_script: echo ""
-      script: echo "Deploying to rubygems.org ..."
-      deploy:
-        provider: rubygems
-        api_key:
-          secure: AzTHDbKRr1ZO4E2mRyvU054Tx8c2cZbKkoDBZjSAQ2CY3E7oH137NTAIGd4BthH/E9mbEXtGpZIDfWPbaOcUJQ5Bz24CWTKmGyic6FrPhJnOW5CKVSLGCDPzpmqHULv/GTN16YN0Dh1HLeGYZzlHlxT0+4AVvbvBAleHrAFeJs8=
-        gem: pact_broker
-        on:
-          tags: true
-          repo: pact-foundation/pact_broker

data/CHANGELOG.md

@@ -1,3 +1,24 @@
+<a name="v2.46.0"></a>
+### v2.46.0 (2020-01-30)
+
+
+#### Features
+
+* allow the base URL of the application to be set for the API	 ([73bd4c44](/../../commit/73bd4c44))
+* correct logs relation to pb:logs in the triggered webhooks resource	 ([89ea1a58](/../../commit/89ea1a58))
+
+* **pacts for verification**
+  * add pre and post verification messages that can be displayed to the user based on whether or not the verification has passed or failed	 ([bb079858](/../../commit/bb079858))
+  * allow all versions for a particular tag to be verified (eg. all prod versions of a mobile consumer)	 ([e16feef6](/../../commit/e16feef6))
+  * optimise queries for determining which provider version tags are pending	 ([b4e1461a](/../../commit/b4e1461a))
+
+
+#### Bug Fixes
+
+* **pacts for verification**
+  * set includePendingStatus to false by default	 ([9b3162ac](/../../commit/9b3162ac))
+
+
 <a name="v2.45.0"></a>
 ### v2.45.0 (2020-01-30)
 

data/lib/db.rb

@@ -25,11 +25,17 @@ module DB
   # pool, as noted in the documentation for the extension.
   #
   def self.connect db_credentials
+    # Keep this conifiguration in sync with lib/pact_broker/app.rb#configure_database_connection
     Sequel.datetime_class = DateTime
     # logger = Logger.new($stdout)
     con = Sequel.connect(db_credentials.merge(:logger => logger, :pool_class => Sequel::ThreadedConnectionPool, :encoding => 'utf8'))
     con.extension(:connection_validator)
     con.extension(:pagination)
+    con.extend_datasets do
+      def any?
+        !empty?
+      end
+    end
     con.pool.connection_validation_timeout = -1 #Check the connection on every request
     con.timezone = :utc
     con.run("SET sql_mode='STRICT_TRANS_TABLES';") if db_credentials[:adapter].to_s =~ /mysql/
@@ -49,7 +55,7 @@ module DB
   end
 
   def self.mysql?
-    PACT_BROKER_DB.adapter_scheme.to_s =~ /mysql/
+    !!(PACT_BROKER_DB.adapter_scheme.to_s =~ /mysql/)
   end
 
   PACT_BROKER_DB ||= connection_for_env ENV.fetch('RACK_ENV')

data/lib/pact_broker/api/contracts/verifiable_pacts_json_query_schema.rb

@@ -18,7 +18,7 @@ module PactBroker
           optional(:consumerVersionSelectors).each do
             schema do
               required(:tag).filled(:str?)
-              required(:latest).filled(included_in?: [true])
+              optional(:latest).filled(included_in?: [true, false])
             end
           end
           optional(:includePendingStatus).filled(included_in?: [true, false])

data/lib/pact_broker/api/contracts/verifiable_pacts_query_schema.rb

@@ -17,7 +17,7 @@ module PactBroker
           optional(:consumer_version_selectors).each do
             schema do
               required(:tag).filled(:str?)
-              required(:latest).filled(included_in?: ["true"])
+              optional(:latest).filled(included_in?: ["true", "false"])
             end
           end
           optional(:include_pending_status).filled(included_in?: ["true", "false"])

data/lib/pact_broker/api/decorators/triggered_webhook_decorator.rb

@@ -12,7 +12,7 @@ module PactBroker
 
         property :created_at, as: :triggeredAt
 
-        link :logs do | context |
+        link :'pb:logs' do | context |
           {
             href: triggered_webhook_logs_url(represented, context[:base_url]),
             title: "Webhook execution logs",
@@ -20,6 +20,14 @@ module PactBroker
           }
         end
 
+        link :logs do | context |
+          {
+            href: triggered_webhook_logs_url(represented, context[:base_url]),
+            title: "DEPRECATED - Use pb:logs",
+            name: represented.request_description
+          }
+        end
+
         link :'pb:webhook' do | context |
           {
             href: webhook_url(represented.webhook_uuid, context[:base_url]),

data/lib/pact_broker/api/decorators/verifiable_pact_decorator.rb

@@ -30,25 +30,33 @@ module PactBroker
           property :notices, getter: -> (context) { context[:decorator].notices(context[:options][:user_options]) }
           property :noteToDevelopers, getter: -> (_) { "Please print out the text from the 'notices' rather than using the inclusionReason and the pendingReason fields. These will be removed when this API moves out of beta."}
 
-          def inclusion_reason(pact_url)
-            PactBroker::Pacts::VerifiablePactMessages.new(represented, pact_url).inclusion_reason
-          end
-
-          def pending_reason(pact_url)
-            PactBroker::Pacts::VerifiablePactMessages.new(represented, pact_url).pending_reason
-          end
-
           def notices(user_options)
+            # TODO move this out of the decorator
             pact_url = pact_version_url(represented, user_options[:base_url])
-            mess = [{
-              timing: 'pre_verification',
-              text: inclusion_reason(pact_url)
+            messages = PactBroker::Pacts::VerifiablePactMessages.new(represented, pact_url)
+
+            the_notices = [{
+              when: 'before_verification',
+              text: messages.inclusion_reason
             }]
-            mess << {
-              timing: 'pre_verification',
-              text: pending_reason(pact_url)
-            } if user_options[:include_pending_status]
-            mess
+
+            if user_options[:include_pending_status]
+              append_notice(the_notices, 'before_verification', messages.pending_reason)
+              append_notice(the_notices, 'after_verification:success_true_published_false', messages.verification_success_true_published_false)
+              append_notice(the_notices, 'after_verification:success_false_published_false', messages.verification_success_false_published_false)
+              append_notice(the_notices, 'after_verification:success_true_published_true', messages.verification_success_true_published_true)
+              append_notice(the_notices, 'after_verification:success_false_published_true', messages.verification_success_false_published_true)
+            end
+            the_notices
+          end
+
+          def append_notice the_notices, the_when, text
+            if text
+              the_notices << {
+                when: the_when,
+                text: text
+              }
+            end
           end
         end
 

data/lib/pact_broker/api/decorators/verifiable_pacts_query_decorator.rb

@@ -19,7 +19,7 @@ module PactBroker
             }
         end
 
-        property :include_pending_status, default: true,
+        property :include_pending_status, default: false,
           setter: ->(fragment:, represented:, **) {
             represented.include_pending_status = (fragment == 'true' || fragment == true)
           }

data/lib/pact_broker/api/resources/base_resource.rb

@@ -59,7 +59,7 @@ module PactBroker
         alias_method :path_info, :identifier_from_path
 
         def base_url
-          request.base_uri.to_s.chomp('/')
+          PactBroker.configuration.base_url || request.base_uri.to_s.chomp('/')
         end
 
         def charsets_provided

data/lib/pact_broker/api/resources/triggered_webhook_logs.rb

@@ -26,7 +26,7 @@ module PactBroker
 
         def triggered_webhook
           @triggered_webhook ||= begin
-            criteria = {webhook_uuid: identifier_from_path[:uuid], trigger_uuid: identifier_from_path[:trigger_uuid]}
+            criteria = { webhook_uuid: identifier_from_path[:uuid], trigger_uuid: identifier_from_path[:trigger_uuid] }
             PactBroker::Webhooks::TriggeredWebhook.where(criteria).single_record
           end
         end

data/lib/pact_broker/app.rb

@@ -4,7 +4,6 @@ require 'pact_broker/project_root'
 require 'pact_broker/logging/default_formatter'
 require 'rack-protection'
 require 'rack/hal_browser'
-require 'rack/pact_broker/store_base_url'
 require 'rack/pact_broker/add_pact_broker_version_header'
 require 'rack/pact_broker/convert_file_extension_to_accept_header'
 require 'rack/pact_broker/database_transaction'
@@ -106,11 +105,18 @@ module PactBroker
     end
 
     def configure_database_connection
+      # Keep this configuration in sync with lib/db.rb
       PactBroker::DB.connection = configuration.database_connection
       PactBroker::DB.connection.timezone = :utc
+      PactBroker::DB.connection.extend_datasets do
+        def any?
+          !empty?
+        end
+      end
       PactBroker::DB.validate_connection_config if configuration.validate_database_connection_config
       PactBroker::DB.set_mysql_strict_mode_if_mysql
       PactBroker::DB.connection.extension(:pagination)
+
       Sequel.datetime_class = DateTime
       Sequel.database_timezone = :utc # Store all dates in UTC, assume any date without a TZ is UTC
       Sequel.application_timezone = :local # Convert dates to localtime when retrieving from database
@@ -152,7 +158,6 @@ module PactBroker
       end
       @app_builder.use Rack::PactBroker::InvalidUriProtection
       @app_builder.use Rack::PactBroker::ResetThreadData
-      @app_builder.use Rack::PactBroker::StoreBaseURL
       @app_builder.use Rack::PactBroker::AddPactBrokerVersionHeader
       @app_builder.use Rack::PactBroker::AddVaryHeader
       @app_builder.use Rack::Static, :urls => ["/stylesheets", "/css", "/fonts", "/js", "/javascripts", "/images"], :root => PactBroker.project_root.join("public")

data/lib/pact_broker/configuration.rb

@@ -33,7 +33,7 @@ module PactBroker
       :seed_example_data
     ]
 
-    attr_accessor :log_dir, :database_connection, :auto_migrate_db, :auto_migrate_db_data, :example_data_seeder, :seed_example_data, :use_hal_browser, :html_pact_renderer, :use_rack_protection
+    attr_accessor :base_url, :log_dir, :database_connection, :auto_migrate_db, :auto_migrate_db_data, :example_data_seeder, :seed_example_data, :use_hal_browser, :html_pact_renderer, :use_rack_protection
     attr_accessor :validate_database_connection_config, :enable_diagnostic_endpoints, :version_parser, :sha_generator
     attr_accessor :use_case_sensitive_resource_names, :order_versions_by_date
     attr_accessor :check_for_potential_duplicate_pacticipant_names
@@ -176,10 +176,6 @@ module PactBroker
       self.enable_public_badge_access = enable_badge_resources
     end
 
-    def base_url
-      ENV['PACT_BROKER_BASE_URL']
-    end
-
     def save_to_database
       # Can't require a Sequel::Model class before the connection has been set
       require 'pact_broker/config/save'

data/lib/pact_broker/matrix/repository.rb

@@ -97,9 +97,9 @@ module PactBroker
 
       private
 
-      # If one of the specified pacticipants is a consumer, then that provider is required to be deployed
+      # If a specified pacticipant is a consumer, then its provider is required to be deployed
       # to the same environment before the consumer can be deployed.
-      # If one of the specified pacticipants is a provider, then the provider may be deployed
+      # If a specified pacticipant is a provider only, then it may be deployed
       # without the consumer being present.
       def is_a_row_for_this_integration_required?(specified_pacticipant_names, consumer_name)
         specified_pacticipant_names.include?(consumer_name)

data/lib/pact_broker/pacts/pact_publication.rb

@@ -25,10 +25,63 @@ module PactBroker
       dataset_module do
         include PactBroker::Repositories::Helpers
 
+        def remove_overridden_revisions
+          join(:latest_pact_publication_ids_for_consumer_versions, { Sequel[:lp][:pact_publication_id] => Sequel[:pact_publications][:id] }, { table_alias: :lp})
+        end
+
+        def join_consumer_versions(table_alias = :cv)
+          join(:versions, { Sequel[:pact_publications][:consumer_version_id] => Sequel[table_alias][:id] }, { table_alias: table_alias })
+        end
+
+        def join_consumer_version_tags(table_alias = :ct)
+          join(:tags, { Sequel[table_alias][:version_id] => Sequel[:pact_publications][:consumer_version_id]}, { table_alias: table_alias })
+        end
+
+        def join_consumer_version_tags_with_names(consumer_version_tag_names)
+          join(:tags, {
+            Sequel[:ct][:version_id] => Sequel[:pact_publications][:consumer_version_id],
+            Sequel[:ct][:name] => consumer_version_tag_names
+          }, {
+            table_alias: :ct
+          })
+        end
+
+        def join_providers(table_alias = :providers)
+          join(:pacticipants, { Sequel[:pact_publications][:provider_id] => Sequel[table_alias][:id] }, { table_alias: table_alias })
+        end
+
+        def join_consumers(table_alias = :consumers)
+          join(:pacticipants, { Sequel[:pact_publications][:consumer_id] => Sequel[table_alias][:id] }, { table_alias: table_alias })
+        end
+
+        def join_pact_versions
+          join(:pact_versions, { Sequel[:pact_publications][:pact_version_id] => Sequel[:pact_versions][:id] })
+        end
+
+        def eager_load_pact_versions
+          eager(:pact_versions)
+        end
+
         def tag tag_name
           filter = name_like(Sequel.qualify(:tags, :name), tag_name)
           join(:tags, {version_id: :consumer_version_id}).where(filter)
         end
+
+        def provider_name_like(name)
+          where(name_like(Sequel[:providers][:name], name))
+        end
+
+        def consumer_version_tag(tag)
+          where(Sequel[:ct][:name] => tag)
+        end
+
+        def order_by_consumer_name
+          order_append_ignore_case(Sequel[:consumers][:name])
+        end
+
+        def order_by_consumer_version_order
+          order_append(Sequel[:cv][:order])
+        end
       end
 
       def before_create

data/lib/pact_broker/pacts/pact_version.rb

@@ -52,21 +52,31 @@ module PactBroker
 
       def select_provider_tags_with_successful_verifications(tags)
         tags.select do | tag |
+          verifications_join = {
+            Sequel[:verifications][:pact_version_id] => Sequel[:pact_versions][:id],
+            Sequel[:verifications][:success] => true
+          }
+          tags_join = {
+            Sequel[:tags][:version_id] => Sequel[:versions][:id],
+            Sequel[:tags][:name] => tag
+          }
           PactVersion.where(Sequel[:pact_versions][:id] => id)
-            .join(:verifications, Sequel[:verifications][:pact_version_id] => Sequel[:pact_versions][:id])
+            .join(:verifications, verifications_join)
             .join(:versions, Sequel[:versions][:id] => Sequel[:verifications][:provider_version_id])
-            .join(:tags, Sequel[:tags][:version_id] => Sequel[:versions][:id])
-            .where(Sequel[:tags][:name] => tag)
-            .where(Sequel[:verifications][:success] => true)
+            .join(:tags, tags_join)
             .any?
         end
       end
 
       def verified_successfully_by_any_provider_version?
+        verifications_join = {
+          Sequel[:verifications][:pact_version_id] => Sequel[:pact_versions][:id],
+          Sequel[:verifications][:pact_version_id] => id,
+          Sequel[:verifications][:success] => true
+        }
         PactVersion.where(Sequel[:pact_versions][:id] => id)
-          .join(:verifications, Sequel[:verifications][:pact_version_id] => Sequel[:pact_versions][:id])
+          .join(:verifications, verifications_join)
           .join(:versions, Sequel[:versions][:id] => Sequel[:verifications][:provider_version_id])
-          .where(Sequel[:verifications][:success] => true)
           .any?
       end
 

data/lib/pact_broker/pacts/repository.rb

@@ -13,6 +13,7 @@ require 'pact_broker/pacts/parse'
 require 'pact_broker/matrix/head_row'
 require 'pact_broker/pacts/latest_pact_publication_id_for_consumer_version'
 require 'pact_broker/pacts/verifiable_pact'
+require 'pact_broker/repositories/helpers'
 
 module PactBroker
   module Pacts
@@ -20,6 +21,7 @@ module PactBroker
 
       include PactBroker::Logging
       include PactBroker::Repositories
+      include PactBroker::Repositories::Helpers
 
       def create params
         pact_version = find_or_create_pact_version(
@@ -125,36 +127,60 @@ module PactBroker
         end
       end
 
+      def find_all_pact_versions_for_provider_with_tags provider_name, consumer_version_tag_names
+        provider = pacticipant_repository.find_by_name(provider_name)
+
+        PactPublication
+          .select_all_qualified
+          .select_append(Sequel[:cv][:order].as(:consumer_version_order))
+          .remove_overridden_revisions
+          .join_consumer_versions(:cv)
+          .join_consumer_version_tags_with_names(consumer_version_tag_names)
+          .where(provider: provider)
+          .eager(:consumer)
+          .eager(:consumer_version)
+          .eager(:provider)
+          .eager(:pact_version)
+          .all
+          .group_by(&:pact_version_id)
+          .values
+          .collect{ | pacts| pacts.sort_by{|pact| pact.values.fetch(:consumer_version_order) }.last }
+          .collect(&:to_domain)
+      end
+
       # To find the work in progress pacts for this verification execution:
       # For each provider tag that will be applied to this verification result (usually there will just be one, but
       # we have to allow for multiple tags),
       # find the head pacts (the pacts that are the latest for their tag) that have been successfully
       # verified against the provider tag.
       # Then, find all the head pacts, and remove the ones that have been successfully verified by ALL
-      # of the provider tags supplied.
+      # of the provider tags supplied, and the ones that were published before the include_wip_pacts_since date.
       # Then, for all of the head pacts that are remaining (these are the WIP ones) work out which
       # provider tags they are pending for.
-      # Don't include pact publications that were created
+      # Don't include pact publications that were created before the provider tag was first used
+      # (that is, before the provider's git branch was created).
       def find_wip_pact_versions_for_provider provider_name, provider_tags_names = [], options = {}
+        # TODO not sure about this
         return [] if provider_tags_names.empty?
 
         provider = pacticipant_repository.find_by_name(provider_name)
 
-        # Hash of provider tag names => list of head pacts
-        successfully_verified_head_pacts_for_provider_tags = find_successfully_verified_head_pacts_by_provider_tag(provider_name, provider_tags_names, options)
+        # Hash of provider tag name => list of head pacts that have been successfully verified by that tag
+        successfully_verified_head_pacts_for_provider_tags = find_successfully_verified_head_pacts_by_provider_tag(provider.id, provider_tags_names, options)
+        # Create hash of provider tag name => list of pact publication ids
         successfully_verified_head_pact_publication_ids_for_each_provider_tag = successfully_verified_head_pacts_for_provider_tags.each_with_object({}) do | (provider_tag_name, head_pacts), hash |
-          hash[provider_tag_name] = head_pacts.collect(&:id)
+          hash[provider_tag_name] = head_pacts.collect(&:id).uniq
         end
 
-        # list of pact_publication_ids that are NOT work in progress
-        head_pact_publication_ids_successully_verified_by_all_provider_tags = successfully_verified_head_pacts_for_provider_tags.values.collect{ |head_pacts| head_pacts.collect(&:id) }.reduce(:&)
+        # list of head pact_publication_ids that are NOT work in progress because they've been verified by all of the provider version tags supplied
+        non_wip_pact_publication_ids = successfully_verified_head_pacts_for_provider_tags.values.collect{ |head_pacts| head_pacts.collect(&:id) }.reduce(:&)
 
-        pact_publication_ids = find_head_pacts_that_have_not_been_successfully_verified_by_all_provider_tags(
-          provider_name,
-          head_pact_publication_ids_successully_verified_by_all_provider_tags,
+        wip_pact_publication_ids = find_head_pacts_that_have_not_been_successfully_verified_by_all_provider_tags(
+          provider.id,
+          non_wip_pact_publication_ids,
           options)
 
-        pacts = AllPactPublications.where(id: pact_publication_ids).order_ignore_case(:consumer_name).order_append(:consumer_version_order)
+        wip_pacts = AllPactPublications.where(id: wip_pact_publication_ids).order_ignore_case(:consumer_name).order_append(:consumer_version_order)
 
         # The first instance (by date) of each provider tag with that name
         provider_tag_collection = PactBroker::Domain::Tag
@@ -166,7 +192,7 @@ module PactBroker
           .where(name: provider_tags_names)
           .all
 
-        pacts.collect do | pact|
+        wip_pacts.collect do | pact|
           pending_tag_names = find_provider_tags_for_which_pact_publication_id_is_pending(pact, successfully_verified_head_pact_publication_ids_for_each_provider_tag)
           pre_existing_tag_names = find_provider_tag_names_that_were_first_used_before_pact_published(pact, provider_tag_collection)
 
@@ -313,13 +339,33 @@ module PactBroker
 
       # Returns a list of Domain::Pact objects the represent pact publications
       def find_for_verification(provider_name, consumer_version_selectors)
+        find_pacts_for_which_the_latest_version_or_latest_version_for_the_tag_is_required(provider_name, consumer_version_selectors) +
+        find_pacts_for_which_all_versions_for_the_tag_are_required(provider_name, consumer_version_selectors)
+      end
+
+      private
+
+      def find_pacts_for_which_the_latest_version_or_latest_version_for_the_tag_is_required(provider_name, consumer_version_selectors)
+        # The tags for which only the latest version is specified
         latest_tags = consumer_version_selectors.any? ?
           consumer_version_selectors.select(&:latest).collect(&:tag) :
           nil
+
         find_latest_pact_versions_for_provider(provider_name, latest_tags)
       end
 
-      private
+      def find_pacts_for_which_all_versions_for_the_tag_are_required(provider_name, consumer_version_selectors)
+        # The tags for which all versions are specified
+        all_tags = consumer_version_selectors.any? ?
+          consumer_version_selectors.reject(&:latest).collect(&:tag) :
+          nil
+
+        if all_tags
+          find_all_pact_versions_for_provider_with_tags(provider_name, all_tags)
+        else
+          []
+        end
+      end
 
       def find_previous_distinct_pact_by_sha pact
         current_pact_content_sha =
@@ -389,27 +435,35 @@ module PactBroker
         end
       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)
+      def find_head_pacts_that_have_not_been_successfully_verified_by_all_provider_tags(provider_id, 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)
+        LatestTaggedPactPublications
+          .where(provider_id: provider_id)
           .where(Sequel.lit('latest_tagged_pact_publications.created_at > ?', options.fetch(:include_wip_pacts_since)))
+          .exclude(id: pact_publication_ids_successfully_verified_by_all_provider_tags)
           .select_for_subquery(:id)
       end
 
-      # Find the head pacts that have been successfully verified by a provider version with the specified tags
-      # Returns a Hash of provider_tag => LatestTaggedPactPublications with only id and tag_name populated
-      def find_successfully_verified_head_pacts_by_provider_tag(provider_name, provider_tags, options)
+      # Find the head pacts that have been successfully verified by a provider version with the specified
+      # provider version tags.
+      # Returns a Hash of provider_tag => LatestTaggedPactPublications with only pact publication id and tag_name populated
+      # This is the list of pacts we are EXCLUDING from the WIP list because they have already been verified successfully
+      def find_successfully_verified_head_pacts_by_provider_tag(provider_id, provider_tags, options)
         provider_tags.compact.each_with_object({}) do | provider_tag, hash |
+          verifications_join = {
+            pact_version_id: :pact_version_id,
+            Sequel[:verifications][:success] => true,
+            Sequel[:verifications][:provider_id] => provider_id
+          }
+          tags_join = {
+            Sequel[:verifications][:provider_version_id] => Sequel[:provider_tags][:version_id],
+            Sequel[:provider_tags][:name] => provider_tag
+          }
           head_pacts = 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)
-            .or(Sequel.lit('latest_tagged_pact_publications.created_at < ?', options.fetch(:include_wip_pacts_since)))
-            .select(Sequel[:latest_tagged_pact_publications][:id].as(:id), :tag_name)
+            .select(Sequel[:latest_tagged_pact_publications][:id].as(:id))
+            .join(:verifications, verifications_join)
+            .join(:tags, tags_join, { table_alias: :provider_tags } )
+            .where(Sequel[:latest_tagged_pact_publications][:provider_id] => provider_id)
             .all
           hash[provider_tag] = head_pacts
         end

data/lib/pact_broker/pacts/verifiable_pact_messages.rb

@@ -35,6 +35,28 @@ module PactBroker
         end
       end
 
+      def verification_success_true_published_false
+        if pending?
+          "This pact is still in pending state for #{pending_provider_tags_description} as the successful verification results #{with_these_tags}have not yet been published."
+        end
+      end
+
+      def verification_success_true_published_true
+        if pending?
+          "This pact is no longer in pending state for #{pending_provider_tags_description}, as a successful verification result #{with_these_tags}has been published. If a verification for a version with  fails in the future, it will fail the build. #{READ_MORE_PENDING}"
+        end
+      end
+
+      def verification_success_false_published_false
+        if pending?
+          "This pact is still in pending state for #{pending_provider_tags_description} as a successful verification result #{with_these_tags}has not yet been published"
+        end
+      end
+
+      def verification_success_false_published_true
+        verification_success_false_published_false
+      end
+
       private
 
       attr_reader :verifiable_pact, :pact_version_url
@@ -77,6 +99,14 @@ module PactBroker
         else "a version of #{provider_name} with tag #{join(non_pending_provider_tags)}"
         end
       end
+
+      def with_these_tags
+        case pending_provider_tags.size
+        when 0 then ""
+        when 1 then "with this tag "
+        else "with these tags "
+        end
+      end
     end
   end
 end

data/lib/pact_broker/repositories/helpers.rb

@@ -23,6 +23,10 @@ module PactBroker
         order(Sequel.function(:lower, column_name))
       end
 
+      def order_append_ignore_case column_name = :name
+        order_append(Sequel.function(:lower, column_name))
+      end
+
       def mysql?
         Sequel::Model.db.adapter_scheme.to_s =~ /mysql/
       end

data/lib/pact_broker/test/test_data_builder.rb

@@ -252,6 +252,10 @@ module PactBroker
         create_webhook(parameters.merge(consumer: nil, provider: nil))
       end
 
+      def create_global_contract_content_changed_webhook parameters = {}
+        create_webhook(parameters.merge(consumer: nil, provider: nil, event_names: [PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED]))
+      end
+
       def create_global_verification_webhook parameters = {}
         create_webhook(parameters.merge(consumer: nil, provider: nil, event_names: [PactBroker::Webhooks::WebhookEvent::VERIFICATION_PUBLISHED]))
       end

data/lib/pact_broker/version.rb

@@ -1,3 +1,3 @@
 module PactBroker
-  VERSION = '2.45.0'
+  VERSION = '2.46.0'
 end

data/pact_broker.gemspec

@@ -48,7 +48,7 @@ Gem::Specification.new do |gem|
   gem.add_runtime_dependency 'roar', '~> 1.1'
   gem.add_runtime_dependency 'reform', '~> 2.2'
   gem.add_runtime_dependency 'dry-validation', '~> 0.10.5'
-  gem.add_runtime_dependency 'sequel', '~> 5.6'
+  gem.add_runtime_dependency 'sequel', '~> 5.28'
   gem.add_runtime_dependency 'webmachine', '1.5.0'
   gem.add_runtime_dependency 'semver2', '~> 3.4.2'
   gem.add_runtime_dependency 'rack', '>= 2.0.8', '~>2.0'

data/script/generate-certificates-for-webooks-certificate-spec.rb

@@ -1,4 +1,12 @@
 #Code to generate certificates
+
+# To generate a self signed CA certificate for use in a server:
+# root_ca.add_extension(ef.create_extension("basicConstraints","CA:TRUE",true))
+# root_ca.add_extension(ef.create_extension("keyUsage","keyCertSign, cRLSign", true))
+# root_ca.add_extension(ef.create_extension("subjectKeyIdentifier","hash",false))
+# root_ca.add_extension(ef.create_extension("authorityKeyIdentifier","keyid:always",false))
+# root_ca.add_extension(ef.create_extension("keyUsage","digitalSignature", true))
+
 require 'openssl'
 
 root_key = OpenSSL::PKey::RSA.new 2048 # the CA's public/private key

data/script/release.sh

@@ -5,6 +5,7 @@ bundle exec rake generate_changelog
 git add CHANGELOG.md lib/pact_broker/version.rb
 VERSION=$(ruby -r ./lib/pact_broker/version.rb -e "puts PactBroker::VERSION")
 git commit -m "chore(release): version ${VERSION}"
-git tag -a v${VERSION} -m "chore(release): version ${VERSION}"
-git push origin v${VERSION}
-git push origin master
+bundle exec rake release
+# git tag -a v${VERSION} -m "chore(release): version ${VERSION}"
+# git push origin v${VERSION}
+# git push origin master

data/script/seed-for-webhook-test.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+
+raise "Please supply database path" unless ARGV[0]
+
+$LOAD_PATH.unshift './lib'
+$LOAD_PATH.unshift './spec'
+$LOAD_PATH.unshift './tasks'
+ENV['RACK_ENV'] = 'development'
+require 'sequel'
+require 'logger'
+DATABASE_CREDENTIALS = {logger: Logger.new($stdout), adapter: "sqlite", database: ARGV[0], :encoding => 'utf8'}.tap { |it| puts it }
+#DATABASE_CREDENTIALS = {adapter: "postgres", database: "pact_broker", username: 'pact_broker', password: 'pact_broker', :encoding => 'utf8'}
+
+connection = Sequel.connect(DATABASE_CREDENTIALS)
+connection.timezone = :utc
+# Uncomment these lines to open a pry session for inspecting the database
+
+require 'pact_broker/db'
+PactBroker::DB.connection = connection
+require 'pact_broker'
+require 'support/test_data_builder'
+
+require 'database/table_dependency_calculator'
+PactBroker::Database::TableDependencyCalculator.call(connection).each do | table_name |
+  connection[table_name].delete
+end
+
+webhook_body = {
+  'pactUrl' => '${pactbroker.pactUrl}',
+  'verificationResultUrl' => '${pactbroker.verificationResultUrl}',
+  'consumerVersionNumber' => '${pactbroker.consumerVersionNumber}',
+  'providerVersionNumber' => '${pactbroker.providerVersionNumber}',
+  'providerVersionTags' => '${pactbroker.providerVersionTags}',
+  'consumerVersionTags' => '${pactbroker.consumerVersionTags}',
+  'consumerName' => '${pactbroker.consumerName}',
+  'providerName' => '${pactbroker.providerName}',
+  'githubVerificationStatus' => '${pactbroker.githubVerificationStatus}'
+}
+
+  # .create_global_webhook(
+  #   method: 'POST',
+  #   url: "http://localhost:9292/pact-changed-webhook",
+  #   body: webhook_body.to_json,
+  #   username: "foo",
+  #   password: "bar")
+
+PactBroker.configuration.base_equality_only_on_content_that_affects_verification_results = false
+
+TestDataBuilder.new
+    .create_global_contract_content_changed_webhook(
+      method: 'POST',
+      url: "http://localhost:9292/pact-changed-webhook",
+      body: webhook_body.to_json,
+      username: "foo",
+      password: "bar")
+    .create_global_verification_webhook(
+      method: 'POST',
+      url: "http://localhost:9292/verification-published-webhook",
+      body: webhook_body.to_json)

data/spec/lib/pact_broker/api/contracts/verifiable_pacts_json_query_schema_spec.rb

@@ -57,7 +57,7 @@ module PactBroker
             }]
           end
 
-          it { is_expected.to have_key(:consumerVersionSelectors) }
+          it { is_expected.to be_empty }
         end
 
         context "when includeWipPactsSince key exists" do

data/spec/lib/pact_broker/api/contracts/verifiable_pacts_query_schema_spec.rb

@@ -51,7 +51,7 @@ module PactBroker
             }]
           end
 
-          it { is_expected.to have_key(:consumer_version_selectors) }
+          it { is_expected.to be_empty }
         end
 
         context "when include_wip_pacts_since key exists" do

data/spec/lib/pact_broker/api/decorators/triggered_webhook_decorator_spec.rb

@@ -43,7 +43,7 @@ module PactBroker
         subject { JSON.parse(json, symbolize_names: true) }
 
         it "includes a link to the logs" do
-          expect(subject[:_links][:logs][:href]).to eq logs_url
+          expect(subject[:_links][:'pb:logs'][:href]).to eq logs_url
         end
 
         it "includes a link to the webhook" do

data/spec/lib/pact_broker/api/decorators/verifiable_pact_decorator_spec.rb

@@ -8,6 +8,10 @@ module PactBroker
           allow_any_instance_of(PactBroker::Api::PactBrokerUrls).to receive(:pact_version_url).and_return('/pact-version-url')
           allow_any_instance_of(PactBroker::Pacts::VerifiablePactMessages).to receive(:inclusion_reason).and_return("the inclusion reason")
           allow_any_instance_of(PactBroker::Pacts::VerifiablePactMessages).to receive(:pending_reason).and_return(pending_reason)
+          allow_any_instance_of(PactBroker::Pacts::VerifiablePactMessages).to receive(:verification_success_true_published_false).and_return('verification_success_true_published_false')
+          allow_any_instance_of(PactBroker::Pacts::VerifiablePactMessages).to receive(:verification_success_false_published_false).and_return('verification_success_false_published_false')
+          allow_any_instance_of(PactBroker::Pacts::VerifiablePactMessages).to receive(:verification_success_true_published_true).and_return('verification_success_true_published_true')
+          allow_any_instance_of(PactBroker::Pacts::VerifiablePactMessages).to receive(:verification_success_false_published_true).and_return('verification_success_false_published_true')
         end
         let(:pending_reason) { "the pending reason" }
         let(:expected_hash) do
@@ -16,9 +20,23 @@ module PactBroker
               "pending" => true,
               "notices" => [
                 {
+                  "when" => "before_verification",
                   "text" => "the inclusion reason"
-                }, {
+                },{
+                  "when" => "before_verification",
                   "text" => pending_reason
+                },{
+                  "when" => "after_verification:success_true_published_false",
+                  "text" => "verification_success_true_published_false"
+                },{
+                  "when" => "after_verification:success_false_published_false",
+                  "text" => "verification_success_false_published_false"
+                },{
+                  "when" => "after_verification:success_true_published_true",
+                  "text" => "verification_success_true_published_true"
+                },{
+                  "when" => "after_verification:success_false_published_true",
+                  "text" => "verification_success_false_published_true"
                 }
               ]
             },
@@ -60,7 +78,7 @@ module PactBroker
         end
 
         it "creates the inclusion message" do
-          expect(PactBroker::Pacts::VerifiablePactMessages).to receive(:new).twice.with(pact, '/pact-version-url').and_call_original
+          expect(PactBroker::Pacts::VerifiablePactMessages).to receive(:new).with(pact, '/pact-version-url').and_call_original
           subject
         end
 
@@ -76,6 +94,10 @@ module PactBroker
             expect(subject['verificationProperties']).to_not have_key('pendingReason')
             expect(notices).to_not include(pending_reason)
           end
+
+          it "does not include the pending notices" do
+            expect(subject['verificationProperties']['notices'].size).to eq 1
+          end
         end
 
         context "when wip is true" do

data/spec/lib/pact_broker/api/resources/base_resource_spec.rb

@@ -4,7 +4,7 @@ module PactBroker
   module Api
     module Resources
       describe BaseResource do
-        let(:request) { double('request', uri: uri).as_null_object }
+        let(:request) { double('request', uri: uri, base_uri: URI("http://example.org/")).as_null_object }
         let(:response) { double('response') }
         let(:uri) { URI('http://example.org/path?query') }
 
@@ -19,6 +19,28 @@ module PactBroker
             expect(subject.headers['Access-Control-Allow-Methods']).to eq "GET, OPTIONS"
           end
         end
+
+        describe "base_url" do
+          context "when PactBroker.configuration.base_url is not nil" do
+            before do
+              allow(PactBroker.configuration).to receive(:base_url).and_return("http://foo")
+            end
+
+            it "returns the configured base URL" do
+              expect(subject.base_url).to eq "http://foo"
+            end
+          end
+
+          context "when PactBroker.configuration.base_url is nil" do
+            before do
+              allow(PactBroker.configuration).to receive(:base_url).and_return(nil)
+            end
+
+            it "returns the base URL from the request" do
+              expect(subject.base_url).to eq "http://example.org"
+            end
+          end
+        end
       end
 
       ALL_RESOURCES = ObjectSpace.each_object(::Class).select {|klass| klass < BaseResource }

data/spec/lib/pact_broker/pacts/repository_find_for_verification_spec.rb

@@ -11,21 +11,35 @@ module PactBroker
           subject.find{ |pact| pact.consumer_version_number == consumer_version_number }
         end
 
+        def find_by_consumer_name_and_consumer_version_number(consumer_name, consumer_version_number)
+          subject.find{ |pact| pact.consumer_name == consumer_name && pact.consumer_version_number == consumer_version_number }
+        end
+
         before do
-          td.create_pact_with_hierarchy("Foo", "bar-latest-prod", "Bar")
+          td.create_pact_with_hierarchy("Foo", "foo-latest-prod-version", "Bar")
             .create_consumer_version_tag("prod")
-            .create_consumer_version("not-latest-dev", tag_names: ["dev"])
+            .create_consumer_version("not-latest-dev-version", tag_names: ["dev"])
             .comment("next pact not selected")
             .create_pact
-            .create_consumer_version("bar-latest-dev", tag_names: ["dev"])
+            .create_consumer_version("foo-latest-dev-version", tag_names: ["dev"])
             .create_pact
             .create_consumer("Baz")
-            .create_consumer_version("baz-latest-dev", tag_names: ["dev"])
+            .create_consumer_version("baz-latest-dev-version", tag_names: ["dev"])
             .create_pact
         end
 
         subject { Repository.new.find_for_verification("Bar", consumer_version_selectors) }
 
+        context "when there are no selectors" do
+          let(:consumer_version_selectors) { [] }
+
+          it "returns the latest pact for each consumer" do
+            expect(subject.size).to eq 2
+            expect(find_by_consumer_name_and_consumer_version_number("Foo", "foo-latest-dev-version")).to_not be nil
+            expect(find_by_consumer_name_and_consumer_version_number("Baz", "baz-latest-dev-version")).to_not be nil
+          end
+        end
+
         context "when consumer tag names are specified" do
           let(:pact_selector_1) { double('selector', tag: 'dev', latest: true) }
           let(:pact_selector_2) { double('selector', tag: 'prod', latest: true) }
@@ -34,14 +48,43 @@ module PactBroker
           end
 
           it "returns the latest pact with the specified tags for each consumer" do
-            expect(find_by_consumer_version_number("bar-latest-prod")).to_not be nil
-            expect(find_by_consumer_version_number("bar-latest-dev")).to_not be nil
-            expect(find_by_consumer_version_number("baz-latest-dev")).to_not be nil
+            expect(find_by_consumer_version_number("foo-latest-prod-version")).to_not be nil
+            expect(find_by_consumer_version_number("foo-latest-dev-version")).to_not be nil
+            expect(find_by_consumer_version_number("baz-latest-dev-version")).to_not be nil
             expect(subject.size).to eq 3
           end
 
           it "sets the latest_consumer_version_tag_names" do
-            expect(find_by_consumer_version_number("bar-latest-prod").tag).to eq 'prod'
+            expect(find_by_consumer_version_number("foo-latest-prod-version").tag).to eq 'prod'
+          end
+
+          context "when all versions with a given tag are requested" do
+            before do
+              td.create_pact_with_hierarchy("Foo2", "prod-version-1", "Bar2")
+                .create_consumer_version_tag("prod")
+                .create_consumer_version("not-prod-version", tag_names: %w[master])
+                .create_pact
+                .create_consumer_version("prod-version-2", tag_names: %w[prod])
+                .create_pact
+            end
+
+            let(:consumer_version_selectors) { [pact_selector_1] }
+            let(:pact_selector_1) { double('selector', tag: 'prod', latest: nil) }
+
+            subject { Repository.new.find_for_verification("Bar2", consumer_version_selectors) }
+
+            it "returns all the versions with the specified tag" do
+              expect(subject.size).to be 2
+              expect(find_by_consumer_version_number("prod-version-1")).to_not be nil
+              expect(find_by_consumer_version_number("prod-version-2")).to_not be nil
+            end
+
+            it "dedupes them to ensure that each pact version is only verified once" do
+              td.create_consumer_version("prod-version-3", tag_names: %w[prod])
+                .republish_same_pact
+              expect(subject.size).to be 2
+              expect(subject.collect(&:consumer_version_number)).to eq %w[prod-version-1 prod-version-3]
+            end
           end
         end
 
@@ -49,14 +92,14 @@ module PactBroker
           let(:consumer_version_selectors) { [] }
 
           it "returns the latest pact for each provider" do
-            expect(find_by_consumer_version_number("bar-latest-dev")).to_not be nil
-            expect(find_by_consumer_version_number("baz-latest-dev")).to_not be nil
+            expect(find_by_consumer_version_number("foo-latest-dev-version")).to_not be nil
+            expect(find_by_consumer_version_number("baz-latest-dev-version")).to_not be nil
             expect(subject.size).to eq 2
           end
 
           it "does not set the tag name" do
-            expect(find_by_consumer_version_number("bar-latest-dev").tag).to be nil
-            expect(find_by_consumer_version_number("bar-latest-dev").overall_latest?).to be true
+            expect(find_by_consumer_version_number("foo-latest-dev-version").tag).to be nil
+            expect(find_by_consumer_version_number("foo-latest-dev-version").overall_latest?).to be true
           end
         end
       end

data/spec/support/verification_job.rb

@@ -2,6 +2,8 @@ require 'sucker_punch'
 require 'faraday'
 require 'pact_broker/logging'
 
+
+# Publishes verification results, as if they were triggered by a CI job
 module PactBroker
   class VerificationJob
     include SuckerPunch::Job

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pact_broker
 version: !ruby/object:Gem::Version
-  version: 2.45.0
+  version: 2.46.0
 platform: ruby
 authors:
 - Bethany Skurrie
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-29 00:00:00.000000000 Z
+date: 2020-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -94,14 +94,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.6'
+        version: '5.28'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.6'
+        version: '5.28'
 - !ruby/object:Gem::Dependency
   name: webmachine
   requirement: !ruby/object:Gem::Requirement
@@ -1147,7 +1147,6 @@ files:
 - lib/rack/pact_broker/no_auth.rb
 - lib/rack/pact_broker/request_target.rb
 - lib/rack/pact_broker/reset_thread_data.rb
-- lib/rack/pact_broker/store_base_url.rb
 - lib/rack/pact_broker/ui_authentication.rb
 - lib/rack/pact_broker/ui_request_filter.rb
 - lib/webmachine/rack_adapter_monkey_patch.rb
@@ -1232,6 +1231,7 @@ files:
 - script/restart.sh
 - script/run-with-ssl.rb
 - script/seed-example-matrix.rb
+- script/seed-for-webhook-test.rb
 - script/seed-matrix.rb
 - script/seed.rb
 - script/update-hal-browser

data/lib/rack/pact_broker/store_base_url.rb

@@ -1,14 +0,0 @@
-module Rack
-  module PactBroker
-    class StoreBaseURL
-      def initialize app
-        @app = app
-      end
-
-      def call(env)
-        Thread.current[:pact_broker_thread_data].base_url ||= (ENV['PACT_BROKER_BASE_URL'] || ::Rack::Request.new(env).base_url)
-        @app.call(env)
-      end
-    end
-  end
-end