pact_broker 2.89.1 → 2.90.0

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

@@ -1,168 +0,0 @@
-require "pact_broker/domain/webhook"
-
-module PactBroker
-  module Domain
-    describe Webhook do
-      let(:uuid) { "uuid" }
-      let(:consumer) { Pacticipant.new(name: "Consumer")}
-      let(:provider) { Pacticipant.new(name: "Provider")}
-      let(:request_template) { instance_double(PactBroker::Webhooks::WebhookRequestTemplate, build: webhook_request)}
-      let(:webhook_request) { instance_double(PactBroker::Domain::WebhookRequest, execute: http_response, http_request: http_request) }
-      let(:webhook_template_parameters) { instance_double(PactBroker::Webhooks::PactAndVerificationParameters, to_hash: webhook_template_parameters_hash) }
-      let(:webhook_template_parameters_hash) { { "foo" => "bar" } }
-      let(:http_request) { double("http request") }
-      let(:http_response) { double("http response", code: response_code) }
-      let(:response_code) { "200" }
-      let(:event_context) { { some: "things" } }
-      let(:logging_options) { { other: "options" } }
-      let(:options) { { logging_options: logging_options, http_success_codes: [200], user_agent: "user agent" } }
-      let(:pact) { double("pact") }
-      let(:verification) { double("verification") }
-      let(:logger) { double("logger").as_null_object }
-
-      before do
-        allow(webhook).to receive(:logger).and_return(logger)
-        allow(PactBroker::Webhooks::PactAndVerificationParameters).to receive(:new).and_return(webhook_template_parameters)
-      end
-
-      subject(:webhook) { Webhook.new(uuid: uuid, request: request_template, consumer: consumer, provider: provider) }
-
-      describe "scope_description" do
-        subject { webhook.scope_description }
-
-        context "with a consumer and provider" do
-          it { is_expected.to eq "A webhook for the pact between Consumer and Provider" }
-
-          context "when provider is specified by a label" do
-            let(:provider) { WebhookPacticipant.new(label: "provider-label")}
-
-            it { is_expected.to eq "A webhook for the pact between Consumer and providers labeled 'provider-label'" }
-          end
-
-          context "when consumer is specified by a label" do
-            let(:consumer) { WebhookPacticipant.new(label: "consumer-label")}
-
-            it { is_expected.to eq "A webhook for the pact between consumers labeled 'consumer-label' and Provider" }
-          end
-
-          context "when both are specified by labels" do
-            let(:consumer) { WebhookPacticipant.new(label: "consumer-label")}
-            let(:provider) { WebhookPacticipant.new(label: "provider-label")}
-
-            it do
-              is_expected.to eq(
-                "A webhook for the pact between consumers labeled 'consumer-label' and providers labeled 'provider-label'"
-              )
-            end
-          end
-        end
-
-        context "with a consumer only" do
-          let(:provider) { nil }
-
-          it { is_expected.to eq "A webhook for all pacts with consumer Consumer" }
-
-          context "when specified by a label" do
-            let(:consumer) { WebhookPacticipant.new(label: "consumer-label")}
-
-            it { is_expected.to eq "A webhook for all pacts with consumer labeled 'consumer-label'" }
-          end
-        end
-
-        context "with a provider only" do
-          let(:consumer) { nil }
-
-          it { is_expected.to eq "A webhook for all pacts with provider Provider" }
-
-          context "when specified by a label" do
-            let(:provider) { WebhookPacticipant.new(label: "provider-label")}
-
-            it { is_expected.to eq "A webhook for all pacts with provider labeled 'provider-label'" }
-          end
-        end
-
-        context "with neither a consumer nor a provider" do
-          let(:consumer) { nil }
-          let(:provider) { nil }
-
-          it { is_expected.to eq "A webhook for all pacts" }
-        end
-      end
-
-      describe "execute" do
-        before do
-          allow(request_template).to receive(:build).and_return(webhook_request)
-          allow(PactBroker::Webhooks::WebhookRequestLogger).to receive(:new).and_return(webhook_request_logger)
-        end
-
-        let(:webhook_request_logger) { instance_double(PactBroker::Webhooks::WebhookRequestLogger, log: "logs") }
-
-        let(:execute) { subject.execute(pact, verification, event_context, options) }
-
-        it "creates the template parameters" do
-          expect(PactBroker::Webhooks::PactAndVerificationParameters).to receive(:new).with(
-            pact, verification, event_context
-          )
-          execute
-        end
-
-        it "builds the request" do
-          expect(request_template).to receive(:build).with(webhook_template_parameters_hash, "user agent")
-          execute
-        end
-
-        it "executes the request" do
-          expect(webhook_request).to receive(:execute)
-          execute
-        end
-
-        it "generates the execution logs" do
-          expect(webhook_request_logger).to receive(:log).with(uuid, webhook_request, http_response, true, nil, event_context)
-          execute
-        end
-
-        it "returns a WebhookExecutionResult" do
-          expect(execute.request).to_not be nil
-          expect(execute.response).to_not be nil
-          expect(execute.logs).to eq "logs"
-          expect(execute.error).to be nil
-          expect(execute.success?).to be true
-        end
-
-        it "logs before and after" do
-          allow(logger).to receive(:info)
-          expect(logger).to receive(:info).with(/Executing/)
-          execute
-        end
-
-        context "when a response status is returned that is not in the http_success_codes" do
-          let(:response_code) { "301" }
-
-          it "returns a result with success? false" do
-            expect(execute.success?).to be false
-          end
-        end
-
-        context "when an error is thrown" do
-          let(:error_class) { Class.new(StandardError) }
-
-          before do
-            allow(webhook_request).to receive(:execute).and_raise(error_class)
-          end
-
-          it "generates the execution logs" do
-            expect(webhook_request_logger).to receive(:log).with(uuid, webhook_request, nil, false, instance_of(error_class), event_context)
-            execute
-          end
-
-          it "returns a WebhookExecutionResult with an error" do
-            expect(execute.request).to_not be nil
-            expect(execute.response).to be nil
-            expect(execute.logs).to eq "logs"
-            expect(execute.error).to_not be nil
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/errors/error_logger_spec.rb

@@ -1,65 +0,0 @@
-require "pact_broker/errors/error_logger"
-
-module PactBroker
-  module Errors
-    describe ErrorLogger do
-      before do
-        allow(ErrorLogger).to receive(:logger).and_return(logger)
-        allow(error).to receive(:backtrace).and_return(["backtrace"])
-        allow(PactBroker::Errors).to receive(:reportable_error?).and_return(reportable)
-      end
-
-      let(:logger) { double("logger").as_null_object }
-      let(:error) { StandardError.new("test error") }
-      let(:env) { double("env") }
-      let(:error_reference) { "bYWfnyWPlf" }
-      let(:reportable) { true }
-
-      subject { ErrorLogger.call(error, error_reference, env) }
-
-      context "when the error class is in the warning_error_classes list" do
-        before do
-          allow(PactBroker.configuration).to receive(:warning_error_classes).and_return([Sequel::ForeignKeyConstraintViolation])
-        end
-        let(:error) { Sequel::ForeignKeyConstraintViolation.new }
-
-        it "logs at warn so as not to wake everyone up in the middle of the night" do
-          expect(logger).to receive(:warn).with(/bYWfnyWPlf/, error)
-          subject
-        end
-      end
-
-      context "when the error cause class is in the warning_error_classes list" do
-        class TestCauseError < StandardError; end
-
-        before do
-          allow(PactBroker.configuration).to receive(:warning_error_classes).and_return([TestCauseError])
-          allow(error).to receive(:cause).and_return(TestCauseError.new)
-        end
-
-        let(:error) { StandardError.new("message") }
-
-        it "logs at warn so as not to wake everyone up in the middle of the night" do
-          expect(logger).to receive(:warn).with(/bYWfnyWPlf/, error)
-          subject
-        end
-      end
-
-      context "when the error is reportable" do
-        it "logs at error" do
-          expect(ErrorLogger).to receive(:log_error).with(error, /bYWfnyWPlf/)
-          subject
-        end
-      end
-
-      context "when the error is not reportable and not a warning level" do
-        let(:reportable) { false }
-
-        it "logs at info" do
-          expect(logger).to receive(:info).with(/bYWfnyWPlf/, error)
-          subject
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/errors_spec.rb

@@ -1,54 +0,0 @@
-require "pact_broker/errors"
-require "pact_broker/configuration"
-
-module PactBroker
-  module Errors
-    describe ".report" do
-      before do
-        PactBroker.configuration.add_api_error_reporter do | error, options |
-          thing.call(error, options)
-        end
-
-        PactBroker.configuration.add_api_error_reporter do | error, options |
-          thing.another_call(error, options)
-        end
-      end
-
-      let(:error) { StandardError.new("test error") }
-      let(:thing) { double("thing", call: nil, another_call: nil) }
-      let(:error_reference) { "bYWfnyWPlf" }
-      let(:expected_options) { { env: env, error_reference: "bYWfnyWPlf" } }
-      let(:env) { double("env") }
-
-      subject { PactBroker::Errors.report(error, error_reference, env) }
-
-
-      it "invokes the api error reporters" do
-        expect(thing).to receive(:call).with(error, expected_options)
-        expect(thing).to receive(:another_call).with(error, expected_options)
-        subject
-      end
-
-      context "when the error reporter raises an error itself" do
-        class TestError < StandardError; end
-
-        let(:logger) { double("logger").as_null_object }
-
-        before do
-          expect(thing).to receive(:call).and_raise(TestError.new)
-          allow(PactBroker::Errors).to receive(:logger).and_return(logger)
-        end
-
-        it "logs the error" do
-          expect(logger).to receive(:error).at_least(1).times
-          subject
-        end
-
-        it "does not propagate the error" do
-          expect(thing).to receive(:another_call)
-          subject
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/events/subscriber_spec.rb

@@ -1,43 +0,0 @@
-require "pact_broker/events/subscriber"
-require "pact_broker/events/publisher"
-
-module PactBroker
-  module Events
-    describe "#subscribe" do
-      class TestPublisher
-        include PactBroker::Events::Publisher
-
-        def broadcast_foo(id)
-          broadcast(:foo, id )
-        end
-      end
-
-      class TestListener
-        attr_reader :events
-
-        def initialize
-          @events = []
-        end
-
-        def foo(params)
-          @events << params
-        end
-      end
-
-      it "allows overlapping subscriptions" do
-        listener_1 = TestListener.new
-        listener_2 = TestListener.new
-        PactBroker::Events.subscribe(listener_1) do
-          TestPublisher.new.broadcast_foo(1)
-          PactBroker::Events.subscribe(listener_2) do
-            TestPublisher.new.broadcast_foo(2)
-          end
-          TestPublisher.new.broadcast_foo(3)
-        end
-
-        expect(listener_1.events).to eq [1, 2, 3]
-        expect(listener_2.events).to eq [2]
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/feature_toggle_spec.rb

@@ -1,80 +0,0 @@
-require "pact_broker/feature_toggle"
-require "anyway/testing/helpers"
-
-module PactBroker
-  describe FeatureToggle do
-    describe "enabled?" do
-      include Anyway::Testing::Helpers
-
-      let(:ignore_env) { false }
-
-      subject { FeatureToggle.enabled?(:foo, ignore_env) }
-
-      context "when RACK_ENV is not production" do
-        around do | example |
-          with_env("RACK_ENV" => "development", &example)
-        end
-
-        context "when PACT_BROKER_FEATURES includes the given string" do
-          around do | example |
-            with_env("PACT_BROKER_FEATURES" => "foo bar", &example)
-          end
-
-          it { is_expected.to be true }
-        end
-
-        context "when PACT_BROKER_FEATURES does not include the given string" do
-          around do | example |
-            with_env("PACT_BROKER_FEATURES" => "", &example)
-          end
-
-          it { is_expected.to be true }
-
-          context "when ignore env is set" do
-            let(:ignore_env) { true }
-
-            it { is_expected.to be false }
-          end
-        end
-      end
-
-      context "when RACK_ENV is production" do
-        around do | example |
-          with_env("RACK_ENV" => "production", &example)
-        end
-
-        context "when PACT_BROKER_FEATURES includes the given string" do
-          around do | example |
-            with_env("PACT_BROKER_FEATURES" => "foo bar", &example)
-          end
-
-          it { is_expected.to be true }
-        end
-
-        context "when PACT_BROKER_FEATURES includes the given string inside another word" do
-          around do | example |
-            with_env("PACT_BROKER_FEATURES" => "foowiffle bar", &example)
-          end
-
-          it { is_expected.to be false }
-        end
-
-        context "when PACT_BROKER_FEATURES includes the given string but the case doesn't match" do
-          around do | example |
-            with_env("PACT_BROKER_FEATURES" => "FOO bar", &example)
-          end
-
-          it { is_expected.to be true }
-        end
-
-        context "when PACT_BROKER_FEATURES does not include the given string" do
-          around do | example |
-            with_env("PACT_BROKER_FEATURES" => nil, &example)
-          end
-
-          it { is_expected.to be false }
-        end
-      end
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-require "spec_helper"
-require "pact_broker/groups/service"
-require "pact_broker/index/service"
-
-module PactBroker
-
-  module Groups
-    describe Service do
-
-      describe "#find_group_containing" do
-
-        let(:consumer_a) { double("consumer a", name: "consumer a", id: 1)}
-        let(:consumer_b) { double("consumer b", name: "consumer b", id: 2)}
-
-        let(:provider_x) { double("provider x", name: "provider x", id: 3)}
-        let(:provider_y) { double("provider y", name: "provider y", id: 4)}
-
-        let(:relationship_1) { Domain::IndexItem.new(consumer_a, provider_x) }
-        let(:relationship_2) { Domain::IndexItem.new(consumer_b, provider_y) }
-
-        let(:group_1) { Domain::Group.new(relationship_1) }
-        let(:group_2) { Domain::Group.new(relationship_2) }
-
-        let(:relationship_list) { double("relationship list") }
-        let(:groups) { [group_1, group_2]}
-
-        subject  { Service.find_group_containing(consumer_b) }
-
-        before do
-          allow(PactBroker::Index::Service).to receive(:find_index_items).and_return(relationship_list)
-          allow(Relationships::Groupify).to receive(:call).and_return(groups)
-        end
-
-        it "retrieves a list of the relationships" do
-          allow(Index::Service).to receive(:find_index_items)
-          subject
-        end
-
-        it "turns the relationships into groups" do
-          expect(Relationships::Groupify).to receive(:call).with(relationship_list)
-          subject
-        end
-
-        it "returns the Group containing the given pacticipant" do
-          expect(subject).to be group_2
-        end
-
-      end
-
-    end
-  end
-end

data/spec/lib/pact_broker/hash_refinements_spec.rb

@@ -1,63 +0,0 @@
-require "pact_broker/hash_refinements"
-
-module PactBroker
-  describe HashRefinements do
-    using HashRefinements
-
-    let(:a) { { a: 1, b: { c: 3 }, d: 5, e: nil } }
-    let(:b) { { a: 2, b: { c: 4 } } }
-    let(:expected) { { a: 2, b: { c: 4 }, d: 5, e: nil } }
-
-    it "merges" do
-      expect(a.deep_merge(b)).to eq expected
-    end
-
-    describe "camelcase_keys" do
-      let(:hash_1) do
-        {
-          "foo_bar" => {
-            :meep_moop => "blahBlah",
-            "beepBoop" => ""
-          }
-        }
-      end
-
-      let(:expected) do
-        {
-          "fooBar" => {
-            :meepMoop => "blahBlah",
-            "beepBoop" => ""
-          }
-        }
-      end
-
-      it "camel cases the keys" do
-        expect(hash_1.camelcase_keys).to eq expected
-      end
-    end
-
-    describe "snakecase_keys" do
-      let(:hash_1) do
-        {
-          "fooBar" => {
-            :meepMoop => "blahBlah",
-            "already_snake" => ""
-          }
-        }
-      end
-
-      let(:expected) do
-        {
-          "foo_bar" => {
-            :meep_moop => "blahBlah",
-            "already_snake" => ""
-          }
-        }
-      end
-
-      it "snake cases the keys" do
-        expect(hash_1.snakecase_keys).to eq expected
-      end
-    end
-  end
-end