pact_broker 2.27.6 → 2.29.0

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

@@ -5,6 +5,29 @@ module PactBroker
     describe HeadRow do
       let(:td) { TestDataBuilder.new }
 
+      describe "webhooks" do
+        let(:td) { TestDataBuilder.new }
+
+        before do
+          td.create_consumer("Foo")
+            .create_provider("Bar")
+            .create_consumer_version
+            .create_pact
+            .create_global_webhook
+            .create_consumer_webhook
+            .create_provider_webhook
+            .create_provider("Wiffle")
+            .create_provider_webhook
+        end
+
+        let(:row) { HeadRow.where(consumer_name: "Foo", provider_name: "Bar").single_record }
+
+        it "returns all the webhooks" do
+          rows = HeadRow.eager(:webhooks).all
+          expect(rows.first.webhooks.count).to eq 3
+        end
+      end
+
       describe "latest_verification_for_consumer_version_tag" do
         context "when the pact with a given tag has been verified" do
           before do

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

@@ -0,0 +1,242 @@
+require 'pact_broker/matrix/service'
+
+module PactBroker
+  module Matrix
+    describe Service do
+      let(:td) { TestDataBuilder.new }
+      describe "find" do
+        subject { Service.find(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) { {} }
+
+        describe "find" do
+          let(:selectors) do
+            [ { pacticipant_name: "foo" } ]
+          end
+
+          let(:options) do
+            { latest: true, tag: "prod" }
+          end
+
+          before do
+            td.create_pact_with_hierarchy("foo", "1", "bar")
+              .create_verification(provider_version: "2", tag_names: ["prod"])
+          end
+
+          it "returns a QueryResultsWithDeploymentStatusSummary" do
+            expect(subject.rows).to be_a(Array)
+            expect(subject.selectors).to be selectors
+            expect(subject.options).to be options
+            expect(subject.resolved_selectors).to be_a(Array)
+            expect(subject.resolved_selectors.count).to eq 2
+            expect(subject.integrations.count).to eq 1
+            expect(subject.deployment_status_summary).to be_a(DeploymentStatusSummary)
+          end
+        end
+
+        describe "when deploying a version of a provider with multiple versions of a consumer in production that is missing a verification for the latest prod version" do
+          before do
+            td.create_pact_with_hierarchy("Foo", "1", "Bar")
+              .create_consumer_version_tag("prod")
+              .create_verification(provider_version: "10", tag_names: ["test"])
+              .create_consumer_version("2", tag_names: ["prod"])
+              .create_pact
+          end
+
+          let(:selectors) { [{ pacticipant_name: "Bar", latest: true, tag: "test" }]}
+          let(:options) { { tag: "prod" } }
+
+          it "does not allow the consumer to be deployed" do
+            expect(subject.deployment_status_summary.deployable?).to_not be true
+          end
+        end
+
+        describe "when deploying a consumer that has not been verified by any providers" do
+          before do
+            td.create_pact_with_hierarchy("Foo", "1", "Bar")
+              .create_provider("Baz")
+              .create_pact
+          end
+          let(:selectors) do
+            [ { pacticipant_name: "Foo", pacticipant_version_number: "1" } ]
+          end
+
+          it "returns 2 integrations" do
+            expect(subject.integrations.size).to eq 2
+          end
+
+          it "but cannot resolve selectors for the providers" do
+            expect(subject.resolved_selectors.size).to eq 1
+          end
+
+          it "does not allow the consumer to be deployed" do
+            expect(subject.deployment_status_summary.deployable?).to_not be true
+          end
+        end
+
+        describe "when deploying a consumer that has two providers in prod, but it is not verified by one of the prod provider versions, pact_broker-client issue #33" do
+          before do
+            td.create_pact_with_hierarchy("Foo", "3.0.0", "Bar")
+              .create_verification(provider_version: "10.0.0", tag_names: ["prod"])
+              .create_provider("Baz")
+              .create_pact
+              .create_verification(provider_version: "20", tag_names:["prod"])
+              .create_consumer_version("2.0.0")
+              .use_provider("Bar")
+              .create_pact
+              .create_verification(provider_version: "11.0.0", tag_names: ["prod"])
+          end
+
+          let(:selectors) do
+            [ { pacticipant_name: "Foo", pacticipant_version_number: "3.0.0" } ]
+          end
+
+          let(:options) { {latest: true, tag: "prod"} }
+
+          it "returns 2 integrations" do
+            expect(subject.integrations.size).to eq 2
+          end
+
+          it "returns 1 row" do
+            expect(subject.rows.size).to eq 1
+          end
+
+          it "does not allow the consumer to be deployed" do
+            expect(subject.deployment_status_summary.deployable?).to_not be true
+          end
+        end
+
+        describe "when deploying an old version of a consumer that has added a new provider since that version" do
+          before do
+            td.create_pact_with_hierarchy("Foo", "1", "Bar")
+              .create_verification(provider_version: "2")
+              .create_consumer_version("2")
+              .create_pact
+              .create_verification(provider_version: "3")
+              .create_provider("Wiffle")
+              .create_pact
+              .create_verification(provider_version: "10")
+          end
+
+          let(:selectors) do
+            [ { pacticipant_name: "Foo", pacticipant_version_number: "1" } ]
+          end
+
+          it "allows the old version of the consumer to be deployed" do
+            expect(subject.deployment_status_summary.deployable?).to be true
+          end
+        end
+
+        describe "when the specified version does not exist" do
+          before do
+            td.create_pact_with_hierarchy("Foo", "1", "Bar")
+          end
+
+          let(:selectors) do
+            [ { pacticipant_name: "Bar", pacticipant_version_number: "5" } ]
+          end
+
+          it "does not allow the provider to be deployed" do
+            expect(subject.deployment_status_summary.deployable?).to_not be true
+          end
+        end
+
+        describe "when deploying a provider to prod for the first time and the consumer is not yet deployed" do
+          before do
+            td.create_pact_with_hierarchy("Foo", "1", "Bar")
+            .create_verification(provider_version: "2")
+          end
+
+          let(:selectors) do
+            [ { pacticipant_name: "Bar", pacticipant_version_number: "2" } ]
+          end
+
+          let(:options) do
+            { latest: true, tag: "prod" }
+          end
+
+          subject { Service.find(selectors, options) }
+
+          it "allows the provider to be deployed" do
+            expect(subject.deployment_status_summary.deployable?).to be true
+          end
+        end
+
+        describe "when deploying a consumer to prod for the first time and the provider is not yet deployed" do
+          before do
+            td.create_pact_with_hierarchy("Foo", "1", "Bar")
+            .create_verification(provider_version: "2")
+          end
+
+          let(:selectors) do
+            [ { pacticipant_name: "Foo", pacticipant_version_number: "1" } ]
+          end
+
+          let(:options) do
+            { latest: true, tag: "prod" }
+          end
+
+          it "does not allow the consumer to be deployed" do
+            expect(subject.deployment_status_summary.deployable?).to_not be true
+          end
+        end
+
+        describe "when deploying an app that is both a consumer and a provider to prod for the first time and the downstream provider is not yet deployed" do
+          before do
+            td.create_pact_with_hierarchy("Foo", "1", "Bar")
+            .create_verification(provider_version: "2")
+            .use_consumer("Bar")
+            .use_consumer_version("2")
+            .create_provider("Baz")
+            .create_pact
+          end
+
+          let(:selectors) do
+            [ { pacticipant_name: "Bar", pacticipant_version_number: "2" } ]
+          end
+
+          let(:options) do
+            { latest: true, tag: "prod" }
+          end
+
+          it "does not allow the app to be deployed" do
+            expect(subject.deployment_status_summary.deployable?).to_not be true
+          end
+        end
+
+        describe "when deploying an app that is both a consumer and a provider to prod for the first time and the downstream provider has been deployed" do
+          before do
+            td.create_pact_with_hierarchy("Foo", "1", "Bar")
+            .create_verification(provider_version: "2")
+            .use_consumer("Bar")
+            .use_consumer_version("2")
+            .create_provider("Baz")
+            .create_pact
+            .create_verification(provider_version: "4", tag_names: "prod")
+          end
+
+          let(:selectors) do
+            [ { pacticipant_name: "Bar", pacticipant_version_number: "2" } ]
+          end
+
+          let(:options) do
+            { latest: true, tag: "prod" }
+          end
+
+          it "allows the app to be deployed" do
+            expect(subject.deployment_status_summary.deployable?).to be true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+require 'pact_broker/matrix/repository'
+
+module PactBroker
+  module Matrix
+    describe Repository do
+      let(:td) { TestDataBuilder.new}
+
+      def build_selectors(hash)
+        hash.collect do | key, value |
+          { pacticipant_name: key, pacticipant_version_number: value }
+        end
+      end
+
+      def shorten_row row
+        "#{row[:consumer_name]}#{row[:consumer_version_number]} #{row[:provider_name]}#{row[:provider_version_number] || '?'} n#{row[:verification_number] || '?'}"
+      end
+
+      def shorten_rows rows
+        rows.collect{ |r| shorten_row(r) }
+      end
+
+      describe "find when deploying a provider to prod for the first time and the consumer has not been deployed yet" do
+        before do
+          td.create_pact_with_hierarchy("Foo", "1", "Bar")
+            .create_verification(provider_version: "2")
+        end
+
+        let(:selectors) { [ { pacticipant_name: "Bar", pacticipant_version_number: "2" } ] }
+        let(:options) { { latest: true, tag: "prod"} }
+
+        subject { shorten_rows(rows) }
+        let(:rows) { Repository.new.find(selectors, options) }
+
+        it "returns an empty array" do
+          expect(rows).to eq []
+        end
+      end
+
+      describe "find when deploying a consumer to prod for the first time and the provider has not been deployed yet" do
+        before do
+          td.create_pact_with_hierarchy("Foo", "1", "Bar")
+            .create_verification(provider_version: "2")
+        end
+
+        let(:selectors) { [ { pacticipant_name: "Foo", pacticipant_version_number: "1" } ] }
+        let(:options) { { latest: true, tag: "prod"} }
+
+        subject { shorten_rows(rows) }
+        let(:results) { Repository.new.find(selectors, options) }
+
+        it "returns an empty array" do
+          expect(results).to eq []
+          expect(results.resolved_selectors.find{ |s | s[:pacticipant_name] == "Bar"}[:pacticipant_version_id]).to eq -1
+        end
+      end
+    end
+  end
+end

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

@@ -956,24 +956,27 @@ module PactBroker
           context "when the latest tag is specified" do
             let(:selectors) { [{ pacticipant_name: 'D', latest: true, tag: 'dev' } ] }
 
-            it "raises an error" do
-              expect { subject }.to raise_error Error, /No version of D found/
+            it "returns an empty array" do
+              expect(subject).to eq []
+              expect(subject.resolved_selectors.find{ |s | s[:pacticipant_name] == "D"}[:pacticipant_version_id]).to eq -1
             end
           end
 
           context "when all tags are specified" do
             let(:selectors) { [{ pacticipant_name: 'D', tag: 'dev' } ] }
 
-            it "raises an error" do
-              expect { subject }.to raise_error Error, /No version of D found/
+            it "returns an empty array" do
+              expect(subject).to eq []
+              expect(subject.resolved_selectors.find{ |s | s[:pacticipant_name] == "D"}[:pacticipant_version_id]).to eq -1
             end
           end
 
           context "when no tags are specified" do
             let(:selectors) { [{ pacticipant_name: 'E', latest: true } ] }
 
-            it "raises an error" do
-              expect { subject }.to raise_error Error, /No version of E found/
+            it "returns an empty array" do
+              expect(subject).to eq []
+              expect(subject.resolved_selectors.find{ |s | s[:pacticipant_name] == "E"}[:pacticipant_version_id]).to eq -1
             end
           end
         end
@@ -988,6 +991,8 @@ module PactBroker
           .create_pact
           .create_verification(provider_version: "10.0.0", tag_names: ["prod"])
           .create_provider("baz")
+          .create_pact
+          .create_verification(provider_version: "9.0.0")
           .create_consumer_version("2.0.0")
           .create_pact
           .create_verification(provider_version: "20.0.0", tag_names: ["prod"])
@@ -995,12 +1000,40 @@ module PactBroker
 
         let(:selectors) { [{ pacticipant_name: "foo", pacticipant_version_number: "1.0.0" }] }
         let(:options) { {latestby: "cvp", latest: true, tag: "prod"} }
+        let(:results) { Repository.new.find(selectors, options) }
 
-        subject { shorten_rows(Repository.new.find(selectors, options)) }
+        subject { shorten_rows(results) }
 
         it "only returns a row for the foo pact version that has been verified by the current production version of bar" do
           expect(subject).to eq ["foo1.0.0 bar10.0.0 n1"]
         end
+
+        it "returns 2 integrations" do
+          expect(results.integrations.size).to eq 2
+        end
+      end
+
+      describe "when deploying a provider and the version of the consumer is not specified and multiple consumer versions have been verified by this provider version" do
+        before do
+          td.create_pact_with_hierarchy("Foo", "1", "Bar")
+            .create_verification(provider_version: "5")
+            .create_consumer_version("2")
+            .create_pact
+            .create_verification(provider_version: "5")
+        end
+
+        subject { Repository.new.find(selectors, options) }
+
+        let(:options) { { latestby: 'cvp' } }
+
+        let(:selectors) do
+          [ { pacticipant_name: "Bar", pacticipant_version_number: "5" } ]
+        end
+
+        it "returns only the latest consumer version row", pending: "Can't work out what this should do" do
+          expect(subject.rows.size).to eq 1
+          expect(subject.rows.first.consumer_version_number).to eq "2"
+        end
       end
     end
   end

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

@@ -5,32 +5,6 @@ module PactBroker
     describe Service do
       let(:td) { TestDataBuilder.new }
 
-      describe "find integration test" do
-        let(:selectors) do
-          [ { pacticipant_name: "foo" } ]
-        end
-
-        let(:options) do
-          { latest: true, tag: "prod" }
-        end
-
-        before do
-          td.create_pact_with_hierarchy("foo", "1", "bar")
-            .create_verification(provider_version: "2", tag_names: ["prod"])
-        end
-
-        subject { Service.find(selectors, options) }
-
-        it "returns a QueryResultsWithDeploymentStatusSummary" do
-          expect(subject.rows).to be_a(Array)
-          expect(subject.selectors).to be selectors
-          expect(subject.options).to be options
-          expect(subject.resolved_selectors).to be_a(Array)
-          expect(subject.resolved_selectors.count).to eq 2
-          expect(subject.deployment_status_summary).to be_a(DeploymentStatusSummary)
-        end
-      end
-
       describe "validate_selectors" do
 
         subject { Service.validate_selectors(selectors) }
@@ -43,21 +17,6 @@ module PactBroker
           end
         end
 
-        context "when one or more of the selectors does not match any known version" do
-          before do
-            td.create_pacticipant("Foo")
-              .create_version("1")
-              .create_pacticipant("Bar")
-              .create_version("2")
-          end
-
-          let(:selectors) { [{ pacticipant_name: "Foo", pacticipant_version_number: "1" }, { pacticipant_name: "Bar", pacticipant_version_number: "1" }] }
-
-          it "returns error messages" do
-            expect(subject).to eq ["No pact or verification found for Bar version 1"]
-          end
-        end
-
         context "when the pacticipant does not exist" do
           let(:selectors) { [{ pacticipant_name: "Foo", pacticipant_version_number: "1" }] }
 
@@ -105,15 +64,6 @@ module PactBroker
               expect(subject).to eq []
             end
           end
-
-          context "when there is not a version for the tag" do
-
-            let(:selectors) { [{ pacticipant_name: "Foo", latest: true, tag: "wiffle" }, { pacticipant_name: "Bar", pacticipant_version_number: "2" }] }
-
-            it "returns an error message" do
-              expect(subject).to eq ["No version of Foo found with tag wiffle"]
-            end
-          end
         end
 
         context "when the latest is used as well as a version" do