pact_broker 2.77.0 → 2.80.0

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

@@ -1,8 +1,10 @@
-require 'pact_broker/matrix/deployment_status_summary'
-require 'pact_broker/matrix/row'
-require 'pact_broker/matrix/query_results'
-require 'pact_broker/matrix/integration'
-require 'pact_broker/matrix/resolved_selector'
+require "pact_broker/matrix/deployment_status_summary"
+require "pact_broker/matrix/row"
+require "pact_broker/matrix/query_results"
+require "pact_broker/matrix/integration"
+require "pact_broker/matrix/resolved_selector"
+require "pact_broker/matrix/query_results"
+
 
 module PactBroker
   module Matrix
@@ -12,7 +14,7 @@ module PactBroker
         allow(subject).to receive(:logger).and_return(logger)
       end
 
-      let(:logger) { double('logger').as_null_object }
+      let(:logger) { double("logger").as_null_object }
 
       describe ".call" do
         let(:rows) { [row_1, row_2] }
@@ -61,14 +63,14 @@ module PactBroker
           ]
         end
 
-        let(:foo) { double('foo', id: 1, name: "Foo") }
-        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: 11)}
-        let(:baz_version) { double('baz version', number: "4ee06460f10e8207ad904fa9fa6c4842e462ab59", id: 12)}
-        let(:verification_1) { double('verification 1', interactions_missing_test_results: []) }
-        let(:verification_2) { double('verification 2', interactions_missing_test_results: []) }
+        let(:foo) { double("foo", id: 1, name: "Foo") }
+        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: 11)}
+        let(:baz_version) { double("baz version", number: "4ee06460f10e8207ad904fa9fa6c4842e462ab59", id: 12)}
+        let(:verification_1) { double("verification 1", interactions_missing_test_results: []) }
+        let(:verification_2) { double("verification 2", interactions_missing_test_results: []) }
 
         let(:resolved_selectors) do
           [
@@ -93,7 +95,24 @@ module PactBroker
           ]
         end
 
-        subject { DeploymentStatusSummary.new(rows, resolved_selectors, integrations) }
+        let(:ignored_rows) { [] }
+        let(:resolved_ignore_selectors) { [] }
+
+        let(:query_results) do
+          instance_double(PactBroker::Matrix::QueryResults,
+            considered_rows: rows,
+            ignored_rows: ignored_rows,
+            resolved_selectors: resolved_selectors,
+            resolved_ignore_selectors: resolved_ignore_selectors,
+            integrations: integrations,
+            rows: rows + ignored_rows,
+            options: options
+          )
+        end
+
+        let(:options) { { environment_name: "prod" } }
+
+        subject { DeploymentStatusSummary.new(query_results) }
 
         context "when there is a row for all integrations" do
           its(:deployable?) { is_expected.to be true }
@@ -101,6 +120,12 @@ module PactBroker
           its(:counts) { is_expected.to eq success: 2, failed: 0, unknown: 0 }
         end
 
+        context "when there are resolved_ignore_selectors" do
+          let(:resolved_ignore_selectors) { [ResolvedSelector.new()] }
+
+          its(:counts) { is_expected.to have_key(:ignored) }
+        end
+
         context "when there are no rows" do
           let(:rows) { [] }
 
@@ -120,6 +145,17 @@ module PactBroker
           its(:deployable?) { is_expected.to be nil }
           its(:reasons) { is_expected.to eq [PactNotEverVerifiedByProvider.new(resolved_selectors.first, resolved_selectors[1]) ] }
           its(:counts) { is_expected.to eq success: 1, failed: 0, unknown: 1 }
+
+          context "when that row is ignored" do
+            let(:resolved_ignore_selectors) { [instance_double("PactBroker::Matrix::ResolvedSelector", pacticipant_or_version_does_not_exist?: false).as_null_object] }
+            let(:rows) { [row_2] }
+            let(:ignored_rows) { [row_1] }
+
+            its(:deployable?) { is_expected.to be true }
+
+            its(:reasons) { is_expected.to eq [Successful.new] }
+            its(:counts) { is_expected.to eq success: 1, failed: 0, unknown: 0, ignored: 1 }
+          end
         end
 
         context "when one or more of the success flags are false" do
@@ -128,9 +164,21 @@ module PactBroker
           its(:deployable?) { is_expected.to be false }
           its(:reasons) { is_expected.to eq [VerificationFailed.new(resolved_selectors.first, resolved_selectors[1])] }
           its(:counts) { is_expected.to eq success: 1, failed: 1, unknown: 0 }
+
+          context "when that row is ignored" do
+            let(:resolved_ignore_selectors) { [instance_double("PactBroker::Matrix::ResolvedSelector", pacticipant_or_version_does_not_exist?: false).as_null_object] }
+            let(:rows) { [row_2] }
+            let(:ignored_rows) { [row_1] }
+
+            its(:deployable?) { is_expected.to be true }
+            its(:reasons) { is_expected.to eq [Successful.new] }
+            its(:counts) { is_expected.to eq success: 1, failed: 0, unknown: 0, ignored: 1 }
+          end
         end
 
-        context "when there is a provider relationship missing" do
+        # TODO
+        # 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 provider relationship missing [don't think this is possible any more]" do
           let(:rows) { [row_1] }
 
           its(:deployable?) { is_expected.to be nil }
@@ -138,9 +186,7 @@ module PactBroker
           its(:counts) { is_expected.to eq success: 1, failed: 0, unknown: 1 }
         end
 
-        # 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
@@ -169,7 +215,7 @@ module PactBroker
           its(:counts) { is_expected.to eq success: 0, failed: 0, unknown: 0 }
         end
 
-        context "when there is a provider integration missing and only the consumer was specified in the query" do
+        context "when there is a provider integration that does not have a matching row and only the consumer was specified in the query" do
           let(:rows) { [row_1] }
 
           let(:integrations) do
@@ -201,7 +247,12 @@ module PactBroker
               pacticipant_version_number: bar_version.number,
               latest: nil,
               tag: nil,
-              type: :inferred
+              branch: nil,
+              environment_name: nil,
+              type: :inferred,
+              ignore: false,
+              one_of_many: false,
+              original_selector: {}
             )
           end
 
@@ -214,6 +265,35 @@ module PactBroker
           its(:deployable?) { is_expected.to be nil }
           its(:reasons) { is_expected.to eq [PactNotEverVerifiedByProvider.new(resolved_selectors.first, dummy_selector)] }
         end
+
+        context "when there are ignore selectors that don't match any pacticipant or version" do
+          let(:resolved_ignore_selectors) { [instance_double("PactBroker::Matrix::ResolvedSelector", pacticipant_or_version_does_not_exist?: true).as_null_object] }
+
+          its(:reasons) { is_expected.to eq [IgnoreSelectorDoesNotExist.new(resolved_ignore_selectors.first), PactBroker::Matrix::Successful.new] }
+        end
+
+        context "when there is a selector without a specified pacticipant version number" do
+          let(:resolved_selectors) do
+            [
+              ResolvedSelector.new(
+                pacticipant_id: foo.id,
+                pacticipant_name: foo.name,
+                pacticipant_version_number: foo_version.number,
+                pacticipant_version_id: foo_version.id,
+                type: :specified,
+                original_selector: { latest: true, tag: "asdf" }
+              )
+            ]
+          end
+
+          its(:reasons) { is_expected.to include SelectorWithoutPacticipantVersionNumberSpecified.new }
+        end
+
+        context "when there is no to tag or environment specified" do
+          let(:options) { { } }
+
+          its(:reasons) { is_expected.to include NoEnvironmentSpecified.new }
+        end
       end
     end
   end

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

@@ -1,5 +1,5 @@
-require 'pact_broker/matrix/every_row'
-require 'pact_broker/matrix/resolved_selector'
+require "pact_broker/matrix/every_row"
+require "pact_broker/matrix/resolved_selector"
 
 module PactBroker
   module Matrix
@@ -19,11 +19,11 @@ module PactBroker
         end
 
         let(:selector_1) do
-          PactBroker::Matrix::ResolvedSelector.for_pacticipant(foo, :specified)
+          PactBroker::Matrix::ResolvedSelector.for_pacticipant(foo, {}, :specified, false)
         end
 
         let(:selector_2) do
-          PactBroker::Matrix::ResolvedSelector.for_pacticipant(bar, :specified)
+          PactBroker::Matrix::ResolvedSelector.for_pacticipant(bar, {}, :specified, false)
         end
 
         let(:selectors) { [selector_1, selector_2] }
@@ -109,7 +109,7 @@ module PactBroker
         end
 
         let(:query_ids) do
-          double('query_ids',
+          double("query_ids",
             all_pacticipant_ids: [foo.id, bar.id],
             pacticipant_version_ids: [],
             pacticipant_ids: [foo.id, bar.id]

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

@@ -1,4 +1,4 @@
-require 'pact_broker/matrix/head_row'
+require "pact_broker/matrix/head_row"
 
 module PactBroker
   module Matrix

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

@@ -0,0 +1,175 @@
+require "pact_broker/matrix/service"
+
+module PactBroker
+  module Matrix
+    describe Service do
+      describe "find with environments" do
+        subject { Service.can_i_deploy(selectors, options) }
+
+        # Useful for eyeballing the messages to make sure they read nicely
+        # after do
+        #   require 'pact_broker/api/decorators/reason_decorator'
+        #   subject.deployment_status_summary.reasons.each do | reason |
+        #     puts reason
+        #     puts PactBroker::Api::Decorators::ReasonDecorator.new(reason).to_s
+        #   end
+        # end
+
+        context "when there is a successful verification between the provider in test environment and the consumer to be deployed" do
+          before do
+            td.create_environment("test")
+              .create_pact_with_verification("Foo", "1", "Bar", "2")
+              .create_deployed_version_for_provider_version
+              .create_verification(provider_version: "3", number: 2, success: false)
+          end
+
+          let(:selectors) do
+            [
+              UnresolvedSelector.new(pacticipant_name: "Foo", pacticipant_version_number: "1"),
+            ]
+          end
+
+          let(:options) { { latestby: "cvp", environment_name: "test" } }
+
+          it "allows the consumer to be deployed" do
+            expect(subject.deployment_status_summary).to be_deployable
+          end
+        end
+
+        context "when there is an unsuccessful verification between the provider in test environment and the consumer to be deployed" do
+          before do
+            td.create_environment("test")
+              .create_pact_with_verification("Foo", "1", "Bar", "2", false)
+              .create_deployed_version_for_provider_version
+              .create_verification(provider_version: "3", number: 3, success: true)
+          end
+
+          let(:selectors) do
+            [
+              UnresolvedSelector.new(pacticipant_name: "Foo", pacticipant_version_number: "1"),
+            ]
+          end
+
+          let(:options) { { latestby: "cvp", environment_name: "test" } }
+
+          it "does not allow the consumer to be deployed" do
+            expect(subject.deployment_status_summary).to_not be_deployable
+          end
+        end
+
+        context "when the provider has not been deployed to the given environment" do
+          before do
+            td.create_environment("test")
+              .create_pact_with_verification("Foo", "1", "Bar", "2")
+          end
+
+          let(:selectors) do
+            [
+              UnresolvedSelector.new(pacticipant_name: "Foo", pacticipant_version_number: "1"),
+            ]
+          end
+
+          let(:options) { { latestby: "cvp", environment_name: "test" } }
+
+          it "does not allow the consumer to be deployed" do
+            expect(subject.deployment_status_summary).to_not be_deployable
+          end
+        end
+
+        context "when the consumer has not been deployed to the given environment" do
+          before do
+            td.create_environment("test")
+              .create_pact_with_verification("Foo", "1", "Bar", "2")
+          end
+
+          let(:selectors) do
+            [
+              UnresolvedSelector.new(pacticipant_name: "Bar", pacticipant_version_number: "2"),
+            ]
+          end
+
+          let(:options) { { latestby: "cvp", environment_name: "test" } }
+
+          it "allows the provider to be deployed" do
+            expect(subject.deployment_status_summary).to be_deployable
+          end
+        end
+
+        describe "when deploying a version of a provider with multiple versions of a consumer in production" do
+          before do
+            td.create_environment("prod")
+              .create_pact_with_hierarchy("Foo", "1", "Bar")
+              .create_deployed_version_for_consumer_version(environment_name: "prod", target: "1")
+              .create_verification(provider_version: "10")
+              .create_consumer_version("2")
+              .create_pact
+              .create_deployed_version_for_consumer_version(environment_name: "prod", target: "2")
+          end
+
+          let(:selectors) { [ UnresolvedSelector.new(pacticipant_name: "Bar", pacticipant_version_number: "10") ]}
+          let(:options) { { environment_name: "prod" } }
+
+          it "knows that there are multiple versions of the consumer in production" do
+            subject
+            expect(subject.resolved_selectors.select { |s| s.pacticipant_name == "Bar" }.collect(&:one_of_many?)).to eq [false]
+            expect(subject.resolved_selectors.select { |s| s.pacticipant_name == "Foo" }.collect(&:one_of_many?)).to eq [true, true]
+          end
+
+          context "when a verification for the latest prod version is missing" do
+            it "does not allow the provider to be deployed" do
+              expect(subject.deployment_status_summary).to_not be_deployable
+            end
+          end
+
+          context "when there is a successful verification for every prod version of the consumer" do
+            before do
+              td.create_verification(provider_version: "10")
+            end
+
+            it "does allow the provider to be deployed" do
+              expect(subject.deployment_status_summary).to be_deployable
+            end
+          end
+        end
+
+        describe "when deploying a version of a consumer with multiple versions of a provider in production" do
+          before do
+            td.create_environment("prod")
+              .create_pact_with_hierarchy("Foo", "1", "Bar")
+              .create_verification(provider_version: "10")
+              .create_deployed_version_for_provider_version(environment_name: "prod", target: "1")
+              .create_consumer_version("2")
+              .create_pact
+              .create_provider_version("11")
+              .create_deployed_version_for_provider_version(environment_name: "prod", target: "2")
+          end
+
+          let(:selectors) { [ UnresolvedSelector.new(pacticipant_name: "Foo", pacticipant_version_number: "2") ]}
+          let(:options) { { environment_name: "prod" } }
+
+          it "knows that there are multiple versions of the provider in production" do
+            subject
+            expect(subject.resolved_selectors.select { |s| s.pacticipant_name == "Foo" }.collect(&:one_of_many?)).to eq [false]
+            expect(subject.resolved_selectors.select { |s| s.pacticipant_name == "Bar" }.collect(&:one_of_many?)).to eq [true, true]
+          end
+
+          context "when a verification for the latest prod version is missing" do
+            it "does not allow the consumer to be deployed" do
+              expect(subject.deployment_status_summary).to_not be_deployable
+            end
+          end
+
+          context "when there is a successful verification for every prod version of the consumer" do
+            before do
+              td.create_verification(provider_version: "11")
+            end
+
+            it "does allow the consumer to be deployed" do
+              expect(subject.deployment_status_summary).to be_deployable
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,226 @@
+require "pact_broker/matrix/service"
+
+module PactBroker
+  module Matrix
+    describe Service do
+      describe "find" do
+        subject { Service.can_i_deploy(selectors, options) }
+
+        # Useful for eyeballing the messages to make sure they read nicely
+        after do
+          # require 'pact_broker/api/decorators/reason_decorator'
+          # subject.deployment_status_summary.reasons.each do | reason |
+          #   puts reason
+          #   puts PactBroker::Api::Decorators::ReasonDecorator.new(reason).to_s
+          # end
+        end
+
+        let(:options) { {} }
+
+        shared_examples_for "without any ignore selectors" do
+          context "without any ignore selectors" do
+            let(:ignore_selectors) { [] }
+
+            its(:deployment_status_summary) { is_expected.to_not be_deployable}
+          end
+        end
+
+        shared_examples_for "with ignore selectors" do
+          its(:deployment_status_summary) { is_expected.to be_deployable}
+        end
+
+        describe "when deploying a consumer and ignoring a provider" do
+          let(:selectors) do
+            [ UnresolvedSelector.new(pacticipant_name: "Foo", pacticipant_version_number: "1") ]
+          end
+
+          let(:options) do
+            { latest: true, tag: "prod", latestby: "cvp", ignore_selectors: ignore_selectors }
+          end
+
+          let(:ignore_selectors) do
+            [ UnresolvedSelector.new(pacticipant_name: "Bar") ]
+          end
+
+          describe "with a missing verification from a provider" do
+            before do
+              td.create_pact_with_hierarchy("Foo", "1", "Bar")
+                .create_provider_version("2", tag_names: ["prod"])
+            end
+
+            include_context "with ignore selectors"
+            include_examples "without any ignore selectors"
+          end
+
+          describe "with a failed verification from a provider" do
+            before do
+              td.create_pact_with_hierarchy("Foo", "1", "Bar")
+                .create_verification(provider_version: "2", tag_names: ["prod"], success: false)
+            end
+
+            include_context "with ignore selectors"
+            include_examples "without any ignore selectors"
+
+            context "when ignoring the specific provider version" do
+              let(:ignore_selectors) do
+                [ UnresolvedSelector.new(pacticipant_name: "Bar", pacticipant_version_number: "2") ]
+              end
+
+              include_context "with ignore selectors"
+            end
+
+            context "when ignoring a different specific provider version" do
+              let(:ignore_selectors) do
+                [ UnresolvedSelector.new(pacticipant_name: "Bar", pacticipant_version_number: "999") ]
+              end
+
+              its(:deployment_status_summary) { is_expected.to_not be_deployable}
+            end
+          end
+
+          describe "when the provider has not been deployed" do
+            before do
+              td.create_pact_with_hierarchy("Foo", "1", "Bar")
+                .create_verification(provider_version: "2")
+            end
+
+            include_context "with ignore selectors"
+            include_examples "without any ignore selectors"
+          end
+
+          describe "when the consumer and provider have been specified" do
+            before do
+              td.create_pact_with_hierarchy("Foo", "1", "Bar")
+                .create_verification(provider_version: "2", success: false, tag_names: ["prod"])
+            end
+
+            let(:selectors) do
+              [
+                UnresolvedSelector.new(pacticipant_name: "Foo", pacticipant_version_number: "1"),
+                UnresolvedSelector.new(pacticipant_name: "Bar", tag: "prod", latest: true)
+              ]
+            end
+
+            include_context "with ignore selectors"
+            include_examples "without any ignore selectors"
+          end
+
+          describe "when the consumer and provider have been specified and the provider version specified does not exist" do
+            before do
+              td.create_pact_with_hierarchy("Foo", "1", "Bar")
+                .create_verification(provider_version: "2", success: true)
+            end
+
+            let(:selectors) do
+              [
+                UnresolvedSelector.new(pacticipant_name: "Foo", pacticipant_version_number: "1"),
+                UnresolvedSelector.new(pacticipant_name: "Bar", tag: "prod", latest: true)
+              ]
+            end
+
+            include_context "with ignore selectors"
+            include_examples "without any ignore selectors"
+          end
+
+          describe "when the provider to ignore does not exist" do
+            before do
+              td.create_pact_with_hierarchy("Foo", "1", "NotBar")
+                .create_verification(provider_version: "2", success: true)
+            end
+
+            let(:selectors) do
+              [
+                UnresolvedSelector.new(pacticipant_name: "Foo", pacticipant_version_number: "1"),
+              ]
+            end
+
+            it "includes a warning about the incorrect ignore selector" do
+              expect(subject.deployment_status_summary.reasons.collect(&:class)).to include(PactBroker::Matrix::IgnoreSelectorDoesNotExist)
+            end
+          end
+
+          describe "when the provider version to ignore does not exist" do
+            before do
+              td.create_pact_with_hierarchy("Foo", "1", "Bar")
+                .create_verification(provider_version: "2", success: true)
+            end
+
+            let(:selectors) do
+              [
+                UnresolvedSelector.new(pacticipant_name: "Foo", pacticipant_version_number: "1"),
+              ]
+            end
+
+            let(:ignore_selectors) do
+              [ UnresolvedSelector.new(pacticipant_name: "Bar", pacticipant_version_number: "999") ]
+            end
+
+            it "includes a warning about the incorrect ignore selector" do
+              expect(subject.deployment_status_summary.reasons.collect(&:class)).to include(PactBroker::Matrix::IgnoreSelectorDoesNotExist)
+            end
+          end
+        end
+
+        describe "when deploying a provider and ignoring a consumer" do
+          let(:selectors) do
+            [ UnresolvedSelector.new(pacticipant_name: "Bar", pacticipant_version_number: "2") ]
+          end
+
+          let(:options) do
+            { latest: true, tag: "prod", latestby: "cvp", ignore_selectors: ignore_selectors }
+          end
+
+          let(:ignore_selectors) do
+            []
+          end
+
+          let(:ignore_selectors) do
+            [ UnresolvedSelector.new(pacticipant_name: "Foo") ]
+          end
+
+          describe "with a missing verification from a provider" do
+            before do
+              td.create_pact_with_hierarchy("Foo", "1", "Bar")
+                .create_consumer_version_tag("prod")
+                .create_provider_version("2")
+            end
+
+            let(:ignore_selectors) { [] }
+
+            it "does allows the provider to be deployed even without ignoring anything because there is no connection between that version of the provider and the consumer" do
+              expect(subject.deployment_status_summary).to be_deployable
+              expect(subject.deployment_status_summary.reasons.collect(&:class)).to include(PactBroker::Matrix::NoDependenciesMissing)
+            end
+          end
+
+          describe "with a failed verification from a provider" do
+            before do
+              td.create_pact_with_hierarchy("Foo", "1", "Bar")
+                .create_consumer_version_tag("prod")
+                .create_verification(provider_version: "2", success: false)
+            end
+
+            include_context "with ignore selectors"
+            include_examples "without any ignore selectors"
+
+            context "when ignoring the specific consumer version" do
+              let(:ignore_selectors) do
+                [ UnresolvedSelector.new(pacticipant_name: "Foo", pacticipant_version_number: "1") ]
+              end
+
+              include_context "with ignore selectors"
+            end
+
+            context "when ignoring the wrong specific consumer version" do
+              let(:ignore_selectors) do
+                [ UnresolvedSelector.new(pacticipant_name: "Foo", pacticipant_version_number: "wrong") ]
+              end
+
+              its(:deployment_status_summary) { is_expected.to_not be_deployable}
+            end
+          end
+        end
+      end
+    end
+  end
+end