RubyGems - pact_broker - Versions diffs - 2.89.1 → 2.93.0 - Mend

pact_broker 2.89.1 → 2.93.0

Files changed (710) hide show

data/spec/lib/pact_broker/api/renderers/html_pact_renderer_spec.rb DELETED Viewed

@@ -1,141 +0,0 @@
-require "spec_helper"
-require "pact_broker/api/renderers/html_pact_renderer"
-require "timecop"
-module PactBroker
-  module Api
-    module Renderers
-      describe HtmlPactRenderer do
-        before do
-          ENV["BACKUP_TZ"] = ENV["TZ"]
-          ENV["TZ"] = "Australia/Melbourne"
-          PactBroker.configuration.enable_public_badge_access = true
-          allow(PactBroker::Api::PactBrokerUrls).to receive(:pact_url).with("http://base", pact).and_return(pact_url)
-          allow(PactBroker::Api::PactBrokerUrls).to receive(:matrix_for_pact_url).with(pact, "http://base").and_return(matrix_url)
-          allow_any_instance_of(HtmlPactRenderer).to receive(:logger).and_return(logger)
-          Timecop.freeze(created_at + 3)
-        end
-        after do
-          ENV["TZ"] = ENV["BACKUP_TZ"]
-          Timecop.return
-        end
-        let(:consumer_name) { "Consumer" }
-        let(:provider_name) { "Provider" }
-        let(:consumer_version_number) { "1.2.3" }
-        let(:consumer) { double("consumer", name: consumer_name) }
-        let(:provider) { double("provider", name: provider_name) }
-        let(:consumer_version) { double("consumer version") }
-        let(:created_at) { DateTime.new(2014, 02, 27) }
-        let(:json_content) { load_fixture("renderer_pact.json") }
-        let(:pact) do
-          double("pact",
-            json_content: json_content,
-            consumer_version_number: consumer_version_number,
-            consumer: consumer,
-            provider: provider,
-            consumer_version_tag_names: consumer_version_tag_names,
-            created_at: created_at,
-            consumer_version: consumer_version
-            )
-        end
-        let(:consumer_version_tag_names) { ["prod", "master"] }
-        let(:pact_url) { "/pact/url" }
-        let(:matrix_url) { "/matrix/url" }
-        let(:options) do
-          {
-            base_url: "http://base",
-            badge_url: "http://badge"
-           }
-        end
-        let(:logger) { double("logger").as_null_object }
-        subject { HtmlPactRenderer.call(pact, options) }
-        describe ".call" do
-          it "renders the pact as HTML" do
-            expect(subject).to include("<html>")
-            expect(subject).to include("</html>")
-            expect(subject).to include("<link rel='stylesheet'")
-            expect(subject).to include("href='http://base/stylesheets/github.css'")
-            expect(subject).to include("<pre><code")
-            expect(subject).to include("&quot;method&quot;:")
-            expect(subject).to match(/<h\d>.*Some Consumer/)
-            expect(subject).to match(/<h\d>.*Some Provider/)
-            expect(subject).to include("Date published:")
-            expect(subject).to include("Thu 27 Feb 2014, 11:00am +11:00")
-            expect(subject).to include("3 days ago")
-            expect(subject).to match(/title.*Pact between Consumer and Provider/)
-            expect(subject).to match(/prod, master/)
-          end
-          it "renders the badge image" do
-            expect(subject).to include "<img src=\"http://badge\"/>"
-          end
-          it "renders a text area with the badge markdown" do
-            expect(subject).to include "<textarea"
-            expect(subject).to include "[![Consumer/Provider Pact Status](http://badge)](http://base)"
-          end
-          it "includes the matrix URL" do
-            expect(subject).to include matrix_url
-          end
-          context "with dodgey data" do
-            let(:consumer_name) { '<script>alert("consumer");</script>' }
-            let(:provider_name) { '<script>alert("provider");</script>' }
-            let(:consumer_version_number) { '<script>alert("version");</script>' }
-            let(:consumer_version_tag_names) { ['<script>alert("tag");</script>'] }
-            it "does not contain the literal <script> anywhere except the badge markdown" do
-              expect(subject).to_not include consumer_version_number
-              expect(subject.scan(consumer_name).count).to eq 1
-              expect(subject.scan(provider_name).count).to eq 1
-              expect(subject).to include '[![<script>alert("consumer");</script>/<script>alert("provider");</script> Pact Status](http://badge)]'
-            end
-          end
-          context "when enable_public_badge_access is false" do
-            before do
-              PactBroker.configuration.enable_public_badge_access = false
-            end
-            it "renders a message instructing the user to turn public access on" do
-              expect(subject).to include "set `enable_public_badge_access` to true in the configuration"
-            end
-          end
-          context "when the content is not a valid pact, but is still JSON" do
-            before do
-              allow(pact).to receive(:content_hash).and_return(content_hash)
-            end
-            let(:json_content) { "[1]" }
-            let(:content_hash) { [1] }
-            it "includes a dismissive title" do
-              expect(subject).to include "A contract between Consumer and Provider"
-            end
-            it "includes a warning" do
-              expect(subject).to include "Note:"
-            end
-            it "renders the JSON in HTML" do
-              expect(subject).to match(/\[\s+1\s+\]/m)
-            end
-            it "logs a warning" do
-              expect(logger).to receive(:info).with(/Could not parse.*Error/)
-              subject
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/api/renderers/integrations_dot_renderer_spec.rb DELETED Viewed

@@ -1,29 +0,0 @@
-require "pact_broker/api/renderers/integrations_dot_renderer"
-module PactBroker
-  module Api
-    module Renderers
-      describe IntegrationsDotRenderer do
-        # TODO work out how to handle apostrophes etc
-        let(:integrations) do
-          [
-            double("integration", consumer_name: "Foo", provider_name: "Bar"),
-            double("integration", consumer_name: "Wiffle", provider_name: "Foo Thing")
-          ]
-        end
-        let(:expected_content) { load_fixture("expected.gv") }
-        describe "#call" do
-          subject { IntegrationsDotRenderer.call(integrations) }
-          it "renders a dot file" do
-            expect(subject).to eq expected_content
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/api/resources/all_webhooks_spec.rb DELETED Viewed

@@ -1,145 +0,0 @@
-require "spec_helper"
-require "pact_broker/api/resources/all_webhooks"
-module PactBroker::Api
-  module Resources
-    describe AllWebhooks do
-      before do
-        allow(PactBroker::Pacticipants::Service).to receive(:find_pacticipant_by_name).with("Some Provider").and_return(provider)
-        allow(PactBroker::Pacticipants::Service).to receive(:find_pacticipant_by_name).with("Some Consumer").and_return(consumer)
-        allow(Decorators::WebhookDecorator).to receive(:new).and_return(webhook_decorator)
-      end
-      let(:webhook_service) { PactBroker::Webhooks::Service }
-      let(:uuid) { "1483234k24DKFGJ45K" }
-      let(:path) { "/webhooks" }
-      let(:headers) { {"CONTENT_TYPE" => "application/json"} }
-      let(:webhook) { double("webhook", consumer: parsed_consumer, provider: parsed_provider) }
-      let(:parsed_provider) { instance_double(PactBroker::Domain::Pacticipant, name: "Some Provider") }
-      let(:parsed_consumer) { instance_double(PactBroker::Domain::Pacticipant, name: "Some Consumer") }
-      let(:consumer) { double("consumer", name: "Some Consumer") }
-      let(:provider) { double("provider", name: "Some Provider") }
-      let(:saved_webhook) { double("saved_webhook")}
-      let(:webhook_decorator) { instance_double(Decorators::WebhookDecorator, from_json: webhook) }
-      describe "POST" do
-        before do
-          allow(webhook_service).to receive(:create).and_return(saved_webhook)
-          allow(webhook_service).to receive(:next_uuid).and_return(next_uuid)
-          allow(webhook_service).to receive(:errors).and_return(errors)
-          allow(PactBroker::Domain::Webhook).to receive(:new).and_return(webhook)
-        end
-        let(:webhook_json) do
-          {
-            some: "json"
-          }.to_json
-        end
-        let(:next_uuid) { "123k2nvkkwjrwk34" }
-        let(:valid) { true }
-        let(:errors) { double("errors", empty?: valid, messages: ["messages"]) }
-        subject { post path, webhook_json, headers }
-        context "with malformed JSON" do
-          let(:webhook_json) { "{" }
-          it "returns a 400 error" do
-            subject
-            expect(last_response.status).to eq 400
-          end
-        end
-        context "with invalid attributes" do
-          let(:valid) { false }
-          it "returns a 400" do
-            subject
-            expect(last_response.status).to be 400
-          end
-          it "returns a HAL JSON content type" do
-            subject
-            expect(last_response.headers["Content-Type"]).to eq "application/hal+json;charset=utf-8"
-          end
-          it "returns the validation errors" do
-            subject
-            expect(JSON.parse(last_response.body, symbolize_names: true)).to eq errors: ["messages"]
-          end
-        end
-        context "with valid attributes" do
-          before do
-            allow_any_instance_of(Decorators::WebhookDecorator).to receive(:to_json).and_return(webhook_response_json)
-            allow(webhook_decorator).to receive(:to_json).and_return(webhook_response_json)
-          end
-          let(:webhook_response_json) { { some: "webhook" }.to_json }
-          it "saves the webhook" do
-            expect(webhook_service).to receive(:create).with(next_uuid, webhook, consumer, provider)
-            subject
-          end
-          it "returns a 201 response" do
-            subject
-            expect(last_response.status).to be 201
-          end
-          it "returns the Location header" do
-            subject
-            expect(last_response.headers["Location"]).to include(next_uuid)
-          end
-          it "returns a HAL JSON content type" do
-            subject
-            expect(last_response.headers["Content-Type"]).to eq "application/hal+json;charset=utf-8"
-          end
-          it "generates the JSON response body" do
-            expect(Decorators::WebhookDecorator).to receive(:new).with(saved_webhook).and_return(webhook_decorator)
-            expect(webhook_decorator).to receive(:to_json).with(user_options: hash_including({ base_url: "http://example.org" }))
-            subject
-          end
-          it "returns the JSON representation of the webhook" do
-            subject
-            expect(last_response.body).to eq webhook_response_json
-          end
-        end
-      end
-      describe "GET" do
-        subject { get "/webhooks" }
-        let(:webhooks) { [double("webhook")]}
-        let(:decorator) { double(Decorators::WebhooksDecorator, to_json: json)}
-        let(:json) { {some: "json"}.to_json }
-        before do
-          allow(Decorators::WebhooksDecorator).to receive(:new).and_return(decorator)
-          allow(PactBroker::Webhooks::Service).to receive(:find_all).and_return(webhooks)
-        end
-        it "returns a 200 HAL JSON response" do
-          subject
-          expect(last_response).to be_a_hal_json_success_response
-        end
-        it "generates a JSON representation of the webhook" do
-          expect(Decorators::WebhooksDecorator).to receive(:new).with(webhooks)
-          expect(decorator).to receive(:to_json).with(user_options: instance_of(Decorators::DecoratorContext))
-          subject
-        end
-        it "includes the JSON representation in the response body" do
-          subject
-          expect(last_response.body).to eq json
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/api/resources/badge_spec.rb DELETED Viewed

@@ -1,212 +0,0 @@
-require "pact_broker/api/resources/badge"
-require "pact_broker/badges/service"
-require "pact_broker/matrix/service"
-module PactBroker
-  module Api
-    module Resources
-      describe Badge do
-        let(:path) { "/pacts/provider/provider/consumer/consumer/latest/badge" }
-        let(:params) { {} }
-        before do
-          allow(PactBroker::Pacts::Service).to receive(:find_latest_pact).and_return(pact)
-          allow(PactBroker::Verifications::Service).to receive(:find_latest_verification_for).and_return(verification)
-          allow(PactBroker::Badges::Service).to receive(:pact_verification_badge).and_return("badge")
-          allow(PactBroker::Badges::Service).to receive(:pact_verification_badge_url).and_return("http://badge")
-          allow(PactBroker::Verifications::PseudoBranchStatus).to receive(:new).and_return(pseudo_branch_verification_status)
-          allow(PactBroker::Badges::Service).to receive(:can_provide_badge_using_redirect?).and_return(false)
-        end
-        let(:pact) { instance_double("PactBroker::Domain::Pact", consumer: consumer, provider: provider, consumer_version_number: "2", revision_number: "1") }
-        let(:consumer) { double("consumer") }
-        let(:provider) { double("provider") }
-        let(:verification) { double("verification", provider_version_number: "3", number: "7") }
-        let(:pseudo_branch_verification_status) { instance_double("PactBroker::Verifications::PseudoBranchStatus", to_sym: :verified) }
-        subject { get path, params, {"HTTP_ACCEPT" => "image/svg+xml"}; last_response }
-        context "when enable_public_badge_access is false and the request is not authenticated" do
-          before do
-            PactBroker.configuration.enable_public_badge_access = false
-            allow_any_instance_of(Badge).to receive(:authenticated?).and_return(false)
-          end
-          it "returns a 401" do
-            expect(subject.status).to eq 401
-          end
-        end
-        context "when enable_public_badge_access is false but the request is authenticated" do
-          before do
-            PactBroker.configuration.enable_public_badge_access = false
-            allow_any_instance_of(Badge).to receive(:authenticated?).and_return(true)
-          end
-          it "returns a 200" do
-            expect(subject.status).to eq 200
-          end
-        end
-        context "when enable_public_badge_access is true" do
-          before do
-            PactBroker.configuration.enable_public_badge_access = true
-          end
-          it "retrieves the latest pact" do
-            expect(PactBroker::Pacts::Service).to receive(:find_latest_pact)
-            subject
-          end
-          it "retrieves the latest verification for the pact's consumer and provider" do
-            expect(PactBroker::Verifications::Service).to receive(:find_latest_verification_for).with(consumer, provider, nil)
-            subject
-          end
-          context "when the pact is not found" do
-            let(:pact) { nil }
-            it "does not retrieve the latest verification" do
-              expect(PactBroker::Verifications::Service).to_not receive(:find_latest_verification_for)
-              subject
-            end
-          end
-          it "determines the pact's verification status based on the latest pact and latest verification" do
-            expect(PactBroker::Verifications::PseudoBranchStatus).to receive(:new).with(pact, verification)
-            subject
-          end
-          context "when can_provide_badge_using_redirect? is false" do
-            before do
-              allow(PactBroker::Badges::Service).to receive(:can_provide_badge_using_redirect?).and_return(false)
-            end
-            it "creates a badge" do
-              expect(PactBroker::Badges::Service).to receive(:pact_verification_badge).with(pact, nil, false, :verified, {})
-              subject
-            end
-            it "returns a 200 status" do
-              expect(subject.status).to eq 200
-            end
-            it "does not allow caching" do
-              expect(subject.headers["Cache-Control"]).to eq "no-cache"
-            end
-            it "returns the badge" do
-              expect(subject.body).to end_with "badge"
-            end
-            it "returns a comment with the consumer and provider numbers" do
-              expect(subject.body).to include "<!-- consumer version 2 revision 1 provider version 3 number 7 -->"
-            end
-          end
-          context "when can_provide_badge_using_redirect? is true" do
-            before do
-              allow(PactBroker::Badges::Service).to receive(:can_provide_badge_using_redirect?).and_return(true)
-            end
-            it "determines the URL of the badge to redirect to" do
-              expect(PactBroker::Badges::Service).to receive(:pact_verification_badge_url).with(pact, nil, false, :verified, {})
-              subject
-            end
-            it "returns a 301 redirect to the badge URL" do
-              expect(subject.status).to eq 307
-              expect(subject.headers["Location"]).to eq "http://badge"
-              expect(subject.headers["Cache-Control"]).to eq "no-cache"
-            end
-          end
-          context "when the label param is specified" do
-            let(:params) { {label: "consumer"} }
-            it "creates a badge with the specified label" do
-              expect(PactBroker::Badges::Service).to receive(:pact_verification_badge).with(anything, "consumer", anything, anything, {})
-              subject
-            end
-          end
-          context "when the initials param is true" do
-            let(:params) { {initials: "true"} }
-            it "creates a badge with initials" do
-              expect(PactBroker::Badges::Service).to receive(:pact_verification_badge).with(anything, anything, true, anything, {})
-              subject
-            end
-          end
-          context "when the pact is not found" do
-            let(:pact) { nil }
-            it "returns a 200 status" do
-              expect(subject.status).to eq 200
-            end
-          end
-          context "when retrieving the badge for the latest pact with a tag" do
-            let(:path) { "/pacts/provider/provider/consumer/consumer/latest/prod/badge" }
-            it "retrieves the latest verification for the pact's consumer and provider and specified tag" do
-              expect(PactBroker::Verifications::Service).to receive(:find_latest_verification_for).with(anything, anything, "prod")
-              subject
-            end
-          end
-          context "when retrieving the badge for a matrix row by tag" do
-            before do
-              allow(PactBroker::Matrix::Service).to receive(:find_for_consumer_and_provider_with_tags).and_return(row)
-              allow(PactBroker::Verifications::Service).to receive(:find_by_id).and_return(verification)
-            end
-            let(:path) { "/matrix/provider/provider/latest/master/consumer/consumer/latest/prod/badge" }
-            let(:row) { { consumer_name: "consumer", provider_name: "provider" } }
-            context "when a pact is found" do
-              it "looks up the verification" do
-                expect(PactBroker::Verifications::Service).to receive(:find_latest_verification_for_tags) do | consumer, provider, tag|
-                  expect(consumer.name).to eq "consumer"
-                  expect(provider.name).to eq "provider"
-                  expect(tag).to eq "prod"
-                end
-                subject
-              end
-              context "when a verification is found" do
-                before do
-                  allow(PactBroker::Verifications::Service).to receive(:find_latest_verification_for_tags).and_return(verification)
-                end
-                it "returns the badge" do
-                  expect(subject.body).to end_with "badge"
-                end
-              end
-              context "when a verification is not found" do
-                before do
-                  allow(PactBroker::Verifications::Service).to receive(:find_latest_verification_for_tags).and_return(nil)
-                end
-                it "returns the badge" do
-                  expect(subject.body).to end_with "badge"
-                end
-              end
-            end
-            context "when a pact is not found" do
-              let(:pact) { nil }
-              it "does not look up the verification" do
-                expect(PactBroker::Verifications::Service).to_not receive(:find_latest_verification_for_tags)
-                subject
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/api/resources/can_i_deploy_badge_spec.rb DELETED Viewed

@@ -1,80 +0,0 @@
-require "pact_broker/api/resources/can_i_deploy_badge"
-module PactBroker
-  module Api
-    module Resources
-      describe CanIDeployBadge do
-        before do
-          allow_any_instance_of(described_class).to receive(:badge_service).and_return(badge_service)
-          allow_any_instance_of(described_class).to receive(:matrix_service).and_return(matrix_service)
-          allow_any_instance_of(described_class).to receive(:pacticipant_service).and_return(pacticipant_service)
-          allow_any_instance_of(described_class).to receive(:version_service).and_return(version_service)
-          allow(badge_service).to receive(:can_i_deploy_badge_url).and_return("http://badge")
-          allow(badge_service).to receive(:error_badge_url).and_return("http://error")
-          allow(matrix_service).to receive(:can_i_deploy).and_return(results)
-          allow(pacticipant_service).to receive(:find_pacticipant_by_name).and_return(pacticipant)
-          allow(version_service).to receive(:find_by_pacticipant_name_and_latest_tag).and_return(version)
-          allow(PactBroker.configuration).to receive(:show_backtrace_in_error_response?).and_return(false)
-          allow(PactBroker::Errors).to receive(:generate_error_reference).and_return("abcd")
-        end
-        let(:pacticipant_service) { class_double("PactBroker::Pacticipant::Service").as_stubbed_const }
-        let(:badge_service) { class_double("PactBroker::Badges::Service").as_stubbed_const }
-        let(:matrix_service) { class_double("PactBroker::Matrix::Service").as_stubbed_const }
-        let(:version_service) { class_double("PactBroker::Version::Service").as_stubbed_const }
-        let(:results) { double("results", deployable?: true) }
-        let(:pacticipant) { double("pacticipant") }
-        let(:version) { double("version") }
-        let(:path) { "/pacticipants/Foo/latest-version/main/can-i-deploy/to/prod/badge"}
-        subject { get(path) }
-        context "when the pacticipant exists" do
-          it "returns a redirect to the badge" do
-            expect(badge_service).to receive(:can_i_deploy_badge_url).with("main", "prod", nil, true)
-            expect(subject.status).to eq 307
-          end
-        end
-        context "when the pacticipant does not exist" do
-          let(:pacticipant) { nil }
-          it "returns a redirect to a 'not found' badge" do
-            expect(badge_service).to receive(:error_badge_url).with("Foo", "not found")
-            expect(subject.status).to eq 307
-          end
-        end
-        context "when the version does not exist" do
-          let(:version) { nil }
-          it "returns a redirect to a 'not found' badge" do
-            expect(badge_service).to receive(:error_badge_url).with("version", "not found")
-            expect(subject.status).to eq 307
-          end
-        end
-        context "with a custom label" do
-          subject { get(path, label: "some custom label") }
-          it "returns a redirect to a badge with a custom label" do
-            expect(badge_service).to receive(:can_i_deploy_badge_url).with("main", "prod", "some custom label", true)
-            subject
-          end
-        end
-        context "when there is an error" do
-          before do
-            allow(matrix_service).to receive(:can_i_deploy).and_raise("foo error")
-          end
-          it "returns a redirect to a badge with an error message" do
-            expect(badge_service).to receive(:error_badge_url).with("error", "reference: abcd")
-            expect(subject.status).to eq 307
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/api/resources/can_i_deploy_pacticipant_version_spec.rb DELETED Viewed

@@ -1,31 +0,0 @@
-require "pact_broker/api/resources/can_i_deploy_pacticipant_version"
-require "pact_broker/matrix/service"
-module PactBroker
-  module Api
-    module Resources
-      describe CanIDeployPacticipantVersion do
-        include_context "stubbed services"
-        before do
-          allow(PactBroker::Matrix::Service).to receive(:can_i_deploy).and_return([])
-          allow(pacticipant_service).to receive(:find_pacticipant_by_name).and_return(pacticipant)
-          allow(version_service).to receive(:find_by_pacticipant_name_and_latest_tag).and_return(version)
-          allow(PactBroker::Api::Decorators::MatrixDecorator).to receive(:new).and_return(decorator)
-        end
-        let(:pacticipant) { double("pacticipant") }
-        let(:version) { double("version") }
-        let(:path) { "/pacticipants/Foo/latest-version/main/can-i-deploy/to/prod" }
-        let(:json_response_body) { JSON.parse(subject.body, symbolize_names: true) }
-        let(:decorator) { double("decorator", to_json: "response_body") }
-        let(:selectors) { double("selectors") }
-        let(:options) { double("options") }
-        subject { get(path, nil, "Content-Type" => "application/hal+json") }
-        it { is_expected.to be_a_hal_json_success_response }
-      end
-    end
-  end
-end