pact_broker 2.89.1 → 2.93.0

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

@@ -1,72 +0,0 @@
-require "pact_broker/verifications/summary_for_consumer_version"
-
-module PactBroker
-  module Verifications
-    describe SummaryForConsumerVersion do
-
-      let(:verifications) { [verification_1, verification_2] }
-      let(:verification_1) do
-        instance_double("PactBroker::Domain::Verification",
-          success: true,
-          provider_name: "Successful Provider"
-        )
-      end
-      let(:verification_2) do
-        instance_double("PactBroker::Domain::Verification",
-          success: false,
-          provider_name: "Failed Provider"
-        )
-      end
-
-      let(:pact_1) { instance_double("pact", provider_name: "Successful Provider") }
-      let(:pact_2) { instance_double("pact", provider_name: "Failed Provider") }
-      let(:pact_3) { instance_double("pact", provider_name: "Unknown Provider") }
-
-      let(:pacts) do
-        [pact_1, pact_2, pact_3]
-      end
-
-      subject { SummaryForConsumerVersion.new(verifications, pacts)}
-
-      describe "#provider_summary" do
-        it "returns the successful providers" do
-          expect(subject.provider_summary.successful).to eq ["Successful Provider"]
-        end
-
-        it "returns the failed providers" do
-          expect(subject.provider_summary.failed).to eq ["Failed Provider"]
-        end
-
-        it "returns the unknown providers" do
-          expect(subject.provider_summary.unknown).to eq ["Unknown Provider"]
-        end
-      end
-
-      describe "success" do
-        context "when all pacts have a successful verification" do
-          let(:verifications) { [verification_1] }
-          let(:pacts) { [[pact_1]] }
-          its(:success) { is_expected.to be true }
-        end
-
-        context "when some pacts have not been verified" do
-          let(:verifications) { [] }
-          let(:pacts) { [[pact_1]] }
-          its(:success) { is_expected.to be false }
-        end
-
-        context "when some pacts have failed verification" do
-          let(:verifications) { [verification_2] }
-          let(:pacts) { [[pact_2]] }
-          its(:success) { is_expected.to be false }
-        end
-
-        context "when there are no verifications" do
-          let(:verifications) { [] }
-          let(:pacts) { [[pact_2]] }
-          its(:success) { is_expected.to be false }
-        end
-      end
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-require "pact_broker/versions/abbreviate_number"
-
-module PactBroker
-  module Versions
-    describe AbbreviateNumber do
-      describe "#call" do
-        TEST_CASES = [
-          ["202326572516dea6998a7f311fcaa161c0768fc2", "2023265"],
-          ["1.2.3+areallyreallyreallylongexplanation", "1.2.3+areallyreallyreallylongexplanation"],
-          ["2516dea6998a7f", "2516dea6998a7f"],
-          ["1.2.3+202326572516dea6998a7f311fcaa161c0768fc2", "1.2.3+2023265"],
-          ["this-is-very-long-text-this-is-very-long-text-this-is-very-long-text-this-is-very-long-text", "this-is-very-long-text-this-is-very-lon…-long-text"]
-        ]
-
-        TEST_CASES.each do |(input, output)|
-          it "shortens #{input} to #{output}" do
-            expect(AbbreviateNumber.call(input)).to eq output
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,71 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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/parse_semantic_version_spec.rb

@@ -1,42 +0,0 @@
-require "spec_helper"
-require "pact_broker/versions/parse_semantic_version"
-
-module PactBroker
-  module Versions
-    describe ParseSemanticVersion do
-
-      describe ".call" do
-        context "when parsing a semantic version" do
-
-          subject { ParseSemanticVersion.call("1.2.3") }
-
-          it "returns the version" do
-            expect(subject.major).to eq 1
-            expect(subject.minor).to eq 2
-            expect(subject.to_s).to eq "1.2.3"
-          end
-
-          it "returns a comparable version" do
-            expect(subject).to be > ParseSemanticVersion.call("1.2.2")
-            expect(subject).to be == ParseSemanticVersion.call("1.2.3")
-            expect(subject).to be < ParseSemanticVersion.call("1.3.1")
-          end
-
-          it "allows versions with one or two parts for backwards compatibility" do
-            expect(ParseSemanticVersion.call("1")).to eq ::SemVer.new(1,0,0)
-            expect(ParseSemanticVersion.call("1.2")).to eq ::SemVer.new(1,2,0)
-          end
-
-          it "returns nil when version is invalid" do
-            expect(ParseSemanticVersion.call("abc")).to be_nil
-          end
-
-          it "accepts semver metadata" do
-            expect(ParseSemanticVersion.call("1.2.3+abc.234")).not_to be_nil
-          end
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,302 +0,0 @@
-require "spec_helper"
-require "pact_broker/versions/repository"
-
-module PactBroker
-  module Versions
-    describe Repository do
-      let(:pacticipant_name) { "test_pacticipant" }
-      let(:version_number) { "1.2.3" }
-
-      describe "#find_by_pacticipant_name_and_latest_tag" do
-        before do
-          td.create_consumer("Bar")
-            .create_consumer_version("2.3.4")
-            .create_consumer_version_tag("prod")
-            .create_consumer("Foo")
-            .create_consumer_version("1.2.3")
-            .create_consumer_version_tag("prod")
-            .create_consumer_version("2.3.4")
-            .create_consumer_version_tag("prod")
-            .create_consumer_version("5.6.7")
-        end
-
-        subject { Repository.new.find_by_pacticipant_name_and_latest_tag("Foo", "prod") }
-
-        it "returns the most recent version that has the specified tag" do
-
-          expect(subject.number).to eq "2.3.4"
-          expect(subject.pacticipant.name).to eq "Foo"
-        end
-      end
-
-      describe "#create" do
-        context "when a previous version exists" do
-          let!(:existing_version) do
-            TestDataBuilder.new.create_version_with_hierarchy(pacticipant_name, version_number).and_return(:version)
-          end
-
-          subject { Repository.new.create pacticipant_id: existing_version.pacticipant_id, number: "1.2.4" }
-
-          it "creates a new version" do
-            expect { subject }.to change { PactBroker::Domain::Version.count }.by(1)
-          end
-
-          it "sets the order to the previous version's order plus one" do
-            expect(subject.order).to eq existing_version.order + 1
-          end
-        end
-
-        context "when the same version already exists" do
-          let!(:existing_version) { TestDataBuilder.new.create_version_with_hierarchy(pacticipant_name, version_number).and_return(:version) }
-
-          subject { Repository.new.create pacticipant_id: existing_version.pacticipant_id, number: version_number }
-
-          it "does not create a new version" do
-            expect { subject }.to_not change { PactBroker::Domain::Version.count }
-          end
-
-          it "returns the pre-existing version" do
-            expect(subject.id).to eq existing_version.id
-          end
-        end
-      end
-
-      describe "#delete_by_id" do
-        let!(:version) do
-          td.create_consumer("Foo")
-            .create_consumer_version("1.2.3")
-            .create_consumer_version("4.5.6")
-            .and_return(:consumer_version)
-        end
-
-        subject { Repository.new.delete_by_id version.id }
-
-        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
-
-        subject { described_class.new.find_by_pacticipant_name_and_number pacticipant_name, version_number }
-
-        context "when the version exists" do
-          before do
-            td.create_consumer("Another Consumer")
-              .create_consumer(pacticipant_name)
-              .create_consumer_version(version_number)
-              .create_consumer_version_tag("prod")
-              .create_consumer_version("1.2.4")
-              .create_consumer("Yet Another Consumer")
-              .create_consumer_version(version_number)
-          end
-
-          it "returns the version" do
-            expect(subject.id).to_not be nil
-            expect(subject.number).to eq version_number
-            expect(subject.pacticipant.name).to eq pacticipant_name
-            expect(subject.tags.first.name).to eq "prod"
-            expect(subject.order).to_not be nil
-          end
-
-          context "when case sensitivity is turned off and names with different cases are used" do
-            before do
-              allow(PactBroker.configuration).to receive(:use_case_sensitive_resource_names).and_return(false)
-            end
-
-            subject { described_class.new.find_by_pacticipant_name_and_number pacticipant_name.upcase, version_number.upcase }
-
-            it "returns the version" do
-              expect(subject).to_not be nil
-            end
-          end
-        end
-
-        context "when the version doesn't exist" do
-          it "returns nil" do
-            expect(subject).to be_nil
-          end
-        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
-            .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(tags: tags) }
-
-        subject { Repository.new.create_or_overwrite(pacticipant, version_number, open_struct_version) }
-
-        it "overwrites the values" do
-          expect(subject.branch_names).to eq ["original-branch"]
-          expect(subject.build_url).to eq nil
-        end
-
-        it "does not change the tags" do
-          expect { subject }.to_not change { PactBroker::Domain::Version.for("Foo", "1234").tags }
-        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 "#find_latest_version_from_main_branch" do
-        subject { Repository.new.find_latest_version_from_main_branch(td.find_pacticipant("Foo")) }
-
-        context "when there is a version with the provider's configured main branch as the branch" do
-          before do
-            td.create_consumer("Foo", main_branch: "main")
-              .create_consumer_version("1", branch: "main")
-              .create_consumer_version("2", branch: "main")
-              .create_consumer_version("3", tag_name: "main")
-              .create_consumer_version("4", branch: "not-main")
-          end
-
-          its(:number) { is_expected.to eq "2" }
-        end
-
-        context "when there is a version with the provider's configured main branch as the tag" do
-          before do
-            td.create_consumer("Foo", main_branch: "main")
-              .create_consumer_version("1", branch: "not-main")
-              .create_consumer_version("2", branch: "not-main")
-              .create_consumer_version("3", tag_name: "main")
-              .create_consumer_version("4", branch: "not-main")
-          end
-
-          its(:number) { is_expected.to eq "3" }
-        end
-
-        context "when there are no versions with a matching branch or tag set" do
-          before do
-            td.create_consumer("Foo", main_branch: "main")
-              .create_consumer_version("1", branch: "not-main")
-              .create_consumer_version("2", tag_name: "not-main")
-          end
-
-          it { is_expected.to be_nil }
-        end
-      end
-    end
-  end
-end