pact_broker 2.89.1 → 2.90.0

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

@@ -1,74 +0,0 @@
-require "pact_broker/matrix/row"
-
-module PactBroker
-  module Matrix
-    describe Row do
-      let(:td) { TestDataBuilder.new }
-
-      describe "latest_verification_for_consumer_and_provider" do
-        before do
-          td.create_pact_with_hierarchy("Foo", "1", "Bar")
-            .create_verification(provider_version: "9")
-            .create_consumer_version("2")
-            .create_consumer_version_tag("prod")
-            .create_pact
-            .create_verification(provider_version: "10")
-            .create_consumer("Wiffle")
-            .create_consumer_version("4")
-            .create_pact
-            .create_verification(provider_version: "11")
-        end
-
-        subject { Row.where(consumer_name: "Foo", provider_name: "Bar").all.collect(&:latest_verification_for_consumer_and_provider) }
-
-        it "returns the latest verification for the consumer and provider" do
-          expect(subject.collect(&:provider_version_number)).to eq ["10", "10"]
-        end
-      end
-
-      describe "<=>" do
-        let(:row_1) do
-          Row.new(
-            consumer_name: "A",
-            consumer_version_order: 1,
-            pact_revision_number: 1,
-            provider_name: "B",
-            provider_version_order: 1,
-            verification_id: 1
-          )
-        end
-        let(:row_2) do
-          Row.new(
-            consumer_name: "A",
-            consumer_version_order: 1,
-            pact_revision_number: 1,
-            provider_name: "B",
-            provider_version_order: 1,
-            verification_id: 2
-          )
-        end
-
-        it "sorts" do
-          expect([row_1, row_2].sort).to eq [row_2, row_1]
-        end
-
-        context "with a nil column" do
-          let(:row_2) do
-            Row.new(
-              consumer_name: "A",
-              consumer_version_order: 1,
-              pact_revision_number: 1,
-              provider_name: "B",
-              provider_version_order: nil,
-              verification_id: nil
-            )
-          end
-
-          it "sorts the rows first" do
-            expect([row_1, row_2].sort).to eq [row_2, row_1]
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,200 +0,0 @@
-require "pact_broker/matrix/service"
-require "pact_broker/matrix/unresolved_selector"
-
-module PactBroker
-  module Matrix
-    describe Service do
-      describe "validate_selectors" do
-        before do
-          allow(PactBroker::Deployments::EnvironmentService).to receive(:find_by_name).and_return(environment)
-        end
-        let(:environment) { double("environment") }
-
-        subject { Service.validate_selectors(selectors, options) }
-
-        let(:options) { { limit: "1" } }
-
-        context "when there are no selectors" do
-          let(:selectors) { [] }
-
-          it "returns error messages" do
-            expect(subject.first).to eq "Please provide 1 or more version selectors."
-          end
-        end
-
-        context "when the pacticipant does not exist" do
-          let(:selectors) { [{ pacticipant_name: "Foo", pacticipant_version_number: "1" }] }
-
-          it "returns error messages" do
-            expect(subject.first).to eq "Pacticipant Foo not found"
-          end
-        end
-
-        context "when the pacticipant name is not specified" do
-          let(:selectors) { [{ pacticipant_name: nil, pacticipant_version_number: "1" }] }
-
-          it "returns error messages" do
-            expect(subject.first).to eq "Please specify the pacticipant name"
-          end
-        end
-
-        context "when the pacticipant version is not specified" do
-          before do
-            td.create_pacticipant("Foo")
-              .create_version("1")
-              .create_pacticipant("Bar")
-              .create_version("2")
-          end
-
-          let(:selectors) { [ UnresolvedSelector.new(pacticipant_name: "Foo", pacticipant_version_number: nil ), UnresolvedSelector.new(pacticipant_name: "Bar", pacticipant_version_number: nil) ] }
-
-          it "returns no error messages" do
-            expect(subject).to eq []
-          end
-        end
-
-        context "when the latest_tag is used instead of a version" do
-          before do
-            td.create_pacticipant("Foo")
-              .create_version("1")
-              .create_tag("prod")
-              .create_pacticipant("Bar")
-              .create_version("2")
-          end
-
-          let(:selectors) { [ UnresolvedSelector.new(pacticipant_name: "Foo", latest_tag: "prod"), UnresolvedSelector.new(pacticipant_name: "Bar", pacticipant_version_number: "2")] }
-
-          context "when there is a version for the tag" do
-            it "returns no error messages" do
-              expect(subject).to eq []
-            end
-          end
-        end
-
-        context "when the latest is used as well as a version" do
-          before do
-            td.create_pacticipant("Foo")
-              .create_version("1")
-              .create_tag("prod")
-              .create_pacticipant("Bar")
-              .create_version("2")
-          end
-
-          let(:selectors) { [ UnresolvedSelector.new(pacticipant_name: "Foo", pacticipant_version_number: "1", latest: true), UnresolvedSelector.new(pacticipant_name: "Bar", pacticipant_version_number: "2")] }
-
-          it "returns an error message" do
-            expect(subject).to eq ["A version number and latest flag cannot both be specified for Foo"]
-          end
-        end
-
-        context "when both a to tag and an environment are specified" do
-          let(:selectors) { [] }
-
-          let(:options) do
-            {
-              tag: "prod",
-              environment_name: "prod"
-            }
-          end
-
-          it "returns an error message" do
-            expect(subject.last).to include "Cannot specify both"
-          end
-        end
-
-        context "when both latest=true and an environment are specified" do
-          let(:selectors) { [] }
-
-          let(:options) do
-            {
-              latest: true,
-              environment_name: "prod"
-            }
-          end
-
-          it "returns an error message" do
-            expect(subject.last).to include "Cannot specify both latest"
-          end
-        end
-
-        context "when the environment does not exist" do
-          let(:selectors) { [] }
-          let(:environment) { nil }
-
-          let(:options) do
-            {
-              environment_name: "prod"
-            }
-          end
-
-          it "returns an error message" do
-            expect(subject.last).to include "Environment with name 'prod' does not exist"
-          end
-        end
-
-        context "when a pacticipant to ignore is missing a name" do
-          let(:selectors) { [UnresolvedSelector.new(pacticipant_name: "Foo", pacticipant_version_number: "1")] }
-
-          let(:options) do
-            {
-              ignore_selectors: [UnresolvedSelector.new(pacticipant_version_number: "1")]
-            }
-          end
-
-          it "returns an error message" do
-            expect(subject.last).to include "Please specify the pacticipant name to ignore"
-          end
-        end
-
-        context "with an invalid limit" do
-          let(:options) { { limit: "limit" } }
-          let(:selectors) { [] }
-
-          it "returns an error message" do
-            expect(subject.last).to include "The limit"
-          end
-        end
-      end
-
-      describe "find_for_consumer_and_provider_with_tags integration test" do
-
-        let(:params) do
-          {
-            consumer_name: "consumer",
-            provider_name: "provider",
-            tag: "prod",
-            provider_tag: "master"
-          }
-        end
-
-        subject { Service.find_for_consumer_and_provider_with_tags(params) }
-
-        context "when the specified row exists" do
-          before do
-            td.create_pact_with_hierarchy("consumer", "1", "provider")
-              .create_consumer_version_tag("prod")
-              .create_verification(provider_version: "2")
-              .use_provider_version("2")
-              .create_provider_version_tag("master")
-              .create_verification(provider_version: "3", number: 2)
-              .create_consumer_version("2")
-              .create_pact
-          end
-
-          it "returns the row" do
-            expect(subject.consumer_name).to eq "consumer"
-            expect(subject.provider_name).to eq "provider"
-            expect(subject.consumer_version_number).to eq "1"
-            expect(subject.provider_version_number).to eq "2"
-          end
-        end
-
-        context "when the specified row does not exist" do
-          it "returns nil" do
-            expect(subject).to be nil
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/messages_spec.rb

@@ -1,29 +0,0 @@
-require "spec_helper"
-require "pact_broker/messages"
-
-module PactBroker
-  module Messages
-    describe "#potential_duplicate_pacticipant_message" do
-      let(:new_name) { "Contracts" }
-      let(:fred) { double("Contracts Service", name: "Contracts Service") }
-      let(:frederich) { double("Accepted Contracts", name: "Accepted Contracts") }
-      let(:potential_duplicate_pacticipants) { [fred, frederich]}
-
-      let(:expected_message) { String.new <<-EOS
-This is the first time a pact has been published for "Contracts".
-The name "Contracts" is very similar to the following existing consumers/providers:
-* Contracts Service
-* Accepted Contracts
-If you meant to specify one of the above names, please correct the pact configuration, and re-publish the pact.
-If the pact is intended to be for a new consumer or provider, please manually create "Contracts" using the following command, and then re-publish the pact:
-$ curl -v -XPOST -H "Content-Type: application/json" -d "{\\\"name\\\": \\\"Contracts\\\"}" http://example.org/pacticipants
-EOS
-      }
-      subject { Messages.potential_duplicate_pacticipant_message new_name, potential_duplicate_pacticipants, "http://example.org" }
-
-      it "returns a message" do
-        expect(subject).to start_with expected_message
-      end
-    end
-  end
-end

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

@@ -1,131 +0,0 @@
-require "pact_broker/metrics/service"
-
-module PactBroker
-  module Metrics
-    module Service
-      describe "#metrics" do
-        subject { Service.metrics }
-
-        describe "pacticipants" do
-          before do
-            td.create_consumer("Foo")
-              .create_consumer("Bar", main_branch: "foo")
-          end
-
-          its([:pacticipants, :count]) { is_expected.to eq 2 }
-          its([:pacticipants, :withMainBranchSetCount]) { is_expected.to eq 1 }
-        end
-
-        describe "pacticipant versions" do
-          before do
-            td.create_consumer("Foo")
-              .create_consumer_version("2")
-              .create_consumer_version("3", branch: "main")
-          end
-
-          its([:pacticipantVersions, :count]) { is_expected.to eq 2 }
-          its([:pacticipantVersions, :withBranchCount]) { is_expected.to eq 1 }
-          its([:pacticipantVersions, :withUserCreatedBranchCount]) { is_expected.to eq 1 }
-        end
-
-        describe "environments, deployed versions, released versions" do
-          before do
-            td.create_environment("test")
-              .create_consumer("Foo")
-              .create_consumer_version("2")
-              .create_deployed_version_for_consumer_version(currently_deployed: false)
-              .create_consumer_version("3")
-              .create_deployed_version_for_consumer_version
-              .create_consumer_version("4")
-              .create_released_version_for_consumer_version(currently_supported: false)
-              .create_consumer_version("5")
-              .create_released_version_for_consumer_version
-              .create_consumer_version("6")
-              .create_released_version_for_consumer_version
-          end
-
-          its([:environments, :count]) { is_expected.to eq 1 }
-          its([:deployedVersions, :count]) { is_expected.to eq 2 }
-          its([:deployedVersions, :currentlyDeployedCount]) { is_expected.to eq 1 }
-          its([:deployedVersions, :userCreatedCount]) { is_expected.to eq 2 }
-          its([:releasedVersions, :count]) { is_expected.to eq 3 }
-          its([:releasedVersions, :currentlySupportedCount]) { is_expected.to eq 2 }
-        end
-
-        describe "interactions latestCount" do
-          before do
-            td.create_consumer
-              .create_provider
-              .create_consumer_version
-              .create_pact(json_content: { interactions: [1, 2], messages: [1] }.to_json)
-              .create_consumer
-              .create_provider
-              .create_consumer_version
-              .create_pact(json_content: { interactions: [1, 2], messages: [1] }.to_json)
-              .create_consumer
-              .create_provider
-              .create_consumer_version
-              .create_pact(json_content: { foo: "bar" }.to_json)
-            PactBroker::Pacts::PactVersion.dataset.update(interactions_count: nil, messages_count: nil)
-          end
-
-          it "includes a count of the number of interactions in the overall latest pacts" do
-            expect(subject[:interactions]).to eq({
-              latestInteractionsCount: 4,
-              latestMessagesCount: 2,
-              latestInteractionsAndMessagesCount: 6
-            })
-          end
-        end
-
-        describe "verificationResultsPerPactVersion" do
-          before do
-            td.create_pact_with_hierarchy
-              .create_consumer_version_tag("prod")
-              .comment("this pact version will have 2 verifications")
-              .create_verification
-              .create_verification(number: 2, tag_names: ["main"])
-              .revise_pact
-              .comment("this pact version will have 1 verification")
-              .create_verification
-              .create_consumer_version
-              .create_consumer_version_tag("main")
-              .create_pact
-              .comment("this pact will have 1 verification")
-              .create_verification
-              .create_consumer_version
-              .create_consumer_version_tag("main")
-              .create_pact
-              .comment("this pact will have 1 verification")
-              .create_verification
-          end
-
-          let(:distribution) { subject[:verificationResultsPerPactVersion][:distribution] }
-
-          it "returns a distribution of verifications per pact version" do
-            expect(distribution).to eq(1 => 3, 2 => 1)
-          end
-        end
-
-        describe "pactRevisionsPerPactPublication" do
-          before do
-            td.create_pact_with_hierarchy
-              .comment("this consumer version will have 3 revisions")
-              .revise_pact
-              .revise_pact
-              .create_consumer_version
-              .create_pact
-              .comment("this consumer version will have 1 revision")
-              .revise_pact
-          end
-
-          let(:distribution) { subject[:pactRevisionsPerConsumerVersion][:distribution] }
-
-          it "returns a distribution of pact revisions per consumer version" do
-            expect(distribution).to eq(2 => 1, 3 => 1)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,63 +0,0 @@
-require "spec_helper"
-require "pact_broker/pacticipants/find_potential_duplicate_pacticipant_names"
-
-module PactBroker
-
-  module Pacticipants
-
-    describe FindPotentialDuplicatePacticipantNames do
-
-      describe "split" do
-        SPLIT_TEST_CASES = [
-          ["a-foo-service", ["a", "foo", "service"]],
-          ["a_foo_service", ["a", "foo", "service"]],
-          ["FooAService", ["foo", "a", "service"]],
-          ["Foo A Service", ["foo", "a", "service"]],
-          ["S3 Bucket Service", ["s3", "bucket", "service"]],
-          ["S3BucketService", ["s3", "bucket", "service"]],
-          ["S3-Bucket-Service", ["s3", "bucket", "service"]],
-          ["S3_Bucket_Service", ["s3", "bucket", "service"]],
-        ]
-
-        SPLIT_TEST_CASES.each do | input, output |
-          it "splits #{input} into #{output.inspect}" do
-            expect(FindPotentialDuplicatePacticipantNames.split(input)).to eq output
-          end
-        end
-      end
-
-      describe ".call" do
-
-        subject { FindPotentialDuplicatePacticipantNames.call(new_name, existing_names) }
-
-        CALL_TEST_CASES = [
-          ["accounts", ["accounts-receivable"], []],
-          ["Accounts", ["Accounts Receivable"], []],
-          ["The Accounts", ["Accounts"], []],
-          ["accounts", ["account-service", "account-api", "account-provider"], ["account-service", "account-api", "account-provider"]],
-          ["accounts-api", ["account-service", "account-provider"], ["account-service", "account-provider"]],
-          ["Contracts Service", ["Contracts Service", "Contracts", "Something"], []],
-          ["Contracts", ["Contract Service", "Contacts", "Something"], ["Contract Service"]],
-          ["Contracts Service", ["Contract", "Contacts", "Something"], ["Contract"]],
-          ["Contract Service", ["Contracts", "Contacts", "Something"], ["Contracts"]],
-          ["Contract Service", ["contracts", "Contacts", "Something"], ["contracts"]],
-          ["ContractService", ["Contracts Service", "Contacts", "Something"], ["Contracts Service"]],
-          ["Contract Service", ["ContractsService", "Contacts", "Something"], ["ContractsService"]],
-          ["Contract_Service", ["ContractsService", "Contracts Service", "contracts-service", "Contacts", "Something"], ["ContractsService", "Contracts Service", "contracts-service"]]
-        ]
-
-        CALL_TEST_CASES.each do | the_new_name, the_existing_names, the_expected_duplicates |
-          context "when the new name is #{the_new_name} and the existing names are #{the_existing_names.inspect}" do
-            let(:new_name) { the_new_name }
-            let(:existing_names) { the_existing_names }
-            let(:expected_duplicates) { the_expected_duplicates}
-
-            it "returns #{the_expected_duplicates.inspect} as the potential duplicates" do
-              expect(subject).to eq expected_duplicates
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-require "pact_broker/pacticipants/generate_display_name"
-
-module PactBroker
-  module Pacticipants
-    describe GenerateDisplayName do
-      describe ".call" do
-        TEST_CASES = {
-          "foo" => "Foo",
-          "MyService" => "My Service",
-          "my-service" => "My Service",
-          "my_service" => "My Service",
-          "my service" => "My Service",
-          "ABCService" => "ABC Service",
-          "A4Service" => "A4 Service",
-          "SNSPactEventConsumer" => "SNS Pact Event Consumer",
-          "AWSSummiteerWeb" => "AWS Summiteer Web",
-          "Beer-Consumer" => "Beer Consumer",
-          "foo.pretend-consumer" => "Foo Pretend Consumer",
-          "Client-XX" => "Client XX",
-          "providerJSWorkshop" => "Provider JS Workshop",
-          "e2e Provider Example" => "E2e Provider Example",
-          "MP - Our Provider" => "MP - Our Provider",
-          "PoC - Pact-broker-consumer" => "PoC - Pact Broker Consumer",
-          "QB-DATABASE Service" => "QB DATABASE Service",
-          "Support Species App (Provider)" => "Support Species App (Provider)",
-          9 => "9",
-          "" => "",
-          nil => nil
-        }
-
-        TEST_CASES.each do | name, expected_display_name |
-          it "converts #{name.inspect} to #{expected_display_name.inspect}" do
-            expect(GenerateDisplayName.call(name)).to eq expected_display_name
-          end
-        end
-      end
-    end
-  end
-end