pact_broker-client 1.23.0 → 1.24.0

data/lib/pact_broker/client/cli/can_i_deploy_long_desc.txt

@@ -2,7 +2,7 @@ Returns exit code 0 or 1, indicating whether or not the specified application (p
 
 The environment variables PACT_BROKER_BASE_URL, PACT_BROKER_USERNAME and PACT_BROKER_PASSWORD may be used instead of their respective command line options.
 
-There are two ways to use `can-i-deploy`. The first (recommended and most common) approach is to specify just the application version you want to deploy and let the Pact Broker work out the dependencies for you. The second approach is to specify each application version explicitly. This would generally only be used if there were limitations that stopped you being able to use the first approach.
+There are two ways to use `can-i-deploy`. The first (recommended and most commonly used) approach is to specify just the application version you want to deploy and let the Pact Broker work out the dependencies for you. The second approach is to specify each application version explicitly. This would generally only be used if there were limitations that stopped you being able to use the first approach.
 
 #### Specifying an application version
 
@@ -13,12 +13,13 @@ To specify an application (pacticipant) version you need to provide:
     * `--version VERSION` to specify a known application version (recommended)
     * `--latest` to specify the latest version
     * `--latest TAG` to specify the latest version that has a particular tag
+    * `--all TAG` to specify all the versions that have a particular tag (eg. "all prod" versions). This would be used when ensuring you have backwards compatiblity with all production mobile clients for a provider. Note, when using this option, you need to specify dependency explicitly (see the second usage option).
 
 Using a specific version is the easiest way to ensure you get an accurate response that won't be affected by race conditions.
 
 #### Recommended usage - allowing the Pact Broker to automatically determine the dependencies
 
-If you would like the Pact Broker to calculate the dependencies for you when you want to deploy an application into a given environment, you will need to let the Broker know what application versions are in that environment. To do this, the relevant application version resource in the Broker will need to be "tagged" with the name of the environment during the deployment process:
+Prerequisite: if you would like the Pact Broker to calculate the dependencies for you when you want to deploy an application into a given environment, you will need to let the Broker know which version of each application is in that environment. To do this, the relevant application version resource in the Broker will need to be "tagged" with the name of the environment during the deployment process:
 
     $ pact-broker create-version-tag --pacticipant Foo --version 173153ae0 --tag test
 
@@ -56,13 +57,20 @@ Can I deploy the latest version of the application Foo that has the tag "test" t
 
 
 
-#### Alternate usage - specifying all dependencies explicitly
+#### Alternate usage - specifying dependencies explicitly
 
-If you are unable to use tags, or there is some other limitation that stops you from using the recommended approach, you can specify each of the application versions explictly. You can specify as many application versions as you like.
+If you are unable to use tags, or there is some other limitation that stops you from using the recommended approach, you can specify one or more of the dependencies explictly. You must also do this if you want to use the `--all TAG` option for any of the pacticipants.
 
-    $ pact-broker can-i-deploy --pacticipant PACTICIPANT_1 [--version VERSION_1 | --latest [TAG]] \
-                               --pacticipant PACTICIPANT_2 [--version VERSION_2 | --latest [TAG_2]] \
-                               --to ENVIRONMENT \
+You can specify as many application versions as you like, and you can even specify multiple versions of the same application (repeat the `--pacticipant` name and supply a different version.)
+
+You can use explictly declared dependencies with or without the `--to ENVIRONMENT`. For example, if you declare two (or more) application versions with no `--to ENVIRONMENT`, then only the applications you specify will be taken into account when determining if it is safe to deploy. If you declare two (or more) application versions _as well as_ a `--to ENVIRONMENT`, then the Pact Broker will work out what integrations your declared applications will have in that environment when determining if it safe to deploy. When using this script for a production release, and you are using tags, it is always the most future-proof option to use the `--to` if possible, as it will catch any newly added consumers or providers.
+
+If you are finding that your dependencies are not being automatically included when you supply multiple pacticipant versions, please upgrade to the latest version of the Pact Broker, as this is a more recently added feature.
+
+
+    $ pact-broker can-i-deploy --pacticipant PACTICIPANT_1 [--version VERSION_1 | --latest [TAG_1] | --all TAG_1] \
+                               --pacticipant PACTICIPANT_2 [--version VERSION_2 | --latest [TAG_2] | --all TAG_2] \
+                               [--to ENVIRONMENT] \
                                --broker-base-url BROKER_BASE_URL
 
 Examples:
@@ -82,3 +90,11 @@ Can I deploy the latest version of Foo with tag "master" and the latest version
                                --pacticipant Bar --latest master \
                                --broker-base-url BROKER_BASE_URL
 
+
+Mobile provider use case - can I deploy version b80e7b1b of Bar, all versions of Foo with tag "prod", and the latest version tagged "prod" of any other automatically calculated dependencies together? (Eg. where Bar is a provider and Foo is a mobile consumer with multiple versions in production, and Bar also has its own providers it needs to be compatible with.)
+
+
+    $ pact-broker can-i-deploy --pacticipant Bar --version b80e7b1b \
+                               --pacticipant Foo --all prod \
+                               --to prod \
+                               --broker-base-url BROKER_BASE_URL

data/lib/pact_broker/client/cli/create_or_update_webhook_long_desc.txt

@@ -0,0 +1 @@
+Create a curl command that executes the request that you want your webhook to execute, then replace "curl" with "pact-broker create-or-update-webhook" and add the consumer, provider, event types and broker details. Note that the URL must be the first parameter when executing create-or-update-webhook and a uuid must also be provided. You can generate a valid UUID by using the `generate-uuid` command.

data/lib/pact_broker/client/cli/custom_thor.rb

@@ -64,6 +64,36 @@ module PactBroker
             end
             new_argv.flatten
           end
+
+          # If you try and generate a uuid, and the PACT_BROKER_... env vars are set, it will cause
+          # generate_uuid to be called with parameters that it doesn't declare, and hence, throw an error.
+          # This is a dirty hack that stops that happening!
+          def self.ignored_and_hidden_potential_options_from_environment_variables
+            method_option :broker_base_url, hide: true
+            method_option :broker_username, hide: true
+            method_option :broker_password, hide: true
+            method_option :broker_token, hide: true
+          end
+
+          def self.shared_options_for_webhook_commands
+            method_option :request, banner: "METHOD", aliases: "-X", desc: "HTTP method", required: true
+            method_option :header, aliases: "-H", type: :array, desc: "Header"
+            method_option :data, aliases: "-d", desc: "Data"
+            method_option :user, aliases: "-u", desc: "Basic auth username and password eg. username:password"
+            method_option :consumer, desc: "Consumer name"
+            method_option :provider, desc: "Provider name"
+            method_option :broker_base_url, required: true, aliases: "-b", desc: "The base URL of the Pact Broker"
+            method_option :broker_username, desc: "Pact Broker basic auth username"
+            method_option :broker_password, aliases: "-p", desc: "Pact Broker basic auth password"
+            method_option :broker_token, aliases: "-k", desc: "Pact Broker bearer token"
+            method_option :description, desc: "The description of the webhook"
+            method_option :contract_content_changed, type: :boolean, desc: "Trigger this webhook when the pact content changes"
+            method_option :contract_published, type: :boolean, desc: "Trigger this webhook when a pact is published"
+            method_option :provider_verification_published, type: :boolean, desc: "Trigger this webhook when a provider verification result is published"
+            method_option :provider_verification_failed, type: :boolean, desc: "Trigger this webhook when a failed provider verification result is published"
+            method_option :provider_verification_succeeded, type: :boolean, desc: "Trigger this webhook when a successful provider verification result is published"
+            method_option :verbose, aliases: "-v", type: :boolean, default: false, required: false, desc: "Verbose output. Default: false"
+          end
         end
       end
     end

data/lib/pact_broker/client/version.rb

@@ -1,5 +1,5 @@
 module PactBroker
   module Client
-    VERSION = '1.23.0'
+    VERSION = '1.24.0'
   end
 end

data/lib/pact_broker/client/webhooks/create.rb

@@ -8,8 +8,8 @@ module PactBroker
   module Client
     module Webhooks
       class Create
-
         WEBHOOKS_WITH_OPTIONAL_PACTICICPANTS_NOT_SUPPORTED = "This version of the Pact Broker requires that both consumer and provider are specified for a webhook. Please upgrade your broker to >= 2.22.0 to create a webhook with optional consumer and provider."
+        CREATING_WEBHOOK_WITH_UUID_NOT_SUPPORTED = "This version of the Pact Broker does not support creating webhooks with a specified UUID. Please upgrade your broker to >= 2.49.0 or use the create-webhook command."
 
         attr_reader  :params, :pact_broker_base_url, :basic_auth_options, :verbose
 
@@ -24,7 +24,7 @@ module PactBroker
         end
 
         def call
-          if params.consumer && params.provider
+          if params.consumer && params.provider && !params.uuid
             create_webhook_with_consumer_and_provider
           else
             create_webhook_with_optional_consumer_and_provider
@@ -41,10 +41,19 @@ module PactBroker
         end
 
         def create_webhook_with_optional_consumer_and_provider
-          webhook_entity = index_link.get!._link("pb:webhooks").post(request_body_with_optional_consumer_and_provider)
+          index_entity = index_link.get!
+          if params.uuid
+            if index_entity.can?("pb:webhook")
+              webhook_entity = index_entity._link("pb:webhook").expand(uuid: params.uuid).put(request_body_with_optional_consumer_and_provider)
+            else
+              return error_result(CREATING_WEBHOOK_WITH_UUID_NOT_SUPPORTED)
+            end
+          else
+            webhook_entity = index_entity._link("pb:webhooks").post(request_body_with_optional_consumer_and_provider)
+          end
 
           if webhook_entity.response.status == 405
-            raise PactBroker::Client::Error.new(WEBHOOKS_WITH_OPTIONAL_PACTICICPANTS_NOT_SUPPORTED)
+            return error_result(WEBHOOKS_WITH_OPTIONAL_PACTICICPANTS_NOT_SUPPORTED)
           end
 
           handle_response(webhook_entity)
@@ -62,7 +71,7 @@ module PactBroker
               username: params.username,
               password: params.password
             }
-          }
+          }.tap { |req| req[:description] = params.description if params.description }
         end
 
         def request_body_with_optional_consumer_and_provider
@@ -87,7 +96,7 @@ module PactBroker
           if webhook_entity.success?
             success_result(webhook_entity)
           else
-            error_result(webhook_entity)
+            http_error_result(webhook_entity)
           end
         end
 
@@ -95,7 +104,11 @@ module PactBroker
           CommandResult.new(true, "Webhook #{webhook_entity._link('self').title_or_name.inspect} created")
         end
 
-        def error_result(webhook_entity)
+        def error_result(message)
+          CommandResult.new(false, message)
+        end
+
+        def http_error_result(webhook_entity)
           CommandResult.new(false, "Error creating webhook. response status=#{webhook_entity.response.status} body=#{webhook_entity.response.raw_body}")
         end
 

data/spec/lib/pact_broker/client/cli/broker_create_or_update_webhook_spec.rb

@@ -0,0 +1,23 @@
+require 'pact_broker/client/cli/broker'
+require 'pact_broker/client/webhooks/create'
+
+module PactBroker
+  module Client
+    module CLI
+      describe Broker do
+        describe "create_or_update_webhook" do
+
+          let(:broker) { Broker.new }
+
+          subject { broker.create_or_update_webhook "http://webhook" }
+
+          it "calls PactBroker::Client::Webhooks::Create with the webhook params" do
+            expect(broker).to receive(:run_webhook_commands).with("http://webhook")
+
+            subject
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/pact_broker/client/cli/broker_create_webhook_spec.rb

@@ -6,184 +6,16 @@ module PactBroker
     module CLI
       describe Broker do
         describe "create_webhook" do
-          before do
-            allow($stdout).to receive(:puts)
-            allow(PactBroker::Client::Webhooks::Create).to receive(:call).and_return(command_result)
-            broker.options = OpenStruct.new(options_hash)
-          end
 
           let(:broker) { Broker.new }
-          let(:data) { 'data' }
-          let(:user) { "username:password" }
-          let(:command_result) { double('command result', success: success, message: 'message') }
-          let(:success) { true }
-          let(:header) { ["Foo: bar", "Bar: foo"] }
-
-          let(:options_hash) do
-            {
-              request: "POST",
-              header: header,
-              data: data,
-              user: user,
-              consumer: "consumer",
-              provider: "provider",
-              broker_base_url: "http://broker",
-              broker_username: "username",
-              broker_password: "password",
-              broker_token: "token",
-              contract_content_changed: true,
-              verbose: true
-            }
-          end
-
-          let(:expected_params) do
-            {
-              http_method: "POST",
-              url: "http://webhook",
-              headers: { "Foo" => "bar", "Bar" => "foo"},
-              username: "username",
-              password: "password",
-              body: "data",
-              consumer: "consumer",
-              provider: "provider",
-              events: ["contract_content_changed"]
-            }.tap { |it| Pact::Fixture.add_fixture(:create_webhook_params, it) }
-          end
 
-          subject {  broker.create_webhook "http://webhook" }
+          subject { broker.create_webhook "http://webhook" }
 
           it "calls PactBroker::Client::Webhooks::Create with the webhook params" do
-            expect(PactBroker::Client::Webhooks::Create).to receive(:call) do | params, _, _ |
-              expect(params).to eq expected_params
-              command_result
-            end
-            subject
-          end
+            expect(broker).to receive(:run_webhook_commands).with("http://webhook")
 
-          it "calls PactBroker::Client::Webhooks::Create with pact broker details" do
-            expect(PactBroker::Client::Webhooks::Create).to receive(:call) do | _, broker_base_url, pact_broker_client_options |
-              expect(broker_base_url).to eq "http://broker"
-              expect(pact_broker_client_options).to eq(basic_auth: { username: "username", password: "password"}, token: "token", verbose: true)
-              command_result
-            end
             subject
           end
-
-          context "when neither event type is selected" do
-            before do
-              options_hash.delete(:contract_content_changed)
-              broker.options = OpenStruct.new(options_hash)
-            end
-
-            it "raises an error" do
-              expect { subject }.to raise_error PactBroker::Client::Error, /You must select at least one/
-            end
-          end
-
-          context "with no basic auth" do
-            before do
-              options_hash.delete(:broker_username)
-              options_hash.delete(:broker_password)
-              broker.options = OpenStruct.new(options_hash)
-            end
-
-            it "calls Webhooks::Create without basic auth" do
-              expect(PactBroker::Client::Webhooks::Create).to receive(:call) do | _, _, pact_broker_client_options |
-                expect(pact_broker_client_options).to eq(token: "token", verbose: true)
-                command_result
-              end
-              subject
-            end
-          end
-
-          context "when there are no headers specified" do
-            let(:header) { nil }
-
-            it "calls Webhooks::Create with an empty hash of headers" do
-              expect(PactBroker::Client::Webhooks::Create).to receive(:call) do | params, _, _ |
-                expect(params[:headers]).to eq({})
-                command_result
-              end
-              subject
-            end
-          end
-
-          context "when data is nil" do
-            let(:data) { nil }
-
-            it "alls Webhooks::Create with a nil body" do
-              expect(PactBroker::Client::Webhooks::Create).to receive(:call) do | params, _, _ |
-                expect(params[:body]).to be nil
-                command_result
-              end
-              subject
-            end
-          end
-
-          context "when a file reference is passed for the data" do
-            before do
-              FileUtils.mkdir_p "tmp"
-              File.open("tmp/body.json", "w") { |file| file << "file" }
-            end
-
-            let(:data) { "@tmp/body.json" }
-
-            it "reads the file and passes it in to the Webhooks::Create call" do
-              expect(PactBroker::Client::Webhooks::Create).to receive(:call) do | params, _, _ |
-                expect(params[:body]).to eq "file"
-                command_result
-              end
-              subject
-            end
-
-            context "when the file is not found" do
-
-              let(:data) { "@doesnotexist.json" }
-
-              it "raises a PactBroker::Client::Error" do
-                expect { subject }.to raise_error PactBroker::Client::Error, /Couldn't read data from file/
-              end
-            end
-
-            context "when successful" do
-              it "prints the message to stdout" do
-                expect($stdout).to receive(:puts).with('message')
-                subject
-              end
-            end
-
-            context "when not successful" do
-              let(:success) { false }
-
-              it "prints the message to stderr" do
-                expect($stdout).to receive(:puts).with('message')
-                begin
-                  subject
-                rescue SystemExit
-                end
-              end
-
-              it "exits with code 1" do
-                exited_with_error = false
-                begin
-                  subject
-                rescue SystemExit
-                  exited_with_error = true
-                end
-                expect(exited_with_error).to be true
-              end
-            end
-
-            context "when a PactBroker::Client::Error is raised" do
-              before do
-                allow(PactBroker::Client::Webhooks::Create).to receive(:call).and_raise(PactBroker::Client::Error, "foo")
-              end
-
-              it "raises a WebhookCreationError which does not show an ugly stack trace" do
-                expect { subject }.to raise_error(WebhookCreationError, /foo/)
-              end
-            end
-          end
         end
       end
     end

data/spec/lib/pact_broker/client/cli/broker_run_webhook_commands_spec.rb

@@ -0,0 +1,210 @@
+require 'pact_broker/client/cli/broker'
+require 'pact_broker/client/webhooks/create'
+
+module PactBroker
+  module Client
+    module CLI
+      describe Broker do
+        describe "run_webhook_commands" do
+          before do
+            allow($stdout).to receive(:puts)
+            allow(PactBroker::Client::Webhooks::Create).to receive(:call).and_return(command_result)
+            broker.options = OpenStruct.new(options_hash)
+          end
+
+          let(:broker) { Broker.new }
+          let(:data) { 'data' }
+          let(:user) { "username:password" }
+          let(:command_result) { double('command result', success: success, message: 'message') }
+          let(:success) { true }
+          let(:header) { ["Foo: bar", "Bar: foo"] }
+
+          let(:options_hash) do
+            {
+              uuid: '9999',
+              request: "POST",
+              header: header,
+              data: data,
+              user: user,
+              consumer: "consumer",
+              provider: "provider",
+              broker_base_url: "http://broker",
+              broker_username: "username",
+              broker_password: "password",
+              broker_token: "token",
+              contract_content_changed: true,
+              verbose: true
+            }
+          end
+
+          let(:expected_params) do
+            {
+              uuid: '9999',
+              http_method: "POST",
+              url: "http://webhook",
+              headers: { "Foo" => "bar", "Bar" => "foo"},
+              username: "username",
+              password: "password",
+              body: "data",
+              consumer: "consumer",
+              provider: "provider",
+              events: ["contract_content_changed"]
+            }.tap { |it| Pact::Fixture.add_fixture(:create_webhook_params, it) }
+          end
+
+          subject { broker.run_webhook_commands "http://webhook" }
+
+          it "calls PactBroker::Client::Webhooks::Create with the webhook params" do
+            expect(PactBroker::Client::Webhooks::Create).to receive(:call) do | params, _, _ |
+              expect(params).to eq expected_params
+              command_result
+            end
+            subject
+          end
+
+          it "calls PactBroker::Client::Webhooks::Create with pact broker details" do
+            expect(PactBroker::Client::Webhooks::Create).to receive(:call) do | _, broker_base_url, pact_broker_client_options |
+              expect(broker_base_url).to eq "http://broker"
+              expect(pact_broker_client_options).to eq(basic_auth: { username: "username", password: "password"}, token: "token", verbose: true)
+              command_result
+            end
+            subject
+          end
+
+          context "when neither event type is selected" do
+            before do
+              options_hash.delete(:contract_content_changed)
+              broker.options = OpenStruct.new(options_hash)
+            end
+
+            it "raises an error" do
+              expect { subject }.to raise_error WebhookCreationError, /You must specify at least one/
+            end
+          end
+
+          context "with no basic auth" do
+            before do
+              options_hash.delete(:broker_username)
+              options_hash.delete(:broker_password)
+              broker.options = OpenStruct.new(options_hash)
+            end
+
+            it "calls Webhooks::Create without basic auth" do
+              expect(PactBroker::Client::Webhooks::Create).to receive(:call) do | _, _, pact_broker_client_options |
+                expect(pact_broker_client_options).to eq(token: "token", verbose: true)
+                command_result
+              end
+              subject
+            end
+          end
+
+          context "when there are no headers specified" do
+            let(:header) { nil }
+
+            it "calls Webhooks::Create with an empty hash of headers" do
+              expect(PactBroker::Client::Webhooks::Create).to receive(:call) do | params, _, _ |
+                expect(params[:headers]).to eq({})
+                command_result
+              end
+              subject
+            end
+          end
+
+          context "when data is nil" do
+            let(:data) { nil }
+
+            it "alls Webhooks::Create with a nil body" do
+              expect(PactBroker::Client::Webhooks::Create).to receive(:call) do | params, _, _ |
+                expect(params[:body]).to be nil
+                command_result
+              end
+              subject
+            end
+          end
+
+          context "when a uuid is provided" do
+            before do
+              options_hash.merge!(uuid: '9999')
+              expected_params.merge!(uuid: '9999')
+
+              broker.options = OpenStruct.new(options_hash)
+            end
+
+            it "calls PactBroker::Client::Webhooks::Create with uuid in params" do
+              expect(PactBroker::Client::Webhooks::Create).to receive(:call) do | params, _, _ |
+                expect(params).to eq expected_params
+                command_result
+              end
+              subject
+            end
+          end
+
+          context "when a file reference is passed for the data" do
+            before do
+              FileUtils.mkdir_p "tmp"
+              File.open("tmp/body.json", "w") { |file| file << "file" }
+            end
+
+            let(:data) { "@tmp/body.json" }
+
+            it "reads the file and passes it in to the Webhooks::Create call" do
+              expect(PactBroker::Client::Webhooks::Create).to receive(:call) do | params, _, _ |
+                expect(params[:body]).to eq "file"
+                command_result
+              end
+              subject
+            end
+
+            context "when the file is not found" do
+
+              let(:data) { "@doesnotexist.json" }
+
+              it "raises a WebhookCreationError" do
+                expect { subject }.to raise_error WebhookCreationError, /Couldn't read data from file/
+              end
+            end
+
+            context "when successful" do
+              it "prints the message to stdout" do
+                expect($stdout).to receive(:puts).with('message')
+                subject
+              end
+            end
+
+            context "when not successful" do
+              let(:success) { false }
+
+              it "prints the message to stderr" do
+                expect($stdout).to receive(:puts).with('message')
+                begin
+                  subject
+                rescue SystemExit
+                end
+              end
+
+              it "exits with code 1" do
+                exited_with_error = false
+                begin
+                  subject
+                rescue SystemExit
+                  exited_with_error = true
+                end
+                expect(exited_with_error).to be true
+              end
+            end
+
+            context "when a PactBroker::Client::Error is raised" do
+              before do
+                allow(PactBroker::Client::Webhooks::Create).to receive(:call).and_raise(PactBroker::Client::Error, "foo")
+              end
+
+              it "raises a WebhookCreationError which does not show an ugly stack trace" do
+                expect { subject }.to raise_error(WebhookCreationError, /foo/)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end