pact_broker 2.27.6 → 2.29.0

data/script/restart.sh

@@ -0,0 +1,18 @@
+#/bin/bash
+
+root_dir=$(cd "$(dirname "$0")/.." && pwd)
+example_dir="${root_dir}/example"
+APP_DIR="${APP_DIR:-${example_dir}}"
+
+cd "${APP_DIR}"
+
+if [ -f .pid ]; then
+  pid=$(cat .pid)
+  echo "Pid is ${pid}"
+  kill $pid
+  sleep 2
+fi
+
+bundle exec rackup &
+pid=$!
+echo $pid > .pid

data/script/watch.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+relative_app_dir=${1:-$PWD}
+export APP_DIR=$(cd $relative_app_dir && pwd)
+root_dir=$(cd "$(dirname "$0")/.." && pwd)
+"${root_dir}"/script/restart.sh &
+fswatch -o "${root_dir}/lib" | xargs -n1 -I{} "${root_dir}/script/restart.sh"

data/spec/features/publish_verification_spec.rb

@@ -45,7 +45,7 @@ describe "Recording a pact verification" do
     expect(JSON.parse(subject.body)).to include JSON.parse(verification_content)
   end
 
-  context "with a webhook configured" do
+  context "with a webhook configured", job: true do
     before do
       td.create_webhook(
         method: 'POST',

data/spec/integration/app_spec.rb

@@ -31,7 +31,7 @@ module PactBroker
     context "when Accept includes text/html" do
       let(:env) { {'HTTP_ACCEPT' => 'text/html'} }
 
-      subject { get path, '', env; last_response.tap { |it| File.open("bethtest.html", "w") { |file| file << it.body } } }
+      subject { get path, '', env; last_response }
 
       describe "a request for root" do
 

data/spec/integration/webhooks/certificate_spec.rb

@@ -1,13 +1,21 @@
 require 'pact_broker/domain/webhook_request'
+require 'faraday'
 # certificates and key generated by script/generate-certificates-for-webooks-certificate-spec.rb
 
 describe "executing a webhook to a server with a self signed certificate" do
-  let(:td) { TestDataBuilder.new }
+  def wait_for_server_to_start
+    Faraday.new(url: "https://localhost:4444", ssl: {verify: false}) do |builder|
+      builder.request :retry, max: 20, interval: 0.5, exceptions: [StandardError]
+      builder.adapter  :net_http
+    end.get
+  end
+
   before(:all) do
     @pipe = IO.popen("bundle exec ruby spec/support/ssl_webhook_server.rb")
-    sleep 3
+    wait_for_server_to_start
   end
 
+  let(:td) { TestDataBuilder.new }
   let(:webhook_request) do
     PactBroker::Domain::WebhookRequest.new(
       method: 'get',

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

@@ -101,8 +101,9 @@ module PactBroker
             }
           end
 
-          let(:query_results){ PactBroker::Matrix::QueryResultsWithDeploymentStatusSummary.new([row_1, row_2], selectors, options, resolved_selectors, deployment_status_summary)}
+          let(:query_results){ PactBroker::Matrix::QueryResultsWithDeploymentStatusSummary.new([row_1, row_2], selectors, options, resolved_selectors, integrations, deployment_status_summary)}
           let(:selectors) { nil }
+          let(:integrations){ [] }
           let(:options) { nil }
           let(:resolved_selectors) { nil }
           let(:counts) { { success: 1 } }

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

@@ -0,0 +1,59 @@
+require 'pact_broker/api/decorators/reason_decorator'
+require 'pact_broker/matrix/reason'
+
+module PactBroker
+  module Api
+    module Decorators
+      describe ReasonDecorator do
+
+        REASON_CLASSES = ObjectSpace.each_object(Class).select { |klass| klass < PactBroker::Matrix::Reason }
+
+        describe "the number of Reason classes" do
+          it "is 9 - add another spec here if a new Reason is added" do
+            expect(REASON_CLASSES.size).to eq 9
+          end
+        end
+
+        describe "#to_s" do
+
+          let(:consumer_selector) { double('consumer selector', description: "version 2 of Foo") }
+          let(:provider_selector) { double('provider selector', description: "version 6 of Bar") }
+          let(:selectors) { [consumer_selector, provider_selector] }
+
+          subject { ReasonDecorator.new(reason) }
+
+          context "when the reason is PactBroker::Matrix::PactNotEverVerifiedByProvider" do
+            let(:reason) { PactBroker::Matrix::PactNotEverVerifiedByProvider.new(*selectors) }
+            let(:provider_selector) { double('provider selector', description: "any version of Bar") }
+
+            its(:to_s) { is_expected.to eq "There is no verified pact between version 2 of Foo and any version of Bar" }
+          end
+
+          context "when the reason is PactBroker::Matrix::PactNotVerifiedByRequiredProviderVersion" do
+            let(:reason) { PactBroker::Matrix::PactNotVerifiedByRequiredProviderVersion.new(*selectors) }
+
+            its(:to_s) { is_expected.to eq "There is no verified pact between version 2 of Foo and version 6 of Bar" }
+          end
+
+          context "when the reason is PactBroker::Matrix::VerificationFailed" do
+            let(:reason) { PactBroker::Matrix::VerificationFailed.new(*selectors) }
+
+            its(:to_s) { is_expected.to eq "The verification between version 2 of Foo and version 6 of Bar failed" }
+          end
+
+          context "when the reason is PactBroker::Matrix::NoDependenciesMissing" do
+            let(:reason) { PactBroker::Matrix::NoDependenciesMissing.new }
+
+            its(:to_s) { is_expected.to eq "There are no missing dependencies" }
+          end
+
+          context "when the reason is PactBroker::Matrix::Successful" do
+            let(:reason) { PactBroker::Matrix::Successful.new }
+
+            its(:to_s) { is_expected.to eq "All required verification results are published and successful" }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -8,12 +8,13 @@ module PactBroker
 
           before do
             allow(ErrorHandler).to receive(:logger).and_return(logger)
+            allow(SecureRandom).to receive(:urlsafe_base64).and_return("bYWfn-+yWPlf")
           end
 
           let(:logger) { double('logger').as_null_object }
           let(:error) { StandardError.new('test error') }
           let(:thing) { double('thing', call: nil, another_call: nil) }
-          let(:options) { { env: env } }
+          let(:options) { { env: env, error_reference: "bYWfnyWPlf" } }
           let(:request) { double('request' ) }
           let(:response) { double('response', :body= => nil) }
           let(:env) { double('env') }
@@ -37,33 +38,59 @@ module PactBroker
             subject
           end
 
-          context "when the error is a PactBroker::Error or subclass" do
-            let(:error) { Class.new(PactBroker::Error).new('test error') }
-
-            it "does not invoke the api error reporters" do
-              expect(thing).to_not receive(:call).with(error, options)
-              subject
-            end
-          end
-
-          it "creates a json error response body" do
+          it "includes an error reference" do
             expect(response).to receive(:body=) do | body |
-              expect(JSON.parse(body)['error']).to include 'message' => 'test error'
+              expect(JSON.parse(body)['error']).to include 'reference' => "bYWfnyWPlf"
             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")
+            context "when the error is a PactBroker::Error or subclass" do
+              let(:error) { Class.new(PactBroker::Error).new('test error') }
+
+              it "does not invoke the api error reporters" do
+                expect(thing).to_not receive(:call).with(error, options)
+                subject
+              end
+
+              it "uses the error message as the message" do
+                expect(response).to receive(:body=) do | body |
+                  expect(JSON.parse(body)['error']).to include 'message' => "test error"
+                end
+                subject
+              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 the error is not a PactBroker::Error or subclass" do
+              it "invokes the api error reporters" do
+                expect(thing).to receive(:call).with(error, options)
+                subject
+              end
+
+              it "uses the error message as the message" do
+                expect(response).to receive(:body=) do | body |
+                  expect(JSON.parse(body)['error']).to include 'message' => "test error"
+                end
+                subject
+              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
-              subject
             end
           end
 
@@ -72,11 +99,47 @@ module PactBroker
               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")
+            context "when the error is a PactBroker::Error or subclass" do
+              let(:error) { Class.new(PactBroker::Error).new('test error') }
+
+              it "does not invoke the api error reporters" do
+                expect(thing).to_not receive(:call).with(error, options)
+                subject
+              end
+
+              it "uses the error message as the message" do
+                expect(response).to receive(:body=) do | body |
+                  expect(JSON.parse(body)['error']).to include 'message' => "test error"
+                end
+                subject
+              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 not a PactBroker::Error or subclass" do
+              it "invokes the api error reporters" do
+                expect(thing).to receive(:call).with(error, options)
+                subject
+              end
+
+              it "uses a hardcoded error message" do
+                expect(response).to receive(:body=) do | body |
+                  expect(JSON.parse(body)['error']['message']).to match /An error/
+                end
+                subject
+              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
-              subject
             end
           end
 

data/spec/lib/pact_broker/app_spec.rb

@@ -65,6 +65,28 @@ module PactBroker
       end
     end
 
+    describe "use_custom_ui" do
+      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
+
+      context "when the UI returns a 404 response" do
+        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_xxx_auth" do
       class TestAuth
         def initialize app, *args, &block

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

@@ -310,7 +310,7 @@ module PactBroker
           end
 
           it "logs the error" do
-            expect(logger).to receive(:error).with(/Error.*WebhookTestError.*blah/)
+            expect(logger).to receive(:info).with(/Error.*WebhookTestError.*blah/)
             execute
           end
 

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

@@ -2,6 +2,7 @@ require 'pact_broker/matrix/deployment_status_summary'
 require 'pact_broker/matrix/row'
 require 'pact_broker/matrix/query_results'
 require 'pact_broker/matrix/integration'
+require 'pact_broker/matrix/resolved_selector'
 
 module PactBroker
   module Matrix
@@ -17,21 +18,33 @@ module PactBroker
         let(:rows) { [row_1, row_2] }
         let(:row_1) do
           double(Row,
+            consumer: foo,
+            provider: bar,
+            consumer_version: foo_version,
+            provider_version: bar_version,
             consumer_name: "Foo",
             consumer_id: 1,
+            consumer_version_id: 1,
             provider_name: "Bar",
             provider_id: 2,
-            success: row_1_success
+            success: row_1_success,
+            pacticipant_names: %w{Foo Bar}
           )
         end
 
         let(:row_2) do
           double(Row,
+            consumer: foo,
+            provider: baz,
+            consumer_version: foo_version,
+            provider_version: baz_version,
             consumer_name: "Foo",
             consumer_id: 1,
+            consumer_version_id: 1,
             provider_name: "Baz",
             provider_id: 3,
-            success: true
+            success: true,
+            pacticipant_names: %w{Foo Baz}
           )
         end
 
@@ -39,22 +52,38 @@ module PactBroker
 
         let(:integrations) do
           [
-            Integration.new(1, "Foo", 2, "Bar"),
-            Integration.new(1, "Foo", 3, "Baz")
+            Integration.new(1, "Foo", 2, "Bar", true),
+            Integration.new(1, "Foo", 3, "Baz", true)
           ]
         end
 
+        let(:foo) { double('foo', id: 1, name: "Foo") }
+        let(:bar) { double('bar', id: 2, name: "Bar") }
+        let(:baz) { double('baz', id: 3, name: "Baz") }
+        let(:foo_version) { double('foo version', number: "ddec8101dabf4edf9125a69f9a161f0f294af43c", id: 10)}
+        let(:bar_version) { double('bar version', number: "14131c5da3abf323ccf410b1b619edac76231243", id: 10)}
+        let(:baz_version) { double('baz version', number: "4ee06460f10e8207ad904fa9fa6c4842e462ab59", id: 10)}
+
         let(:resolved_selectors) do
           [
-            {
-              pacticipant_id: 1, pacticipant_version_number: "ddec8101dabf4edf9125a69f9a161f0f294af43c"
-            },
-            {
-              pacticipant_id: 2, pacticipant_version_number: "14131c5da3abf323ccf410b1b619edac76231243"
-            },
-            {
-              pacticipant_id: 3, pacticipant_version_number: "4ee06460f10e8207ad904fa9fa6c4842e462ab59"
-            }
+            ResolvedSelector.new(
+              pacticipant_id: 1,
+              pacticipant_name: "Foo",
+              pacticipant_version_number: "ddec8101dabf4edf9125a69f9a161f0f294af43c",
+              pacticipant_version_id: 10
+            ),
+            ResolvedSelector.new(
+              pacticipant_id: 2,
+              pacticipant_name: "Bar",
+              pacticipant_version_number: "14131c5da3abf323ccf410b1b619edac76231243",
+              pacticipant_version_id: 11
+            ),
+            ResolvedSelector.new(
+             pacticipant_id: 3,
+             pacticipant_name: "Baz",
+             pacticipant_version_number: "4ee06460f10e8207ad904fa9fa6c4842e462ab59",
+             pacticipant_version_id: 12
+            ),
           ]
         end
 
@@ -62,7 +91,7 @@ module PactBroker
 
         context "when there is a row for all integrations" do
           its(:deployable?) { is_expected.to be true }
-          its(:reasons) { is_expected.to eq ["All verification results are published and successful"] }
+          its(:reasons) { is_expected.to eq [Successful.new] }
           its(:counts) { is_expected.to eq success: 2, failed: 0, unknown: 0 }
         end
 
@@ -70,7 +99,12 @@ module PactBroker
           let(:rows) { [] }
 
           its(:deployable?) { is_expected.to be nil }
-          its(:reasons) { is_expected.to eq ["No results matched the given query"] }
+          its(:reasons) do
+            is_expected.to eq [
+              PactNotVerifiedByRequiredProviderVersion.new(resolved_selectors.first, resolved_selectors[1]),
+              PactNotVerifiedByRequiredProviderVersion.new(resolved_selectors.first, resolved_selectors.last)
+            ]
+          end
           its(:counts) { is_expected.to eq success: 0, failed: 0, unknown: 2 }
         end
 
@@ -78,7 +112,7 @@ module PactBroker
           let(:row_1_success) { nil }
 
           its(:deployable?) { is_expected.to be nil }
-          its(:reasons) { is_expected.to eq ["Missing one or more verification results"] }
+          its(:reasons) { is_expected.to eq [PactNotEverVerifiedByProvider.new(resolved_selectors.first, resolved_selectors[1]) ] }
           its(:counts) { is_expected.to eq success: 1, failed: 0, unknown: 1 }
         end
 
@@ -86,36 +120,90 @@ module PactBroker
           let(:row_1_success) { false }
 
           its(:deployable?) { is_expected.to be false }
-          its(:reasons) { is_expected.to eq ["One or more verifications have failed"] }
+          its(:reasons) { is_expected.to eq [VerificationFailed.new(resolved_selectors.first, resolved_selectors[1])] }
           its(:counts) { is_expected.to eq success: 1, failed: 1, unknown: 0 }
         end
 
-        context "when there is a relationship missing" do
+        context "when there is a provider relationship missing" do
           let(:rows) { [row_1] }
 
           its(:deployable?) { is_expected.to be nil }
-          its(:reasons) { is_expected.to eq ["There is no verified pact between Foo (ddec8101dabf4edf9125a69f9a161f0f294af43c) and Baz (4ee06460f10e8207ad904fa9fa6c4842e462ab59)"] }
+          its(:reasons) { is_expected.to eq [PactNotVerifiedByRequiredProviderVersion.new(resolved_selectors.first, resolved_selectors.last)] }
           its(:counts) { is_expected.to eq success: 1, failed: 0, unknown: 1 }
         end
 
-        context "when there is something unexpected about the data and the resolved selector cannot be found" do
+        context "when there is a consumer integration missing and only the provider was specified in the query" do
+          let(:rows) { [row_1] }
+          let(:integrations) do
+            [
+              Integration.new(1, "Foo", 2, "Bar", true),
+              Integration.new(3, "Baz", 2, "Bar", false) # the missing one
+            ]
+          end
+
+          its(:deployable?) { is_expected.to be true }
+          its(:reasons) { is_expected.to eq [Successful.new] }
+          its(:counts) { is_expected.to eq success: 1, failed: 0, unknown: 0 }
+        end
+
+        context "when there are no rows, and no missing downstream providers and the provider was specified in the query" do
+          let(:rows) { [] }
+          let(:integrations) do
+            [
+              Integration.new(1, "Foo", 2, "Bar", false),
+              Integration.new(3, "Baz", 2, "Bar", false)
+            ]
+          end
+
+          its(:deployable?) { is_expected.to be true }
+          its(:reasons) { is_expected.to eq [NoDependenciesMissing.new] }
+          its(:counts) { is_expected.to eq success: 0, failed: 0, unknown: 0 }
+        end
+
+        context "when there is a provider integration missing and only the consumer was specified in the query" do
           let(:rows) { [row_1] }
 
-          let(:resolved_selectors) do
+          let(:integrations) do
             [
-              {
-                pacticipant_id: 3, pacticipant_version_number: "4ee06460f10e8207ad904fa9fa6c4842e462ab59"
-              }
+              Integration.new(1, "Foo", 2, "Bar", true),
+              Integration.new(1, "Foo", 3, "Baz", true) # the missing one
             ]
           end
 
           its(:deployable?) { is_expected.to be nil }
-          its(:reasons) { is_expected.to eq ["There is no verified pact between Foo (unresolved version) and Baz (4ee06460f10e8207ad904fa9fa6c4842e462ab59)"] }
+          its(:reasons) { is_expected.to eq [PactNotVerifiedByRequiredProviderVersion.new(resolved_selectors.first, resolved_selectors.last)] }
+          its(:counts) { is_expected.to eq success: 1, failed: 0, unknown: 1 }
+        end
 
-          it "logs a warning" do
-            expect(logger).to receive(:warn).with(/Could not find the resolved version/)
-            subject.reasons
+        context "when there are no inferred selectors and the pact has not ever been verified" do
+          # This happens when the user has not specified a version of the provider (eg no 'latest' and/or 'tag')
+          # so the "add inferred selectors" code in the Matrix::Repository has not run
+          # AND the pact has not been verified
+          # eg.
+          # bundle exec bin/pact-broker can-i-deploy --broker-base-url http://localhost:9292 --pacticipant Foo --version 1.1.0
+          let(:rows) { [row_1] }
+          let(:row_1_success) { nil }
+
+          let(:dummy_selector) do
+            ResolvedSelector.new(
+              pacticipant_id: 2,
+              pacticipant_name: "Bar",
+              pacticipant_version_id: 10,
+              pacticipant_version_number: "14131c5da3abf323ccf410b1b619edac76231243",
+              latest: nil,
+              tag: nil,
+              type: :inferred
+            )
           end
+
+          before do
+            resolved_selectors.delete_at(1)
+            resolved_selectors.delete_at(1)
+            integrations.delete_at(1)
+          end
+
+          its(:deployable?) { is_expected.to be nil }
+          its(:reasons) { is_expected.to eq [PactNotEverVerifiedByProvider.new(resolved_selectors.first, dummy_selector)] }
         end
       end
     end