pact_broker 2.89.1 → 2.90.0

data/spec/lib/pact_broker/api/middleware/basic_auth_spec.rb

@@ -1,312 +0,0 @@
-require "pact_broker/api/middleware/basic_auth"
-require "pact_broker/api/authorization/resource_access_policy"
-
-module PactBroker
-  module Api
-    module Middleware
-      describe "basic auth" do
-        let(:protected_app) { ->(_) { [200, {}, []]} }
-
-        let(:policy) { PactBroker::Api::Authorization::ResourceAccessPolicy.build(allow_public_read_access, allow_public_access_to_heartbeat, enable_public_badge_access) }
-        let(:app) { BasicAuth.new(protected_app, [write_username, write_password], [read_username, read_password], policy) }
-        let(:allow_public_read_access) { false }
-        let(:allow_public_read_access) { false }
-        let(:write_username) { "write_username" }
-        let(:write_password) { "write_password" }
-        let(:read_username) { "read_username" }
-        let(:read_password) { "read_password" }
-        let(:allow_public_access_to_heartbeat) { true }
-        let(:enable_public_badge_access) { true }
-
-        context "when requesting the heartbeat" do
-          let(:path) { "/diagnostic/status/heartbeat" }
-
-          context "when allow_public_access_to_heartbeat is true" do
-            context "when no credentials are used" do
-              it "allows GET" do
-                get path
-                expect(last_response.status).to eq 200
-              end
-            end
-          end
-
-          context "when allow_public_access_to_heartbeat is false" do
-            let(:allow_public_access_to_heartbeat) { false }
-
-            context "when no credentials are used" do
-              it "does not allow GET" do
-                get path
-                expect(last_response.status).to eq 401
-              end
-            end
-
-            context "when the correct credentials are used" do
-              it "allows GET" do
-                basic_authorize "read_username", "read_password"
-                get path
-                expect(last_response.status).to eq 200
-              end
-            end
-          end
-        end
-
-        context "when requesting a pact badge" do
-          context "when no credentials are used" do
-            it "allows GET" do
-              get "/pacts/provider/foo/consumer/bar/badge"
-              expect(last_response.status).to eq 200
-            end
-          end
-
-          context "when enable_public_badge_access=false" do
-            let(:enable_public_badge_access) { false }
-
-            it "does not allow GET" do
-              get "/pacts/provider/foo/consumer/bar/badge"
-              expect(last_response.status).to eq 401
-            end
-          end
-        end
-
-        context "when requesting a matrix badge" do
-          context "when no credentials are used" do
-            it "allows GET" do
-              get "/matrix/provider/foo/latest/dev/consumer/bar/latest/dev/badge"
-              expect(last_response.status).to eq 200
-            end
-          end
-        end
-
-        context "with the correct username and password for the write user" do
-          it "allows GET" do
-            basic_authorize "write_username", "write_password"
-            get "/"
-            expect(last_response.status).to eq 200
-          end
-
-          it "allows POST" do
-            basic_authorize "write_username", "write_password"
-            post "/"
-            expect(last_response.status).to eq 200
-          end
-
-          it "allows HEAD" do
-            basic_authorize "write_username", "write_password"
-            head "/"
-            expect(last_response.status).to eq 200
-          end
-
-          it "allows OPTIONS" do
-            basic_authorize "write_username", "write_password"
-            options "/"
-            expect(last_response.status).to eq 200
-          end
-
-          it "allows PUT" do
-            basic_authorize "write_username", "write_password"
-            delete "/"
-            expect(last_response.status).to eq 200
-          end
-
-          it "allows PATCH" do
-            basic_authorize "write_username", "write_password"
-            patch "/"
-            expect(last_response.status).to eq 200
-          end
-
-          it "allows DELETE" do
-            basic_authorize "write_username", "write_password"
-            delete "/"
-            expect(last_response.status).to eq 200
-          end
-        end
-
-        context "with the incorrect username for the write user" do
-          it "does not allow POST" do
-            basic_authorize "wrong_username", "write_password"
-            post "/"
-            expect(last_response.status).to eq 401
-          end
-        end
-
-        context "with the incorrect password for the write user" do
-          it "does not allow POST" do
-            basic_authorize "write_username", "wrong_password"
-            post "/"
-            expect(last_response.status).to eq 401
-          end
-        end
-
-        context "with the correct username and password for the read user" do
-          it "allows GET" do
-            basic_authorize "read_username", "read_password"
-            get "/"
-            expect(last_response.status).to eq 200
-          end
-
-          it "allows OPTIONS" do
-            basic_authorize "read_username", "read_password"
-            options "/"
-            expect(last_response.status).to eq 200
-          end
-
-          it "allows HEAD" do
-            basic_authorize "read_username", "read_password"
-            head "/"
-            expect(last_response.status).to eq 200
-          end
-
-          it "does not allow POST" do
-            basic_authorize "read_username", "read_password"
-            post "/"
-            expect(last_response.status).to eq 401
-          end
-
-          it "does not allow PUT" do
-            basic_authorize "read_username", "read_password"
-            put "/"
-            expect(last_response.status).to eq 401
-          end
-
-          it "does not allow PATCH" do
-            basic_authorize "read_username", "read_password"
-            patch "/"
-            expect(last_response.status).to eq 401
-          end
-
-          it "does not allow DELETE" do
-            basic_authorize "read_username", "read_password"
-            delete "/"
-            expect(last_response.status).to eq 401
-          end
-
-          it "allows POST to the pacts for verification endpoint" do
-            basic_authorize "read_username", "read_password"
-            post "/pacts/provider/Foo/for-verification"
-            expect(last_response.status).to eq 200
-          end
-        end
-
-        context "with the incorrect username and password for the write user" do
-          it "does not allow GET" do
-            basic_authorize "write_username", "wrongpassword"
-            get "/"
-            expect(last_response.status).to eq 401
-          end
-        end
-
-        context "with the incorrect username and password for the read user" do
-          it "does not allow GET" do
-            basic_authorize "read_username", "wrongpassword"
-            get "/"
-            expect(last_response.status).to eq 401
-          end
-        end
-
-        context "with a request to the badge URL" do
-          context "with no credentials" do
-            it "allows GET" do
-              get "/pacts/provider/foo/consumer/bar/badge"
-              expect(last_response.status).to eq 200
-            end
-          end
-        end
-
-        context "when there is no read only user configured" do
-          before do
-            allow($stdout).to receive(:puts)
-          end
-
-          let(:read_username) { nil }
-          let(:read_password) { nil }
-
-          context "when allow_public_read_access is false" do
-            context "with no credentials" do
-              it "does not allow a GET" do
-                get "/"
-                expect(last_response.status).to eq 401
-              end
-            end
-
-            context "with empty credentials" do
-              it "does not allow a GET" do
-                basic_authorize("", "")
-                get "/"
-                expect(last_response.status).to eq 401
-              end
-            end
-
-            context "with incorrect credentials" do
-              it "does not allow a GET" do
-                basic_authorize("foo", "bar")
-                get "/"
-                expect(last_response.status).to eq 401
-              end
-            end
-          end
-
-          context "when allow_public_read_access is true" do
-            let(:allow_public_read_access) { true }
-
-            context "with no credentials" do
-              it "allows a GET" do
-                get "/"
-                expect(last_response.status).to eq 200
-              end
-
-              it "does not allow POST" do
-                post "/"
-                expect(last_response.status).to eq 401
-              end
-            end
-
-            context "with empty credentials" do
-              before do
-                basic_authorize("", "")
-              end
-
-              it "allows a GET" do
-                get "/"
-                expect(last_response.status).to eq 200
-              end
-
-              it "does not allow POST" do
-                post "/"
-                expect(last_response.status).to eq 401
-              end
-            end
-
-            context "with incorrect credentials" do
-              before do
-                basic_authorize("foo", "bar")
-              end
-
-              it "allows a GET" do
-                get "/"
-                expect(last_response.status).to eq 200
-              end
-
-              it "does not allow POST" do
-                post "/"
-                expect(last_response.status).to eq 401
-              end
-            end
-          end
-        end
-
-        context "when the credentials are configured with empty strings" do
-          before do
-            basic_authorize("", "")
-          end
-
-          let(:write_username) { "" }
-          let(:write_password) { "" }
-
-          subject { get("/") }
-
-          its(:status) { is_expected.to eq 401 }
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/api/middleware/configuration_spec.rb

@@ -1,43 +0,0 @@
-require "pact_broker/api/middleware/configuration"
-
-module PactBroker
-  module Api
-    module Middleware
-      class TestApp
-        def call(_)
-          [200, {}, [PactBroker.configuration.allow_dangerous_contract_modification.to_s]]
-        end
-      end
-
-      describe Configuration do
-        describe "#call" do
-          let(:configuration) do
-            conf = PactBroker::Configuration.default_configuration
-            conf.allow_dangerous_contract_modification = false
-            conf
-          end
-          let(:app) { Configuration.new(TestApp.new, configuration) }
-          let(:rack_env) { {} }
-
-          subject { get("/", nil, rack_env) }
-
-          context "with no overrides" do
-            it "uses the default configuration" do
-              expect(subject.body).to eq "false"
-            end
-          end
-
-          context "with overrides" do
-            let(:rack_env) do
-              { "pactbroker.configuration_overrides" => { allow_dangerous_contract_modification: true }}
-            end
-
-            it "overrides the configuration for the duration of the request" do
-              expect(subject.body).to eq "true"
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/api/pact_broker_urls_spec.rb

@@ -1,221 +0,0 @@
-require "pact_broker/api/pact_broker_urls"
-
-module PactBroker
-  module Api
-    describe PactBrokerUrls do
-      before do
-        allow(PactBrokerUrls).to receive(:logger).and_return(logger)
-      end
-      let(:logger) { double("logger").as_null_object }
-
-      # Regex find all the URL parameter names
-      # \/\{[^\}\s\[\(\.]+\}
-
-      let(:base_url) { "http://example.org" }
-      let(:consumer_name) { "Foo/Foo" }
-      let(:provider_name) { "Bar/Bar" }
-      let(:pact) do
-        double("pact",
-          consumer: consumer,
-          provider: provider,
-          consumer_version_number: "123/456",
-          pact_version_sha: "5hbfu",
-          consumer_version_tag_names: ["dev"])
-      end
-      let(:consumer) { double("pacticipant", name: consumer_name) }
-      let(:provider) { double("pacticipant", name: provider_name) }
-      let(:verification) do
-        instance_double(PactBroker::Domain::Verification,
-          consumer_name: consumer_name,
-          provider_name: provider_name,
-          pact_version_sha: "1234",
-          number: "1")
-      end
-      let(:version) do
-        double("version",
-          pacticipant: consumer,
-          number: "2/4")
-      end
-      let(:tag) { double("tag", name: "feat/foo", version: version) }
-
-      matcher :match_route_in_api do |api|
-        match do |url|
-          req = Webmachine::Request.new("GET", URI(url), Webmachine::Headers.new, "", nil)
-          api.application.routes.any?{ |route| route.match?(req) }
-        end
-
-        description do
-          "match route in API"
-        end
-
-        failure_message do |_|
-          "expected API to have route for path #{URI.parse(url).path}"
-        end
-
-        failure_message_when_negated do |_|
-          "expected API to not have route for path #{URI.parse(url).path}"
-        end
-      end
-
-      describe "pact_url" do
-        subject { PactBrokerUrls.pact_url(base_url, pact) }
-
-        it { is_expected.to match_route_in_api(PactBroker::API) }
-        it { is_expected.to eq "http://example.org/pacts/provider/Bar%2FBar/consumer/Foo%2FFoo/version/123%2F456" }
-      end
-
-      describe "templated_tag_url_for_pacticipant" do
-        subject { PactBrokerUrls.templated_tag_url_for_pacticipant(provider_name, base_url) }
-
-        it { is_expected.to eq "http://example.org/pacticipants/Bar%2FBar/versions/{version}/tags/{tag}" }
-      end
-
-      describe "pact_triggered_webhooks_url" do
-        subject { PactBrokerUrls.pact_triggered_webhooks_url(pact, base_url) }
-
-        it { is_expected.to match_route_in_api(PactBroker::API) }
-        it { is_expected.to eq "http://example.org/pacts/provider/Bar%2FBar/consumer/Foo%2FFoo/version/123%2F456/triggered-webhooks" }
-      end
-
-      describe "verification_triggered_webhooks_url" do
-        subject { PactBrokerUrls.verification_triggered_webhooks_url(verification, base_url) }
-
-        it { is_expected.to match_route_in_api(PactBroker::API) }
-        it { is_expected.to eq "http://example.org/pacts/provider/Bar%2FBar/consumer/Foo%2FFoo/pact-version/1234/verification-results/1/triggered-webhooks" }
-      end
-
-      describe "verification_publication_url" do
-        context "with no metadata" do
-          subject { PactBrokerUrls.verification_publication_url(verification, base_url) }
-
-          it { is_expected.to match_route_in_api(PactBroker::API) }
-          it { is_expected.to eq "http://example.org/pacts/provider/Bar%2FBar/consumer/Foo%2FFoo/pact-version/1234/metadata//verification-results" }
-        end
-
-        context "with metadata" do
-          subject { PactBrokerUrls.verification_publication_url(verification, base_url, "abcd") }
-
-          it { is_expected.to match_route_in_api(PactBroker::API) }
-          it { is_expected.to eq "http://example.org/pacts/provider/Bar%2FBar/consumer/Foo%2FFoo/pact-version/1234/metadata/abcd/verification-results" }
-        end
-      end
-
-      describe "verification_url_from_params" do
-        context "with consumer_version_number" do
-          let(:params) do
-            {
-              consumer_name: consumer_name,
-              provider_name: provider_name,
-              pact_version_sha: "1234",
-              consumer_version_number: "2",
-              verification_number: "1"
-            }
-          end
-
-          subject { PactBrokerUrls.verification_url_from_params(params, base_url)}
-
-          it { is_expected.to eq "http://example.org/pacts/provider/Bar%2FBar/consumer/Foo%2FFoo/pact-version/1234/metadata/Y3ZuPTI/verification-results/1" }
-        end
-      end
-
-      describe "templated_diff_url" do
-        subject { PactBrokerUrls.templated_diff_url(pact, base_url) }
-
-        it { is_expected.to eq "http://example.org/pacts/provider/Bar%2FBar/consumer/Foo%2FFoo/pact-version/5hbfu/diff/pact-version/{pactVersion}" }
-      end
-
-      describe "webhook metadata" do
-        it "builds the webhook metadata" do
-          encoded_metadata = PactBrokerUrls.encode_metadata("some" => "metadata")
-          expect(PactBrokerUrls.decode_pact_metadata(encoded_metadata)).to eq "some" => "metadata"
-        end
-      end
-
-      describe "decode_pact_metadata" do
-        context "when the metadata is nil" do
-          it "returns an empty hash" do
-            expect(PactBrokerUrls.decode_pact_metadata(nil)).to eq({})
-          end
-        end
-
-        context "when the metadata is empty" do
-          it "returns an empty hash" do
-            expect(PactBrokerUrls.decode_pact_metadata("")).to eq({})
-          end
-        end
-
-        context "with padding" do
-          let(:encoded_metadata) { Base64.urlsafe_encode64("foo=bar", padding: true) }
-
-          it "can still handle it" do
-            expect(PactBrokerUrls.decode_pact_metadata(encoded_metadata)).to eq("foo" => "bar")
-          end
-        end
-
-        context "when the padding has been removed" do
-          let(:encoded_metadata) { Base64.urlsafe_encode64("foo=bar", padding: false) }
-
-          it "can still handle it" do
-            expect(PactBrokerUrls.decode_pact_metadata(encoded_metadata)).to eq("foo" => "bar")
-          end
-        end
-
-        context "another example without the padding" do
-          let(:encoded_metadata) { "c1tdW2xdPXRydWUmc1tdW2" }
-
-          it "can still handle it" do
-            expect(PactBrokerUrls.decode_pact_metadata(encoded_metadata)).to eq({ "s" => [{ "l" => "true" }, nil] })
-          end
-        end
-
-        context "when the metadata is not valid base64" do
-          let(:encoded_metadata) { "%" }
-
-          it "returns an empty hash" do
-            expect(PactBrokerUrls.decode_pact_metadata(encoded_metadata)).to eq({})
-          end
-
-          it "logs a warning" do
-            expect(logger).to receive(:warn).with("Exception parsing webhook metadata: '%'. Parsing using Base64.decode64 returns ''", ArgumentError)
-            PactBrokerUrls.decode_pact_metadata(encoded_metadata)
-          end
-        end
-      end
-
-      describe "latest_verification_for_pact_url" do
-        context "when permalink = true" do
-          subject { PactBrokerUrls.latest_verification_for_pact_url(pact, base_url, true) }
-
-          it { is_expected.to eq "http://example.org/pacts/provider/Bar%2FBar/consumer/Foo%2FFoo/pact-version/5hbfu/verification-results/latest" }
-        end
-
-        context "when permalink = false" do
-          subject { PactBrokerUrls.latest_verification_for_pact_url(pact, base_url, false) }
-
-          it { is_expected.to eq "http://example.org/pacts/provider/Bar%2FBar/consumer/Foo%2FFoo/version/123%2F456/verification-results/latest" }
-        end
-      end
-
-      describe "matrix_for_pacticipant_version_url" do
-        subject { PactBrokerUrls.matrix_for_pacticipant_version_url(version, base_url) }
-
-        it { is_expected.to eq "http://example.org/matrix?q[][pacticipant]=Foo%2FFoo&q[][version]=2%2F4&latestby=cvpv" }
-      end
-
-      describe "matrix_badge_url" do
-        subject { PactBrokerUrls.matrix_badge_url_for_selectors(consumer_selector, provider_selector, base_url) }
-        let(:provider_selector) { PactBroker::Matrix::UnresolvedSelector.new(pacticipant_name: provider_name, tag: "meep", latest: true) }
-        let(:consumer_selector) { PactBroker::Matrix::UnresolvedSelector.new(pacticipant_name: consumer_name, tag: "bar", latest: true) }
-
-        it { is_expected.to eq "http://example.org/matrix/provider/Bar%2FBar/latest/meep/consumer/Foo%2FFoo/latest/bar/badge.svg" }
-      end
-
-      describe "tag_url" do
-        subject { PactBrokerUrls.tag_url(base_url, tag) }
-
-        it { is_expected.to match_route_in_api(PactBroker::API) }
-        it { is_expected.to eq "http://example.org/pacticipants/Foo%2FFoo/versions/2%2F4/tags/feat%2Ffoo" }
-      end
-    end
-  end
-end