pact_broker 2.4.2 → 2.5.0

data/spec/integration/app_spec.rb

@@ -7,7 +7,7 @@ module PactBroker
   describe App do
 
     before do
-      TestDataBuilder.new.create_pact_with_hierarchy 'Some Consumer', '1.0', 'Some Provider'
+      TestDataBuilder.new.create_pact_with_hierarchy('Some Consumer', '1.0', 'Some Provider').and_return(:pact)
     end
 
     let(:hal_browser_enabled) { true }

data/spec/integration/endpoints/group.rb

@@ -6,7 +6,7 @@ describe "/groups/{pacticipant-name}" do
 
   describe "GET" do
     before do
-      TestDataBuilder.new.create_pact_with_hierarchy "Consumer", "1.2.3", "Provider"
+      TestDataBuilder.new.create_pact_with_hierarchy("Consumer", "1.2.3", "Provider").and_return(:pact)
       get "/groups/Consumer"
     end
 

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

@@ -9,7 +9,8 @@ module PactBroker
 
       describe LatestPactDecorator do
 
-        let(:pact) { RepresentablePact.new(TestDataBuilder.new.create_pact_with_hierarchy 'Consumer', '1.2.3', 'Provider') }
+        let(:pact_domain) { TestDataBuilder.new.create_pact_with_hierarchy('Consumer', '1.2.3', 'Provider').and_return(:pact) }
+        let(:pact) { RepresentablePact.new(pact_domain) }
         let(:base_url) { 'http://example.org' }
 
         subject { JSON.parse LatestPactDecorator.new(pact).to_json(user_options: { base_url: base_url }), symbolize_names: true}

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

@@ -53,14 +53,12 @@ module PactBroker
 
           it "includes a link to the diff with the previous distinct version" do
             expect(subject[:_links][:'pb:diff-previous-distinct']).to eq({href: 'http://example.org/pacts/provider/A%20Provider/consumer/A%20Consumer/version/1234/diff/previous-distinct',
-              title: 'Diff',
-              name: 'Diff with previous distinct version of this pact'})
+              title: 'Diff with previous distinct version of this pact'})
           end
 
           it "includes a link to the previous distinct pact version" do
             expect(subject[:_links][:'pb:previous-distinct']).to eq({href: 'http://example.org/pacts/provider/A%20Provider/consumer/A%20Consumer/version/1234/previous-distinct',
-              title: 'Pact',
-              name: 'Previous distinct version of this pact'})
+              title: 'Previous distinct version of this pact'})
           end
 
           it "includes a link to tag this version" do
@@ -80,11 +78,15 @@ module PactBroker
           end
 
           it "includes a link to the latest pact" do
-            expect(subject[:_links][:'pb:latest-pact-version'][:title]).to eq "Pact"
-            expect(subject[:_links][:'pb:latest-pact-version'][:name]).to eq "Latest version of this pact"
+            expect(subject[:_links][:'pb:latest-pact-version'][:title]).to eq "Latest version of this pact"
             expect(subject[:_links][:'pb:latest-pact-version'][:href]).to eq "http://example.org/pacts/provider/A%20Provider/consumer/A%20Consumer/latest"
           end
 
+          it "includes a link to all pact versions" do
+            expect(subject[:_links][:'pb:all-pact-versions'][:title]).to eq "All versions of this pact"
+            expect(subject[:_links][:'pb:all-pact-versions'][:href]).to eq "http://example.org/pacts/provider/A%20Provider/consumer/A%20Consumer/versions"
+          end
+
           it "includes a link to the pact version" do
             expect(subject[:_links][:'pb:consumer-version'][:title]).to eq "Consumer version"
             expect(subject[:_links][:'pb:consumer-version'][:name]).to eq "1234"

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

@@ -0,0 +1,134 @@
+require 'pact_broker/api/decorators/pact_webhooks_status_decorator'
+
+module PactBroker
+  module Api
+    module Decorators
+      describe PactWebhooksStatusDecorator do
+
+        let(:user_options) do
+          {consumer: 'Foo', provider: 'Bar', resource_url: 'http://example.org/foo', base_url: 'http://example.org'}
+        end
+
+        let(:triggered_webhook) do
+          double('PactBroker::Webhooks::TriggeredWebhook',
+            trigger_type: PactBroker::Webhooks::TriggeredWebhook::TRIGGER_TYPE_PUBLICATION,
+            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(:triggered_webhooks) { [triggered_webhook] }
+
+        let(:json) do
+          PactWebhooksStatusDecorator.new(triggered_webhooks).to_json(user_options: user_options)
+        end
+
+        subject { JSON.parse json, symbolize_names: true }
+
+        it "includes a list of triggered webhooks" do
+          expect(subject[:_embedded][:triggeredWebhooks]).to be_instance_of(Array)
+        end
+
+        it "includes a link to the logs" do
+          expect(subject[:_embedded][:triggeredWebhooks][0][:_links][:logs][:href]).to eq logs_url
+        end
+
+        it "includes a link to the webhook" do
+          expect(subject[:_embedded][:triggeredWebhooks][0][:_links][:'pb:webhook'][:href]).to eq "http://example.org/webhooks/4321"
+        end
+
+        it "includes the triggered webhooks properties" do
+          expect(subject[:_embedded][:triggeredWebhooks].first).to include(
+            status: 'success',
+            triggerType: 'pact_publication',
+            attemptsMade: 1,
+            attemptsRemaining: 2
+          )
+        end
+
+        it "includes a link to the consumer" do
+          expect(subject[:_links][:'pb:consumer']).to_not be nil
+        end
+
+        it "includes a link to the provider" do
+          expect(subject[:_links][:'pb:provider']).to_not be nil
+        end
+
+        it "includes a link to the pact" do
+          expect(subject[:_links][:'pb:pact-version']).to_not be nil
+        end
+
+        it "includes a summary of the triggered webhook statuses" do
+          expect(subject[:summary]).to eq({successful: 1, failed: 0})
+        end
+
+        context "when there is a failure" do
+          let(:status) { PactBroker::Webhooks::TriggeredWebhook::STATUS_FAILURE }
+          let(:failure) { true }
+
+          it "includes a link to the error logs" do
+            expect(subject[:_links][:'pb:error-logs'][0][:href]).to eq logs_url
+          end
+
+          it "has a failed count of 1" do
+            expect(subject[:summary]).to eq({successful: 0, failed: 1})
+          end
+        end
+
+        context "when there is a retry" do
+          let(:status) { PactBroker::Webhooks::TriggeredWebhook::STATUS_RETRYING }
+          let(:retrying) { true }
+
+          it "includes a link to the error logs" do
+            expect(subject[:_links][:'pb:error-logs'][0][:href]).to eq logs_url
+          end
+
+          it "has a retrying count of 1" do
+            expect(subject[:summary]).to eq({successful: 0, failed: 0, retrying: 1})
+          end
+        end
+
+        context "when there is a not_run triggered webhook" do
+          let(:status) { PactBroker::Webhooks::TriggeredWebhook::STATUS_NOT_RUN }
+
+          it "does not include a link to the error logs" do
+            expect(subject[:_links][:'pb:error-logs']).to be_empty
+          end
+
+          it "has a notRun count of 1" do
+            expect(subject[:summary]).to eq({successful: 0, failed: 0, notRun: 1})
+          end
+        end
+
+        context "when there are no triggered webhooks" do
+          let(:triggered_webhooks) { [] }
+
+          it "doesn't blow up" do
+            subject
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -9,7 +9,7 @@ module PactBroker
 
       describe RelationshipsCsvDecorator do
 
-        let(:pact) { TestDataBuilder.new.create_pact_with_hierarchy "My Consumer", "1.0", "My Provider"}
+        let(:pact) { TestDataBuilder.new.create_pact_with_hierarchy("My Consumer", "1.0", "My Provider").and_return(:pact) }
         let(:pacts) { [pact]}
 
 

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

@@ -4,7 +4,7 @@ require 'pact_broker/api/decorators/representable_pact'
 
 module PactBroker::Api::Decorators
   describe RepresentablePact do
-    let(:pact) { TestDataBuilder.new.create_pact_with_hierarchy 'Consumer', '1.2.3', 'Provider' }
+    let(:pact) { TestDataBuilder.new.create_pact_with_hierarchy('Consumer', '1.2.3', 'Provider').and_return(:pact) }
 
     subject { RepresentablePact.new(pact) }
 

data/spec/lib/pact_broker/api/renderers/html_pact_renderer_spec.rb

@@ -9,6 +9,7 @@ module PactBroker
         before do
           ENV['BACKUP_TZ'] = ENV['TZ']
           ENV['TZ'] = "Australia/Melbourne"
+          PactBroker.configuration.enable_public_badge_access = true
         end
 
         after do
@@ -21,12 +22,18 @@ module PactBroker
         let(:json_content) { load_fixture('renderer_pact.json') }
         let(:pact) { double('pact', json_content: json_content, consumer_version_number: '1.2.3', consumer: consumer, provider: provider, consumer_version_tag_names: ['prod', 'master'], created_at: created_at)}
         let(:pact_url) { '/pact/url' }
+        let(:options) do
+          {
+            base_url: 'http://base',
+            badge_url: 'http://badge'
+           }
+        end
 
         before do
           allow(PactBroker::Api::PactBrokerUrls).to receive(:pact_url).with('', pact).and_return(pact_url)
         end
 
-        subject { HtmlPactRenderer.call pact }
+        subject { HtmlPactRenderer.call pact, options }
 
         describe ".call" do
           it "renders the pact as HTML" do
@@ -44,6 +51,25 @@ module PactBroker
             expect(subject).to match /prod, master/
           end
 
+          it "renders the badge image" do
+            expect(subject).to include "<img src='http://badge'/>"
+          end
+
+          it "renders a text area with the badge markdown" do
+            expect(subject).to include "<textarea"
+            expect(subject).to include "[![Consumer/Provider Pact Status](http://badge)](http://base)"
+          end
+
+          context "when enable_public_badge_access is false" do
+            before do
+              PactBroker.configuration.enable_public_badge_access = false
+            end
+
+            it "renders a message instructing the user to turn public access on" do
+              expect(subject).to include "set `enable_public_badge_access` to true in the configuration"
+            end
+          end
+
           context "when the content is not a valid pact, but is still JSON" do
             before do
               allow(pact).to receive(:content_hash).and_return(content_hash)

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

@@ -8,32 +8,49 @@ module PactBroker
         let(:path) { "/pacts/provider/provider/consumer/consumer/latest/badge" }
         let(:params) { {} }
 
+        before do
+          allow(PactBroker::Pacts::Service).to receive(:find_latest_pact).and_return(pact)
+          allow(PactBroker::Verifications::Service).to receive(:find_latest_verification_for).and_return(verification)
+          allow(PactBroker::Badges::Service).to receive(:pact_verification_badge).and_return("badge")
+          allow(PactBroker::Verifications::Status).to receive(:new).and_return(verification_status)
+        end
+
+        let(:pact) { instance_double("PactBroker::Domain::Pact", consumer: consumer, provider: provider) }
+        let(:consumer) { double('consumer') }
+        let(:provider) { double('provider') }
+        let(:verification) { double("verification") }
+        let(:verification_status) { instance_double("PactBroker::Verifications::Status", to_sym: :verified) }
+
+
         subject { get path, params, {'HTTP_ACCEPT' => 'image/svg+xml'}; last_response }
 
-        context "when enable_badge_resources is false" do
+        context "when enable_public_badge_access is false and the request is not authenticated" do
           before do
-            PactBroker.configuration.enable_badge_resources = false
+            PactBroker.configuration.enable_public_badge_access = false
+            allow_any_instance_of(Badge).to receive(:authenticated?).and_return(false)
           end
 
-          it "returns a 404" do
-            expect(subject.status).to eq 404
+          it "returns a 401" do
+            expect(subject.status).to eq 401
           end
         end
 
-        context "when enable_badge_resources is true" do
+        context "when enable_public_badge_access is false but the request is authenticated" do
           before do
-            PactBroker.configuration.enable_badge_resources = true
-            allow(PactBroker::Pacts::Service).to receive(:find_latest_pact).and_return(pact)
-            allow(PactBroker::Verifications::Service).to receive(:find_latest_verification_for).and_return(verification)
-            allow(PactBroker::Badges::Service).to receive(:pact_verification_badge).and_return("badge")
-            allow(PactBroker::Verifications::Status).to receive(:new).and_return(verification_status)
+            PactBroker.configuration.enable_public_badge_access = false
+            allow_any_instance_of(Badge).to receive(:authenticated?).and_return(true)
           end
 
-          let(:pact) { instance_double("PactBroker::Domain::Pact", consumer: consumer, provider: provider) }
-          let(:consumer) { double('consumer') }
-          let(:provider) { double('provider') }
-          let(:verification) { double("verification") }
-          let(:verification_status) { instance_double("PactBroker::Verifications::Status", to_sym: :verified) }
+          it "returns a 200" do
+            expect(subject.status).to eq 200
+          end
+        end
+
+        context "when enable_public_badge_access is true" do
+
+          before do
+            PactBroker.configuration.enable_public_badge_access = true
+          end
 
           it "retrieves the latest pact" do
             expect(PactBroker::Pacts::Service).to receive(:find_latest_pact)

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

@@ -0,0 +1,17 @@
+require 'pact_broker/api/resources/base_resource'
+
+module PactBroker
+  module Api
+    module Resources
+      describe BaseResource do
+        let(:request) { double('request', uri: uri) }
+        let(:response) { double('response') }
+        let(:uri) { URI('http://example.org/path?query') }
+
+        subject { BaseResource.new(request, response) }
+
+        its(:resource_url) { is_expected.to eq 'http://example.org/path' }
+      end
+    end
+  end
+end

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

@@ -16,17 +16,19 @@ module PactBroker::Api
 
         context "Accept: text/html" do
 
+          let(:path) { "/pacts/provider/provider_name/consumer/consumer_name/latest" }
           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"} }
+          let(:pact_id_params) { {provider_name: "provider_name", consumer_name: "consumer_name"} }
+          let(:html_options) { { base_url: 'http://example.org', badge_url: "http://example.org#{path}/badge.svg" } }
 
           before do
             allow(PactBroker::Pacts::Service).to receive(:find_latest_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/latest",{}, {'HTTP_ACCEPT' => "text/html"} }
+          subject { get path ,{}, {'HTTP_ACCEPT' => "text/html"} }
 
           it "find the pact" do
             expect(PactBroker::Pacts::Service).to receive(:find_latest_pact).with(hash_including(pact_id_params))
@@ -34,7 +36,7 @@ module PactBroker::Api
           end
 
           it "uses the configured HTML renderer" do
-            expect(PactBroker.configuration.html_pact_renderer).to receive(:call).with(pact)
+            expect(PactBroker.configuration.html_pact_renderer).to receive(:call).with(pact, html_options)
             subject
           end
 

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

@@ -24,21 +24,28 @@ module PactBroker::Api
           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(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 "find the pact" do
+          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)
+            expect(PactBroker.configuration.html_pact_renderer).to receive(:call).with(pact, html_options)
             subject
           end
 

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

@@ -0,0 +1,28 @@
+require 'pact_broker/api/resources/triggered_webhook_logs'
+
+module PactBroker
+  module Api
+    module Resources
+      describe TriggeredWebhookLogs do
+
+        let(:td) { TestDataBuilder.new }
+
+        before do
+          td.create_pact_with_hierarchy
+            .create_webhook(uuid: "5432")
+            .create_triggered_webhook(trigger_uuid: "1234")
+            .create_webhook_execution(logs: "foo")
+            .create_webhook_execution(logs: "bar")
+        end
+
+        let(:path) { "/webhooks/5432/trigger/1234/logs" }
+
+        subject { get path; last_response }
+
+        it "returns the concatenated webhook execution logs" do
+          expect(subject.body).to eq "foo\nbar"
+        end
+      end
+    end
+  end
+end

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

@@ -28,12 +28,26 @@ module PactBroker
             let(:success) { true }
             let(:execution_result) { double('execution_result', success?: success, to_json: json)}
             let(:json) { {some: 'json'}.to_json }
-            let(:webhook) { double("webhook") }
+            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" }
 
             before do
               allow(PactBroker::Webhooks::Service).to receive(:execute_webhook_now).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)
+              subject
             end
 
             context "when execution is successful" do
@@ -65,13 +79,9 @@ module PactBroker
                 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

@@ -11,50 +11,62 @@ module PactBroker::Api
         allow(PactBroker::Webhooks::Service).to receive(:find_by_uuid).and_return(webhook)
       end
 
-      subject { get '/webhooks/some-uuid' }
+      describe "GET" do
+        subject { get '/webhooks/some-uuid'; last_response }
 
-      context "when the webhook does not exist" do
-        let(:webhook) { nil }
+        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
+          it "returns a 404" do
+            expect(subject).to be_a_404_response
+          end
         end
-      end
 
-      context "when the webhook exists" do
+        context "when the webhook exists" do
 
-        let(:webhook) { double("webhook") }
-        let(:decorator) { double(Decorators::WebhookDecorator, to_json: json)}
-        let(:json) { {some: 'json'}.to_json }
+          let(:webhook) { double("webhook") }
+          let(:decorator) { double(Decorators::WebhookDecorator, to_json: json)}
+          let(:json) { {some: 'json'}.to_json }
 
-        before do
-          allow(Decorators::WebhookDecorator).to receive(:new).and_return(decorator)
-        end
+          before do
+            allow(Decorators::WebhookDecorator).to receive(:new).and_return(decorator)
+          end
 
-        it "finds the webhook by UUID" do
-          expect(PactBroker::Webhooks::Service).to receive(:find_by_uuid).with('some-uuid')
-          subject
-        end
+          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 "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: { base_url: 'http://example.org'})
-          subject
-        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: { 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
+          it "includes the JSON representation in the response body" do
+            subject
+            expect(last_response.body).to eq json
+          end
         end
       end
 
+      describe "PUT" do
+        context "when the webhook does not exist" do
+          let(:webhook) { nil }
+          let(:webhook_json) { load_fixture('webhook_valid.json') }
+
+          subject { put '/webhooks/some-uuid', webhook_json, {'CONTENT_TYPE' => 'application/json'}; last_response }
+
+          it "returns a 404" do
+            expect(subject).to be_a_404_response
+          end
+        end
+      end
     end
   end
-
 end

data/spec/lib/pact_broker/app_spec.rb

@@ -3,16 +3,14 @@ require 'pact_broker/app'
 module PactBroker
   describe App do
 
-    class TestApp < PactBroker::App
+    before do
+      allow(PactBroker::DB).to receive(:run_migrations)
+    end
 
+    class TestApp < PactBroker::App
       def configure_database_connection
-        # do nothing
-      end
-
-      def migrate_database
-        # do nothing
+        # do nothing so we don't screw up our test connection
       end
-
     end
 
     let(:app) do
@@ -21,6 +19,13 @@ module PactBroker
       end
     end
 
+    describe "on start up" do
+      it "fails any retrying triggered webhooks left over when the app shut down" do
+        expect(PactBroker::Webhooks::Service).to receive(:fail_retrying_triggered_webhooks)
+        app
+      end
+    end
+
     it "adds the X-Pact-Broker-Version header" do
       get "/"
       expect(last_response.headers['X-Pact-Broker-Version']).to match /\d/
@@ -208,6 +213,5 @@ module PactBroker
         expect { subject }.to_not change { PactBroker::Domain::Pacticipant.count }
       end
     end
-
   end
 end