pact_broker 2.89.1 → 2.90.0

data/spec/lib/pact_broker/webhooks/webhook_request_logger_spec.rb

@@ -1,207 +0,0 @@
-require "pact_broker/webhooks/webhook_request_logger"
-require "pact_broker/domain/webhook_request"
-
-module PactBroker
-  module Webhooks
-    describe WebhookRequestLogger do
-      before do
-        if response
-          response_headers.each do | key, value |
-            allow(response).to receive(:each_header).and_yield(key, value)
-          end
-        end
-        allow(webhook_request_logger).to receive(:logger).and_return(logger)
-        subject
-      end
-
-      let(:logger) { double("logger").as_null_object }
-      let(:uuid) { "uuid" }
-      let(:options) { { failure_log_message: "oops", show_response: show_response, http_code_success: [200] } }
-      let(:show_response) { true }
-      let(:username) { nil }
-      let(:password) { nil }
-      let(:url) { "http://example.org/hook" }
-      let(:headers) { {"Content-Type" => "text/plain", "Authorization" => "foo"} }
-      let(:body) { "reqbody" }
-      let(:webhook_request) do
-        PactBroker::Domain::WebhookRequest.new(
-          method: "post",
-          url: url,
-          headers: headers,
-          username: username,
-          password: password,
-          body: body)
-      end
-      let(:error) { nil }
-      let(:status) { 200 }
-      let(:response) do
-        double("response",
-          http_version: "1.0",
-          message: "OK",
-          code: status,
-          body: response_body,
-          to_hash: response_headers
-        )
-      end
-      let(:response_body) { "respbod" }
-      let(:response_headers) do
-        {
-          "content-type" => "text/foo, blah"
-        }
-      end
-
-      let(:base_url) { "http://example.org" }
-      let(:webhook_context) { { consumer_version_number: "123", base_url: base_url } }
-
-      let(:webhook_request_logger) { WebhookRequestLogger.new(options) }
-      let(:success) { true }
-
-      subject(:logs) { webhook_request_logger.log(uuid, webhook_request, response, success, error, webhook_context) }
-
-      describe "application logs" do
-        it "logs the request" do
-          expect(logger).to have_received(:info).with(/POST.*example/)
-          expect(logger).to have_received(:debug).with(/.*text\/plain/)
-          expect(logger).to have_received(:debug).with(/.*reqbody/)
-        end
-
-        it "logs the response" do
-          expect(logger).to have_received(:info).with(/response.*200/)
-          expect(logger).to have_received(:debug).with(/text\/foo/)
-          expect(logger).to have_received(:debug).with(/respbod/)
-        end
-      end
-
-      describe "execution logs" do
-        it "logs the application context" do
-          expect(logs).to include webhook_context.to_json
-        end
-
-        it "logs the request method and path" do
-          expect(logs).to include "POST http://example.org/hook"
-        end
-
-        it "logs the request headers" do
-          expect(logs).to include "content-type: text/plain"
-        end
-
-        it "logs the request body" do
-          expect(logs).to include body
-        end
-
-        context "when show_response is true" do
-          it "logs the response status" do
-            expect(logs).to include "HTTP/1.0 200"
-          end
-
-          it "logs the response headers" do
-            expect(logs).to include "content-type: text/foo, blah"
-          end
-
-          it "logs the response body" do
-            expect(logs).to include "respbod"
-          end
-        end
-
-        context "when show_response is false" do
-          let(:show_response) { false }
-
-          it "does not log the response status" do
-            expect(logs).to_not include "HTTP/1.0 200"
-          end
-
-          it "does not log the response headers" do
-            expect(logs).to_not include "content-type: text/foo, blah"
-          end
-
-          it "does not log the response body" do
-            expect(logs).to_not include "respbod"
-          end
-
-          it "logs a message about why the response is hidden" do
-            expect(logs).to include base_url
-            expect(logs).to include "security purposes"
-          end
-        end
-
-        context "when the response code is a success" do
-          it "does not log the failure_log_message" do
-            expect(logs).to_not include "oops"
-          end
-        end
-
-        context "when the status is not successful" do
-          let(:success) { false }
-
-          it "logs the failure_log_message" do
-            expect(logs).to include "oops"
-          end
-        end
-
-        context "with basic auth" do
-          let(:headers) { { "authorization" => "foo" } }
-
-          it "logs the Authorization header with a starred value" do
-            expect(logs).to include "authorization: **********"
-          end
-        end
-
-        context "when the response body contains a non UTF-8 character" do
-          let(:response_body) { "This has some \xC2 invalid chars" }
-
-          it "logs the safe body so it doesn't blow up the database" do
-            expect(logs).to include "This has some  invalid chars"
-          end
-
-          it "logs that it has cleaned the string to the execution logger" do
-            expect(logs).to include("Note that invalid UTF-8 byte sequences were removed")
-          end
-        end
-
-        context "when an error occurs executing the request" do
-
-          class WebhookTestError < StandardError; end
-
-          before do
-            allow(error).to receive(:backtrace).and_return([])
-          end
-
-          let(:response) { nil }
-          let(:success) { false }
-          let(:error) do
-            err = WebhookTestError.new("blah")
-            allow(err).to receive(:backtrace).and_return([])
-            err
-          end
-
-          it "logs the error" do
-            expect(logger).to have_received(:info).with(/Error.*WebhookTestError.*blah/)
-          end
-
-          it "logs the failure_log_message" do
-            expect(logs).to include "oops"
-          end
-
-          context "when show_response is true" do
-            it "logs the exception information" do
-              expect(logs).to include "blah"
-            end
-          end
-
-          context "when show_response is false" do
-            let(:show_response) { false }
-
-            it "does not logs the exception information" do
-              expect(logs).to_not include "blah"
-            end
-
-            it "logs a message about why the response is hidden" do
-              expect(logs).to include base_url
-              expect(logs).to include "security purposes"
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/webhooks/webhook_request_template_spec.rb

@@ -1,227 +0,0 @@
-require "pact_broker/webhooks/webhook_request_template"
-
-module PactBroker
-  module Webhooks
-    describe WebhookRequestTemplate do
-      let(:attributes) do
-        {
-          method: "POST",
-          url: url,
-          username: username,
-          password: password,
-          uuid: "1234",
-          body: body,
-          headers: headers
-        }
-      end
-
-      let(:new_attributes) do
-        {
-          method: "POST",
-          url: built_url,
-          username: "usernameBUILT",
-          password: "passwordBUILT",
-          uuid: "1234",
-          body: built_body,
-          headers: {"headername" => "headervalueBUILT"},
-          user_agent: "Pact Broker"
-        }
-      end
-
-      let(:username) { "username" }
-      let(:password) { "password" }
-      let(:headers) { {"headername" => "headervalue"} }
-      let(:url) { "http://example.org/hook?foo=bar" }
-      let(:base_url) { "http://broker" }
-      let(:built_url) { "http://example.org/hook?foo=barBUILT" }
-      let(:body) { { foo: "bar" } }
-      let(:built_body) { '{"foo":"bar"}BUILT' }
-
-      describe "#build" do
-        before do
-          allow(PactBroker::Webhooks::Render).to receive(:call) do | content, _pact, _verification |
-            content + "BUILT"
-          end
-        end
-
-        let(:params_hash) { double("params hash") }
-
-        subject { WebhookRequestTemplate.new(attributes).build(params_hash, "Pact Broker") }
-
-        it "renders the url template" do
-          expect(PactBroker::Webhooks::Render).to receive(:call).with(url, params_hash) do | content, pact, verification, &block |
-            expect(content).to eq url
-            expect(pact).to be pact
-            expect(verification).to be verification
-            expect(block.call("foo bar")).to eq "foo+bar"
-            built_url
-          end
-          subject
-        end
-
-        context "when the body is a string" do
-          let(:body) { "body" }
-
-          it "renders the body template with the String" do
-            expect(PactBroker::Webhooks::Render).to receive(:call).with("body", params_hash)
-            subject
-          end
-        end
-
-        context "when the body is an object" do
-          let(:request_body_string) { '{"foo":"bar"}' }
-
-          it "renders the body template with JSON" do
-            expect(PactBroker::Webhooks::Render).to receive(:call).with(request_body_string, params_hash)
-            subject
-          end
-        end
-
-        it "renders each header value" do
-          expect(PactBroker::Webhooks::Render).to receive(:call).with("headervalue", params_hash)
-          subject
-        end
-
-        it "renders the username" do
-          expect(PactBroker::Webhooks::Render).to receive(:call).with("username", params_hash)
-          subject
-        end
-
-        it "renders the password" do
-          expect(PactBroker::Webhooks::Render).to receive(:call).with("password", params_hash)
-          subject
-        end
-
-        it "creates a new PactBroker::Domain::WebhookRequest" do
-          expect(PactBroker::Domain::WebhookRequest).to receive(:new).with(new_attributes)
-          subject
-        end
-
-        context "when optional attributes are missing" do
-          let(:attributes) do
-            {
-              method: "POST",
-              url: url,
-              uuid: "1234",
-            }
-          end
-
-          it "does not blow up" do
-            subject
-          end
-        end
-      end
-
-      describe "redacted_headers" do
-        subject { WebhookRequestTemplate.new(attributes) }
-
-        let(:headers) do
-          {
-            "Authorization" => "foo",
-            "X-authorization" => "bar",
-            "Token" => "bar",
-            "X-Auth-Token" => "bar",
-            "X-Authorization-Token" => "bar",
-            "OK" => "ok"
-          }
-        end
-
-        let(:expected_headers) do
-          {
-            "Authorization" => "**********",
-            "X-authorization" => "**********",
-            "Token" => "**********",
-            "X-Auth-Token" => "**********",
-            "X-Authorization-Token" => "**********",
-            "OK" => "ok"
-          }
-        end
-
-        it "redacts sensitive headers" do
-          expect(subject.redacted_headers).to eq expected_headers
-        end
-
-        context "when there is a parameter in the value" do
-          let(:headers) do
-            {
-              "Authorization" => "${pactbroker.secret}"
-            }
-          end
-
-          let(:expected_headers) do
-            {
-              "Authorization" => "${pactbroker.secret}"
-            }
-          end
-
-          it "does not redact it" do
-            expect(subject.redacted_headers).to eq expected_headers
-          end
-        end
-      end
-
-      describe "display_password" do
-        subject { WebhookRequestTemplate.new(attributes) }
-
-        context "when it is nil" do
-          let(:password) { nil }
-
-          its(:display_password) { is_expected.to be nil }
-        end
-
-        context "when the password contains a parameter" do
-          let(:password) { "${pactbroker.foo}" }
-
-          its(:display_password) { is_expected.to eq password }
-        end
-
-        context "when the password does not contains a parameter" do
-          let(:password) { "foo" }
-
-          its(:display_password) { is_expected.to eq "**********" }
-        end
-      end
-
-      describe "template_parameters" do
-        subject { WebhookRequestTemplate.new(attributes) }
-
-        context "with a JSON body" do
-          let(:url) { "http://localhost?token=${bar.thing}"}
-          let(:body) do
-            {
-              "someKey" => "${pactbroker.something}",
-              "${pactbroker.someKey}" => "blah",
-              "blah" => "${foo.someFoo}"
-            }
-          end
-          let(:headers) do
-            {
-              "name" => "${header.thing}"
-            }
-          end
-
-          let(:username) { "${foo.username}" }
-          let(:password) { "${foo.password}" }
-
-          its(:template_parameters) { is_expected.to eq ["pactbroker.something", "pactbroker.someKey", "foo.someFoo", "bar.thing", "header.thing", "foo.username", "foo.password"] }
-          its(:body_template_parameters) { is_expected.to eq ["pactbroker.something", "pactbroker.someKey", "foo.someFoo"] }
-          its(:header_template_parameters) { is_expected.to eq ["header.thing"] }
-          its(:url_template_parameters) { is_expected.to eq ["bar.thing"] }
-          its(:credentials_template_parameters) { is_expected.to eq ["foo.username", "foo.password"]}
-
-          context "with a scope specified" do
-            it "returns the template_parameters that start with the specified scope" do
-              expect(subject.template_parameters("foo")).to eq ["foo.someFoo", "foo.username", "foo.password"]
-            end
-          end
-        end
-
-        context "with a string body" do
-          let(:body) { "${pactbroker.someKey} ${pactbroker.someOtherKey} ${pactbroker.someOtherKey} ${pactbroker.withSpace } pactbroker.invalid" }
-
-          its(:template_parameters) { is_expected.to eq ["pactbroker.someKey", "pactbroker.someOtherKey"] }
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/webhooks/webhook_spec.rb

@@ -1,39 +0,0 @@
-require "pact_broker/webhooks/webhook"
-
-module PactBroker
-  module Webhooks
-    describe Webhook do
-      before do
-        td.create_consumer("Foo")
-          .create_provider("Bar")
-          .create_label("label1")
-          .create_consumer_version
-          .create_pact
-          .create_global_webhook
-          .create_consumer_webhook
-          .create_provider_webhook
-          .create_provider("Wiffle")
-          .create_provider_webhook
-          .create_webhook(provider: nil, consumer: nil, provider_label: "label1")
-          .create_webhook(provider: nil, consumer: nil, consumer_label: "label2", provider_label: "label1")
-      end
-
-      let(:consumer) { PactBroker::Domain::Pacticipant.find(name: "Foo") }
-      let(:provider) { PactBroker::Domain::Pacticipant.find(name: "Bar") }
-      let(:pact) { PactBroker::Pacts::PactPublication.find(id: td.pact.id) }
-
-      describe "#is_for?" do
-        let(:matching_webhook_uuids) { Webhooks::Webhook.find_by_consumer_and_or_provider(consumer, provider).collect(&:uuid) }
-        let(:matching_webhooks) { Webhooks::Webhook.where(uuid: matching_webhook_uuids) }
-        let(:non_matching_webhooks) { Webhooks::Webhook.exclude(uuid: matching_webhook_uuids) }
-
-        it "matches the implementation of Webhook::Repository#find_by_consumer_and_or_provider" do
-          expect(matching_webhooks).not_to be_empty
-          expect(non_matching_webhooks).not_to be_empty
-          expect(matching_webhooks.reject{|w| w.is_for?(pact)}).to be_empty
-          expect(non_matching_webhooks.reject{|w| !w.is_for?(pact)}).to be_empty
-        end
-      end
-    end
-  end
-end

data/spec/lib/rack/hal_browser/redirect_spec.rb

@@ -1,63 +0,0 @@
-require "rack/test"
-require "rack/hal_browser/redirect"
-
-module Rack
-  module HalBrowser
-    describe Redirect do
-      include Rack::Test::Methods
-
-      let(:inner_app) do
-        ->(_env) { [200, {"Content-Type" => "text/html"}, ["All good!"]] }
-      end
-
-      let(:app) { Redirect.new(inner_app) }
-
-      it "passes non-html requests straight through" do
-        get "/", {}, "HTTP_ACCEPT" => "application/hal+json"
-        expect(last_response).to be_ok
-        expect(last_response.headers["Content-Type"]).to eq "text/html"
-        expect(last_response.body).to eq "All good!"
-      end
-
-      context "when client accepts html and json" do
-
-        it "redirects to the HAL browser" do
-          get "/", {}, "HTTP_ACCEPT" => "text/html,application/hal+json"
-          follow_redirect!
-          expect(last_request.url).to eq "http://example.org/hal-browser/browser.html"
-        end
-
-        it "passes the original request path to the HAL browser via the fragment" do
-          get "/foo", {}, "HTTP_ACCEPT" => "text/html,application/hal+json"
-          expect(last_response.headers["Location"]).to eq "/hal-browser/browser.html#/foo"
-        end
-
-      end
-
-      context "when a path is excluded" do
-
-        let(:app) { Redirect.new(inner_app, :exclude => "/foo") }
-
-        it "passes requests to the excluded path straight through" do
-          get "/foo", {}, "HTTP_ACCEPT" => "text/html"
-          expect(last_response).to be_ok
-          expect(last_response.headers["Content-Type"]).to eq "text/html"
-          expect(last_response.body).to eq "All good!"
-        end
-
-      end
-
-      context "when clent uses non GET verb" do
-
-        it "passes requests to the excluded path straight through" do
-          post "/foo", {}, "HTTP_ACCEPT" => "text/html"
-          expect(last_response).to be_ok
-          expect(last_response.headers["Content-Type"]).to eq "text/html"
-          expect(last_response.body).to eq "All good!"
-        end
-
-      end
-
-    end
-  end
-end

data/spec/lib/rack/pact_broker/add_pact_broker_version_header_spec.rb

@@ -1,16 +0,0 @@
-require "rack/pact_broker/add_pact_broker_version_header"
-
-module Rack
-  module PactBroker
-    describe AddPactBrokerVersionHeader do
-
-      let(:app) { AddPactBrokerVersionHeader.new(->(_env){[200, {}, []]}) }
-
-      it "adds the PactBroker version as a header" do
-        get "/"
-        expect(last_response.headers["X-Pact-Broker-Version"]).to match(/\d/)
-      end
-
-    end
-  end
-end

data/spec/lib/rack/pact_broker/database_transaction_spec.rb

@@ -1,77 +0,0 @@
-require "tasks/database"
-require "rack/pact_broker/database_transaction"
-
-module Rack
-  module PactBroker
-    describe DatabaseTransaction, no_db_clean: true do
-
-      before do
-        ::PactBroker::Database.truncate
-      end
-
-      after do
-        ::PactBroker::Database.truncate
-      end
-
-      let(:headers) { {} }
-
-      let(:api) do
-        ->(_env) { ::PactBroker::Domain::Pacticipant.create(name: "Foo"); [500, headers, []] }
-      end
-
-      let(:app) do
-        ::Rack::PactBroker::DatabaseTransaction.new(api, ::PactBroker::DB.connection)
-      end
-
-      let(:rack_headers) { {} }
-
-      subject { self.send(http_method, "/", nil, rack_headers) }
-
-      it "sets the pactbroker.database_connector on the env" do
-        actual_env = nil
-        allow(api).to receive(:call) do | env |
-          actual_env = env
-          [200, {}, {}]
-        end
-        subject
-        expect(actual_env).to have_key("pactbroker.database_connector")
-      end
-
-      context "when the pactbroker.database_connector already exists" do
-        let(:rack_headers) { { "pactbroker.database_connector" => existing_database_connector } }
-        let(:existing_database_connector) { double("existing database connector") }
-
-        it "does not overwrite it" do
-          expect(api).to receive(:call).with(hash_including("pactbroker.database_connector" => existing_database_connector)).and_call_original
-          subject
-        end
-      end
-
-      context "for get requests" do
-        let(:http_method) { :get }
-
-        it "does not use a transaction" do
-          expect { subject }.to change { ::PactBroker::Domain::Pacticipant.count }.by(1)
-        end
-      end
-
-      [:post, :put, :patch, :delete].each do | http_meth |
-        let(:http_method) { http_meth }
-        context "for #{http_meth} requests" do
-          it "uses a transaction and rollsback if there is a 500 error" do
-            expect { subject }.to change { ::PactBroker::Domain::Pacticipant.count }.by(0)
-          end
-        end
-      end
-
-      context "when there is an error but the resource sets the no rollback header" do
-        let(:headers) { {::PactBroker::DO_NOT_ROLLBACK => "true"} }
-        let(:http_method) { :post }
-
-        it "does not roll back" do
-          expect { subject }.to change { ::PactBroker::Domain::Pacticipant.count }.by(1)
-        end
-      end
-    end
-  end
-end

data/spec/lib/rack/pact_broker/invalid_uri_protection_spec.rb

@@ -1,50 +0,0 @@
-require "rack/pact_broker/invalid_uri_protection"
-
-module Rack
-  module PactBroker
-    describe InvalidUriProtection do
-      let(:target_app) { ->(_env){ [200, {}, []] } }
-      let(:app) { InvalidUriProtection.new(target_app) }
-      let(:path) { "/foo" }
-
-      subject { get(path) }
-
-      context "with a URI that the Ruby default URI library cannot parse" do
-        let(:path) { "/badpath" }
-
-        before do
-          # Can't use or stub URI.parse because rack test uses it to execute the actual test
-          allow_any_instance_of(InvalidUriProtection).to receive(:parse).and_raise(URI::InvalidURIError)
-        end
-
-        it "returns a 404" do
-          expect(subject.status).to eq 404
-        end
-      end
-
-      context "when the URI can be parsed" do
-        it "passes the request to the underlying app" do
-          expect(subject.status).to eq 200
-        end
-
-        context "when the URI contains a new line because someone forgot to strip the result of `git rev-parse HEAD`, and I have totally never done this before myself" do
-          let(:path) { "/foo%0A/bar" }
-
-          it "returns a 422" do
-            expect(subject.status).to eq 422
-            expect(subject.body).to include "new line"
-          end
-        end
-
-        context "when the URI contains a tab because sooner or later someone is eventually going to do this" do
-          let(:path) { "/foo%09/bar" }
-
-          it "returns a 422" do
-            expect(subject.status).to eq 422
-            expect(subject.body).to include "tab"
-          end
-        end
-      end
-    end
-  end
-end