pact_broker 2.89.1 → 2.90.0

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

@@ -1,68 +0,0 @@
-require "pact_broker/api/resources/latest_verifications_for_consumer_version"
-require "pact_broker/versions/service"
-
-module PactBroker
-  module Api
-    module Resources
-
-      describe LatestVerificationsForConsumerVersion do
-        describe "GET" do
-          let(:url) { "/verification-results/consumer/Consumer/version/1.2.3/latest" }
-          let(:response_body) { JSON.parse(subject.body, {symbolize_names: true}) }
-          let(:version) { double(:version) }
-
-          subject { get url; last_response }
-
-          before do
-            allow(PactBroker::Versions::Service).to receive(:find_by_pacticipant_name_and_number).and_return(version)
-          end
-
-          it "looks up the consumer version" do
-            expect(PactBroker::Versions::Service).to receive(:find_by_pacticipant_name_and_number).with(hash_including(pacticipant_name: "Consumer", pacticipant_version_number: "1.2.3"))
-            subject
-          end
-
-          context "when the consumer version exists" do
-            let(:decorator) { double(:decorator, to_json: json) }
-            let(:summary) { double(:summary) }
-            let(:json) { {some: "json"}.to_json }
-
-            before do
-              allow(PactBroker::Api::Decorators::VerificationSummaryDecorator).to receive(:new).and_return(decorator)
-              allow(PactBroker::Verifications::Service).to receive(:verification_summary_for_consumer_version).and_return(summary)
-            end
-
-            it { is_expected.to be_a_hal_json_success_response }
-
-            it "finds the latest verifications for the consumer version" do
-              expect(PactBroker::Verifications::Service).to receive(:verification_summary_for_consumer_version).with(hash_including(consumer_name: "Consumer", consumer_version_number: "1.2.3"))
-              subject
-            end
-
-            it "serialises the verifications" do
-              expect(PactBroker::Api::Decorators::VerificationSummaryDecorator).to receive(:new).with(summary)
-              expect(decorator).to receive(:to_json) do | args |
-                expect(args[:user_options][:consumer_name]).to eq "Consumer"
-                expect(args[:user_options][:consumer_version_number]).to eq "1.2.3"
-                expect(args[:user_options][:resource_url]).to include(url)
-                expect(args[:user_options][:base_url]).to eq "http://example.org"
-              end
-              subject
-            end
-
-            it "returns the serialised verifications in the response" do
-              expect(subject.body).to eq(json)
-            end
-          end
-
-          context "when the consumer version does not exist" do
-            let(:version) { nil }
-
-            it { is_expected.to be_a_404_response }
-          end
-
-        end
-      end
-    end
-  end
-end

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

@@ -1,11 +0,0 @@
-require "pact_broker/api/resources/matrix_badge"
-
-module PactBroker
-  module Api
-    module Resources
-      describe MatrixBadge do
-        # spec is in spec/lib/pact_broker/api/resources/badge_spec.rb#123 to avoid duplication
-      end
-    end
-  end
-end

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

@@ -1,42 +0,0 @@
-require "pact_broker/api/resources/matrix"
-require "pact_broker/matrix/service"
-
-module PactBroker
-  module Api
-    module Resources
-      describe Matrix do
-        before do
-          allow(PactBroker::Matrix::Service).to receive(:validate_selectors).and_return(error_messages)
-          allow(PactBroker::Matrix::Service).to receive(:can_i_deploy).and_return([])
-          allow(PactBroker::Matrix::ParseQuery).to receive(:call).and_return([selectors, options])
-        end
-
-        let(:td) { TestDataBuilder.new }
-        let(:path) { "/matrix" }
-        let(:json_response_body) { JSON.parse(subject.body, symbolize_names: true) }
-        let(:params) { {q: [{pacticipant: "Foo", version: "1"}, {pacticipant: "Bar", version: "2"}]} }
-        let(:error_messages) { [] }
-        let(:selectors) { double("selectors") }
-        let(:options) { double("options") }
-
-        subject { get path, params, {"Content-Type" => "application/hal+json"}; last_response }
-
-        it "validates the selectors" do
-          expect(PactBroker::Matrix::Service).to receive(:validate_selectors).with(selectors, options)
-          subject
-        end
-
-        context "when a validation error occurs" do
-          let(:error_messages) { ["foo"] }
-          it "returns a 400 status" do
-            expect(subject.status).to eq 400
-          end
-
-          it "returns error messages" do
-            expect(json_response_body[:errors]).to eq ["foo"]
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,178 +0,0 @@
-require "spec_helper"
-require "pact_broker/api/resources/pact"
-require "rack/test"
-require "pact_broker/pacts/service"
-require "pact_broker/pacticipants/service"
-
-module PactBroker::Api
-  module Resources
-    describe Pact do
-      include Rack::Test::Methods
-
-      let(:app) { PactBroker::API }
-      let(:json) { {some: "json"}.to_json }
-
-      describe "GET" do
-        context "Accept: text/html" do
-
-          let(:json_content) { "json_content" }
-          let(:pact) { double("pact", json_content: json_content)}
-          let(:html) { "html" }
-          let(:pact_id_params) { {provider_name: "provider_name", consumer_name: "consumer_name", consumer_version_number: "1.2.3"} }
-          let(:html_options) { { base_url: "http://example.org", badge_url: "http://badge" } }
-
-          before do
-            allow_any_instance_of(Pact).to receive(:badge_url_for_latest_pact).and_return("http://badge")
-            allow_any_instance_of(Pact).to receive(:ui_base_url).and_return("http://example.org")
-            allow(PactBroker::Pacts::Service).to receive(:find_pact).and_return(pact)
-            allow(PactBroker.configuration.html_pact_renderer).to receive(:call).and_return(html)
-          end
-
-          subject { get "/pacts/provider/provider_name/consumer/consumer_name/versions/1.2.3",{}, {"HTTP_ACCEPT" => "text/html"} }
-
-          it "finds the pact" do
-            expect(PactBroker::Pacts::Service).to receive(:find_pact).with(hash_including(pact_id_params))
-            subject
-          end
-
-          it "determines the badge url for the HTML page" do
-            expect_any_instance_of(Pact).to receive(:badge_url_for_latest_pact).with(pact, "http://example.org")
-            subject
-          end
-
-          it "uses the configured HTML renderer" do
-            expect(PactBroker.configuration.html_pact_renderer).to receive(:call).with(pact, html_options)
-            subject
-          end
-
-          it "returns a HTML body" do
-            subject
-            expect(last_response.body).to eq html
-          end
-
-          it "returns a content type of HTML" do
-            subject
-            expect(last_response.headers["Content-Type"]).to eq "text/html;charset=utf-8"
-          end
-
-        end
-      end
-
-      shared_examples "an update endpoint" do |http_method|
-        subject { self.send http_method, "/pacts/provider/Provider/consumer/Consumer/version/1.2.3", json, {"CONTENT_TYPE" => "application/json"} ; last_response }
-
-        let(:response) { subject; last_response }
-
-        context "with invalid JSON" do
-          let(:json) { "{" }
-
-          it "returns a 400 response" do
-            expect(response.status).to eq 400
-          end
-
-          it "returns a JSON content type" do
-            expect(response.headers["Content-Type"]).to eq "application/hal+json;charset=utf-8"
-          end
-
-          it "returns an error message" do
-            expect(JSON.parse(response.body)["error"]).to match(/Error parsing JSON/)
-          end
-        end
-
-        context "with validation errors" do
-          let(:errors) { double(:errors, messages: ["messages"]) }
-
-          before do
-            allow_any_instance_of(Contracts::PutPactParamsContract).to receive(:validate).and_return(false)
-            allow_any_instance_of(Contracts::PutPactParamsContract).to receive(:errors).and_return(errors)
-          end
-
-          it "returns a 400 error" do
-            expect(subject).to be_a_json_error_response "messages"
-          end
-        end
-
-        context "with a potential duplicate pacticipant" do
-
-          let(:pacticipant_service) { PactBroker::Pacticipants::Service }
-          let(:messages) { ["message1", "message2"] }
-
-          before do
-            allow(pacticipant_service).to receive(:messages_for_potential_duplicate_pacticipants).and_return(messages)
-          end
-
-          it "checks for duplicates" do
-            expect(pacticipant_service).to receive(:messages_for_potential_duplicate_pacticipants).with(["Consumer", "Provider"], "http://example.org")
-            response
-          end
-
-          it "returns a 409 response" do
-            expect(response.status).to eq 409
-          end
-
-          it "returns a text response" do
-            expect(response.headers["Content-Type"]).to eq "text/plain"
-          end
-
-          it "returns the messages in the response body" do
-            expect(response.body).to eq "message1\nmessage2"
-          end
-        end
-      end
-
-      describe "PUT" do
-        it_behaves_like "an update endpoint", :put
-      end
-
-      describe "PATCH" do
-        it_behaves_like "an update endpoint", :patch
-      end
-
-      describe "DELETE" do
-        before do
-          allow(pact_service).to receive(:find_pact).and_return(pact)
-          allow(pact_service).to receive(:delete)
-          allow(pact_service).to receive(:find_latest_pact).and_return(latest_pact)
-          allow_any_instance_of(described_class).to receive(:latest_pact_url).and_return("http://latest-pact")
-        end
-
-        let(:pact) { double("pact") }
-        let(:pact_service) { PactBroker::Pacts::Service }
-        let(:latest_pact) { double("latest pact") }
-
-        subject { delete "/pacts/provider/Provider/consumer/Consumer/version/1.2", json, {"CONTENT_TYPE" => "application/json"} ; last_response }
-
-        context "when the pact exists" do
-          it "deletes the pact using the pact service" do
-            expect(pact_service).to receive(:delete).with(instance_of(PactBroker::Pacts::PactParams))
-            subject
-          end
-
-          it "returns a 200" do
-            expect(subject.status).to eq 200
-          end
-
-          it "returns a link to the latest pact" do
-            expect(JSON.parse(subject.body)["_links"]["pb:latest-pact-version"]["href"]).to eq "http://latest-pact"
-          end
-
-          context "with there are no more pacts" do
-            let(:latest_pact) { nil }
-
-            it "does not return a link" do
-              expect(JSON.parse(subject.body)["_links"]).to_not have_key("pb:latest-pact-version")
-            end
-          end
-        end
-
-        context "when the pact does not exist" do
-          let(:pact) { nil }
-
-          it "returns a 404" do
-            expect(subject.status).to eq 404
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,54 +0,0 @@
-require "pact_broker/api/resources/pact_triggered_webhooks"
-
-module PactBroker
-  module Api
-    module Resources
-      describe PactTriggeredWebhooks do
-        describe "GET" do
-          before do
-            allow(Decorators::TriggeredWebhooksDecorator).to receive(:new).and_return(decorator)
-            allow_any_instance_of(PactTriggeredWebhooks).to receive(:webhook_service).and_return(webhook_service)
-            allow_any_instance_of(PactTriggeredWebhooks).to receive(:pact).and_return(pact)
-            allow(webhook_service).to receive(:find_triggered_webhooks_for_pact).and_return(triggered_webhooks)
-          end
-
-          let(:decorator) { instance_double(Decorators::TriggeredWebhooksDecorator, to_json: "json") }
-          let(:webhook_service) { class_double(PactBroker::Webhooks::Service) }
-          let(:pact) { instance_double(PactBroker::Domain::Pact, name: "The pact") }
-          let(:triggered_webhooks) { double("triggered_webhooks") }
-          let(:path) { "/pacts/provider/bar/consumer/foo/version/1/triggered-webhooks" }
-
-          subject { get path; last_response }
-
-          context "when the pact exists" do
-            it { is_expected.to be_a_hal_json_success_response }
-
-            it "finds the triggered webhooks for the pact" do
-              expect(webhook_service).to receive(:find_triggered_webhooks_for_pact)
-              subject
-            end
-
-            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 the the pact")
-                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 pact does not exist" do
-            let(:pact) { nil }
-
-            it { is_expected.to be_a_404_response }
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,60 +0,0 @@
-require "spec_helper"
-require "pact_broker/api/resources/pacticipant"
-
-module PactBroker::Api
-  module Resources
-    describe Pacticipant do
-      describe "DELETE" do
-
-        let(:pacticpant) { double("pacticpant") }
-
-        before do
-          allow(PactBroker::Pacticipants::Service).to receive(:delete)
-          allow(PactBroker::Pacticipants::Service).to receive(:find_pacticipant_by_name).and_return(pacticpant)
-        end
-
-        subject { delete("/pacticipants/Some%20Service" ) }
-
-        context "when the resource exists" do
-          it "deletes the pacticpant by name" do
-            expect(PactBroker::Pacticipants::Service).to receive(:delete).with("Some Service")
-            subject
-          end
-
-          it "returns a 204 OK" do
-            subject
-            expect(last_response.status).to eq 204
-          end
-        end
-
-        context "when the resource doesn't exist" do
-
-          let(:pacticpant) { nil }
-
-          it "returns a 404 Not Found" do
-            subject
-            expect(last_response.status).to eq 404
-          end
-        end
-
-        context "when an error occurs" do
-          before do
-            allow(PactBroker::Pacticipants::Service).to receive(:delete).and_raise("An error")
-          end
-
-          let(:response_body) { JSON.parse(last_response.body, symbolize_names: true) }
-
-          it "returns a 500 Internal Server Error" do
-            subject
-            expect(last_response.status).to eq 500
-          end
-
-          it "returns an error message" do
-            subject
-            expect(response_body[:error][:message]).to eq "An error"
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,238 +0,0 @@
-require "pact_broker/api/resources/pacticipant_webhooks"
-
-module PactBroker::Api
-  module Resources
-    describe PacticipantWebhooks do
-
-      let(:webhook_service) { PactBroker::Webhooks::Service }
-      let(:uuid) { "1483234k24DKFGJ45K" }
-      let(:path) { "/webhooks/provider/Some%20Provider/consumer/Some%20Consumer" }
-      let(:headers) { {"CONTENT_TYPE" => "application/json"} }
-      let(:webhook) { double("webhook")}
-      let(:saved_webhook) { double("saved_webhook")}
-      let(:provider) { instance_double(PactBroker::Domain::Pacticipant) }
-      let(:consumer) { instance_double(PactBroker::Domain::Pacticipant) }
-      let(:webhook_decorator) { instance_double(Decorators::WebhookDecorator, from_json: webhook) }
-
-      before do
-        allow(PactBroker::Pacticipants::Service).to receive(:find_pacticipant_by_name).with("Some Provider").and_return(provider)
-        allow(PactBroker::Pacticipants::Service).to receive(:find_pacticipant_by_name).with("Some Consumer").and_return(consumer)
-        allow(Decorators::WebhookDecorator).to receive(:new).and_return(webhook_decorator)
-      end
-
-      describe "GET" do
-        let(:webhooks) { double("webhooks") }
-        let(:json) { {some: "webhooks"}.to_json }
-        let(:decorator) { instance_double(Decorators::WebhooksDecorator, to_json: json) }
-
-        before do
-          allow(webhook_service).to receive(:find_by_consumer_and_provider).and_return(webhooks)
-          allow(Decorators::WebhooksDecorator).to receive(:new).and_return(decorator)
-        end
-
-        subject { get path }
-
-        describe "for webhooks with a consumer and provider" do
-          it "returns a 200 HAL JSON response" do
-            subject
-            expect(last_response).to be_a_hal_json_success_response
-          end
-
-          it "generates a JSON body" do
-            expect(Decorators::WebhooksDecorator).to receive(:new).with(webhooks)
-            expect(decorator).to receive(:to_json).with(user_options: instance_of(Decorators::DecoratorContext))
-            subject
-          end
-
-          it "includes the generated JSON in the response body" do
-            subject
-            expect(last_response.body).to eq json
-          end
-
-          context "when the provider does not exist" do
-            context "when the provider does not exist" do
-              let(:provider) { nil }
-
-              it "returns a 404" do
-                expect(subject.status).to eq 404
-              end
-            end
-          end
-
-          context "when the consumer does not exist" do
-            let(:consumer) { nil }
-
-            it "returns a 404" do
-              expect(subject.status).to eq 404
-            end
-          end
-        end
-
-        context "for provider webhooks" do
-          let(:path) { "/webhooks/provider/Some%20Provider" }
-
-          context "when the provider does exist" do
-            it "returns a 200" do
-              expect(subject.status).to eq 200
-            end
-          end
-
-          context "when the provider does not exist" do
-            let(:provider) { nil }
-
-            it "returns a 404" do
-              expect(subject.status).to eq 404
-            end
-          end
-        end
-
-        context "for consumer webhooks" do
-          let(:path) { "/webhooks/consumer/Some%20Consumer" }
-
-          context "when the consumer does exist" do
-            it "returns a 200" do
-              expect(subject.status).to eq 200
-            end
-          end
-
-          context "when the consumer does not exist" do
-            let(:consumer) { nil }
-
-            it "returns a 404" do
-              expect(subject.status).to eq 404
-            end
-          end
-        end
-      end
-
-      describe "POST" do
-        let(:webhook_json) do
-          {
-            some: "json"
-          }.to_json
-        end
-        let(:next_uuid) { "123k2nvkkwjrwk34" }
-
-        let(:valid) { true }
-        let(:errors) { double("errors", empty?: valid, messages: ["messages"]) }
-
-        before do
-          allow(webhook_service).to receive(:create).and_return(saved_webhook)
-          allow(webhook_service).to receive(:next_uuid).and_return(next_uuid)
-          allow(webhook_service).to receive(:errors).and_return(errors)
-          allow(PactBroker::Domain::Webhook).to receive(:new).and_return(webhook)
-        end
-
-        subject { post path, webhook_json, headers }
-
-        context "with malformed JSON" do
-          let(:webhook_json) { "{" }
-
-          it "returns a 400 error" do
-            subject
-            expect(last_response.status).to eq 400
-          end
-        end
-
-        context "when the provider is not found" do
-          let(:provider) { nil }
-
-          it "returns a 404 status" do
-            subject
-            expect(last_response.status).to eq 404
-          end
-
-          it "returns a JSON content type" do
-            subject
-            expect(last_response.headers["Content-Type"]).to eq "application/hal+json;charset=utf-8"
-          end
-
-          it "returns an error message" do
-            subject
-            expect(JSON.parse(last_response.body, symbolize_names: true)).to eq error: "No provider with name 'Some Provider' found"
-          end
-        end
-
-        context "when the consumer is not found" do
-          let(:consumer) { nil }
-          it "returns a 404 status" do
-            subject
-            expect(last_response.status).to eq 404
-          end
-
-          it "returns a JSON content type" do
-            subject
-            expect(last_response.headers["Content-Type"]).to eq "application/hal+json;charset=utf-8"
-          end
-
-          it "returns an error message" do
-            subject
-            expect(JSON.parse(last_response.body, symbolize_names: true)).to eq error: "No consumer with name 'Some Consumer' found"
-          end
-        end
-
-        context "with invalid attributes" do
-
-          let(:valid) { false }
-
-          it "returns a 400" do
-            subject
-            expect(last_response.status).to be 400
-          end
-
-          it "returns a JSON content type" do
-            subject
-            expect(last_response.headers["Content-Type"]).to eq "application/hal+json;charset=utf-8"
-          end
-
-          it "returns the validation errors" do
-            subject
-            expect(JSON.parse(last_response.body, symbolize_names: true)).to eq errors: ["messages"]
-          end
-
-        end
-
-        context "with valid attributes" do
-
-          let(:webhook_response_json) { {some: "webhook"}.to_json }
-
-          before do
-            allow_any_instance_of(Decorators::WebhookDecorator).to receive(:to_json).and_return(webhook_response_json)
-            allow(webhook_decorator).to receive(:to_json).and_return(webhook_response_json)
-          end
-
-          it "saves the webhook" do
-            expect(webhook_service).to receive(:create).with(next_uuid, webhook, consumer, provider)
-            subject
-          end
-
-          it "returns a 201 response" do
-            subject
-            expect(last_response.status).to be 201
-          end
-
-          it "returns the Location header" do
-            subject
-            expect(last_response.headers["Location"]).to include(next_uuid)
-          end
-
-          it "returns a JSON content type" do
-            subject
-            expect(last_response.headers["Content-Type"]).to eq "application/hal+json;charset=utf-8"
-          end
-
-          it "generates the JSON response body" do
-            expect(Decorators::WebhookDecorator).to receive(:new).with(saved_webhook).and_return(webhook_decorator)
-            expect(webhook_decorator).to receive(:to_json).with(user_options: hash_including(base_url: "http://example.org"))
-            subject
-          end
-
-          it "returns the JSON representation of the webhook" do
-            subject
-            expect(last_response.body).to eq webhook_response_json
-          end
-        end
-      end
-    end
-  end
-end