pact_broker 2.76.2 → 2.77.0

data/spec/lib/pact_broker/configuration_spec.rb

@@ -60,6 +60,18 @@ module PactBroker
         end
       end
 
+      describe "webhook_http_code_success" do
+        it "allows setting the 'webhook_http_code_success' by a space-delimited string" do
+          PactBroker.configuration.webhook_http_code_success = "200 201 202"
+          expect(PactBroker.configuration.webhook_http_code_success).to be_a Config::SpaceDelimitedIntegerList
+        end
+
+        it "allows setting the 'webhook_http_code_success' by an array" do
+          PactBroker.configuration.webhook_http_code_success = [200, 201, 202]
+          expect(PactBroker.configuration.webhook_http_code_success).to be_a Config::SpaceDelimitedIntegerList
+        end
+      end
+
       describe "webhook_scheme_whitelist" do
         it "allows setting the whitelist by a string" do
           PactBroker.configuration.webhook_scheme_whitelist = "foo"

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

@@ -3,22 +3,23 @@ require 'pact_broker/domain/tag'
 module PactBroker
   module Domain
     describe Tag do
-      before do
-        td.create_consumer("foo")
-          .create_consumer_version("1")
-          .create_consumer_version_tag("dev")
-          .create_consumer_version_tag("prod")
-          .create_consumer_version("2")
-          .create_consumer_version_tag("dev")
-          .create_consumer_version_tag("bloop")
-          .create_consumer_version("3")
-          .create_consumer_version_tag("dev")
-          .create_consumer("bar")
-          .create_consumer_version("1")
-          .create_consumer_version_tag("test")
-      end
 
       describe "#latest_tags_for_pacticipant_ids" do
+        before do
+          td.create_consumer("foo")
+            .create_consumer_version("1")
+            .create_consumer_version_tag("dev")
+            .create_consumer_version_tag("prod")
+            .create_consumer_version("2")
+            .create_consumer_version_tag("dev")
+            .create_consumer_version_tag("bloop")
+            .create_consumer_version("3")
+            .create_consumer_version_tag("dev")
+            .create_consumer("bar")
+            .create_consumer_version("1")
+            .create_consumer_version_tag("test")
+        end
+
         it "returns the latest tags for the given pacticipant ids" do
           pacticipant = PactBroker::Domain::Pacticipant.order(:id).first
           tags = Tag.latest_tags_for_pacticipant_ids([pacticipant.id]).all
@@ -32,6 +33,21 @@ module PactBroker
       end
 
       describe "latest_tags" do
+        before do
+          td.create_consumer("foo")
+            .create_consumer_version("1")
+            .create_consumer_version_tag("dev")
+            .create_consumer_version_tag("prod")
+            .create_consumer_version("2")
+            .create_consumer_version_tag("dev")
+            .create_consumer_version_tag("bloop")
+            .create_consumer_version("3")
+            .create_consumer_version_tag("dev")
+            .create_consumer("bar")
+            .create_consumer_version("1")
+            .create_consumer_version_tag("test")
+        end
+
         it "returns the tags that belong to the most recent version with that tag/pacticipant" do
           tags = Tag.latest_tags.all
           expect(tags.collect(&:name).sort).to eq %w{bloop dev prod test}
@@ -42,19 +58,77 @@ module PactBroker
           expect(tags.collect(&:created_at).compact.size).to eq 4
         end
       end
+
+      describe "latest_for_pacticipant?" do
+        before do
+          # Foo v1 Bar1
+          # Foo v1 Bar2
+          # Foo v2 Bar1
+          td.create_pact_with_verification_and_tags("Foo", "1", ["dev", "prod"], "Bar1")
+            .create_provider("Bar2")
+            .create_pact
+            .create_pact_with_verification_and_tags("Foo", "2", ["dev"], "Bar1")
+            .create_consumer_version("3")
+            .create_consumer_version_tag("dev")
+        end
+
+        it "returns true if there are no other tags with that name for that pacticipant for a later version" do
+          version_1 = PactBroker::Versions::Repository.new.find_by_pacticipant_name_and_number("Foo", "1")
+          expect(version_1.tags.find { |t| t.name == "prod" }.latest_for_pacticipant?).to be true
+          expect(version_1.tags.find { |t| t.name == "dev" }.latest_for_pacticipant?).to be false
+        end
+      end
+
+      describe "head_tags_for_pact_publication" do
+        before do
+          # Foo v1 Bar1
+          # Foo v1 Bar2
+          # Foo v2 Bar1
+          td.create_pact_with_verification_and_tags("Foo", "1", ["dev", "prod"], "Bar1")
+            .create_provider("Bar2")
+            .create_pact
+            .create_pact_with_verification_and_tags("Foo", "2", ["dev"], "Bar1")
+            .create_consumer_version("3")
+            .create_consumer_version_tag("dev")
+        end
+
+        it "returns the names of the tags for which this pact publication is the latest" do
+          pact_0 = PactBroker::Pacts::PactPublication.find(id: PactBroker::Pacts::Repository.new.find_pact("Foo", "1", "Bar1").id)
+          expect(pact_0.consumer_version.tags.collect(&:name).sort).to eq ["dev", "prod"]
+          expect(Tag.head_tags_for_pact_publication(pact_0).collect(&:name).sort).to eq ["prod"]
+
+          pact_1 = PactBroker::Pacts::PactPublication.find(id: PactBroker::Pacts::Repository.new.find_pact("Foo", "2", "Bar1").id)
+          expect(Tag.head_tags_for_pact_publication(pact_1).collect(&:name).sort).to eq ["dev"]
+
+          pact_2 = PactBroker::Pacts::PactPublication.find(id: PactBroker::Pacts::Repository.new.find_pact("Foo", "1", "Bar2").id)
+          expect(Tag.head_tags_for_pact_publication(pact_2).collect(&:name).sort).to eq ["dev", "prod"]
+        end
+      end
+
+      describe "head_tag" do
+        before do
+          td.create_consumer("Foo")
+            .create_consumer_version("1", tag_names: ["main", "test"])
+            .create_consumer_version("2", tag_names: ["main", "test"])
+            .create_consumer_version("3", tag_names: ["main"])
+            .create_provider("Bar")
+            .create_provider_version("1", tag_names: ["main", "test"])
+            .create_provider_version("2", tag_names: ["main", "test"])
+            .create_provider_version("3", tag_names: ["main"])
+        end
+
+        it "lazy loads" do
+          expect(Tag.for("Foo", "2", "main").head_tag).to eq Tag.for("Foo", "3", "main")
+          expect(Tag.for("Foo", "3", "main").head_tag).to eq Tag.for("Foo", "3", "main")
+          expect(Tag.for("Bar", "1", "test").head_tag).to eq Tag.for("Bar", "2", "test")
+        end
+
+        it "eager loads" do
+          tags = Tag.order(:version_order, :name).eager(:head_tag).all
+          expect(tags[0].head_tag).to eq Tag.for("Foo", "3", "main")
+          expect(tags[1].head_tag).to eq Tag.for("Foo", "2", "test")
+        end
+      end
     end
   end
 end
-
-# Table: tags
-# Primary Key: (name, version_id)
-# Columns:
-#  name       | text                        |
-#  version_id | integer                     |
-#  created_at | timestamp without time zone | NOT NULL
-#  updated_at | timestamp without time zone | NOT NULL
-# Indexes:
-#  tags_pk      | PRIMARY KEY btree (version_id, name)
-#  ndx_tag_name | btree (name)
-# Foreign key constraints:
-#  tags_version_id_fkey | (version_id) REFERENCES versions(id)

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

@@ -142,6 +142,88 @@ module PactBroker
         end
       end
 
+      describe "latest_for_pacticipant?" do
+        before do
+          td.create_consumer("Foo")
+            .create_consumer_version("1")
+            .create_consumer_version("2")
+            .create_consumer("Bar")
+            .create_consumer_version("5")
+            .create_consumer_version("6")
+            .create_consumer_version("7")
+        end
+
+        context "when the version is the latest for the pacticipant" do
+          it "returns true" do
+            expect(Version.for("Foo", "2").latest_for_pacticipant?).to be true
+          end
+        end
+
+        context "when the version is not the latest version for the pacticipant" do
+          it "returns false" do
+            expect(Version.for("Foo", "1").latest_for_pacticipant?).to be false
+          end
+        end
+      end
+
+      describe "latest_version_for_pacticipant" do
+        before do
+          td.create_consumer("Foo")
+            .create_consumer_version("1")
+            .create_consumer_version("2")
+            .create_consumer("Bar")
+            .create_consumer_version("5")
+            .create_consumer_version("6")
+            .create_consumer_version("7")
+        end
+
+        subject { Version.order(:order) }
+
+        it "lazy loads" do
+          expect(subject.all[0].latest_version_for_pacticipant.number).to eq "2"
+        end
+
+        it "eager loads" do
+          all = subject.eager(:latest_version_for_pacticipant).all
+          expect(all[0].associations[:latest_version_for_pacticipant]).to_not be nil
+          expect(all[0].latest_version_for_pacticipant.number).to eq "2"
+        end
+      end
+
+      describe "latest_version_for_branch" do
+        before do
+          td.create_consumer("Foo")
+            .create_consumer_version("1", branch: "main")
+            .create_consumer_version("2", branch: "main")
+            .create_consumer_version("3", branch: "feat/x")
+            .create_consumer_version("4", branch: "feat/x")
+            .create_consumer_version("5")
+        end
+
+        subject { Version.order(:order) }
+
+        it "lazy loads" do
+          expect(subject.all[0].latest_version_for_branch.number).to eq "2"
+          expect(subject.all[2].latest_version_for_branch.number).to eq "4"
+          expect(subject.all[4].latest_version_for_branch).to eq nil
+        end
+
+        it "eager loads" do
+          all = subject.eager(:latest_version_for_branch).all
+
+          expect(all[0].associations[:latest_version_for_branch]).to_not be nil
+          expect(all[1].associations[:latest_version_for_branch]).to_not be nil
+          expect(all[2].associations[:latest_version_for_branch]).to_not be nil
+          expect(all[3].associations[:latest_version_for_branch]).to_not be nil
+          expect(all[4].associations.fetch(:latest_version_for_branch)).to be nil
+
+          expect(all[0].latest_version_for_branch.number).to eq "2"
+          expect(all[1].latest_version_for_branch.number).to eq "2"
+          expect(all[2].latest_version_for_branch.number).to eq "4"
+          expect(all[4].latest_version_for_branch).to eq nil
+        end
+      end
+
       describe "#latest_pact_publication" do
         let!(:pact) do
           TestDataBuilder.new
@@ -173,26 +255,32 @@ module PactBroker
         end
       end
 
-      describe "tags_with_latest_flag" do
+      describe "latest_for_branch?" do
         before do
-          td.create_consumer("foo")
-            .create_consumer_version("1")
-            .create_consumer_version_tag("dev")
-            .create_consumer_version_tag("prod")
-            .create_consumer_version("2")
-            .create_consumer_version_tag("dev")
+          td.create_consumer("Foo")
+            .create_consumer_version("1", branch: "main")
+            .create_consumer_version("2", branch: "main")
+            .create_consumer_version("3", branch: nil)
+        end
+
+        subject { version.latest_for_branch? }
+
+        context "when there is a later version with the same branch name" do
+          let(:version) { Version.for("Foo", "1") }
+
+          it { is_expected.to be false }
         end
 
-        it "uneager loads" do
-          version = Version.first(number: "1")
-          expect(version.tags.collect(&:name).sort).to eq %w{dev prod}
-          expect(version.tags_with_latest_flag.select(&:latest).collect(&:name)).to eq %w{prod}
+        context "when there is a later version with the same branch name" do
+          let(:version) { Version.for("Foo", "2") }
+
+          it { is_expected.to be true }
         end
 
-        it "eager loads" do
-          version = Version.eager(:tags, :tags_with_latest_flag).where(number: "1").all.first
-          expect(version.tags.collect(&:name).sort).to eq %w{dev prod}
-          expect(version.tags_with_latest_flag.select(&:latest).collect(&:name)).to eq %w{prod}
+        context "when there is no branch" do
+          let(:version) { Version.for("Foo", "3") }
+
+          it { is_expected.to be nil }
         end
       end
     end

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

@@ -11,7 +11,7 @@ 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(:http_response) { double('http response', code: "200") }
       let(:event_context) { { some: 'things' } }
       let(:logging_options) { { other: 'options' } }
       let(:options) { { logging_options: logging_options } }

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
+