pact_broker 2.31.0 → 2.32.0

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

@@ -6,11 +6,8 @@ require 'pact_broker/pacticipants/service'
 
 
 module PactBroker::Api
-
   module Resources
-
     describe Pact do
-
       include Rack::Test::Methods
 
       let(:app) { PactBroker::API }

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

@@ -5,25 +5,29 @@ require 'pact_broker/verifications/service'
 
 module PactBroker
   module Api
-
     module Resources
-
       describe Verifications do
-
         describe "post" do
-
-          let(:url) { "/pacts/provider/Provider/consumer/Consumer/pact-version/1234/verification-results" }
-          let(:request_body) { {some: 'params'}.to_json }
-          subject { post url, request_body, {'CONTENT_TYPE' => 'application/json' }; last_response }
-          let(:response_body) { JSON.parse(subject.body, {symbolize_names: true}) }
+          let(:url) { "/pacts/provider/Provider/consumer/Consumer/pact-version/1234/metadata/abcd/verification-results" }
+          let(:request_body) { { some: 'params' }.to_json }
+          let(:rack_env) do
+            { 'CONTENT_TYPE' => 'application/json', 'pactbroker.database_connector' => database_connector }
+          end
+          let(:response_body) { JSON.parse(subject.body, symbolize_names: true) }
+          let(:database_connector) { double('database_connector' )}
           let(:verification) { double(PactBroker::Domain::Verification) }
           let(:errors_empty) { true }
+          let(:parsed_metadata) { { the: 'metadata' } }
+          let(:base_url) { "http://example.org" }
 
           before do
             allow(PactBroker::Verifications::Service).to receive(:create).and_return(verification)
             allow(PactBroker::Verifications::Service).to receive(:errors).and_return(double(:errors, messages: ['errors'], empty?: errors_empty))
+            allow(PactBrokerUrls).to receive(:parse_webhook_metadata).and_return(parsed_metadata)
           end
 
+          subject { post url, request_body, rack_env; last_response }
+
           it "looks up the specified pact" do
             allow(Pacts::Service).to receive(:find_pact).with(instance_of(PactBroker::Pacts::PactParams))
           end
@@ -39,7 +43,13 @@ module PactBroker
           end
 
           context "when the pact exists" do
-            let(:pact) { instance_double("PactBroker::Domain::Pact", provider_name: 'Provider', consumer_name: 'Consumer', pact_version_sha: '1234') }
+            let(:pact) do
+              instance_double("PactBroker::Domain::Pact",
+                provider_name: 'Provider',
+                consumer_name: 'Consumer',
+                pact_version_sha: '1234'
+              )
+            end
             let(:next_verification_number) { "2" }
             let(:serialised_verification) { {some: 'verification'}.to_json }
             let(:decorator) { instance_double('PactBroker::Api::Decorators::VerificationDecorator', to_json: serialised_verification) }
@@ -48,6 +58,12 @@ module PactBroker
               allow(Pacts::Service).to receive(:find_pact).and_return(pact)
               allow(PactBroker::Verifications::Service).to receive(:next_number).and_return(next_verification_number)
               allow(PactBroker::Api::Decorators::VerificationDecorator).to receive(:new).and_return(decorator)
+              allow(PactBroker.configuration).to receive(:show_webhook_response?).and_return('some-boolean')
+            end
+
+            it "parses the webhook metadata" do
+              expect(PactBrokerUrls).to receive(:parse_webhook_metadata).with("abcd")
+              subject
             end
 
             it "returns a 201" do
@@ -59,7 +75,21 @@ module PactBroker
             end
 
             it "stores the verification in the database" do
-              expect(PactBroker::Verifications::Service).to receive(:create).with(next_verification_number, hash_including('some' => 'params'), pact)
+              expect(PactBroker::Verifications::Service).to receive(:create).with(
+                next_verification_number,
+                hash_including('some' => 'params'),
+                pact,
+                {
+                  execution_options: {
+                    show_response: 'some-boolean'
+                  },
+                  webhook_context: {
+                    the: 'metadata',
+                    base_url: base_url,
+                  },
+                  database_connector: database_connector
+                }
+              )
               subject
             end
 

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

@@ -33,6 +33,16 @@ module PactBroker
             let(:pact) { instance_double("PactBroker::Domain::Pact") }
             let(:consumer_name) { "foo" }
             let(:provider_name) { "bar" }
+            let(:webhook_options) do
+              {
+                execution_options: {
+                  show_response: false,
+                },
+                webhook_context: {
+                  base_url: "http://example.org"
+                }
+              }
+            end
 
             before do
               allow(PactBroker::Webhooks::Service).to receive(:test_execution).and_return(execution_result)
@@ -40,7 +50,7 @@ module PactBroker
             end
 
             it "executes the webhook" do
-              expect(PactBroker::Webhooks::Service).to receive(:test_execution).with(webhook)
+              expect(PactBroker::Webhooks::Service).to receive(:test_execution).with(webhook, webhook_options)
               subject
             end
 
@@ -65,9 +75,9 @@ module PactBroker
             context "when execution is not successful" do
               let(:success) { false }
 
-              it "returns a 500 JSON response" do
+              it "returns a 200 JSON response" do
                 subject
-                expect(last_response.status).to eq 500
+                expect(last_response.status).to eq 200
               end
 
               it "includes the execution result JSON in the body" do

data/spec/lib/pact_broker/app_spec.rb

@@ -66,13 +66,15 @@ module PactBroker
     end
 
     describe "use_custom_ui" do
+      before do
+        app.use_custom_ui(custom_ui)
+        get "/", nil, { "HTTP_ACCEPT" => "text/html" }
+      end
+
       context "when the UI returns a non 404 response" do
         let(:custom_ui) { double('ui', call: [200, {}, ["hello"]]) }
 
         it "returns the given page" do
-          app.use_custom_ui(custom_ui)
-
-          get "/", nil, { "HTTP_ACCEPT" => "text/html" }
           expect(last_response.body).to eq "hello"
         end
       end
@@ -81,12 +83,34 @@ module PactBroker
         let(:custom_ui) { double('ui', call: [404, {}, []]) }
 
         it "passes on the call to the rest of the app" do
-          get "/", nil, { "HTTP_ACCEPT" => "text/html" }
           expect(last_response.status).to eq 200
         end
       end
     end
 
+    describe "use_custom_api" do
+      before do
+        app.use_custom_api(custom_api)
+        get "/", nil, { "HTTP_ACCEPT" => "application/hal+json" }
+      end
+
+      context "when the API returns a non 404 response" do
+        let(:custom_api) { double('api', call: [200, {}, ["hello"]]) }
+
+        it "returns the given resource" do
+          expect(last_response.body).to eq "hello"
+        end
+      end
+
+      context "when the custom API returns a 404 response" do
+        let(:custom_api) { double('api', call: [404, {}, []]) }
+
+        it "passes on the call to the rest of the app" do
+          expect(last_response.body).to_not eq "hello"
+        end
+      end
+    end
+
     describe "use_xxx_auth" do
       class TestAuth
         def initialize app, *args, &block

data/spec/lib/pact_broker/db/data_migrations/set_latest_version_sequence_value_spec.rb

@@ -0,0 +1,68 @@
+require 'pact_broker/db/data_migrations/set_latest_version_sequence_value'
+
+module PactBroker
+  module DB
+    module DataMigrations
+      describe SetLatestVersionSequenceValue, data_migration: true do
+        include MigrationHelpers
+
+        describe ".call" do
+          before (:all) do
+            PactBroker::Database.migrate(20190509)
+          end
+
+          let(:now) { DateTime.new(2018, 2, 2) }
+
+          subject { SetLatestVersionSequenceValue.call(database) }
+
+          context "when there is no sequence value set" do
+            context "when there are no versions" do
+              it "initializes the sequence value - this is required at start up each time in case someone has changed the ordering configuration (date vs semantic)" do
+                subject
+                expect(database[:version_sequence_number].first[:value]).to eq 100
+              end
+            end
+
+            context "when there are pre-existing versions" do
+              let!(:consumer) { create(:pacticipants, {name: 'Consumer', created_at: now, updated_at: now}) }
+              let!(:consumer_version) { create(:versions, {number: '1.2.3', order: 1, pacticipant_id: consumer[:id], created_at: now, updated_at: now}) }
+              let!(:consumer_version) { create(:versions, {number: '1.2.5', order: 3, pacticipant_id: consumer[:id], created_at: now, updated_at: now}) }
+
+              it "initializes the sequence value to the max version order with a margin of error" do
+                subject
+                expect(database[:version_sequence_number].first[:value]).to eq 103
+              end
+            end
+          end
+
+          context "when a value already exists and it is already higher than the max_order" do
+            before do
+              database[:version_sequence_number].insert(value: 5)
+            end
+
+            it "does not update the value" do
+              subject
+              expect(database[:version_sequence_number].first[:value]).to eq 5
+              expect(database[:version_sequence_number].count).to eq 1
+            end
+          end
+
+          context "when a value already exists and it not higher than the max_order" do
+            before do
+              database[:version_sequence_number].insert(value: 3)
+            end
+
+            let!(:consumer) { create(:pacticipants, {name: 'Consumer', created_at: now, updated_at: now}) }
+            let!(:consumer_version) { create(:versions, {number: '1.2.3', order: 1, pacticipant_id: consumer[:id], created_at: now, updated_at: now}) }
+            let!(:consumer_version) { create(:versions, {number: '1.2.5', order: 3, pacticipant_id: consumer[:id], created_at: now, updated_at: now}) }
+
+            it "updates the value" do
+              subject
+              expect(database[:version_sequence_number].first[:value]).to eq 103
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/pact_broker/domain/order_versions_spec.rb

@@ -24,7 +24,7 @@ describe PactBroker::Domain::OrderVersions do
     end
   end
 
-  context "when order_versions_by_date is true (not recommended)" do
+  context "when order_versions_by_date is true (recommended)" do
     before do
       allow(PactBroker.configuration).to receive(:order_versions_by_date).and_return(true)
     end
@@ -69,7 +69,6 @@ describe PactBroker::Domain::OrderVersions do
     end
 
     context "when the new version is considered to be earlier than the previous latest version" do
-
       before do
         Sequel::Model.db[:versions].where(number: '2').update(number: 'z')
         Sequel::Model.db[:versions].where(number: '3').update(number: 'a')
@@ -80,8 +79,6 @@ describe PactBroker::Domain::OrderVersions do
         PactBroker::Domain::Version.create(number: '2', pacticipant_id: consumer.id)
         expect(ordered_versions).to eq(['1', 'z', 'a', '2', '4'])
       end
-
     end
   end
-
 end

data/spec/lib/pact_broker/domain/webhook_spec.rb

@@ -8,8 +8,9 @@ module PactBroker
       let(:request_template) { instance_double(PactBroker::Webhooks::WebhookRequestTemplate, build: request)}
       let(:request) { instance_double(PactBroker::Domain::WebhookRequest, execute: result) }
       let(:result) { double('result') }
-      let(:options) { { base_url: base_url } }
-      let(:base_url) { "http://broker" }
+      let(:webhook_context) { { some: 'things' } }
+      let(:execution_options) { { other: 'options' } }
+      let(:options) { { webhook_context: webhook_context, execution_options: execution_options } }
       let(:pact) { double('pact') }
       let(:verification) { double('verification') }
       let(:logger) { double('logger').as_null_object }
@@ -20,8 +21,8 @@ module PactBroker
 
       subject(:webhook) { Webhook.new(request: request_template, consumer: consumer, provider: provider) }
 
-      describe "description" do
-        subject { webhook.description }
+      describe "scope_description" do
+        subject { webhook.scope_description }
 
         context "with a consumer and provider" do
           it { is_expected.to eq "A webhook for the pact between Consumer and Provider" }
@@ -55,12 +56,15 @@ module PactBroker
         let(:execute) { subject.execute pact, verification, options }
 
         it "builds the request" do
-          expect(request_template).to receive(:build).with(pact: pact, verification: verification, base_url: base_url)
+          expect(request_template).to receive(:build).with(
+            pact: pact,
+            verification: verification,
+            webhook_context: webhook_context)
           execute
         end
 
         it "executes the request" do
-          expect(request).to receive(:execute).with(options)
+          expect(request).to receive(:execute).with(execution_options)
           execute
         end
 

data/spec/lib/pact_broker/matrix/parse_query_spec.rb

@@ -39,22 +39,22 @@ module PactBroker
         context "with no options specified" do
           let(:query) { "" }
 
-          it "does not set any options" do
-            expect(subject.last).to eq({})
+          it "sets the defaults" do
+            expect(subject.last).to eq(limit: "100")
           end
         end
 
         context "with just one status specified" do
           let(:query) { "success=true" }
           it "extracts the one status" do
-            expect(subject.last).to eq success: [true]
+            expect(subject.last).to include success: [true]
           end
         end
 
         context "with an array of statuses" do
           let(:query) { "success[]=true&success[]=false&success[]=" }
           it "extracts the statuses" do
-            expect(subject.last).to eq success: [true, false, nil]
+            expect(subject.last).to include success: [true, false, nil]
           end
         end
 
@@ -62,7 +62,7 @@ module PactBroker
           let(:query) { "success[]=&foo=bar" }
 
           it "sets an array with a nil success" do
-            expect(subject.last).to eq(success: [nil])
+            expect(subject.last).to include success: [nil]
           end
         end
 
@@ -70,7 +70,7 @@ module PactBroker
           let(:query) { "success=&foo=bar" }
 
           it "sets an array with a nil success" do
-            expect(subject.last).to eq(success: [nil])
+            expect(subject.last).to include success: [nil]
           end
         end
 
@@ -86,7 +86,7 @@ module PactBroker
           let(:query) { "q[][pacticipant]=Foo&latest=true" }
 
           it "returns options with latest true" do
-            expect(subject.last).to eq latest: true
+            expect(subject.last).to include latest: true
           end
         end
 
@@ -105,6 +105,14 @@ module PactBroker
             expect(subject.first).to eq [{ pacticipant_name: 'Foo', tag: 'prod' }]
           end
         end
+
+        context "when a limit is specified" do
+          let(:query) { "limit=200" }
+
+          it "sets the limit" do
+            expect(subject.last[:limit]).to eq "200"
+          end
+        end
       end
     end
   end

data/spec/lib/pact_broker/pacts/service_spec.rb

@@ -33,7 +33,7 @@ module PactBroker
         let(:provider) { double('provider', id: 2) }
         let(:version) { double('version', id: 3, pacticipant_id: 1) }
         let(:existing_pact) { nil }
-        let(:new_pact) { double('new_pact', json_content: json_content) }
+        let(:new_pact) { double('new_pact', consumer_version_tag_names: %[dev], json_content: json_content) }
         let(:json_content) { { the: "contract" }.to_json }
         let(:json_content_with_ids) { { the: "contract with ids" }.to_json }
         let(:previous_pacts) { [] }
@@ -47,6 +47,8 @@ module PactBroker
         end
         let(:content) { double('content') }
         let(:content_with_interaction_ids) { double('content_with_interaction_ids', to_json: json_content_with_ids) }
+        let(:webhook_options) { { the: 'options'} }
+        let(:outgoing_webhook_options) { { the: 'options', webhook_context: { consumer_version_tags: %[dev] }} }
 
         before do
           allow(Content).to receive(:from_json).and_return(content)
@@ -54,7 +56,7 @@ module PactBroker
           allow(PactBroker::Pacts::GenerateSha).to receive(:call).and_call_original
         end
 
-        subject { Service.create_or_update_pact(params) }
+        subject { Service.create_or_update_pact(params, webhook_options) }
 
         context "when no pact exists with the same params" do
           it "creates the sha before adding the interaction ids" do
@@ -69,13 +71,19 @@ module PactBroker
           end
 
           it "triggers webhooks" do
-            expect(webhook_trigger_service).to receive(:trigger_webhooks_for_new_pact).with(new_pact)
+            expect(webhook_trigger_service).to receive(:trigger_webhooks_for_new_pact).with(new_pact, outgoing_webhook_options)
             subject
           end
         end
 
         context "when a pact exists with the same params" do
-          let(:existing_pact) { double('existing_pact', id: 4, json_content: { the: "contract" }.to_json) }
+          let(:existing_pact) do
+            double('existing_pact',
+              id: 4,
+              consumer_version_tag_names: %[dev],
+              json_content: { the: "contract" }.to_json
+            )
+          end
 
           it "creates the sha before adding the interaction ids" do
             expect(PactBroker::Pacts::GenerateSha).to receive(:call).ordered
@@ -89,7 +97,7 @@ module PactBroker
           end
 
           it "triggers webhooks" do
-            expect(webhook_trigger_service).to receive(:trigger_webhooks_for_updated_pact).with(existing_pact, new_pact)
+            expect(webhook_trigger_service).to receive(:trigger_webhooks_for_updated_pact).with(existing_pact, new_pact, outgoing_webhook_options)
             subject
           end
         end