pact_broker 2.81.0 → 2.82.0

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

@@ -21,7 +21,8 @@ module PactBroker
           subject { parsed_options }
 
           its([:latestby]) { is_expected.to eq "cvp" }
-          its([:latest]) { is_expected.to eq true }
+          its([:latest]) { is_expected.to eq nil }
+          its([:environment_name]) { is_expected.to eq "prod" }
           its([:ignore_selectors]) { is_expected.to eq [] }
 
           context "with pacticipants to ignore" do
@@ -36,6 +37,20 @@ module PactBroker
               ]
             end
           end
+
+          context "with a tag" do
+            let(:params) do
+              {
+                pacticipant: "foo",
+                version: "1",
+                to: "prod"
+              }
+            end
+
+            its([:latestby]) { is_expected.to eq "cvp" }
+            its([:latest]) { is_expected.to eq true }
+            its([:tag]) { is_expected.to eq "prod" }
+          end
         end
 
         describe "parsed_selectors" do

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

@@ -3,8 +3,6 @@ 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 |
           UnresolvedSelector.new(pacticipant_name: key, pacticipant_version_number: value)

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

@@ -4,8 +4,6 @@ require "pact_broker/matrix/unresolved_selector"
 module PactBroker
   module Matrix
     describe Repository do
-      let(:td) { TestDataBuilder.new}
-
       def build_selectors(hash)
         hash.collect do | key, value |
           UnresolvedSelector.new(pacticipant_name: key, pacticipant_version_number: value)

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

@@ -6,6 +6,50 @@ module PactBroker
       describe "#metrics" do
         subject { Service.metrics }
 
+        describe "pacticipants" do
+          before do
+            td.create_consumer("Foo")
+              .create_consumer("Bar", main_branch: "foo")
+          end
+
+          its([:pacticipants, :count]) { is_expected.to eq 2 }
+          its([:pacticipants, :withMainBranchSetCount]) { is_expected.to eq 1 }
+        end
+
+        describe "pacticipant versions" do
+          before do
+            td.create_consumer("Foo")
+              .create_consumer_version("2")
+              .create_consumer_version("3", branch: "main")
+          end
+
+          its([:pacticipantVersions, :count]) { is_expected.to eq 2 }
+          its([:pacticipantVersions, :withBranchSetCount]) { is_expected.to eq 1 }
+        end
+
+        describe "environments, deployed versions, released versions" do
+          before do
+            td.create_environment("test")
+              .create_consumer("Foo")
+              .create_consumer_version("2")
+              .create_deployed_version_for_consumer_version(currently_deployed: false)
+              .create_consumer_version("3")
+              .create_deployed_version_for_consumer_version
+              .create_consumer_version("4")
+              .create_released_version_for_consumer_version(currently_supported: false)
+              .create_consumer_version("5")
+              .create_released_version_for_consumer_version
+              .create_consumer_version("6")
+              .create_released_version_for_consumer_version
+          end
+
+          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([:releasedVersions, :count]) { is_expected.to eq 3 }
+          its([:releasedVersions, :currentlySupportedCount]) { is_expected.to eq 2 }
+        end
+
         describe "interactions latestCount" do
           before do
             td.create_consumer

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

@@ -10,10 +10,9 @@ module PactBroker
         allow(Service).to receive(:logger).and_return(logger)
       end
 
-      let(:td) { TestDataBuilder.new }
       let(:logger) { double("logger").as_null_object }
 
-      subject{ Service }
+      subject { Service }
 
       describe ".messages_for_potential_duplicate_pacticipants" do
 
@@ -100,10 +99,35 @@ module PactBroker
         end
       end
 
+      describe ".maybe_set_main_branch" do
+        before do
+          allow(PactBroker.configuration).to receive(:auto_detect_main_branch).and_return(true)
+          allow(PactBroker.configuration).to receive(:main_branch_candidates).and_return(["foo", "bar"])
+          td.create_pacticipant("Foo", main_branch: main_branch)
+        end
+
+        let(:main_branch) { nil }
+
+        subject { Service.maybe_set_main_branch(td.find_pacticipant("Foo"), "bar") }
+
+        context "when the main branch is nil and auto_detect_main_branch=true and the potential branch is in the list of candidate main branch names" do
+          it "sets the main branch" do
+            expect(subject.main_branch).to eq "bar"
+          end
+        end
+
+        context "when the branch is already set" do
+          let(:main_branch) { "main" }
+
+          it "does not overwrite it" do
+            expect(subject.main_branch).to eq "main"
+          end
+        end
+      end
+
       describe "delete" do
         before do
-          TestDataBuilder.new
-            .create_consumer("Consumer")
+          td.create_consumer("Consumer")
             .create_label("finance")
             .create_consumer_version("2.3.4")
             .create_provider("Provider")
@@ -186,7 +210,6 @@ module PactBroker
           it "deletes the verifications" do
             expect{ delete_provider }.to change{ PactBroker::Domain::Verification.count }.by(-1)
           end
-
         end
       end
     end

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

@@ -7,6 +7,31 @@ module PactBroker
 
         subject { PactPublication.for_provider_and_consumer_version_selector(provider, consumer_version_selector).all }
 
+        context "all_for_tag" do
+          before do
+            td.create_provider("Bar")
+              .create_consumer("Foo")
+              .create_consumer_version("1", tag_name: "prod")
+              .create_pact
+              .create_consumer_version("2", tag_name: "not-prod")
+              .create_pact
+              .create_consumer_version("3", tag_name: "prod")
+              .create_pact
+              .create_provider("NotBar")
+              .create_pact
+          end
+
+          let(:provider) { td.find_pacticipant("Bar") }
+          let(:consumer_version_selector) { Selector.all_for_tag("prod") }
+
+          it "returns all the pacts for the specified consumer version tag" do
+            expect(subject.size).to eq 2
+            expect(subject.first.values[:tag_name]).to eq "prod"
+            expect(subject.last.values[:tag_name]).to eq "prod"
+          end
+
+        end
+
         context "for main branch" do
           let(:consumer_version_selector) { Selector.for_main_branch }
           let(:provider) { td.find_pacticipant("Bar") }

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

@@ -3,7 +3,6 @@ require "pact_broker/pacts/pact_version"
 module PactBroker
   module Pacts
     describe PactVersion do
-
       describe "pacticipant names" do
         subject(:pact_version) do
           td.create_consumer("consumer")
@@ -36,6 +35,36 @@ module PactBroker
         end
       end
 
+      describe "#latest_verification" do
+        before do
+          td.create_pact_with_verification("Foo", "1", "Bar", "2")
+            .create_verification(provider_version: "3", number: 2)
+            .create_pact_with_verification("NotFoo", "1", "Bar", "4")
+            .create_verification(provider_version: "5", number: 3)
+            .create_pact_with_verification("NotFoo2", "1", "NotBar", "4")
+            .create_verification(provider_version: "6", number: 5)
+            .create_pact_with_verification("NotFoo3", "2", "NotBar", "5")
+            .create_verification(provider_version: "7", number: 6)
+        end
+
+        context "lazy loading" do
+          it "lazy loads" do
+            expect(PactPublication.order(:id).all.first.pact_version.latest_verification.provider_version_number).to eq "3"
+            expect(PactPublication.order(:id).all.last.pact_version.latest_verification.provider_version_number).to eq "7"
+          end
+        end
+
+        context "eager loading" do
+          let(:pact_version_1) { PactVersion.eager(:latest_verification).order(:id).all.first }
+          let(:pact_version_2) { PactVersion.eager(:latest_verification).order(:id).all.last }
+
+          it "eager loads" do
+            expect(pact_version_1.associations[:latest_verification].provider_version_number).to eq "3"
+            expect(pact_version_2.associations[:latest_verification].provider_version_number).to eq "7"
+          end
+        end
+      end
+
       describe "latest_consumer_version" do
         before do
           td.create_consumer("consumer")

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

@@ -15,26 +15,112 @@ module PactBroker
         subject { Repository.new.find_for_verification("Bar", consumer_version_selectors) }
 
         context "when there are no selectors" do
-          before do
-            td.create_pact_with_hierarchy("Foo", "foo-latest-prod-version", "Bar")
-              .create_consumer_version_tag("prod")
-              .create_consumer_version("not-latest-dev-version", tag_names: ["dev"])
-              .comment("next pact not selected")
-              .create_pact
-              .create_consumer_version("foo-latest-dev-version", tag_names: ["dev"])
-              .create_pact
-              .create_consumer("Baz")
-              .create_consumer_version("baz-latest-dev-version", tag_names: ["dev"])
-              .create_pact
-          end
+
+          let(:foo_main_branch) { nil }
 
           let(:consumer_version_selectors) { Selectors.new }
 
-          it "returns the latest pact for each consumer" do
-            expect(subject.size).to eq 2
-            expect(find_by_consumer_name_and_consumer_version_number("Foo", "foo-latest-dev-version")).to_not be nil
-            expect(find_by_consumer_name_and_consumer_version_number("Baz", "baz-latest-dev-version")).to_not be nil
-            expect(subject.all?(&:overall_latest?)).to be true
+          context "when there is no main branch version" do
+            before do
+              td.create_consumer("Foo")
+                .create_pact_with_hierarchy("Foo", "foo-latest-prod-version", "Bar")
+                .create_consumer_version_tag("prod")
+                .create_consumer_version("not-latest-dev-version", tag_names: ["dev"])
+                .comment("next pact not selected")
+                .create_pact
+                .create_consumer_version("foo-latest-dev-version", tag_names: ["dev"])
+                .create_pact
+                .create_consumer("Baz")
+                .create_consumer_version("baz-latest-dev-version", tag_names: ["dev"])
+                .create_pact
+            end
+
+            it "returns the latest pact for each consumer" do
+              expect(subject.size).to eq 2
+              expect(find_by_consumer_name_and_consumer_version_number("Foo", "foo-latest-dev-version")).to_not be nil
+              expect(find_by_consumer_name_and_consumer_version_number("Baz", "baz-latest-dev-version")).to_not be nil
+              expect(subject.all?(&:overall_latest?)).to be true
+            end
+          end
+
+          context "when there is a version from the main branch" do
+            before do
+              td.create_consumer("Foo", main_branch: "main")
+                .create_consumer_version("1", branch: "main")
+                .create_provider("Bar")
+                .create_pact
+                .create_pact_with_hierarchy("Foo", "2", "Bar")
+            end
+
+            it "returns the latest version from the main branch" do
+              expect(subject.size).to eq 1
+              expect(find_by_consumer_name_and_consumer_version_number("Foo", "1")).to_not be_nil
+              expect(subject.first.selectors.first).to be_latest_for_main_branch
+            end
+          end
+
+          context "when there is a version with a tag with the name of the main branch" do
+            before do
+              td.create_consumer("Foo", main_branch: "main")
+                .create_consumer_version("1", tag_name: "main")
+                .create_provider("Bar")
+                .create_pact
+                .create_pact_with_hierarchy("Foo", "2", "Bar")
+            end
+
+            it "returns the latest version from the main branch" do
+              expect(subject.size).to eq 1
+              expect(find_by_consumer_name_and_consumer_version_number("Foo", "1")).to_not be_nil
+              expect(subject.first.selectors.first).to be_latest_for_tag
+              expect(subject.first.selectors.first.tag).to eq "main"
+            end
+          end
+
+          context "when there is a not version from the main branch" do
+            before do
+              td.create_pact_with_hierarchy("Foo", "1", "Bar")
+                .create_pact_with_hierarchy("Foo", "2", "Bar")
+            end
+
+            it "returns the latest version from the main branch" do
+              expect(subject.size).to eq 1
+              expect(find_by_consumer_name_and_consumer_version_number("Foo", "2")).to_not be_nil
+              expect(subject.first.selectors.first).to be_overall_latest
+            end
+          end
+
+          context "when there are currently deployed versons" do
+            before do
+              td.create_environment("test")
+                .create_pact_with_hierarchy("Foo", "1", "Bar")
+                .create_deployed_version_for_consumer_version(currently_deployed: false)
+                .create_pact_with_hierarchy("Foo", "2", "Bar")
+                .create_deployed_version_for_consumer_version
+                .create_pact_with_hierarchy("Foo", "3", "Bar")
+            end
+
+            it "returns the currently deployed pacts" do
+              expect(find_by_consumer_name_and_consumer_version_number("Foo", "1")).to be_nil
+              expect(find_by_consumer_name_and_consumer_version_number("Foo", "2")).to_not be_nil
+              expect(find_by_consumer_name_and_consumer_version_number("Foo", "2").selectors.first).to be_currently_deployed
+            end
+          end
+
+          context "when there are currently released+supported versions" do
+            before do
+              td.create_environment("test")
+                .create_pact_with_hierarchy("Foo", "1", "Bar")
+                .create_released_version_for_consumer_version(currently_supported: false)
+                .create_pact_with_hierarchy("Foo", "2", "Bar")
+                .create_released_version_for_consumer_version
+                .create_pact_with_hierarchy("Foo", "3", "Bar")
+            end
+
+            it "returns the currently deployed pacts" do
+              expect(find_by_consumer_name_and_consumer_version_number("Foo", "1")).to be_nil
+              expect(find_by_consumer_name_and_consumer_version_number("Foo", "2")).to_not be_nil
+              expect(find_by_consumer_name_and_consumer_version_number("Foo", "2").selectors.first).to be_currently_supported
+            end
           end
         end
 
@@ -159,9 +245,10 @@ module PactBroker
               expect(find_by_consumer_version_number("foo-latest-prod-version").selectors).to eq [Selector.all_for_tag_and_consumer("prod", "Foo").resolve(PactBroker::Domain::Version.for("Foo", "foo-latest-prod-version"))]
             end
 
-            it "uses the latest consumer verison number as the resolved version when the same pact content is selected multiple times" do
+            it "includes all the selectors when the same pact content is selected multiple times (used to just use the latest, not sure about this)" do
               expect(find_by_consumer_version_number("3")).to be nil
-              expect(find_by_consumer_version_number("4").selectors).to eq [Selector.all_for_tag_and_consumer("prod", "Foo").resolve(PactBroker::Domain::Version.for("Foo", "4"))]
+              expect(find_by_consumer_version_number("4").selectors.first).to eq Selector.all_for_tag_and_consumer("prod", "Foo").resolve(PactBroker::Domain::Version.for("Foo", "3"))
+              expect(find_by_consumer_version_number("4").selectors.last).to eq Selector.all_for_tag_and_consumer("prod", "Foo").resolve(PactBroker::Domain::Version.for("Foo", "4"))
             end
           end
         end
@@ -266,7 +353,7 @@ module PactBroker
           end
 
           it "does not set the tag name" do
-            expect(find_by_consumer_version_number("foo-latest-dev-version").selectors).to eq [ResolvedSelector.new({ latest: true }, PactBroker::Domain::Version.find(number: "foo-latest-dev-version"))]
+            expect(find_by_consumer_version_number("foo-latest-dev-version").selectors).to eq [ResolvedSelector.new({ latest: true, consumer: "Foo" }, PactBroker::Domain::Version.find(number: "foo-latest-dev-version"))]
             expect(find_by_consumer_version_number("foo-latest-dev-version").overall_latest?).to be true
           end
         end

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

@@ -26,7 +26,7 @@ module PactBroker
             provider_branch: provider_branch
         )
       end
-      let(:consumer_version) { double("version", number: "1234" )}
+      let(:consumer_version) { double("version", number: "1234", order: 1) }
       let(:environment) { instance_double("PactBroker::Deployments::Environment", name: "test") }
       let(:test_environment) { environment }
       let(:prod_environment) { instance_double("PactBroker::Deployments::Environment", name: "prod") }

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

@@ -4,33 +4,49 @@ require "pact_broker/tags/service"
 module PactBroker
   module Tags
     describe Service do
-
+      before do
+        allow(Service).to receive(:version_service).and_return(version_service)
+        allow(Service).to receive(:pacticipant_service).and_return(pacticipant_service)
+        allow(version_service).to receive(:maybe_set_version_branch_from_tag)
+        allow(pacticipant_service).to receive(:maybe_set_main_branch)
+      end
+      let(:pacticipant_service) { class_double("PactBroker::Pacticipants::Service").as_stubbed_const }
+      let(:version_service) { class_double("PactBroker::Versions::Service").as_stubbed_const }
+      let(:tag_reposistory) { instance_double("PactBroker::Tags::Repository", create: double("tag")) }
       let(:pacticipant_name) { "test_pacticipant" }
       let(:version_number) { "1.2.3" }
       let(:tag_name) { "prod" }
-
-      let(:options) { {pacticipant_name: pacticipant_name, pacticipant_version_number: version_number, tag_name: tag_name}}
-      let(:test_data_builder) { TestDataBuilder.new }
+      let(:options) { { pacticipant_name: pacticipant_name, pacticipant_version_number: version_number, tag_name: tag_name }}
+      let(:use_first_tag_as_branch) { false }
 
       describe ".create" do
-
         subject { Service.create(options) }
 
-        # Naughty integration test... didn't seem much point unit testing this
-
         it "creates the new tag" do
           expect(subject.name).to eq tag_name
           expect(subject.version.number).to eq version_number
           expect(subject.version.pacticipant.name).to eq pacticipant_name
         end
 
+        it "calls the version_service.maybe_set_version_branch_from_tag before creating the tag" do
+          # so that we use the version before the tag is created (we have to detect if there are no tags present)
+          allow(Service).to receive(:tag_repository).and_return(tag_reposistory)
+          expect(version_service).to receive(:maybe_set_version_branch_from_tag).with(instance_of(PactBroker::Domain::Version), tag_name).ordered
+          expect(tag_reposistory).to receive(:create).ordered
+          subject
+        end
+
+        it "calls the pacticipant_service.maybe_set_main_branch" do
+          expect(pacticipant_service).to receive(:maybe_set_main_branch).with(instance_of(PactBroker::Domain::Pacticipant), tag_name)
+          subject
+        end
       end
 
       describe "delete" do
 
         let(:second_pacticipant_name) { "second_test_pacticipant" }
         let(:second_version_number) { "4.5.6" }
-        let(:second_options_same_tag_name) { {pacticipant_name: second_pacticipant_name, pacticipant_version_number: second_version_number, tag_name: tag_name}}
+        let(:second_options_same_tag_name) { { pacticipant_name: second_pacticipant_name, pacticipant_version_number: second_version_number, tag_name: tag_name }}
 
         before do
           Service.create(options)