pact_broker 2.89.1 → 2.90.0

data/spec/lib/pact_broker/api/decorators/pacticipant_decorator_spec.rb

@@ -1,89 +0,0 @@
-require "spec_helper"
-require "pact_broker/api/decorators/pacticipant_decorator"
-require "pact_broker/domain/pacticipant"
-
-module PactBroker
-  module Api
-    module Decorators
-      describe PacticipantDecorator do
-        describe "from_json" do
-          let(:pacticipant) { OpenStruct.new }
-          let(:decorator) { PacticipantDecorator.new(pacticipant) }
-          let(:hash) do
-            {
-              name: "Foo",
-              mainBranch: "main"
-            }
-          end
-
-          subject { decorator.from_json(hash.to_json) }
-
-          its(:name) { is_expected.to eq "Foo" }
-          its(:main_branch) { is_expected.to eq "main" }
-        end
-        describe "to_json" do
-          let(:pacticipant) do
-            td.create_pacticipant("Name")
-              .create_label("foo")
-              .and_return(:pacticipant)
-          end
-
-          let(:created_at) { Time.new(2014, 3, 4) }
-          let(:updated_at) { Time.new(2014, 3, 5) }
-          let(:base_url) { "http://example.org" }
-
-          before do
-            pacticipant.created_at = created_at
-            pacticipant.updated_at = updated_at
-            allow_any_instance_of(PacticipantDecorator).to receive(:templated_tag_url_for_pacticipant).and_return("version_tag_url")
-            allow_any_instance_of(PacticipantDecorator).to receive(:templated_version_url_for_pacticipant).and_return("version_url")
-          end
-
-          subject { JSON.parse PacticipantDecorator.new(pacticipant).to_json(user_options: { base_url: base_url }), symbolize_names: true }
-
-          it "includes timestamps" do
-            expect(subject[:createdAt]).to eq FormatDateTime.call(created_at)
-            expect(subject[:updatedAt]).to eq FormatDateTime.call(updated_at)
-          end
-
-          it "includes embedded labels" do
-            expect(subject[:_embedded][:labels].first).to include name: "foo"
-            expect(subject[:_embedded][:labels].first[:_links][:self][:href]).to match %r{http://example.org/.*foo}
-          end
-
-          it "includes a relation for a version tag" do
-            expect_any_instance_of(PacticipantDecorator).to receive(:templated_tag_url_for_pacticipant).with("Name", base_url)
-            expect(subject[:_links][:'pb:version-tag'][:href]).to eq "version_tag_url"
-          end
-
-          it "includes a relation for a version" do
-            expect_any_instance_of(PacticipantDecorator).to receive(:templated_version_url_for_pacticipant).with("Name", base_url)
-            expect(subject[:_links][:'pb:version'][:href]).to eq "version_url"
-          end
-
-          context "when there is a latest_version" do
-            before { td.create_version("1.2.107") }
-            it "includes an embedded latestVersion" do
-              expect(subject[:_embedded][:latestVersion]).to include number: "1.2.107"
-            end
-
-            it "includes an embedded latest-version for backwards compatibility" do
-              expect(subject[:_embedded][:'latest-version']).to include number: "1.2.107"
-            end
-
-            it "includes a deprecation warning" do
-              expect(subject[:_embedded][:'latest-version']).to include title: "DEPRECATED - please use latestVersion"
-            end
-          end
-
-          context "when there is no latest_version" do
-            it "doesn't blow up" do
-              expect(subject[:_embedded]).to_not have_key(:latestVersion)
-              expect(subject[:_embedded]).to_not have_key(:'latest-version')
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/api/decorators/pacts_for_verification_query_decorator_spec.rb

@@ -1,175 +0,0 @@
-require "pact_broker/api/decorators/pacts_for_verification_query_decorator"
-
-module PactBroker
-  module Api
-    module Decorators
-      describe PactsForVerificationQueryDecorator do
-
-        let(:provider_version_tags) { %w[dev] }
-        let(:provider_version_branch) { "main" }
-
-        subject { PactsForVerificationQueryDecorator.new(OpenStruct.new).from_hash(params)  }
-
-        context "when parsing JSON params" do
-          let(:params) do
-            {
-              "providerVersionTags" => provider_version_tags,
-              "providerVersionBranch" => provider_version_branch,
-              "consumerVersionSelectors" => consumer_version_selectors
-            }
-          end
-
-          let(:consumer_version_selectors) do
-            [{ "tag" => "dev", "ignored" => "foo", "latest" => true }]
-          end
-
-          it "parses the consumer_version_selectors to a Selectors collection" do
-            expect(subject.consumer_version_selectors).to be_a(PactBroker::Pacts::Selectors)
-          end
-
-          it "parses the provider version branch" do
-            expect(subject.provider_version_branch).to eq "main"
-          end
-
-          context "when latest is not specified" do
-            let(:consumer_version_selectors) do
-              [{ "tag" => "dev" }]
-            end
-
-            it "defaults to nil" do
-              expect(subject.consumer_version_selectors.first.latest).to be nil
-            end
-          end
-
-          context "with a fallback" do
-            let(:consumer_version_selectors) do
-              [{ "tag" => "feat-x", "fallbackTag" => "dev", "latest" => true }]
-            end
-
-            it "sets the fallback" do
-              expect(subject.consumer_version_selectors.first.fallback_tag).to eq "dev"
-            end
-          end
-
-          it "parses the latest as a boolean" do
-            expect(subject.consumer_version_selectors.first).to eq PactBroker::Pacts::Selector.new(tag: "dev", latest: true)
-          end
-
-          context "when there are no consumer_version_selectors" do
-            let(:params) { {} }
-
-            it "returns an empty array" do
-              expect(subject.consumer_version_selectors).to eq PactBroker::Pacts::Selectors.new
-            end
-          end
-
-          context "when there are no provider_version_tags" do
-            let(:params) { {} }
-
-            it "returns an empty array" do
-              expect(subject.provider_version_tags).to eq []
-            end
-          end
-
-          context "when a branch is specified but the latest is not specified" do
-            let(:consumer_version_selectors) do
-              [{ "branch" => "main" }]
-            end
-
-            it "defaults the latest to true" do
-              expect(subject.consumer_version_selectors.first.branch).to eq "main"
-              expect(subject.consumer_version_selectors.first.latest).to be true
-            end
-          end
-
-          context "when an environment is specified" do
-            let(:consumer_version_selectors) do
-              [{ "environment" => "prod" }]
-            end
-
-            it "sets the environment" do
-              expect(subject.consumer_version_selectors.first.environment_name).to eq "prod"
-            end
-          end
-
-          context "when an environment is specified and released is true" do
-            let(:consumer_version_selectors) do
-              [{ "environment" => "prod", "released" => true }]
-            end
-
-            it "sets the currently_supported to true" do
-              expect(subject.consumer_version_selectors.first.environment_name).to eq "prod"
-              expect(subject.consumer_version_selectors.first.currently_supported).to be true
-            end
-          end
-
-          context "when an environment is specified and deployed is true" do
-            let(:consumer_version_selectors) do
-              [{ "environment" => "prod", "deployed" => true }]
-            end
-
-            it "sets the currently_deployed to true" do
-              expect(subject.consumer_version_selectors.first.environment_name).to eq "prod"
-              expect(subject.consumer_version_selectors.first.currently_deployed).to be true
-            end
-          end
-
-          context "when deployedOrReleased is set to true" do
-            let(:consumer_version_selectors) do
-              [{ "deployedOrReleased" => true }]
-            end
-
-            it "creates two selectors - one for deployed and one for released" do
-              expect(subject.consumer_version_selectors.size).to eq 2
-              expect(subject.consumer_version_selectors.first).to eq PactBroker::Pacts::Selector.for_currently_deployed
-              expect(subject.consumer_version_selectors.last).to eq PactBroker::Pacts::Selector.for_currently_supported
-            end
-          end
-
-          context "when matchingBranch is true" do
-            let(:consumer_version_selectors) do
-              [{ "matchingBranch" => true }]
-            end
-
-            it "sets the branch and latest and matching branch properties" do
-              expect(subject.consumer_version_selectors).to contain_exactly(have_attributes(branch: "main", matching_branch: true, latest: true))
-            end
-          end
-        end
-
-        context "when parsing query string params" do
-          let(:params) do
-            {
-              "provider_version_tags" => provider_version_tags,
-              "consumer_version_selectors" => consumer_version_selectors
-            }
-          end
-
-          let(:consumer_version_selectors) do
-            [{ "tag" => "dev", "latest" => "true" }]
-          end
-
-          it "parses the provider_version_tags" do
-            expect(subject.provider_version_tags).to eq provider_version_tags
-          end
-
-          it "parses a string 'latest' to a boolean" do
-            expect(subject.consumer_version_selectors.first).to eq PactBroker::Pacts::Selector.new(tag: "dev", latest: true)
-          end
-        end
-
-        context "when specifying include_wip_pacts_since" do
-          let(:params) do
-            {
-              "include_wip_pacts_since" => "2013-02-13T20:04:45.000+11:00"
-            }
-          end
-
-          it "parses the date" do
-            expect(subject.include_wip_pacts_since).to eq DateTime.parse("2013-02-13T20:04:45.000+11:00")
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/api/decorators/provider_pacts_decorator_spec.rb

@@ -1,58 +0,0 @@
-require "pact_broker/api/decorators/provider_pacts_decorator"
-
-module PactBroker
-  module Api
-    module Decorators
-      describe ProviderPactsDecorator do
-
-        let(:pacts) { [pact]}
-        let(:pact) do
-          double("pact", name: "Pact name", consumer_name: "Foo")
-        end
-        let(:user_options) do
-          {
-            base_url: "http://example.org",
-            resource_url: "http://example.org/provider-pacts",
-            title: "title",
-            provider_name: "foo"
-          }
-        end
-
-        before do
-          allow_any_instance_of(ProviderPactsDecorator).to receive(:pact_url).and_return("pact_url")
-        end
-
-        subject { JSON.parse ProviderPactsDecorator.new(pacts).to_json(user_options: user_options), symbolize_names: true }
-
-        let(:expected) do
-          {
-            :_links => {
-              :self=> {
-                :href=> "http://example.org/provider-pacts",
-                :title => "title"
-              },
-              :"pb:provider" => {
-                :href => "http://example.org/pacticipants/foo",
-                :name => "foo"
-              },
-              :"pb:pacts" =>[{
-                :href => "pact_url",
-                :title => "Pact name",
-                :name => "Foo" }],
-              :pacts => [{
-                :href => "pact_url",
-                :title => "DEPRECATED - please use the pb:pacts relation. Pact name",
-                :name => "Foo"
-                }
-              ]
-            }
-          }
-        end
-
-        it "matches the expected JSON" do
-          expect(subject).to match_pact(expected)
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/api/decorators/publish_contracts_results_decorator_spec.rb

@@ -1,53 +0,0 @@
-require "pact_broker/api/decorators/publish_contracts_results_decorator"
-require "pact_broker/contracts/contracts_publication_results"
-require "pact_broker/contracts/notice"
-
-module PactBroker
-  module Api
-    module Decorators
-      describe PublishContractsResultsDecorator do
-        describe "to_hash" do
-          before do
-            allow(decorator).to receive(:version_url).and_return("version_url")
-            allow(decorator).to receive(:tag_url).and_return("tag_url")
-            allow(decorator).to receive(:pact_url).and_return("pact_url")
-            allow(decorator).to receive(:pacticipant_url).and_return("pacticipant_url")
-            allow(version).to receive(:pacticipant).and_return(pacticipant)
-            allow(tag).to receive(:version).and_return(version)
-          end
-
-          let(:results) do
-            PactBroker::Contracts::ContractsPublicationResults.from_hash(
-              notices: notices,
-              pacticipant: pacticipant,
-              version: version,
-              contracts: contracts,
-              tags: tags
-            )
-          end
-          let(:contracts) { [pact] }
-          let(:pact) { instance_double(PactBroker::Domain::Pact, name: "pact name") }
-          let(:pacticipant) { PactBroker::Domain::Pacticipant.new(name: "Foo" ) }
-          let(:tags) { [tag]}
-          let(:tag) { PactBroker::Domain::Tag.new(name: "main")}
-          let(:version) { PactBroker::Domain::Version.new(number: "1" ) }
-          let(:notices) { [PactBroker::Contracts::Notice.warning("foo") ] }
-          let(:decorator_options) { { user_options: user_options } }
-          let(:user_options) do
-            {
-              base_url: "http://example.org"
-            }
-          end
-
-          let(:decorator) { PublishContractsResultsDecorator.new(results) }
-
-          subject { decorator.to_hash(decorator_options) }
-
-          it {
-            Approvals.verify(subject, :name => "publish_contracts_results_decorator", format: :json)
-          }
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/api/decorators/reason_decorator_spec.rb

@@ -1,95 +0,0 @@
-require "pact_broker/api/decorators/reason_decorator"
-require "pact_broker/matrix/reason"
-
-module PactBroker
-  module Api
-    module Decorators
-      describe ReasonDecorator do
-        REASON_CLASSES = ObjectSpace.each_object(Class).select { |klass| klass < PactBroker::Matrix::Reason && klass.name&.start_with?("PactBroker") }
-
-        describe "the number of Reason classes" do
-          let(:expected_number_of_reason_classes) { 14 }
-
-          it "is 14 - this is a reminder to add another spec here if a new Reason is added" do
-            expect(REASON_CLASSES.size).to eq expected_number_of_reason_classes
-          end
-        end
-
-        describe "#to_s" do
-          let(:consumer_selector) { double("consumer selector", description: "version 2 of Foo") }
-          let(:provider_selector) { double("provider selector", description: "version 6 of Bar") }
-          let(:selectors) { [consumer_selector, provider_selector] }
-
-          subject { ReasonDecorator.new(reason) }
-
-          context "when the reason is PactBroker::Matrix::PactNotEverVerifiedByProvider" do
-            let(:reason) { PactBroker::Matrix::PactNotEverVerifiedByProvider.new(*selectors) }
-            let(:provider_selector) { double("provider selector", description: "any version of Bar") }
-
-            its(:to_s) { is_expected.to eq "There is no verified pact between version 2 of Foo and any version of Bar" }
-          end
-
-          context "when the reason is PactBroker::Matrix::PactNotVerifiedByRequiredProviderVersion" do
-            let(:reason) { PactBroker::Matrix::PactNotVerifiedByRequiredProviderVersion.new(*selectors) }
-
-            its(:to_s) { is_expected.to eq "There is no verified pact between version 2 of Foo and version 6 of Bar" }
-          end
-
-          context "when the reason is PactBroker::Matrix::VerificationFailed" do
-            let(:reason) { PactBroker::Matrix::VerificationFailed.new(*selectors) }
-
-            its(:to_s) { is_expected.to eq "The verification for the pact between version 2 of Foo and version 6 of Bar failed" }
-          end
-
-          context "when the reason is PactBroker::Matrix::NoDependenciesMissing" do
-            let(:reason) { PactBroker::Matrix::NoDependenciesMissing.new }
-
-            its(:to_s) { is_expected.to eq "There are no missing dependencies" }
-          end
-
-          context "when the reason is PactBroker::Matrix::Successful" do
-            let(:reason) { PactBroker::Matrix::Successful.new }
-
-            its(:to_s) { is_expected.to eq "All required verification results are published and successful" }
-          end
-
-          context "when the reason is PactBroker::Matrix::IgnoreSelectorDoesNotExist" do
-            let(:reason) { PactBroker::Matrix::IgnoreSelectorDoesNotExist.new(selector) }
-            let(:selector) {  double("consumer selector", description: "version 2 of Foo (no such version exists)") }
-
-            its(:to_s) { is_expected.to eq "WARN: Cannot ignore version 2 of Foo (no such version exists)" }
-          end
-
-          context "when the reason is PactBroker::Matrix::InteractionsMissingVerifications" do
-            let(:reason) { PactBroker::Matrix::InteractionsMissingVerifications.new(consumer_selector, provider_selector, interactions) }
-            let(:interactions) do
-              [
-                {
-                  "description" => "desc1",
-                  "providerState" => "p2"
-                },{
-                  "description" => "desc1",
-                  "providerStates" => [ { "name" => "desc3"}, { "name" => "desc4"} ]
-                }
-              ]
-            end
-
-            its(:to_s) { is_expected.to eq "WARN: Although the verification was reported as successful, the results for version 2 of Foo and version 6 of Bar may be missing tests for the following interactions: desc1 given p2; desc1 given desc3, desc4" }
-          end
-
-          context "when the reason is NoEnvironmentSpecified" do
-            let(:reason) { PactBroker::Matrix::NoEnvironmentSpecified.new }
-
-            its(:to_s) { is_expected.to start_with "WARN: It is recommended to specify the environment" }
-          end
-
-          context "when the reason is SelectorWithoutPacticipantVersionNumberSpecified" do
-            let(:reason) { PactBroker::Matrix::SelectorWithoutPacticipantVersionNumberSpecified.new }
-
-            its(:to_s) { is_expected.to start_with "WARN: It is recommended to specify the version number" }
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/api/decorators/relationships_csv_decorator_spec.rb

@@ -1,28 +0,0 @@
-require "spec_helper"
-require "pact_broker/api/decorators/relationships_csv_decorator"
-
-module PactBroker
-  module Api
-    module Decorators
-      describe RelationshipsCsvDecorator do
-
-        let(:pact) { TestDataBuilder.new.create_pact_with_hierarchy("My Consumer", "1.0", "My Provider").and_return(:pact) }
-        let(:pacts) { [pact]}
-
-        subject { RelationshipsCsvDecorator.new(pacts) }
-
-        describe "#to_csv" do
-
-          let(:line_1) { "1,My Consumer,1,3158419,0,1,2,0,0,0,0,0,0,0,0"}
-          let(:line_2) { "2,My Provider,1,3158419,0,2,0,0,0,0,0,0,0,0,0" }
-          let(:expected_text) { [line_1, line_2].join("\n") + "\n" }
-
-          xit "returns the relationships as CSV" do
-            expect(subject.to_csv).to eq expected_text
-          end
-        end
-
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/api/decorators/representable_pact_spec.rb

@@ -1,29 +0,0 @@
-require "spec_helper"
-require "spec/support/test_data_builder"
-require "pact_broker/api/decorators/representable_pact"
-
-module PactBroker::Api::Decorators
-  describe RepresentablePact do
-    let(:pact) { TestDataBuilder.new.create_pact_with_hierarchy("Consumer", "1.2.3", "Provider").and_return(:pact) }
-
-    subject { RepresentablePact.new(pact) }
-
-    describe "initialize" do
-      it "creates an object with a provider with a name" do
-        expect(subject.provider.name).to eq "Provider"
-      end
-
-      it "creates an object with a provider with a nil version" do
-        expect(subject.provider.version).to be_nil
-      end
-
-      it "creates an object with a consumer with a name" do
-        expect(subject.consumer.name).to eq "Consumer"
-      end
-
-      it "creates an object with a consumer that has the current pact's version" do
-        expect(subject.consumer.version.number).to eq "1.2.3"
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/api/decorators/tag_decorator_spec.rb

@@ -1,57 +0,0 @@
-require "pact_broker/api/decorators/tag_decorator"
-require "pact_broker/tags/repository"
-
-require "support/test_data_builder"
-
-module PactBroker
-
-  module Api
-
-    module Decorators
-
-      describe TagDecorator do
-
-        let(:tag) do
-          TestDataBuilder.new
-            .create_consumer("Consumer")
-            .create_version("1.2.3")
-            .create_tag("prod")
-            .and_return(:tag)
-        end
-
-        let(:options) { { user_options: { base_url: "http://example.org" } } }
-
-        subject { JSON.parse TagDecorator.new(tag).to_json(options), symbolize_names: true }
-
-        it "includes the tag name" do
-          expect(subject[:name]).to eq "prod"
-        end
-
-        it "includes a link to itself" do
-          expect(subject[:_links][:self][:href]).to eq "http://example.org/pacticipants/Consumer/versions/1.2.3/tags/prod"
-        end
-
-        it "includes the tag name" do
-          expect(subject[:_links][:self][:name]).to eq "prod"
-        end
-
-        it "includes a link to the version" do
-          expect(subject[:_links][:version][:href]).to eq "http://example.org/pacticipants/Consumer/versions/1.2.3"
-        end
-
-        it "includes the version number" do
-          expect(subject[:_links][:version][:name]).to eq "1.2.3"
-        end
-
-        it "includes a link to the pacticipant" do
-          expect(subject[:_links][:pacticipant][:href]).to eq "http://example.org/pacticipants/Consumer"
-        end
-
-        it "includes the pacticipant name" do
-          expect(subject[:_links][:pacticipant][:name]).to eq "Consumer"
-        end
-
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/api/decorators/tagged_pact_versions_decorator_spec.rb

@@ -1,79 +0,0 @@
-require "pact_broker/api/decorators/tagged_pact_versions_decorator"
-
-module PactBroker
-  module Api
-    module Decorators
-      describe TaggedPactVersionsDecorator do
-        before do
-          allow(PactBroker::Api::Decorators::PactVersionDecorator).to receive(:new).and_return(_version_decorator)
-          allow_any_instance_of(TaggedPactVersionsDecorator).to receive(:pact_url).and_return("pact_url")
-          allow_any_instance_of(TaggedPactVersionsDecorator).to receive(:pacticipant_url).and_return("pacticipant_url")
-          allow_any_instance_of(TaggedPactVersionsDecorator).to receive(:pacticipant_url).and_return("pacticipant_url")
-        end
-
-        let(:user_options) do
-          register_fixture(:tagged_pact_versions_decorator_user_options) do
-            {
-              base_url: "http://example.org",
-              resource_url: "http://example.org/pacts/provider/Bar/consumer/Foo/tag/prod",
-              consumer_name: "Foo",
-              provider_name: "Bar",
-              tag: "prod"
-            }
-          end
-        end
-
-        let(:_version_decorator) do
-          instance_double(PactBroker::Api::Decorators::VersionDecorator, to_hash: { some: "pact" } )
-        end
-        let(:pact_versions) { [pact_version] }
-        let(:pact_version) do
-          instance_double("PactBroker::Domain::Pact").as_null_object
-        end
-
-        let(:decorator) { TaggedPactVersionsDecorator.new(pact_versions) }
-        let(:json) { decorator.to_json(user_options: user_options) }
-        subject { JSON.parse(json) }
-
-        let(:expected) do
-          {
-           "_embedded" => {
-             "pacts" => [
-               {
-                 "some" => "pact"
-               }
-             ]
-           },
-           "_links" => {
-             "self" => {
-               "href" => "http://example.org/pacts/provider/Bar/consumer/Foo/tag/prod",
-               "title" => "All versions of the pact between Foo and Bar with tag prod"
-             },
-             "pb:consumer" => {
-               "href" => "pacticipant_url",
-               "title" => "Consumer",
-               "name" => "Foo"
-             },
-             "pb:provider" => {
-               "href" => "pacticipant_url",
-               "title" => "Provider",
-               "name" => "Bar"
-             },
-             "pb:pact-versions" => [
-               {
-                 "href" => "pact_url",
-                 "title" => "Pact version",
-                 "name" => "#[InstanceDouble(PactBroker::Domain::Pact) (anonymous)]"
-               }
-             ]
-           }
-          }
-        end
-
-        it "matches the expected JSON" do
-          expect(subject).to match_pact(expected, allow_unexpected_keys: false)
-        end
-      end
-    end
-  end
-end