pact_broker 2.32.0 → 2.33.0

data/lib/pact_broker/integrations/integration.rb

@@ -8,3 +8,10 @@ module PactBroker
     end
   end
 end
+
+# Table: integrations
+# Columns:
+#  consumer_id   | integer |
+#  consumer_name | text    |
+#  provider_id   | integer |
+#  provider_name | text    |

data/lib/pact_broker/matrix/repository.rb

@@ -61,7 +61,6 @@ module PactBroker
         end
 
         integrations = find_integrations_for_specified_selectors(resolved_selectors.select(&:specified?))
-
         QueryResults.new(lines.sort, specified_selectors, options, resolved_selectors, integrations)
       end
 

data/lib/pact_broker/matrix/row.rb

@@ -41,33 +41,74 @@ module PactBroker
           end
         end
 
+        # find rows where (the consumer (and optional version) matches any of the selectors)
+        # AND
+        # the (provider (and optional version) matches any of the selectors OR the provider matches
+        #      and the verification is missing (and hence the provider version is null))
         def where_consumer_and_provider_in selectors
           where{
             Sequel.&(
               Sequel.|(
-                *selectors.collect do |s|
-                  if s[:pacticipant_version_id]
-                    Sequel.&(consumer_id: s[:pacticipant_id], consumer_version_id: s[:pacticipant_version_id])
-                  else
-                    Sequel.&(consumer_id: s[:pacticipant_id])
-                  end
-                end
+                *QueryHelper.consumer_and_maybe_consumer_version_match_any_selector(selectors)
               ),
               Sequel.|(
-                *(selectors.collect do |s|
-                  if s[:pacticipant_version_id]
-                    Sequel.&(provider_id: s[:pacticipant_id], provider_version_id: s[:pacticipant_version_id])
-                  else
-                    Sequel.&(provider_id: s[:pacticipant_id])
-                  end
-                end + selectors.collect do |s|
-                  Sequel.&(provider_id: s[:pacticipant_id], provider_version_id: nil)
-                end)
-              )
+                *QueryHelper.provider_and_maybe_provider_version_match_any_selector_or_verification_is_missing(selectors)
+              ),
+              QueryHelper.either_consumer_or_provider_was_specified_in_query(selectors)
             )
           }
         end
 
+        # Can't access other dataset_module methods from inside the Sequel `where{ ... }` block, so make a private class
+        # with some helper methods
+        class QueryHelper
+          def self.consumer_and_maybe_consumer_version_match_any_selector(selectors)
+            selectors.collect { |s| consumer_and_maybe_consumer_version_match_selector(s) }
+          end
+
+          def self.consumer_and_maybe_consumer_version_match_selector(s)
+            if s[:pacticipant_version_id]
+              Sequel.&(consumer_id: s[:pacticipant_id], consumer_version_id: s[:pacticipant_version_id])
+            else
+              Sequel.&(consumer_id: s[:pacticipant_id])
+            end
+          end
+
+          def self.provider_and_maybe_provider_version_match_selector(s)
+            if s[:pacticipant_version_id]
+              Sequel.&(provider_id: s[:pacticipant_id], provider_version_id: s[:pacticipant_version_id])
+            else
+              Sequel.&(provider_id: s[:pacticipant_id])
+            end
+          end
+
+          # if the pact for a consumer version has never been verified, it exists in the matrix as a row
+          # with a blank provider version id
+          def self.provider_verification_is_missing_for_matching_selector(s)
+            Sequel.&(provider_id: s[:pacticipant_id], provider_version_id: nil)
+          end
+
+          def self.provider_and_maybe_provider_version_match_any_selector_or_verification_is_missing(selectors)
+            selectors.collect { |s|
+              provider_and_maybe_provider_version_match_selector(s)
+            } + selectors.collect { |s|
+              provider_verification_is_missing_for_matching_selector(s)
+            }
+          end
+
+          # Some selecters are specified in the query, others are implied (when only one pacticipant is specified,
+          # the integrations are automatically worked out, and the selectors for these are of type :implied )
+          # When there are 3 pacticipants that each have dependencies on each other (A->B, A->C, B->C), the query
+          # to deploy C (implied A, implied B, specified C) was returning the A->B row because it matched the
+          # implied selectors as well.
+          # This extra filter makes sure that every row that is returned actually matches one of the specified
+          # selectors.
+          def self.either_consumer_or_provider_was_specified_in_query(selectors)
+            specified_pacticipant_ids = selectors.select{ |s| s[:type] == :specified }.collect{ |s| s[:pacticipant_id] }
+            Sequel.|({ consumer_id: specified_pacticipant_ids } , { provider_id: specified_pacticipant_ids })
+          end
+        end
+
         def where_consumer_or_provider_is s
           where{
             Sequel.|(

data/lib/pact_broker/pacts/pact_publication.rb

@@ -5,6 +5,7 @@ require 'pact_broker/repositories/helpers'
 module PactBroker
   module Pacts
     class PactPublication < Sequel::Model(:pact_publications)
+      UNIQUE_CONSTRAINT_KEYS = [:consumer_version_id, :provider_id, :revision_number].freeze
 
       extend Forwardable
 
@@ -57,6 +58,12 @@ module PactBroker
         OpenStruct.new(number: consumer_version.number, pacticipant: consumer_version.pacticipant, tags: consumer_version.tags, order: consumer_version.order)
       end
 
+      def upsert
+        params = to_hash.merge(created_at: Sequel.datetime_class.now)
+        self.id = PactPublication.upsert(params, UNIQUE_CONSTRAINT_KEYS).id
+        self.refresh
+      end
+
       private
 
       def cached_domain_for_delegation
@@ -70,7 +77,7 @@ end
 
 # Table: pact_publications
 # Columns:
-#  id                  | integer                     | PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY
+#  id                  | integer                     | PRIMARY KEY DEFAULT nextval('pact_publications_id_seq'::regclass)
 #  consumer_version_id | integer                     | NOT NULL
 #  provider_id         | integer                     | NOT NULL
 #  revision_number     | integer                     | NOT NULL

data/lib/pact_broker/pacts/pact_version.rb

@@ -53,7 +53,7 @@ end
 
 # Table: pact_versions
 # Columns:
-#  id          | integer                     | PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY
+#  id          | integer                     | PRIMARY KEY DEFAULT nextval('pact_versions_id_seq'::regclass)
 #  consumer_id | integer                     | NOT NULL
 #  provider_id | integer                     | NOT NULL
 #  sha         | text                        | NOT NULL

data/lib/pact_broker/pacts/repository.rb

@@ -31,8 +31,9 @@ module PactBroker
           consumer_version_id: params[:version_id],
           provider_id: params[:provider_id],
           consumer_id: params[:consumer_id],
-          pact_version: pact_version
-        ).save
+          pact_version: pact_version,
+          revision_number: 1
+        ).upsert
         update_latest_pact_publication_ids(pact_publication)
         pact_publication.to_domain
       end
@@ -46,18 +47,14 @@ module PactBroker
           params.fetch(:json_content)
         )
         if existing_model.pact_version_id != pact_version.id
-          key = {
+          pact_publication = PactPublication.new(
             consumer_version_id: existing_model.consumer_version_id,
             provider_id: existing_model.provider_id,
             revision_number: next_revision_number(existing_model),
-          }
-          new_params = key.merge(
             consumer_id: existing_model.consumer_id,
             pact_version_id: pact_version.id,
             created_at: Sequel.datetime_class.now
-          )
-          PactPublication.upsert(new_params, key.keys)
-          pact_publication = PactPublication.where(key).single_record
+          ).upsert
           update_latest_pact_publication_ids(pact_publication)
           pact_publication.to_domain
         else

data/lib/pact_broker/repositories/helpers.rb

@@ -36,21 +36,22 @@ module PactBroker
         end
       end
 
-      def upsert row, key_names, columns_to_update = nil
+      def upsert row, unique_key_names, columns_to_update = nil
         if postgres?
-          insert_conflict(update: row, target: key_names).insert(row)
+          insert_conflict(update: row, target: unique_key_names).insert(row)
         elsif mysql?
-          update_cols = columns_to_update || (row.keys - key_names)
+          update_cols = columns_to_update || (row.keys - unique_key_names)
           on_duplicate_key_update(*update_cols).insert(row)
         else
           # Sqlite
-          key = row.reject{ |k, v| !key_names.include?(k) }
+          key = row.reject{ |k, v| !unique_key_names.include?(k) }
           if where(key).count == 0
             insert(row)
           else
             where(key).update(row)
           end
         end
+        model.find(row.select{ |key, _| unique_key_names.include?(key)} )
       end
     end
   end

data/lib/pact_broker/test/test_data_builder.rb

@@ -3,7 +3,7 @@ require 'pact_broker/repositories'
 require 'pact_broker/services'
 require 'pact_broker/webhooks/repository'
 require 'pact_broker/webhooks/service'
-require 'pact_broker/domain/webhook_execution_result'
+require 'pact_broker/webhooks/webhook_execution_result'
 require 'pact_broker/pacts/repository'
 require 'pact_broker/pacts/service'
 require 'pact_broker/pacts/content'
@@ -267,7 +267,7 @@ module PactBroker
       def create_webhook_execution params = {}
         params.delete(:comment)
         logs = params[:logs] || "logs"
-        webhook_execution_result = PactBroker::Domain::WebhookExecutionResult.new(nil, OpenStruct.new(code: "200"), logs, nil)
+        webhook_execution_result = PactBroker::Webhooks::WebhookExecutionResult.new(nil, OpenStruct.new(code: "200"), logs, nil)
         @webhook_execution = PactBroker::Webhooks::Repository.new.create_execution @triggered_webhook, webhook_execution_result
         created_at = params[:created_at] || @pact.created_at + Rational(1, 86400)
         set_created_at_if_set created_at, :webhook_executions, {id: @webhook_execution.id}

data/lib/pact_broker/version.rb

@@ -1,3 +1,3 @@
 module PactBroker
-  VERSION = '2.32.0'
+  VERSION = '2.33.0'
 end

data/lib/pact_broker/versions/latest_version.rb

@@ -9,3 +9,13 @@ module PactBroker
     end
   end
 end
+
+# Table: latest_versions
+# Columns:
+#  id             | integer                     |
+#  number         | text                        |
+#  repository_ref | text                        |
+#  pacticipant_id | integer                     |
+#  order          | integer                     |
+#  created_at     | timestamp without time zone |
+#  updated_at     | timestamp without time zone |

data/lib/pact_broker/webhooks/execution.rb

@@ -41,7 +41,7 @@ end
 
 # Table: webhook_executions
 # Columns:
-#  id                   | integer                     | PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY
+#  id                   | integer                     | PRIMARY KEY DEFAULT nextval('webhook_executions_id_seq'::regclass)
 #  triggered_webhook_id | integer                     |
 #  success              | boolean                     | NOT NULL
 #  logs                 | text                        |

data/lib/pact_broker/webhooks/http_request_with_redacted_headers.rb

@@ -0,0 +1,21 @@
+require 'pact_broker/domain/webhook_request'
+
+module PactBroker
+  module Webhooks
+    class HttpRequestWithRedactedHeaders < SimpleDelegator
+      def to_hash
+        __getobj__().to_hash.each_with_object({}) do | (key, values), new_hash |
+          new_hash[key] = redact?(key) ? ["**********"] : values
+        end
+      end
+
+      def method
+        __getobj__().method
+      end
+
+      def redact? name
+        PactBroker::Domain::WebhookRequest::HEADERS_TO_REDACT.any?{ | pattern | name =~ pattern }
+      end
+    end
+  end
+end

data/lib/pact_broker/webhooks/http_response_with_utf_8_safe_body.rb

@@ -0,0 +1,21 @@
+module PactBroker
+  module Webhooks
+    class HttpResponseWithUtf8SafeBody < SimpleDelegator
+      def body
+        if unsafe_body
+          unsafe_body.encode('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: '')
+        else
+          unsafe_body
+        end
+      end
+
+      def unsafe_body
+        __getobj__().body
+      end
+
+      def unsafe_body?
+        unsafe_body != body
+      end
+    end
+  end
+end

data/lib/pact_broker/webhooks/job.rb

@@ -46,12 +46,12 @@ module PactBroker
       end
 
       def webhook_options(data)
-        execution_options = data[:execution_options].merge(
+        logging_options = data[:logging_options].merge(
           success_log_message: "Successfully executed webhook",
           failure_log_message: failure_log_message
         )
         {
-          execution_options: execution_options,
+          logging_options: logging_options,
           webhook_context: data[:webhook_context]
         }
       end

data/lib/pact_broker/webhooks/pact_and_verification_parameters.rb

@@ -0,0 +1,86 @@
+module PactBroker
+  module Webhooks
+    class PactAndVerificationParameters
+
+      def initialize(pact, trigger_verification, webhook_context)
+        @pact = pact
+        @verification = trigger_verification || (pact && pact.latest_verification)
+        @webhook_context = webhook_context
+        @base_url = webhook_context.fetch(:base_url)
+      end
+
+      def to_hash
+        @hash ||= {
+          '${pactbroker.pactUrl}' => pact ? PactBroker::Api::PactBrokerUrls.pact_version_url_with_metadata(pact, base_url) : "",
+          '${pactbroker.verificationResultUrl}' => verification_url,
+          '${pactbroker.consumerVersionNumber}' => consumer_version_number,
+          '${pactbroker.providerVersionNumber}' => verification ? verification.provider_version_number : "",
+          '${pactbroker.providerVersionTags}' => provider_version_tags,
+          '${pactbroker.consumerVersionTags}' => consumer_version_tags,
+          '${pactbroker.consumerName}' => pact ? pact.consumer_name : "",
+          '${pactbroker.providerName}' => pact ? pact.provider_name : "",
+          '${pactbroker.githubVerificationStatus}' => github_verification_status,
+          '${pactbroker.consumerLabels}' => pacticipant_labels(pact && pact.consumer),
+          '${pactbroker.providerLabels}' => pacticipant_labels(pact && pact.provider)
+        }
+      end
+
+      private
+
+      attr_reader :pact, :verification, :webhook_context, :base_url
+
+
+      def github_verification_status
+        if verification
+          verification.success ? "success" : "failure"
+        else
+          "pending"
+        end
+      end
+
+      def verification_url
+        if verification
+          PactBroker::Api::PactBrokerUrls.verification_url(verification, base_url)
+        else
+          ""
+        end
+      end
+
+      def consumer_version_number
+        if webhook_context[:consumer_version_number]
+          webhook_context[:consumer_version_number]
+        else
+          pact ? pact.consumer_version_number : ""
+        end
+      end
+
+      def consumer_version_tags
+        if webhook_context[:consumer_version_tags]
+          webhook_context[:consumer_version_tags].join(", ")
+        else
+          if pact
+            pact.consumer_version.tags.collect(&:name).join(", ")
+          else
+            ""
+          end
+        end
+      end
+
+      def provider_version_tags
+        if webhook_context[:provider_version_tags]
+          webhook_context[:provider_version_tags].join(", ")
+        else
+          if verification
+            verification.provider_version.tags.collect(&:name).join(", ")
+          else
+            ""
+          end
+        end
+      end
+
+      def pacticipant_labels pacticipant
+        pacticipant && pacticipant.labels ? pacticipant.labels.collect(&:name).join(", ") : ""
+      end
+    end
+  end
+end

data/lib/pact_broker/webhooks/render.rb

@@ -1,88 +1,27 @@
+require 'pact_broker/webhooks/pact_and_verification_parameters'
+
 module PactBroker
   module Webhooks
     class Render
 
       TEMPLATE_PARAMETER_REGEXP = /\$\{pactbroker\.[^\}]+\}/
+      DEFAULT_ESCAPER = lambda { |it| it }
 
-      def self.call(template, pact, trigger_verification, webhook_context, &escaper)
-        base_url = webhook_context[:base_url]
-        verification = trigger_verification || (pact && pact.latest_verification)
-        params = {
-          '${pactbroker.pactUrl}' => pact ? PactBroker::Api::PactBrokerUrls.pact_version_url_with_metadata(pact, base_url) : "",
-          '${pactbroker.verificationResultUrl}' => verification_url(verification, base_url),
-          '${pactbroker.consumerVersionNumber}' => consumer_version_number(pact, webhook_context),
-          '${pactbroker.providerVersionNumber}' => verification ? verification.provider_version_number : "",
-          '${pactbroker.providerVersionTags}' => provider_version_tags(verification, webhook_context),
-          '${pactbroker.consumerVersionTags}' => consumer_version_tags(pact, webhook_context),
-          '${pactbroker.consumerName}' => pact ? pact.consumer_name : "",
-          '${pactbroker.providerName}' => pact ? pact.provider_name : "",
-          '${pactbroker.githubVerificationStatus}' => github_verification_status(verification),
-          '${pactbroker.consumerLabels}' => pacticipant_labels(pact && pact.consumer),
-          '${pactbroker.providerLabels}' => pacticipant_labels(pact && pact.provider)
-        }
-
-        if escaper
-          params.keys.each do | key |
-            params[key] = escaper.call(params[key])
-          end
-        end
+      def self.call(template, params, &escaper)
+        render_template(escape_params(params, escaper || DEFAULT_ESCAPER), template)
+      end
 
+      def self.render_template(params, template)
         params.inject(template) do | template, (key, value) |
           template.gsub(key, value)
         end
       end
 
-      def self.github_verification_status verification
-        if verification
-          verification.success ? "success" : "failure"
-        else
-          "pending"
-        end
-      end
-
-      def self.verification_url verification, base_url
-        if verification
-          PactBroker::Api::PactBrokerUrls.verification_url(verification, base_url)
-        else
-          ""
-        end
-      end
-
-      def self.consumer_version_number(pact, webhook_context)
-        if webhook_context[:consumer_version_number]
-          webhook_context[:consumer_version_number]
-        else
-          pact ? pact.consumer_version_number : ""
+      def self.escape_params(params, escaper)
+        params.keys.each_with_object({}) do | key, new_params |
+          new_params[key] = escaper.call(params[key])
         end
       end
-
-      def self.consumer_version_tags pact, webhook_context
-        if webhook_context[:consumer_version_tags]
-          webhook_context[:consumer_version_tags].join(", ")
-        else
-          if pact
-            pact.consumer_version.tags.collect(&:name).join(", ")
-          else
-            ""
-          end
-        end
-      end
-
-      def self.provider_version_tags verification, webhook_context
-        if webhook_context[:provider_version_tags]
-          webhook_context[:provider_version_tags].join(", ")
-        else
-          if verification
-            verification.provider_version.tags.collect(&:name).join(", ")
-          else
-            ""
-          end
-        end
-      end
-
-      def self.pacticipant_labels pacticipant
-        pacticipant && pacticipant.labels ? pacticipant.labels.collect(&:name).join(", ") : ""
-      end
     end
   end
 end