pact_broker 2.89.1 → 2.90.0

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

@@ -1,282 +0,0 @@
-require "pact_broker/integrations/service"
-
-module PactBroker
-  module Integrations
-    describe Service do
-      describe "find_all" do
-        before do
-          allow(PactBroker::Integrations::Integration).to receive(:eager).and_return(dataset)
-          allow(dataset).to receive(:eager).and_return(dataset)
-          allow(dataset).to receive(:all).and_return(integrations)
-        end
-
-        let(:dataset) { double("integrations") }
-        let(:integrations) { [ integration_1, integration_2 ] }
-        let(:integration_1) do
-          double(
-            "integration 1",
-            latest_pact_or_verification_publication_date: DateTime.new(2019, 1, 1)
-          )
-        end
-        let(:integration_2) do
-          double(
-            "integration 2",
-            latest_pact_or_verification_publication_date: DateTime.new(2019, 2, 1)
-          )
-        end
-
-        it "sorts the integrations with the most recently active first so that the UI doesn't need to do it" do
-          expect(Service.find_all.first).to be integration_2
-        end
-      end
-
-      describe "#delete" do
-        subject { Service.delete("Foo", "Bar") }
-
-        context "with webhook data" do
-          before do
-            td.create_pact_with_hierarchy("Foo", "1", "Bar")
-              .create_webhook
-              .create_triggered_webhook
-              .create_webhook_execution
-          end
-
-          it "deletes the webhooks" do
-            expect { subject }.to change { PactBroker::Webhooks::Webhook.count }
-          end
-        end
-
-        context "when the consumer version does not have any other pacts associated with it" do
-          before do
-            td.create_pact_with_hierarchy("Foo", "1", "Bar")
-          end
-
-          it "deletes the consumer version" do
-            expect { subject }.to change { PactBroker::Domain::Version.count }
-          end
-        end
-
-        context "when the consumer version has another pact associated with it" do
-          before do
-            td.create_pact_with_hierarchy("Foo", "1", "Bar")
-              .create_provider
-              .create_pact
-          end
-
-          it "does not delete the consumer version" do
-            expect { subject }.to_not change { PactBroker::Domain::Version.count }
-          end
-        end
-
-        context "when the consumer version has another verification associated with it" do
-          # Foo v1 -> Bar (no verification) - deleted
-          # Baz v2 -> Foo v1                - not deleted
-          before do
-            td.create_pact_with_hierarchy("Foo", "1", "Bar")
-              .create_consumer("Baz")
-              .create_consumer_version("2")
-              .use_provider("Foo")
-              .create_pact
-              .create_verification(provider_version: "1")
-          end
-
-          it "does not delete the consumer version" do
-            expect { subject }.to_not change { PactBroker::Domain::Version.count }
-          end
-        end
-
-        context "when the provider has verifications" do
-          before do
-            td.create_pact_with_hierarchy("Foo", "1", "Bar")
-              .create_verification(provider_version: "2")
-          end
-
-          it "deletes the verifications" do
-            expect { subject }.to change { PactBroker::Domain::Verification.count }
-          end
-        end
-
-        context "with pact versions" do
-          before do
-            td.create_pact_with_hierarchy("Foo", "1", "Bar")
-          end
-
-          it "deletes the pact versions" do
-            expect { subject }.to change { PactBroker::Pacts::PactVersion.count }
-          end
-        end
-
-        context "when the consumer has other providers" do
-          before do
-            td.create_pact_with_hierarchy("Foo", "1", "Bar")
-              .create_provider("Baz")
-              .create_consumer_version("2")
-              .create_pact
-          end
-
-          it "does not delete the consumer" do
-            expect { subject }.to_not change { PactBroker::Domain::Pacticipant.where(name: "Foo").count }
-          end
-        end
-
-        context "when the consumer has other consumers" do
-          before do
-            td.create_pact_with_hierarchy("Foo", "1", "Bar")
-              .create_consumer("Baz")
-              .create_consumer_version("2")
-              .use_provider("Foo")
-              .create_pact
-          end
-
-          it "does not delete the consumer" do
-            expect { subject }.to_not change { PactBroker::Domain::Pacticipant.where(name: "Foo").count }
-          end
-        end
-
-        context "when the consumer does not have other providers or consumers" do
-          before do
-            td.create_pact_with_hierarchy("Foo", "1", "Bar")
-          end
-
-          it "deletes the consumer" do
-            expect { subject }.to change { PactBroker::Domain::Pacticipant.where(name: "Foo").count }
-          end
-        end
-
-        context "when the provider has other consumers" do
-          before do
-            td.create_pact_with_hierarchy("Foo", "1", "Bar")
-              .create_consumer("Baz")
-              .create_consumer_version("2")
-              .create_pact
-          end
-
-          it "does not delete the provider" do
-            expect { subject }.to_not change { PactBroker::Domain::Pacticipant.where(name: "Bar").count }
-          end
-        end
-
-        context "when the provider has other providers" do
-          before do
-            td.create_pact_with_hierarchy("Foo", "1", "Bar")
-              .use_consumer("Bar")
-              .create_consumer_version("2")
-              .create_provider("Baz")
-              .create_pact
-          end
-
-          it "does not delete the provider" do
-            expect { subject }.to_not change { PactBroker::Domain::Pacticipant.where(name: "Bar").count }
-          end
-        end
-
-        context "when the provider does not have other providers or consumers" do
-          before do
-            td.create_pact_with_hierarchy("Foo", "1", "Bar")
-          end
-
-          it "deletes the provider" do
-            expect { subject }.to change { PactBroker::Domain::Pacticipant.where(name: "Bar").count }
-          end
-        end
-
-        context "When a webhook exists between the consumer and another provider" do
-          before do
-            td.create_pact_with_hierarchy("Foo", "1", "Bar")
-              .create_provider("Baz")
-              .create_webhook
-          end
-
-          it "does not delete the consumer" do
-            expect { subject }.to_not change { PactBroker::Domain::Pacticipant.where(name: "Foo").count }
-          end
-        end
-
-        context "When a webhook exists between the provider and another consumer" do
-          before do
-            td.create_pact_with_hierarchy("Foo", "1", "Bar")
-              .create_consumer("Baz")
-              .create_webhook
-          end
-
-          it "does not delete the provider" do
-            expect { subject }.to_not change { PactBroker::Domain::Pacticipant.where(name: "Bar").count }
-          end
-        end
-
-        context "When a pacticipant has labels" do
-          before do
-            td.create_pact_with_hierarchy("Foo", "1", "Bar")
-              .create_label("prod")
-          end
-
-          it "deletes the label" do
-            expect { subject }.to change { PactBroker::Domain::Label.count }
-          end
-
-          it "deletes the pacticipant" do
-            expect { subject }.to change { PactBroker::Domain::Pacticipant.where(name: "Bar").count }
-          end
-        end
-
-        context "When a version has tags" do
-          before do
-            td.create_pact_with_hierarchy("Foo", "1", "Bar")
-              .create_consumer_version_tag("prod")
-          end
-
-          it "deletes the tag" do
-            expect { subject }.to change { PactBroker::Domain::Tag.count }
-          end
-
-          it "deletes the version" do
-            expect { subject }.to change { PactBroker::Domain::Version.count }
-          end
-        end
-
-        context "when a pacticipant has a pact with itself... I wouldn't have believed it unless I'd seen it..." do
-          before do
-            td.create_consumer("Foo")
-              .use_provider("Foo")
-              .create_consumer_version("1")
-              .create_pact
-          end
-
-          it "doesn't blow up" do
-            Service.delete("Foo", "Foo")
-          end
-        end
-
-        context "when the pacticipants are not found for some bizarre reason (I can't see how this can happen, but it has)" do
-          it "raises an error" do
-            expect { Service.delete("Foo", "Bar") }.to raise_error(PactBroker::Error, /found/)
-          end
-        end
-
-        context "when there are deployed versions" do
-          before do
-            td.create_consumer("Foo")
-              .create_consumer_version("1")
-              .create_environment("test")
-              .create_deployed_version_for_consumer_version
-          end
-
-          it "doesn't blow up" do
-            Service.delete("Foo", "Foo")
-          end
-        end
-      end
-
-      describe "delete_all" do
-        before do
-          td.create_everything_for_an_integration
-        end
-
-        it "doesn't blow up" do
-          Service.delete_all
-          expect(PactBroker::Domain::Pacticipant.count).to be 0
-        end
-      end
-    end
-  end
-end

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

@@ -1,124 +0,0 @@
-require "spec_helper"
-require "pact_broker/labels/repository"
-
-module PactBroker
-  module Labels
-    describe Repository do
-
-      describe ".find" do
-
-        let(:pacticipant_name) { "foo" }
-        let(:label_name) { "ios" }
-
-        subject { Repository.new }
-        let(:options) { {pacticipant_name: pacticipant_name, label_name: label_name} }
-        let(:find_label) { subject.find options }
-
-        let!(:test_data_builder) do
-          TestDataBuilder.new
-            .create_pacticipant("wiffle")
-            .create_label(label_name)
-            .create_pacticipant(pacticipant_name)
-            .create_label("wrong label")
-        end
-
-        context "when the label exists" do
-
-          before do
-            test_data_builder.create_label(label_name)
-          end
-
-          it "returns the label" do
-            expect(find_label.name).to eq label_name
-            expect(find_label.pacticipant.name).to eq pacticipant_name
-            expect(find_label.created_at).to be_datey
-            expect(find_label.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, label_name: label_name.upcase} }
-
-            it "returns the label" do
-              expect(find_label).to_not be nil
-              expect(find_label.name).to eq label_name
-            end
-          end
-
-          context "when case sensitivity is turned on and a label name with different case is used" do
-            before do
-              allow(PactBroker.configuration).to receive(:use_case_sensitive_resource_names).and_return(true)
-            end
-
-            let(:options) { {pacticipant_name: pacticipant_name, label_name: label_name.upcase} }
-
-            it "returns nil" do
-              expect(find_label).to be nil
-            end
-          end
-
-          context "when case sensitivity is turned on and a pacticipant name with different case is used" do
-            before do
-              allow(PactBroker.configuration).to receive(:use_case_sensitive_resource_names).and_return(true)
-            end
-
-            let(:options) { {pacticipant_name: pacticipant_name.upcase, label_name: label_name} }
-
-            it "returns nil" do
-              expect(find_label).to be nil
-            end
-          end
-        end
-
-        context "when the tag does not exist" do
-          it "returns nil" do
-            expect(find_label).to be_nil
-          end
-        end
-      end
-
-      describe "delete" do
-        let(:pacticipant_name) { "foo" }
-        let(:label_name) { "ios" }
-
-        let!(:pacticipant) do
-          TestDataBuilder.new
-            .create_pacticipant("Ignore")
-            .create_label("ios")
-            .create_pacticipant(pacticipant_name)
-            .create_label("ios")
-            .create_label("bar")
-            .and_return(:pacticipant)
-        end
-        let(:options) { {pacticipant_name: pacticipant_name, label_name: label_name} }
-
-        subject { Repository.new.delete(options) }
-
-        it "deletes the label" do
-          expect{ subject }.to change { PactBroker::Domain::Label.count }.by(-1)
-        end
-      end
-
-      describe "delete_by_pacticipant_id" do
-        let!(:pacticipant) do
-          TestDataBuilder.new
-            .create_pacticipant("Ignore")
-            .create_label("ios")
-            .create_pacticipant("Foo")
-            .create_label("ios")
-            .create_label("bar")
-            .and_return(:pacticipant)
-        end
-
-        subject { Repository.new.delete_by_pacticipant_id(pacticipant.id) }
-
-        it "deletes the labels" do
-          expect{ subject }.to change { PactBroker::Domain::Label.count }.by(-2)
-        end
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-require "pact_broker/labels/service"
-
-module PactBroker
-  module Labels
-    describe Service do
-      let(:pacticipant_name) { "foo" }
-      let(:label_name) { "ios" }
-      let(:options) { {pacticipant_name: pacticipant_name, label_name: label_name}}
-
-      describe ".create" do
-        subject { Service.create(options) }
-
-        # Naughty integration test... didn't seem much point unit testing this
-        it "creates the new tag" do
-          expect(subject.name).to eq label_name
-          expect(subject.pacticipant.name).to eq pacticipant_name
-        end
-      end
-
-      describe "delete" do
-        it "calls delete on the label repository" do
-          allow_any_instance_of(Labels::Repository).to receive(:delete).with(options)
-          Service.delete(options)
-        end
-      end
-    end
-  end
-end

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

@@ -1,100 +0,0 @@
-require "pact_broker/matrix/aggregated_row"
-
-module PactBroker
-  module Matrix
-    describe AggregatedRow do
-      describe "latest_verification_for_pseudo_branch" do
-        let(:row_1) do
-          instance_double("PactBroker::Matrix::HeadRow",
-            consumer_name: "Foo",
-            provider_name: "Bar",
-            verification: verification_1,
-            latest_verification_for_consumer_version_tag: tag_verification_1,
-            consumer_version_tag_name: consumer_version_tag_name_1)
-        end
-        let(:row_2) do
-          instance_double("PactBroker::Matrix::HeadRow",
-            verification: verification_2,
-            latest_verification_for_consumer_version_tag: tag_verification_2,
-            consumer_version_tag_name: consumer_version_tag_name_2)
-        end
-        let(:verification_1) { instance_double("PactBroker::Domain::Verification", id: 1) }
-        let(:verification_2) { instance_double("PactBroker::Domain::Verification", id: 2) }
-        let(:tag_verification_1) { instance_double("PactBroker::Domain::Verification", id: 3) }
-        let(:tag_verification_2) { instance_double("PactBroker::Domain::Verification", id: 4) }
-        let(:consumer_version_tag_name_1) { "master" }
-        let(:consumer_version_tag_name_2) { "prod" }
-        let(:rows) { [row_1, row_2] }
-        let(:aggregated_row) { AggregatedRow.new(rows) }
-
-        subject { aggregated_row.latest_verification_for_pseudo_branch }
-
-        context "when the rows have verifications" do
-          it "returns the verification with the largest id" do
-            expect(subject).to be verification_2
-          end
-        end
-
-        context "when the rows do not have verifications, but there are a previous verifications for a pacts with the same tag" do
-          let(:verification_1) { nil }
-          let(:verification_2) { nil }
-
-          it "returns the verification for the previous pact that has the largest id" do
-            expect(subject).to be tag_verification_2
-          end
-        end
-
-        context "when there is no verification for any of the rows or any of the pacts with the same tag" do
-          let(:verification_1) { nil }
-          let(:verification_2) { nil }
-          let(:tag_verification_1) { nil }
-          let(:tag_verification_2) { nil }
-
-          context "when one of the rows is the overall latest" do
-            let(:consumer_version_tag_name_1) { nil }
-            let(:overall_latest_verification) { instance_double("PactBroker::Domain::Verification", id: 1) }
-            before do
-              allow(row_1).to receive(:latest_verification_for_consumer_and_provider).and_return(overall_latest_verification)
-            end
-
-            it "looks up the overall latest verification" do
-              expect(row_1).to receive(:latest_verification_for_consumer_and_provider)
-              subject
-            end
-
-            it "returns the overall latest verification" do
-              expect(subject).to be overall_latest_verification
-            end
-          end
-
-          context "when none of the rows is not the overall latest (they are all the latest with a tag)" do
-            it "returns nil" do
-              expect(subject).to be nil
-            end
-          end
-        end
-      end
-
-      describe "latest_verification_for_pact_version" do
-        let(:row_1) do
-          instance_double("PactBroker::Matrix::HeadRow",
-            verification: verification_1)
-        end
-        let(:row_2) do
-          instance_double("PactBroker::Matrix::HeadRow",
-            verification: verification_2)
-        end
-        let(:verification_1) { instance_double("PactBroker::Domain::Verification", id: 2) }
-        let(:verification_2) { instance_double("PactBroker::Domain::Verification", id: 1) }
-        let(:rows) { [row_1, row_2] }
-        let(:aggregated_row) { AggregatedRow.new(rows) }
-
-        subject { aggregated_row.latest_verification_for_pact_version }
-
-        it "returns the verification with the largest id" do
-          expect(subject.id).to eq 2
-        end
-      end
-    end
-  end
-end

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

@@ -1,72 +0,0 @@
-require "pact_broker/matrix/can_i_deploy_query_schema"
-
-module PactBroker
-  module Api
-    module Contracts
-      describe CanIDeployQuerySchema do
-        subject { CanIDeployQuerySchema.call(params) }
-
-        context "with valid params" do
-          let(:params) do
-            {
-              pacticipant: "foo",
-              version: "1",
-              to: "prod"
-            }
-          end
-
-          it { is_expected.to be_empty }
-        end
-
-        context "with a to tag and an environment specified" do
-          before do
-            allow(PactBroker::Deployments::EnvironmentService).to receive(:find_by_name).and_return(double("environment"))
-          end
-
-          let(:params) do
-            {
-              pacticipant: "foo",
-              version: "1",
-              environment: "prod",
-              to: "prod"
-            }
-          end
-
-          it { is_expected.to_not be_empty }
-        end
-
-        context "when the environment does exist" do
-          before do
-            allow(PactBroker::Deployments::EnvironmentService).to receive(:find_by_name).and_return(double("environment"))
-          end
-
-          let(:params) do
-            {
-              pacticipant: "foo",
-              version: "1",
-              environment: "prod"
-            }
-          end
-
-          it { is_expected.to be_empty }
-        end
-
-        context "when the environment does not exist" do
-          before do
-            allow(PactBroker::Deployments::EnvironmentService).to receive(:find_by_name).and_return(nil)
-          end
-
-          let(:params) do
-            {
-              pacticipant: "foo",
-              version: "1",
-              environment: "prod"
-            }
-          end
-
-          its([:environment, 0]) { is_expected.to eq "environment with name 'prod' does not exist" }
-        end
-      end
-    end
-  end
-end