pact_broker 2.22.0 → 2.23.0

data/spec/lib/pact_broker/api/decorators/triggered_webhooks_decorator_spec.rb

@@ -0,0 +1,28 @@
+require 'pact_broker/api/decorators/triggered_webhooks_decorator'
+require 'pact_broker/webhooks/triggered_webhook'
+
+module PactBroker
+  module Api
+    module Decorators
+      describe TriggeredWebhooksDecorator do
+        let(:triggered_webhook) do
+          instance_double(PactBroker::Webhooks::TriggeredWebhook).as_null_object
+        end
+        let(:decorator) { TriggeredWebhooksDecorator.new([triggered_webhook]) }
+        let(:user_options) { { resource_title: "Title", resource_url: "http://url" } }
+        let(:json) { decorator.to_json(user_options: user_options) }
+
+        subject { JSON.parse(json) }
+
+        it "includes a self relation" do
+          expect(subject['_links']['self']['title']).to eq "Title"
+          expect(subject['_links']['self']['href']).to eq "http://url"
+        end
+
+        it "includes an embedded list of triggered webhooks" do
+          expect(subject['_embedded']['triggeredWebhooks']).to be_instance_of(Array)
+        end
+      end
+    end
+  end
+end

data/spec/lib/pact_broker/api/decorators/verification_decorator_spec.rb

@@ -4,6 +4,9 @@ module PactBroker
   module Api
     module Decorators
       describe VerificationDecorator do
+        before do
+          allow_any_instance_of(VerificationDecorator).to receive(:verification_triggered_webhooks_url).and_return("http://triggered-webhooks")
+        end
 
         let(:verification) do
           instance_double('PactBroker::Domain::Verification',
@@ -30,6 +33,7 @@ module PactBroker
 
         let(:options) { { user_options: { base_url: 'http://example.org' } } }
 
+
         subject { JSON.parse VerificationDecorator.new(verification).to_json(options), symbolize_names: true }
 
         it "includes the success status" do
@@ -55,6 +59,10 @@ module PactBroker
         it "includes a link to its pact" do
           expect(subject[:_links][:'pb:pact-version'][:href]).to match %r{http://example.org/pacts/}
         end
+
+        it "includes a link to the triggered webhooks" do
+          expect(subject[:_links][:'pb:triggered-webhooks'][:href]).to eq "http://triggered-webhooks"
+        end
       end
     end
   end

data/spec/lib/pact_broker/api/decorators/webhook_decorator_spec.rb

@@ -16,7 +16,7 @@ module PactBroker
         end
 
         let(:webhook_request) do
-          Domain::WebhookRequest.new(request)
+          Webhooks::WebhookRequestTemplate.new(request)
         end
 
         let(:consumer) { Domain::Pacticipant.new(name: 'Consumer') }
@@ -46,6 +46,14 @@ module PactBroker
             expect(parsed_json[:request]).to eq request
           end
 
+          it 'includes the consumer' do
+            expect(parsed_json[:consumer]).to eq name: "Consumer"
+          end
+
+          it 'includes the provider' do
+            expect(parsed_json[:provider]).to eq name: "Provider"
+          end
+
           it 'includes a link to the consumer' do
             expect(parsed_json[:_links][:'pb:consumer'][:name]).to eq 'Consumer'
             expect(parsed_json[:_links][:'pb:consumer'][:href]).to eq 'http://example.org/pacticipants/Consumer'
@@ -89,6 +97,34 @@ module PactBroker
             end
           end
 
+          context 'when there is no consumer' do
+            before do
+              webhook.consumer = nil
+            end
+
+            it 'does not include the consumer relation' do
+              expect(parsed_json[:_links][:'pb:consumer']).to be nil
+            end
+
+            it 'does not include the pact webhooks relation' do
+              expect(parsed_json[:_links][:'pb:pact-webhooks']).to be nil
+            end
+          end
+
+          context 'when there is no provider' do
+            before do
+              webhook.provider = nil
+            end
+
+            it 'does not include the provider relation' do
+              expect(parsed_json[:_links][:'pb:provider']).to be nil
+            end
+
+            it 'does not include the pact webhooks relation' do
+              expect(parsed_json[:_links][:'pb:pact-webhooks']).to be nil
+            end
+          end
+
           context 'when the headers contain sensitve information' do
             let(:headers) { { 'Authorization' => 'foo' } }
             it 'redacts them' do

data/spec/lib/pact_broker/api/decorators/webhook_execution_result_decorator_spec.rb

@@ -8,9 +8,15 @@ module PactBroker
 
         describe "to_json" do
 
-          let(:webhook_execution_result) { PactBroker::Domain::WebhookExecutionResult.new(response, logs, error)}
+          let(:webhook_execution_result) { PactBroker::Domain::WebhookExecutionResult.new(request, response, logs, error)}
           let(:logs) { "logs" }
           let(:headers) { { "Something" => ["blah", "thing"]} }
+          let(:request) do
+            req = Net::HTTP::Get.new("http://example.org?foo=bar")
+            req['Foo'] = ['bar', 'wiffle']
+            req.body = { foo: 'bar' }.to_json
+            req
+          end
           let(:response) { double('http_response', code: '200', body: response_body, to_hash: headers) }
           let(:response_body) { 'body' }
           let(:error) { nil }
@@ -43,6 +49,32 @@ module PactBroker
             end
           end
 
+          context "when there is a request" do
+            it "includes the request URL" do
+              expect(subject[:request][:url]).to eq "http://example.org?foo=bar"
+            end
+
+            it "includes the request headers" do
+              expect(subject[:request][:headers][:'foo']).to eq "bar, wiffle"
+            end
+
+            context "when the request body is JSON" do
+              it "includes the request body as JSON" do
+                expect(subject[:request][:body]).to include( foo: 'bar' )
+              end
+            end
+
+            context "when the request body is not json" do
+              before do
+                request.body = "<xml></xml>"
+              end
+
+              it "includes the request body as a String" do
+                expect(subject[:request][:body]).to eq "<xml></xml>"
+              end
+            end
+          end
+
           context "when there is a response" do
             it "includes the response code" do
               expect(subject[:response][:status]).to eq 200
@@ -51,6 +83,7 @@ module PactBroker
             it "includes the response headers" do
               expect(subject[:response][:headers]).to eq :'Something' => "blah, thing"
             end
+
             it "includes the response body" do
               expect(subject[:response][:body]).to eq response_body
             end

data/spec/lib/pact_broker/api/decorators/{webhook_request_decorator_spec.rb → webhook_request_template_decorator_spec.rb}

@@ -1,17 +1,17 @@
 require 'spec_helper'
-require 'pact_broker/api/decorators/webhook_request_decorator'
+require 'pact_broker/api/decorators/webhook_request_template_decorator'
 require 'json'
 
 module PactBroker
   module Api
     module Decorators
-      describe WebhookRequestDecorator do
+      describe WebhookRequestTemplateDecorator do
 
         let(:username) { 'username' }
         let(:display_password) { '*****' }
         let(:webhook_request) do
           instance_double(
-            PactBroker::Domain::WebhookRequest,
+            PactBroker::Webhooks::WebhookRequestTemplate,
             username: username,
             display_password: display_password,
             method: 'POST',
@@ -20,7 +20,7 @@ module PactBroker
             headers: {})
         end
 
-        let(:json) { WebhookRequestDecorator.new(webhook_request).to_json }
+        let(:json) { WebhookRequestTemplateDecorator.new(webhook_request).to_json }
 
         subject { JSON.parse(json, symbolize_names: true)}
 
@@ -58,9 +58,9 @@ module PactBroker
           end
 
           let(:json) { hash.to_json }
-          let(:webhook_request) { PactBroker::Domain::WebhookRequest.new }
+          let(:webhook_request) { PactBroker::Webhooks::WebhookRequestTemplate.new }
 
-          subject { WebhookRequestDecorator.new(webhook_request).from_json(json) }
+          subject { WebhookRequestTemplateDecorator.new(webhook_request).from_json(json) }
 
           it "reads the username" do
             expect(subject.username).to eq username
@@ -69,10 +69,8 @@ module PactBroker
           it "reads the password" do
             expect(subject.password).to eq password
           end
-
         end
-
       end
     end
   end
-end
+end

data/spec/lib/pact_broker/api/pact_broker_urls_spec.rb

@@ -5,12 +5,34 @@ module PactBroker
     describe PactBrokerUrls do
 
       let(:base_url) { "http://example.org" }
+      let(:pact) { double('pact', consumer: consumer, provider: provider, consumer_version_number: "123") }
+      let(:consumer) { double('pacticipant', name: "Foo") }
+      let(:provider) { double('pacticipant', name: "Bar") }
+      let(:verification) do
+        instance_double(PactBroker::Domain::Verification,
+          consumer_name: "Foo",
+          provider_name: "Bar",
+          pact_version_sha: "1234",
+          number: "1")
+      end
 
       describe "templated_tag_url_for_pacticipant" do
         subject { PactBrokerUrls.templated_tag_url_for_pacticipant("Bar", base_url) }
 
         it { is_expected.to eq "http://example.org/pacticipants/Bar/versions/{version}/tags/{tag}" }
       end
+
+      describe "pact_triggered_webhooks_url" do
+        subject { PactBrokerUrls.pact_triggered_webhooks_url(pact, base_url) }
+
+        it { is_expected.to eq "http://example.org/pacts/provider/Bar/consumer/Foo/version/123/triggered-webhooks" }
+      end
+
+      describe "verification_triggered_webhooks_url" do
+        subject { PactBrokerUrls.verification_triggered_webhooks_url(verification, base_url) }
+
+        it { is_expected.to eq "http://example.org/pacts/provider/Bar/consumer/Foo/pact-version/1234/verification-results/1/triggered-webhooks" }
+      end
     end
   end
 end

data/spec/lib/pact_broker/api/resources/{pact_webhooks_spec.rb → all_webhooks_spec.rb}

@@ -1,20 +1,22 @@
-require 'pact_broker/api/resources/pact_webhooks'
+require 'spec_helper'
+require 'pact_broker/api/resources/all_webhooks'
 
 module PactBroker::Api
 
   module Resources
 
-    describe PactWebhooks do
-
+    describe AllWebhooks do
 
       let(:webhook_service) { PactBroker::Webhooks::Service }
       let(:uuid) { '1483234k24DKFGJ45K' }
-      let(:path) { "/webhooks/provider/Some%20Provider/consumer/Some%20Consumer" }
+      let(:path) { "/webhooks" }
       let(:headers) { {'CONTENT_TYPE' => 'application/json'} }
-      let(:webhook) { double('webhook')}
+      let(:webhook) { double('webhook', consumer: parsed_consumer, provider: parsed_provider) }
+      let(:parsed_provider) { instance_double(PactBroker::Domain::Pacticipant, name: "Some Provider") }
+      let(:parsed_consumer) { instance_double(PactBroker::Domain::Pacticipant, name: "Some Consumer") }
+      let(:consumer) { double('consumer', name: "Some Consumer") }
+      let(:provider) { double('provider', name: "Some Provider") }
       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
@@ -23,45 +25,14 @@ module PactBroker::Api
         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 }
-
-        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
-
-
-      end
-
       describe "POST" do
         let(:webhook_json) do
           {
             some: 'json'
           }.to_json
         end
-        let(:next_uuid) { '123k2nvkkwjrwk34' }
 
+        let(:next_uuid) { '123k2nvkkwjrwk34' }
         let(:valid) { true }
         let(:errors) { double("errors", empty?: valid, messages: ['messages']) }
 
@@ -83,44 +54,6 @@ module PactBroker::Api
           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 }
@@ -130,7 +63,7 @@ module PactBroker::Api
             expect(last_response.status).to be 400
           end
 
-          it "returns a JSON content type" do
+          it "returns a HAL JSON content type" do
             subject
             expect(last_response.headers['Content-Type']).to eq 'application/hal+json;charset=utf-8'
           end
@@ -144,7 +77,7 @@ module PactBroker::Api
 
         context "with valid attributes" do
 
-          let(:webhook_response_json) { {some: 'webhook'}.to_json }
+          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)
@@ -166,7 +99,7 @@ module PactBroker::Api
             expect(last_response.headers['Location']).to include(next_uuid)
           end
 
-          it "returns a JSON content type" do
+          it "returns a HAL JSON content type" do
             subject
             expect(last_response.headers['Content-Type']).to eq 'application/hal+json;charset=utf-8'
           end
@@ -183,6 +116,39 @@ module PactBroker::Api
           end
         end
       end
+
+      describe "GET" do
+
+        subject { get "/webhooks" }
+
+        let(:webhooks) { [double('webhook')]}
+        let(:decorator) { double(Decorators::WebhooksDecorator, to_json: json)}
+        let(:json) { {some: 'json'}.to_json }
+
+        before do
+          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
+
+        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
+        end
+
+        it "includes the JSON representation in the response body" do
+          subject
+          expect(last_response.body).to eq json
+        end
+
+      end
+
     end
   end
+
 end

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

@@ -40,6 +40,40 @@ module PactBroker
             end
           end
 
+          it "creates a json error response body" do
+            expect(response).to receive(:body=) do | body |
+              expect(JSON.parse(body)['error']).to include 'message' => 'test error'
+            end
+            subject
+          end
+
+
+          context "when show_backtrace_in_error_response? is true" do
+            before do
+              allow(PactBroker.configuration).to receive(:show_backtrace_in_error_response?).and_return(true)
+            end
+
+            it "includes the backtrace in the error response" do
+              expect(response).to receive(:body=) do | body |
+                expect(body).to include("backtrace")
+              end
+              subject
+            end
+          end
+
+          context "when show_backtrace_in_error_response? is false" do
+            before do
+              allow(PactBroker.configuration).to receive(:show_backtrace_in_error_response?).and_return(false)
+            end
+
+            it "does not include the backtrace in the error response" do
+              expect(response).to receive(:body=) do | body |
+                expect(body).to_not include("backtrace")
+              end
+              subject
+            end
+          end
+
           context "when the error is a PactBroker::TestError" do
             let(:error) { PactBroker::TestError.new('test error') }