pact_broker-client 1.41.0 → 1.46.0

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

@@ -32,7 +32,7 @@ module PactBroker::Client::CLI
             ["spec/support/cli_test_pacts/foo.json"],
             { number: "1.2.3", tags: [], version_required: false },
             {},
-            {}
+            { pact_broker_base_url: 'http://pact-broker' }
           )
           invoke_broker
         end

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

@@ -33,7 +33,8 @@ module PactBroker
               broker_username: "username",
               broker_password: "password",
               contract_content_changed: true,
-              verbose: true
+              verbose: true,
+              team_uuid: "1234"
             }
           end
 
@@ -49,7 +50,8 @@ module PactBroker
               body: "data",
               consumer: "consumer",
               provider: "provider",
-              events: ["contract_content_changed"]
+              events: ["contract_content_changed"],
+              team_uuid: "1234"
             }.tap { |it| Pact::Fixture.add_fixture(:create_webhook_params, it) }
           end
 
@@ -66,7 +68,7 @@ module PactBroker
           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"}, verbose: true)
+              expect(pact_broker_client_options).to eq(pact_broker_base_url: 'http://broker', basic_auth: { username: "username", password: "password"}, verbose: true)
               command_result
             end
             subject
@@ -92,7 +94,7 @@ module PactBroker
 
             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(verbose: true)
+                expect(pact_broker_client_options).to eq(verbose: true, pact_broker_base_url: 'http://broker')
                 command_result
               end
               subject
@@ -110,7 +112,7 @@ module PactBroker
             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(verbose: true, token: "token")
+                expect(pact_broker_client_options).to eq(verbose: true, token: "token", pact_broker_base_url: 'http://broker')
                 command_result
               end
               subject

data/spec/lib/pact_broker/client/deployments/record_deployment_spec.rb

@@ -0,0 +1,204 @@
+require 'pact_broker/client/deployments/record_deployment'
+
+module PactBroker
+  module Client
+    module Deployments
+      describe RecordDeployment do
+        describe ".call" do
+          let(:broker_base_url) { "http://broker" }
+          let(:index_body_hash) do
+            {
+              _links: {
+                "pb:environments" => { href: "#{broker_base_url}/environments" },
+                "pb:pacticipant-version" => {
+                  href: "#{broker_base_url}/pacticipants/{pacticipant}/versions/{version}"
+                }
+              }
+            }
+          end
+          let(:version_body_hash) do
+            {
+              "_links" => {
+                "pb:record-deployment" => [
+                  {
+                    name: "test",
+                    href: "#{broker_base_url}/record-deployment"
+                  }
+                ]
+              }
+            }
+          end
+          let(:environments_body_hash) do
+            {
+              "_links" => {
+                "pb:environments" => [
+                  {
+                    "name" => "test",
+                    "href" => ""
+                  }
+                ]
+              }
+
+            }
+          end
+          let(:record_deployment_body_hash) do
+            { "some" => "response" }
+          end
+          let!(:index_request) do
+            stub_request(:get, broker_base_url).to_return(status: 200, body: index_body_hash.to_json, headers: { "Content-Type" => "application/hal+json" }  )
+          end
+          let!(:version_request) do
+            stub_request(:get, broker_base_url + "/pacticipants/Foo/versions/1").to_return(status: 200, body: version_body_hash.to_json, headers: { "Content-Type" => "application/hal+json" }  )
+          end
+
+          let!(:environments_request) do
+            stub_request(:get, "http://broker/environments").
+              with(headers: { 'Accept'=>'application/hal+json' }).
+              to_return(status: 200, body: environments_body_hash.to_json, headers: { "Content-Type" => "application/hal+json" })
+          end
+          let!(:record_deployment_request) do
+            stub_request(:post, "http://broker/record-deployment").
+              to_return(status: 200, body: record_deployment_body_hash.to_json , headers: {})
+          end
+
+          let(:target) { "blue" }
+
+          let(:params) do
+            {
+              pacticipant_name: "Foo",
+              version_number: "1",
+              environment_name: "test",
+              target: target
+            }
+          end
+
+          let(:options) do
+            {
+              output: output,
+              verbose: true
+            }
+          end
+          let(:output) { "text" }
+          let(:pact_broker_client_options) { { pact_broker_base_url: broker_base_url} }
+
+          subject { RecordDeployment.call(params, options, pact_broker_client_options) }
+
+          context "when the pb:environments relation does not exist" do
+            let(:index_body_hash) do
+              {
+                "_links" => {}
+              }
+            end
+            it "returns an error response" do
+              expect(subject.success).to be false
+              expect(subject.message).to include "does not support"
+            end
+          end
+
+          context "when the specified version does not exist" do
+            let!(:version_request) do
+              stub_request(:get, broker_base_url + "/pacticipants/Foo/versions/1").to_return(status: 404)
+            end
+
+            it "returns an error response" do
+              expect(subject.success).to be false
+              expect(subject.message).to include "Foo version 1 not found"
+            end
+          end
+
+          context "when the pacticipant version does not support recording deployments" do
+            let(:version_body_hash) do
+              {
+                "_links" => {}
+              }
+            end
+            it "returns an error response" do
+              expect(subject.success).to be false
+              expect(subject.message).to include "does not support"
+            end
+          end
+
+          context "when the specified environment is not available for recording a deployment" do
+            let(:version_body_hash) do
+              {
+                "_links" => {
+                  "pb:record-deployment" => [
+                    {
+                      "name" => "prod",
+                      "href" => ""
+                    }
+                  ]
+                }
+              }
+            end
+
+            context "when the environment does not exist" do
+              let(:environments_body_hash) do
+                {
+                  "_links" => {
+                    "pb:environments" => [
+                      {
+                        "name" => "prod",
+                        "href" => ""
+                      },{
+                        "name" => "uat",
+                        "href" => ""
+                      }
+                    ]
+                  }
+                }
+              end
+
+              it "returns an error response" do
+                expect(subject.success).to be false
+                expect(subject.message).to include "No environment found with name 'test'. Available options: prod"
+              end
+            end
+
+            context "when the environment does exist" do
+              it "returns an error response" do
+                expect(subject.success).to be false
+                expect(subject.message).to include "Environment 'test' is not an available option for recording a deployment of Foo. Available options: prod"
+              end
+            end
+          end
+
+          context "when the output is json" do
+            let(:output) { "json" }
+
+            it "returns the JSON payload" do
+              expect(JSON.parse(subject.message)).to eq record_deployment_body_hash
+            end
+          end
+
+          context "when the response headers contain Pactflow" do
+            before do
+              allow_any_instance_of(RecordDeployment).to receive(:check_if_command_supported)
+              allow_any_instance_of(RecordDeployment).to receive(:check_environment_exists)
+              allow_any_instance_of(RecordDeployment).to receive(:record_action)
+              allow_any_instance_of(RecordDeployment).to receive(:index_resource).and_return(index_resource)
+            end
+
+            let(:response_headers) { { "X-Pactflow-Sha" => "abc" } }
+
+            let(:index_resource) do
+              double('PactBroker::Client::Hal::Entity', response: double('response', headers: response_headers) )
+            end
+
+            it "indicates the API was Pactflow" do
+              expect(subject.message).to include "Recorded deployment of Foo version 1 to test environment (target blue) in Pactflow"
+            end
+
+            context "when target is nil" do
+              let(:target) { nil }
+
+              it "does not include the target in the result message" do
+                expect(subject.message).to include "Recorded deployment of Foo version 1 to test environment in"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/pact_broker/client/deployments/record_support_ended_spec.rb

@@ -0,0 +1,208 @@
+require 'pact_broker/client/deployments/record_support_ended'
+
+module PactBroker
+  module Client
+    module Deployments
+      describe RecordSupportEnded do
+        let(:params) do
+          {
+            pacticipant_name: "Foo",
+            version_number: version_number,
+            environment_name: "test"
+          }
+        end
+        let(:version_number) { "2" }
+        let(:output) { "text" }
+        let(:options) { { output: output, verbose: true } }
+        let(:pact_broker_base_url) { "http://broker" }
+        let(:pact_broker_client_options) { { pact_broker_base_url: pact_broker_base_url } }
+
+        let(:index_body_hash) do
+          {
+            _links: {
+              :'pb:environments' => {
+                href: environments_url
+              },
+              :'pb:pacticipant' => {
+                href: pacticipant_url
+              }
+            }
+          }
+        end
+
+        let(:environments_hash) do
+          {
+            _links: {
+              :'pb:environments' => [
+                {
+                  name: "test",
+                  href: test_environment_url
+                }
+              ]
+            }
+          }
+        end
+
+        let(:environment_hash) do
+          {
+            _links: {
+              :'pb:currently-supported-versions' => {
+                href: currently_supported_versions_url
+              }
+            }
+          }
+        end
+
+        let(:supported_versions_hash) do
+          {
+            _embedded: {
+              releasedVersions: [
+                {
+                  number: "customer-1",
+                  _links: {
+                    self: {
+                      href: supported_version_url_1
+                    }
+                  }
+                },
+                {
+                  number: returned_target_2,
+                  _links: {
+                    self: {
+                      href: supported_version_url_2
+                    }
+                  }
+                }
+              ]
+            }
+          }
+        end
+
+        let(:returned_target_2) { nil }
+        let(:supported_version_hash) do
+          {
+            _embedded: {
+              version: {
+                number: "2"
+              }
+            }
+          }
+        end
+
+        let(:environments_url) { "#{webmock_base_url}/environments" }
+        let(:test_environment_url) { "#{webmock_base_url}/environments/1234" }
+        let(:currently_supported_versions_url) { "#{webmock_base_url}/currently-deployed-versions" }
+        let(:supported_version_url_1) { "#{webmock_base_url}/deployed-version-1" }
+        let(:supported_version_url_2) { "#{webmock_base_url}/deployed-version-2" }
+        let(:pacticipant_url) { "#{webmock_base_url}/pacticipant" }
+
+        let(:webmock_base_url) { "http://broker" }
+
+        let!(:index_request) do
+          stub_request(:get, "http://broker").to_return(status: 200, body: index_body_hash.to_json, headers: { "Content-Type" => "application/hal+json" }  )
+        end
+
+        let!(:environments_request) do
+          stub_request(:get, "http://broker/environments").to_return(status: 200, body: environments_hash.to_json, headers: { "Content-Type" => "application/hal+json" }  )
+        end
+
+        let!(:environment_request) do
+          stub_request(:get, test_environment_url).to_return(status: 200, body: environment_hash.to_json, headers: { "Content-Type" => "application/hal+json" }  )
+        end
+
+        let!(:supported_versions_request) do
+          stub_request(:get, currently_supported_versions_url + "?pacticipant=Foo&version=2").to_return(status: 200, body: supported_versions_hash.to_json, headers: { "Content-Type" => "application/hal+json" }  )
+        end
+
+        let!(:supported_version_patch_request_1) do
+          stub_request(:patch, supported_version_url_1).with(body: { currentlySupported: false}.to_json).to_return(status: 200, body: supported_version_hash.to_json, headers: { "Content-Type" => "application/hal+json" })
+        end
+
+        let!(:supported_version_patch_request_2) do
+          stub_request(:patch, supported_version_url_2).with(body: { currentlySupported: false}.to_json).to_return(status: 200, body: supported_version_hash.to_json, headers: { "Content-Type" => "application/hal+json" })
+        end
+
+        let!(:pacticipant_request) do
+          stub_request(:get, pacticipant_url).to_return(status: pacticipant_request_status, body: {}.to_json, headers: { "Content-Type" => "application/hal+json" })
+        end
+
+        let(:pacticipant_request_status) { 200 }
+
+        subject { RecordSupportEnded.call(params, options, pact_broker_client_options) }
+
+        its(:success) { is_expected.to eq true }
+        its(:message) { is_expected.to include "Recorded support ended for Foo version 2 in test environment in the Pact Broker" }
+
+        context "when there is no pb:environments relation in the index" do
+          let(:index_body_hash) do
+            {
+              _links: {}
+            }
+          end
+
+          its(:success) { is_expected.to be false }
+          its(:message) { is_expected.to include "support" }
+        end
+
+        context "when output is json" do
+          let(:output) { "json" }
+          its(:message) { is_expected.to eq [supported_version_hash, supported_version_hash].to_json }
+        end
+
+        context "when there is an error returned from one of the supported version updates (there should only ever be one supported version, but testing just for the sake of it)" do
+          let!(:supported_version_patch_request_2) do
+            stub_request(:patch, supported_version_url_2).to_return(status: 400, body: { errors: { foo: ["some error"]}}.to_json, headers: { "Content-Type" => "application/hal+json" })
+          end
+
+          let(:returned_target_2) { "customer-1" }
+
+          its(:success) { is_expected.to be false }
+          its(:message) { is_expected.to include "Recorded" }
+          its(:message) { is_expected.to include "some error" }
+        end
+
+        context "when there is no currently-deployed-versions relation in the environment resource" do
+          let(:environment_hash) do
+            {
+              _links: {}
+            }
+          end
+
+          its(:success) { is_expected.to be false }
+          its(:message) { is_expected.to include "support" }
+        end
+
+        context "when there is no matching supported versions" do
+          let(:supported_versions_hash) do
+            {
+              _embedded: {
+                releasedVersions: []
+              }
+            }
+          end
+
+          let(:expected_message) { "Foo version 2 is not currently released in test environment. Cannot record support ended." }
+
+          its(:success) { is_expected.to be false }
+          its(:message) { is_expected.to include expected_message }
+
+          context "when there are no supported versions for the pacticipant" do
+            context "when the pacticipant does not exist" do
+              let(:pacticipant_request_status) { 404 }
+
+              its(:success) { is_expected.to be false }
+              its(:message) { is_expected.to include "No pacticipant with name 'Foo' found" }
+            end
+          end
+
+          context "when output is json" do
+            let(:output) { "json" }
+
+            its(:message) { is_expected.to eq({ error: { message: expected_message } }.to_json) }
+          end
+        end
+
+      end
+    end
+  end
+end