pact_broker 2.43.0 → 2.44.0

data/lib/pact_broker/matrix/reason.rb

@@ -37,6 +37,9 @@ module PactBroker
     # the required provider version
     # (this row is not included in the matrix, and it's
     # absence must be inferred)
+    # Update: because the left outer join now returns a row with blank verification
+    # details, this scenario is now indistingishable from PactNotEverVerifiedByProvider
+    # TODO: merge these two classes when it's verified that they are duplicates.
     class PactNotVerifiedByRequiredProviderVersion < ErrorReasonWithTwoSelectors; end
 
     # The pact verification has failed

data/lib/pact_broker/matrix/repository.rb

@@ -1,6 +1,7 @@
 require 'pact_broker/repositories/helpers'
 require 'pact_broker/matrix/row'
 require 'pact_broker/matrix/quick_row'
+require 'pact_broker/matrix/every_row'
 require 'pact_broker/matrix/head_row'
 require 'pact_broker/error'
 require 'pact_broker/matrix/query_results'
@@ -53,9 +54,16 @@ module PactBroker
 
       # Return the latest matrix row (pact/verification) for each consumer_version_number/provider_version_number
       def find specified_selectors, options = {}
-        resolved_selectors = resolve_selectors(specified_selectors, options)
-        lines = query_matrix(resolved_selectors, options)
-        lines = apply_latestby(options, specified_selectors, lines)
+        resolved_specified_selectors = resolve_versions_and_add_ids(specified_selectors, :specified)
+        integrations = find_integrations_for_specified_selectors(resolved_specified_selectors)
+        resolved_selectors = if infer_selectors_for_integrations?(options)
+          resolved_specified_selectors + inferred_selectors(resolved_specified_selectors, integrations, options)
+        else
+          resolved_specified_selectors
+        end
+
+        all_lines = query_matrix(resolved_selectors, options)
+        lines = apply_latestby(options, all_lines)
 
         # This needs to be done after the latestby, so can't be done in the db unless
         # the latestby logic is moved to the db
@@ -63,7 +71,6 @@ module PactBroker
           lines = lines.select{ |l| options[:success].include?(l.success) }
         end
 
-        integrations = find_integrations_for_specified_selectors(resolved_selectors.select(&:specified?))
         QueryResults.new(lines.sort, specified_selectors, options, resolved_selectors, integrations)
       end
 
@@ -101,7 +108,7 @@ module PactBroker
       end
 
       # It would be nicer to do this in the SQL, but it requires time that I don't have at the moment
-      def apply_latestby options, selectors, lines
+      def apply_latestby options, lines
         return lines unless options[:latestby]
         group_by_columns = case options[:latestby]
         when 'cvpv' then GROUP_BY_PROVIDER_VERSION_NUMBER
@@ -118,39 +125,34 @@ module PactBroker
       end
 
       def query_matrix selectors, options
-        query = options[:latestby] ? QuickRow.select_all_columns.eager_all_the_things : Row.select_all
-        query = query.matching_selectors(selectors)
+        query = base_model(options)
+                  .select_all_columns
+                  .matching_selectors(selectors)
+                  .order_by_names_ascending_most_recent_first
         query = query.limit(options[:limit]) if options[:limit]
-        query
-          .order_by_names_ascending_most_recent_first
-          .eager(:consumer_version_tags)
-          .eager(:provider_version_tags)
-          .all
+        query.eager_all_the_things.all
       end
 
-      def resolve_selectors(specified_selectors, options)
-        resolved_specified_selectors = resolve_versions_and_add_ids(specified_selectors, :specified, options[:latestby])
-        if options[:latest] || options[:tag]
-          add_inferred_selectors(resolved_specified_selectors, options)
-        else
-          resolved_specified_selectors
-        end
+      def base_model(options)
+        options[:latestby] ? QuickRow : EveryRow
       end
 
       # Find the version number for selectors with the latest and/or tag specified
-      def resolve_versions_and_add_ids(selectors, selector_type, latestby)
+      def resolve_versions_and_add_ids(selectors, selector_type)
         selectors.collect do | selector |
           pacticipant = PactBroker::Domain::Pacticipant.find(name: selector[:pacticipant_name])
           versions = find_versions_for_selector(selector)
-          build_selectors_for_pacticipant_and_versions(pacticipant, versions, selector, selector_type, latestby)
+          build_resolved_selectors(pacticipant, versions, selector, selector_type)
         end.flatten
       end
 
-      def build_selectors_for_pacticipant_and_versions(pacticipant, versions, original_selector, selector_type, latestby)
+      # When a single selector specifies multiple versions (eg. "all prod pacts"), this expands
+      # the single selector into one selector for each version.
+      def build_resolved_selectors(pacticipant, versions, original_selector, selector_type)
         if versions
           versions.collect do | version |
             if version
-              selector_for_version(pacticipant, version, original_selector, selector_type, latestby)
+              selector_for_version(pacticipant, version, original_selector, selector_type)
             else
               selector_for_non_existing_version(pacticipant, original_selector, selector_type)
             end
@@ -178,14 +180,17 @@ module PactBroker
         end
       end
 
+      def infer_selectors_for_integrations?(options)
+        options[:latest] || options[:tag]
+      end
+
       # When only one selector is specified, (eg. checking to see if Foo version 2 can be deployed to prod),
       # need to look up all integrated pacticipants, and determine their relevant (eg. latest prod) versions
-      def add_inferred_selectors(resolved_specified_selectors, options)
-        integrations = find_integrations_for_specified_selectors(resolved_specified_selectors)
+      def inferred_selectors(resolved_specified_selectors, integrations, options)
         all_pacticipant_names = integrations.collect(&:pacticipant_names).flatten.uniq
         specified_names = resolved_specified_selectors.collect{ |s| s[:pacticipant_name] }
         inferred_pacticipant_names = all_pacticipant_names - specified_names
-        resolved_specified_selectors + build_inferred_selectors(inferred_pacticipant_names, options)
+        build_inferred_selectors(inferred_pacticipant_names, options)
       end
 
       def build_inferred_selectors(inferred_pacticipant_names, options)
@@ -197,21 +202,14 @@ module PactBroker
           selector[:latest] = options[:latest] if options[:latest]
           selector
         end
-        resolve_versions_and_add_ids(selectors, :inferred, options[:latestby])
-      end
-
-      def all_pacticipant_names_in_specified_matrix(selectors)
-        find_integrations_for_specified_selectors(selectors)
-          .collect(&:pacticipant_names)
-          .flatten
-          .uniq
+        resolve_versions_and_add_ids(selectors, :inferred)
       end
 
       def selector_for_non_existing_version(pacticipant, original_selector, selector_type)
         ResolvedSelector.for_pacticipant_and_non_existing_version(pacticipant, original_selector, selector_type)
       end
 
-      def selector_for_version(pacticipant, version, original_selector, selector_type, latestby)
+      def selector_for_version(pacticipant, version, original_selector, selector_type)
         ResolvedSelector.for_pacticipant_and_version(pacticipant, version, original_selector, selector_type)
       end
 

data/lib/pact_broker/pacticipants/repository.rb

@@ -1,6 +1,7 @@
 require 'sequel'
 require 'pact_broker/domain/pacticipant'
 require 'pact_broker/repositories/helpers'
+require 'pact_broker/error'
 
 module PactBroker
   module Pacticipants
@@ -9,7 +10,9 @@ module PactBroker
       include PactBroker::Repositories::Helpers
 
       def find_by_name name
-        PactBroker::Domain::Pacticipant.where(name_like(:name, name)).single_record
+        pacticipants = PactBroker::Domain::Pacticipant.where(name_like(:name, name)).all
+        handle_multiple_pacticipants_found(name, pacticipants) if pacticipants.size > 1
+        pacticipants.first
       end
 
       def find_by_id id
@@ -66,6 +69,11 @@ module PactBroker
           pacticipant.destroy
         end
       end
+
+      def handle_multiple_pacticipants_found(name, pacticipants)
+        names = pacticipants.collect(&:name).join(", ")
+        raise PactBroker::Error.new("Found multiple pacticipants with a case insensitive name match for '#{name}': #{names}. Please delete one of them, or set PactBroker.configuration.use_case_sensitive_resource_names = true")
+      end
     end
   end
 end

data/lib/pact_broker/pacts/repository.rb

@@ -11,7 +11,7 @@ require 'pact/shared/json_differ'
 require 'pact_broker/domain'
 require 'pact_broker/pacts/parse'
 require 'pact_broker/matrix/head_row'
-require 'pact_broker/pacts/latest_pact_publication_id_by_consumer_version'
+require 'pact_broker/pacts/latest_pact_publication_id_for_consumer_version'
 require 'pact_broker/pacts/verifiable_pact'
 
 module PactBroker

data/lib/pact_broker/repositories/helpers.rb

@@ -1,3 +1,5 @@
+Sequel.extension :escaped_like
+
 module PactBroker
   module Repositories
     module Helpers
@@ -5,11 +7,16 @@ module PactBroker
       extend self
 
       def name_like column_name, value
-        Sequel.like(column_name, value, case_sensitivity_options)
-      end
-
-      def case_sensitivity_options
-        {case_insensitive: !PactBroker.configuration.use_case_sensitive_resource_names}
+        if PactBroker.configuration.use_case_sensitive_resource_names
+          if mysql?
+            # sigh, mysql, this is the only way to perform a case sensitive search
+            Sequel.like(column_name, value.gsub("_", "\\_"), { case_insensitive: false })
+          else
+            { column_name => value }
+          end
+        else
+          Sequel.like(column_name, value.gsub("_", "\\_"), { case_insensitive: true })
+        end
       end
 
       def order_ignore_case column_name = :name

data/lib/pact_broker/version.rb

@@ -1,3 +1,3 @@
 module PactBroker
-  VERSION = '2.43.0'
+  VERSION = '2.44.0'
 end

data/pact_broker.gemspec

@@ -53,7 +53,7 @@ Gem::Specification.new do |gem|
   gem.add_runtime_dependency 'semver2', '~> 3.4.2'
   gem.add_runtime_dependency 'rack', '>= 2.0.8', '~>2.0'
   gem.add_runtime_dependency 'redcarpet', '>=3.3.2', '~>3.3'
-  gem.add_runtime_dependency 'pact-support'
+  gem.add_runtime_dependency 'pact-support', '~> 1.12', '>= 1.12.1'
   gem.add_runtime_dependency 'padrino-core', '>= 0.14.3', '~> 0.14'
   gem.add_runtime_dependency 'sinatra', '>= 2.0.8.1', '< 3.0'
   gem.add_runtime_dependency 'haml', '~>5.0'

data/spec/lib/pact_broker/integrations/service_spec.rb

@@ -257,6 +257,7 @@ module PactBroker
 
         it "doesn't blow up" do
           Service.delete_all
+          expect(PactBroker::Domain::Pacticipant.count).to be 0
         end
       end
     end

data/spec/lib/pact_broker/matrix/deployment_status_summary_spec.rb

@@ -16,35 +16,37 @@ module PactBroker
 
       describe ".call" do
         let(:rows) { [row_1, row_2] }
+        # Foo => Bar
         let(:row_1) do
           double(Row,
             consumer: foo,
             provider: bar,
             consumer_version: foo_version,
             provider_version: bar_version,
-            consumer_name: "Foo",
-            consumer_id: 1,
-            consumer_version_id: 1,
-            provider_name: "Bar",
-            provider_id: 2,
+            consumer_name: foo.name,
+            consumer_id: foo.id,
+            consumer_version_id: foo_version.id,
+            provider_name: bar.name,
+            provider_id: bar.id,
             success: row_1_success,
-            pacticipant_names: %w{Foo Bar}
+            pacticipant_names: [foo.name, bar.name]
           )
         end
 
+        # Foo => Baz
         let(:row_2) do
           double(Row,
             consumer: foo,
             provider: baz,
             consumer_version: foo_version,
             provider_version: baz_version,
-            consumer_name: "Foo",
-            consumer_id: 1,
-            consumer_version_id: 1,
-            provider_name: "Baz",
-            provider_id: 3,
+            consumer_name: foo.name,
+            consumer_id: foo.id,
+            consumer_version_id: foo_version.id,
+            provider_name: baz.name,
+            provider_id: baz.id,
             success: true,
-            pacticipant_names: %w{Foo Baz}
+            pacticipant_names: [foo.name, baz.name]
           )
         end
 
@@ -61,29 +63,29 @@ module PactBroker
         let(:bar) { double('bar', id: 2, name: "Bar") }
         let(:baz) { double('baz', id: 3, name: "Baz") }
         let(:foo_version) { double('foo version', number: "ddec8101dabf4edf9125a69f9a161f0f294af43c", id: 10)}
-        let(:bar_version) { double('bar version', number: "14131c5da3abf323ccf410b1b619edac76231243", id: 10)}
-        let(:baz_version) { double('baz version', number: "4ee06460f10e8207ad904fa9fa6c4842e462ab59", id: 10)}
+        let(:bar_version) { double('bar version', number: "14131c5da3abf323ccf410b1b619edac76231243", id: 11)}
+        let(:baz_version) { double('baz version', number: "4ee06460f10e8207ad904fa9fa6c4842e462ab59", id: 12)}
 
         let(:resolved_selectors) do
           [
             ResolvedSelector.new(
-              pacticipant_id: 1,
-              pacticipant_name: "Foo",
-              pacticipant_version_number: "ddec8101dabf4edf9125a69f9a161f0f294af43c",
-              pacticipant_version_id: 10
+              pacticipant_id: foo.id,
+              pacticipant_name: foo.name,
+              pacticipant_version_number: foo_version.number,
+              pacticipant_version_id: foo_version.id
             ),
             ResolvedSelector.new(
-              pacticipant_id: 2,
-              pacticipant_name: "Bar",
-              pacticipant_version_number: "14131c5da3abf323ccf410b1b619edac76231243",
-              pacticipant_version_id: 11
+              pacticipant_id: bar.id,
+              pacticipant_name: bar.name,
+              pacticipant_version_number: bar_version.number,
+              pacticipant_version_id: bar_version.id
             ),
             ResolvedSelector.new(
-             pacticipant_id: 3,
-             pacticipant_name: "Baz",
-             pacticipant_version_number: "4ee06460f10e8207ad904fa9fa6c4842e462ab59",
-             pacticipant_version_id: 12
-            ),
+             pacticipant_id: baz.id,
+             pacticipant_name: baz.name,
+             pacticipant_version_number: baz_version.number,
+             pacticipant_version_id: baz_version.id
+            )
           ]
         end
 
@@ -132,12 +134,15 @@ module PactBroker
           its(:counts) { is_expected.to eq success: 1, failed: 0, unknown: 1 }
         end
 
-        context "when there is a consumer integration missing and only the provider was specified in the query" do
+        # I think this is an impossible scenario now that the left outer join returns a row with blank verification fields
+        context "when there is a consumer row missing a verification and only the provider was specified in the query" do
+
           let(:rows) { [row_1] }
+
           let(:integrations) do
             [
               Integration.new(1, "Foo", 2, "Bar", true),
-              Integration.new(3, "Baz", 2, "Bar", false) # the missing one
+              Integration.new(3, "Baz", 2, "Bar", false) # the integration missing a verification
             ]
           end
 
@@ -186,10 +191,10 @@ module PactBroker
 
           let(:dummy_selector) do
             ResolvedSelector.new(
-              pacticipant_id: 2,
-              pacticipant_name: "Bar",
-              pacticipant_version_id: 10,
-              pacticipant_version_number: "14131c5da3abf323ccf410b1b619edac76231243",
+              pacticipant_id: bar.id,
+              pacticipant_name: bar.name,
+              pacticipant_version_id: bar_version.id,
+              pacticipant_version_number: bar_version.number,
               latest: nil,
               tag: nil,
               type: :inferred

data/spec/lib/pact_broker/matrix/every_row_spec.rb

@@ -0,0 +1,136 @@
+require 'pact_broker/matrix/every_row'
+require 'pact_broker/matrix/resolved_selector'
+
+module PactBroker
+  module Matrix
+    describe EveryRow do
+      let(:foo) { PactBroker::Domain::Pacticipant.where(name: "Foo").single_record }
+      let(:bar) { PactBroker::Domain::Pacticipant.where(name: "Bar").single_record }
+      let(:wiffle) { PactBroker::Domain::Pacticipant.where(name: "Wiffle").single_record }
+
+      describe "matching_selectors" do
+        before do
+          td.create_pact_with_verification("Foo", "1", "Bar", "2")
+            .create_consumer_version("2")
+            .create_pact
+            .create_provider("Wiffle")
+            .create_pact
+            .create_verification(provider_version: "5")
+        end
+
+        let(:selector_1) do
+          PactBroker::Matrix::ResolvedSelector.for_pacticipant(foo, :specified)
+        end
+
+        let(:selector_2) do
+          PactBroker::Matrix::ResolvedSelector.for_pacticipant(bar, :specified)
+        end
+
+        let(:selectors) { [selector_1, selector_2] }
+
+        subject { EveryRow.select_all_columns.matching_selectors(selectors).all }
+
+        let(:un_verified_row) { subject.find{ |r| r.provider_id == bar.id && !r.has_verification? } }
+        let(:verified_row) { subject.find{ |r| r.provider_id == bar.id && r.has_verification? } }
+
+        it "includes the verified and unverified rows" do
+          expect(subject.size).to eq 2
+          expect(un_verified_row).to_not be nil
+          expect(verified_row).to_not be nil
+        end
+      end
+
+      describe "eager_all_the_things" do
+        before do
+          td.create_pact_with_verification("Foo", "1", "Bar", "2")
+            .create_consumer_version_tag("foo")
+            .create_provider_version_tag("foo")
+        end
+
+        subject do
+          EveryRow
+            .select_all_columns
+            .join_verifications
+            .join_pacticipants_and_pacticipant_versions
+            .eager_all_the_things
+            .all
+        end
+
+        it "can eager load all the things" do
+          expect(subject.first.provider_version).to_not be nil
+          expect(subject.first.provider_version_id).to_not be nil
+          expect(subject.first.consumer_version).to_not be nil
+          expect(subject.first.consumer_version_id).to_not be nil
+          expect(subject.first.provider_version_id).to_not be nil
+          expect(subject.first.consumer_version_id).to_not be nil
+          expect(subject.first.pact_publication_id).to_not be nil
+          expect(subject.first.pact_version_id).to_not be nil
+          expect(subject.first.verification_id).to_not be nil
+          expect(subject.first.provider).to_not be nil
+          expect(subject.first.consumer).to_not be nil
+          expect(subject.first.consumer_version).to_not be nil
+          expect(subject.first.provider_version).to_not be nil
+          expect(subject.first.pact_version).to_not be nil
+          expect(subject.first.verification).to_not be nil
+          expect(subject.first.pact_revision_number).to_not be nil
+          expect(subject.first.verification_number).to_not be nil
+          expect(subject.first.consumer_version_tags).to_not be_empty
+          expect(subject.first.provider_version_tags).to_not be_empty
+        end
+      end
+
+
+      describe "join_verifications" do
+        before do
+          td.create_pact_with_verification("Foo", "1", "Bar", "2")
+            .create_provider("Wiffle")
+            .create_pact
+            .create_verification(provider_version: "5")
+        end
+
+        subject do
+          EveryRow
+            .select_all_columns
+            .join_verifications
+            .join_pacticipants_and_pacticipant_versions
+            .all
+        end
+
+        it "joins all the verifications" do
+          expect(subject.size).to eq 2
+          expect(subject.all?(&:has_verification?)).to be true
+        end
+      end
+
+      describe "join_verifications_for" do
+        before do
+          td.create_pact_with_verification("Foo", "1", "Bar", "2")
+            .create_provider("Wiffle")
+            .create_pact
+            .create_verification(provider_version: "5")
+        end
+
+        let(:query_ids) do
+          double('query_ids',
+            all_pacticipant_ids: [foo.id, bar.id],
+            pacticipant_version_ids: [],
+            pacticipant_ids: [foo.id, bar.id]
+          )
+        end
+
+        subject do
+          EveryRow
+            .select_all_columns
+            .join_verifications_for(query_ids)
+            .join_pacticipants_and_pacticipant_versions
+            .all
+        end
+
+        it "pre-filters the verifications before joining them" do
+          expect(subject.size).to eq 2
+          expect(subject.find{ |r| r.provider_id == wiffle.id && !r.has_verification? }).to_not be nil
+        end
+      end
+    end
+  end
+end