pact_broker 2.89.1 → 2.90.0

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

@@ -1,253 +0,0 @@
-require "pact_broker/pacts/verifiable_pact_messages"
-require "pact_broker/pacts/verifiable_pact"
-require "pact_broker/pacts/selectors"
-
-module PactBroker
-  module Pacts
-    describe VerifiablePactMessages do
-      let(:pending_provider_tags) { [] }
-      let(:non_pending_provider_tags) { [] }
-      let(:provider_branch) { nil }
-      let(:pending) { false }
-      let(:wip) { false }
-      let(:selectors) { Selectors.new }
-      let(:pact_version_url) { "http://pact" }
-      let(:verifiable_pact) do
-        double(VerifiablePact,
-            consumer: double("consumer", main_branch: "main"),
-            consumer_name: "Foo",
-            consumer_version_number: "123",
-            provider_name: "Bar",
-            pending_provider_tags: pending_provider_tags,
-            non_pending_provider_tags: non_pending_provider_tags,
-            pending?: pending,
-            wip?: wip,
-            selectors: selectors,
-            provider_branch: provider_branch
-        )
-      end
-      let(:consumer_version) { double("version", number: "1234", order: 1) }
-      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", production?: true) }
-
-      subject { VerifiablePactMessages.new(verifiable_pact, pact_version_url) }
-
-      describe "#inclusion_reason" do
-        context "when there is one selector" do
-          let(:selectors) { Selectors.create_for_overall_latest.resolve(consumer_version) }
-          its(:inclusion_reason) { is_expected.to include "The pact at http://pact is being verified because the pact content belongs to the consumer version matching the following criterion:" }
-        end
-
-        context "when there is more than one selector" do
-          let(:selectors) { Selectors.create_for_latest_of_each_branch(%w[main feat-x]).resolve(consumer_version) }
-          its(:inclusion_reason) { is_expected.to include "The pact at http://pact is being verified because the pact content belongs to the consumer versions matching the following criteria:" }
-        end
-
-
-        context "when there are no head consumer tags" do
-          let(:selectors) { Selectors.create_for_overall_latest.resolve(consumer_version) }
-          its(:inclusion_reason) { is_expected.to include "latest version of a consumer that has a pact with Bar (1234)" }
-        end
-
-        context "when there is 1 head consumer tags" do
-          let(:selectors) { Selectors.create_for_latest_of_each_tag(%w[dev]).resolve(consumer_version) }
-          its(:inclusion_reason) { is_expected.to include "latest version tagged 'dev' (1234)" }
-          its(:pact_description) { is_expected.to eq "Pact between Foo and Bar, consumer version 123, latest with tag dev"}
-        end
-
-        context "when there are branches" do
-          let(:selectors) { Selectors.create_for_latest_of_each_branch(%w[main feat-x]).resolve(consumer_version) }
-          its(:inclusion_reason) { is_expected.to include "latest version from branch 'feat-x' (1234)" }
-          its(:inclusion_reason) { is_expected.to include "latest version from branch 'main' (1234)" }
-          its(:pact_description) { is_expected.to eq "Pact between Foo and Bar, consumer version 123, latest from branch main, latest from branch feat-x"}
-        end
-
-        context "when there are branches and tags" do
-          let(:selectors) { Selectors.new([Selector.latest_for_branch("main"), Selector.latest_for_tag("prod")]).resolve(consumer_version) }
-          its(:inclusion_reason) { is_expected.to include "latest version from branch 'main' (1234)" }
-          its(:inclusion_reason) { is_expected.to include "latest version tagged 'prod' (1234)" }
-        end
-
-        context "when there are 2 head consumer tags" do
-          let(:selectors) { Selectors.create_for_latest_of_each_tag(%w[dev prod]).resolve(consumer_version) }
-          its(:inclusion_reason) { is_expected.to include "latest version tagged 'dev' (1234)" }
-          its(:inclusion_reason) { is_expected.to include "latest version tagged 'prod' (1234)" }
-        end
-
-        context "when the pact was selected by the fallback tag" do
-          let(:selectors) { Selectors.new(Selector.latest_for_tag_with_fallback("feat-x", "master").resolve_for_fallback(consumer_version)) }
-          its(:inclusion_reason) { is_expected.to include "latest version tagged 'master' (fallback tag used as no pact was found with tag 'feat-x') (1234)" }
-        end
-
-        context "when the pact was selected by the fallback tag" do
-          let(:selectors) { Selectors.new(Selector.latest_for_branch_with_fallback("feat-x", "master").resolve_for_fallback(consumer_version)) }
-          its(:inclusion_reason) { is_expected.to include "latest version from branch 'master' (fallback branch used as no pact was found from branch 'feat-x') (1234)" }
-        end
-
-        context "when the pact was for the main branch" do
-          let(:selectors) { Selectors.new(Selector.for_main_branch.resolve(consumer_version)) }
-
-          context "when the main branch is called main" do
-            its(:inclusion_reason) { is_expected.to include "latest version from the main branch 'main' (1234)" }
-          end
-        end
-
-        context "when the pact is a WIP pact for the specified provider tags" do
-          let(:selectors) { Selectors.create_for_latest_of_each_tag(%w[feat-x]).resolve(consumer_version) }
-          let(:wip) { true }
-          let(:pending) { true }
-          let(:pending_provider_tags) { %w[dev] }
-
-          its(:inclusion_reason) { is_expected.to include "The pact at http://pact is being verified because it is a 'work in progress' pact (ie. it is the pact for the latest version of Foo tagged with 'feat-x' and is still in pending state)."}
-
-          context "when the pact is a WIP pact for a consumer branch" do
-            let(:selectors) { Selectors.create_for_latest_of_each_branch(%w[feat-x feat-y]).resolve(consumer_version) }
-
-            its(:inclusion_reason) { is_expected.to include "The pact at http://pact is being verified because it is a 'work in progress' pact (ie. it is the pact for the latest versions of Foo from branches 'feat-x' and 'feat-y' (both have the same content) and is still in pending state)."}
-          end
-
-          context "when the pact is a WIP pact for a consumer branch and consumer rags" do
-            let(:selectors) { Selectors.create_for_latest_of_each_branch(%w[feat-x feat-y]).resolve(consumer_version) + Selectors.create_for_latest_of_each_tag(%w[feat-z feat-w]).resolve(consumer_version) }
-
-            its(:inclusion_reason) { is_expected.to include "it is the pact for the latest versions of Foo from branches 'feat-x' and 'feat-y' and tagged with 'feat-z' and 'feat-w' (all have the same content)"}
-          end
-        end
-
-        context "when the pact is one of all versions for a tag" do
-          let(:selectors) { Selectors.create_for_all_of_each_tag(%w[prod]).resolve(consumer_version) }
-
-          its(:inclusion_reason) { is_expected.to include "all consumer versions tagged 'prod' (1234)"}
-        end
-
-        context "when the pact is one of all versions for a tag and consumer" do
-          let(:selectors) { Selectors.new(Selector.all_for_tag_and_consumer("prod", "Foo")).resolve(consumer_version) }
-
-          its(:inclusion_reason) { is_expected.to include "all Foo versions tagged 'prod' (1234)"}
-        end
-
-        context "when the pact is the latest version for a tag and consumer" do
-          let(:selectors) { Selectors.new(Selector.latest_for_tag_and_consumer("prod", "Foo")).resolve(consumer_version) }
-
-          its(:inclusion_reason) { is_expected.to include "latest version of Foo tagged 'prod' (1234)"}
-        end
-
-        context "when the pact is the latest version for a branch and consumer" do
-          let(:selectors) { Selectors.new(Selector.latest_for_branch_and_consumer("main", "Foo")).resolve(consumer_version) }
-
-          its(:inclusion_reason) { is_expected.to include "latest version of Foo from branch 'main' (1234)"}
-        end
-
-        context "when the pact is the latest version for a consumer" do
-          let(:selectors) { Selectors.new(Selector.latest_for_consumer("Foo")).resolve(consumer_version) }
-
-          its(:inclusion_reason) { is_expected.to include "latest version of Foo that has a pact with Bar (1234)"}
-        end
-
-        context "when the consumer version is currently deployed to a single environment" do
-          let(:selectors) { Selectors.new(Selector.for_currently_deployed("test")).resolve_for_environment(consumer_version, environment) }
-
-          its(:inclusion_reason) { is_expected.to include "consumer version(s) currently deployed to test (1234)"}
-        end
-
-        context "when the consumer version is released and supported in a single environment" do
-          let(:selectors) { Selectors.new(Selector.for_currently_supported("test")).resolve_for_environment(consumer_version, environment) }
-
-          its(:inclusion_reason) { is_expected.to include "consumer version(s) released and supported in test (1234)"}
-        end
-
-        context "when the consumer version is currently released/deployed in single environment" do
-          let(:selectors) { Selectors.new(Selector.for_environment("test")).resolve_for_environment(consumer_version, environment) }
-
-          its(:inclusion_reason) { is_expected.to include "a consumer version in environment test (1234)"}
-        end
-
-        context "when the verison of a specific consumer is currently released/deployed in single environment" do
-          let(:selectors) { Selectors.new(Selector.for_environment_and_consumer("test", "Foo")).resolve_for_environment(consumer_version, environment) }
-
-          its(:inclusion_reason) { is_expected.to include "Foo version in environment test (1234)"}
-        end
-
-        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", 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), test (1234) and prod (1234)"}
-        end
-
-        context "when the currently deployed consumer version is for a consumer" do
-          let(:selectors) do
-            Selectors.new(
-              Selector.for_currently_deployed_and_environment_and_consumer("test", "Foo").resolve_for_environment(consumer_version, test_environment),
-              Selector.for_currently_deployed_and_environment_and_consumer("prod", "Foo").resolve_for_environment(consumer_version, prod_environment),
-              Selector.for_currently_deployed_and_environment_and_consumer("test", "Bar").resolve_for_environment(consumer_version, test_environment),
-              Selector.for_currently_deployed("test").resolve_for_environment(consumer_version, test_environment),
-            )
-          end
-
-          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
-      end
-
-      describe "#pending_reason" do
-        context "when the pact is not pending" do
-          context "when there are no non_pending_provider_tags or a provider branch" do
-            its(:pending_reason) { is_expected.to include "This pact has previously been successfully verified by Bar. If this verification fails, it will fail the build." }
-          end
-
-          context "when there is 1 non_pending_provider_tag" do
-            let(:non_pending_provider_tags) { %w[dev] }
-
-            its(:pending_reason) { is_expected.to include "This pact has previously been successfully verified by a version of Bar with tag 'dev'. If this verification fails, it will fail the build."}
-          end
-
-          context "when there is a provider branch" do
-            let(:provider_branch) { "main" }
-            let(:non_pending_provider_tags) { %w[dev] }
-
-            # uses branch in preference as that's what the WIP pacts logic does
-            its(:pending_reason) { is_expected.to include "This pact has previously been successfully verified by a version of Bar from branch 'main'. If this verification fails, it will fail the build."}
-          end
-        end
-
-        context "when the pact is pending" do
-          let(:pending) { true }
-
-          context "when there are no non_pending_provider_tags or a provider_branch" do
-            its(:pending_reason) { is_expected.to include "This pact is in pending state for this version of Bar because a successful verification result for Bar has not yet been published. If this verification fails, it will not cause the overall build to fail." }
-          end
-
-          context "when there is a provider_branch" do
-            let(:provider_branch) { "main" }
-            its(:pending_reason) { is_expected.to include "This pact is in pending state for this version of Bar because a successful verification result for a version of Bar from branch 'main' has not yet been published. If this verification fails, it will not cause the overall build to fail." }
-          end
-
-          context "when there is 1 pending_provider_tag" do
-            let(:pending_provider_tags) { %w[dev] }
-
-            its(:pending_reason) { is_expected.to include "This pact is in pending state for this version of Bar because a successful verification result for a version of Bar with tag 'dev' has not yet been published. If this verification fails, it will not cause the overall build to fail." }
-          end
-
-          context "when there are 2 pending_provider_tags" do
-            let(:pending_provider_tags) { %w[dev feat-x] }
-
-            its(:pending_reason) { is_expected.to include "This pact is in pending state for this version of Bar because a successful verification result for a versions of Bar with tag 'dev' and 'feat-x' has not yet been published. If this verification fails, it will not cause the overall build to fail." }
-          end
-
-          context "when there are 3 pending_provider_tags" do
-            let(:pending_provider_tags) { %w[dev feat-x feat-y] }
-
-            its(:pending_reason) { is_expected.to include "'dev', 'feat-x' and 'feat-y'" }
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,43 +0,0 @@
-require "spec_helper"
-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") }
-        let(:consumer_b) { double("consumer b", id: 2, name: "consumer b") }
-        let(:consumer_c) { double("consumer c", id: 3, name: "consumer c") }
-
-        let(:consumer_l) { double("consumer l", id: 4, name: "consumer l") }
-        let(:consumer_m) { double("consumer m", id: 5, name: "consumer m") }
-
-        let(:provider_p) { double("provider p", id: 6, name: "provider p") }
-
-        let(:provider_x) { double("provider x", id: 7, name: "provider x") }
-        let(:provider_y) { double("provider y", id: 8, name: "provider y") }
-        let(:provider_z) { double("provider z", id: 9, name: "provider z") }
-
-        let(:relationship_1) { Domain::IndexItem.new(consumer_a, provider_x) }
-        let(:relationship_4) { Domain::IndexItem.new(consumer_a, provider_y) }
-        let(:relationship_2) { Domain::IndexItem.new(consumer_b, provider_y) }
-
-        let(:relationship_3) { Domain::IndexItem.new(consumer_c, provider_z) }
-
-        let(:relationship_5) { Domain::IndexItem.new(consumer_l, provider_p) }
-        let(:relationship_6) { Domain::IndexItem.new(consumer_m, provider_p) }
-
-        let(:relationships) { [relationship_1, relationship_2, relationship_3, relationship_4, relationship_5, relationship_6] }
-
-        it "separates the relationships into isolated groups" do
-          groups = Groupify.call(relationships)
-          expect(groups[0]).to eq(Domain::Group.new(relationship_1, relationship_4, relationship_2))
-          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/tags/repository_spec.rb

@@ -1,144 +0,0 @@
-require "spec_helper"
-require "pact_broker/tags/repository"
-
-module PactBroker
-  module Tags
-    describe Repository do
-      let(:td) { TestDataBuilder.new }
-
-      describe ".create" do
-        before do
-          td.create_pacticipant("foo")
-            .create_version("1")
-        end
-
-        let(:params) { { name: "prod", version: td.version } }
-
-        subject { Repository.new.create(params) }
-
-        it "returns a tag" do
-          expect(subject).to be_a(Domain::Tag)
-        end
-
-        it "sets the properties" do
-          expect(subject.name).to eq "prod"
-          expect(subject.version.id).to eq td.version.id
-          expect(subject.version_order).to eq td.version.order
-          expect(subject.pacticipant_id).to eq td.version.pacticipant_id
-        end
-
-        context "when the tag already exists" do
-          before do
-            td.create_tag("prod")
-          end
-
-          it "does nothing" do
-            expect { subject }.to_not change { Domain::Tag.count }
-          end
-
-          it "returns a tag" do
-            expect(subject).to be_a(Domain::Tag)
-          end
-        end
-      end
-
-      describe ".find" do
-
-        let(:pacticipant_name) { "test_pacticipant" }
-        let(:version_number) { "1.2.3a" }
-        let(:tag_name) { "prod" }
-
-        subject { Repository.new }
-        let(:options) { {pacticipant_name: pacticipant_name, pacticipant_version_number: version_number, tag_name: tag_name} }
-        let(:find_tag) { subject.find options }
-
-        let!(:test_data_builder) do
-          TestDataBuilder.new
-            .create_pacticipant("wrong_pacticipant")
-            .create_version(version_number)
-            .create_tag(tag_name) #Tag with wrong pacticipant
-            .create_pacticipant(pacticipant_name)
-            .create_version("2.0.0")
-            .create_tag(tag_name) # Tag with wrong version number
-            .create_version(version_number)
-            .create_tag("wrong tag") #Tag with wrong name
-        end
-
-        context "when the tag exists" do
-
-          before do
-            test_data_builder.create_tag(tag_name) # Right tag!
-          end
-
-          it "returns the tag" do
-            expect(find_tag.name).to eq tag_name
-            expect(find_tag.version.number).to eq version_number
-            expect(find_tag.version.pacticipant.name).to eq pacticipant_name
-            expect(find_tag.created_at).to be_datey
-            expect(find_tag.updated_at).to be_datey
-          end
-
-          context "when case sensitivity is turned off and a name with different case is used" do
-            before do
-              allow(PactBroker.configuration).to receive(:use_case_sensitive_resource_names).and_return(false)
-            end
-
-            let(:options) { {pacticipant_name: pacticipant_name.upcase, pacticipant_version_number: version_number.upcase, tag_name: tag_name.upcase} }
-
-            it "returns the tag" do
-              expect(find_tag).to_not be nil
-              expect(find_tag.name).to eq tag_name
-            end
-          end
-        end
-
-        context "when the tag does not exist" do
-          it "returns nil" do
-            expect(find_tag).to be_nil
-          end
-        end
-      end
-
-      describe "delete_by_version_id" do
-        let!(:version) do
-          TestDataBuilder.new
-            .create_consumer
-            .create_provider
-            .create_consumer_version("4.5.6")
-            .create_consumer_version_tag("prod")
-            .create_consumer_version("1.2.3")
-            .create_consumer_version_tag("prod")
-            .create_consumer_version_tag("foo")
-            .and_return(:consumer_version)
-        end
-
-        subject { Repository.new.delete_by_version_id(version.id) }
-
-        it "deletes the tag" do
-          expect{ subject }.to change { PactBroker::Domain::Tag.count }.by(-2)
-        end
-      end
-
-      describe "find_all_tag_names_for_pacticipant" do
-        before do
-          td.create_consumer("Foo")
-            .create_consumer_version("1")
-            .create_consumer_version_tag("prod")
-            .create_consumer_version_tag("master")
-            .create_consumer_version("2")
-            .create_consumer_version_tag("prod")
-            .create_consumer_version_tag("dev")
-            .create_consumer("Bar")
-            .create_consumer_version("1")
-            .create_consumer_version_tag("ignore")
-        end
-
-        subject { Repository.new.find_all_tag_names_for_pacticipant("Foo") }
-
-        it "returns all the tag names for the pacticipant" do
-          expect(subject).to eq ["dev", "master", "prod"]
-        end
-      end
-    end
-  end
-end

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

@@ -1,66 +0,0 @@
-require "spec_helper"
-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(:use_first_tag_as_branch) { false }
-
-      describe ".create" do
-        subject { Service.create(options) }
-
-        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 }}
-
-        before do
-          Service.create(options)
-          Service.create(second_options_same_tag_name)
-        end
-
-        let(:delete_tag_for_particpant_and_version) { subject.delete second_options_same_tag_name}
-
-        it "deletes the tag for the particpiant and the version" do
-          expect{ delete_tag_for_particpant_and_version }.to change{
-            PactBroker::Domain::Tag.all.count
-          }.by(-1)
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/ui/controllers/can_i_deploy_spec.rb

@@ -1,26 +0,0 @@
-require "pact_broker/ui/controllers/can_i_deploy"
-
-module PactBroker
-  module UI
-    module Controllers
-      describe CanIDeploy do
-
-        let(:app) { CanIDeploy }
-
-        describe "GET" do
-          before do
-            TestDataBuilder.new
-              .create_pact_with_hierarchy("Foo", "1", "Bar")
-              .create_consumer_version_tag("main")
-          end
-
-          subject { get("/Foo/latest-version/main/can-i-deploy/to/prod") }
-
-          it "renders the matrix page" do
-            expect(subject.body).to include "The Matrix"
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/ui/controllers/clusters_spec.rb

@@ -1,27 +0,0 @@
-require "spec_helper"
-require "pact_broker/ui/controllers/clusters"
-require "rack/test"
-
-module PactBroker
-  module UI
-    module Controllers
-      describe Clusters do
-
-        include Rack::Test::Methods
-
-        let(:app) { Clusters }
-
-        describe "/" do
-          describe "GET" do
-
-            xit "does something" do
-              get "/"
-              puts last_response.body
-            end
-
-          end
-        end
-      end
-    end
-  end
-end