pact_broker 2.89.1 → 2.90.0

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

@@ -1,137 +0,0 @@
-require "pact_broker/versions/service"
-
-module PactBroker
-  module Versions
-    describe Service do
-      describe ".maybe_set_version_branch_from_tag" do
-        before do
-          allow(PactBroker.configuration).to receive(:use_first_tag_as_branch).and_return(use_first_tag_as_branch)
-        end
-
-        let(:pacticipant_name) { "test_pacticipant" }
-        let(:version_number) { "1.2.3" }
-        let(:tag_name) { "prod" }
-
-        subject { Service.maybe_set_version_branch_from_tag(td.find_version(pacticipant_name, version_number), tag_name) }
-
-        context "when use_first_tag_as_branch is true" do
-          let(:use_first_tag_as_branch) { true }
-
-          context "when there is already a tag" do
-            before do
-              td.create_consumer(pacticipant_name)
-                .create_consumer_version(version_number, tag_name: "foo")
-            end
-
-            it "does not set the branch" do
-              subject
-              expect(td.find_version(pacticipant_name, version_number).branch).to be_nil
-            end
-          end
-
-          context "when the branch is already set" do
-            before do
-              td.create_consumer(pacticipant_name)
-                .create_consumer_version(version_number, branch: "foo")
-            end
-
-            it "does not update the branch" do
-              subject
-              expect(td.find_version(pacticipant_name, version_number).branch_names).to eq ["foo"]
-            end
-          end
-
-          context "when use_first_tag_as_branch is false" do
-            before do
-              td.create_consumer(pacticipant_name)
-                .create_consumer_version(version_number)
-            end
-
-            let(:use_first_tag_as_branch) { false }
-
-            it "does not set the branch" do
-              subject
-              expect(td.find_version(pacticipant_name, version_number).branch).to be_nil
-            end
-          end
-
-          context "when the version was outside of the time difference limit" do
-            before do
-              version = td.create_consumer(pacticipant_name)
-                .create_consumer_version(version_number)
-                .and_return(:consumer_version)
-
-              version.update(created_at: created_at)
-              allow(PactBroker.configuration).to receive(:use_first_tag_as_branch_time_limit).and_return(10)
-              allow(Time).to receive(:now).and_return(td.in_utc { Time.new(2021, 1, 2, 10, 10, 11) } )
-            end
-
-            let(:created_at) { td.in_utc { Time.new(2021, 1, 2, 10, 10, 0) }.to_datetime  }
-            let(:one_second) { 1/(24 * 60 * 60) }
-
-            it "does not set the branch" do
-              subject
-              expect(td.find_version(pacticipant_name, version_number).branch).to be_nil
-            end
-          end
-
-          context "when the version was created within the limit" do
-            before do
-              version = td
-                .create_consumer(pacticipant_name)
-                .create_consumer_version(version_number)
-                .and_return(:consumer_version)
-
-              version.update(created_at: created_at)
-              allow(PactBroker.configuration).to receive(:use_first_tag_as_branch_time_limit).and_return(10)
-              allow(Time).to receive(:now).and_return(td.in_utc { Time.new(2021, 1, 2, 10, 10, 10) } )
-            end
-
-            let(:created_at) { td.in_utc { Time.new(2021, 1, 2, 10, 10, 0) }.to_datetime  }
-            let(:one_second) { 1/(24 * 60 * 60) }
-
-            it "sets the branch" do
-              subject
-              expect(td.find_version(pacticipant_name, version_number).branch_names).to include "prod"
-            end
-          end
-        end
-      end
-      describe ".delete" do
-        let!(:version) do
-          td
-            .create_consumer
-            .create_provider
-            .create_consumer_version("1.2.3")
-            .create_consumer_version_tag("prod")
-            .create_pact
-            .create_verification(provider_version: "1.0.0")
-            .create_webhook
-            .create_triggered_webhook
-            .create_webhook_execution
-            .and_return(:consumer_version)
-        end
-
-        subject { Service.delete(version) }
-
-        it "deletes the pact publication" do
-          expect{ subject }.to change { PactBroker::Pacts::PactPublication.count }.by(-1)
-        end
-
-        it "deletes the tags" do
-          expect{ subject }.to change { PactBroker::Domain::Tag.count }.by(-1)
-        end
-
-        it "deletes the version" do
-          expect{ subject }.to change { PactBroker::Domain::Version.count }.by(-1)
-        end
-
-        context "when deleting a provider version" do
-          it "deletes associated verifications" do
-            expect { Service.delete(td.provider_version ) }. to change { PactBroker::Domain::Verification.count }.by(-1)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,85 +0,0 @@
-require "pact_broker/webhooks/check_host_whitelist"
-
-module PactBroker
-  module Webhooks
-    describe CheckHostWhitelist do
-      context "when the host is 10.0.0.7" do
-        let(:host) { "10.0.1.0" }
-
-        it "matches 10.0.0.0/8" do
-          expect(CheckHostWhitelist.call(host, ["10.0.0.0/8"])).to eq ["10.0.0.0/8"]
-        end
-
-        it "matches 10.0.1.0" do
-          expect(CheckHostWhitelist.call(host, [host])).to eq [host]
-        end
-
-        it "does not match 10.0.0.2" do
-          expect(CheckHostWhitelist.call(host, ["10.0.0.2"])).to eq []
-        end
-
-        it "does not match 10.0.0.0/28" do
-          expect(CheckHostWhitelist.call(host, ["10.0.0.0/28"])).to eq []
-        end
-      end
-
-      context "when the whitelist includes *.foo.bar" do
-        let(:whitelist) { ["*.foo.bar"] }
-
-        it "matches host a.foo.bar" do
-          expect(CheckHostWhitelist.call("a.foo.bar", whitelist)).to eq whitelist
-        end
-
-        it "does not matche host a.b.foo.bar" do
-          expect(CheckHostWhitelist.call("a.b.foo.bar", whitelist)).to eq []
-        end
-
-        it "does not match a.foo.bar.b" do
-          expect(CheckHostWhitelist.call("a.foo.bar.b", whitelist)).to eq []
-        end
-
-        it "does not match foo.bar" do
-          expect(CheckHostWhitelist.call("foo.bar", whitelist)).to eq []
-        end
-
-        it "does not match 10.0.0.2" do
-          expect(CheckHostWhitelist.call("10.0.0.2", whitelist)).to eq []
-        end
-      end
-
-      context "when the whitelist includes *.2" do
-        it "does not match 10.0.0.2 as that's the wrong way to declare an IP range" do
-          expect(CheckHostWhitelist.call("10.0.0.2", ["*.0.0.2"])).to eq []
-        end
-      end
-
-      context "when the whitelist includes *.foo.*.bar" do
-        let(:whitelist) { ["*.foo.*.bar"] }
-
-        it "does not match host a.foo.b.bar, according to RFC 6125, section 6.4.3, subitem 1" do
-          expect(CheckHostWhitelist.call("a.foo.b.bar", whitelist)).to eq []
-        end
-      end
-
-      context "when the host is localhost" do
-        let(:host) { "localhost" }
-
-        it "matches localhost" do
-          expect(CheckHostWhitelist.call(host, [host])).to eq [host]
-        end
-
-        it "matches /local.*/" do
-          expect(CheckHostWhitelist.call(host, [/local*/])).to eq [/local*/]
-        end
-
-        it "does not match foo" do
-          expect(CheckHostWhitelist.call(host, ["foo"])).to eq []
-        end
-
-        it "does not match /foo.*/" do
-          expect(CheckHostWhitelist.call(host, [/foo*/])).to eq []
-        end
-      end
-    end
-  end
-end

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

@@ -1,18 +0,0 @@
-require "pact_broker/webhooks/execution_configuration"
-
-module PactBroker
-  module Webhooks
-    describe ExecutionConfiguration do
-      subject { ExecutionConfiguration.new }
-
-      it "returns a new object with the updated value" do
-        expect(subject.with_show_response(true)[:logging_options][:show_response]).to eq true
-        expect(subject.with_show_response(false)[:logging_options][:show_response]).to eq false
-      end
-
-      it "deep merges webhook context" do
-        expect(subject.with_webhook_context(a: 1, b: 1).with_webhook_context(b: 2)[:webhook_context]).to eq a: 1, b: 2
-      end
-    end
-  end
-end

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

@@ -1,188 +0,0 @@
-require "pact_broker/webhooks/job"
-require "pact_broker/webhooks/execution_configuration"
-
-module PactBroker
-  module Webhooks
-    describe Job do
-      before do
-        allow(PactBroker::Webhooks::TriggerService).to receive(:execute_triggered_webhook_now).and_return(result)
-        allow(PactBroker::Webhooks::Service).to receive(:update_triggered_webhook_status)
-        allow(PactBroker::Webhooks::TriggeredWebhook).to receive(:find).and_return(triggered_webhook)
-        allow(Job).to receive(:logger).and_return(logger)
-        allow(webhook_execution_configuration).to receive(:with_success_log_message).and_return(webhook_execution_configuration)
-        allow(webhook_execution_configuration).to receive(:with_failure_log_message).and_return(webhook_execution_configuration)
-      end
-
-      let(:base_url) { "http://broker" }
-      let(:triggered_webhook) { instance_double("PactBroker::Webhooks::TriggeredWebhook", webhook_uuid: "1234", id: 1) }
-      let(:result) { instance_double("PactBroker::Domain::WebhookExecutionResult", success?: success) }
-      let(:webhook_execution_configuration) do
-        instance_double(PactBroker::Webhooks::ExecutionConfiguration, retry_schedule: retry_schedule, to_hash: webhook_execution_configuration_hash)
-      end
-      let(:webhook_execution_configuration_hash) { { the: "options" } }
-      let(:success) { true }
-      let(:logger) { double("logger").as_null_object }
-      let(:database_connector) { ->(&block) { block.call } }
-      let(:webhook_context) { { the: "context" } }
-      let(:retry_schedule) { [10, 60, 120, 300, 600, 1200] }
-      let(:job_params) do
-        {
-          triggered_webhook: triggered_webhook,
-          database_connector: database_connector,
-          webhook_execution_configuration: webhook_execution_configuration
-        }
-      end
-
-      subject { Job.new.perform(job_params) }
-
-      it "reloads the TriggeredWebhook object to make sure it has a fresh copy" do
-        expect(PactBroker::Webhooks::TriggeredWebhook).to receive(:find).with(id: 1)
-        subject
-      end
-
-      context "when the job succeeds" do
-        it "does not reschedule the job" do
-          expect(Job).to_not receive(:perform_in)
-          subject
-        end
-
-        it "updates the triggered_webhook status to 'success'" do
-          expect(PactBroker::Webhooks::Service).to receive(:update_triggered_webhook_status)
-            .with(triggered_webhook, TriggeredWebhook::STATUS_SUCCESS)
-          subject
-        end
-      end
-
-      context "when an error occurs for the first time" do
-        before do
-          allow(PactBroker::Webhooks::TriggerService).to receive(:execute_triggered_webhook_now).and_raise(error)
-        end
-
-        let(:error) { "an error" }
-
-        context "when the error is HTTP related (most likely caused by a problem with the webhook or request itself)" do
-          let(:error) { Errno::ECONNREFUSED.new }
-
-          it "logs a message at info" do
-            expect(logger).to receive(:info).with(/Error executing/, error)
-            subject
-          end
-        end
-
-        context "when the error is not HTTP related (most likely caused by a code, platform or environment issue)" do
-          it "logs a message at warn" do
-            expect(logger).to receive(:warn).with(/Error executing/, instance_of(RuntimeError))
-            subject
-          end
-        end
-
-        it "reschedules the job in 10 seconds" do
-          expect(Job).to receive(:perform_in).with(10, hash_including(error_count: 1))
-          subject
-        end
-
-        it "reschedules the job with the passed in data" do
-          expect(Job).to receive(:perform_in).with(10, hash_including(job_params))
-          subject
-        end
-
-        it "updates the triggered_webhook status to 'retrying'" do
-          expect(PactBroker::Webhooks::Service).to receive(:update_triggered_webhook_status)
-            .with(triggered_webhook, TriggeredWebhook::STATUS_RETRYING)
-          subject
-        end
-      end
-
-      context "when the webhook execution result is not successful for the first time" do
-        let(:success) { false }
-
-        it "reschedules the job in 10 seconds" do
-          expect(Job).to receive(:perform_in).with(10, hash_including(error_count: 1))
-          subject
-        end
-
-        it "sets the success and failure messages" do
-          expect(webhook_execution_configuration).to receive(:with_success_log_message).with("Successfully executed webhook")
-          expect(webhook_execution_configuration).to receive(:with_failure_log_message).with("Retrying webhook in 10 seconds")
-          subject
-
-        end
-
-        it "executes the job with an log message indicating that the webhook will be retried" do
-          expect(PactBroker::Webhooks::TriggerService).to receive(:execute_triggered_webhook_now)
-            .with(triggered_webhook, webhook_execution_configuration_hash)
-          subject
-        end
-
-        it "updates the triggered_webhook status to 'retrying'" do
-          expect(PactBroker::Webhooks::Service).to receive(:update_triggered_webhook_status)
-            .with(triggered_webhook, TriggeredWebhook::STATUS_RETRYING)
-          subject
-        end
-      end
-
-      context "when an error occurs for the second time" do
-        before do
-          allow(PactBroker::Webhooks::TriggerService).to receive(:execute_triggered_webhook_now).and_raise("an error")
-          job_params[:error_count] = 1
-        end
-
-        it "reschedules the job in 60 seconds" do
-          expect(Job).to receive(:perform_in).with(60, hash_including(error_count: 2))
-          subject
-        end
-
-        it "updates the triggered_webhook status to 'retrying'" do
-          expect(PactBroker::Webhooks::Service).to receive(:update_triggered_webhook_status)
-            .with(triggered_webhook, TriggeredWebhook::STATUS_RETRYING)
-          subject
-        end
-      end
-
-      context "when the job is not successful for the last time" do
-        before do
-          job_params[:error_count] = 6
-        end
-
-        let(:success) { false }
-
-        it "executes the job with an log message indicating that the webhook has failed" do
-          expect(webhook_execution_configuration).to receive(:with_failure_log_message).with("Webhook execution failed after 7 attempts")
-          expect(webhook_execution_configuration).to receive(:with_success_log_message).with("Successfully executed webhook")
-
-          expect(PactBroker::Webhooks::TriggerService).to receive(:execute_triggered_webhook_now)
-            .with(triggered_webhook, webhook_execution_configuration_hash)
-          subject
-        end
-
-        it "does not reschedule the job" do
-          expect(Job).to_not receive(:perform_in)
-          subject
-        end
-
-        it "logs that it has failed" do
-          allow(Job.logger).to receive(:info)
-          expect(Job.logger).to receive(:info).with(/Failed to execute/)
-          subject
-        end
-
-        it "updates the triggered_webhook status to 'failed'" do
-          expect(PactBroker::Webhooks::Service).to receive(:update_triggered_webhook_status).with(triggered_webhook, TriggeredWebhook::STATUS_FAILURE)
-          subject
-        end
-      end
-
-      context "when the webhook gets deleted between executions" do
-        before do
-          allow(PactBroker::Webhooks::TriggeredWebhook).to receive(:find).and_return(nil)
-        end
-
-        it "does not reschedule the job" do
-          expect(Job).to_not receive(:perform_in)
-          expect(logger).to receive(:info).with(/Could not find webhook with id: 1/)
-          subject
-        end
-      end
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-require "pact_broker/webhooks/pact_and_verification_parameters"
-require "pact_broker/messages"
-
-module PactBroker
-  module Webhooks
-    describe PactAndVerificationParameters do
-      PactAndVerificationParameters::ALL.each do | parameter |
-        describe parameter do
-          it "has a description in lib/pact_broker/locale/en.yml" do
-            expect(PactBroker::Messages.message("messages.webhooks.parameters.#{parameter}", default: nil)).to_not be_nil
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,60 +0,0 @@
-require "pact_broker/webhooks/redact_logs"
-
-module PactBroker
-  module Webhooks
-    describe RedactLogs do
-      describe ".call" do
-        let(:values) { [] }
-
-        let(:string) do
-          "Authorization: foo\nX-Thing: bar"
-        end
-
-        let(:x_auth_string) do
-          "X-Authorization: bar foo\nX-Thing: bar"
-        end
-
-        let(:x_auth_token) do
-          "X-Auth-Token: bar foo\nX-Thing: bar"
-        end
-
-        let(:x_authorization_token) do
-          "X-Authorization-Token: bar foo\nX-Thing: bar"
-        end
-
-        let(:string_lower) do
-          "authorization: foo\nX-Thing: bar"
-        end
-
-        it "hides the value of the Authorization header" do
-          expect(RedactLogs.call(string, values)).to eq "Authorization: [REDACTED]\nX-Thing: bar"
-        end
-
-        it "hides the value of the X-Authorization header" do
-          expect(RedactLogs.call(x_auth_string, values)).to eq "X-Authorization: [REDACTED]\nX-Thing: bar"
-        end
-
-        it "hides the value of the X-Auth-Token header" do
-          expect(RedactLogs.call(x_auth_token, values)).to eq "X-Auth-Token: [REDACTED]\nX-Thing: bar"
-        end
-
-        it "hides the value of the X-Authorization-Token header" do
-          expect(RedactLogs.call(x_authorization_token, values)).to eq "X-Authorization-Token: [REDACTED]\nX-Thing: bar"
-        end
-
-        it "hides the value of the authorization header" do
-          expect(RedactLogs.call(string_lower, values)).to eq "authorization: [REDACTED]\nX-Thing: bar"
-        end
-
-        context "with values" do
-          let(:values) { %w[foo bar] }
-          let(:string) { "blahfoo\nbar wiffle" }
-
-          it "hides the passed in values" do
-            expect(RedactLogs.call(string, values)).to eq "blah********\n******** wiffle"
-          end
-        end
-      end
-    end
-  end
-end