pact_broker 2.89.1 → 2.90.0

data/spec/lib/rack/pact_broker/request_target_spec.rb

@@ -1,69 +0,0 @@
-require "rack/pact_broker/request_target"
-
-module Rack
-  module PactBroker
-    describe RequestTarget do
-      let(:rack_env) do
-        {
-          "CONTENT_TYPE" => content_type,
-          "HTTP_ACCEPT" => accept,
-          "PATH_INFO" => path
-        }
-      end
-      let(:content_type) { nil }
-      let(:accept) { nil }
-      let(:path) { "" }
-
-      describe "#request_for_ui?" do
-        let(:path) { "/" }
-
-        subject { RequestTarget.request_for_ui?(rack_env) }
-
-        context "when the Accept header includes text/html" do
-          let(:accept) { "text/html" }
-
-          it { is_expected.to be true }
-        end
-
-        context "when the request is for a web asset with an Accept header of */*" do
-          let(:path) { "/blah/foo.woff" }
-          let(:accept) { "*/*" }
-
-          it { is_expected.to be true }
-        end
-
-        context "when the request is for a content type served by the API (HAL browser request)" do
-          let(:accept) { "application/hal+json, application/json, */*; q=0.01" }
-
-          it { is_expected.to be false }
-        end
-
-        context "when the request is not for a web asset and the Accept headers is */* (default Accept header from curl request)" do
-          let(:accept) { "*/*" }
-
-          it { is_expected.to be false }
-        end
-
-        context "when the request is not for a web asset and no Accept header is specified" do
-          let(:accept) { nil }
-
-          it { is_expected.to be false }
-        end
-
-        context "when the request ends in a web asset extension but has Accept application/hal+json" do
-          let(:accept) { "application/hal+json" }
-          let(:path) { "/blah/foo.woff" }
-
-          it { is_expected.to be false }
-        end
-
-        context "when the request is for a badge resource with a svg content type" do
-          let(:accept) { "image/svg+xml;charset=utf-8" }
-          let(:path) { "/pacts/provider/foo/consumer/bar/latest/badge" }
-
-          it { is_expected.to be false }
-        end
-      end
-    end
-  end
-end

data/spec/lib/rack/pact_broker/set_base_url_spec.rb

@@ -1,86 +0,0 @@
-require "rack/pact_broker/set_base_url"
-
-module Rack
-  module PactBroker
-    describe SetBaseUrl do
-      let(:base_urls) { ["http://pact-broker"] }
-      let(:rack_env) { {} }
-      let(:target_app) { double("app", call: [200, {}, []]) }
-      let(:app) { SetBaseUrl.new(target_app, base_urls) }
-
-      subject { get("/", {}, rack_env) }
-
-      describe "#call" do
-        context "when the base_url is already set" do
-          let(:rack_env) { { "pactbroker.base_url" => "http://foo"} }
-
-          it "does not overwrite it" do
-            expect(target_app).to receive(:call).with(hash_including("pactbroker.base_url" => "http://foo"))
-            subject
-          end
-        end
-
-        context "when there is one base URL" do
-          it "sets that base_url" do
-            expect(target_app).to receive(:call).with(hash_including("pactbroker.base_url" => "http://pact-broker"))
-            subject
-          end
-        end
-
-        context "when there are no base URLs" do
-          let(:base_urls) { [] }
-
-          it "sets the base URL to nil" do
-            expect(target_app).to receive(:call).with(hash_including("pactbroker.base_url" => nil))
-            subject
-          end
-        end
-
-        context "when there are multiple base URLs" do
-          let(:base_urls) { ["https://foo", "https://pact-broker-external", "http://pact-broker-internal"] }
-
-          let(:host) { "pact-broker-internal" }
-          let(:scheme) { "http" }
-          let(:forwarded_host) { "pact-broker-external" }
-          let(:forwarded_scheme) { "https" }
-          let(:rack_env) do
-            {
-              Rack::HTTP_HOST => host,
-              Rack::RACK_URL_SCHEME => scheme,
-              "HTTP_X_FORWARDED_HOST" => forwarded_host,
-              "HTTP_X_FORWARDED_SCHEME" => forwarded_scheme
-            }
-          end
-
-          context "when the base URL created taking any X-Forwarded headers into account matches one of the base URLs" do
-            it "uses that base URL" do
-              expect(target_app).to receive(:call).with(hash_including("pactbroker.base_url" => "https://pact-broker-external"))
-              subject
-            end
-          end
-
-          context "when the base URL created NOT taking the X-Forwarded headers into account matches one of the base URLs (potential cache poisoning)" do
-            let(:forwarded_host) { "pact-broker-external-wrong" }
-
-            it "uses that base URL" do
-              expect(target_app).to receive(:call).with(hash_including("pactbroker.base_url" => "http://pact-broker-internal"))
-              subject
-            end
-          end
-
-          context "when neither base URL matches the base URLs (potential cache poisoning)" do
-            before do
-              rack_env["HTTP_HOST"] = "silly-buggers-1"
-              rack_env["HTTP_X_FORWARDED_HOST"] = "silly-buggers-1"
-            end
-
-            it "uses the first base URL" do
-              expect(target_app).to receive(:call).with(hash_including("pactbroker.base_url" => "https://foo"))
-              subject
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/rack/pact_broker/use_when_spec.rb

@@ -1,49 +0,0 @@
-require "rack/pact_broker/use_when"
-require "rack/test"
-
-module Rack
-  module PactBroker
-    describe UseWhen do
-
-      using Rack::PactBroker::UseWhen
-      include Rack::Test::Methods
-
-      class TestMiddleware
-        def initialize(app, additional_headers)
-          @app = app
-          @additional_headers = additional_headers
-        end
-
-        def call(env)
-          status, headers, body = @app.call(env)
-          [status, headers.merge(@additional_headers), body]
-        end
-      end
-
-      let(:app) do
-        target_app = -> (_env) { [200, {}, []] }
-        builder = Rack::Builder.new
-        condition = ->(env) { env["PATH_INFO"] == "/match" }
-        builder.use_when condition, TestMiddleware, { "Foo" => "Bar" }
-        builder.run target_app
-        builder.to_app
-      end
-
-      context "when the condition matches" do
-        subject { get "/match" }
-
-        it "uses the middleware" do
-          expect(subject.headers).to include "Foo" => "Bar"
-        end
-      end
-
-      context "when the condition does not match" do
-        subject { get "/no-match" }
-
-        it "does not use the middleware" do
-          expect(subject.headers.keys).to_not include "Foo"
-        end
-      end
-    end
-  end
-end

data/spec/lib/sequel/plugins/insert_ignore_spec.rb

@@ -1,82 +0,0 @@
-require "sequel/plugins/insert_ignore"
-require "sequel"
-
-module Sequel
-  module Plugins
-    module InsertIgnore
-      class PacticipantNoInsertIgnore < Sequel::Model(:pacticipants)
-        plugin :timestamps, update_on_create: true
-      end
-
-      class Pacticipant < Sequel::Model
-        plugin :insert_ignore, identifying_columns: [:name]
-        plugin :timestamps, update_on_create: true
-      end
-
-      class Version < Sequel::Model
-        plugin :insert_ignore, identifying_columns: [:pacticipant_id, :number]
-        plugin :timestamps, update_on_create: true
-      end
-
-      context "when a duplicate is inserted with no insert_ignore" do
-        before do
-          PacticipantNoInsertIgnore.new(name: "Foo").save
-        end
-
-        subject do
-          PacticipantNoInsertIgnore.new(name: "Foo").save
-        end
-
-        it "raises an error" do
-          expect { subject }.to raise_error Sequel::UniqueConstraintViolation
-        end
-      end
-
-      # This doesn't work on MSQL because the _insert_raw method
-      # does not return the row ID of the duplicated row when insert_ignore is used
-      # May have to go back to the old method of doing this
-      context "when a duplicate Pacticipant is inserted with insert_ignore" do
-        before do
-          Pacticipant.new(name: "Foo", repository_url: "http://foo").insert_ignore
-        end
-
-        subject do
-          Pacticipant.new(name: "Foo").insert_ignore
-        end
-
-        it "does not raise an error" do
-          expect { subject }.to_not raise_error
-        end
-
-        it "sets the values on the object" do
-          expect(subject.repository_url).to eq "http://foo"
-        end
-
-        it "does not insert another row" do
-          expect { subject }.to_not change { Pacticipant.count }
-        end
-      end
-
-      context "when a duplicate Version is inserted with insert_ignore" do
-        let!(:pacticipant) { Pacticipant.new(name: "Foo").save }
-        let!(:original_version) { Version.new(number: "1", pacticipant_id: pacticipant.id).insert_ignore }
-
-        subject do
-          Version.new(number: "1", pacticipant_id: pacticipant.id).insert_ignore
-        end
-
-        it "does not raise an error" do
-          expect { subject }.to_not raise_error
-        end
-
-        it "sets the values on the object" do
-          expect(subject.id).to eq original_version.id
-        end
-
-        it "does not insert another row" do
-          expect { subject }.to_not change { Version.count }
-        end
-      end
-    end
-  end
-end

data/spec/lib/sequel/plugins/upsert_spec.rb

@@ -1,159 +0,0 @@
-require "sequel/plugins/upsert"
-require "sequel"
-
-module Sequel
-  module Plugins
-    module Upsert
-      class PacticipantNoUpsert < Sequel::Model(:pacticipants)
-        plugin :timestamps, update_on_create: true
-      end
-
-      class Pacticipant < Sequel::Model
-        plugin :upsert, identifying_columns: [:name]
-        plugin :timestamps, update_on_create: true
-      end
-
-      class Version < Sequel::Model
-        plugin :upsert, identifying_columns: [:pacticipant_id, :number]
-        plugin :timestamps, update_on_create: true
-      end
-
-      class LatestPactPublicationIdForConsumerVersion < Sequel::Model(:latest_pact_publication_ids_for_consumer_versions)
-        set_primary_key [:provider_id, :consumer_version_id]
-        unrestrict_primary_key
-        plugin :upsert, identifying_columns: [:provider_id, :consumer_version_id]
-      end
-
-      describe PacticipantNoUpsert do
-        it "has an _insert_dataset method" do
-          expect(PacticipantNoUpsert.private_instance_methods).to include(:_insert_dataset)
-        end
-      end
-
-      describe "LatestPactPublicationIdForConsumerVersion" do
-        before do
-          td.create_pact_with_hierarchy("Foo", "1", "Bar")
-            .create_consumer_version("2")
-        end
-
-        let!(:new_pact_publication) do
-          pact_publication_values = PactBroker::Pacts::PactPublication.first.values.dup
-          pact_publication_values.delete(:id)
-          pact_publication_values.delete(:created_at)
-          pact_publication_values.delete(:updated_at)
-          pact_publication_values[:revision_number] = 2
-          PactBroker::Pacts::PactPublication.new(pact_publication_values).save
-        end
-
-        let(:new_latest_pact_publication_id_for_consumer_version) do
-          values = LatestPactPublicationIdForConsumerVersion.first.values
-          LatestPactPublicationIdForConsumerVersion.new(values.merge(pact_publication_id: new_pact_publication.id))
-        end
-
-        describe "save" do
-          subject { new_latest_pact_publication_id_for_consumer_version.save }
-
-          it "raises an error" do
-            expect { subject }.to raise_error Sequel::UniqueConstraintViolation
-          end
-        end
-
-        describe "upsert" do
-          subject { new_latest_pact_publication_id_for_consumer_version.upsert }
-
-          it "updates the new object with the values from the existing object" do
-            expect(subject.pact_publication_id).to eq new_pact_publication.id
-          end
-        end
-      end
-
-      context "when a duplicate is inserted with no upsert" do
-        before do
-          PacticipantNoUpsert.new(name: "Foo").save
-        end
-
-        subject do
-          PacticipantNoUpsert.new(name: "Foo").save
-        end
-
-        it "raises an error" do
-          expect { subject }.to raise_error Sequel::UniqueConstraintViolation
-        end
-      end
-
-      # This doesn't work on MSQL because the _insert_raw method
-      # does not return the row ID of the duplicated row when upsert is used
-      # May have to go back to the old method of doing this
-      context "when a duplicate Pacticipant is inserted with upsert" do
-        before do
-          Pacticipant.new(name: "Foo", repository_url: "http://foo").upsert
-        end
-
-        subject do
-          Pacticipant.new(name: "Foo", repository_url: "http://bar").upsert
-        end
-
-        it "does not raise an error" do
-          expect { subject }.to_not raise_error
-        end
-
-        it "sets the values on the object" do
-          expect(subject.repository_url).to eq "http://bar"
-        end
-
-        it "does not insert another row" do
-          expect { subject }.to_not change { Pacticipant.count }
-        end
-      end
-
-      context "when a duplicate Version is inserted with upsert" do
-        let!(:pacticipant) { Pacticipant.new(name: "Foo").save }
-        let!(:original_version) do
-          version = Version.new(
-            number: "1",
-            pacticipant_id: pacticipant.id,
-            build_url: "original-url"
-          ).upsert
-          Version.where(id: version.id).update(created_at: yesterday, updated_at: yesterday)
-          version
-        end
-        let(:yesterday) { DateTime.now - 2 }
-
-        subject do
-          Version.new(number: "1", pacticipant_id: pacticipant.id, build_url: "new-url").upsert
-        end
-
-        it "does not raise an error" do
-          expect { subject }.to_not raise_error
-        end
-
-        it "sets the values on the object" do
-          expect(subject.build_url).to eq "new-url"
-        end
-
-        context "when an attribute is not set" do
-          subject do
-            Version.new(number: "1", pacticipant_id: pacticipant.id).upsert
-          end
-
-          it "nils out values that weren't set on the second model" do
-            expect(subject.build_url).to eq nil
-          end
-        end
-
-
-        it "does not insert another row" do
-          expect { subject }.to_not change { Version.count }
-        end
-
-        it "does not change the created_at" do
-          expect { subject }.to_not change { Version.where(number: "1").first.created_at }
-        end
-
-        it "does change the updated_at" do
-          expect { subject }.to change { Version.where(number: "1").first.updated_at }
-        end
-      end
-    end
-  end
-end

data/spec/lib/webmachine/rack_adapter_monkey_patch_spec.rb

@@ -1,49 +0,0 @@
-require "webmachine"
-require "webmachine/adapters/rack_mapped"
-require "rack/test"
-
-module Webmachine
-  module Adapters
-    class TestResource < Webmachine::Resource
-      def allowed_methods
-        ["POST"]
-      end
-
-      def process_post
-        response.body = request.env["FOO"]
-        true
-      end
-    end
-
-    describe Rack do
-      include ::Rack::Test::Methods
-
-      let(:app) do
-        pact_api = Webmachine::Application.new do |app|
-          app.routes do
-            add(["test"], TestResource)
-          end
-        end
-
-        pact_api.configure do |config|
-          config.adapter = :RackMapped
-        end
-
-        pact_api.adapter
-      end
-
-      let(:rack_env) do
-        {
-          "FOO" => "foo"
-        }
-      end
-
-      subject { post("/test", nil, rack_env) }
-
-      it "passes the rack env through on the request" do
-        expect(subject.status).to eq 200
-        expect(subject.body).to eq "foo"
-      end
-    end
-  end
-end

data/spec/migrations/20180201_create_head_matrix_spec.rb

@@ -1,132 +0,0 @@
-describe "latest tagged matrix", migration: true do
-  let(:td) { TestDataBuilder.new }
-
-  before do
-    PactBroker::Database.migrate
-  end
-
-  subject { database[:head_matrix].all }
-
-  context "with a single consumer version tag on the latest version" do
-    before do
-      td.create_pact_with_hierarchy("Foo", "1", "Bar")
-        .create_consumer_version_tag("prod")
-        .create_consumer_version("2")
-        .create_consumer_version_tag("prod")
-        .create_pact
-        .revise_pact
-    end
-
-    context "without a verification" do
-      it "returns a line with no tag and a line with a tag" do
-        expect(subject).to contain_hash(
-          consumer_version_tag_name: nil,
-          consumer_version_number: "2"
-        )
-        expect(subject).to contain_hash(
-          consumer_version_tag_name: "prod",
-          consumer_version_number: "2"
-        )
-      end
-    end
-
-    context "with a verification" do
-      before do
-        td.create_verification(provider_version: "3")
-      end
-      it "returns the verification details" do
-        expect(subject).to contain_hash(
-          consumer_version_tag_name: nil,
-          consumer_version_number: "2",
-          provider_version_number: "3"
-        )
-        expect(subject).to contain_hash(
-          consumer_version_tag_name: "prod",
-          consumer_version_number: "2",
-          provider_version_number: "3"
-        )
-      end
-    end
-  end
-  context "with two tags on the latest version" do
-    before do
-      td.create_pact_with_hierarchy("Foo", "1", "Bar")
-        .create_consumer_version_tag("prod")
-        .create_consumer_version_tag("master")
-        .create_consumer_version("2")
-        .create_consumer_version_tag("prod")
-        .create_consumer_version_tag("master")
-        .create_pact
-        .revise_pact
-    end
-
-    it "returns a line with no tag, and a line for each tag" do
-      expect(subject).to contain_hash(
-        consumer_version_tag_name: nil,
-        consumer_version_number: "2"
-      )
-      expect(subject).to contain_hash(
-        consumer_version_tag_name: "prod",
-        consumer_version_number: "2"
-      )
-
-      expect(subject).to contain_hash(
-        consumer_version_tag_name: "master",
-        consumer_version_number: "2"
-      )
-    end
-
-    context "with a verification" do
-      before do
-        td.create_verification(provider_version: "3")
-      end
-      it "returns the verification details" do
-        expect(subject).to contain_hash(
-          consumer_version_tag_name: nil,
-          consumer_version_number: "2",
-          provider_version_number: "3"
-        )
-        expect(subject).to contain_hash(
-          consumer_version_tag_name: "prod",
-          consumer_version_number: "2",
-          provider_version_number: "3"
-        )
-
-        expect(subject).to contain_hash(
-          consumer_version_tag_name: "master",
-          consumer_version_number: "2",
-          provider_version_number: "3"
-        )
-      end
-    end
-  end
-  context "with different versions for overall latest, and two other tags" do
-    before do
-      td.create_pact_with_hierarchy("Foo", "1", "Bar")
-        .create_consumer_version_tag("prod")
-        .create_consumer_version_tag("master")
-        .create_consumer_version("2")
-        .create_consumer_version_tag("master")
-        .create_pact
-        .revise_pact
-        .create_consumer_version("3")
-        .create_pact
-    end
-
-    it "returns a line for each" do
-      expect(subject).to contain_hash(
-        consumer_version_tag_name: nil,
-        consumer_version_number: "3"
-      )
-      expect(subject).to contain_hash(
-        consumer_version_tag_name: "prod",
-        consumer_version_number: "1"
-      )
-
-      expect(subject).to contain_hash(
-        consumer_version_tag_name: "master",
-        consumer_version_number: "2"
-      )
-    end
-  end
-end