pact_broker 2.22.0 → 2.23.0

data/spec/features/create_webhook_spec.rb

@@ -6,74 +6,123 @@ describe "Creating a webhook" do
     TestDataBuilder.new.create_pact_with_hierarchy("Some Consumer", "1", "Some Provider")
   end
 
-  let(:path) { "/webhooks/provider/Some%20Provider/consumer/Some%20Consumer" }
   let(:headers) { {'CONTENT_TYPE' => 'application/json'} }
   let(:response_body) { JSON.parse(last_response.body, symbolize_names: true)}
   let(:webhook_json) { webhook_hash.to_json }
+  let(:webhook_hash) do
+    {
+      events: [{
+        name: 'something_happened'
+      }],
+      request: {
+        method: 'POST',
+        url: 'https://example.org',
+        headers: {
+          :"Content-Type" => "application/json"
+        },
+        body: {
+          a: 'body'
+        }
+      }
+    }
+  end
 
-  subject { post path, webhook_json, headers }
+  subject { post(path, webhook_json, headers) }
 
-  context "with invalid attributes" do
+  context "for a consumer and provider" do
+    let(:path) { "/webhooks/provider/Some%20Provider/consumer/Some%20Consumer" }
 
-    let(:webhook_hash) { {} }
+    context "with invalid attributes" do
+      let(:webhook_hash) { {} }
 
-    it "returns a 400" do
-      subject
-      expect(last_response.status).to be 400
-    end
+      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(response_body[:errors]).to_not be_empty
+      it "returns the validation errors" do
+        subject
+        expect(response_body[:errors]).to_not be_empty
+      end
     end
 
+    context "with valid attributes" do
+      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 match(%r{http://example.org/webhooks/.+})
+      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 newly created webhook" do
+        subject
+        expect(response_body).to include webhook_hash
+      end
+    end
   end
 
-  context "with valid attributes" do
-
-    let(:webhook_hash) do
-      {
-        events: [{
-          name: 'something_happened'
-        }],
-        request: {
-          method: 'POST',
-          url: 'https://example.org',
-          headers: {
-            :"Content-Type" => "application/json"
-          },
-          body: {
-            a: 'body'
-          }
-        }
-      }
+  context "for a provider" do
+    let(:path) { "/webhooks" }
+
+    before do
+      webhook_hash[:provider] = { name: "Some Provider" }
     end
 
-    let(:webhook_json) { webhook_hash.to_json }
+    it "returns a 201 response" do
+      subject
+      expect(last_response.status).to be 201
+    end
+
+    it "creates a webhook without a consumer" do
+      subject
+      expect(PactBroker::Webhooks::Webhook.first.provider).to_not be nil
+      expect(PactBroker::Webhooks::Webhook.first.consumer).to be nil
+    end
+  end
+
+  context "for a consumer" do
+    let(:path) { "/webhooks" }
+    before do
+      webhook_hash[:consumer] = { name: "Some Consumer" }
+    end
 
     it "returns a 201 response" do
       subject
       expect(last_response.status).to be 201
     end
 
-    it "returns the Location header" do
+    it "creates a webhook without a provider" do
       subject
-      expect(last_response.headers['Location']).to match(%r{http://example.org/webhooks/.+})
+      expect(PactBroker::Webhooks::Webhook.first.consumer).to_not be nil
+      expect(PactBroker::Webhooks::Webhook.first.provider).to be nil
     end
+  end
+
+  context "with no consumer or provider" do
+    let(:path) { "/webhooks" }
 
-    it "returns a JSON Content Type" do
+    it "returns a 201 response" do
       subject
-      expect(last_response.headers['Content-Type']).to eq 'application/hal+json;charset=utf-8'
+      expect(last_response.status).to be 201
     end
 
-    it "returns the newly created webhook" do
+    it "creates a webhook without a provider" do
       subject
-      expect(response_body).to include webhook_hash
+      expect(PactBroker::Webhooks::Webhook.first.consumer).to be nil
+      expect(PactBroker::Webhooks::Webhook.first.provider).to be nil
     end
   end
 end

data/spec/features/execute_webhook_spec.rb

@@ -25,6 +25,7 @@ describe "Execute a webhook" do
     let!(:request) do
       stub_request(:post, /http/).with(body: 'http://example.org/pacts/provider/Bar/consumer/Foo/version/1').to_return(:status => 200, body: response_body)
     end
+
     let(:response_body) { "webhook-response-body" }
 
     it "performs the HTTP request" do
@@ -36,12 +37,12 @@ describe "Execute a webhook" do
       expect(subject.status).to be 200
     end
 
-    it "saves a TriggeredWebhook" do
-      expect { subject }.to change { PactBroker::Webhooks::TriggeredWebhook.count }.by(1)
+    it "does not save a TriggeredWebhook" do
+      expect { subject }.to_not change { PactBroker::Webhooks::TriggeredWebhook.count }
     end
 
-    it "saves a WebhookExecution" do
-      expect { subject }.to change { PactBroker::Webhooks::Execution.count }.by(1)
+    it "does not save a WebhookExecution" do
+      expect { subject }.to_not change { PactBroker::Webhooks::Execution.count }
     end
 
     context "when a webhook host whitelist is not configured" do
@@ -52,11 +53,6 @@ describe "Execute a webhook" do
       it "does not show any response details" do
         expect(subject.body).to_not include response_body
       end
-
-      it "does not log any response details" do
-        subject
-        expect(PactBroker::Webhooks::Execution.order(:id).last.logs).to_not include response_body
-      end
     end
 
     context "when a webhook host whitelist is configured" do
@@ -67,11 +63,6 @@ describe "Execute a webhook" do
       it "includes response details" do
         expect(subject.body).to include response_body
       end
-
-      it "logs the response details" do
-        subject
-        expect(PactBroker::Webhooks::Execution.order(:id).last.logs).to include response_body
-      end
     end
   end
 
@@ -98,12 +89,12 @@ describe "Execute a webhook" do
       expect(subject.status).to be 500
     end
 
-    it "saves a TriggeredWebhook" do
-      expect { subject }.to change { PactBroker::Webhooks::TriggeredWebhook.count }.by(1)
+    it "does not save a TriggeredWebhook" do
+      expect { subject }.to_not change { PactBroker::Webhooks::TriggeredWebhook.count }
     end
 
-    it "saves a WebhookExecution" do
-      expect { subject }.to change { PactBroker::Webhooks::Execution.count }.by(1)
+    it "does not save a WebhookExecution" do
+      expect { subject }.to_not change { PactBroker::Webhooks::Execution.count }
     end
   end
 end

data/spec/features/get_triggered_webhooks_for_pact_spec.rb

@@ -0,0 +1,20 @@
+RSpec.describe "Get triggered webhooks for pact" do
+  before do
+    td.create_pact_with_hierarchy
+      .create_webhook
+      .create_triggered_webhook
+      .create_webhook_execution
+  end
+
+  let(:td) { TestDataBuilder.new }
+  let(:path) { PactBroker::Api::PactBrokerUrls.pact_triggered_webhooks_url(td.pact) }
+  let(:json_response_body) { JSON.parse(subject.body) }
+
+  subject { get(path); last_response }
+
+  it { is_expected.to be_a_hal_json_success_response }
+
+  it "contains a list of triggered webhooks" do
+    expect(json_response_body['_embedded']['triggeredWebhooks'].size).to be 1
+  end
+end

data/spec/features/get_triggered_webhooks_for_verification_spec.rb

@@ -0,0 +1,21 @@
+RSpec.describe "Get triggered webhooks for verification" do
+  before do
+    td.create_pact_with_hierarchy
+      .create_verification_webhook
+      .create_verification
+      .create_triggered_webhook
+      .create_webhook_execution
+  end
+
+  let(:td) { TestDataBuilder.new }
+  let(:path) { PactBroker::Api::PactBrokerUrls.verification_triggered_webhooks_url(td.verification) }
+  let(:json_response_body) { JSON.parse(subject.body) }
+
+  subject { get(path); last_response }
+
+  it { is_expected.to be_a_hal_json_success_response }
+
+  it "contains a list of triggered webhooks" do
+    expect(json_response_body['_embedded']['triggeredWebhooks'].size).to be 1
+  end
+end

data/spec/fixtures/webhook_valid_with_pacticipants.json

@@ -0,0 +1,23 @@
+{
+  "events": [{
+    "name": "something_happened"
+  }],
+  "consumer": {
+    "name": "Foo"
+  },
+  "provider": {
+    "name": "Bar"
+  },
+  "request": {
+    "method": "POST",
+    "url": "HTTPS://some.url",
+    "username": "username",
+    "password": "password",
+    "headers": {
+      "Accept": "application/json"
+    },
+    "body": {
+      "a" : "body"
+    }
+  }
+}

data/spec/integration/webhooks/certificate_spec.rb

@@ -11,12 +11,12 @@ describe "executing a webhook to a server with a self signed certificate" do
   let(:webhook_request) do
     PactBroker::Domain::WebhookRequest.new(
       method: 'get',
-      url: 'https://localhost:4444')
+      url: 'https://localhost:4444/')
   end
 
   let(:pact) { td.create_pact_with_hierarchy.and_return(:pact) }
 
-  subject { webhook_request.execute(pact, nil) }
+  subject { webhook_request.execute({}) }
 
   context "without the correct cacert" do
     it "fails" do

data/spec/lib/pact_broker/api/contracts/webhook_contract_spec.rb

@@ -6,14 +6,16 @@ module PactBroker
   module Api
     module Contracts
       describe WebhookContract do
-        let(:json) { load_fixture 'webhook_valid.json' }
+        let(:json) { load_fixture 'webhook_valid_with_pacticipants.json' }
         let(:hash) { JSON.parse(json) }
         let(:webhook) { PactBroker::Api::Decorators::WebhookDecorator.new(Domain::Webhook.new).from_json(json) }
         let(:subject) { WebhookContract.new(webhook) }
         let(:matching_hosts) { ['foo'] }
+        let(:consumer) { double("consumer") }
+        let(:provider) { double("provider") }
 
         def valid_webhook_with
-          hash = load_json_fixture 'webhook_valid.json'
+          hash = load_json_fixture 'webhook_valid_with_pacticipants.json'
           yield hash
           hash.to_json
         end
@@ -23,6 +25,8 @@ module PactBroker
             PactBroker.configuration.webhook_http_method_whitelist = webhook_http_method_whitelist
             PactBroker.configuration.webhook_host_whitelist = webhook_host_whitelist
             allow(PactBroker::Webhooks::CheckHostWhitelist).to receive(:call).and_return(whitelist_matches)
+            allow(PactBroker::Pacticipants::Service).to receive(:find_pacticipant_by_name).with("Foo").and_return(consumer)
+            allow(PactBroker::Pacticipants::Service).to receive(:find_pacticipant_by_name).with("Bar").and_return(provider)
             subject.validate(hash)
           end
 
@@ -36,6 +40,98 @@ module PactBroker
             end
           end
 
+          context "with a nil consumer name" do
+            let(:json) do
+              valid_webhook_with do |hash|
+                hash['consumer']['name'] = nil
+              end
+            end
+
+            it "contains an error" do
+              expect(subject.errors[:'consumer.name']).to eq ["can't be blank"]
+            end
+          end
+
+          context "with no consumer name key" do
+            let(:json) do
+              valid_webhook_with do |hash|
+                hash['consumer'].delete('name')
+              end
+            end
+
+            # I'd prefer this to be "is missing". Isn't the whole point of dry validation
+            # that you can distingush between keys being missing and values being missing? FFS.
+            it "contains an error" do
+              expect(subject.errors[:'consumer.name']).to eq ["can't be blank"]
+            end
+          end
+
+          context "with no consumer" do
+            let(:json) do
+              valid_webhook_with do |hash|
+                hash.delete('consumer')
+              end
+            end
+
+            it "contains no errors" do
+              expect(subject.errors).to be_empty
+            end
+          end
+
+          context "with a consumer name that doesn't match any existing consumer" do
+            let(:consumer) { nil }
+
+            it "contains no errors" do
+              expect(subject.errors[:'consumer.name']).to eq ["does not match an existing pacticipant"]
+            end
+          end
+
+          context "with a nil provider name" do
+            let(:json) do
+              valid_webhook_with do |hash|
+                hash['provider']['name'] = nil
+              end
+            end
+
+            it "contains an error" do
+              expect(subject.errors[:'provider.name']).to eq ["can't be blank"]
+            end
+          end
+
+          context "with no provider name key" do
+            let(:json) do
+              valid_webhook_with do |hash|
+                hash['provider'].delete('name')
+              end
+            end
+
+            # I'd prefer this to be "is missing". Isn't the whole point of dry validation
+            # that you can distingush between keys being missing and values being missing? FFS.
+            it "contains an error" do
+              expect(subject.errors[:'provider.name']).to eq ["can't be blank"]
+            end
+          end
+
+          context "with no provider" do
+            let(:json) do
+              valid_webhook_with do |hash|
+                hash.delete('provider')
+              end
+            end
+
+            it "contains no errors" do
+              expect(subject.errors).to be_empty
+            end
+          end
+
+          context "with a provider name that doesn't match any existing provider" do
+            let(:provider) { nil }
+
+            it "contains no errors" do
+              expect(subject.errors[:'provider.name']).to eq ["does not match an existing pacticipant"]
+            end
+          end
+
           context "with no request defined" do
             let(:json) { {}.to_json }
 

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

@@ -0,0 +1,64 @@
+require 'pact_broker/api/decorators/triggered_webhook_decorator'
+
+module PactBroker
+  module Api
+    module Decorators
+      describe TriggeredWebhookDecorator do
+        let(:triggered_webhook) do
+          double('PactBroker::Webhooks::TriggeredWebhook',
+            trigger_type: PactBroker::Webhooks::TriggeredWebhook::TRIGGER_TYPE_RESOURCE_CREATION,
+            status: status,
+            failure?: failure,
+            retrying?: retrying,
+            trigger_uuid: '1234',
+            webhook_uuid: '4321',
+            request_description: "GET http://foo",
+            pact_publication: pact,
+            number_of_attempts_made: 1,
+            number_of_attempts_remaining: 2,
+            created_at: DateTime.new(2017),
+            updated_at: DateTime.new(2017)
+          )
+        end
+
+        let(:pact) do
+          double('pact',
+            provider: double(name: 'provider'),
+            consumer: double(name: 'consumer'),
+            consumer_version_number: '1',
+            name: 'foo '
+          )
+        end
+
+        let(:failure) { false }
+        let(:retrying) { false }
+        let(:status) { PactBroker::Webhooks::TriggeredWebhook::STATUS_SUCCESS }
+        let(:logs_url) { "http://example.org/webhooks/4321/trigger/1234/logs" }
+        let(:user_options) { { base_url: "http://example.org" } }
+
+        let(:json) do
+          TriggeredWebhookDecorator.new(triggered_webhook).to_json(user_options: user_options)
+        end
+
+        subject { JSON.parse(json, symbolize_names: true) }
+
+        it "includes a link to the logs" do
+          expect(subject[:_links][:logs][:href]).to eq logs_url
+        end
+
+        it "includes a link to the webhook" do
+          expect(subject[:_links][:'pb:webhook'][:href]).to eq "http://example.org/webhooks/4321"
+        end
+
+        it "includes the triggered webhooks properties" do
+          expect(subject).to include(
+            status: 'success',
+            triggerType: 'resource_creation',
+            attemptsMade: 1,
+            attemptsRemaining: 2
+          )
+        end
+      end
+    end
+  end
+end