pact_broker 2.89.1 → 2.90.0

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

@@ -1,94 +0,0 @@
-require "pact_broker/api/decorators/dashboard_decorator"
-require "pact_broker/domain/index_item"
-
-ORIGINAL_TZ = ENV["TZ"]
-
-module PactBroker
-  module Api
-    module Decorators
-      describe DashboardDecorator do
-        let(:index_item) do
-          instance_double("PactBroker::Domain::IndexItem",
-            consumer: consumer,
-            provider: provider,
-            consumer_name: consumer.name,
-            provider_name: provider.name,
-            latest_pact: pact,
-            latest_verification: verification,
-            provider_version: provider_version,
-            consumer_version: consumer_version,
-            last_webhook_execution_date: last_webhook_execution_date,
-            webhook_status: "blah",
-            pseudo_branch_verification_status: "wiffle",
-            provider_version_number: provider_version.number,
-            provider_version_branches: ["main"],
-            consumer_version_number: consumer_version.number,
-            consumer_version_branches: ["main"],
-            tag_names: ["prod"],
-            latest_verification_latest_tags: [double("tag", name: "dev", latest?: true)]
-          )
-        end
-        let(:consumer) { instance_double("PactBroker::Domain::Pacticipant", name: "Foo") }
-        let(:provider) { instance_double("PactBroker::Domain::Pacticipant", name: "Bar") }
-        let(:pact) { instance_double("PactBroker::Domain::Pact", created_at: created_at) }
-        let(:verification) { instance_double("PactBroker::Domain::Verification", success: true, created_at: created_at) }
-        let(:consumer_version) { instance_double("PactBroker::Domain::Version", number: "1", pacticipant: consumer) }
-        let(:provider_version) { instance_double("PactBroker::Domain::Version", number: "2", pacticipant: provider) }
-        let(:last_webhook_execution_date) { created_at }
-        let(:base_url) { "http://example.org" }
-        let(:options) { { user_options: { base_url: base_url } } }
-        let(:dashboard_json) { DashboardDecorator.new([index_item]).to_json(options) }
-        let(:created_at) { td.in_utc { DateTime.new(2018) } }
-
-        before do
-          allow_any_instance_of(DashboardDecorator).to receive(:pact_url).with(base_url, pact).and_return("pact_url")
-          allow_any_instance_of(DashboardDecorator).to receive(:latest_verification_for_pact_url).with(pact, base_url, false).and_return("latest_verification_url")
-          allow_any_instance_of(DashboardDecorator).to receive(:pacticipant_url).with(base_url, consumer).and_return("consumer_url")
-          allow_any_instance_of(DashboardDecorator).to receive(:pacticipant_url).with(base_url, provider).and_return("provider_url")
-          allow_any_instance_of(DashboardDecorator).to receive(:version_url).with(base_url, consumer_version).and_return("consumer_version_url")
-          allow_any_instance_of(DashboardDecorator).to receive(:webhooks_status_url).with(consumer, provider, base_url).and_return("webhooks_status_url")
-          allow_any_instance_of(DashboardDecorator).to receive(:tag_url) do | _instance, base_url, tag |
-            if tag.version == consumer_version
-              expect(tag.name).to eq "prod"
-              expect(tag.version).to be consumer_version
-              expect(base_url).to eq base_url
-              "pact_prod_tag_url"
-            else
-              expect(tag.name).to eq "dev"
-              expect(tag.version).to be provider_version
-              expect(base_url).to eq base_url
-              "verification_dev_tag_url"
-            end
-          end
-        end
-
-        let(:expected_hash) { JSON.parse(File.read("spec/fixtures/dashboard.json")) }
-
-        subject { JSON.parse(dashboard_json) }
-
-        it "creates some json" do
-          expect(subject).to match_pact(expected_hash, { allow_unexpected_keys: false })
-        end
-
-        context "when the pact has never been verified" do
-          let(:verification) { nil }
-
-          it "has a null last verification and provider version" do
-            expected_hash["items"][0]["latestVerificationResult"] = nil
-            expected_hash["items"][0]["provider"]["version"] = nil
-            expect(subject).to match_pact(expected_hash, { allow_unexpected_keys: false })
-          end
-        end
-
-        context "when no webhooks have been executed" do
-          let(:last_webhook_execution_date) { nil }
-
-          it "has a null latestWebhookExecution" do
-            expected_hash["items"][0]["latestWebhookExecution"] = nil
-            expect(subject).to match_pact(expected_hash, { allow_unexpected_keys: false })
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-require "pact_broker/api/decorators/embedded_label_decorator"
-
-module PactBroker
-  module Api
-    module Decorators
-
-      describe LabelDecorator do
-
-        let(:label) do
-          TestDataBuilder.new
-            .create_consumer("Consumer")
-            .create_label("ios")
-            .and_return(:label)
-        end
-
-        let(:options) { { user_options: { base_url: "http://example.org" } } }
-
-        subject { JSON.parse EmbeddedLabelDecorator.new(label).to_json(options), symbolize_names: true }
-
-        it "includes the label name" do
-          expect(subject[:name]).to eq "ios"
-        end
-
-        it "includes a link to itself" do
-          expect(subject[:_links][:self][:href]).to eq "http://example.org/pacticipants/Consumer/labels/ios"
-        end
-
-        it "includes the label name" do
-          expect(subject[:_links][:self][:name]).to eq "ios"
-        end
-      end
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-require "pact_broker/api/decorators/embedded_tag_decorator"
-require "pact_broker/tags/repository"
-require "support/test_data_builder"
-
-module PactBroker
-
-  module Api
-
-    module Decorators
-
-      describe EmbeddedTagDecorator do
-
-        let(:tag) do
-          TestDataBuilder.new
-            .create_consumer("Consumer")
-            .create_version("1.2.3")
-            .create_tag("prod")
-          PactBroker::Tags::Repository.new.find(tag_name: "prod", pacticipant_version_number: "1.2.3", pacticipant_name: "Consumer")
-        end
-
-        let(:options) { { user_options: { base_url: "http://example.org" } } }
-        let(:json) { EmbeddedTagDecorator.new(tag).to_json(options) }
-
-        subject { JSON.parse json, 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
-
-      end
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-require "spec_helper"
-require "pact_broker/api/decorators/embedded_version_decorator"
-
-module PactBroker
-  module Api
-    module Decorators
-      describe EmbeddedVersionDecorator do
-
-        let(:version) do
-          TestDataBuilder.new
-            .create_consumer("Consumer")
-            .create_version("1.2.3")
-          PactBroker::Versions::Repository.new.find_by_pacticipant_name_and_number "Consumer", "1.2.3"
-        end
-
-        let(:options) { { user_options: { base_url: "http://example.org" } } }
-
-        subject { JSON.parse EmbeddedVersionDecorator.new(version).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
-
-      end
-    end
-  end
-end

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

@@ -1,62 +0,0 @@
-require "pact_broker/api/decorators/extended_pact_decorator"
-
-module PactBroker
-  module Api
-    module Decorators
-      describe ExtendedPactDecorator do
-        before do
-          allow(decorator).to receive(:templated_diff_url).and_return("templated-diff-url")
-          allow(decorator).to receive(:verification_publication_url).and_return("verification-publication-url")
-        end
-        let(:content_hash) {
-          {
-            "consumer" => {"name" => "Consumer"},
-            "provider" => {"name" => "Provider"},
-            "interactions" => [],
-            "metadata" => {}
-          }
-        }
-
-        let(:base_url) { "http://example.org" }
-        let(:created_at) { Time.new(2014, 3, 4) }
-        let(:pact) { double("pact",
-          content_hash: content_hash,
-          created_at: created_at,
-          consumer: consumer,
-          consumer_name: consumer.name,
-          provider: provider,
-          provider_name: provider.name,
-          consumer_version: consumer_version,
-          consumer_version_number: "1234",
-          pact_version_sha: "9999",
-          revision_number: 2,
-          name: "A Pact",
-          head_tag_names: head_tag_names
-        )}
-        let(:head_tag_names) { ["prod"] }
-        let(:consumer) { instance_double(PactBroker::Domain::Pacticipant, name: "A Consumer")}
-        let(:provider) { instance_double(PactBroker::Domain::Pacticipant, name: "A Provider")}
-        let(:consumer_version) { instance_double(PactBroker::Domain::Version, number: "1234", pacticipant: consumer)}
-        let(:metadata) { "abcd" }
-        let(:decorator) { ExtendedPactDecorator.new(pact) }
-        let(:json) { decorator.to_json(user_options: { base_url: base_url, metadata: metadata }) }
-        subject { JSON.parse(json, symbolize_names: true) }
-
-        it "includes an array of tags" do
-          expect(subject[:_embedded][:tags].first).to include name: "prod", latest: true
-          # Can't seem to stub the verification_publication_url method on the TagDecorator
-          expect(subject[:_embedded][:tags].first[:_links][:'pb:latest-pact'][:href]).to eq "http://example.org/pacts/provider/A%20Provider/consumer/A%20Consumer/latest/prod"
-          expect(subject[:_embedded][:tags].first[:_links][:self][:href]).to eq "http://example.org/pacticipants/A%20Consumer/versions/1234/tags/prod"
-        end
-
-        it "includes the pact contents under the contract key" do
-          expect(subject[:contract]).to eq JSON.parse(content_hash.to_json, symbolize_names: true)
-        end
-
-        it "does not include the contract contents in the root" do
-          expect(subject).to_not have_key(:interactions)
-        end
-      end
-    end
-  end
-end

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

@@ -1,86 +0,0 @@
-require "pact_broker/api/decorators/integration_decorator"
-require "pact_broker/integrations/integration"
-
-module PactBroker
-  module Api
-    module Decorators
-      describe IntegrationDecorator do
-        before do
-          allow(integration_decorator).to receive(:dashboard_url_for_integration).and_return("/dashboard")
-          allow(integration_decorator).to receive(:matrix_url).and_return("/matrix")
-          allow(integration_decorator).to receive(:group_url).and_return("/group")
-        end
-
-        let(:integration) do
-          instance_double(PactBroker::Integrations::Integration,
-            consumer: consumer,
-            provider: provider,
-            verification_status_for_latest_pact: pseudo_branch_verification_status
-          )
-        end
-        let(:consumer) { double("consumer", name: "the consumer") }
-        let(:provider) { double("provider", name: "the provider") }
-        let(:pseudo_branch_verification_status) { double("pseudo_branch_verification_status", to_s: "some_status") }
-
-        let(:options) { { user_options: { base_url: "http://example.org" } } }
-        let(:expected_hash) do
-          {
-            "consumer" => {
-              "name" => "the consumer"
-            },
-            "provider" => {
-              "name" => "the provider"
-            },
-            "verificationStatus" => "some_status",
-            "_links" => {
-              "pb:dashboard" => {
-                "href" => "/dashboard"
-              },
-              "pb:matrix" => {
-                "title" => "Matrix of pacts/verification results for the consumer and the provider",
-                "href" => "/matrix"
-              },
-              "pb:group" => {
-                "href" => "/group"
-              }
-            }
-          }
-        end
-
-        let(:integration_decorator) { IntegrationDecorator.new(integration) }
-        let(:json) { integration_decorator.to_json(options) }
-        subject { JSON.parse(json) }
-
-        it "generates a hash" do
-          expect(subject).to match_pact expected_hash
-        end
-
-        it "generates the correct link for the dashboard" do
-          expect(integration_decorator).to receive(:dashboard_url_for_integration).with(
-            "the consumer",
-            "the provider",
-            "http://example.org"
-          )
-          subject
-        end
-
-        it "generates the correct link for the matrix" do
-          expect(integration_decorator).to receive(:matrix_url).with(
-            "the consumer",
-            "the provider",
-            "http://example.org"
-          )
-          subject
-        end
-
-        it "generates the correct group url for the matrix" do
-          expect(integration_decorator).to receive(:group_url).with(
-            "the consumer",
-            "http://example.org"
-          )
-          subject
-        end
-      end
-    end
-  end
-end

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

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

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

@@ -1,42 +0,0 @@
-require "pact_broker/api/decorators/label_decorator"
-
-module PactBroker
-  module Api
-    module Decorators
-
-      describe LabelDecorator do
-
-        let(:label) do
-          TestDataBuilder.new
-            .create_consumer("Consumer")
-            .create_label("ios")
-            .and_return(:label)
-        end
-
-        let(:options) { { user_options: { base_url: "http://example.org" } } }
-
-        subject { JSON.parse LabelDecorator.new(label).to_json(options), symbolize_names: true }
-
-        it "includes the label name" do
-          expect(subject[:name]).to eq "ios"
-        end
-
-        it "includes a link to itself" do
-          expect(subject[:_links][:self][:href]).to eq "http://example.org/pacticipants/Consumer/labels/ios"
-        end
-
-        it "includes the label name" do
-          expect(subject[:_links][:self][:name]).to eq "ios"
-        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/latest_pact_decorator_spec.rb

@@ -1,25 +0,0 @@
-require "spec_helper"
-require "pact_broker/api/decorators/latest_pact_decorator"
-
-module PactBroker
-
-  module Api
-
-    module Decorators
-
-      describe LatestPactDecorator do
-
-        let(:pact_domain) { TestDataBuilder.new.create_pact_with_hierarchy("Consumer", "1.2.3", "Provider").and_return(:pact) }
-        let(:pact) { RepresentablePact.new(pact_domain) }
-        let(:base_url) { "http://example.org" }
-
-        subject { JSON.parse LatestPactDecorator.new(pact).to_json(user_options: { base_url: base_url }), symbolize_names: true}
-
-        it "includes the createdAt date" do
-          expect(subject[:createdAt]).to_not be_nil
-        end
-
-      end
-    end
-  end
-end