pact_broker 2.83.0 → 2.84.0

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

@@ -43,6 +43,7 @@ module PactBroker
               .create_pact
               .create_consumer_version("2", branch: "main")
               .create_pact
+              .revise_pact
               .create_consumer_version("3", branch: "not-main")
               .create_pact
               .create_consumer("Bob", main_branch: "develop")
@@ -62,12 +63,12 @@ module PactBroker
           it "returns the latest pact for the main branch of every consumer" do
             expect(subject.size).to eq 2
             expect(subject.sort_by(&:id).first.consumer.name).to eq "Foo"
-            expect(subject.sort_by(&:id).first.consumer_version.branch).to eq "main"
             expect(subject.sort_by(&:id).first.consumer_version.number).to eq "2"
+            expect(subject.sort_by(&:id).first.values[:branch_name]).to eq "main"
 
             expect(subject.sort_by(&:id).last.consumer.name).to eq "Bob"
-            expect(subject.sort_by(&:id).last.consumer_version.branch).to eq "develop"
             expect(subject.sort_by(&:id).last.consumer_version.number).to eq "5"
+            expect(subject.sort_by(&:id).last.values[:branch_name]).to eq "develop"
           end
         end
 

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

@@ -256,9 +256,9 @@ module PactBroker
           expect(subject.size).to eq 3
           subject.collect(&:values)
 
-          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[:branch_name] == "main" }.consumer_version.number).to eq "3"
+          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[:branch_name] == "main" }.consumer_version.number).to eq "6"
         end
 
         context "chained with created after" do
@@ -267,8 +267,8 @@ module PactBroker
           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"
+            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[:branch_name] == "main" }.consumer_version.number).to eq "6"
           end
         end
       end

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

@@ -114,8 +114,8 @@ module PactBroker
           it "returns one pact_publication with multiple selectors" do
             expect(subject.size).to eq 1
             expect(subject.first.selectors.size).to eq 2
-            expect(subject.first.selectors.first.environment.name).to eq "test"
-            expect(subject.first.selectors.last.environment.name).to eq "prod"
+            expect(subject.first.selectors.first.environment.name).to eq "prod"
+            expect(subject.first.selectors.last.environment.name).to eq "test"
           end
         end
       end

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

@@ -149,8 +149,8 @@ module PactBroker
           it "returns one pact_publication with multiple selectors" do
             expect(subject.size).to eq 1
             expect(subject.first.selectors.size).to eq 2
-            expect(subject.first.selectors.first.environment.name).to eq "test"
-            expect(subject.first.selectors.last.environment.name).to eq "prod"
+            expect(subject.first.selectors.first.environment.name).to eq "prod"
+            expect(subject.first.selectors.last.environment.name).to eq "test"
           end
         end
       end

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

@@ -12,23 +12,65 @@ module PactBroker
         let(:all_prod_for_consumer_1) { Selector.all_for_tag_and_consumer("prod", "Foo") }
         let(:all_prod_for_consumer_2) { Selector.all_for_tag_and_consumer("prod", "Bar") }
         let(:all_dev_for_consumer_1) { Selector.all_for_tag_and_consumer("dev", "Bar") }
-        let(:all_prod) { Selector.all_for_tag("prod") }
+        let(:all_tagged_prod) { Selector.all_for_tag("prod") }
         let(:all_dev) { Selector.all_for_tag("dev") }
         let(:currently_deployed_to_prod) { Selector.for_currently_deployed("prod") }
         let(:currently_deployed_to_test) { Selector.for_currently_deployed("test") }
         let(:currently_supported_in_prod) { Selector.for_currently_supported("prod") }
 
         let(:unsorted_selectors) do
-          [currently_supported_in_prod, all_prod, all_dev, currently_deployed_to_prod, all_dev_for_consumer_1, latest_for_branch_main, latest_for_tag_prod, currently_deployed_to_test, overall_latest_1, overall_latest_1, latest_for_tag_dev, all_prod_for_consumer_2, all_prod_for_consumer_1]
+          [currently_supported_in_prod, all_tagged_prod, all_dev, currently_deployed_to_prod, all_dev_for_consumer_1, latest_for_branch_main, latest_for_tag_prod, currently_deployed_to_test, overall_latest_1, overall_latest_1, latest_for_tag_dev, all_prod_for_consumer_2, all_prod_for_consumer_1]
         end
 
         let(:expected_sorted_selectors) do
-          [overall_latest_1, overall_latest_1, latest_for_branch_main, currently_deployed_to_prod, currently_deployed_to_test, currently_supported_in_prod, latest_for_tag_dev, latest_for_tag_prod, all_dev_for_consumer_1, all_prod_for_consumer_2, all_prod_for_consumer_1, all_dev, all_prod]
+          [
+            overall_latest_1,
+            overall_latest_1,
+            latest_for_branch_main,
+            latest_for_tag_dev,
+            latest_for_tag_prod,
+            all_dev_for_consumer_1,
+            all_dev,
+            all_prod_for_consumer_2,
+            all_prod_for_consumer_1,
+            all_tagged_prod,
+            currently_deployed_to_prod,
+            currently_deployed_to_test,
+            currently_supported_in_prod,
+          ]
         end
 
         it "sorts the selectors" do
           expect(unsorted_selectors.sort).to eq(expected_sorted_selectors)
         end
+
+        context "with resolved selectors" do
+          let(:currently_deployed_to_prod) { Selector.for_currently_deployed("prod").resolve_for_environment(double("version", order: 1), double("environment", name: "prod", production?: true)) }
+          let(:currently_deployed_to_test) { Selector.for_currently_deployed("test").resolve_for_environment(double("version", order: 1), double("environment", name: "test", production?: false)) }
+          let(:currently_supported_in_prod) { Selector.for_currently_supported("prod").resolve_for_environment(double("version", order: 1), double("environment", name: "prod", production?: true)) }
+
+          let(:expected_sorted_selectors) do
+            [
+              overall_latest_1,
+              overall_latest_1,
+              latest_for_branch_main,
+              latest_for_tag_dev,
+              latest_for_tag_prod,
+              all_dev_for_consumer_1,
+              all_dev,
+              all_prod_for_consumer_2,
+              all_prod_for_consumer_1,
+              all_tagged_prod,
+              currently_deployed_to_test,
+              currently_deployed_to_prod,
+              currently_supported_in_prod,
+            ]
+          end
+
+          it "sorts the selectors" do
+            expect(unsorted_selectors.sort).to eq(expected_sorted_selectors)
+          end
+        end
       end
     end
   end

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

@@ -27,9 +27,9 @@ module PactBroker
         )
       end
       let(:consumer_version) { double("version", number: "1234", order: 1) }
-      let(:environment) { instance_double("PactBroker::Deployments::Environment", name: "test") }
+      let(:environment) { instance_double("PactBroker::Deployments::Environment", name: "test", production?: false) }
       let(:test_environment) { environment }
-      let(:prod_environment) { instance_double("PactBroker::Deployments::Environment", name: "prod") }
+      let(:prod_environment) { instance_double("PactBroker::Deployments::Environment", name: "prod", production?: true) }
 
       subject { VerifiablePactMessages.new(verifiable_pact, pact_version_url) }
 
@@ -171,13 +171,13 @@ module PactBroker
         context "when the consumer version is currently deployed to a multiple environments" do
           let(:selectors) do
             Selectors.new(
-              Selector.for_currently_deployed("dev").resolve_for_environment(consumer_version, double("environment", name: "dev")),
+              Selector.for_currently_deployed("dev").resolve_for_environment(consumer_version, double("environment", name: "dev", production?: false)),
               Selector.for_currently_deployed("test").resolve_for_environment(consumer_version, test_environment),
               Selector.for_currently_deployed("prod").resolve_for_environment(consumer_version, prod_environment)
             )
           end
 
-          its(:inclusion_reason) { is_expected.to include "consumer version(s) currently deployed to dev (1234), prod (1234) and test (1234)"}
+          its(:inclusion_reason) { is_expected.to include "consumer version(s) currently deployed to dev (1234), test (1234) and prod (1234)"}
         end
 
         context "when the currently deployed consumer version is for a consumer" do
@@ -190,7 +190,7 @@ module PactBroker
             )
           end
 
-          its(:inclusion_reason) { is_expected.to include "version(s) of Foo currently deployed to prod (1234) and test (1234)"}
+          its(:inclusion_reason) { is_expected.to include "version(s) of Foo currently deployed to test (1234) and prod (1234)"}
           its(:inclusion_reason) { is_expected.to include "version(s) of Bar currently deployed to test (1234)"}
           its(:inclusion_reason) { is_expected.to include "consumer version(s) currently deployed to test (1234)"}
         end

data/spec/lib/pact_broker/relationships/groupify_spec.rb

@@ -3,11 +3,8 @@ require "pact_broker/relationships/groupify"
 require "pact_broker/domain/index_item"
 
 module PactBroker
-
   module Relationships
-
     describe Groupify do
-
       describe ".call" do
 
         let(:consumer_a) { double("consumer a", id: 1, name: "consumer a") }
@@ -40,9 +37,7 @@ module PactBroker
           expect(groups[1]).to eq(Domain::Group.new(relationship_3))
           expect(groups[2]).to eq(Domain::Group.new(relationship_5, relationship_6))
         end
-
       end
     end
-
   end
 end

data/spec/lib/pact_broker/ui/view_models/index_item_spec.rb

@@ -7,11 +7,13 @@ module PactBroker
     module ViewDomain
       describe IndexItem do
 
-        let(:consumer) { instance_double("PactBroker::Domain::Pacticipant", name: "Consumer Name")}
-        let(:provider) { instance_double("PactBroker::Domain::Pacticipant", name: "Provider Name")}
+        let(:consumer) { instance_double("PactBroker::Domain::Pacticipant", name: "Consumer Name") }
+        let(:provider) { instance_double("PactBroker::Domain::Pacticipant", name: "Provider Name") }
+        let(:consumer_version) { instance_double("PactBroker::Domain::Version") }
+
         let(:latest_pact) { instance_double("PactBroker::Domain::Pact", consumer_version_number: "1.2.3") }
         let(:latest_verification) { instance_double("PactBroker::Domain::Verification") }
-        let(:domain_relationship) { PactBroker::Domain::IndexItem.new(consumer, provider, latest_pact, latest, latest_verification, [], [], tags, latest_verification_latest_tags)}
+        let(:domain_relationship) { PactBroker::Domain::IndexItem.new(consumer, provider, consumer_version, latest_pact, latest, latest_verification, [], [], tags, latest_verification_latest_tags)}
         let(:tags) { [] }
         let(:verification_tag_1) { instance_double("PactBroker::Tags::TagWithLatestFlag", name: "dev") }
         let(:verification_tag_2) { instance_double("PactBroker::Tags::TagWithLatestFlag", name: "prod") }
@@ -135,6 +137,16 @@ module PactBroker
           its(:provider_version_latest_tag_names) { is_expected.to eq ["dev", "prod"] }
         end
 
+        describe "tagged_pacts" do
+          let(:tags) { ["master", "prod"] }
+          its(:tagged_pacts) do
+            is_expected.to eq([
+              { tag: "master", deletionUrl: "/pacts/provider/Provider%20Name/consumer/Consumer%20Name/tag/master" }.to_json,
+              { tag: "prod", deletionUrl: "/pacts/provider/Provider%20Name/consumer/Consumer%20Name/tag/prod" }.to_json
+            ])
+          end
+        end
+
         describe "<=>" do
 
           let(:relationship_model_4) { double("PactBroker::Domain::IndexItem", consumer_name: "A", provider_name: "X") }

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

@@ -36,7 +36,7 @@ module PactBroker
           end
 
           it "sets the tag names" do
-            expect(subject.reload.tag_names).to eq ["foo", "bar"]
+            expect(subject.reload.tag_names.sort).to eq ["bar", "foo"]
           end
 
           it "saves the consumer_version_selector_hashes" do

data/spec/lib/pact_broker/versions/branch_service_spec.rb

@@ -0,0 +1,71 @@
+require "pact_broker/versions/branch_service"
+
+module PactBroker
+  module Versions
+    describe BranchService do
+      describe ".find_branch_version" do
+        before do
+          td.create_consumer("Foo")
+            .create_consumer_version("1", branch: "main")
+            .create_consumer_version("1", branch: "feat/x")
+            .create_consumer_version("2", branch: "main")
+        end
+
+        subject { BranchService.find_branch_version(pacticipant_name: "Foo", version_number: "1", branch_name: "main") }
+
+        its(:version_number) { is_expected.to eq "1" }
+      end
+
+      describe "#create_branch_version" do
+        subject { BranchService.find_or_create_branch_version(pacticipant_name: "Foo", version_number: "1", branch_name: "main") }
+
+        context "when nothing exists" do
+          it "creates and returns the branch version" do
+            expect(subject.pacticipant.name).to eq "Foo"
+            expect(subject.version_number).to eq "1"
+            expect(subject.branch_name).to eq "main"
+          end
+        end
+
+        context "when everything exists except the branch version" do
+          before do
+            td.create_consumer("Foo")
+              .create_consumer_version("0", branch: "main")
+          end
+
+          it "does not create the branch" do
+            expect{ subject }.to_not change { PactBroker::Versions::Branch.where(name: "main").count }
+          end
+
+          it "creates and returns the branch version" do
+            expect(subject.pacticipant.name).to eq "Foo"
+            expect(subject.version_number).to eq "1"
+            expect(subject.branch_name).to eq "main"
+            expect(subject.branch_head).to_not be nil
+          end
+        end
+
+        context "when everything exists" do
+          before do
+            td.create_consumer("Foo")
+              .create_consumer_version("1", branch: "main")
+
+            BranchVersion.dataset.update(updated_at: Sequel.datetime_class.now - 10, created_at: Sequel.datetime_class.now - 10)
+          end
+
+          it "does not create a new branch version" do
+            expect{ subject }.to_not change { PactBroker::Versions::BranchVersion.count }
+          end
+
+          it "updates the updated_at" do
+            expect{ subject }.to change { PactBroker::Versions::BranchVersion.first.updated_at }
+          end
+
+          it "does not change the created_at" do
+            expect{ subject }.to_not change { PactBroker::Versions::BranchVersion.first.created_at }
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/pact_broker/versions/branch_version_repository_spec.rb

@@ -0,0 +1,81 @@
+require "pact_broker/versions/branch_version_repository"
+
+module PactBroker
+  module Versions
+    describe BranchVersionRepository do
+      describe "add_branch" do
+        before do
+          allow(repository).to receive(:pacticipant_service).and_return(pacticipant_service)
+          allow(pacticipant_service).to receive(:maybe_set_main_branch)
+        end
+        let!(:version) { td.create_consumer("Foo").create_consumer_version("1", branch: "original-branch").and_return(:consumer_version) }
+        let(:new_branch_name) { "new-branch" }
+        let(:pacticipant_service) { class_double("PactBroker::Pacticipants::Service").as_stubbed_const }
+        let(:repository) { BranchVersionRepository.new }
+
+        subject { repository.add_branch(version, new_branch_name).version.refresh }
+
+        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), new_branch_name)
+          subject
+        end
+
+        context "when the branch does not already exist" do
+          it "default auto_created to false" do
+            subject
+            expect(PactBroker::Versions::BranchVersion.last.auto_created).to be false
+          end
+
+          it "creates a branch" do
+            expect { subject }.to change { PactBroker::Versions::Branch.count }.by(1)
+          end
+
+          it "creates a branch_version" do
+            expect { subject }.to change { PactBroker::Versions::BranchVersion.count }.by(1)
+          end
+
+          it "adds the branch_version to the version" do
+            expect(subject.branch_versions.count).to eq 2
+            expect(subject.branch_versions.last.branch_name).to eq "new-branch"
+          end
+
+          it "updates the branch head" do
+            branch_head = subject.pacticipant.branch_head_for("new-branch")
+            expect(branch_head.version.id).to eq subject.refresh.id
+          end
+
+          context "when auto_created is true" do
+            subject { repository.add_branch(version, new_branch_name, auto_created: true) }
+
+            it "default auto_created to false" do
+              subject
+              expect(PactBroker::Versions::BranchVersion.last.auto_created).to be true
+            end
+          end
+        end
+
+        context "when the branch and branch version do already exist" do
+          let(:new_branch_name) { "original-branch" }
+
+          it "does not creates a branch" do
+            expect { subject }.to_not change { PactBroker::Versions::Branch.order(:name).collect(&:name) }
+          end
+
+          it "does not create a branch_version" do
+            expect { subject }.to change { PactBroker::Versions::BranchVersion.count }.by(0)
+          end
+
+          it "keeps the branch_version on the version" do
+            expect(subject.branch_versions.count).to eq 1
+            expect(subject.branch_versions.first.branch_name).to eq "original-branch"
+          end
+
+          it "does not change the branch head" do
+            branch_head = subject.pacticipant.branch_head_for("original-branch")
+            expect(branch_head.version).to eq subject
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/pact_broker/versions/branch_version_spec.rb

@@ -0,0 +1,27 @@
+require "pact_broker/versions/branch_version"
+
+module PactBroker
+  module Versions
+    describe BranchVersion do
+      describe "#latest?" do
+        before do
+          td.create_consumer("Foo")
+            .create_consumer_version("2", branch: "foo")
+            .create_consumer_version("3", branch: "foo")
+        end
+
+        context "when it is the latest version for the branch" do
+          subject { td.find_version("Foo", "3").branch_versions.first }
+
+          its(:latest?) { is_expected.to be true }
+        end
+
+        context "when it is not the latest version for the branch" do
+          subject { td.find_version("Foo", "2").branch_versions.first }
+
+          its(:latest?) { is_expected.to be false }
+        end
+      end
+    end
+  end
+end

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

@@ -63,8 +63,7 @@ module PactBroker
 
       describe "#delete_by_id" do
         let!(:version) do
-          TestDataBuilder.new
-            .create_consumer
+          td.create_consumer("Foo")
             .create_consumer_version("1.2.3")
             .create_consumer_version("4.5.6")
             .and_return(:consumer_version)
@@ -75,6 +74,35 @@ module PactBroker
         it "deletes the version" do
           expect { subject }.to change{ PactBroker::Domain::Version.count }.by(-1)
         end
+
+        context "when the deleted version is the latest for a branch" do
+          let!(:version) do
+            td.create_consumer("Foo")
+              .create_consumer_version("1.2.3", branch: "main")
+              .create_consumer_version("4.5.6", branch: "main")
+              .and_return(:consumer_version)
+          end
+
+          it "updates the branch head" do
+            subject
+            expect(td.find_pacticipant("Foo").branch_head_for("main").version.number).to eq "1.2.3"
+          end
+        end
+
+        context "when the deleted version is the latest and last for a branch" do
+          let!(:version) do
+            td.create_consumer("Foo")
+              .create_consumer_version("4.5.6", branch: "main")
+              .and_return(:consumer_version)
+          end
+
+          it "leaves the branch, but deletes the branch head (not sure about this, but thinking the branch creation date is handy for the WIP/pending calculation)" do
+            subject
+            foo = td.find_pacticipant("Foo")
+            expect(foo.branches.collect(&:name)).to include "main"
+            expect(td.find_pacticipant("Foo").branch_head_for("main")).to be nil
+          end
+        end
       end
 
       describe "#find_by_pacticipant_name_and_number" do
@@ -83,8 +111,7 @@ module PactBroker
 
         context "when the version exists" do
           before do
-            TestDataBuilder.new
-              .create_consumer("Another Consumer")
+            td.create_consumer("Another Consumer")
               .create_consumer(pacticipant_name)
               .create_consumer_version(version_number)
               .create_consumer_version_tag("prod")
@@ -121,6 +148,64 @@ module PactBroker
         end
       end
 
+      describe "#create_or_update" do
+        before do
+          td.subtract_day
+            .create_consumer("Foo")
+            .create_consumer_version(version_number, branch: "original-branch", build_url: "original-build-url")
+            .create_consumer_version_tag("dev")
+        end
+
+        let(:pacticipant) { td.and_return(:consumer) }
+        let(:version_number) { "1234" }
+        let(:tags) { nil }
+        let(:open_struct_version) { OpenStruct.new(build_url: new_build_url, tags: tags) }
+        let(:new_build_url) { "new-build-url" }
+
+        subject { Repository.new.create_or_update(pacticipant, version_number, open_struct_version) }
+
+        context "with empty properties" do
+          let(:open_struct_version) { OpenStruct.new }
+
+          it "does not overwrite missing values the values" do
+            expect(subject.build_url).to eq "original-build-url"
+          end
+
+          it "does not change the tags" do
+            expect { subject }.to_not change { PactBroker::Domain::Version.for("Foo", "1234").tags }
+          end
+        end
+
+        context "when there are tags specified" do
+          let(:tags) { [ OpenStruct.new(name: "main")] }
+
+          it "overwrites the tags" do
+            expect(subject.tags.count).to eq 1
+            expect(subject.tags.first.name).to eq "main"
+          end
+        end
+
+        it "does not change the created date" do
+          expect { subject }.to_not change { PactBroker::Domain::Version.for("Foo", "1234").created_at }
+        end
+
+        it "does change the updated date" do
+          expect { subject }.to change { PactBroker::Domain::Version.for("Foo", "1234").updated_at }
+        end
+
+        it "maintains the order" do
+          expect { subject }.to_not change { PactBroker::Domain::Version.for("Foo", "1234").order }
+        end
+
+        context "when the version does not already exist" do
+          let(:version) { OpenStruct.new(number: "555", branch: "new-branch") }
+
+          it "sets the order" do
+            expect(subject.order).to_not be nil
+          end
+        end
+      end
+
       describe "#create_or_overwrite" do
         before do
           td.subtract_day
@@ -132,12 +217,12 @@ module PactBroker
         let(:pacticipant) { td.and_return(:consumer) }
         let(:version_number) { "1234" }
         let(:tags) { nil }
-        let(:open_struct_version) { OpenStruct.new(branch: "new-branch", tags: tags) }
+        let(:open_struct_version) { OpenStruct.new(tags: tags) }
 
         subject { Repository.new.create_or_overwrite(pacticipant, version_number, open_struct_version) }
 
         it "overwrites the values" do
-          expect(subject.branch).to eq "new-branch"
+          expect(subject.branch_names).to eq ["original-branch"]
           expect(subject.build_url).to eq nil
         end