pact_broker-client 1.75.3 → 1.75.4

data/spec/service_providers/pact_broker_client_matrix_ignore_spec.rb

@@ -1,98 +0,0 @@
-require_relative 'pact_helper'
-require 'pact_broker/client/can_i_deploy'
-
-module PactBroker::Client
-  describe Matrix, :pact => true do
-
-    include_context "pact broker"
-
-    describe "can-i-deploy ignoring a pacticipant version" do
-      let(:matrix_response_body) { matrix }
-      let(:matrix) do
-        {
-          "summary" => {
-            "deployable" => true,
-            "ignored" => 1
-          },
-          "notices" => Pact.each_like("text" => "some notice", "type" => "info"),
-          "matrix" => [
-            {
-              "consumer" => {
-                "name" => "Foo",
-                "version" => {
-                  "number" => "1.2.3"
-                }
-              },
-              "provider" => {
-                "name" => "Bar",
-                "version" => {
-                  "number" => "4.5.6"
-                }
-              },
-              "verificationResult" => {
-                "success" => true,
-                "_links" => {
-                  "self" => {
-                    "href" => Pact.like("http://result")
-                  }
-                }
-              }
-            },{
-              "consumer" => {
-                "name" => "Foo",
-                "version" => {
-                  "number" => "3.4.5"
-                }
-              },
-              "provider" => {
-                "name" => "Bar",
-                "version" => {
-                  "number" => "4.5.6"
-                }
-              },
-              "verificationResult" => {
-                "success" => false,
-                "_links" => {
-                  "self" => {
-                    "href" => Pact.like("http://result")
-                  }
-                }
-              },
-              "ignored" => true
-            }
-          ]
-        }
-
-      end
-      let(:selectors) { [{ pacticipant: "Bar", version: "4.5.6" }, { pacticipant: "Foo", tag: "prod" } ] }
-      let(:matrix_options) do
-        {
-          ignore_selectors: [{ pacticipant: "Foo", version: "3.4.5" }]
-        }
-      end
-      let(:options) { { retry_while_unknown: 0, output: 'table' } }
-
-      before do
-        pact_broker
-          .given("provider Bar version 4.5.6 has a successful verification for Foo version 1.2.3 tagged prod and a failed verification for version 3.4.5 tagged prod")
-          .upon_receiving("a request to determine if Bar can be deployed with all Foo tagged prod, ignoring the verification for Foo version 3.4.5")
-          .with(
-            method: :get,
-            path: "/matrix",
-            query: "q%5B%5D%5Bpacticipant%5D=Bar&q%5B%5D%5Bversion%5D=4.5.6&q%5B%5D%5Bpacticipant%5D=Foo&q%5B%5D%5Btag%5D=prod&latestby=cvpv&ignore%5B%5D%5Bpacticipant%5D=Foo&ignore%5B%5D%5Bversion%5D=3.4.5"
-          )
-          .will_respond_with(
-            status: 200,
-            headers: pact_broker_response_headers,
-            body: matrix_response_body
-          )
-      end
-
-      subject { PactBroker::Client::CanIDeploy.call(selectors, matrix_options, options, { pact_broker_base_url: broker_base_url })}
-
-      it 'returns the CLI output' do
-        Approvals.verify(subject.message, :name => "can_i_deploy_ignore", format: :txt)
-      end
-    end
-  end
-end

data/spec/service_providers/pact_broker_client_matrix_spec.rb

@@ -1,292 +0,0 @@
-require_relative 'pact_helper'
-require 'pact_broker/client'
-require "pact_broker/client/matrix/query"
-
-module PactBroker::Client
-  describe Matrix, :pact => true do
-
-    include_context "pact broker"
-
-    describe "retriving the compatibility matrix" do
-      let(:matrix_response_body) { Pact.like(matrix) }
-      let(:matrix) { JSON.parse(File.read('spec/support/matrix.json')) }
-      let(:selectors) { [{ pacticipant: "Foo", version: "1.2.3" }, { pacticipant: "Bar", version: "4.5.6" }] }
-      let(:options) { {} }
-
-      subject { PactBroker::Client::Matrix::Query.call({ selectors: selectors, options: options }, {}, { pact_broker_base_url: pact_broker.mock_service_base_url }) }
-
-      context "when results are found" do
-        before do
-          pact_broker.
-            given("the pact for Foo version 1.2.3 has been verified by Bar version 4.5.6").
-            upon_receiving("a request for the compatibility matrix for Foo version 1.2.3 and Bar version 4.5.6").
-            with(
-              method: :get,
-              path: "/matrix",
-              query: "q%5B%5D%5Bpacticipant%5D=Foo&q%5B%5D%5Bversion%5D=1.2.3&q%5B%5D%5Bpacticipant%5D=Bar&q%5B%5D%5Bversion%5D=4.5.6&latestby=cvpv"
-            ).
-            will_respond_with(
-              status: 200,
-              headers: pact_broker_response_headers,
-              body: matrix_response_body
-            )
-        end
-
-        it 'returns the pact matrix' do
-          matrix = subject
-          expect(matrix[:matrix].size).to eq 1
-        end
-      end
-
-      context "when the pacticipant name has a space in it" do
-        before do
-          pact_broker.
-            given("the pact for Foo Thing version 1.2.3 has been verified by Bar version 4.5.6").
-            upon_receiving("a request for the compatibility matrix for Foo version 1.2.3 and Bar version 4.5.6").
-            with(
-              method: :get,
-              path: "/matrix",
-              query: "q%5B%5D%5Bpacticipant%5D=Foo%20Thing&q%5B%5D%5Bversion%5D=1.2.3&q%5B%5D%5Bpacticipant%5D=Bar&q%5B%5D%5Bversion%5D=4.5.6&latestby=cvpv"
-            ).
-            will_respond_with(
-              status: 200,
-              headers: pact_broker_response_headers,
-              body: matrix_response_body
-            )
-        end
-
-        let(:selectors) { [{ pacticipant: "Foo Thing", version: "1.2.3" }, { pacticipant: "Bar", version: "4.5.6" }] }
-
-        it 'incorrectly escapes the spaces but it still seems to work' do
-          matrix = subject
-          expect(matrix[:matrix].size).to eq 1
-        end
-      end
-
-      context "with only one version selector" do
-        before do
-          pact_broker.
-            given("the pact for Foo version 1.2.3 has been verified by Bar version 4.5.6 and version 5.6.7").
-            upon_receiving("a request for the compatibility matrix where only the version of Foo is specified").
-            with(
-              method: :get,
-              path: "/matrix",
-              query: "q%5B%5D%5Bpacticipant%5D=Foo&q%5B%5D%5Bversion%5D=1.2.3&latestby=cvp&latest=true"
-            ).
-            will_respond_with(
-              status: 200,
-              headers: pact_broker_response_headers,
-              body: matrix_response_body
-            )
-        end
-
-        let(:selectors) { [{ pacticipant: "Foo", version: "1.2.3" }] }
-
-        it 'returns the row with the lastest verification for version 1.2.3' do
-          matrix = subject
-          expect(matrix[:matrix].size).to eq 1
-        end
-      end
-
-      context "when one or more of the versions does not exist" do
-        before do
-          pact_broker.
-            given("the pact for Foo version 1.2.3 has been verified by Bar version 4.5.6").
-            upon_receiving("a request for the compatibility matrix where one or more versions does not exist").
-            with(
-              method: :get,
-              path: "/matrix",
-              query: "q%5B%5D%5Bpacticipant%5D=Foo&q%5B%5D%5Bversion%5D=1.2.3&q%5B%5D%5Bpacticipant%5D=Bar&q%5B%5D%5Bversion%5D=9.9.9&latestby=cvpv"
-            ).
-            will_respond_with(
-              status: 200,
-              headers: pact_broker_response_headers,
-              body: {
-                summary: {
-                  reason: Pact.like("an error message")
-                }
-              }
-            )
-        end
-
-        let(:selectors) { [{ pacticipant: "Foo", version: "1.2.3" }, { pacticipant: "Bar", version: "9.9.9" }] }
-
-        it 'does not raise an error' do
-          subject
-        end
-      end
-
-      context "when results are not found" do
-        before do
-          pact_broker.
-            upon_receiving("a request for the compatibility matrix for a pacticipant that does not exist").
-            with(
-              method: :get,
-              path: "/matrix",
-              query: "q%5B%5D%5Bpacticipant%5D=Wiffle&q%5B%5D%5Bversion%5D=1.2.3&q%5B%5D%5Bpacticipant%5D=Meep&q%5B%5D%5Bversion%5D=9.9.9&latestby=cvpv"
-            ).
-            will_respond_with(
-              status: 400,
-              headers: pact_broker_response_headers,
-              body: {
-                errors: Pact.each_like("an error message")
-              }
-            )
-        end
-
-        let(:selectors) { [{ pacticipant: "Wiffle", version: "1.2.3" }, { pacticipant: "Meep", version: "9.9.9" }] }
-
-        it 'raises an error' do
-          expect {
-            subject
-          }.to raise_error PactBroker::Client::Hal::ErrorResponseReturned, /an error message/
-        end
-      end
-
-      context "when no versions are specified" do
-        before do
-          pact_broker.
-            given("the pact for Foo version 1.2.3 and 1.2.4 has been verified by Bar version 4.5.6").
-            upon_receiving("a request for the compatibility matrix for all versions of Foo and Bar").
-            with(
-              method: :get,
-              path: "/matrix",
-              query: "q%5B%5D%5Bpacticipant%5D=Foo&q%5B%5D%5Bpacticipant%5D=Bar&latestby=cvpv"
-            ).
-            will_respond_with(
-              status: 200,
-              headers: pact_broker_response_headers,
-              body: {
-                matrix: Pact.each_like(matrix_row, min: 2)
-              }
-            )
-        end
-        let(:matrix_row) { JSON.parse(File.read('spec/support/matrix.json'))['matrix'].first }
-        let(:selectors) { [{ pacticipant: "Foo" }, { pacticipant: "Bar" }] }
-
-        it "returns multiple rows" do
-          matrix = subject
-          expect(matrix[:matrix].size).to eq 2
-        end
-      end
-
-      context "when the success option is true" do
-        before do
-          pact_broker.
-            given("the pact for Foo version 1.2.3 has been successfully verified by Bar version 4.5.6, and 1.2.4 unsuccessfully by 9.9.9").
-            upon_receiving("a request for the successful rows of the compatibility matrix for all versions of Foo and Bar").
-            with(
-              method: :get,
-              path: "/matrix",
-              query: "q%5B%5D%5Bpacticipant%5D=Foo&q%5B%5D%5Bpacticipant%5D=Bar&latestby=cvpv&success%5B%5D=true"
-            ).
-            will_respond_with(
-              status: 200,
-              headers: pact_broker_response_headers,
-              body: matrix_response_body
-            )
-        end
-        let(:matrix_row) { JSON.parse(File.read('spec/support/matrix.json'))['matrix'].first }
-        let(:selectors) { [{ pacticipant: "Foo" }, { pacticipant: "Bar" }] }
-        let(:options) { {success: true} }
-
-        it "returns only the successful row" do
-          matrix = pact_broker_client.matrix.get(selectors, options)
-          expect(matrix[:matrix].size).to eq 1
-        end
-      end
-
-      context "when the latest version for a given tag is specified" do
-        before do
-          pact_broker.
-            given("the pact for Foo version 1.2.3 has been successfully verified by Bar version 4.5.6 with tag prod, and 1.2.4 unsuccessfully by 9.9.9").
-            upon_receiving("a request for the compatibility matrix for Foo version 1.2.3 and the latest prod version of Bar").
-            with(
-              method: :get,
-              path: "/matrix",
-              query: "q%5B%5D%5Bpacticipant%5D=Foo&q%5B%5D%5Bversion%5D=1.2.3&q%5B%5D%5Bpacticipant%5D=Bar&q%5B%5D%5Blatest%5D=true&q%5B%5D%5Btag%5D=prod&latestby=cvpv"
-            ).
-            will_respond_with(
-              status: 200,
-              headers: pact_broker_response_headers,
-              body: matrix_response_body
-            )
-        end
-        let(:matrix_row) { JSON.parse(File.read('spec/support/matrix.json'))['matrix'].first }
-        let(:selectors) { [{ pacticipant: "Foo", version: "1.2.3"}, { pacticipant: "Bar", latest: true, tag: 'prod' }] }
-        let(:options) { {} }
-
-        it "returns the matrix with the latest prod version of Bar" do
-          matrix = pact_broker_client.matrix.get(selectors, options)
-          expect(matrix[:matrix].size).to eq 1
-        end
-      end
-
-      context "when the latest version is specified" do
-        before do
-          pact_broker.
-            given("the pact for Foo version 1.2.3 has been successfully verified by Bar version 4.5.6, and 1.2.4 unsuccessfully by 9.9.9").
-            upon_receiving("a request for the compatibility matrix for Foo version 1.2.3 and the latest version of Bar").
-            with(
-              method: :get,
-              path: "/matrix",
-              query: "q%5B%5D%5Bpacticipant%5D=Foo&q%5B%5D%5Bversion%5D=1.2.4&q%5B%5D%5Bpacticipant%5D=Bar&q%5B%5D%5Blatest%5D=true&latestby=cvpv"
-            ).
-            will_respond_with(
-              status: 200,
-              headers: pact_broker_response_headers,
-              body: matrix_response_body
-            )
-        end
-        let(:matrix_row) { JSON.parse(File.read('spec/support/matrix.json'))['matrix'].first }
-        let(:selectors) { [{ pacticipant: "Foo", version: "1.2.4"}, { pacticipant: "Bar", latest: true }] }
-        let(:options) { {} }
-
-        it "returns the matrix with the latest prod version of Bar" do
-          matrix = pact_broker_client.matrix.get(selectors, options)
-          expect(matrix[:matrix].size).to eq 1
-        end
-      end
-
-      context "when checking if we can deploy with the latest tagged versions of the other services" do
-        before do
-          pact_broker.
-            given("the pact for Foo version 1.2.3 has been successfully verified by Bar version 4.5.6 (tagged prod) and version 5.6.7").
-            upon_receiving("a request for the compatibility matrix for Foo version 1.2.3 and the latest prod versions of all other pacticipants").
-            with(
-              method: :get,
-              path: "/matrix",
-              query: "q%5B%5D%5Bpacticipant%5D=Foo&q%5B%5D%5Bversion%5D=1.2.3&latestby=cvp&latest=true&tag=prod"
-            ).
-            will_respond_with(
-              status: 200,
-              headers: pact_broker_response_headers,
-              body: matrix_response_body
-            )
-        end
-
-        let(:selectors) { [{ pacticipant: "Foo", version: "1.2.3" }] }
-
-        let(:matrix_response_body) {
-          {
-            matrix: [{
-              consumer: { name: 'Foo', version: { number: '1.2.3' } },
-              provider: { name: 'Bar', version: { number: '4.5.6'} },
-            }]
-          }
-        }
-
-        let(:options) { { to_tag: 'prod' } }
-
-        it "returns the matrix with the latest prod version of Bar" do
-          matrix = pact_broker_client.matrix.get(selectors, options)
-          expect(matrix[:matrix].size).to eq 1
-        end
-      end
-
-      context "with an environment name" do
-        it "passes the environment name in the options"
-      end
-    end
-  end
-end

data/spec/service_providers/pact_broker_client_pacticipant_version_spec.rb

@@ -1,56 +0,0 @@
-require_relative 'pact_helper'
-require 'pact_broker/client'
-
-module PactBroker::Client
-  describe Pacts, :pact => true do
-
-    include_context "pact broker"
-
-    describe "retriving pacticipant versions" do
-      context "when retrieving the production details of a version" do
-        context "when a version is found" do
-          let(:repository_ref) { "package/pricing-service-1.2.3"}
-          let(:tags) { ['prod']}
-          let(:body) { { number: '1.2.3', repository_ref: repository_ref, tags: tags } }
-          before do
-            pact_broker.
-              given("a pacticipant version with production details exists for the Pricing Service").
-              upon_receiving("a request for the latest pacticpant version tagged with 'prod'").
-              with(
-                method: :get,
-                path: '/pacticipants/Pricing%20Service/versions/latest',
-                query: 'tag=prod',
-                headers: get_request_headers).
-              will_respond_with(
-                status: 200,
-                headers: pact_broker_response_headers.merge({'Content-Type' => 'application/json'}),
-                body: body )
-          end
-
-          xit 'returns the version details' do
-            expect( pact_broker_client.pacticipants.versions.latest pacticipant: 'Pricing Service', tag: 'prod' ).to eq body
-          end
-        end
-      end
-      context "when a version is not found" do
-        before do
-          pact_broker.
-            given("no pacticipant version exists for the Pricing Service").
-            upon_receiving("a request for the latest pacticipant version").
-            with(
-              method: :get,
-              path: '/pacticipants/Pricing%20Service/versions/latest',
-              headers: get_request_headers).
-            will_respond_with(
-              status: 404,
-              headers: pact_broker_response_headers )
-        end
-
-        xit 'returns nil' do
-          expect( pact_broker_client.pacticipants.versions.latest pacticipant: 'Pricing Service' ).to eq nil
-        end
-      end
-    end
-
-  end
-end

data/spec/service_providers/pact_broker_client_publish_spec.rb

@@ -1,135 +0,0 @@
-require 'pact_broker/client/pact_broker_client'
-require_relative 'pact_helper'
-
-module PactBroker::Client
-  describe PactBrokerClient, :pact => true do
-
-    include_context "pact broker"
-
-    describe "publishing a pact" do
-
-      let(:options) { { pact_hash: pact_hash, consumer_version: consumer_version }}
-      let(:location) { 'http://example.org/pacts/provider/Pricing%20Service/consumer/Condor/latest' }
-      context "when the provider already exists in the pact-broker" do
-
-        before do
-          pact_broker.
-          given("the 'Pricing Service' already exists in the pact-broker").
-          upon_receiving("a request to publish a pact").
-          with(
-            method: :put,
-            path: '/pacts/provider/Pricing%20Service/consumer/Condor/version/1.3.0',
-            headers: default_request_headers,
-            body: pact_hash ).
-          will_respond_with(
-            headers: pact_broker_response_headers,
-            status: 201,
-            body: {
-              _links: {
-                :'pb:latest-pact-version' => {
-                  href: location
-                }
-              }
-            }
-          )
-        end
-        it "returns the URL to find the newly published pact" do
-          expect(pact_broker_client.pacticipants.versions.pacts.publish(options)).to eq location
-        end
-      end
-
-      context "when the provider, consumer, pact and version already exist in the pact-broker" do
-        shared_examples "an already-existing pact" do |method|
-          before do
-            pact_broker.
-              given("the 'Pricing Service' and 'Condor' already exist in the pact-broker, and Condor already has a pact published for version 1.3.0").
-              upon_receiving("a request to publish a pact with method #{method}").
-              with(
-                method: method,
-                path: '/pacts/provider/Pricing%20Service/consumer/Condor/version/1.3.0',
-                headers: default_request_headers,
-                body: pact_hash ).
-              will_respond_with(
-                headers: pact_broker_response_headers,
-                status: 200,
-                body: {
-                  _links: {
-                    :'pb:latest-pact-version' => {
-                      href: location
-                    }
-                  }
-                }
-              )
-          end
-
-          it "returns true" do
-            expect(pact_broker_client.pacticipants.versions.pacts.publish(options)).to be_truthy
-          end
-        end
-
-        context "when the write method is set to merge" do
-          let(:client_config) { super().merge(client_options: {write: :merge}) }
-
-          it_behaves_like "an already-existing pact", :patch
-        end
-
-        context "when the write method is not set" do
-          it_behaves_like "an already-existing pact", :put
-        end
-      end
-
-      context "when the provider does not exist, but the consumer, pact and version already exist in the pact-broker" do
-        before do
-          pact_broker.
-            given("'Condor' already exist in the pact-broker, but the 'Pricing Service' does not").
-            upon_receiving("a request to publish a pact").
-            with(
-              method: :put,
-              path: '/pacts/provider/Pricing%20Service/consumer/Condor/version/1.3.0',
-              headers: default_request_headers,
-              body: pact_hash ).
-            will_respond_with(
-              headers: pact_broker_response_headers,
-              status: 201,
-              body: {
-                _links: {
-                  :'pb:latest-pact-version' => {
-                    href: location
-                  }
-                }
-              }
-            )
-        end
-        it "returns true" do
-          expect(pact_broker_client.pacticipants.versions.pacts.publish(options)).to be_truthy
-        end
-      end
-
-      context "when publishing is not successful" do
-        before do
-          pact_broker.
-            given("an error occurs while publishing a pact").
-            upon_receiving("a request to publish a pact").
-            with(
-              method: :put,
-              path: '/pacts/provider/Pricing%20Service/consumer/Condor/version/1.3.0',
-              headers: default_request_headers,
-              body: pact_hash ).
-            will_respond_with(
-              status: 500,
-              headers: {'Content-Type' => Pact.term(generate: 'application/hal+json', matcher: %r{application/.*json})},
-              body: {
-                error: {
-                  message: Pact::Term.new(matcher: /.*/, generate: 'An error occurred')
-                }
-              }
-            )
-        end
-        it "raises an error" do
-          expect { pact_broker_client.pacticipants.versions.pacts.publish options }.to raise_error /An error occurred/
-        end
-      end
-
-    end
-  end
-end

data/spec/service_providers/pact_broker_client_register_repository_spec.rb

@@ -1,49 +0,0 @@
-module PactBroker::Client
-  describe Pacticipants, :pact => true do
-
-    include_context "pact broker"
-
-    let(:repository_url ) { "git@git.realestate.com.au:business-systems/pricing-service" }
-
-    describe "registering a repository url" do
-      context "where the pacticipant does not already exist in the pact-broker" do
-        before do
-          pact_broker.
-            given("the 'Pricing Service' does not exist in the pact-broker").
-            upon_receiving("a request to register the repository URL of a pacticipant").
-            with(
-                method: :patch,
-                path: '/pacticipants/Pricing%20Service',
-                headers: old_patch_request_headers,
-                body: {repository_url: repository_url} ).
-              will_respond_with(
-                status: 201,
-                headers: pact_broker_response_headers
-              )
-        end
-        it "returns true" do
-          expect(pact_broker_client.pacticipants.update({:pacticipant => 'Pricing Service', :repository_url => repository_url})).to be true
-        end
-      end
-      context "where the 'Pricing Service' exists in the pact-broker" do
-        before do
-          pact_broker.
-            given("the 'Pricing Service' already exists in the pact-broker").
-            upon_receiving("a request to register the repository URL of a pacticipant").
-            with(
-              method: :patch,
-              path: '/pacticipants/Pricing%20Service',
-              headers: old_patch_request_headers,
-              body: { repository_url: repository_url }).
-            will_respond_with(
-              status: 200,
-              headers: pact_broker_response_headers
-            )
-        end
-        it "returns true" do
-          expect(pact_broker_client.pacticipants.update({:pacticipant => 'Pricing Service', :repository_url => repository_url})).to be true
-        end
-      end
-    end
-  end
-end

data/spec/service_providers/pact_broker_client_retrieve_all_pacts_for_provider_spec.rb

@@ -1,53 +0,0 @@
-require_relative 'pact_helper'
-require 'pact_broker/client'
-
-module PactBroker::Client
-  describe Pacts, :pact => true do
-
-    include_context "pact broker"
-
-    describe "retriving all pacts for provider" do
-      let(:response_body) { Pact.like(JSON.parse(File.read("./spec/support/latest_pacts_for_provider.json"))) }
-      let(:expectedPactsArray) { [{:name => "Condor", :href => "http://example.org/pacts/provider/Pricing%20Service/consumer/Condor/version/1.3.0"}] }
-
-      context "when retrieving all the latest pacts for provider with prod tag specified" do
-        before do
-          pact_broker.
-              given("tagged as prod pact between Condor and the Pricing Service exists").
-              upon_receiving("a request for the list of the latest prod pacts from all consumers for the Pricing Service'").
-              with(
-                  method: :get,
-                  path: "/pacts/provider/Pricing%20Service/latest/prod",
-                  headers: {}).
-              will_respond_with(
-                  status: 200,
-                  body: response_body)
-        end
-        it 'returns the map of all provider latest prod pacts' do
-          pactsArray = pact_broker_client.pacticipants.versions.pacts.list_latest_for_provider provider: 'Pricing Service', tag: 'prod'
-          expect(pactsArray.length).to eq(1)
-          expect(pactsArray).to eq(expectedPactsArray)
-        end
-      end
-      context "when retrieving all the latest pacts for provider with no tag specified" do
-        before do
-          pact_broker.
-              given("a latest pact between Condor and the Pricing Service exists").
-              upon_receiving("a request for the list of the latest pacts from all consumers for the Pricing Service'").
-              with(
-                  method: :get,
-                  path: "/pacts/provider/Pricing%20Service/latest",
-                  headers: {}).
-              will_respond_with(
-                  status: 200,
-                  body: response_body)
-        end
-        it 'returns the map of all provider latest pacts' do
-          pactsArray = pact_broker_client.pacticipants.versions.pacts.list_latest_for_provider provider: 'Pricing Service'
-          expect(pactsArray.length).to eq(1)
-          expect(pactsArray).to eq(expectedPactsArray)
-        end
-      end
-    end
-  end
-end