pact_broker 2.89.1 → 2.90.0

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

@@ -1,239 +0,0 @@
-require "spec_helper"
-require "pact_broker/pacticipants/repository"
-require "support/test_data_builder"
-
-module PactBroker
-  module Pacticipants
-    describe Repository do
-      describe "#create" do
-        let(:repository) { Repository.new }
-
-        subject { repository.create(name: "Foo") }
-
-        context "when the pacticipant does not already exist" do
-          before do
-            td.create_pacticipant("Bar")
-            allow_any_instance_of(PactBroker::Domain::Pacticipant).to receive(:generate_display_name).and_return("display_name")
-          end
-
-          let(:display_name) { "Foo" }
-
-          subject { repository.create(name: "foo", display_name: display_name, repository_url: "url", main_branch: "main") }
-
-          it "returns the new pacticipant" do
-            expect(subject).to be_a(PactBroker::Domain::Pacticipant)
-            expect(subject.name).to eq "foo"
-            expect(subject.main_branch).to eq "main"
-            expect(subject.repository_url).to eq "url"
-            expect(subject.display_name).to eq "Foo"
-          end
-
-          context "when no display name is provided" do
-            let(:display_name) { nil }
-
-            it "generates one" do
-              expect(subject.display_name).to eq "display_name"
-            end
-          end
-        end
-
-        context "when a race condition occurs and the pacticipant was already created by another request" do
-          before do
-            td.create_pacticipant("Foo", repository_url: "original")
-          end
-
-          it "does not raise an error" do
-            subject
-          end
-
-          it "returns the existing pacticipant" do
-            expect(subject).to be_a(PactBroker::Domain::Pacticipant)
-            expect(subject.name).to eq "Foo"
-            expect(subject.repository_url).to eq "original"
-          end
-        end
-      end
-
-      describe "replace" do
-        before do
-          td.create_pacticipant("Bar", main_branch: "foo", repository_namespace: "foo")
-          allow_any_instance_of(PactBroker::Domain::Pacticipant).to receive(:generate_display_name).and_return("display_name")
-        end
-
-        subject { Repository.new.replace("Bar", OpenStruct.new(main_branch: "bar", repository_url: "new_url")) }
-
-        it "replaces the pacticipant" do
-          expect(subject.main_branch).to eq "bar"
-          expect(subject.repository_namespace).to eq nil
-          expect(subject.display_name).to eq "display_name"
-        end
-      end
-
-      describe "#find" do
-        before do
-          td
-            .create_pacticipant("Foo")
-            .create_label("in")
-            .create_pacticipant("Bar")
-            .create_label("in")
-            .create_label("blah")
-            .create_pacticipant("Wiffle")
-            .create_label("out")
-        end
-
-        subject { Repository.new.find label_name: "in" }
-
-        it "returns the pacticipants with the given label" do
-          expect(subject.collect(&:name)).to eq ["Bar", "Foo"]
-        end
-
-      end
-      describe "#find_by_name" do
-        before do
-          td.create_pacticipant("Foo-Bar")
-        end
-
-        subject { Repository.new.find_by_name("foo-bar") }
-
-        context "when the name is a different case" do
-          context "with case sensitivity turned on" do
-            before do
-              allow(PactBroker.configuration).to receive(:use_case_sensitive_resource_names).and_return(true)
-            end
-
-            it "returns nil" do
-              expect(subject).to be nil
-            end
-          end
-
-          context "with case sensitivity turned off" do
-            before do
-              allow(PactBroker.configuration).to receive(:use_case_sensitive_resource_names).and_return(false)
-            end
-
-            it "returns the pacticipant" do
-              expect(subject).to_not be nil
-              expect(subject.name).to eq "Foo-Bar"
-            end
-          end
-
-          context "with case sensitivity turned off and multiple records found", skip: DB.mysql?  do
-            # Can't be created in MySQL - duplicate record
-            before do
-              td.create_pacticipant("Foo-bar")
-              allow(PactBroker.configuration).to receive(:use_case_sensitive_resource_names).and_return(false)
-            end
-
-            it "raises an error" do
-              expect { subject }.to raise_error PactBroker::Error, /Found multiple pacticipants.*foo-bar/
-            end
-          end
-
-          context "with case sensitivity turned off and searching for a name with an underscore" do
-            before do
-              allow(PactBroker.configuration).to receive(:use_case_sensitive_resource_names).and_return(false)
-            end
-
-            subject { Repository.new.find_by_name("foo_bar") }
-
-            it { is_expected.to be nil }
-          end
-
-          context "with case sensitivity turned on and searching for a name with an underscore" do
-            subject { Repository.new.find_by_name("foo_bar") }
-
-            it { is_expected.to be nil }
-          end
-
-          context "with case sensitivity turned off no record found" do
-            subject { Repository.new.find_by_name("blah") }
-
-            it { is_expected.to be nil }
-          end
-        end
-      end
-
-      describe "#pacticipant_names" do
-        before do
-          td
-            .create_pacticipant("Plants")
-            .create_pacticipant("Animals")
-        end
-
-        subject { Repository.new.pacticipant_names }
-
-        it "returns an array of pacticipant names" do
-          expect(subject).to eq ["Animals", "Plants"]
-        end
-
-      end
-
-      describe "#find_all_pacticipant_versions_in_reverse_order" do
-        before do
-          td
-            .create_consumer("Foo")
-            .create_consumer_version("1.2.3")
-            .create_consumer_version("4.5.6")
-            .create_consumer("Bar")
-            .create_consumer_version("8.9.0")
-        end
-
-        subject { Repository.new.find_all_pacticipant_versions_in_reverse_order "Foo" }
-
-        it "returns all the application versions for the given consumer" do
-          expect(subject.collect(&:number)).to eq ["4.5.6", "1.2.3"]
-        end
-
-        context "with pagination options" do
-          subject { Repository.new.find_all_pacticipant_versions_in_reverse_order "Foo", page_number: 1, page_size: 1 }
-
-          it "paginates the query" do
-            expect(subject.collect(&:number)).to eq ["4.5.6"]
-          end
-        end
-      end
-
-      describe "#search_by_name" do
-        let(:consumer_name) { "This is_a test-consumer" }
-        let(:provider_name) { "and a test/provider" }
-
-        before do
-          td
-            .create_consumer(consumer_name)
-            .create_consumer(provider_name)
-        end
-
-        context "when there is a consumer/provider name which matches the search term" do
-          it "returns the pacticipants" do
-            searched_dataset =  Repository.new.search_by_name "consumer"
-            expect(searched_dataset.collect(&:name)).to eq([consumer_name])
-
-            searched_dataset =  Repository.new.search_by_name "provider"
-            expect(searched_dataset.collect(&:name)).to eq([provider_name])
-
-            searched_dataset =  Repository.new.search_by_name "test"
-            expect(searched_dataset.collect(&:name)).to include(*[consumer_name, provider_name])
-          end
-
-          # SQL escape character is '_'
-          it "escapes the '_' character" do
-            searched_dataset =  Repository.new.search_by_name "is_a"
-            expect(searched_dataset.collect(&:name)).to eq([consumer_name])
-          end
-
-          it "searches case insentively" do
-            searched_dataset =  Repository.new.search_by_name "TEST"
-            expect(searched_dataset.collect(&:name)).to include(*[consumer_name, provider_name])
-          end
-        end
-
-        context "when there is NO consumer/provider name which matches the search term" do
-          it "returns empty dataset" do
-            searched_dataset =  Repository.new.search_by_name "this_will_not_yield_any_result"
-            expect(searched_dataset.count).to eq(0)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,217 +0,0 @@
-require "spec_helper"
-require "pact_broker/pacticipants/service"
-require "pact_broker/domain/tag"
-require "pact_broker/domain/pact"
-
-module PactBroker
-  module Pacticipants
-    describe Service do
-      before do
-        allow(Service).to receive(:logger).and_return(logger)
-      end
-
-      let(:logger) { double("logger").as_null_object }
-
-      subject { Service }
-
-      describe ".messages_for_potential_duplicate_pacticipants" do
-
-        let(:base_url) { "http://example.org" }
-        let(:fred_duplicates) { [double("Frederich pacticipant")] }
-        let(:mary_dulicates) { [double("Marta pacticipant")] }
-
-        before do
-          allow(Service).to receive(:find_potential_duplicate_pacticipants).with("Fred").and_return(fred_duplicates)
-          allow(Service).to receive(:find_potential_duplicate_pacticipants).with("Mary").and_return(mary_dulicates)
-          allow(Messages).to receive(:potential_duplicate_pacticipant_message).and_return("message1", "message2")
-        end
-
-        subject { Service.messages_for_potential_duplicate_pacticipants ["Fred", "Mary"], base_url }
-
-        it "finds the potential duplicates for each name" do
-          expect(Service).to receive(:find_potential_duplicate_pacticipants).with("Fred")
-          expect(Service).to receive(:find_potential_duplicate_pacticipants).with("Mary")
-          subject
-        end
-
-        context "when there are potential duplicates" do
-
-          it "creates a message for each dupliate" do
-            expect(Messages).to receive(:potential_duplicate_pacticipant_message).with("Fred", fred_duplicates, base_url)
-            expect(Messages).to receive(:potential_duplicate_pacticipant_message).with("Mary", mary_dulicates, base_url)
-            subject
-          end
-
-          it "returns an array of messages" do
-            expect(subject).to eq ["message1", "message2"]
-          end
-        end
-
-        context "when there are no potential duplicates" do
-          let(:fred_duplicates) { [] }
-          let(:mary_dulicates) { [] }
-
-          it "returns an empty array" do
-            expect(subject).to eq []
-          end
-        end
-      end
-
-      describe ".find_potential_duplicate_pacticipants" do
-        let(:pacticipant_name) { "pacticipant_name" }
-        let(:duplicates) { ["Fred", "Mary"] }
-        let(:pacticipant_names) { double("pacticipant_names") }
-        let(:fred) { double("fred pacticipant")}
-        let(:mary) { double("mary pacticipant")}
-        let(:pacticipant_repository) { instance_double(PactBroker::Pacticipants::Repository)}
-
-        before do
-          allow(PactBroker::Pacticipants::FindPotentialDuplicatePacticipantNames).to receive(:call).and_return(duplicates)
-          allow(PactBroker::Pacticipants::Repository).to receive(:new).and_return(pacticipant_repository)
-          allow(pacticipant_repository).to receive(:pacticipant_names).and_return(pacticipant_names)
-          allow(pacticipant_repository).to receive(:find_by_name).with("Fred").and_return(fred)
-          allow(pacticipant_repository).to receive(:find_by_name).with("Mary").and_return(mary)
-        end
-
-        it "finds all the pacticipant names" do
-          expect(pacticipant_repository).to receive(:pacticipant_names)
-          subject.find_potential_duplicate_pacticipants pacticipant_name
-        end
-
-        it "calculates the duplicates" do
-          expect(PactBroker::Pacticipants::FindPotentialDuplicatePacticipantNames).to receive(:call).with(pacticipant_name, pacticipant_names)
-          subject.find_potential_duplicate_pacticipants pacticipant_name
-        end
-
-        it "retrieves the pacticipants by name" do
-          expect(pacticipant_repository).to receive(:find_by_name).with("Fred")
-          expect(pacticipant_repository).to receive(:find_by_name).with("Mary")
-          subject.find_potential_duplicate_pacticipants pacticipant_name
-        end
-
-        it "returns the duplicate pacticipants" do
-          expect(subject.find_potential_duplicate_pacticipants(pacticipant_name)).to eq [fred, mary]
-        end
-
-        it "logs the names" do
-          expect(logger).to receive(:info).with(/pacticipant_name.*Fred, Mary/)
-          subject.find_potential_duplicate_pacticipants pacticipant_name
-        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
-          td.create_consumer("Consumer")
-            .create_label("finance")
-            .create_consumer_version("2.3.4")
-            .create_provider("Provider")
-            .create_pact
-            .create_consumer_version("1.2.3")
-            .create_consumer_version_tag("prod")
-            .create_pact
-            .create_webhook
-            .create_triggered_webhook
-            .create_webhook_execution
-            .create_verification
-        end
-
-        let(:delete_consumer) { subject.delete "Consumer" }
-        let(:delete_provider) { subject.delete "Provider" }
-
-        context "deleting a consumer" do
-          it "deletes the pacticipant" do
-            expect{ delete_consumer }.to change{ PactBroker::Domain::Pacticipant.all.count }.by(-1)
-          end
-
-          it "deletes the child versions" do
-            expect{ delete_consumer }.to change{ PactBroker::Domain::Version.where(number: "1.2.3").count }.by(-1)
-          end
-
-          it "deletes the child tags" do
-            expect{ delete_consumer }.to change{ PactBroker::Domain::Tag.where(name: "prod").count }.by(-1)
-          end
-
-          it "deletes the webhooks" do
-            expect{ delete_consumer }.to change{ PactBroker::Webhooks::Webhook.count }.by(-1)
-          end
-
-          it "deletes the triggered webhooks" do
-            expect{ delete_consumer }.to change{ PactBroker::Webhooks::TriggeredWebhook.count }.by(-1)
-          end
-
-          it "deletes the webhook executions" do
-            expect{ delete_consumer }.to change{ PactBroker::Webhooks::Execution.count }.by(-1)
-          end
-
-          it "deletes the child pacts" do
-            expect{ delete_consumer }.to change{ PactBroker::Pacts::PactPublication.count }.by(-2)
-          end
-
-          it "deletes the verifications" do
-            expect{ delete_consumer }.to change{ PactBroker::Domain::Verification.count }.by(-1)
-          end
-        end
-
-        context "deleting a provider" do
-          it "deletes the pacticipant" do
-            expect{ delete_provider }.to change{ PactBroker::Domain::Pacticipant.all.count }.by(-1)
-          end
-
-          it "does not delete any versions" do
-            expect{ delete_provider }.to change{ PactBroker::Domain::Version.where(number: "1.2.3").count }.by(0)
-          end
-
-          it "deletes the child tags only if there are any" do
-            expect{ delete_provider }.to change{ PactBroker::Domain::Tag.where(name: "prod").count }.by(0)
-          end
-
-          it "deletes the webhooks" do
-            expect{ delete_provider }.to change{ PactBroker::Webhooks::Webhook.count }.by(-1)
-          end
-
-          it "deletes the triggered webhooks" do
-            expect{ delete_provider }.to change{ PactBroker::Webhooks::TriggeredWebhook.count }.by(-1)
-          end
-
-          it "deletes the webhook executions" do
-            expect{ delete_provider }.to change{ PactBroker::Webhooks::Execution.count }.by(-1)
-          end
-
-          it "deletes the child pacts" do
-            expect{ delete_provider }.to change{ PactBroker::Pacts::PactPublication.count }.by(-2)
-          end
-
-          it "deletes the verifications" do
-            expect{ delete_provider }.to change{ PactBroker::Domain::Verification.count }.by(-1)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,75 +0,0 @@
-require "pact_broker/pacts/build_verifiable_pact_notices"
-
-module PactBroker
-  module Pacts
-    describe BuildVerifiablePactNotices do
-      before do
-        allow(VerifiablePactMessages).to receive(:new).and_return(verifiable_pact_messages)
-      end
-
-      let(:verifiable_pact_messages) do
-        instance_double(VerifiablePactMessages,
-          inclusion_reason: "the inclusion reason",
-          pending_reason: "pending reason",
-          verification_success_true_published_false: "verification_success_true_published_false",
-          verification_success_false_published_false: "verification_success_false_published_false",
-          verification_success_true_published_true: "verification_success_true_published_true",
-          verification_success_false_published_true: "verification_success_false_published_true"
-        )
-      end
-
-      let(:options) { {} }
-      let(:pact_url) { "http://pact" }
-      let(:verifiable_pact) { instance_double("PactBroker::Pacts::VerifiablePact") }
-
-      subject { BuildVerifiablePactNotices.call(verifiable_pact, pact_url, options) }
-
-      context "when include_pending_status is true" do
-        let(:expected_notices) do
-          [
-            {
-              :when => "before_verification",
-              :text => "the inclusion reason"
-            },{
-              :when => "before_verification",
-              :text => "pending reason"
-            },{
-              :when => "after_verification:success_true_published_false",
-              :text => "verification_success_true_published_false"
-            },{
-              :when => "after_verification:success_false_published_false",
-              :text => "verification_success_false_published_false"
-            },{
-              :when => "after_verification:success_true_published_true",
-              :text => "verification_success_true_published_true"
-            },{
-              :when => "after_verification:success_false_published_true",
-              :text => "verification_success_false_published_true"
-            }
-          ]
-        end
-
-        let(:options) { { include_pending_status: true } }
-
-        it "it returns a list of notices with information about the pending status" do
-          expect(subject).to eq expected_notices
-        end
-      end
-
-      context "when include_pending_status is not true" do
-        let(:expected_notices) do
-          [
-            {
-              :when => "before_verification",
-              :text => "the inclusion reason"
-            }
-          ]
-        end
-
-        it "it returns a list of notices without information about the pending status" do
-          expect(subject).to eq expected_notices
-        end
-      end
-    end
-  end
-end