pact_broker 2.89.1 → 2.90.0

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

@@ -1,69 +0,0 @@
-require "pact_broker/api/decorators/triggered_webhook_decorator"
-
-module PactBroker
-  module Api
-    module Decorators
-      describe TriggeredWebhookDecorator do
-        let(:triggered_webhook) do
-          double("PactBroker::Webhooks::TriggeredWebhook",
-            trigger_type: PactBroker::Webhooks::TriggeredWebhook::TRIGGER_TYPE_RESOURCE_CREATION,
-            event_name: "some_event",
-            status: status,
-            failure?: failure,
-            retrying?: retrying,
-            uuid: "1234",
-            webhook_uuid: "4321",
-            request_description: "GET http://foo",
-            pact_publication: pact,
-            number_of_attempts_made: 1,
-            number_of_attempts_remaining: 2,
-            created_at: DateTime.new(2017),
-            updated_at: DateTime.new(2017),
-            webhook: webhook
-          )
-        end
-
-        let(:webhook) { double("webhook") }
-
-        let(:pact) do
-          double("pact",
-            provider: double(name: "provider"),
-            consumer: double(name: "consumer"),
-            consumer_version_number: "1",
-            name: "foo "
-          )
-        end
-
-        let(:failure) { false }
-        let(:retrying) { false }
-        let(:status) { PactBroker::Webhooks::TriggeredWebhook::STATUS_SUCCESS }
-        let(:logs_url) { "http://example.org/triggered-webhooks/1234/logs" }
-        let(:user_options) { { base_url: "http://example.org" } }
-
-        let(:json) do
-          TriggeredWebhookDecorator.new(triggered_webhook).to_json(user_options: user_options)
-        end
-
-        subject { JSON.parse(json, symbolize_names: true) }
-
-        it "includes a link to the logs" do
-          expect(subject[:_links][:'pb:logs'][:href]).to eq logs_url
-        end
-
-        it "includes a link to the webhook" do
-          expect(subject[:_links][:'pb:webhook'][:href]).to eq "http://example.org/webhooks/4321"
-        end
-
-        it "includes the triggered webhooks properties" do
-          expect(subject).to include(
-            status: "success",
-            triggerType: "resource_creation",
-            attemptsMade: 1,
-            attemptsRemaining: 2,
-            eventName: "some_event"
-          )
-        end
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-require "pact_broker/api/decorators/triggered_webhooks_decorator"
-require "pact_broker/webhooks/triggered_webhook"
-
-module PactBroker
-  module Api
-    module Decorators
-      describe TriggeredWebhooksDecorator do
-        let(:triggered_webhook) do
-          instance_double(PactBroker::Webhooks::TriggeredWebhook).as_null_object
-        end
-        let(:decorator) { TriggeredWebhooksDecorator.new([triggered_webhook]) }
-        let(:user_options) { { resource_title: "Title", resource_url: "http://url" } }
-        let(:json) { decorator.to_json(user_options: user_options) }
-
-        subject { JSON.parse(json) }
-
-        it "includes a self relation" do
-          expect(subject["_links"]["self"]["title"]).to eq "Title"
-          expect(subject["_links"]["self"]["href"]).to eq "http://url"
-        end
-
-        it "includes an embedded list of triggered webhooks" do
-          expect(subject["_embedded"]["triggeredWebhooks"]).to be_instance_of(Array)
-        end
-      end
-    end
-  end
-end

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

@@ -1,94 +0,0 @@
-require "pact_broker/api/decorators/verifiable_pact_decorator"
-
-module PactBroker
-  module Api
-    module Decorators
-      describe VerifiablePactDecorator do
-        before do
-          allow_any_instance_of(PactBroker::Api::PactBrokerUrls).to receive(:pact_version_url_with_metadata).and_return("http://pact")
-          allow(PactBroker::Pacts::BuildVerifiablePactNotices).to receive(:call).and_return(notices)
-          allow_any_instance_of(PactBroker::Pacts::VerifiablePactMessages).to receive(:pact_version_short_description).and_return("short desc")
-          allow_any_instance_of(VerifiablePactDecorator).to receive(:build_metadata_for_pact_for_verification).and_return(metadata)
-        end
-
-        let(:pending_reason) { "the pending reason" }
-        let(:notices) do
-          [
-            {
-              some: "notice"
-            }
-          ]
-        end
-        let(:expected_hash) do
-          {
-            "shortDescription" => "short desc",
-            "verificationProperties" => {
-              "pending" => true,
-              "notices" => [
-                {
-                  "some" => "notice"
-                }
-              ]
-            },
-            "_links" => {
-              "self" => {
-                "href" => "http://pact",
-                "name" => "name"
-              }
-            }
-          }
-        end
-        let(:decorator) { VerifiablePactDecorator.new(pact) }
-        let(:pact) do
-          double("PactBroker::Pacts::VerifiablePact",
-            pending: true,
-            wip: wip,
-            name: "name",
-            provider_name: "Bar",
-            pending_provider_tags: pending_provider_tags,
-            consumer_tags: consumer_tags,
-            selectors: PactBroker::Pacts::Selectors.new([PactBroker::Pacts::ResolvedSelector.new({ latest: true }, double("version", number: "2", id: 1))]))
-        end
-        let(:pending_provider_tags) { %w[dev] }
-        let(:consumer_tags) { %w[dev] }
-        let(:options) { { user_options: { base_url: "http://example.org", include_pending_status: include_pending_status } } }
-        let(:include_pending_status) { true }
-        let(:wip){ false }
-        let(:metadata) { double("metadata") }
-        let(:json) { decorator.to_json(options) }
-
-        subject { JSON.parse(json) }
-
-        it "generates a matching hash" do
-          expect(subject).to match_pact(expected_hash)
-        end
-
-        it "creates the pact version url" do
-          expect(decorator).to receive(:pact_version_url_with_metadata).with(pact, metadata, "http://example.org")
-          subject
-        end
-
-        it "creates the notices" do
-          allow(PactBroker::Pacts::BuildVerifiablePactNotices).to receive(:call).with(pact, "http://pact", include_pending_status: include_pending_status)
-          subject
-        end
-
-        context "when include_pending_status is false" do
-          let(:include_pending_status) { false }
-
-          it "does not include the pending flag" do
-            expect(subject["verificationProperties"]).to_not have_key("pending")
-          end
-        end
-
-        context "when wip is true" do
-          let(:wip) { true }
-
-          it "includes the wip flag" do
-            expect(subject["verificationProperties"]["wip"]).to be true
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-require "pact_broker/api/decorators/verifiable_pacts_decorator"
-
-module PactBroker
-  module Api
-    module Decorators
-      describe VerifiablePactsDecorator do
-        before do
-          allow(VerifiablePactDecorator).to receive(:new).and_return(verifiable_pact_decorator)
-        end
-        let(:verifiable_pact_decorator) { instance_double(VerifiablePactDecorator).as_null_object }
-        let(:pact) { double("pact") }
-        let(:decorator) { VerifiablePactsDecorator.new([pact]) }
-        let(:options) { { user_options: { resource_url: "http://example.org/pacts" } } }
-
-        let(:json) { decorator.to_json(options) }
-
-        subject { JSON.parse(json) }
-
-        it "includes a list of verifiable pacts" do
-          expect(subject["_embedded"]["pacts"]).to be_an(Array)
-        end
-
-        it "includes a link to itself" do
-          expect(subject["_links"]["self"]["href"]).to eq "http://example.org/pacts"
-        end
-      end
-    end
-  end
-end

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

@@ -1,81 +0,0 @@
-require "pact_broker/api/decorators/verification_decorator"
-
-module PactBroker
-  module Api
-    module Decorators
-      describe VerificationDecorator do
-        before do
-          allow_any_instance_of(VerificationDecorator).to receive(:verification_triggered_webhooks_url).and_return("http://triggered-webhooks")
-          allow_any_instance_of(VerificationDecorator).to receive(:pact_version_with_consumer_version_metadata_url).and_return("http://pact")
-        end
-
-        let(:verification) do
-          instance_double("PactBroker::Domain::Verification",
-            number: 1,
-            success: true,
-            provider_version_number: "4.5.6",
-            provider_name: "Provider",
-            consumer_name: "Consumer",
-            test_results: { "arbitrary" => "json" },
-            build_url: "http://build-url",
-            pact_version_sha: "1234",
-            execution_date: DateTime.now,
-            provider_version_tags: provider_version_tags,
-            verified_by_implementation: "Ruby",
-            verified_by_version: "1234")
-        end
-
-        let(:pact) do
-          instance_double("PactBroker::Domain::Pact",
-            name: "A name",
-            provider_name: "Provider",
-            consumer_name: "Consumer",
-            consumer_version_number: "1.2.3",
-            pact_version_sha: "1234",
-          )
-        end
-
-        let(:provider_version_tags) { [instance_double(PactBroker::Tags::TagWithLatestFlag, name: "prod", latest?: true)] }
-
-        let(:options) { { user_options: { base_url: "http://example.org", pact: pact } } }
-
-        let(:json) { VerificationDecorator.new(verification).to_json(options) }
-
-        subject { JSON.parse json, symbolize_names: true }
-
-        it "includes the success status" do
-          expect(subject[:success]).to eq true
-        end
-
-        it "includes the provider version" do
-          expect(subject[:providerApplicationVersion]).to eq "4.5.6"
-        end
-
-        it "includes the test results" do
-          expect(subject[:testResults]).to eq(arbitrary: "json")
-        end
-
-        it "includes the build URL" do
-          expect(subject[:buildUrl]).to eq "http://build-url"
-        end
-
-        it "includes a link to itself" do
-          expect(subject[:_links][:self][:href]).to match %r{http://example.org/.*/verification-results/1}
-        end
-
-        it "includes a link to its pact" do
-          expect(subject[:_links][:'pb:pact-version'][:href]).to eq "http://pact"
-        end
-
-        it "includes a link to the triggered webhooks" do
-          expect(subject[:_links][:'pb:triggered-webhooks'][:href]).to eq "http://triggered-webhooks"
-        end
-
-        it "includes the framework that did the verification" do
-          expect(subject[:verifiedBy][:implementation]).to eq "Ruby"
-          expect(subject[:verifiedBy][:version]).to eq "1234"
-        end
-      end
-    end
-  end
-end

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

@@ -1,65 +0,0 @@
-require "pact_broker/api/decorators/verification_summary_decorator"
-
-module PactBroker
-  module Api
-    module Decorators
-      describe VerificationSummaryDecorator do
-        let(:summary) { instance_double("PactBroker::Verification::SummaryForConsumerVersion", verifications: verifications, success: true, provider_summary: provider_summary) }
-        let(:provider_summary) {
-          instance_double("provider summary", successful: ["Successful provider"], failed: ["Failed provider"], unknown: ["Unknown provider"])
-        }
-        let(:verifications) { [verification] }
-        let(:verification) do
-          instance_double("PactBroker::Domain::Verification",
-            success: true, number: 1,
-            provider_version_number: "4.5.6",
-            build_url: "http://some-build",
-            provider_name: "Provider",
-            consumer_name: "Consumer",
-            pact_version: pact_version,
-            pact_version_sha: "1234",
-            latest_pact_publication: pact,
-            test_results: nil,
-            execution_date: DateTime.now,
-            provider_version_tags: provider_version_tags,
-            verified_by_implementation: "Ruby",
-            verified_by_version: "1234")
-        end
-
-        let(:pact_version) do
-          instance_double("PactBroker::Pacts::PactVersion", name: "Name")
-        end
-
-        let(:provider_version_tags) { [instance_double(PactBroker::Tags::TagWithLatestFlag, name: "prod", latest?: true)] }
-        let(:pact) { instance_double("PactBroker::Domain::Pact", name: "Some pact", consumer_name: "Foo", provider_name: "Bar", consumer_version_number: "1.2.3", pact_version_sha: "1234") }
-        let(:is_pending) { true }
-        let(:options) { {base_url: "http://example.org", consumer_name: "Foo", consumer_version_number: "1.2.3", resource_url: "http://self"} }
-
-        subject { JSON.parse VerificationSummaryDecorator.new(summary).to_json(user_options: options), symbolize_names: true }
-
-        it "includes a list of verification results" do
-          expect(subject[:_embedded][:verificationResults]).to be_instance_of(Array)
-          expect(subject[:_embedded][:verificationResults].size).to eq 1
-        end
-
-        it "includes a title" do
-          expect(subject[:_links][:self][:title]).to eq "Latest verification results for consumer Foo version 1.2.3"
-        end
-
-        it "includes a link to itself" do
-          expect(subject[:_links][:self][:href]).to eq "http://self"
-        end
-
-        it "includes a flag to indicate the overall success or failure of all the verification results" do
-          expect(subject[:success]).to be true
-        end
-
-        it "includes a provider summary" do
-          expect(subject[:providerSummary][:successful]).to eq ["Successful provider"]
-          expect(subject[:providerSummary][:failed]).to eq ["Failed provider"]
-          expect(subject[:providerSummary][:unknown]).to eq ["Unknown provider"]
-        end
-      end
-    end
-  end
-end

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

@@ -1,121 +0,0 @@
-require "spec_helper"
-require "pact_broker/api/decorators/version_decorator"
-
-module PactBroker
-  module Api
-    module Decorators
-      describe VersionDecorator do
-        describe "from_json" do
-          let(:hash) do
-            {
-              buildUrl: "buildUrl",
-              tags: [{ name: "main" }]
-            }
-          end
-
-          subject { VersionDecorator.new(OpenStruct.new).from_json(hash.to_json) }
-
-          it "sets the properties" do
-            expect(subject.build_url).to eq "buildUrl"
-            expect(subject.tags.first.name).to eq "main"
-          end
-        end
-
-        describe "to_json" do
-          before do
-            allow(decorator).to receive(:deployed_versions_for_version_and_environment_url).and_return("http://deployed-versions")
-          end
-
-          let(:version) do
-            TestDataBuilder.new
-              .create_consumer("Consumer")
-              .create_provider("providerA")
-              .create_consumer_version("1.2.3", branch: "main")
-              .create_consumer_version_tag("prod")
-              .create_pact
-              .create_provider("ProviderB")
-              .create_pact
-              .and_return(:consumer_version)
-          end
-
-          let(:environments) do
-            [
-              instance_double("PactBroker::Deployments::Environment",
-                uuid: "1234",
-                name: "test",
-                display_name: "Test"
-              )
-            ]
-          end
-
-          let(:base_url) { "http://example.org" }
-          let(:options) { { user_options: { base_url: base_url, environments: environments } } }
-          let(:decorator) { VersionDecorator.new(version) }
-
-          subject { JSON.parse(decorator.to_json(options), symbolize_names: true) }
-
-          it "includes a link to itself" do
-            expect(subject[:_links][:self][:href]).to eq "http://example.org/pacticipants/Consumer/versions/1.2.3"
-          end
-
-          it "includes the version number in the link" do
-            expect(subject[:_links][:self][:name]).to eq "1.2.3"
-          end
-
-          it "includes its title in the link" do
-            expect(subject[:_links][:self][:title]).to eq "Version"
-          end
-
-          it "includes the version number" do
-            expect(subject[:number]).to eq "1.2.3"
-          end
-
-          it "includes a link to the pacticipant" do
-            expect(subject[:_links][:'pb:pacticipant']).to eq title: "Pacticipant", name: "Consumer", href: "http://example.org/pacticipants/Consumer"
-          end
-
-          it "includes a link to get, create or delete a tag" do
-            expect(subject[:_links][:'pb:tag']).to include href: "http://example.org/pacticipants/Consumer/versions/1.2.3/tags/{tag}", templated: true
-          end
-
-          it "includes a list of the tags" do
-            expect(subject[:_embedded][:tags]).to be_instance_of(Array)
-            expect(subject[:_embedded][:tags].first[:name]).to eq "prod"
-          end
-
-          it "includes the branches" do
-            expect(subject[:_embedded][:branches]).to be_instance_of(Array)
-            expect(subject[:_embedded][:branches].first[:name]).to eq "main"
-            expect(subject[:_embedded][:branches].first[:latest]).to eq true
-          end
-
-          it "includes the timestamps" do
-            expect(subject[:createdAt]).to_not be nil
-          end
-
-          it "includes a list of sorted pacts" do
-            expect(subject[:_links][:'pb:pact-versions']).to be_instance_of(Array)
-            expect(subject[:_links][:'pb:pact-versions'].first[:href]).to include("1.2.3")
-            expect(subject[:_links][:'pb:pact-versions'].first[:name]).to include("Pact between")
-            expect(subject[:_links][:'pb:pact-versions'].first[:name]).to include("providerA")
-            expect(subject[:_links][:'pb:pact-versions'].last[:name]).to include("ProviderB")
-          end
-
-          it "includes a link to the latest verification results for the pacts for this version" do
-            expect(subject[:_links][:'pb:latest-verification-results-where-pacticipant-is-consumer'][:href]).to match(%r{http://.*/verification-results/.*/latest})
-          end
-
-          it "includes a list of environments that this version can be deployed to" do
-            expect(decorator).to receive(:deployed_versions_for_version_and_environment_url).with(version, environments.first, base_url)
-            expect(subject[:_links][:'pb:record-deployment']).to be_instance_of(Array)
-            expect(subject[:_links][:'pb:record-deployment'].first).to eq(
-              name: "test",
-              title: "Record deployment to Test",
-              href: "http://deployed-versions"
-            )
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,49 +0,0 @@
-require "spec_helper"
-require "pact_broker/api/decorators/versions_decorator"
-require "pact_broker/domain/version"
-
-module PactBroker
-  module Api
-    module Decorators
-      describe VersionsDecorator do
-
-        let(:options) { { resource_url: "http://versions", base_url: "http://example.org", pacticipant_name: "Consumer", query_string: query_string}}
-        let(:query_string) { nil }
-        let(:versions) { [] }
-
-        subject { JSON.parse VersionsDecorator.new(versions).to_json(user_options: options), symbolize_names: true }
-
-        context "with no query string" do
-          its([:_links, :self, :href]) { is_expected.to eq "http://versions" }
-        end
-
-        context "with a query string" do
-          let(:query_string) { "foo=bar" }
-          its([:_links, :self, :href]) { is_expected.to eq "http://versions?foo=bar" }
-        end
-
-        context "with no versions" do
-          it "doesn't blow up" do
-            subject
-          end
-        end
-
-        context "with versions" do
-          let!(:version) do
-            TestDataBuilder.new
-              .create_consumer("Consumer")
-              .create_consumer_version("1.2.3")
-              .create_consumer_version_tag("prod")
-              .and_return(:consumer_version)
-          end
-          let(:versions) { [version] }
-
-          it "displays a list of versions" do
-            expect(subject[:_embedded][:versions]).to be_instance_of(Array)
-            expect(subject[:_embedded][:versions].size).to eq 1
-          end
-        end
-      end
-    end
-  end
-end