pact_broker 2.89.1 → 2.90.0

data/spec/lib/pact_broker/configuration_spec.rb

@@ -1,167 +0,0 @@
-require "spec_helper"
-require "pact_broker/configuration"
-require "pact_broker/api/renderers/html_pact_renderer"
-require "pact_broker/config/setting"
-
-module PactBroker
-  describe Configuration do
-    describe "show_backtrace_in_error_response?" do
-      before do
-        allow(ENV).to receive(:[]).and_call_original
-      end
-
-      context "when RACK_ENV is not set" do
-        before do
-          allow(ENV).to receive(:[]).with("RACK_ENV").and_return(nil)
-        end
-
-        its(:show_backtrace_in_error_response?) { is_expected.to be false }
-      end
-
-      context "when RACK_ENV is not production" do
-        before do
-          allow(ENV).to receive(:[]).with("RACK_ENV").and_return("development")
-        end
-
-        its(:show_backtrace_in_error_response?) { is_expected.to be true }
-      end
-
-      context "when RACK_ENV is production" do
-        before do
-          allow(ENV).to receive(:[]).with("RACK_ENV").and_return("production")
-        end
-
-        its(:show_backtrace_in_error_response?) { is_expected.to be false }
-      end
-    end
-
-    describe "with_runtime_configuration_overrides" do
-      before do
-        allow(PactBroker.configuration).to receive(:logger).and_return(logger)
-      end
-      let(:logger) { double("logger", debug?: true, debug: nil, warn: nil) }
-
-      it "overrides the specified runtime configuration attributes within the block" do
-        attribute_in_block = nil
-        PactBroker.with_runtime_configuration_overrides(disable_ssl_verification: "true") do
-          attribute_in_block = PactBroker.configuration.disable_ssl_verification
-        end
-        expect(attribute_in_block).to eq true
-        expect(PactBroker.configuration.disable_ssl_verification).to eq false
-      end
-
-      it "logs the overrides at debug level" do
-        expect(logger).to receive(:debug).with("Overridding runtime configuration", payload: hash_including(overrides: { disable_ssl_verification: true }))
-        PactBroker.with_runtime_configuration_overrides(disable_ssl_verification: "true") do
-          "foo"
-        end
-      end
-
-      it "does not override the other runtime configuration attributes within the block" do
-        attribute_in_block = nil
-        PactBroker.with_runtime_configuration_overrides(disable_ssl_verification: "true") do
-          attribute_in_block = PactBroker.configuration.webhook_scheme_whitelist
-        end
-        expect(PactBroker.configuration.webhook_scheme_whitelist).to eq attribute_in_block
-      end
-
-      it "returns the results of the block" do
-        return_value = PactBroker.with_runtime_configuration_overrides(disable_ssl_verification: "true") do
-          "foo"
-        end
-        expect(return_value).to eq "foo"
-      end
-
-      context "when the specified runtime attribute does not exist" do
-        it "logs that it has ignored those attributes" do
-          expect(logger).to receive(:debug).with("Overridding runtime configuration", payload: hash_including(ignoring: { no_existy: true }))
-          PactBroker.with_runtime_configuration_overrides(no_existy: "true") do
-            "foo"
-          end
-        end
-      end
-    end
-
-    describe "default configuration" do
-      describe ".html_pact_renderer" do
-
-        let(:pact) { double("pact") }
-        let(:options) { double("options") }
-
-        it "calls the inbuilt HtmlPactRenderer" do
-          expect(PactBroker::Api::Renderers::HtmlPactRenderer).to receive(:call).with(pact, options)
-          PactBroker.configuration.html_pact_renderer.call pact, options
-        end
-      end
-
-      describe "webhook_http_method_whitelist" do
-        it "allows setting the whitelist by a string" do
-          PactBroker.configuration.webhook_http_method_whitelist = "foo"
-          expect(PactBroker.configuration.webhook_http_method_whitelist).to be_a Config::SpaceDelimitedStringList
-        end
-
-        it "allows setting the whitelist by an array" do
-          PactBroker.configuration.webhook_http_method_whitelist = ["foo", "/.*/"]
-          expect(PactBroker.configuration.webhook_http_method_whitelist).to eq ["foo", /.*/]
-        end
-      end
-
-      describe "webhook_http_code_success" do
-        it "allows setting the 'webhook_http_code_success' by a space-delimited string" do
-          PactBroker.configuration.webhook_http_code_success = "200 201 202"
-          expect(PactBroker.configuration.webhook_http_code_success).to be_a Config::SpaceDelimitedIntegerList
-        end
-
-        it "allows setting the 'webhook_http_code_success' by an array" do
-          PactBroker.configuration.webhook_http_code_success = [200, 201, 202]
-          expect(PactBroker.configuration.webhook_http_code_success).to eq [200, 201, 202]
-        end
-      end
-
-      describe "webhook_scheme_whitelist" do
-        it "allows setting the whitelist by a string" do
-          PactBroker.configuration.webhook_scheme_whitelist = "foo"
-          expect(PactBroker.configuration.webhook_scheme_whitelist).to be_a Config::SpaceDelimitedStringList
-        end
-      end
-
-      describe "webhook_host_whitelist" do
-        it "allows setting the whitelist by a string" do
-          PactBroker.configuration.webhook_host_whitelist = "foo"
-          expect(PactBroker.configuration.webhook_host_whitelist).to be_a Config::SpaceDelimitedStringList
-        end
-      end
-
-      describe "load_from_database!" do
-        let(:configuration) { PactBroker::Configuration.new }
-
-        before do
-          PactBroker::Config::Setting.create(name: "use_case_sensitive_resource_names", type: "string", value: "foo")
-        end
-
-        it "loads the configurations from the database" do
-          configuration.load_from_database!
-          expect(configuration.use_case_sensitive_resource_names).to eq "foo"
-        end
-      end
-
-      describe "add_api_error_reporter" do
-        let(:configuration) { PactBroker::Configuration.new }
-        let(:block) { Proc.new{ | error, options | } }
-
-        it "should add the error notifier " do
-          configuration.add_api_error_reporter(&block)
-          expect(configuration.api_error_reporters.first).to eq block
-        end
-
-        context "with a proc with the wrong number of arguments" do
-          let(:block) { Proc.new{ | error | } }
-
-          it "raises an error" do
-            expect { configuration.add_api_error_reporter(&block) }.to raise_error PactBroker::ConfigurationError
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,193 +0,0 @@
-require "pact_broker/contracts/service"
-
-module PactBroker
-  module Contracts
-    describe Service do
-      describe "#publish" do
-        let(:contracts_to_publish) do
-          ContractsToPublish.from_hash(
-            pacticipant_name: "Foo",
-            pacticipant_version_number: "1",
-            tags: ["a", "b"],
-            branch: branch,
-            contracts: contracts
-          )
-        end
-
-        let(:on_conflict) { "overwrite" }
-        let(:branch) { "main" }
-        let(:contracts) { [contract_1] }
-        let(:contract_1) do
-          ContractToPublish.from_hash(
-            consumer_name: "Foo",
-            provider_name: "Bar",
-            decoded_content: decoded_contract,
-            specification: "pact",
-            on_conflict: on_conflict
-          )
-        end
-
-        let(:contract_hash) { { consumer: { name: "Foo" }, provider: { name: "Bar" }, interactions: [{a: "b"}] } }
-        let(:decoded_contract) { contract_hash.to_json }
-        let(:base_url) { "http://example.org" }
-
-        subject { Service.publish(contracts_to_publish, base_url: base_url) }
-
-        it "creates the tags" do
-          expect { subject }.to change { PactBroker::Domain::Tag.count }.by 2
-        end
-
-        it "sets the version branch" do
-          subject
-          expect(PactBroker::Domain::Version.order(:id).last.branch_names).to include "main"
-        end
-
-        it "returns a results object" do
-          expect(subject.contracts.first).to be_a(PactBroker::Domain::Pact)
-        end
-
-        context "when the pact does not already exist" do
-          context "when the write mode is overwrite" do
-            it "returns an info message" do
-              expect(subject.notices.find{ |log| log.type == "success" && log.text.include?(" published ") }).to_not be nil
-            end
-          end
-
-          context "when the write mode is merge" do
-            let(:on_conflict) { "merge" }
-
-            it "returns an info message" do
-              expect(subject.notices.find{ |log| log.type == "success" && log.text.include?(" published ") }).to_not be nil
-            end
-          end
-
-          context "when no branch is specified but tags are" do
-            before do
-              allow(PactBroker.configuration).to receive(:use_first_tag_as_branch).and_return(true)
-            end
-
-            let(:contracts_to_publish) do
-              ContractsToPublish.from_hash(
-                pacticipant_name: "Foo",
-                pacticipant_version_number: "1",
-                tags: ["a", "b"],
-                branch: nil,
-                contracts: contracts
-              )
-            end
-
-            it "uses the first tag as the branch" do
-              subject
-              expect(PactBroker::Domain::Version.order(:id).last.branch_versions.collect(&:branch_name)).to eq ["a"]
-            end
-          end
-        end
-
-        context "when the pact already exists" do
-          before do
-            td.create_consumer("Foo")
-              .create_provider("Bar")
-              .create_consumer_version("1", branch: "feat/x", tag_names: ["z"])
-              .create_pact
-          end
-
-          it "adds the tags to the existing version" do
-            expect { subject }.to change { PactBroker::Domain::Version.order(:id).last.tags.count}.from(1).to(3)
-          end
-
-          it "adds the branch to the existing version" do
-            expect { subject }.to change { PactBroker::Domain::Version.order(:id).last.branch_versions.collect(&:branch_name)}.from(["feat/x"]).to(["feat/x", "main"])
-          end
-
-          context "when the write mode is overwrite" do
-            context "when the content is different" do
-              it "returns a warning message" do
-                expect(subject.notices.find{ |log| log.type == "warning" && log.text.include?("changed content") }).to_not be nil
-              end
-            end
-
-            context "when the content is the same" do
-              let(:decoded_contract) { PactBroker::Pacts::PactVersion.last.content }
-
-              it "returns an info message" do
-                expect(subject.notices.find{ |log| log.type == "success" && log.text.include?("republished") }).to_not be nil
-              end
-            end
-          end
-
-          context "when the write mode is merge" do
-            let(:on_conflict) { "merge" }
-
-            it "returns an info message" do
-              expect(subject.notices.find{ |log| log.type == "success" && log.text.include?("merged") }).to_not be nil
-            end
-          end
-        end
-      end
-
-      describe "#conflict_errors" do
-        let(:contracts_to_publish) do
-          ContractsToPublish.from_hash(
-            pacticipant_name: "Foo",
-            pacticipant_version_number: "1",
-            tags: ["a", "b"],
-            branch: branch,
-            contracts: contracts
-          )
-        end
-
-        let(:on_conflict) { "overwrite" }
-        let(:branch) { "main" }
-        let(:contracts) { [contract_1] }
-        let(:contract_1) do
-          ContractToPublish.from_hash(
-            consumer_name: "Foo",
-            provider_name: "Bar",
-            decoded_content: decoded_contract,
-            specification: "pact",
-            on_conflict: on_conflict
-          )
-        end
-
-        let(:contract_hash) { { consumer: { name: "Foo" }, provider: { name: "Bar" }, interactions: [{a: "b"}] } }
-        let(:decoded_contract) { contract_hash.to_json }
-
-        subject { Service.conflict_notices(contracts_to_publish) }
-
-        context "when a pact already exists" do
-          before do
-            allow(PactBroker.configuration).to receive(:allow_dangerous_contract_modification).and_return(allow_dangerous_contract_modification)
-            td.create_pact_with_hierarchy("Foo", "1", "Bar", existing_json_content)
-          end
-
-          let(:existing_json_content) { td.random_json_content("Foo", "Bar") }
-
-          context "when allow_dangerous_contract_modification=false and the pact content is different" do
-            let(:allow_dangerous_contract_modification) { false }
-
-            it "returns errors" do
-              expect(subject).to_not be_empty
-            end
-          end
-
-          context "when allow_dangerous_contract_modification=false and the pact content is the same" do
-            let(:allow_dangerous_contract_modification) { false }
-            let(:existing_json_content) { decoded_contract }
-
-            it { is_expected.to be_empty }
-          end
-
-          context "when allow_dangerous_contract_modification=true and the pact content is different" do
-            let(:allow_dangerous_contract_modification) { true }
-
-            it { is_expected.to be_empty }
-          end
-        end
-
-        context "when no pacts exist" do
-          it { is_expected.to be_empty }
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/db/clean_incremental_spec.rb

@@ -1,120 +0,0 @@
-require "pact_broker/db/clean_incremental"
-require "pact_broker/matrix/unresolved_selector"
-
-module PactBroker
-  module DB
-    # Inner queries don't work on MySQL. Seriously, MySQL???
-    xdescribe CleanIncremental do
-      def pact_publication_count_for(consumer_name, version_number)
-        PactBroker::Pacts::PactPublication.where(consumer_version: PactBroker::Domain::Version.where_pacticipant_name(consumer_name).where(number: version_number)).count
-      end
-
-      let(:options) { {} }
-      let(:db) { PactBroker::DB.connection }
-
-
-      let(:latest_dev_selector) { PactBroker::Matrix::UnresolvedSelector.new(tag: "dev", latest: true) }
-      let(:all_prod_selector) { PactBroker::Matrix::UnresolvedSelector.new(tag: "prod") }
-      let(:limit) { 3 }
-      let(:dry_run) { false }
-
-      subject { CleanIncremental.call(PactBroker::DB.connection, options) }
-
-      describe ".call"do
-        context "when there are specified versions to keep" do
-          before do
-            td.create_environment("test")
-              .create_pact_with_hierarchy("Foo", "1", "Bar")
-              .create_webhook
-              .create_triggered_webhook
-              .create_webhook_execution
-              .create_consumer_version_tag("prod").comment("keep as one of prod")
-              .create_consumer_version_tag("dev")
-              .add_day
-              .create_consumer_version("2").comment("DELETE")
-              .add_day
-              .create_consumer_version("3", tag_names: %w{prod}).comment("keep as one of prod")
-              .create_pact
-              .add_day
-              .create_consumer_version("4", tag_names: %w{dev}).comment("DELETE as not latest")
-              .create_deployed_version_for_consumer_version
-              .create_pact
-              .add_day
-              .create_consumer_version("5", tag_names: %w{dev}).comment("keep as latest dev")
-              .create_pact
-              .add_day
-              .create_consumer_version("6", tag_names: %w{foo}).comment("DELETE as not specified")
-              .create_pact
-              .add_day
-              .create_consumer_version("7").comment("keep as deletion limit is 3")
-              .create_pact
-
-          end
-
-          let(:options) { { keep: [all_prod_selector, latest_dev_selector], limit: limit, dry_run: dry_run } }
-
-          it "does not delete the consumer versions specified" do
-            expect(PactBroker::Domain::Version.where(number: "1").count).to be 1
-            expect(PactBroker::Domain::Version.where(number: "2").count).to be 1
-            expect(PactBroker::Domain::Version.where(number: "3").count).to be 1
-            expect(PactBroker::Domain::Version.where(number: "4").count).to be 1
-            expect(PactBroker::Domain::Version.where(number: "5").count).to be 1
-            expect(PactBroker::Domain::Version.where(number: "6").count).to be 1
-            expect(PactBroker::Domain::Version.where(number: "7").count).to be 1
-            subject
-            expect(PactBroker::Domain::Version.where(number: "1").count).to be 1
-            expect(PactBroker::Domain::Version.where(number: "2").count).to be 0
-            expect(PactBroker::Domain::Version.where(number: "3").count).to be 1
-            expect(PactBroker::Domain::Version.where(number: "4").count).to be 0
-            expect(PactBroker::Domain::Version.where(number: "5").count).to be 1
-            expect(PactBroker::Domain::Version.where(number: "6").count).to be 0
-            expect(PactBroker::Domain::Version.where(number: "7").count).to be 1
-          end
-
-          context "when dry_run: true" do
-            before do
-              td.create_pact_with_hierarchy("Meep", "2", "Moop")
-                .create_consumer_version_tag("foop")
-                .create_consumer_version("3")
-                .create_consumer_version_tag("blah")
-            end
-
-            let(:dry_run) { true }
-
-            it "doesn't delete anything" do
-              expect { subject }.to_not change { PactBroker::Domain::Version.count }
-            end
-
-            # Always fails on github actions, never locally :shrug:
-            it "returns info on what will be deleted", pending: ENV["CI"] == "true" do
-              Approvals.verify(subject, :name => "clean_incremental_dry_run", format: :json)
-            end
-          end
-        end
-
-
-        context "with orphan pact versions" do
-          before do
-            # Create a pact that will not be deleted
-            td.create_pact_with_hierarchy("Foo", "0", "Bar", json_content_1)
-              .create_consumer_version_tag("dev")
-            # Create an orphan pact version
-            pact_version_params = PactBroker::Pacts::PactVersion.first.to_hash
-            pact_version_params.delete(:id)
-            pact_version_params[:sha] = "1234"
-            PactBroker::Pacts::PactVersion.create(pact_version_params)
-          end
-
-          let(:json_content_1) { { interactions: ["a", "b"]}.to_json }
-          let(:json_content_2) { { interactions: ["a", "c"]}.to_json }
-
-          let(:options) { { keep: [latest_dev_selector] } }
-
-          it "deletes them" do
-            expect { subject }.to change { PactBroker::Pacts::PactVersion.count }.by(-1)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/db/clean_old_spec.rb

@@ -1,123 +0,0 @@
-require "pact_broker/db/clean"
-
-module PactBroker
-  module DB
-    # Inner queries don't work on MySQL. Seriously, MySQL???
-    describe Clean, skip: true, pending: !!DB.mysql?  do
-      let(:options) { {} }
-      let(:db) { PactBroker::DB.connection }
-
-      subject { Clean.call(PactBroker::DB.connection, options) }
-
-      describe ".call"do
-
-        before do
-          td.create_pact_with_hierarchy("Foo", "0", "Bar")
-            .create_consumer_version_tag("prod")
-            .create_consumer_version("1")
-            .create_pact
-            .create_consumer_version_tag("prod")
-            .comment("keep")
-            .create_verification(provider_version: "20")
-            .create_consumer_version("2")
-            .create_pact
-            .comment("don't keep")
-            .create_webhook
-            .create_triggered_webhook
-            .create_webhook_execution
-            .create_verification(provider_version: "30")
-            .create_verification_webhook
-            .create_triggered_webhook
-            .create_webhook_execution
-            .create_consumer_version("3")
-            .create_pact
-            .comment("keep")
-            .create_verification(provider_version: "40")
-            .create_verification(provider_version: "40", number: 2)
-            .create_verification(provider_version: "50", number: 3)
-        end
-
-
-        it "does not delete any rows in the head matrix" do
-          head_matrix_before = db[:head_matrix].select_all
-          subject
-          head_matrix_after = db[:head_matrix].select_all
-          expect(head_matrix_before).to eq head_matrix_after
-        end
-
-        it "deletes rows that aren't the latest or latest tagged" do
-          subject
-          expect(db[:matrix].where(consumer_version_number: "2").count).to eq 0
-        end
-
-        it "deletes orphan pact_versions" do
-          subject
-          expect(db[:pact_versions].count).to eq 2
-        end
-
-        it "deletes orphan versions" do
-          subject
-          expect(db[:versions].where(number: "20").count).to be 1
-          expect(db[:versions].where(number: "30").count).to be 0
-          expect(db[:versions].where(number: "40").count).to be 1
-          expect(db[:versions].where(number: "50").count).to be 1
-        end
-
-        it "deletes overwritten verifications" do
-          expect(db[:matrix].where(provider_version_number: "40").count).to eq 2
-          subject
-          expect(db[:matrix].where(provider_version_number: "40", verification_number: 2).count).to eq 1
-        end
-      end
-
-      describe ".call with a date" do
-        before do
-          td.set_now(DateTime.new(2019, 1, 1))
-            .create_pact_with_hierarchy
-            .create_verification
-        end
-        let(:options) { { date: date } }
-
-        context "when the data is older than the given date" do
-          let(:date) { DateTime.new(2019, 1, 2) }
-          let(:expected_report) do
-            {
-              kept: { pact_publications: 0, verification_results: 0 },
-              deleted: { pact_publications: 1, verification_results: 1 }
-            }
-          end
-
-          it "is deleted" do
-            subject
-            expect(db[:head_matrix].count).to be 0
-          end
-
-          it "returns a report" do
-            expect(subject).to include(expected_report)
-          end
-        end
-
-        context "when the data is not older than the given date" do
-          let(:date) { DateTime.new(2019, 1, 1) }
-          let(:expected_report) do
-            {
-              kept: { pact_publications: 1, verification_results: 1 },
-              deleted: { pact_publications: 0, verification_results: 0 }
-            }
-          end
-
-          it "is not deleted" do
-            subject
-            expect(db[:head_matrix].count).to be 1
-            expect(db[:pact_publications].count).to be 1
-            expect(db[:verifications].count).to be 1
-          end
-
-          it "returns a report" do
-            expect(subject).to include(expected_report)
-          end
-        end
-      end
-    end
-  end
-end