pact_broker 2.89.1 → 2.90.0

data/spec/lib/pact_broker/app_spec.rb

@@ -1,348 +0,0 @@
-require "pact_broker/app"
-
-module PactBroker
-  describe App do
-
-    before do
-      allow(PactBroker::DB).to receive(:run_migrations)
-    end
-
-    class TestApp < PactBroker::App
-      def configure_database_connection
-        # do nothing so we don't screw up our test connection
-      end
-    end
-
-    let(:app) do
-      TestApp.new do | configuration |
-        configuration.database_connection = PactBroker::DB.connection
-      end
-    end
-
-    describe "on start up" do
-      it "fails any retrying triggered webhooks left over when the app shut down" do
-        expect(PactBroker::Webhooks::Service).to receive(:fail_retrying_triggered_webhooks)
-        app
-      end
-    end
-
-    it "adds the X-Pact-Broker-Version header" do
-      get "/"
-      expect(last_response.headers["X-Pact-Broker-Version"]).to match(/\d/)
-    end
-
-    class Middleware
-
-      def initialize app
-        @app = app
-      end
-
-      def call env
-        self.class.calls << env
-        @app.call(env)
-      end
-
-      def self.calls
-        @calls ||= []
-      end
-    end
-
-    it "acts like a ::Rack::Builder" do
-      app.use Middleware
-      expect { get "/" }.to change { Middleware.calls.count }.by(1)
-    end
-
-    describe "before_resource and after_resource" do
-      CALLBACKS = []
-      before do
-        PactBroker.configuration.before_resource { | _resource | CALLBACKS << "before" }
-        PactBroker.configuration.after_resource { | _resource | CALLBACKS << "after" }
-      end
-
-      it "executes the callbacks" do
-        get "/"
-        expect(CALLBACKS).to eq ["before", "after"]
-      end
-    end
-
-    describe "use_custom_ui" do
-      before do
-        app.use_custom_ui(custom_ui)
-        get "/", nil, { "HTTP_ACCEPT" => "text/html" }
-      end
-
-      context "when the UI returns a non 404 response" do
-        let(:custom_ui) { double("ui", call: [200, {}, ["hello"]]) }
-
-        it "returns the given page" do
-          expect(last_response.body).to eq "hello"
-        end
-      end
-
-      context "when the UI returns a 404 response" do
-        let(:custom_ui) { double("ui", call: [404, {}, []]) }
-
-        it "passes on the call to the rest of the app" do
-          expect(last_response.status).to eq 200
-        end
-      end
-    end
-
-    describe "use_custom_api" do
-      before do
-        app.use_custom_api(custom_api)
-        get "/", nil, { "HTTP_ACCEPT" => "application/hal+json" }
-      end
-
-      context "when the API returns a non 404 response" do
-        let(:custom_api) { double("api", call: [200, {}, ["hello"]]) }
-
-        it "returns the given resource" do
-          expect(last_response.body).to eq "hello"
-        end
-      end
-
-      context "when the custom API returns a 404 response" do
-        let(:custom_api) { double("api", call: [404, {}, []]) }
-
-        it "passes on the call to the rest of the app" do
-          expect(last_response.body).to_not eq "hello"
-        end
-      end
-    end
-
-    describe "use_xxx_auth" do
-      class TestAuth
-        def initialize app, *_args
-          @app = Rack::Auth::Basic.new(app, "Protected") do | username, password |
-            username == "foo" && password == "bar"
-          end
-        end
-
-        def call(env)
-          @app.call(env)
-        end
-      end
-
-      describe "use_api_auth" do
-        it "allows the API to be protected" do
-          app.use_api_auth TestAuth
-
-          basic_authorize "foo", "bar"
-          get "/"
-          expect(last_response.status).to eq 200
-
-          basic_authorize "foo", "wrong"
-          get "/"
-          expect(last_response.status).to eq 401
-          expect(last_response.headers["WWW-Authenticate"]).to eq "Basic realm=\"Protected\""
-        end
-      end
-
-      describe "use_ui_auth" do
-        it "allows the UI to be protected" do
-          app.use_ui_auth TestAuth
-
-          basic_authorize "foo", "bar"
-          get "/", nil, {"HTTP_ACCEPT" => "text/html"}
-          expect(last_response.status).to eq 200
-
-          basic_authorize "foo", "wrong"
-          get "/", nil, {"HTTP_ACCEPT" => "text/html"}
-          expect(last_response.status).to eq 401
-          expect(last_response.headers["WWW-Authenticate"]).to eq "Basic realm=\"Protected\""
-        end
-      end
-
-      context "ordering of calls" do
-        class TestAuth1
-          def initialize app; end
-          def call env; end
-        end
-
-        class TestAuth2 < TestAuth1; end
-
-        before do
-          allow(TestAuth1).to receive(:new).and_return(test_auth_1)
-          allow(TestAuth2).to receive(:new).and_return(test_auth_2)
-        end
-
-        let(:test_auth_1) { instance_double("TestAuth1", call: [404, {}, []]) }
-        let(:test_auth_2) { instance_double("TestAuth2", call: [404, {}, []]) }
-
-        it "calls the UI auth before the API auth" do
-          expect(test_auth_1).to receive(:call).ordered
-          expect(test_auth_2).to receive(:call).ordered
-          app.use_ui_auth TestAuth1
-          app.use_api_auth TestAuth2
-          get "/", nil, {"HTTP_ACCEPT" => "text/html"}
-        end
-      end
-    end
-
-    describe "authenticate" do
-      before do
-        PactBroker.configuration.authenticate do | _resource, authorization_header, _options |
-          authorization_header == "letmein"
-        end
-      end
-
-      context "with an invalid Authorization header" do
-        it "returns a 401" do
-          get "/", {}, {"HTTP_AUTHORIZATION" => "wrong"}
-          expect(last_response.status).to eq 401
-        end
-      end
-
-      context "with valid Authorization header" do
-        it "returns a 200" do
-          get "/", {}, {"HTTP_AUTHORIZATION" => "letmein"}
-          expect(last_response.status).to eq 200
-        end
-      end
-    end
-
-    describe "authenticate_with_basic_auth" do
-      before do
-        PactBroker.configuration.authenticate_with_basic_auth do | _resource, username, password, _options |
-          username == "username" && password == "password"
-        end
-      end
-
-      context "with a request for the API with incorrect username or password" do
-        it "returns a 401" do
-          basic_authorize "foo", "password"
-          get "/"
-          expect(last_response.status).to eq 401
-        end
-      end
-
-      context "with a request for the UI with incorrect username or password" do
-        it "returns a 401" do
-          basic_authorize "foo", "password"
-          get "/", nil, {"HTTP_ACCEPT" => "text/html"}
-          expect(last_response.status).to eq 401
-        end
-      end
-
-      context "with a request for diagnostics with incorrect username or password" do
-        it "returns a 401" do
-          basic_authorize "foo", "password"
-          get "/diagnostic/status/heartbeat"
-          expect(last_response.status).to eq 401
-        end
-      end
-
-      context "with a request for the API with correct username and password" do
-        it "returns a 200" do
-          basic_authorize "username", "password"
-          get "/"
-          expect(last_response.status).to eq 200
-        end
-      end
-
-      context "with a request for the UI with correct username or password" do
-        it "returns a 200" do
-          basic_authorize "username", "password"
-          get "/", nil, {"HTTP_ACCEPT" => "text/html"}
-          expect(last_response.status).to eq 200
-        end
-      end
-
-      context "with a request for diagnostics with correct username or password" do
-        it "returns a 200" do
-          basic_authorize "username", "password"
-          get "/diagnostic/status/heartbeat"
-          expect(last_response.status).to eq 200
-        end
-      end
-    end
-
-    describe "authorize" do
-      before do
-        PactBroker.configuration.authorize do | resource, _options |
-          resource.request.headers["Role"] == "important"
-        end
-      end
-
-      context "with a request for the API with an authorized request" do
-        it "returns a 200" do
-          get "/", nil, {"HTTP_ROLE" => "important"}
-          expect(last_response.status).to eq 200
-        end
-      end
-
-      context "with a request for the UI with an authorized request" do
-        it "returns a 200" do
-          get "/", nil, {"HTTP_ACCEPT" => "text/html", "HTTP_ROLE" => "important"}
-          expect(last_response.status).to eq 200
-        end
-      end
-
-      context "with a request for diagnostics with an authorized request" do
-        it "returns a 200" do
-          get "/diagnostic/status/heartbeat", nil, {"HTTP_ROLE" => "important"}
-          expect(last_response.status).to eq 200
-        end
-      end
-
-      context "with a request for the API with an unauthorized request" do
-        it "returns a 403" do
-          get "/"
-          expect(last_response.status).to eq 403
-        end
-      end
-
-      context "with a request for the UI with an unauthorized request" do
-        it "returns a 200 because there's no point doing authorization on the UI at the moment" do
-          get "/", nil, {"HTTP_ACCEPT" => "text/html"}
-          expect(last_response.status).to eq 200
-        end
-      end
-
-      context "with a request for diagnostics with an unauthorized request" do
-        it "returns a 403" do
-          get "/diagnostic/status/heartbeat"
-          expect(last_response.status).to eq 403
-        end
-      end
-    end
-
-    describe "transactions", no_db_clean: true do
-      let(:pact_content) { load_fixture("a_consumer-a_provider.json") }
-      let(:path) { "/pacts/provider/A%20Provider/consumer/A%20Consumer/versions/1.2.3" }
-      let(:response_body_json) { JSON.parse(subject.body) }
-
-      before do
-        PactBroker::Database.truncate
-        allow_any_instance_of(PactBroker::Pacts::Repository).to receive(:create).and_raise("an error")
-      end
-
-      after do
-        PactBroker::Database.truncate
-      end
-
-      subject { put path, pact_content, { "CONTENT_TYPE" => "application/json" }; last_response  }
-
-      it "wraps the API with a database transaction" do
-        expect { subject }.to_not change { PactBroker::Domain::Pacticipant.count }
-      end
-    end
-
-    describe "when resource is not found" do
-      subject { get("/does/not/exist", nil, { "CONTENT_TYPE" => "application/hal+json" })  }
-
-      it "returns a Content-Type of application/hal+json" do
-        expect(subject.headers["Content-Type"]).to eq "application/hal+json;charset=utf-8"
-      end
-
-      it "returns a JSON body" do
-        expect(subject.body).to eq ""
-      end
-
-      it "returns a 404" do
-        expect(subject.status).to eq 404
-      end
-    end
-  end
-end

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

@@ -1,348 +0,0 @@
-require "pact_broker/badges/service"
-require "webmock/rspec"
-
-module PactBroker
-  module Badges
-    describe Service do
-      let(:pacticipant_name) { "Foo-Bar_Thing Service" }
-      let(:pact) { double("pact", consumer_name: "Foo-Bar", provider_name: "Thing_Blah") }
-      let(:label) { nil }
-      let(:initials) { false }
-      let(:pseudo_branch_verification_status) { :success }
-      let(:logger) { double("logger").as_null_object }
-      let(:expected_url) { "https://img.shields.io/badge/#{expected_left_text}-#{expected_right_text}-#{expected_color}.svg" }
-      let(:expected_color) { "brightgreen" }
-      let(:expected_right_text) { "verified" }
-      let(:expected_left_text) { "foo--bar%2Fthing__blah%20pact" }
-      let(:response_status) { 200 }
-      let!(:http_request) do
-        stub_request(:get, expected_url).to_return(:status => response_status, :body => "svg")
-      end
-      let(:tags) { {} }
-
-      subject { PactBroker::Badges::Service.pact_verification_badge(pact, label, initials, pseudo_branch_verification_status, tags) }
-
-      let(:pact_verification_badge_url) { PactBroker::Badges::Service.pact_verification_badge_url(pact, label, initials, pseudo_branch_verification_status, tags) }
-
-      before do
-        Service.clear_cache
-        allow(Service).to receive(:logger).and_return(logger)
-      end
-
-      describe "can_i_deploy_badge_url" do
-        subject { Service.can_i_deploy_badge_url("main", "prod", nil, true) }
-
-        it { is_expected.to eq URI("https://img.shields.io/badge/can--i--deploy-main%20to%20prod-brightgreen.svg") }
-      end
-
-      describe "pact_verification_badge_url" do
-        context "with the pact is nil" do
-          let(:pact) { nil }
-          let(:expected_left_text) { "pact%20not%20found" }
-          let(:expected_right_text) { "unknown" }
-          let(:expected_color) { "lightgrey" }
-          let(:pseudo_branch_verification_status) { :never }
-
-          it "returns a link to a 'pact not found' badge" do
-            expect(pact_verification_badge_url).to eq URI(expected_url)
-          end
-        end
-      end
-
-      describe "#pact_verification_badge" do
-        it "returns the svg file" do
-          expect(subject).to eq "svg"
-        end
-
-        it "caches the response" do
-          PactBroker::Badges::Service.pact_verification_badge pact, label, initials, pseudo_branch_verification_status
-          PactBroker::Badges::Service.pact_verification_badge pact, label, initials, pseudo_branch_verification_status
-          expect(http_request).to have_been_made.once
-        end
-
-        context "when the label is not specified" do
-          it "creates a badge with the consumer and provider names" do
-            subject
-            expect(http_request).to have_been_made
-            expect(pact_verification_badge_url).to eq URI(expected_url)
-          end
-
-          context "when initials is true" do
-            let(:expected_left_text) { "fb%2Ftb%20pact" }
-            let(:initials) { true }
-
-            it "creates a badge with the consumer and provider initials" do
-              subject
-              expect(http_request).to have_been_made
-              expect(pact_verification_badge_url).to eq URI(expected_url)
-            end
-          end
-
-          context "when initials is true but the consumer and provider names only contain one word" do
-            let(:expected_left_text) { "foo%2Fbar%20pact" }
-            let(:initials) { true }
-            let(:pact) { double("pact", consumer_name: "Foo", provider_name: "Bar") }
-
-            it "creates a badge with the consumer and provider names, not initials" do
-              subject
-              expect(http_request).to have_been_made
-              expect(pact_verification_badge_url).to eq URI(expected_url)
-            end
-          end
-
-          context "when initials is true but the consumer and provider names are one camel cased word" do
-            let(:expected_left_text) { "fa%2Fbp%20pact" }
-            let(:initials) { true }
-            let(:pact) { double("pact", consumer_name: "FooApp", provider_name: "barProvider") }
-
-            it "creates a badge with the consumer and provider names, not initials" do
-              subject
-              expect(http_request).to have_been_made
-              expect(pact_verification_badge_url).to eq URI(expected_url)
-            end
-          end
-
-          context "when initials is true but the consumer and provider names are one camel cased word" do
-            let(:expected_left_text) { "fa%2Fdat%20pact" }
-            let(:initials) { true }
-            let(:pact) { double("pact", consumer_name: "FooApp", provider_name: "doAThing") }
-
-            it "creates a badge with the consumer and provider names, not initials" do
-              subject
-              expect(http_request).to have_been_made
-              expect(pact_verification_badge_url).to eq URI(expected_url)
-            end
-          end
-
-          context "when the tags are supplied" do
-            let(:tags) { { consumer_tag: "prod", provider_tag: "master" } }
-
-            let(:expected_left_text) { "foo--bar%20%28prod%29%2Fthing__blah%20%28master%29%20pact" }
-
-            it "creates a badge with the consumer and provider names, not initials" do
-              subject
-              expect(http_request).to have_been_made
-              expect(pact_verification_badge_url).to eq URI(expected_url)
-            end
-          end
-        end
-
-        context "when label is consumer" do
-          let(:expected_left_text) { "foo--bar%20pact" }
-          let(:label) { "consumer" }
-
-          it "creates a badge with only the consumer name" do
-            subject
-            expect(http_request).to have_been_made
-            expect(pact_verification_badge_url).to eq URI(expected_url)
-          end
-
-          context "when initials is true" do
-            let(:expected_left_text) { "fb%20pact" }
-            let(:initials) { true }
-
-            it "creates a badge with only the consumer initials" do
-              subject
-              expect(http_request).to have_been_made
-              expect(pact_verification_badge_url).to eq URI(expected_url)
-            end
-          end
-        end
-
-        context "when label is provider" do
-          let(:expected_left_text) { "thing__blah%20pact" }
-          let(:label) { "provider" }
-
-          it "creates a badge with only the provider name" do
-            subject
-            expect(http_request).to have_been_made
-            expect(pact_verification_badge_url).to eq URI(expected_url)
-          end
-
-          context "when initials is true" do
-            let(:expected_left_text) { "tb%20pact" }
-            let(:initials) { true }
-
-            it "creates a badge with only the provider initials" do
-              subject
-              expect(http_request).to have_been_made
-              expect(pact_verification_badge_url).to eq URI(expected_url)
-            end
-          end
-        end
-
-        context "when the pseudo_branch_verification_status is :success" do
-          it "create a green badge with left text 'verified'" do
-            subject
-            expect(http_request).to have_been_made
-            expect(pact_verification_badge_url).to eq URI(expected_url)
-          end
-        end
-
-        context "when the pseudo_branch_verification_status is :never" do
-          let(:pseudo_branch_verification_status) { :never }
-          let(:expected_color) { "lightgrey" }
-          let(:expected_right_text) { "unknown" }
-
-          it "create a lightgrey badge with left text 'unknown'" do
-            subject
-            expect(http_request).to have_been_made
-            expect(pact_verification_badge_url).to eq URI(expected_url)
-          end
-        end
-
-        context "when the pseudo_branch_verification_status is :failed" do
-          let(:pseudo_branch_verification_status) { :failed }
-          let(:expected_color) { "red" }
-          let(:expected_right_text) { "failed" }
-
-          it "create a red badge with left text 'failed'" do
-            subject
-            expect(http_request).to have_been_made
-            expect(pact_verification_badge_url).to eq URI(expected_url)
-          end
-        end
-
-        context "when the pseudo_branch_verification_status is :failed_pending" do
-          let(:pseudo_branch_verification_status) { :failed_pending }
-          let(:expected_color) { "red" }
-          let(:expected_right_text) { "failed%20%28pending%29" }
-
-          it "create a red badge with left text 'failed'" do
-            subject
-            expect(http_request).to have_been_made
-            expect(pact_verification_badge_url).to eq URI(expected_url)
-          end
-        end
-
-        context "when the pseudo_branch_verification_status is :stale" do
-          let(:pseudo_branch_verification_status) { :stale }
-          let(:expected_color) { "orange" }
-          let(:expected_right_text) { "changed" }
-
-          it "create a orange badge with left text 'changed'" do
-            subject
-            expect(http_request).to have_been_made
-            expect(pact_verification_badge_url).to eq URI(expected_url)
-          end
-        end
-
-        context "when the pact is nil" do
-          let(:pact) { nil }
-          it "does not make a dynamic badge" do
-            subject
-            expect(http_request).to_not have_been_made
-          end
-
-          it "returns a static image" do
-            expect(subject).to include ">pact not found</"
-            expect(subject).to include ">unknown</"
-          end
-        end
-
-        context "when a non-200 response is returned" do
-          let(:expected_url) { /http/ }
-          let(:response_status) { 404 }
-
-          context "when the pseudo_branch_verification_status is success" do
-            it "returns a static success image" do
-              expect(subject).to include ">pact</"
-              expect(subject).to include ">verified</"
-            end
-          end
-
-          context "when the pseudo_branch_verification_status is failed" do
-            let(:pseudo_branch_verification_status) { :failed }
-
-            it "returns a static failed image" do
-              expect(subject).to include ">pact</"
-              expect(subject).to include ">failed</"
-            end
-          end
-
-          # TODO save a static image for this
-          context "when the pseudo_branch_verification_status is failed_pending" do
-            let(:pseudo_branch_verification_status) { :failed_pending }
-
-            it "returns a static failed image" do
-              expect(subject).to include ">pact</"
-              expect(subject).to include ">failed</"
-            end
-          end
-
-          context "when the pseudo_branch_verification_status is stale" do
-            let(:pseudo_branch_verification_status) { :stale }
-
-            it "returns a static stale image" do
-              expect(subject).to include ">pact</"
-              expect(subject).to include ">changed</"
-            end
-          end
-
-          context "when the pseudo_branch_verification_status is never" do
-            let(:pseudo_branch_verification_status) { :never }
-
-            it "returns a static stale image" do
-              expect(subject).to include ">pact</"
-              expect(subject).to include ">unknown</"
-            end
-          end
-        end
-
-        context "when a timeout exception is raised connecting to the shields.io server" do
-          before do
-            allow(Net::HTTP).to receive(:start).and_raise(Net::OpenTimeout)
-          end
-
-          it "logs a warning rather than an error as this will happen reasonably often" do
-            expect(logger).to receive(:warn).with(/Timeout retrieving badge from.*shield.*Net::OpenTimeout/)
-            subject
-          end
-
-          it "returns a static image" do
-            expect(subject).to include ">pact</"
-          end
-
-          it "does not cache the response" do
-            expect(Service::CACHE.size).to eq 0
-          end
-        end
-
-        context "when an exception is raised connecting to the shields.io server" do
-          before do
-            allow(Net::HTTP).to receive(:start).and_raise("an error")
-          end
-
-          it "logs the error" do
-            expect(logger).to receive(:warn).with(/Error retrieving badge from.*shield.*/, RuntimeError)
-            subject
-          end
-
-          it "returns a static image" do
-            expect(subject).to include ">pact</"
-          end
-
-          it "does not cache the response" do
-            expect(Service::CACHE.size).to eq 0
-          end
-        end
-
-        context "when the shields_io_base_url is not configured" do
-          before do
-            PactBroker.configuration.shields_io_base_url = nil
-          end
-
-          it "does not make an http request" do
-            subject
-            expect(http_request).to_not have_been_made
-          end
-
-          it "returns a static image" do
-            expect(subject).to include ">pact</"
-            expect(subject).to include ">verified</"
-          end
-        end
-      end
-    end
-  end
-end