pact_broker 2.22.0 → 2.23.0

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

@@ -5,25 +5,15 @@ require 'webmock/rspec'
 module PactBroker
   module Domain
     describe WebhookRequest do
-      before do
-        allow(PactBroker::Api::PactBrokerUrls).to receive(:pact_url).and_return('http://example.org/pact-url')
-        allow(PactBroker.configuration).to receive(:base_url).and_return('http://example.org')
-        allow(PactBroker::Webhooks::Render).to receive(:call) do | content, pact, verification, &block |
-          content
-        end
-      end
-
       let(:username) { nil }
       let(:password) { nil }
       let(:url) { 'http://example.org/hook' }
       let(:headers) { {'Content-Type' => 'text/plain', 'Authorization' => 'foo'} }
-      let(:body) { 'body' }
+      let(:body) { 'reqbody' }
       let(:logs) { StringIO.new }
       let(:execution_logger) { Logger.new(logs) }
       let(:options) { {failure_log_message: 'oops', show_response: show_response} }
       let(:show_response) { true }
-      let(:pact) { instance_double('PactBroker::Domain::Pact') }
-      let(:verification) { instance_double('PactBroker::Domain::Verification') }
       let(:logs) { execute.logs }
 
       subject do
@@ -36,21 +26,12 @@ module PactBroker
           body: body)
       end
 
-      let(:execute) { subject.execute(pact, verification, options) }
-
+      let(:execute) { subject.execute(options) }
 
       describe "description" do
         it "returns a brief description of the HTTP request" do
           expect(subject.description).to eq 'POST example.org'
         end
-
-        context "when the URL has a template parameter in it" do
-          let(:url) { "http://foo/commits/${pactbroker.consumerVersionNumber}" }
-
-          it "doesn't explode" do
-            expect(subject.description).to eq 'POST foo'
-          end
-        end
       end
 
       describe "display_password" do
@@ -104,35 +85,7 @@ module PactBroker
             to_return(:status => 200, :body => "respbod", :headers => {'Content-Type' => 'text/foo, blah'})
         end
 
-        let(:request_body) { 'body' }
-
-        it "renders the url template" do
-          expect(PactBroker::Webhooks::Render).to receive(:call).with("http://example.org/hook", pact, verification) do | content, pact, verification, &block |
-            expect(content).to eq "http://example.org/hook"
-            expect(pact).to be pact
-            expect(verification).to be verification
-            expect(block.call("foo bar")).to eq "foo+bar"
-            "http://example.org/hook"
-          end
-          execute
-        end
-
-        context "when the body is a string" do
-          it "renders the body template with the String" do
-            expect(PactBroker::Webhooks::Render).to receive(:call).with('body', pact, verification)
-            execute
-          end
-        end
-
-        context "when the body is an object" do
-          let(:body) { {"foo" => "bar"} }
-          let(:request_body) { '{"foo":"bar"}' }
-
-          it "renders the body template with JSON" do
-            expect(PactBroker::Webhooks::Render).to receive(:call).with(request_body, pact, verification)
-            execute
-          end
-        end
+        let(:request_body) { 'reqbody' }
 
         it "executes the configured request" do
           execute
@@ -141,7 +94,10 @@ module PactBroker
 
         it "logs the request" do
           allow(PactBroker.logger).to receive(:info)
-          expect(PactBroker.logger).to receive(:info).with(/POST.*example.*text.*body/)
+          allow(PactBroker.logger).to receive(:debug)
+          expect(PactBroker.logger).to receive(:info).with(/POST.*example/)
+          expect(PactBroker.logger).to receive(:debug).with(/.*text\/plain/)
+          expect(PactBroker.logger).to receive(:debug).with(/.*reqbody/)
           execute
         end
 
@@ -149,7 +105,7 @@ module PactBroker
           allow(PactBroker.logger).to receive(:info)
           allow(PactBroker.logger).to receive(:debug)
           expect(PactBroker.logger).to receive(:info).with(/response.*200/)
-          expect(PactBroker.logger).to receive(:debug).with(/content-type/)
+          expect(PactBroker.logger).to receive(:debug).with(/text\/foo/)
           expect(PactBroker.logger).to receive(:debug).with(/respbod/)
           execute
         end
@@ -161,11 +117,11 @@ module PactBroker
           end
 
           it "logs the request headers" do
-            expect(logs).to include "Content-Type: text/plain"
+            expect(logs).to include "content-type: text/plain"
           end
 
           it "redacts potentially sensitive headers" do
-            expect(logs).to include "Authorization: **********"
+            expect(logs).to include "authorization: **********"
           end
 
           it "logs the request body" do
@@ -178,7 +134,7 @@ module PactBroker
             end
 
             it "logs the response headers" do
-              expect(logs).to include "Content-Type: text/foo, blah"
+              expect(logs).to include "content-type: text/foo, blah"
             end
 
             it "logs the response body" do
@@ -194,7 +150,7 @@ module PactBroker
             end
 
             it "does not log the response headers" do
-              expect(logs).to_not include "Content-Type: text/foo, blah"
+              expect(logs).to_not include "content-type: text/foo, blah"
             end
 
             it "does not log the response body" do
@@ -224,8 +180,8 @@ module PactBroker
             let(:username) { 'username' }
             let(:password) { 'password' }
 
-            it "logs the username and a starred password" do
-              expect(logs).to include "POST http://username:**********@example.org/hook"
+            it "logs the Authorization header with a starred value" do
+              expect(logs).to include "authorization: **********"
             end
           end
         end
@@ -237,7 +193,7 @@ module PactBroker
               with(
                 basic_auth: [username, password],
                 :headers => {'Content-Type'=>'text/plain'},
-                :body => 'body').
+                :body => 'reqbody').
               to_return(:status => 200, :body => "respbod", :headers => {'Content-Type' => 'text/foo, blah'})
           end
 
@@ -268,7 +224,7 @@ module PactBroker
           let!(:https_request) do
             # webmock will set the request signature scheme to 'https' _only_ if the use_ssl option is set
             stub_request(:post, "https://example.org/hook").
-              with(:headers => {'Content-Type'=>'text/plain'}, :body => 'body').
+              with(:headers => {'Content-Type'=>'text/plain'}, :body => 'reqbody').
               to_return(:status => 200, :body => "respbod", :headers => {'Content-Type' => 'text/foo, blah'})
           end
 
@@ -299,7 +255,7 @@ module PactBroker
           end
 
           it "sets the response on the result" do
-            expect(execute.response).to be_instance_of(Net::HTTPOK)
+            expect(execute.response).to be_instance_of(WebhookResponseWithUtf8SafeBody)
           end
         end
 
@@ -307,7 +263,7 @@ module PactBroker
 
           let!(:http_request) do
             stub_request(:post, "http://example.org/hook").
-              with(:headers => {'Content-Type'=>'text/plain'}, :body => 'body').
+              with(:headers => {'Content-Type'=>'text/plain'}, :body => 'reqbody').
               to_return(:status => 500, :body => "An error")
           end
 
@@ -316,7 +272,7 @@ module PactBroker
           end
 
           it "sets the response on the result" do
-            expect(execute.response).to be_instance_of(Net::HTTPInternalServerError)
+            expect(execute.response).to be_instance_of(WebhookResponseWithUtf8SafeBody)
           end
         end
 
@@ -344,7 +300,7 @@ module PactBroker
           class WebhookTestError < StandardError; end
 
           before do
-            allow(subject).to receive(:http_request).and_raise(WebhookTestError.new("blah"))
+            allow(Net::HTTP).to receive(:start).and_raise(WebhookTestError.new("blah"))
             allow(PactBroker.logger).to receive(:error)
           end
 

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

@@ -1,38 +1,67 @@
-require 'spec_helper'
 require 'pact_broker/domain/webhook'
 
 module PactBroker
-
   module Domain
-
     describe Webhook do
-
       let(:consumer) { Pacticipant.new(name: 'Consumer')}
       let(:provider) { Pacticipant.new(name: 'Provider')}
-      let(:request) { instance_double(PactBroker::Domain::WebhookRequest, execute: nil)}
+      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) { double('options') }
       let(:pact) { double('pact') }
       let(:verification) { double('verification') }
 
-      subject { Webhook.new(request: request, consumer: consumer, provider: provider,) }
+      subject(:webhook) { Webhook.new(request: request_template, consumer: consumer, provider: provider) }
 
       describe "description" do
-        it "returns a description of the webhook" do
-          expect(subject.description).to eq "A webhook for the pact between Consumer and Provider"
+        subject { webhook.description }
+
+        context "with a consumer and provider" do
+          it { is_expected.to eq "A webhook for the pact between Consumer and Provider" }
+        end
+
+        context "with a consumer only" do
+          let(:provider) { nil }
+
+          it { is_expected.to eq "A webhook for all pacts with consumer Consumer" }
+        end
+
+        context "with a provider only" do
+          let(:consumer) { nil }
+
+          it { is_expected.to eq "A webhook for all pacts with provider Provider" }
+        end
+
+        context "with neither a consumer nor a provider" do
+          let(:consumer) { nil }
+          let(:provider) { nil }
+
+          it { is_expected.to eq "A webhook for all pacts" }
         end
       end
 
       describe "execute" do
+        before do
+          allow(request_template).to receive(:build).and_return(request)
+        end
+
+        let(:execute) { subject.execute pact, verification, options }
+
+        it "builds the request" do
+          expect(request_template).to receive(:build).with(pact: pact, verification: verification)
+          execute
+        end
 
         it "executes the request" do
-          expect(request).to receive(:execute).with(pact, verification, options)
-          subject.execute pact, verification, options
+          expect(request).to receive(:execute).with(options)
+          execute
         end
 
         it "logs before and after" do
           allow(PactBroker.logger).to receive(:info)
           expect(PactBroker.logger).to receive(:info).with(/Executing/)
-          subject.execute pact, verification, options
+          execute
         end
       end
     end

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

@@ -964,6 +964,39 @@ module PactBroker
             expect(subject.count).to eq 0
           end
         end
+
+        context "when there is no version for the specified tag" do
+          before do
+            TestDataBuilder.new
+              .create_pact_with_hierarchy("D", "1", "E")
+          end
+
+          subject { Repository.new.find(selectors) }
+
+          context "when the latest tag is specified" do
+            let(:selectors) { [{ pacticipant_name: 'D', latest: true, tag: 'dev' } ] }
+
+            it "raises an error" do
+              expect { subject }.to raise_error Error, /No version of D found/
+            end
+          end
+
+          context "when all tags are specified" do
+            let(:selectors) { [{ pacticipant_name: 'D', tag: 'dev' } ] }
+
+            it "raises an error" do
+              expect { subject }.to raise_error Error, /No version of D found/
+            end
+          end
+
+          context "when no tags are specified" do
+            let(:selectors) { [{ pacticipant_name: 'E', latest: true } ] }
+
+            it "raises an error" do
+              expect { subject }.to raise_error Error, /No version of E found/
+            end
+          end
+        end
       end
     end
   end

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

@@ -70,6 +70,7 @@ module PactBroker
 
       describe "#latest_consumer_version_number" do
         before do
+          PactBroker.configuration.order_versions_by_date = false
           builder = TestDataBuilder.new
           builder
             .create_consumer

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

@@ -697,6 +697,45 @@ module PactBroker
         end
       end
 
+      describe "search_for_latest_pact" do
+        context "when one or more versions of a pact exist without any tags" do
+          before do
+            TestDataBuilder.new
+              .create_consumer("Consumer")
+              .create_provider("Provider")
+              .create_consumer_version("1")
+              .create_pact
+              .create_provider("Another Provider")
+              .create_consumer_version("2")
+              .create_pact
+          end
+
+          context "with both consumer and provider names" do
+            let(:pact) { Repository.new.search_for_latest_pact("Consumer", "Provider") }
+
+            it "returns the latest" do
+              expect(pact.consumer_version.number).to eq("1")
+            end
+          end
+
+          context "with only consumer name" do
+            let(:pact) { Repository.new.search_for_latest_pact("Consumer", nil) }
+
+            it "returns the latest" do
+              expect(pact.consumer_version.number).to eq("2")
+            end
+          end
+
+          context "with only provider name" do
+            let(:pact) { Repository.new.search_for_latest_pact(nil, "Another Provider") }
+
+            it "returns the latest" do
+              expect(pact.consumer_version.number).to eq("2")
+            end
+          end
+        end
+      end
+
       describe "find_latest_pacts" do
         before do
           TestDataBuilder.new
@@ -736,7 +775,6 @@ module PactBroker
 
         it "includes the timestamps - need to update view" do
           pacts = Repository.new.find_latest_pacts
-
           expect(pacts[0].created_at).to be_datey
         end
       end

data/spec/lib/pact_broker/ui/view_models/index_item_spec.rb

@@ -92,7 +92,7 @@ module PactBroker
             let(:webhook_status) { :success }
             its(:webhook_label) { is_expected.to eq "1 day ago" }
             its(:webhook_status) { is_expected.to eq "success" }
-            its(:webhook_url) { is_expected.to end_with "/webhooks/provider/Provider%20Name/consumer/Consumer%20Name/status"}
+            its(:webhook_url) { is_expected.to end_with "/pacts/provider/Provider%20Name/consumer/Consumer%20Name/webhooks/status"}
           end
 
           context "when the webhooks_status is :failure" do

data/spec/lib/pact_broker/verifications/repository_spec.rb

@@ -71,6 +71,42 @@ module PactBroker
         end
       end
 
+      describe "#search_for_latest" do
+        before do
+          TestDataBuilder.new
+            .create_pact_with_hierarchy("Foo", "1", "Bar")
+            .create_verification(provider_version: "2")
+            .create_verification(provider_version: "3", number: 2)
+            .create_provider("Wiffle")
+            .create_pact
+            .create_verification(provider_version: "4")
+        end
+
+        context "with just the consumer name" do
+          subject { Repository.new.search_for_latest("Foo", nil) }
+
+          its(:provider_version_number) { is_expected.to eq "4" }
+        end
+
+        context "with the consumer and provider name" do
+          subject { Repository.new.search_for_latest("Foo", "Bar") }
+
+          its(:provider_version_number) { is_expected.to eq "3" }
+        end
+
+        context "with just the provider name" do
+          subject { Repository.new.search_for_latest(nil, "Bar") }
+
+          its(:provider_version_number) { is_expected.to eq "3" }
+        end
+
+        context "with neither name" do
+          subject { Repository.new.search_for_latest(nil, nil) }
+
+          its(:provider_version_number) { is_expected.to eq "4" }
+        end
+      end
+
       describe "#find_latest_verification_for" do
         context "when there is a revision" do
           before do
@@ -93,6 +129,7 @@ module PactBroker
 
         context "when no tag is specified" do
           before do
+            PactBroker.configuration.order_versions_by_date = false
             TestDataBuilder.new
               .create_provider("Provider1")
               .create_consumer("Consumer1")

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

@@ -10,7 +10,7 @@ module PactBroker
 
       describe "#create" do
         before do
-          allow(PactBroker::Webhooks::Service).to receive(:execute_webhooks)
+          allow(PactBroker::Webhooks::Service).to receive(:trigger_webhooks)
         end
 
         let(:params) { {'success' => true, 'providerApplicationVersion' => '4.5.6'} }
@@ -43,7 +43,7 @@ module PactBroker
 
         it "invokes the webhooks for the verification" do
           verification = create_verification
-          expect(PactBroker::Webhooks::Service).to have_received(:execute_webhooks).with(pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_PUBLISHED)
+          expect(PactBroker::Webhooks::Service).to have_received(:trigger_webhooks).with(pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_PUBLISHED)
         end
       end