pact_broker 2.22.0 → 2.23.0

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

@@ -0,0 +1,54 @@
+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

@@ -55,12 +55,7 @@ module PactBroker::Api
 
           it "returns an error message" do
             subject
-            expect(response_body[:message]).to eq "An error"
-          end
-
-          it "returns the backtrace" do
-            subject
-            expect(response_body[:backtrace]).to be_instance_of(Array)
+            expect(response_body[:error][:message]).to eq "An error"
           end
         end
       end

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

@@ -63,12 +63,7 @@ module PactBroker
 
             it "returns an error message" do
               subject
-              expect(response_body[:message]).to eq "An error"
-            end
-
-            it "returns the backtrace" do
-              subject
-              expect(response_body[:backtrace]).to be_instance_of(Array)
+              expect(response_body[:error][:message]).to eq "An error"
             end
           end
         end

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

@@ -0,0 +1,68 @@
+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/webhook_execution_spec.rb

@@ -35,18 +35,12 @@ module PactBroker
             let(:provider_name) { "bar" }
 
             before do
-              allow(PactBroker::Webhooks::Service).to receive(:execute_webhook_now).and_return(execution_result)
+              allow(PactBroker::Webhooks::Service).to receive(:test_execution).and_return(execution_result)
               allow(PactBroker::Api::Decorators::WebhookExecutionResultDecorator).to receive(:new).and_return(decorator)
-              allow(PactBroker::Pacts::Service).to receive(:find_latest_pact).and_return(pact)
-            end
-
-            it "finds the latest pact for the webhook" do
-              expect(PactBroker::Pacts::Service).to receive(:find_latest_pact).with(consumer_name: consumer_name, provider_name: provider_name)
-              subject
             end
 
             it "executes the webhook" do
-              expect(PactBroker::Webhooks::Service).to receive(:execute_webhook_now).with(webhook, pact)
+              expect(PactBroker::Webhooks::Service).to receive(:test_execution).with(webhook)
               subject
             end
 

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

@@ -1,44 +1,239 @@
-require 'spec_helper'
 require 'pact_broker/api/resources/webhooks'
 
 module PactBroker::Api
-
   module Resources
-
     describe Webhooks do
 
-      describe "GET" 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) }
 
-        subject { get "/webhooks" }
+      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
 
-        let(:webhooks) { [double('webhook')]}
-        let(:decorator) { double(Decorators::WebhooksDecorator, to_json: json)}
-        let(:json) { {some: 'json'}.to_json }
+      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)
-          allow(PactBroker::Webhooks::Service).to receive(:find_all).and_return(webhooks)
         end
 
-        it "returns a 200 HAL JSON response" do
-          subject
-          expect(last_response).to be_a_hal_json_success_response
-        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 "generates a JSON representation of the webhook" do
-          expect(Decorators::WebhooksDecorator).to receive(:new).with(webhooks)
-          expect(decorator).to receive(:to_json).with(user_options: instance_of(Decorators::DecoratorContext))
-          subject
+          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
 
-        it "includes the JSON representation in the response body" do
-          subject
-          expect(last_response.body).to eq json
+        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: { 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

data/spec/lib/pact_broker/configuration_spec.rb

@@ -6,6 +6,36 @@ require 'pact_broker/config/setting'
 module PactBroker
   describe Configuration do
 
+    describe "show_backtrace_in_error_response?" do
+      before do
+        allow(ENV).to receive(:[]).and_call_original
+      end
+
+      context "when RACK_ENV is not set" do
+        before do
+          allow(ENV).to receive(:[]).with("RACK_ENV").and_return(nil)
+        end
+
+        its(:show_backtrace_in_error_response?) { is_expected.to be false }
+      end
+
+      context "when RACK_ENV is not production" do
+        before do
+          allow(ENV).to receive(:[]).with("RACK_ENV").and_return('development')
+        end
+
+        its(:show_backtrace_in_error_response?) { is_expected.to be true }
+      end
+
+      context "when RACK_ENV is production" do
+        before do
+          allow(ENV).to receive(:[]).with("RACK_ENV").and_return('production')
+        end
+
+        its(:show_backtrace_in_error_response?) { is_expected.to be false }
+      end
+    end
+
     context "default configuration" do
       describe ".html_pact_renderer" do