pact_broker 2.89.1 → 2.90.0

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

@@ -1,52 +0,0 @@
-require "pact_broker/db/log_quietener"
-
-module PactBroker
-  module DB
-    describe Logger do
-      let(:logs) { StringIO.new }
-      let(:wrapped_logger) { ::Logger.new(logs) }
-
-      subject { LogQuietener.new(wrapped_logger) }
-
-      describe "error" do
-        context "when the error is for a table or view that does not exist" do
-          before do
-            subject.error("PG::UndefinedTable - some error")
-          end
-
-          it "logs the message at debug level" do
-            expect(logs.string).to include "DEBUG -- :"
-          end
-
-          it "appends a friendly message so people don't freak out" do
-            expect(logs.string).to include "PG::UndefinedTable - some error Don't panic."
-          end
-        end
-
-        context "when the error is a foreign key constraint violation" do
-          before do
-            subject.error("SQLite3::ConstraintException: FOREIGN KEY constraint failed: delete from pacticipants where id = 1")
-          end
-
-          it "logs the message at warn level" do
-            expect(logs.string).to include "WARN -- :"
-          end
-        end
-
-        context "when the error is NOT for a table or view that does not exist" do
-          before do
-            subject.error("foo bar")
-          end
-
-          it "logs the message at error level" do
-            expect(logs.string).to include "ERROR -- :"
-          end
-
-          it "does not append a friendly message so people will correctly panic" do
-            expect(logs.string).to_not include "Don't panic."
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,66 +0,0 @@
-require "pact_broker/db/validate_encoding"
-require "pact_broker/db"
-
-module PactBroker
-  module DB
-
-    describe ValidateEncoding do
-
-      let(:opts) { {encoding: encoding} }
-      let(:connection) { double("connection", opts: opts)}
-
-      subject { ValidateEncoding.(connection) }
-
-      describe ".call" do
-        context "when encoding is UTF8" do
-          let(:encoding) { "UTF8" }
-
-          it "does not raise an error" do
-            subject
-          end
-        end
-
-        context "when encoding is UTF8" do
-          let(:encoding) { "utf8" }
-
-          it "does not raise an error" do
-            subject
-          end
-        end
-
-        context "when encoding is utf-8" do
-          let(:encoding) { "utf-8" }
-
-          it "does not raise an error" do
-            subject
-          end
-        end
-
-        context "when encoding is utf-80" do
-          let(:encoding) { "utf-80" }
-
-          it "does not raise an error, maybe it should, ah well" do
-            subject
-          end
-        end
-
-        context "when encoding is null" do
-          let(:encoding) { nil }
-
-          it "raises an error" do
-            expect{ subject }.to raise_error ConnectionConfigurationError, /The Sequel connection encoding \(nil\) is strongly recommended to be "utf8"/
-          end
-        end
-
-        context "when encoding is latin1" do
-          let(:encoding) { "latin1" }
-
-          it "raises an error" do
-            expect{ subject }.to raise_error ConnectionConfigurationError, /The Sequel connection encoding \("latin1"\) is strongly recommended to be "utf8"/
-          end
-        end
-      end
-
-    end
-  end
-end

data/spec/lib/pact_broker/deployments/deployed_version_service_spec.rb

@@ -1,42 +0,0 @@
-require "pact_broker/deployments/deployed_version_service"
-
-module PactBroker
-  module Deployments
-    describe DeployedVersionService do
-      describe ".create" do
-        before do
-          td.create_environment("test")
-            .create_consumer("foo")
-            .create_consumer_version("1")
-        end
-
-        let(:version) { td.and_return(:consumer_version) }
-        let(:environment) { td.and_return(:environment) }
-
-        context "when the version is already currently deployed" do
-          it "returns the existing deployed version object" do
-            deployed_version_1 = DeployedVersionService.find_or_create("1234", version, environment, nil)
-            deployed_version_2 = DeployedVersionService.find_or_create("4321", version, environment, nil)
-            expect(deployed_version_1.uuid).to eq deployed_version_2.uuid
-          end
-        end
-
-        context "when the version was previously deployed, but there was another version deployed in the meantime" do
-          before do
-            td.create_consumer_version("2")
-          end
-
-          let(:version_1) { PactBroker::Domain::Version.order(:id).first }
-          let(:version_2) { PactBroker::Domain::Version.order(:id).last }
-
-          it "returns a new deployed version object" do
-            deployed_version_1 = DeployedVersionService.find_or_create("1234", version_1, environment, nil)
-            DeployedVersionService.find_or_create("4321", version_2, environment, nil)
-            deployed_version_3 = DeployedVersionService.find_or_create("4545", version_1, environment, nil)
-            expect(deployed_version_1.uuid).to_not eq deployed_version_3.uuid
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/deployments/deployed_version_spec.rb

@@ -1,109 +0,0 @@
-require "pact_broker/deployments/deployed_version"
-
-module PactBroker
-  module Deployments
-    describe DeployedVersion do
-      let!(:environment) { td.create_environment("test").and_return(:environment) }
-      let!(:version) do
-        td.create_consumer
-          .create_consumer_version("1")
-          .and_return(:consumer_version)
-      end
-
-      let(:params) do
-        {
-          uuid: "1234",
-          version_id: version.id,
-          pacticipant_id: version.pacticipant_id,
-          environment_id: environment.id,
-          target: target
-        }
-      end
-
-      let(:target) { nil }
-
-      subject { DeployedVersion.create(params) }
-
-      it "creates a CurrentlyDeployedVersionId" do
-        expect{ subject }.to change { CurrentlyDeployedVersionId.count}.by(1)
-      end
-
-      it "sets the currently deployed version id" do
-        expect(subject.currently_deployed_version_id.deployed_version_id).to eq subject.id
-      end
-
-      context "when a deployed version for the same environment and nil instance name exists" do
-        before do
-          td.create_deployed_version_for_consumer_version(environment_name: "test", target: target)
-        end
-
-        it "does not make a new currently deployed version id" do
-          expect{ subject }.to change { CurrentlyDeployedVersionId.count}.by(0)
-        end
-
-        it "stores an empty string as the target_for_index in the database so that the unique constraint works" do
-          expect(subject.target).to be nil
-          expect(subject.target_for_index).to eq ""
-          expect(subject.currently_deployed_version_id.target_for_index).to eq ""
-        end
-
-        it "updates the currently deployed version id" do
-          expect { subject }.to change { CurrentlyDeployedVersionId.last.deployed_version_id }
-          expect(CurrentlyDeployedVersionId.last.deployed_version_id).to eq subject.id
-        end
-
-        its(:currently_deployed) { is_expected.to be true }
-      end
-
-      context "when a deployed version for the same environment and same instance name exists" do
-        before do
-          td.create_deployed_version_for_consumer_version(environment_name: "test", target: target)
-        end
-
-        let(:target) { "green" }
-
-        its(:currently_deployed) { is_expected.to be true }
-
-        it "does not make a new currently deployed version id" do
-          expect{ subject }.to change { CurrentlyDeployedVersionId.count}.by(0)
-        end
-
-        it "updates the currently deployed version id" do
-          expect { subject }.to change { CurrentlyDeployedVersionId.last.deployed_version_id }
-          expect(CurrentlyDeployedVersionId.last.deployed_version_id).to eq subject.id
-        end
-
-        describe "the previously deployed version" do
-          it "is no longer currently deployed" do
-            subject
-            version.refresh
-            expect(version.deployed_versions.first.currently_deployed).to be false
-          end
-        end
-      end
-
-      context "when a deployed version for the same environment and different instance name exists" do
-        before do
-          td.create_deployed_version_for_consumer_version(environment_name: "test", target: "blue")
-        end
-
-        let(:target) { "green" }
-
-        it "makes a new currently deployed version id" do
-          expect{ subject }.to change { CurrentlyDeployedVersionId.count}.by(1)
-          expect(CurrentlyDeployedVersionId.last.deployed_version_id).to eq subject.id
-        end
-
-        describe "the previously deployed version" do
-          it "is still currently deployed" do
-            subject
-            version.refresh
-            expect(version.deployed_versions.first.currently_deployed).to be true
-          end
-        end
-
-        its(:currently_deployed) { is_expected.to be true }
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/deployments/environment_service_spec.rb

@@ -1,58 +0,0 @@
-require "pact_broker/deployments/environment_service"
-
-module PactBroker
-  module Deployments
-    describe EnvironmentService do
-      describe ".create" do
-        let(:environment) do
-          Environment.new(
-            name: "foo",
-            display_name: display_name,
-            production: false
-          )
-        end
-
-        let(:display_name) { "Foo" }
-
-        subject { EnvironmentService.create("1234", environment) }
-
-        it "creates the environment" do
-          subject
-          expect(subject.name).to eq "foo"
-          expect(subject.display_name).to eq "Foo"
-          expect(subject.production).to eq false
-        end
-
-        context "when the display name is blank or not set" do
-          let(:display_name) { " " }
-
-          it "generates a display name" do
-            expect(PactBroker::Pacticipants::GenerateDisplayName).to receive(:call).with("foo").and_return("Display Name")
-            expect(subject.display_name).to eq "Display Name"
-          end
-        end
-      end
-
-      describe ".replace" do
-        before do
-          td.create_environment("foo", uuid: "1", display_name: "bar", production: false)
-        end
-
-        subject { EnvironmentService.replace("1", Environment.new(name: "bar", display_name: "bar-2", production: true) ) }
-
-        it "replaces the attributes" do
-          subject
-          expect(Environment.first).to have_attributes(name: "bar", display_name: "bar-2", production: true)
-        end
-
-        context "with missing attributes" do
-          subject { EnvironmentService.replace("1", Environment.new ) }
-
-          it "raises an error" do
-            expect { subject }.to raise_error Sequel::DatabaseError
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/deployments/environment_spec.rb

@@ -1,27 +0,0 @@
-require "pact_broker/deployments/environment"
-require "pact_broker/deployments/deployed_version"
-
-module PactBroker
-  module Deployments
-    describe Environment do
-      describe "delete" do
-        before do
-          td.create_consumer("Foo")
-            .create_consumer_version("1")
-            .create_environment("test")
-            .create_deployed_version_for_consumer_version
-            .create_environment("prod")
-            .create_deployed_version_for_consumer_version
-        end
-
-        it "deletes the associated deployed versions when deleting individual environments" do
-          expect { Environment.find(name: "test").delete }.to change { DeployedVersion.count }.by(-1)
-        end
-
-        it "deletes the associated deployed versions when deleting an environment dataset" do
-          expect { Environment.where(name: "test").delete }.to change { DeployedVersion.count }.by(-1)
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/diagnostic/resources/dependencies_spec.rb

@@ -1,85 +0,0 @@
-require "pact_broker/diagnostic/app"
-require "rack/test"
-
-module PactBroker
-  module Diagnostic
-    module Resources
-      describe Dependencies do
-        describe "GET /diagnostic/status/dependencies" do
-          include Rack::Test::Methods
-
-          let(:rack_env) { { "pactbroker.base_url" => "http://pact-broker"} }
-          let(:app) { PactBroker::Diagnostic::App.new }
-          let(:parsed_response_body) { JSON.parse(subject.body) }
-
-
-          subject { get("/diagnostic/status/dependencies", nil, rack_env) }
-
-          it "returns application/hal+json" do
-            expect(subject.headers["Content-Type"]).to eq "application/hal+json"
-          end
-
-          it "returns a link to itself" do
-            expect(parsed_response_body["_links"]["self"]["href"]).to eq "http://pact-broker/diagnostic/status/dependencies"
-          end
-
-          context "when we can connect to the database" do
-            before do
-              allow(PactBroker::DB.connection).to receive(:valid_connection?).and_return(true)
-            end
-
-            it "returns a 200 response" do
-              expect(subject.status).to eq 200
-            end
-
-            it "indicates that the database connectivity is OK" do
-              expect(parsed_response_body["database"]["ok"]).to be true
-            end
-          end
-
-          context "when we can't connect to the database" do
-            before do
-              allow(PactBroker::DB.connection).to receive(:valid_connection?).and_return(false)
-            end
-
-            it "returns a 500 response" do
-              expect(subject.status).to eq 500
-            end
-
-            it "indicates that the database connectivity is not OK" do
-              expect(parsed_response_body["database"]["ok"]).to be false
-            end
-          end
-
-          context "when there is an exception valiating the database connection" do
-
-            class TestError < StandardError; end
-
-            before do
-              allow(PactBroker::DB.connection).to receive(:valid_connection?).and_raise(TestError.new("a message"))
-            end
-
-            it "returns a 500 response" do
-              expect(subject.status).to eq 500
-            end
-
-            it "indicates that the database connectivity is not OK" do
-              expect(parsed_response_body["database"]["ok"]).to be false
-            end
-
-            it "includes an error message" do
-              expect(parsed_response_body["database"]["error"]["message"]).to eq "PactBroker::Diagnostic::Resources::TestError - a message"
-            end
-
-            it "logs the error" do
-              logger = double("Logger")
-              allow_any_instance_of(PactBroker::Diagnostic::Resources::Dependencies).to receive(:logger).and_return(logger)
-              expect(logger).to receive(:error).with(/TestError.*a message/)
-              subject
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/diagnostic/resources/heartbeat_spec.rb

@@ -1,34 +0,0 @@
-require "pact_broker/diagnostic/resources/heartbeat"
-require "pact_broker/diagnostic/app"
-require "rack/test"
-
-module PactBroker
-  module Diagnostic
-    module Resources
-      describe Heartbeat do
-        include Rack::Test::Methods
-
-        let(:app) { PactBroker::Diagnostic::App.new }
-
-        describe "GET /diagnostic/status/heartbeat" do
-          let(:rack_env) { { "pactbroker.base_url" => "http://pact-broker"} }
-          let(:parsed_response_body) { JSON.parse(subject.body) }
-
-          subject { get("/diagnostic/status/heartbeat", nil, rack_env) }
-
-          it "returns a 200" do
-            expect(subject.status).to eq 200
-          end
-
-          it "returns application/hal+json" do
-            expect(subject.headers["Content-Type"]).to eq "application/hal+json"
-          end
-
-          it "returns a link to itself" do
-            expect(parsed_response_body["_links"]["self"]["href"]).to eq "http://pact-broker/diagnostic/status/heartbeat"
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/doc/controllers/app_spec.rb

@@ -1,82 +0,0 @@
-require "pact_broker/doc/controllers/app"
-
-module PactBroker
-  module Doc
-    module Controllers
-      describe App do
-        describe "GET relation" do
-
-          let(:app) { PactBroker::Doc::Controllers::App }
-          let(:rack_env) { {} }
-
-          context "when the resource exists" do
-            subject { get "/webhooks", nil, rack_env }
-
-            it "returns a 200 status" do
-              subject
-              expect(last_response.status).to eq 200
-            end
-
-            it "returns a html content type" do
-              subject
-              expect(last_response.headers["Content-Type"]).to eq "text/html;charset=utf-8"
-            end
-
-            it "returns a html body" do
-              subject
-              expect(last_response.body).to include "<html>"
-            end
-
-            context "with the base_url not set" do
-              it "returns relative links" do
-                expect(subject.body).to include "href='/css"
-              end
-            end
-
-            context "with the base_url set" do
-              let(:rack_env) { { "pactbroker.base_url" => "http://example.org/pact-broker"} }
-
-              it "returns absolute links" do
-                expect(subject.body).to include "href='http://example.org/pact-broker/css"
-              end
-            end
-          end
-
-          context "when the resource does not exist" do
-            subject { get "/blah" }
-
-            it "returns a 200 status, because otherwise, the Rack cascade will make it return a 404 from the webmachine API" do
-              subject
-              expect(last_response.status).to eq 200
-            end
-
-            it "returns a html content type" do
-              subject
-              expect(last_response.headers["Content-Type"]).to eq "text/html;charset=utf-8"
-            end
-
-            it "returns a custom error page" do
-              subject
-              expect(last_response.body).to include "No documentation exists"
-            end
-          end
-
-          context "when the resource has a context and there is a folder with a matching name" do
-            subject { get "/diff?context=pact" }
-
-            it "returns documentation in a folder of the matching name" do
-              subject
-              expect(last_response.status).to eq 200
-              expect(last_response.body).to include "Diff"
-            end
-
-            it "returns a html content type" do
-              subject
-              expect(last_response.headers["Content-Type"]).to eq "text/html;charset=utf-8"
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/doc/coverage_spec.rb

@@ -1,39 +0,0 @@
-require "pact_broker/doc/controllers/app"
-
-RSpec.describe "the HAL docs for the index" do
-
-  let(:app) do
-    Rack::Builder.new do
-      map "/docs" do
-        run PactBroker::Doc::Controllers::App
-      end
-      map "/" do
-        run PactBroker::API
-      end
-    end
-  end
-
-  let(:index_response) { get "/", {}, { "HTTP_ACCEPT" => "application/hal+json" } }
-  let(:index_body) { JSON.parse(index_response.body) }
-  let(:docs_missing_string) { "No documentation exists"}
-
-  it "returns a known message when the documentation doesn't exist" do
-    get "/docs/does-not-exist?context=index", {}, { "HTTP_ACCEPT" => "text/html" }
-    expect(last_response.body).to include docs_missing_string
-  end
-
-  it "has a document for each relation" do
-    relations_that_should_have_docs = index_body["_links"].keys - ["self", "curies", "beta:provider-pacts-for-verification"]
-    relations_without_docs = {}
-
-    relations_that_should_have_docs.each do | relation |
-      path = "/docs/#{relation.split(":", 2).last}?context=index"
-      get path, {}, { "HTTP_ACCEPT" => "text/html" }
-      if last_response.body.include?(docs_missing_string)
-        relations_without_docs[relation] = last_response.status
-      end
-    end
-
-    expect(relations_without_docs).to eq({})
-  end
-end

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

@@ -1,25 +0,0 @@
-require "spec_helper"
-require "pact_broker/domain/group"
-require "pact_broker/domain/index_item"
-
-module PactBroker
-  module Domain
-    describe Group do
-
-      describe "#include_pacticipant" do
-
-        let(:consumer_a) { double("consumer a") }
-        let(:consumer_b) { double("consumer b") }
-
-        let(:provider_x) { double("provider x") }
-        let(:provider_y) { double("provider y") }
-
-        let(:relationship_1) { Domain::IndexItem.new(consumer_a, provider_x)}
-        let(:relationship_2) { Domain::IndexItem.new(consumer_b, provider_y)}
-
-        subject { Group.new(relatio)}
-      end
-
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-require "pact_broker/domain/index_item"
-
-module PactBroker
-  module Domain
-    describe IndexItem do
-      describe "#last_webhook_execution_date" do
-        let(:webhook_execution_1) { double("webhook_execution", created_at: DateTime.new(2013)) }
-        let(:webhook_execution_2) { double("webhook_execution", created_at: DateTime.new(2015)) }
-
-        let(:webhook_executions) { [webhook_execution_1, webhook_execution_2] }
-
-        before do
-          allow(webhook_executions).to receive(:sort).and_return(webhook_executions)
-        end
-
-        subject { IndexItem.create(nil, nil, nil, nil, true, nil, [], webhook_executions) }
-
-        it "returns the created_at date of the last execution" do
-          expect(subject.last_webhook_execution_date).to eq DateTime.new(2015)
-        end
-      end
-    end
-  end
-end