pact_broker 2.75.0 → 2.78.0

data/spec/lib/pact_broker/domain/webhook_spec.rb

@@ -11,10 +11,10 @@ module PactBroker
       let(:webhook_template_parameters) { instance_double(PactBroker::Webhooks::PactAndVerificationParameters, to_hash: webhook_template_parameters_hash) }
       let(:webhook_template_parameters_hash) { { 'foo' => 'bar' } }
       let(:http_request) { double('http request') }
-      let(:http_response) { double('http response') }
-      let(:webhook_context) { { some: 'things' } }
+      let(:http_response) { double('http response', code: "200") }
+      let(:event_context) { { some: 'things' } }
       let(:logging_options) { { other: 'options' } }
-      let(:options) { { webhook_context: webhook_context, logging_options: logging_options } }
+      let(:options) { { logging_options: logging_options } }
       let(:pact) { double('pact') }
       let(:verification) { double('verification') }
       let(:logger) { double('logger').as_null_object }
@@ -61,11 +61,11 @@ module PactBroker
 
         let(:webhook_request_logger) { instance_double(PactBroker::Webhooks::WebhookRequestLogger, log: "logs") }
 
-        let(:execute) { subject.execute pact, verification, options }
+        let(:execute) { subject.execute(pact, verification, event_context, options) }
 
         it "creates the template parameters" do
           expect(PactBroker::Webhooks::PactAndVerificationParameters).to receive(:new).with(
-            pact, verification, webhook_context
+            pact, verification, event_context
           )
           execute
         end
@@ -81,7 +81,7 @@ module PactBroker
         end
 
         it "generates the execution logs" do
-          expect(webhook_request_logger).to receive(:log).with(uuid, webhook_request, http_response, nil, webhook_context)
+          expect(webhook_request_logger).to receive(:log).with(uuid, webhook_request, http_response, nil, event_context)
           execute
         end
 
@@ -106,7 +106,7 @@ module PactBroker
           end
 
           it "generates the execution logs" do
-            expect(webhook_request_logger).to receive(:log).with(uuid, webhook_request, nil, instance_of(error_class), webhook_context)
+            expect(webhook_request_logger).to receive(:log).with(uuid, webhook_request, nil, instance_of(error_class), event_context)
             execute
           end
 

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

@@ -192,6 +192,43 @@ module PactBroker
               expect(rows[1].provider_name).to eq "Wiffle"
             end
           end
+
+          context "with tags[]=" do
+            before do
+              td.create_pact_with_hierarchy("Foo", "1.0.0", "Bar")
+                .create_verification(provider_version: "4.5.6")
+                .create_consumer_version("2.0.0")
+                .create_consumer_version_tag("dev")
+                .create_pact
+                .revise_pact
+                .create_consumer_version("2.1.0")
+                .create_consumer_version_tag("prod")
+                .create_consumer_version_tag("not-prod")
+                .create_pact
+                .revise_pact
+                .create_verification(provider_version: "4.5.6", number: 1)
+                .create_verification(provider_version: "4.5.7", number: 2)
+                .create_verification(provider_version: "4.5.8", number: 3)
+                .create_verification(provider_version: "4.5.9", number: 4)
+                .create_provider("Wiffle")
+                .create_pact
+            end
+
+            let(:options) { {tags: ["prod"]} }
+
+            it "returns a row for for the latest pact and a row for the prod pact (maybe it shouldn't return the latest as well)" do
+              expect(rows.size).to eq 2
+
+              expect(rows[0].latest?).to be true
+              expect(rows[0].provider_name).to eq "Bar"
+              expect(rows[0].tag_names).to eq ["prod"]
+              expect(rows[0].provider_version_number).to eq "4.5.9"
+
+              expect(rows[1].latest?).to be true
+              expect(rows[1].provider_name).to eq "Wiffle"
+              expect(rows[1].tag_names).to eq ["prod"]
+            end
+          end
         end
 
         context "when a pact with a tag has been verified, and then a new changed version has been published with the same tag" do
@@ -263,29 +300,66 @@ module PactBroker
           let(:page_size) { 2 }
           let(:tags) { nil }
 
-          before do
-            td.create_pact_with_hierarchy("Foo1", "1", "Bar1")
-              .create_pact_with_hierarchy("Foo2", "1", "Bar2")
-              .create_pact_with_hierarchy("Foo3", "1", "Bar3")
-          end
+          context "with no tags" do
+            before do
+              td.create_pact_with_hierarchy("Foo1", "1", "Bar1")
+                .create_pact_with_hierarchy("Foo2", "1", "Bar2")
+                .create_pact_with_hierarchy("Foo3", "1", "Bar3")
+            end
 
-          it "it returns the total number of records" do
-            expect(rows.pagination_record_count).to eq 3
-          end
+            it "it returns the total number of records" do
+              expect(rows.pagination_record_count).to eq 3
+            end
 
-          describe "the first page" do
-            it "contains 2 rows" do
-              expect(rows.count).to eq 2
+            describe "the first page" do
+              it "contains 2 rows" do
+                expect(rows.count).to eq 2
+              end
+            end
+
+            describe "the second page" do
+              let(:page_number) { 2 }
+
+              it "contains 1 row" do
+                expect(rows.count).to eq 1
+              end
             end
           end
 
-          describe "the second page" do
-            let(:page_number) { 2 }
+          context "with tags" do
+            before do
+              td.create_pact_with_hierarchy("Foo1", "1", "Bar1")
+                .create_consumer_version_tag("prod")
+                .create_consumer_version_tag("dev")
+                .create_pact_with_hierarchy("Foo2", "1", "Bar2")
+                .create_consumer_version_tag("prod")
+                .create_consumer_version_tag("dev")
+                .create_pact_with_hierarchy("Foo3", "1", "Bar3")
+                .create_consumer_version_tag("prod")
+                .create_consumer_version_tag("dev")
+            end
+
+            let(:tags) { true }
 
-            it "contains 1 row" do
-              expect(rows.count).to eq 1
+            it "it returns the total number of records" do
+              expect(rows.pagination_record_count).to eq 3
+            end
+
+            describe "the first page" do
+              it "contains 2 rows" do
+                expect(rows.count).to eq 2
+              end
+            end
+
+            describe "the second page" do
+              let(:page_number) { 2 }
+
+              it "contains 1 row" do
+                expect(rows.count).to eq 1
+              end
             end
           end
+
         end
       end
 

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

@@ -0,0 +1,400 @@
+require 'pact_broker/pacts/pact_publication'
+
+module PactBroker
+  module Pacts
+    describe PactPublication do
+      describe "latest_by_consumer_branch" do
+        before do
+          td.set_now(Date.new(2020, 1, 1))
+            .create_consumer("Foo")
+            .create_provider("Bar")
+            .create_consumer_version("1", branch: "main")
+            .create_pact
+            .set_now(Date.new(2020, 1, 2))
+            .create_consumer_version("2", branch: "feat/x")
+            .create_pact
+            .set_now(Date.new(2020, 1, 3))
+            .create_consumer_version("3", branch: "main", comment: "latest")
+            .create_pact
+            .set_now(Date.new(2020, 1, 4))
+            .create_consumer_version("4", branch: "feat/x", comment: "latest")
+            .create_pact
+            .set_now(Date.new(2020, 1, 5))
+            .create_consumer("FooZ")
+            .create_consumer_version("6", branch: "main", comment: "latest, different consumer")
+            .create_pact
+            .set_now(Date.new(2020, 1, 6))
+            .create_consumer_version("7", comment: "No branch")
+            .create_pact
+            .set_now(Date.new(2020, 1, 7))
+            .create_consumer_version("8", branch: "main", comment: "No pact")
+        end
+
+        subject { PactPublication.latest_by_consumer_branch.all }
+
+        let(:foo) { PactBroker::Domain::Pacticipant.where(name: "Foo").single_record }
+        let(:bar) { PactBroker::Domain::Pacticipant.where(name: "Bar").single_record }
+        let(:foo_z) { PactBroker::Domain::Pacticipant.where(name: "FooZ").single_record }
+
+        it "returns the latest pact publications for each consumer/branch" do
+          expect(subject.size).to eq 3
+
+          expect(subject.find { |pp| pp.consumer_id == foo.id && pp[:branch] == "main" }.consumer_version.number).to eq "3"
+          expect(subject.find { |pp| pp.consumer_id == foo.id && pp[:branch] == "feat/x" }.consumer_version.number).to eq "4"
+          expect(subject.find { |pp| pp.consumer_id == foo_z.id && pp[:branch] == "main" }.consumer_version.number).to eq "6"
+        end
+
+        it "does not return extra columns" do
+          expect(subject.first.values.keys.sort).to eq (PactPublication.columns + [:branch]).sort
+        end
+
+        context "chained with created after" do
+          subject { PactPublication.created_after(DateTime.new(2020, 1, 3)).latest_by_consumer_branch.all }
+
+          its(:size) { is_expected.to eq 2 }
+
+          it "returns the right versions" do
+            expect(subject.find { |pp| pp.consumer_id == foo.id && pp[:branch] == "feat/x" }.consumer_version.number).to eq "4"
+            expect(subject.find { |pp| pp.consumer_id == foo_z.id && pp[:branch] == "main" }.consumer_version.number).to eq "6"
+          end
+        end
+      end
+
+      describe "latest_for_consumer_branch" do
+        before do
+          td.create_consumer("Foo")
+            .create_provider("Bar")
+            .create_consumer_version("1", branch: "main")
+            .create_pact
+            .create_consumer_version("2", branch: "main")
+            .create_pact
+            .create_consumer_version("3", branch: "feat-x")
+            .create_pact
+            .create_consumer("Foo2")
+            .create_provider("Bar2")
+            .create_consumer_version("10", branch: "main")
+            .create_pact
+            .create_consumer_version("11", branch: "main")
+            .create_pact
+        end
+
+        subject { PactPublication.latest_for_consumer_branch("main") }
+
+        it "returns the latest pacts for the branches with the specified name (for any consumer/provider)" do
+          all = subject.all.sort_by{ |pact_publication| pact_publication.consumer_version.order }
+          expect(all.size).to eq 2
+          expect(all.first.consumer.name).to eq "Foo"
+          expect(all.first.provider.name).to eq "Bar"
+          expect(all.first.consumer_version.number).to eq "2"
+
+          expect(all.last.consumer.name).to eq "Foo2"
+          expect(all.last.provider.name).to eq "Bar2"
+          expect(all.last.consumer_version.number).to eq "11"
+        end
+
+        it "does not return extra columns" do
+          expect(subject.first.values.keys.sort).to eq (PactPublication.columns + [:branch]).sort
+        end
+
+        context "when columns are already selected" do
+          subject { PactPublication.select(Sequel[:pact_publications][:id]).latest_for_consumer_branch("main") }
+
+          it "does not override them" do
+            expect(subject.all.first.values.keys).to eq [:id]
+          end
+        end
+
+        context "when chained" do
+          it "works" do
+            all = PactPublication.for_provider(td.find_pacticipant("Bar")).latest_for_consumer_branch("main").all
+            expect(all.first.provider.name).to eq "Bar"
+          end
+        end
+      end
+
+      describe "latest_by_consumer_tag" do
+        before do
+          td.create_consumer("Foo")
+            .create_provider("Bar")
+            .create_consumer_version("1", tag_names: ["main"])
+            .create_pact
+            .create_consumer_version("2", tag_names: ["feat/x"])
+            .create_pact
+            .create_consumer_version("3", tag_names: ["main"], comment: "latest")
+            .create_pact
+            .create_consumer_version("4", tag_names: ["feat/x"], comment: "latest")
+            .create_pact
+            .create_consumer("FooZ")
+            .create_consumer_version("6", tag_names: ["main"], comment: "Different consumer")
+            .create_pact
+            .create_consumer_version("7", comment: "No branch")
+            .create_pact
+            .create_consumer_version("8", tag_names: ["main"], comment: "No pact")
+        end
+
+        subject { PactPublication.latest_by_consumer_tag.all }
+
+        let(:foo) { PactBroker::Domain::Pacticipant.where(name: "Foo").single_record }
+        let(:bar) { PactBroker::Domain::Pacticipant.where(name: "Bar").single_record }
+        let(:foo_z) { PactBroker::Domain::Pacticipant.where(name: "FooZ").single_record }
+
+        it "returns the latest pact publications for each consumer/branch" do
+          expect(subject.size).to eq 3
+          hashes = subject.collect(&:values)
+
+          expect(subject.find { |pp| pp.consumer_id == foo.id && pp[:tag_name] == "main" }.consumer_version.number).to eq "3"
+          expect(subject.find { |pp| pp.consumer_id == foo.id && pp[:tag_name] == "feat/x" }.consumer_version.number).to eq "4"
+          expect(subject.find { |pp| pp.consumer_id == foo_z.id && pp[:tag_name] == "main" }.consumer_version.number).to eq "6"
+        end
+
+        it "does not return extra columns" do
+          expect(subject.first.values.keys.sort).to eq (PactPublication.columns + [:tag_name]).sort
+        end
+
+        context "when columns are already selected" do
+          subject { PactPublication.select(Sequel[:pact_publications][:id]).latest_by_consumer_tag }
+
+          it "does not override them" do
+            expect(subject.all.first.values.keys).to eq [:id]
+          end
+        end
+      end
+
+      describe "overall_latest" do
+        before do
+          td.create_consumer("Foo")
+            .create_provider("Bar")
+            .create_consumer_version("1", tag_names: ["main"])
+            .create_pact
+            .create_consumer_version("2", tag_names: ["main"])
+            .create_pact
+            .create_consumer_version("3", tag_names: ["feat/x"])
+            .create_pact
+            .create_consumer("Foo2")
+            .create_provider("Bar2")
+            .create_consumer_version("10", tag_names: ["main"])
+            .create_pact
+            .create_consumer_version("11", tag_names: ["main"])
+            .create_pact
+        end
+
+        subject { PactPublication.overall_latest }
+
+        it "returns the latest by consumer/provider" do
+          all = subject.all.sort_by{ | pact_publication | pact_publication.consumer_version.order }
+          expect(all.size).to eq 2
+        end
+
+        it "does not return extra columns" do
+          expect(subject.all.first.values.keys.sort).to eq PactPublication.columns.sort
+        end
+
+        context "when columns are already selected" do
+          subject { PactPublication.select(Sequel[:pact_publications][:id]).overall_latest }
+
+          it "does not override them" do
+            expect(subject.all.first.values.keys).to eq [:id]
+          end
+        end
+
+        context "when chained" do
+          it "works with a consumer" do
+            expect(PactPublication.for_consumer(td.find_pacticipant("Foo")).overall_latest.all.first.consumer.name).to eq "Foo"
+          end
+
+          it "works with a consumer and provider" do
+            td.create_pact_with_hierarchy("Foo", "666", "Nope")
+            all = PactPublication
+              .for_consumer(td.find_pacticipant("Foo"))
+              .for_provider(td.find_pacticipant("Bar"))
+              .overall_latest.all
+            expect(all.size).to eq 1
+            expect(all.first.consumer.name).to eq "Foo"
+            expect(all.first.provider.name).to eq "Bar"
+          end
+        end
+      end
+
+      describe "latest_for_consumer_tag" do
+        before do
+          td.create_consumer("Foo")
+            .create_provider("Bar")
+            .create_consumer_version("1", tag_names: ["main"])
+            .create_pact
+            .create_consumer_version("2", tag_names: ["main"])
+            .create_pact
+            .revise_pact
+            .create_consumer_version("3", tag_names: ["feat/x"])
+            .create_pact
+            .create_consumer("Foo2")
+            .create_provider("Bar2")
+            .create_consumer_version("10", tag_names: ["main"])
+            .create_pact
+            .create_consumer_version("11", tag_names: ["main"])
+            .create_pact
+        end
+
+        subject { PactPublication.latest_for_consumer_tag("main") }
+
+        it "returns the latest pacts for the tags with the specified name (for any consumer/provider)" do
+          all = subject.all.sort_by{ |pact_publication| pact_publication.consumer_version.order }
+          expect(all.size).to eq 2
+          expect(all.first.consumer.name).to eq "Foo"
+          expect(all.first.provider.name).to eq "Bar"
+          expect(all.first.consumer_version.number).to eq "2"
+
+          expect(all.last.consumer.name).to eq "Foo2"
+          expect(all.last.provider.name).to eq "Bar2"
+          expect(all.last.consumer_version.number).to eq "11"
+        end
+
+        it "does not return extra columns" do
+          expect(subject.all.first.values.keys.sort).to eq (PactPublication.columns + [:tag_name]).sort
+        end
+
+        context "when columns are already selected" do
+          subject { PactPublication.select(Sequel[:pact_publications][:id]).latest_for_consumer_tag("main") }
+
+          it "does not override them" do
+            expect(subject.all.first.values.keys).to eq [:id]
+          end
+        end
+
+        context "when chained" do
+          it "works" do
+            all = PactPublication.for_provider(td.find_pacticipant("Bar")).latest_for_consumer_tag("main").all
+            expect(all.first.provider.name).to eq "Bar"
+          end
+        end
+      end
+
+      describe "#successfully_verified_by_provider_branch" do
+        let(:bar) { td.find_pacticipant("Bar") }
+
+        subject { PactPublication.successfully_verified_by_provider_branch(bar.id, "main").all }
+
+        context "PactPublication" do
+          before do
+            td.create_pact_with_hierarchy("Foo", "1", "Bar")
+              .create_verification(provider_version: "2", branch: "main", success: false)
+              .create_pact_with_hierarchy("Foo", "2", "Bar")
+              .create_verification(provider_version: "2", branch: "main", success: true)
+              .create_pact_with_hierarchy("Foo", "3", "Bar")
+              .create_verification(provider_version: "3", branch: "not-main", success: true)
+          end
+
+          it "returns the pact publications that have been succesfully verified by the given provider id and branch" do
+            expect(subject.size).to eq 1
+            expect(subject.first.consumer_version.number).to eq "2"
+          end
+
+          it "does not return extra columns" do
+            expect(subject.first.values.keys.sort).to eq PactPublication.columns.sort
+          end
+        end
+
+
+        context "with chained scopes" do
+          subject { PactPublication.latest_by_consumer_branch.successfully_verified_by_provider_branch(bar.id, "provider-main").all }
+
+          context "when there are no latest branch pacts that have been successfully verified by the specified provider branch" do
+            before do
+              td.create_consumer("Foo")
+                .create_provider("Bar")
+                .create_consumer_version("1", branch: "main", comment: "not latest")
+                .create_pact
+                .create_verification(provider_version: "1", success: true, branch: "provider-main", comment: "successful but not latest")
+                .create_consumer_version("2", branch: "main", comment: "latest")
+                .create_pact
+                .create_verification(provider_version: "2", success: false, branch: "provider-main", comment: "latest but not successful")
+                .create_consumer_version("3", branch: "feat/x", comment: "latest")
+                .create_pact
+                .create_verification(provider_version: "3", success: true, branch: "not-provider-main", comment: "latest, successful, but wrong branch")
+            end
+
+            it { is_expected.to eq [] }
+          end
+
+          context "when there are latest branch pacts that have been successfully verified by the specified provider branch" do
+            before do
+              td.create_consumer("Foo")
+                .create_provider("Bar")
+                .create_consumer_version("1", branch: "main", comment: "not latest")
+                .create_pact
+                .create_verification(provider_version: "1", success: true, branch: "provider-main")
+                .create_consumer_version("2", branch: "main", comment: "latest")
+                .create_pact
+                .create_verification(provider_version: "1", success: true, branch: "provider-main")
+                .create_verification(provider_version: "2", success: true, branch: "provider-main", number: "2")
+            end
+
+            its(:size) { is_expected.to eq 1 }
+
+            it "returns them" do
+              expect(subject.first.consumer_version.number).to eq "2"
+            end
+          end
+
+          context "when there are latest tagged pacts that have been successfully verified by the specified provider branch" do
+            before do
+              td.create_consumer("Foo")
+                .create_provider("Bar")
+                .create_consumer_version("1", tag_names: ["main"], comment: "not latest")
+                .create_pact
+                .create_verification(provider_version: "1", success: true, tag_names: ["provider-main"])
+                .create_consumer_version("2", tag_names: ["main"], comment: "latest")
+                .create_pact
+                .create_verification(provider_version: "1", success: true, branch: "provider-main")
+                .create_verification(provider_version: "2", success: true, branch: "provider-main", number: "2")
+            end
+
+            subject { PactPublication.latest_by_consumer_tag.successfully_verified_by_provider_branch(bar.id, "provider-main").all }
+
+            its(:size) { is_expected.to eq 1 }
+
+            it "returns them" do
+              expect(subject.first.consumer_version.number).to eq "2"
+            end
+          end
+
+          context "subtracting Pact Publications" do
+            before do
+              td.create_consumer("Foo")
+                .create_provider("Bar")
+                .create_consumer_version("1", branch: "main", tag_names: ["main"], comment: "not latest")
+                .create_pact
+                .create_verification(provider_version: "1", success: true, branch: "provider-main")
+                .create_consumer_version("2", branch: "main", tag_names: ["main"], comment: "latest")
+                .create_pact
+                .create_verification(provider_version: "1", success: true, branch: "provider-main")
+                .create_verification(provider_version: "2", success: true, branch: "provider-main", number: "2")
+                .create_consumer_version("3", branch: "feat/x", tag_names: ["feat/x"], )
+                .create_pact
+            end
+
+            let(:bar) { td.find_pacticipant("Bar") }
+
+            it "with branches" do
+              potential = PactPublication.for_provider(bar).latest_by_consumer_branch
+              already_verified = potential.successfully_verified_by_provider_branch(bar.id, "provider-main")
+              not_verified = PactPublication.subtract(potential.all, already_verified.all)
+
+              expect(not_verified.size).to eq 1
+              expect(not_verified.first.consumer_version_number).to eq "3"
+            end
+
+            it "with tags" do
+              potential = PactPublication.for_provider(bar).latest_by_consumer_tag
+              already_verified = potential.successfully_verified_by_provider_branch(bar.id, "provider-main")
+              not_verified = PactPublication.subtract(potential.all, already_verified.all)
+
+              expect(not_verified.size).to eq 1
+              expect(not_verified.first.consumer_version_number).to eq "3"
+            end
+          end
+        end
+      end
+    end
+  end
+end
+