pact_broker 2.89.1 → 2.90.0

data/spec/lib/pact_broker/build_http_options_spec.rb

@@ -1,47 +0,0 @@
-require "spec_helper"
-require "pact_broker/build_http_options"
-
-module PactBroker
-  describe BuildHttpOptions do
-
-    subject { PactBroker::BuildHttpOptions.call(url) }
-
-    context "default http options" do
-      before do
-        PactBroker.configuration.disable_ssl_verification = false
-      end
-
-      describe "when given an insecure URL" do
-        let(:url) { "http://example.org/insecure" }
-        
-        it "should provide an empty configuration object" do
-          expect(subject).to eq({})
-        end
-        
-      end
-      
-      describe "when given a secure URL" do
-        let(:url) { "https://example.org/secure" }
-        
-        it "should validate the full certificate chain" do
-          expect(subject).to include({:use_ssl => true, :verify_mode => 1})
-        end
-        
-      end
-    end
-    
-    context "disable_ssl_verification is set to true" do
-      before do
-        PactBroker.configuration.disable_ssl_verification = true
-      end
-      
-      let(:url) { "https://example.org/secure" }
-      
-      describe "when given a secure URL" do
-        it "should not validate certificates" do
-          expect(subject).to include({:use_ssl => true, :verify_mode => 0})
-        end
-      end
-    end
-  end
-end

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

@@ -1,80 +0,0 @@
-require "pact_broker/certificates/service"
-
-module PactBroker
-  module Certificates
-    describe Service do
-      let(:certificate_content) { File.read("spec/fixtures/certificate.pem") }
-      let(:logger) { spy("logger") }
-
-      before do
-        allow(Service).to receive(:logger).and_return(logger)
-      end
-
-      describe "#cert_store" do
-        subject { Service.cert_store }
-
-        it "returns an OpenSSL::X509::Store" do
-          expect(subject).to be_instance_of(OpenSSL::X509::Store)
-        end
-
-        context "when there is an error adding certificate" do
-          let(:cert_store) { instance_spy(OpenSSL::X509::Store) }
-
-          before do
-            Certificate.create(uuid: "1234", content: certificate_content)
-
-            allow(cert_store).to receive(:add_cert).and_raise(StandardError)
-            allow(OpenSSL::X509::Store).to receive(:new).and_return(cert_store)
-          end
-
-          it "logs the error" do
-            subject
-
-            expect(logger).to have_received(:warn)
-              .with(/Error adding certificate/, StandardError).at_least(1).times
-          end
-
-          it "returns an OpenSSL::X509::Store" do
-            expect(subject).to be(cert_store)
-          end
-        end
-      end
-
-      describe "#find_all_certificates" do
-        let!(:certificate) do
-          Certificate.create(uuid: "1234", content: certificate_content)
-        end
-
-        subject { Service.find_all_certificates }
-
-        context "with a valid certificate chain" do
-          it "returns all the X509 Certificate objects" do
-            expect(subject.size).to eq 2
-          end
-        end
-
-        context "with a valid CA file" do
-          let(:certificate_content) { File.read("spec/fixtures/certificates/cacert.pem") }
-
-          it "returns all the X509 Certificate objects" do
-            expect(logger).to_not receive(:error).with(/Error.*1234/)
-            expect(subject.size).to eq 1
-          end
-        end
-
-        context "with an invalid certificate file" do
-          let(:certificate_content) { File.read("spec/fixtures/certificate-invalid.pem") }
-
-          it "logs an error" do
-            expect(logger).to receive(:warn).with(/Error.*1234/, StandardError)
-            subject
-          end
-
-          it "returns all the valid X509 Certificate objects" do
-            expect(subject.size).to eq 1
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/config/load_spec.rb

@@ -1,110 +0,0 @@
-require "pact_broker/config/load"
-
-module PactBroker
-  module Config
-    describe Load do
-      describe ".call" do
-
-        class MockConfig < Anyway::Config
-          attr_config(
-            foo: "default",
-            bar: "default",
-            nana: "default",
-            meep: "default",
-            lalala: "default",
-            meow: "default",
-            peebo: "default",
-            whitelist: "default",
-            blah: "default",
-            setting_with_override: "default"
-          )
-          attr_config(:setting_with_no_default)
-          config_name :foo
-        end
-
-        before do
-          Setting.create(name: "foo", type: "json", value: {"a" => "thing"}.to_json)
-          Setting.create(name: "bar", type: "string", value: "bar")
-          Setting.create(name: "nana", type: "integer", value: "1")
-          Setting.create(name: "meep", type: "float", value: "1.2")
-          Setting.create(name: "lalala", type: "boolean", value: "1")
-          Setting.create(name: "meow", type: "boolean", value: "0")
-          Setting.create(name: "peebo", type: "string", value: nil)
-          Setting.create(name: "unknown", type: "string", value: nil)
-          Setting.create(name: "whitelist", type: "space_delimited_string_list", value: "foo bar")
-          Setting.create(name: "blah", type: "symbol", value: "boop")
-          Setting.create(name: "setting_with_no_default", type: "string", value: "boop")
-          Setting.create(name: "setting_with_override", type: "string", value: "meep")
-
-          allow(Load.logger).to receive(:warn)
-          allow(Load.logger).to receive(:debug)
-        end
-
-        let(:configuration) { MockConfig.new(setting_with_override: "overridden") }
-
-        subject { Load.call(configuration) }
-
-        it "loads a JSON config" do
-          subject
-          expect(configuration.foo).to eq(a: "thing")
-        end
-
-        it "loads a String setting" do
-          subject
-          expect(configuration.bar).to eq "bar"
-        end
-
-        it "loads a Symbol setting" do
-          subject
-          expect(configuration.blah).to eq :boop
-        end
-
-        it "loads an Integer setting" do
-          subject
-          expect(configuration.nana).to eq 1
-        end
-
-        it "loads a Float setting" do
-          subject
-          expect(configuration.meep).to eq 1.2
-        end
-
-        it "loads a true setting" do
-          subject
-          expect(configuration.lalala).to eq true
-        end
-
-        it "loads a false setting" do
-          subject
-          expect(configuration.meow).to eq false
-        end
-
-        it "loads a nil setting" do
-          subject
-          expect(configuration.peebo).to eq nil
-        end
-
-        it "loads a space_delimited_string_list" do
-          subject
-          expect(configuration.whitelist).to eq ["foo", "bar"]
-        end
-
-        it "loads settings where there is no default" do
-          subject
-          expect(configuration.setting_with_no_default).to eq "boop"
-        end
-
-        it "does not overwrite settings that did not come from the default class" do
-          expect(Load.logger).to receive(:debug).with(/Ignoring.*setting_with_override/)
-          subject
-          expect(configuration.setting_with_override).to eq "overridden"
-        end
-
-        it "does not load a setting where the Configuration object does not have a matching property" do
-          expect(Load.logger).to receive(:warn).with("Could not load configuration setting \"unknown\" as there is no matching attribute on the PactBroker::Config::MockConfig class")
-          subject
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/config/runtime_configuration_documentation_spec.rb

@@ -1,30 +0,0 @@
-require "pact_broker/config/runtime_configuration"
-
-module PactBroker
-  module Config
-    describe RuntimeConfiguration do
-      ATTRIBUTES = RuntimeConfiguration.config_attributes
-      DOCUMENTATION = File.read("docs/configuration.yml")
-      DOCUMENTED_ATTRIBUTES = YAML.load(DOCUMENTATION)["groups"].flat_map{ | group | group["vars"].keys.collect(&:to_sym) }
-      DELIBERATELY_UNDOCUMENTED_ATTRIBUTES = [
-        :warning_error_class_names,
-        :log_configuration_on_startup,
-        :use_hal_browser,
-        :use_rack_protection,
-        :use_case_sensitive_resource_names,
-        :order_versions_by_date,
-        :base_equality_only_on_content_that_affects_verification_results,
-        :semver_formats,
-        :seed_example_data,
-        :use_first_tag_as_branch_time_limit,
-        :validate_database_connection_config
-      ]
-
-      (ATTRIBUTES - DELIBERATELY_UNDOCUMENTED_ATTRIBUTES).each do | attribute_name |
-        it "has documentation for #{attribute_name}" do
-          expect(DOCUMENTED_ATTRIBUTES & [attribute_name]).to include(attribute_name)
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/config/runtime_configuration_logging_methods_spec.rb

@@ -1,22 +0,0 @@
-require "pact_broker/config/runtime_configuration_logging_methods"
-
-module PactBroker
-  module Config
-    describe RuntimeConfigurationLoggingMethods do
-      let(:string_io) { StringIO.new }
-      let(:logger) { Logger.new(string_io) }
-      let(:initial_values) { { database_password: "foo", database_url: "protocol://username:password@host/database"} }
-      let(:runtime_configuration) { RuntimeConfiguration.new(initial_values) }
-
-      subject do
-        runtime_configuration.log_configuration(logger)
-        string_io.string
-      end
-
-      it "redacts the sensitive values" do
-        expect(subject).to include "database_password=*****"
-        expect(subject).to include "database_url=protocol://username:*****@host/database"
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/config/runtime_configuration_spec.rb

@@ -1,71 +0,0 @@
-require "pact_broker/config/runtime_configuration"
-
-module PactBroker
-  module Config
-    describe RuntimeConfiguration do
-      describe "base_url" do
-        it "does not expose base_url for delegation" do
-          expect(RuntimeConfiguration.getter_and_setter_method_names).to_not include :base_url
-        end
-
-        it "does not support the method base_url as base_urls should be used instead" do
-          expect { RuntimeConfiguration.new.base_url }.to raise_error NotImplementedError
-        end
-      end
-
-      context "with a base_url and base_urls as strings" do
-        subject do
-          runtime_configuration = RuntimeConfiguration.new
-          runtime_configuration.base_url = "foo blah"
-          runtime_configuration.base_urls = "bar wiffle"
-          runtime_configuration
-        end
-
-        its(:base_urls) { is_expected.to eq %w[bar wiffle foo blah] }
-      end
-
-      context "with a base_url and base_urls as the same strings" do
-        subject do
-          runtime_configuration = RuntimeConfiguration.new
-          runtime_configuration.base_url = "foo blah"
-          runtime_configuration.base_urls = "foo meep"
-          runtime_configuration
-        end
-
-        its(:base_urls) { is_expected.to eq %w[foo meep blah] }
-      end
-
-      context "with just base_url as a string" do
-        subject do
-          runtime_configuration = RuntimeConfiguration.new
-          runtime_configuration.base_url = "foo blah"
-          runtime_configuration
-        end
-
-        its(:base_urls) { is_expected.to eq %w[foo blah] }
-      end
-
-      context "with just base_urls as a string" do
-        subject do
-          runtime_configuration = RuntimeConfiguration.new
-          runtime_configuration.base_url = nil
-          runtime_configuration.base_urls = "bar wiffle"
-          runtime_configuration
-        end
-
-        its(:base_urls) { is_expected.to eq %w[bar wiffle] }
-      end
-
-      context "with base_url and base_urls as arrays" do
-        subject do
-          runtime_configuration = RuntimeConfiguration.new
-          runtime_configuration.base_url = %w[foo blah]
-          runtime_configuration.base_urls = %w[bar wiffle]
-          runtime_configuration
-        end
-
-        its(:base_urls) { is_expected.to eq %w[bar wiffle foo blah] }
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/config/save_spec.rb

@@ -1,100 +0,0 @@
-require "pact_broker/config/save"
-require "pact_broker/configuration"
-require "pact_broker/config/space_delimited_string_list"
-
-module PactBroker
-  module Config
-    describe Save do
-
-      describe "#call" do
-        let(:setting_names) { [:foo, :bar, :wiffle, :meep, :flop, :peebo, :lalala, :meow, :whitelist, :blah] }
-        let(:configuration) do
-          double("PactBroker::Configuration",
-            foo: true,
-            bar: false,
-            wiffle: ["a", "b", "c"],
-            meep: {a: "thing"},
-            flop: nil,
-            blah: :boop,
-            peebo: 1,
-            lalala: 1.2,
-            meow: Object.new,
-            whitelist: SpaceDelimitedStringList.parse("foo bar"))
-        end
-
-        subject { Save.call(configuration, setting_names) }
-
-        it "saves a Symbol" do
-          subject
-          setting = Setting.find(name: "blah")
-          expect(setting.type).to eq "symbol"
-          expect(setting.value).to eq "boop"
-        end
-
-        it "saves a false config setting to the database" do
-          subject
-          setting = Setting.find(name: "foo")
-          expect(setting.type).to eq "boolean"
-          expect(setting.value).to eq "1"
-        end
-
-        it "saves a true config setting to the database" do
-          subject
-          setting = Setting.find(name: "bar")
-          expect(setting.type).to eq "boolean"
-          expect(setting.value).to eq "0"
-        end
-
-        it "saves an array to the database" do
-          subject
-          setting = Setting.find(name: "wiffle")
-          expect(setting.type).to eq "json"
-          expect(setting.value).to eq '["a","b","c"]'
-        end
-
-        it "saves a hash to the database" do
-          subject
-          setting = Setting.find(name: "meep")
-          expect(setting.type).to eq "json"
-          expect(setting.value).to eq "{\"a\":\"thing\"}"
-        end
-
-        it "saves a nil to the database" do
-          subject
-          setting = Setting.find(name: "flop")
-          expect(setting.type).to eq "string"
-          expect(setting.value).to eq nil
-        end
-
-        it "saves an Integer to the database" do
-          subject
-          setting = Setting.find(name: "peebo")
-          expect(setting.type).to eq "integer"
-          expect(setting.value).to eq "1"
-        end
-
-        it "saves a Float to the database" do
-          subject
-          setting = Setting.find(name: "lalala")
-          expect(setting.type).to eq "float"
-          expect(setting.value).to eq "1.2"
-        end
-
-        it "saves a SpaceDelimitedStringList" do
-          subject
-          setting = Setting.find(name: "whitelist")
-          expect(setting.type).to eq "space_delimited_string_list"
-          expect(setting.value).to eq "foo bar"
-        end
-
-        it "does not save an arbitrary object to the database" do
-          allow(Save.logger).to receive(:warn)
-          expect(Save.logger).to receive(:warn).with("Could not save configuration setting \"meow\" to database as the class Object is not supported.")
-          subject
-          setting = Setting.find(name: "meow")
-          expect(setting).to be nil
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/config/space_delimited_integer_list_spec.rb

@@ -1,47 +0,0 @@
-require "pact_broker/config/space_delimited_integer_list"
-
-module PactBroker
-  module Config
-    describe SpaceDelimitedIntegerList do
-      describe "parse" do
-        subject { SpaceDelimitedIntegerList.parse(input) }
-
-        context "when input is ''" do
-          let(:input) { "" }
-
-          it { is_expected.to eq [] }
-          it { is_expected.to be_a SpaceDelimitedIntegerList }
-
-          its(:to_s) { is_expected.to eq input }
-        end
-
-        context "when input is 'off'" do
-          let(:input) { "off" }
-
-          it { is_expected.to eq [] }
-          it { is_expected.to be_a SpaceDelimitedIntegerList }
-
-          its(:to_s) { is_expected.to eq "" }
-        end
-
-        context "when input is '0 1 1 2 3 5 8 13 21 34'" do
-          let(:input) { "0 1 1 2 3 5 8 13 21 34" }
-
-          it { is_expected.to eq [0, 1, 1, 2, 3, 5, 8, 13, 21, 34] }
-          it { is_expected.to be_a SpaceDelimitedIntegerList }
-
-          its(:to_s) { is_expected.to eq input }
-        end
-
-        context "when input is '13 17 foo 19'" do
-          let(:input) { "13 17 foo 19" }
-
-          it { is_expected.to eq [13, 17, 19] }
-          it { is_expected.to be_a SpaceDelimitedIntegerList }
-
-          its(:to_s) { is_expected.to eq "13 17 19" }
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/config/space_delimited_string_list_spec.rb

@@ -1,45 +0,0 @@
-require "pact_broker/config/space_delimited_string_list"
-
-module PactBroker
-  module Config
-    describe SpaceDelimitedStringList do
-      describe "parse" do
-        subject { SpaceDelimitedStringList.parse(input) }
-
-        context "when input is ''" do
-          let(:input) { "" }
-
-          it { is_expected.to eq [] }
-
-          its(:to_s) { is_expected.to eq input }
-        end
-
-        context "when input is 'foo bar'" do
-          let(:input) { "foo bar" }
-
-          it { is_expected.to eq ["foo", "bar"] }
-
-          it { is_expected.to be_a SpaceDelimitedStringList }
-
-          its(:to_s) { is_expected.to eq input }
-        end
-
-        context "when input is '/foo.*/'" do
-          let(:input) { "/foo.*/" }
-
-          it { is_expected.to eq [/foo.*/] }
-
-          its(:to_s) { is_expected.to eq input }
-        end
-
-        context "when input is '/foo\\.*/' (note double backslash)" do
-          let(:input) { "/foo\\.*/" }
-
-          it { is_expected.to eq [/foo\.*/] }
-
-          its(:to_s) { is_expected.to eq input }
-        end
-      end
-    end
-  end
-end