pact_broker 2.83.0 → 2.84.0

data/spec/lib/pact_broker/api/contracts/{verifiable_pacts_json_query_schema_spec.rb → pacts_for_verification_json_query_schema_spec.rb}

@@ -1,9 +1,9 @@
-require "pact_broker/api/contracts/verifiable_pacts_json_query_schema"
+require "pact_broker/api/contracts/pacts_for_verification_json_query_schema"
 
 module PactBroker
   module Api
     module Contracts
-      describe VerifiablePactsJSONQuerySchema do
+      describe PactsForVerificationJSONQuerySchema do
         before do
           allow(PactBroker::Deployments::EnvironmentService).to receive(:find_by_name).and_return(environment)
         end
@@ -25,7 +25,7 @@ module PactBroker
           }]
         end
 
-        subject { VerifiablePactsJSONQuerySchema.(params) }
+        subject { PactsForVerificationJSONQuerySchema.(params) }
 
         context "when the params are valid" do
           it "has no errors" do

data/spec/lib/pact_broker/api/contracts/{verifiable_pacts_query_schema_spec.rb → pacts_for_verification_query_string_schema_spec.rb}

@@ -1,9 +1,9 @@
-require "pact_broker/api/contracts/verifiable_pacts_query_schema"
+require "pact_broker/api/contracts/pacts_for_verification_query_string_schema"
 
 module PactBroker
   module Api
     module Contracts
-      describe VerifiablePactsQuerySchema do
+      describe PactsForVerificationQueryStringSchema do
         let(:params) do
           {
             provider_version_tags: provider_version_tags,
@@ -20,7 +20,7 @@ module PactBroker
           }]
         end
 
-        subject { VerifiablePactsQuerySchema.(params) }
+        subject { PactsForVerificationQueryStringSchema.(params) }
 
         context "when the params are valid" do
           it "has no errors" do

data/spec/lib/pact_broker/api/decorators/dashboard_decorator_spec.rb

@@ -21,9 +21,9 @@ module PactBroker
             webhook_status: "blah",
             pseudo_branch_verification_status: "wiffle",
             provider_version_number: provider_version.number,
-            provider_version_branch: provider_version.branch,
+            provider_version_branches: ["main"],
             consumer_version_number: consumer_version.number,
-            consumer_version_branch: consumer_version.branch,
+            consumer_version_branches: ["main"],
             tag_names: ["prod"],
             latest_verification_latest_tags: [double("tag", name: "dev", latest?: true)]
           )
@@ -32,8 +32,8 @@ module PactBroker
         let(:provider) { instance_double("PactBroker::Domain::Pacticipant", name: "Bar") }
         let(:pact) { instance_double("PactBroker::Domain::Pact", created_at: created_at) }
         let(:verification) { instance_double("PactBroker::Domain::Verification", success: true, created_at: created_at) }
-        let(:consumer_version) { instance_double("PactBroker::Domain::Version", number: "1", pacticipant: consumer, branch: "main") }
-        let(:provider_version) { instance_double("PactBroker::Domain::Version", number: "2", pacticipant: provider, branch: "main") }
+        let(:consumer_version) { instance_double("PactBroker::Domain::Version", number: "1", pacticipant: consumer) }
+        let(:provider_version) { instance_double("PactBroker::Domain::Version", number: "2", pacticipant: provider) }
         let(:last_webhook_execution_date) { created_at }
         let(:base_url) { "http://example.org" }
         let(:options) { { user_options: { base_url: base_url } } }
@@ -67,7 +67,7 @@ module PactBroker
         subject { JSON.parse(dashboard_json) }
 
         it "creates some json" do
-          expect(subject).to match_pact(expected_hash, {allow_unexpected_keys: false})
+          expect(subject).to match_pact(expected_hash, { allow_unexpected_keys: false })
         end
 
         context "when the pact has never been verified" do
@@ -76,7 +76,7 @@ module PactBroker
           it "has a null last verification and provider version" do
             expected_hash["items"][0]["latestVerificationResult"] = nil
             expected_hash["items"][0]["provider"]["version"] = nil
-            expect(subject).to match_pact(expected_hash, {allow_unexpected_keys: false})
+            expect(subject).to match_pact(expected_hash, { allow_unexpected_keys: false })
           end
         end
 
@@ -85,7 +85,7 @@ module PactBroker
 
           it "has a null latestWebhookExecution" do
             expected_hash["items"][0]["latestWebhookExecution"] = nil
-            expect(subject).to match_pact(expected_hash, {allow_unexpected_keys: false})
+            expect(subject).to match_pact(expected_hash, { allow_unexpected_keys: false })
           end
         end
       end

data/spec/lib/pact_broker/api/decorators/matrix_decorator_spec.rb

@@ -10,6 +10,7 @@ module PactBroker
         describe "to_json" do
           before do
             allow_any_instance_of(ReasonDecorator).to receive(:to_s).and_return("foo")
+            allow_any_instance_of(PactBroker::Api::PactBrokerUrls).to receive(:branch_version_url).and_return("branch_version_url")
           end
           let(:verification_date) { DateTime.new(2017, 12, 31) }
           let(:pact_created_at) { DateTime.new(2017, 1, 1) }
@@ -20,13 +21,13 @@ module PactBroker
               {
                 consumer_name: "Consumer",
                 consumer_version_number: "1.0.0",
-                consumer_version_branch: "main",
+                consumer_version_branch_versions: consumer_version_branch_versions,
                 consumer_version_tags: consumer_version_tags,
                 provider_version_tags: provider_version_tags,
                 pact_version_sha: "1234",
                 pact_created_at: pact_created_at,
                 provider_version_number: "4.5.6",
-                provider_version_branch: "feat/x",
+                provider_version_branch_versions: provider_version_branch_versions,
                 provider_name: "Provider",
                 success: row_1_success,
                 verification_number: 1,
@@ -40,12 +41,12 @@ module PactBroker
               {
                 consumer_name: "Consumer",
                 consumer_version_number: "1.0.0",
-                consumer_version_branch: "main",
+                consumer_version_branch_versions: [],
                 consumer_version_tags: [],
                 pact_version_sha: "1234",
                 pact_created_at: pact_created_at,
                 provider_version_number: nil,
-                provider_version_branch: nil,
+                provider_version_branch_versions: [],
                 provider_name: "Provider",
                 success: row_2_success,
                 verification_number: nil,
@@ -65,6 +66,12 @@ module PactBroker
               version: {
                 number: "1.0.0",
                 branch: "main",
+                branches: [
+                  name: "main",
+                  _links: {
+
+                  }
+                ],
                 _links: {
                   self: {
                     href: "http://example.org/pacticipants/Consumer/versions/1.0.0"
@@ -141,6 +148,10 @@ module PactBroker
 
           let(:consumer_version) { double("consumer version", number: "1.0.0", pacticipant: double("consumer", name: "Consumer")) }
 
+          let(:consumer_version_branch_versions) do
+            [ instance_double("PactBroker::Versions::BranchVersion", branch_name: "main", latest?: true) ]
+          end
+
           let(:consumer_version_tags) do
             [
               double("tag", name: "prod", latest?: true, version: consumer_version, created_at: DateTime.now )
@@ -149,6 +160,10 @@ module PactBroker
 
           let(:provider_version) { double("provider version", number: "4.5.6", pacticipant: double("provider", name: "Provider")) }
 
+          let(:provider_version_branch_versions) do
+            [ instance_double("PactBroker::Versions::BranchVersion", branch_name: "feat/x", latest?: true) ]
+          end
+
           let(:provider_version_tags) do
             [
               double("tag", name: "master", latest?: false, version: provider_version, created_at: DateTime.now)

data/spec/lib/pact_broker/api/decorators/{verifiable_pacts_query_decorator_spec.rb → pacts_for_verification_query_decorator_spec.rb}

@@ -1,14 +1,14 @@
-require "pact_broker/api/decorators/verifiable_pacts_query_decorator"
+require "pact_broker/api/decorators/pacts_for_verification_query_decorator"
 
 module PactBroker
   module Api
     module Decorators
-      describe VerifiablePactsQueryDecorator do
+      describe PactsForVerificationQueryDecorator do
 
         let(:provider_version_tags) { %w[dev] }
         let(:provider_version_branch) { "main" }
 
-        subject { VerifiablePactsQueryDecorator.new(OpenStruct.new).from_hash(params)  }
+        subject { PactsForVerificationQueryDecorator.new(OpenStruct.new).from_hash(params)  }
 
         context "when parsing JSON params" do
           let(:params) do

data/spec/lib/pact_broker/api/decorators/version_decorator_spec.rb

@@ -8,7 +8,6 @@ module PactBroker
         describe "from_json" do
           let(:hash) do
             {
-              branch: "branch",
               buildUrl: "buildUrl",
               tags: [{ name: "main" }]
             }
@@ -17,7 +16,6 @@ module PactBroker
           subject { VersionDecorator.new(OpenStruct.new).from_json(hash.to_json) }
 
           it "sets the properties" do
-            expect(subject.branch).to eq "branch"
             expect(subject.build_url).to eq "buildUrl"
             expect(subject.tags.first.name).to eq "main"
           end
@@ -32,7 +30,7 @@ module PactBroker
             TestDataBuilder.new
               .create_consumer("Consumer")
               .create_provider("providerA")
-              .create_consumer_version("1.2.3")
+              .create_consumer_version("1.2.3", branch: "main")
               .create_consumer_version_tag("prod")
               .create_pact
               .create_provider("ProviderB")
@@ -85,6 +83,12 @@ module PactBroker
             expect(subject[:_embedded][:tags].first[:name]).to eq "prod"
           end
 
+          it "includes the branches" do
+            expect(subject[:_embedded][:branches]).to be_instance_of(Array)
+            expect(subject[:_embedded][:branches].first[:name]).to eq "main"
+            expect(subject[:_embedded][:branches].first[:latest]).to eq true
+          end
+
           it "includes the timestamps" do
             expect(subject[:createdAt]).to_not be nil
           end

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

@@ -39,7 +39,7 @@ module PactBroker
 
         it "sets the version branch" do
           subject
-          expect(PactBroker::Domain::Version.order(:id).last.branch).to eq "main"
+          expect(PactBroker::Domain::Version.order(:id).last.branch_names).to include "main"
         end
 
         it "returns a results object" do
@@ -60,6 +60,27 @@ module PactBroker
               expect(subject.notices.find{ |log| log.type == "success" && log.text.include?(" published ") }).to_not be nil
             end
           end
+
+          context "when no branch is specified but tags are" do
+            before do
+              allow(PactBroker.configuration).to receive(:use_first_tag_as_branch).and_return(true)
+            end
+
+            let(:contracts_to_publish) do
+              ContractsToPublish.from_hash(
+                pacticipant_name: "Foo",
+                pacticipant_version_number: "1",
+                tags: ["a", "b"],
+                branch: nil,
+                contracts: contracts
+              )
+            end
+
+            it "uses the first tag as the branch" do
+              subject
+              expect(PactBroker::Domain::Version.order(:id).last.branch_versions.collect(&:branch_name)).to eq ["a"]
+            end
+          end
         end
 
         context "when the pact already exists" do
@@ -74,8 +95,8 @@ module PactBroker
             expect { subject }.to change { PactBroker::Domain::Version.order(:id).last.tags.count}.from(1).to(3)
           end
 
-          it "updates the branch (TODO this should add to the branches when branches is updated to be a collection)" do
-            expect { subject }.to change { PactBroker::Domain::Version.order(:id).last.branch}.from("feat/x").to("main")
+          it "adds the branch to the existing version" do
+            expect { subject }.to change { PactBroker::Domain::Version.order(:id).last.branch_versions.collect(&:branch_name)}.from(["feat/x"]).to(["feat/x", "main"])
           end
 
           context "when the write mode is overwrite" do

data/spec/lib/pact_broker/db/data_migrations/create_branches_spec.rb

@@ -0,0 +1,57 @@
+require "pact_broker/db/data_migrations/create_branches"
+
+module PactBroker
+  module DB
+    module DataMigrations
+      describe CreateBranches do
+        let(:db) { PactBroker::Domain::Version.db }
+
+        subject { CreateBranches.call(db) }
+
+        context "when there are no branch objects" do
+          before do
+            td.create_pacticipant("Foo")
+              .create_version("1")
+              .create_version("2")
+              .create_version("3")
+              .create_pacticipant("Bar")
+              .create_version("10")
+              .create_version("11")
+              .create_version("12")
+
+            db[:versions].where(number: ["1", "2"]).update(branch: "main")
+            db[:versions].where(number: ["10", "11"]).update(branch: "main")
+          end
+
+          it "creates the missing branch versions" do
+            subject
+            expect(db[:branches].count).to eq 2
+            expect(db[:branch_heads].count).to eq 2
+            expect(db[:branch_versions].count).to eq 4
+            expect(db[:branch_heads].order(:branch_id).first[:version_id]).to eq db[:versions].where(number: "2").single_record[:id]
+            expect(db[:branch_heads].order(:branch_id).last[:version_id]).to eq db[:versions].where(number: "11").single_record[:id]
+          end
+        end
+
+        context "when there is a branch already" do
+          before do
+            td.create_pacticipant("Foo")
+              .create_version("1", branch: "main")
+              .create_version("2")
+              .create_version("3", branch: "main")
+              .create_version("4")
+            db[:versions].where(number: ["1", "2"]).update(branch: "main")
+          end
+
+          it "creates the missing branch versionsq" do
+            subject
+            expect(db[:branches].count).to eq 1
+            expect(db[:branch_heads].count).to eq 1
+            expect(db[:branch_versions].count).to eq 3
+            expect(db[:branch_heads].order(:branch_id).last[:version_id]).to eq db[:versions].where(number: "3").single_record[:id]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -13,7 +13,7 @@ module PactBroker
           allow(webhook_executions).to receive(:sort).and_return(webhook_executions)
         end
 
-        subject { IndexItem.create(nil, nil, nil, true, nil, [], webhook_executions) }
+        subject { IndexItem.create(nil, nil, nil, nil, true, nil, [], webhook_executions) }
 
         it "returns the created_at date of the last execution" do
           expect(subject.last_webhook_execution_date).to eq DateTime.new(2015)

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

@@ -402,40 +402,6 @@ module PactBroker
         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
@@ -492,7 +458,7 @@ module PactBroker
         context "when there is no branch" do
           let(:version) { Version.for("Foo", "3") }
 
-          it { is_expected.to be nil }
+          it { is_expected.to be false }
         end
       end
 

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

@@ -24,7 +24,8 @@ module PactBroker
           end
 
           its([:pacticipantVersions, :count]) { is_expected.to eq 2 }
-          its([:pacticipantVersions, :withBranchSetCount]) { is_expected.to eq 1 }
+          its([:pacticipantVersions, :withBranchCount]) { is_expected.to eq 1 }
+          its([:pacticipantVersions, :withUserCreatedBranchCount]) { is_expected.to eq 1 }
         end
 
         describe "environments, deployed versions, released versions" do
@@ -46,6 +47,7 @@ module PactBroker
           its([:environments, :count]) { is_expected.to eq 1 }
           its([:deployedVersions, :count]) { is_expected.to eq 2 }
           its([:deployedVersions, :currentlyDeployedCount]) { is_expected.to eq 1 }
+          its([:deployedVersions, :userCreatedCount]) { is_expected.to eq 2 }
           its([:releasedVersions, :count]) { is_expected.to eq 3 }
           its([:releasedVersions, :currentlySupportedCount]) { is_expected.to eq 2 }
         end
@@ -64,6 +66,7 @@ module PactBroker
               .create_provider
               .create_consumer_version
               .create_pact(json_content: { foo: "bar" }.to_json)
+            PactBroker::Pacts::PactVersion.dataset.update(interactions_count: nil, messages_count: nil)
           end
 
           it "includes a count of the number of interactions in the overall latest pacts" do

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

@@ -23,11 +23,14 @@ module PactBroker
             .create_consumer("FooZ")
             .create_consumer_version("6", branch: "main", comment: "latest, different consumer")
             .create_pact
+            .revise_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")
+            .create_provider("NotBar")
+            .create_pact
         end
 
         subject { PactPublication.latest_by_consumer_branch.all }
@@ -35,27 +38,30 @@ module PactBroker
         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 }
+        let(:not_bar) { td.find_pacticipant("NotBar") }
 
         it "returns the latest pact publications for each consumer/branch" do
-          expect(subject.size).to eq 3
+          expect(subject.size).to eq 4
 
-          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"
+          expect(subject.find { |pp| pp.consumer_id == foo.id && pp.provider_id == bar.id && pp[:branch_name] == "main" }.consumer_version.number).to eq "3"
+          expect(subject.find { |pp| pp.consumer_id == foo.id && pp.provider_id == bar.id && pp[:branch_name] == "feat/x" }.consumer_version.number).to eq "4"
+          expect(subject.find { |pp| pp.consumer_id == foo_z.id && pp.provider_id == bar.id && pp[:branch_name] == "main" }.consumer_version.number).to eq "6"
+          expect(subject.find { |pp| pp.consumer_id == foo_z.id && pp.provider_id == bar.id && pp[:branch_name] == "main" }.revision_number).to eq 2
+          expect(subject.find { |pp| pp.consumer_id == foo_z.id && pp.provider_id == not_bar.id && pp[:branch_name] == "main" }.consumer_version.number).to eq "8"
         end
 
         it "does not return extra columns" do
-          expect(subject.first.values.keys.sort).to eq (PactPublication.columns + [:branch]).sort
+          expect(subject.first.values.keys.sort).to eq (PactPublication.columns + [:branch_name]).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 }
+          its(:size) { is_expected.to eq 3 }
 
           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"
+            expect(subject.find { |pp| pp.consumer_id == foo.id && pp[:branch_name] == "feat/x" }.consumer_version.number).to eq "4"
+            expect(subject.find { |pp| pp.consumer_id == foo_z.id && pp.provider_id == not_bar.id && pp[:branch_name] == "main" }.consumer_version.number).to eq "8"
           end
         end
       end
@@ -68,6 +74,7 @@ module PactBroker
             .create_pact
             .create_consumer_version("2", branch: "main")
             .create_pact
+            .revise_pact
             .create_consumer_version("3", branch: "feat-x")
             .create_pact
             .create_consumer("Foo2")
@@ -86,6 +93,7 @@ module PactBroker
           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.first.revision_number).to eq 2
 
           expect(all.last.consumer.name).to eq "Foo2"
           expect(all.last.provider.name).to eq "Bar2"
@@ -93,7 +101,7 @@ module PactBroker
         end
 
         it "does not return extra columns" do
-          expect(subject.first.values.keys.sort).to eq (PactPublication.columns + [:branch]).sort
+          expect(subject.first.values.keys.sort).to eq (PactPublication.columns + [:branch_name]).sort
         end
 
         context "when columns are already selected" do
@@ -170,6 +178,7 @@ module PactBroker
             .create_pact
             .create_consumer_version("3", tag_names: ["feat/x"])
             .create_pact
+            .revise_pact
             .create_consumer("Foo2")
             .create_provider("Bar2")
             .create_consumer_version("10", tag_names: ["main"])
@@ -183,6 +192,7 @@ module PactBroker
         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
+          expect(all.first.revision_number).to eq 2
         end
 
         it "does not return extra columns" do
@@ -236,7 +246,7 @@ module PactBroker
 
         subject { PactPublication.latest_for_consumer_tag("main") }
 
-        it "returns the latest pacts for the tags with the specified name (for any consumer/provider)" do
+        it "returns the pacts for the latest versions with the specified 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"
@@ -252,6 +262,95 @@ module PactBroker
           expect(subject.all.first.values.keys.sort).to eq (PactPublication.columns + [:tag_name]).sort
         end
 
+        context "when the latest version with the tag does not have a pact" do
+          before do
+            td.use_consumer("Foo")
+              .create_consumer_version("12", tag_names: ["main"])
+              .use_consumer("Foo2")
+              .create_consumer_version("12", tag_names: ["main"])
+          end
+
+          it "returns the latest pact that belongs to a version with the specified tag" do
+            expect(subject.all.size).to eq 2
+          end
+        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 "for_latest_consumer_versions_with_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.for_latest_consumer_versions_with_tag("main") }
+
+        it "returns the pacts for the latest versions with the specified 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 the latest version with the tag does not have a pact" do
+          before do
+            td.use_consumer("Foo")
+              .create_consumer_version("12", tag_names: ["main"])
+              .use_consumer("Foo2")
+              .create_consumer_version("12", tag_names: ["main"])
+          end
+
+          it "returns an empty list" do
+            expect(subject.all).to eq []
+          end
+
+          context "with the feature_toggle disabled" do
+            before do
+              allow(PactBroker).to receive(:feature_enabled?).with(:fix_issue_494).and_return(false)
+            end
+
+            it "returns pacts" do
+              expect(subject.all.size).to eq 2
+            end
+          end
+        end
+
         context "when columns are already selected" do
           subject { PactPublication.select(Sequel[:pact_publications][:id]).latest_for_consumer_tag("main") }