pact_broker 2.89.1 → 2.90.0

data/spec/lib/pact_broker/api/resources/verification_spec.rb

@@ -1,87 +0,0 @@
-module PactBroker
-  module Api
-    module Resources
-      describe Verification do
-        before do
-          allow_any_instance_of(described_class).to receive(:verification_service).and_return(verification_service)
-          allow(verification_service).to receive(:find).and_return(verification)
-          allow(PactBroker::Api::Decorators::VerificationDecorator).to receive(:new).and_return(decorator)
-        end
-
-        let(:verification) { instance_double("PactBroker::Domain::Verification") }
-        let(:parsed_verification) { double("parsed verification") }
-        let(:verification_service) { class_double("PactBroker::Verifications::Service").as_stubbed_const }
-        let(:path) { "/pacts/provider/Bar/consumer/Foo/pact-version/1/verification-results/2" }
-
-        let(:rack_headers) do
-          {
-            "HTTP_ACCEPT" => "application/hal+json"
-          }
-        end
-
-        let(:decorator) do
-          instance_double("PactBroker::Api::Decorators::VerificationDecorator",
-            to_json: "response",
-            from_json: parsed_verification
-          )
-        end
-
-        describe "GET" do
-          let(:identifier_params) { { consumer_name: "Foo", provider_name: "Bar", pact_version_sha: "1", verification_number: "2" } }
-
-          subject { get(path, nil, rack_headers) }
-
-          it "finds the Verification" do
-            expect(PactBroker::Verifications::Service).to receive(:find).with(hash_including(identifier_params))
-            subject
-          end
-
-          context "when the verification does not exist" do
-            let(:verification) { nil }
-
-            it { is_expected.to be_a_404_response }
-          end
-
-          context "when someone tries to get all the verifications for a pact" do
-            let(:path) { "/pacts/provider/Bar/consumer/Foo/pact-version/1/verification-results/all" }
-
-            it "does not attempt to find the verification" do
-              expect(PactBroker::Verifications::Service).to_not receive(:find)
-              subject
-            end
-
-            it "tells them to use the matrix" do
-              expect(subject.status).to eq 404
-              expect(subject.body).to include "Matrix"
-            end
-          end
-
-          context "when the verification number specified is not a number" do
-            let(:path) { "/pacts/provider/Bar/consumer/Foo/pact-version/1/verification-results/5*5" }
-
-            it "does not attempt to find the verification" do
-              expect(PactBroker::Verifications::Service).to_not receive(:find)
-              subject
-            end
-
-            its(:status) { is_expected.to eq 404 }
-          end
-
-          context "when the Verification exists" do
-            it "generates a JSON representation of the Verification" do
-              expect(PactBroker::Api::Decorators::VerificationDecorator).to receive(:new).with(verification)
-              expect(decorator).to receive(:to_json).with(user_options: hash_including(base_url: "http://example.org"))
-              subject
-            end
-
-            it { is_expected.to be_a_hal_json_success_response }
-
-            it "includes the JSON representation in the response body" do
-              expect(subject.body).to eq "response"
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/api/resources/verification_triggered_webhooks_spec.rb

@@ -1,67 +0,0 @@
-require "pact_broker/api/resources/verification_triggered_webhooks"
-
-module PactBroker
-  module Api
-    module Resources
-      describe VerificationTriggeredWebhooks do
-        describe "GET" do
-          before do
-            allow(Decorators::TriggeredWebhooksDecorator).to receive(:new).and_return(decorator)
-            allow_any_instance_of(VerificationTriggeredWebhooks).to receive(:webhook_service).and_return(webhook_service)
-            allow_any_instance_of(VerificationTriggeredWebhooks).to receive(:verification_service).and_return(verification_service)
-            allow(webhook_service).to receive(:find_triggered_webhooks_for_verification).and_return(triggered_webhooks)
-          end
-
-          let(:decorator) { instance_double(Decorators::TriggeredWebhooksDecorator, to_json: "json") }
-          let(:webhook_service) { class_double(PactBroker::Webhooks::Service) }
-          let(:verification_service) { class_double(PactBroker::Verifications::Service, find: verification) }
-          let(:verification) { instance_double(PactBroker::Domain::Verification, number: "1") }
-          let(:triggered_webhooks) { double("triggered_webhooks") }
-          let(:path) { "/pacts/provider/bar/consumer/foo/pact-version/1234/verification-results/1/triggered-webhooks" }
-
-          subject { get path; last_response }
-
-          it "searchs for the verification" do
-            expect(verification_service).to receive(:find).with(
-              hash_including(
-                provider_name: "bar",
-                consumer_name: "foo",
-                pact_version_sha: "1234",
-                verification_number: "1"
-              )
-            )
-            subject
-          end
-
-          context "when the verification exists" do
-            it "finds the triggered webhooks for the verification" do
-              expect(webhook_service).to receive(:find_triggered_webhooks_for_verification)
-              subject
-            end
-
-            it { is_expected.to be_a_hal_json_success_response }
-
-            it "generates the JSON response body" do
-              expect(Decorators::TriggeredWebhooksDecorator).to receive(:new).with(triggered_webhooks)
-              expect(decorator).to receive(:to_json) do | options |
-                expect(options[:user_options]).to include(resource_title: "Webhooks triggered by the publication of verification result 1")
-                expect(options[:user_options]).to include(resource_url: "http://example.org#{path}")
-              end
-              subject
-            end
-
-            it "returns the generated JSON response body" do
-              expect(subject.body).to eq "json"
-            end
-          end
-
-          context "when the verification does not exist" do
-            let(:verification) { nil }
-
-            it { is_expected.to be_a_404_response }
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/api/resources/verifications_spec.rb

@@ -1,135 +0,0 @@
-require "pact_broker/api/resources/verifications"
-require "pact_broker/pacts/service"
-require "pact_broker/verifications/service"
-
-module PactBroker
-  module Api
-    module Resources
-      describe Verifications do
-        describe "post" do
-          let(:url) { "/pacts/provider/Provider/consumer/Consumer/pact-version/1234/metadata/abcd/verification-results" }
-          let(:request_body) { { some: "params" }.to_json }
-          let(:rack_env) do
-            { "CONTENT_TYPE" => "application/json", "pactbroker.database_connector" => database_connector }
-          end
-          let(:response_body) { JSON.parse(subject.body, symbolize_names: true) }
-          let(:database_connector) { double("database_connector" )}
-          let(:verification) { double(PactBroker::Domain::Verification) }
-          let(:errors_empty) { true }
-          let(:parsed_metadata) { { the: "metadata", consumer_version_number: "2", pending: true } }
-          let(:base_url) { "http://example.org" }
-          let(:webhook_execution_configuration) { instance_double(PactBroker::Webhooks::ExecutionConfiguration) }
-
-          before do
-            allow_any_instance_of(Verifications).to receive(:handle_webhook_events) { |&block| block.call }
-            allow(PactBroker::Verifications::Service).to receive(:create).and_return(verification)
-            allow(PactBroker::Verifications::Service).to receive(:errors).and_return(double(:errors, messages: ["errors"], empty?: errors_empty))
-            allow(PactBrokerUrls).to receive(:decode_pact_metadata).and_return(parsed_metadata)
-          end
-
-          subject { post(url, request_body, rack_env) }
-
-          it "looks up the specified pact" do
-            expect(Pacts::Service).to receive(:find_pact) do | arg |
-              expect(arg).to be_a(PactBroker::Pacts::PactParams)
-              expect(arg[:consumer_version_number]).to eq "2"
-            end
-            subject
-          end
-
-          context "when the pact does not exist" do
-            before do
-              allow(Pacts::Service).to receive(:find_pact).and_return(nil)
-            end
-
-            it "returns a 404" do
-              expect(subject.status).to eq 404
-            end
-          end
-
-          context "when the pact exists" do
-            let(:pact) do
-              instance_double("PactBroker::Domain::Pact",
-                provider_name: "Provider",
-                consumer_name: "Consumer",
-                pact_version_sha: "1234"
-              )
-            end
-            let(:next_verification_number) { "2" }
-            let(:serialised_verification) { {some: "verification"}.to_json }
-            let(:decorator) { instance_double("PactBroker::Api::Decorators::VerificationDecorator", to_json: serialised_verification) }
-
-            before do
-              allow(Pacts::Service).to receive(:find_pact).and_return(pact)
-              allow(Pacts::Service).to receive(:find_for_verification_publication).and_return(verified_pacts)
-              allow(PactBroker::Verifications::Service).to receive(:next_number).and_return(next_verification_number)
-              allow(PactBroker::Api::Decorators::VerificationDecorator).to receive(:new).and_return(decorator)
-              allow(PactBroker.configuration).to receive(:show_webhook_response?).and_return("some-boolean")
-            end
-
-            let(:verified_pacts) { double("verified pacts") }
-
-            it "parses the webhook metadata" do
-              expect(PactBrokerUrls).to receive(:decode_pact_metadata).with("abcd")
-              subject
-            end
-
-            it "returns a 201" do
-              expect(subject.status).to eq 201
-            end
-
-            it "returns the path of the newly created resource in the headers" do
-              expect(subject.headers["Location"]).to eq("http://example.org/pacts/provider/Provider/consumer/Consumer/pact-version/1234/verification-results/2")
-            end
-
-            it "stores the verification in the database" do
-              expect(PactBroker::Verifications::Service).to receive(:create).with(
-                next_verification_number,
-                hash_including("some" => "params", "wip" => false, "pending" => true),
-                verified_pacts,
-                parsed_metadata
-              )
-              subject
-            end
-
-            it "serialises the newly created verification" do
-              expect(PactBroker::Api::Decorators::VerificationDecorator).to receive(:new).with(verification)
-              expect(decorator).to receive(:to_json)
-              subject
-            end
-
-            it "returns the serialised verification in the response body" do
-              expect(subject.body).to eq serialised_verification
-            end
-
-            context "when the verification is for a wip pact" do
-              let(:parsed_metadata) { { wip: "true" } }
-
-              it "merges that into the verification params" do
-                expect(PactBroker::Verifications::Service).to receive(:create).with(
-                  anything,
-                  hash_including("wip" => true),
-                  anything,
-                  anything
-                )
-                subject
-              end
-            end
-          end
-
-          context "when invalid parameters are used" do
-            let(:errors_empty) { false }
-
-            it "returns a 400 status" do
-              expect(subject.status).to eq 400
-            end
-
-            it "sets errors on the response" do
-              expect(response_body[:errors]).to eq ["errors"]
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/api/resources/webhook_execution_spec.rb

@@ -1,92 +0,0 @@
-require "spec_helper"
-require "pact_broker/api/resources/webhook_execution"
-
-module PactBroker
-  module Api
-    module Resources
-      describe WebhookExecution do
-        describe "POST" do
-          before do
-            allow(PactBroker::Webhooks::Service).to receive(:find_by_uuid).and_return(webhook)
-          end
-
-          subject { post "/webhooks/some-uuid/execute"}
-
-          context "when the webhook does not exist" do
-            let(:webhook) { nil }
-
-            it "returns a 404" do
-              subject
-              expect(last_response).to be_a_404_response
-            end
-          end
-
-          context "when the webhook does exist" do
-            let(:success) { true }
-            let(:execution_result) { double("execution_result", success?: success, to_json: json)}
-            let(:json) { {some: "json"}.to_json }
-            let(:webhook) { double("webhook", consumer_name: consumer_name, provider_name: provider_name) }
-            let(:decorator) { instance_double(PactBroker::Api::Decorators::WebhookExecutionResultDecorator, to_json: json)}
-            let(:pact) { instance_double("PactBroker::Domain::Pact") }
-            let(:consumer_name) { "foo" }
-            let(:provider_name) { "bar" }
-            let(:webhook_execution_configuration) { instance_double(PactBroker::Webhooks::ExecutionConfiguration, retry_schedule: [], webhook_context: event_context) }
-            let(:event_context) { { some: "data" } }
-
-            before do
-              allow(PactBroker::Webhooks::TriggerService).to receive(:test_execution).and_return(execution_result)
-              allow(PactBroker::Api::Decorators::WebhookExecutionResultDecorator).to receive(:new).and_return(decorator)
-              allow_any_instance_of(WebhookExecution).to receive(:webhook_execution_configuration).and_return(webhook_execution_configuration)
-            end
-
-            it "executes the webhook" do
-              expect(PactBroker::Webhooks::TriggerService).to receive(:test_execution).with(webhook, event_context, webhook_execution_configuration)
-              subject
-            end
-
-            context "when execution is successful" do
-              let(:expected_user_options) do
-                {
-                  resource_url: "http://example.org/webhooks/some-uuid/execute",
-                  base_url: "http://example.org",
-                  webhook: webhook,
-                  show_response: "foo",
-                }
-              end
-
-              it "returns a 200 JSON response" do
-                subject
-                expect(last_response).to be_a_hal_json_success_response
-              end
-
-              it "generates a JSON response body for the execution result" do
-                allow(PactBroker.configuration).to receive(:show_webhook_response?).and_return("foo")
-                expect(decorator).to receive(:to_json).with(user_options: hash_including(expected_user_options))
-                subject
-              end
-
-              it "includes the execution result JSON in the body" do
-                subject
-                expect(last_response.body).to eq json
-              end
-            end
-
-            context "when execution is not successful" do
-              let(:success) { false }
-
-              it "returns a 200 JSON response" do
-                subject
-                expect(last_response.status).to eq 200
-              end
-
-              it "includes the execution result JSON in the body" do
-                subject
-                expect(last_response.body).to eq json
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/api/resources/webhook_spec.rb

@@ -1,115 +0,0 @@
-require "spec_helper"
-require "pact_broker/api/resources/webhook"
-
-module PactBroker::Api
-  module Resources
-    describe Webhook do
-      before do
-        allow(PactBroker::Webhooks::Service).to receive(:find_by_uuid).and_return(webhook)
-      end
-
-      describe "GET" do
-        subject { get "/webhooks/some-uuid"; last_response }
-
-        context "when the webhook does not exist" do
-          let(:webhook) { nil }
-
-          it "returns a 404" do
-            expect(subject).to be_a_404_response
-          end
-        end
-
-        context "when the webhook exists" do
-          before do
-            allow(Decorators::WebhookDecorator).to receive(:new).and_return(decorator)
-          end
-
-          let(:webhook) { double("webhook") }
-          let(:decorator) { double(Decorators::WebhookDecorator, to_json: json)}
-          let(:json) { {some: "json"}.to_json }
-
-          it "finds the webhook by UUID" do
-            expect(PactBroker::Webhooks::Service).to receive(:find_by_uuid).with("some-uuid")
-            subject
-          end
-
-          it "returns a 200 JSON response" do
-            subject
-            expect(last_response).to be_a_hal_json_success_response
-          end
-
-          it "generates a JSON representation of the webhook" do
-            expect(Decorators::WebhookDecorator).to receive(:new).with(webhook)
-            expect(decorator).to receive(:to_json).with(user_options: hash_including(base_url: "http://example.org"))
-            subject
-          end
-
-          it "includes the JSON representation in the response body" do
-            subject
-            expect(last_response.body).to eq json
-          end
-        end
-      end
-
-      describe "PUT" do
-        before do
-          allow(Decorators::WebhookDecorator).to receive(:new).and_return(decorator)
-          allow(PactBroker::Webhooks::Service).to receive(:create).and_return(created_webhook)
-          allow_any_instance_of(Webhook).to receive(:consumer).and_return(consumer)
-          allow_any_instance_of(Webhook).to receive(:provider).and_return(provider)
-          allow_any_instance_of(Webhook).to receive(:webhook_validation_errors?).and_return(false)
-        end
-
-        let(:consumer) { double("consumer") }
-        let(:provider) { double("provider") }
-        let(:webhook) { double("webhook") }
-        let(:decorator) { double(Decorators::WebhookDecorator, from_json: parsed_webhook, to_json: json)}
-        let(:json) { {some: "json"}.to_json }
-
-        let(:parsed_webhook) { double("parsed_webhook") }
-        let(:created_webhook) { double("created_webhook") }
-        let(:webhook) { nil }
-        let(:webhook_json) { load_fixture("webhook_valid.json") }
-        let(:uuid) { "some-uuid" }
-
-        subject { put("/webhooks/#{uuid}", webhook_json, "CONTENT_TYPE" => "application/json") }
-
-        it "validates the UUID" do
-          expect_any_instance_of(Webhook).to receive(:webhook_validation_errors?).with(parsed_webhook, uuid)
-          subject
-        end
-
-        context "when the webhook does not exist" do
-          it "creates the webhook" do
-            expect(PactBroker::Webhooks::Service).to receive(:create).with(uuid, parsed_webhook, consumer, provider)
-            subject
-          end
-
-          its(:status) { is_expected.to eq 201 }
-
-          it "returns the JSON respresentation of the webhook" do
-            expect(subject.body).to eq json
-          end
-        end
-
-        context "when the webhook does exist" do
-          before do
-            allow(PactBroker::Webhooks::Service).to receive(:update_by_uuid).and_return(created_webhook)
-          end
-          let(:webhook) { double("existing webhook") }
-
-          its(:status) { is_expected.to eq 200 }
-
-          it "updates the webhook" do
-            expect(PactBroker::Webhooks::Service).to receive(:update_by_uuid).with(uuid, JSON.parse(webhook_json))
-            subject
-          end
-
-          it "returns the JSON respresentation of the webhook" do
-            expect(subject.body).to eq json
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/app_basic_auth_spec.rb

@@ -1,122 +0,0 @@
-require "pact_broker/app"
-require "anyway/testing/helpers"
-
-module PactBroker
-  describe App do
-    include Anyway::Testing::Helpers
-
-    before do
-      allow(PactBroker::DB).to receive(:run_migrations)
-    end
-
-    class TestApp2 < PactBroker::App
-      def configure_database_connection
-        # do nothing so we don't screw up our test connection
-      end
-    end
-
-    around do | example |
-      env_vars = {
-        "PACT_BROKER_BASIC_AUTH_ENABLED" => basic_auth_enabled,
-        "PACT_BROKER_BASIC_AUTH_USERNAME" => basic_auth_username,
-        "PACT_BROKER_BASIC_AUTH_PASSWORD" => basic_auth_password,
-        "PACT_BROKER_BASIC_AUTH_READ_ONLY_USERNAME" => basic_auth_read_only_username,
-        "PACT_BROKER_BASIC_AUTH_READ_ONLY_PASSWORD" => basic_auth_read_only_password,
-        "PACT_BROKER_ALLOW_PUBLIC_READ" => allow_public_read,
-        "PACT_BROKER_ENABLE_PUBLIC_BADGE_ACCESS" => enable_public_badge_access
-      }
-      with_env(env_vars, &example)
-    end
-
-    let(:basic_auth_enabled) { "true" }
-    let(:basic_auth_username) { "user" }
-    let(:basic_auth_password) { "pass" }
-    let(:basic_auth_read_only_username) { "rouser" }
-    let(:basic_auth_read_only_password) { "ropass" }
-    let(:allow_public_read) { "false" }
-    let(:enable_public_badge_access) { "false" }
-
-    let(:app) do
-      TestApp2.new do | configuration |
-        configuration.database_connection = PactBroker::DB.connection
-      end
-    end
-
-    subject { get("/") }
-
-    context "with correct write credentials" do
-      before do
-        basic_authorize "user", "pass"
-      end
-
-      its(:status) { is_expected.to eq 200 }
-    end
-
-    context "with correct read credentials" do
-      before do
-        basic_authorize "rouser", "ropass"
-      end
-
-      its(:status) { is_expected.to eq 200 }
-    end
-
-    context "with incorrect credentials" do
-      before do
-        basic_authorize "wrong", "pass"
-      end
-
-      its(:status) { is_expected.to eq 401 }
-    end
-
-    context "with no credentials" do
-      its(:status) { is_expected.to eq 401 }
-
-      context "when allow_public_read=true" do
-        let(:allow_public_read) { "true" }
-
-        its(:status) { is_expected.to eq 200 }
-      end
-    end
-
-    context "with basic auth enabled but no username or password configured" do
-      before do
-        basic_authorize "", ""
-      end
-
-      let(:basic_auth_username) { "" }
-      let(:basic_auth_password) { "" }
-
-      its(:status) { is_expected.to eq 401 }
-    end
-
-    context "with basic auth disabled" do
-      let(:basic_auth_enabled) { "false" }
-
-      context "with no credentials" do
-        its(:status) { is_expected.to eq 200 }
-      end
-    end
-
-    context "accessing a badge" do
-      before do
-        td.create_pact_with_hierarchy("foo", "1", "bar")
-      end
-
-      subject { get(PactBroker::Api::PactBrokerUrls.badge_url_for_latest_pact(td.and_return(:pact))) }
-
-      its(:status) { is_expected.to eq 401 }
-
-      context "with no basic auth configured" do
-        let(:basic_auth_enabled) { "false" }
-
-        its(:status) { is_expected.to eq 307 }
-      end
-
-      context "with public badge access enabled" do
-        let(:enable_public_badge_access) { "true" }
-
-        its(:status) { is_expected.to eq 307 }
-      end
-    end
-  end
-end