pact_broker-client 1.75.3 → 1.75.4

data/spec/service_providers/record_release_spec.rb

@@ -1,130 +0,0 @@
-require 'service_providers/pact_helper'
-require 'pact_broker/client/deployments/record_deployment'
-
-RSpec.describe "recording a release", pact: true do
-  include_context "pact broker"
-  include PactBrokerPactHelperMethods
-
-  let(:pacticipant_name) { "Foo" }
-  let(:version_number) { "5556b8149bf8bac76bc30f50a8a2dd4c22c85f30" }
-  let(:environment_name) { "test" }
-  let(:output) { "text" }
-  let(:target) { "blue" }
-  let(:params) do
-    {
-      pacticipant_name: pacticipant_name,
-      version_number: version_number,
-      environment_name: environment_name
-    }
-  end
-  let(:options) do
-    {
-      output: output
-    }
-  end
-  let(:pact_broker_client_options) { { pact_broker_base_url: broker_base_url } }
-
-  subject { PactBroker::Client::Deployments::RecordRelease.call(params, options, pact_broker_client_options) }
-
-  def mock_index
-    pact_broker
-      .given("the pb:pacticipant-version and pb:environments relations exist in the index resource")
-      .upon_receiving("a request for the index resource")
-      .with(
-          method: "GET",
-          path: '/',
-          headers: get_request_headers).
-        will_respond_with(
-          status: 200,
-          headers: pact_broker_response_headers,
-          body: {
-            _links: {
-              :'pb:pacticipant-version' => {
-                href: placeholder_url_term("pb:pacticipant-version", ["pacticipant", "version"])
-              },
-              :'pb:environments' => {
-                href: placeholder_url_term("pb:environments")
-              }
-            }
-          }
-        )
-  end
-
-  def mock_pacticipant_version_with_test_environment_available_for_release
-    pact_broker
-      .given("version 5556b8149bf8bac76bc30f50a8a2dd4c22c85f30 of pacticipant Foo exists with a test environment available for release")
-      .upon_receiving("a request for a pacticipant version")
-      .with(
-        method: "GET",
-        path: "/HAL-REL-PLACEHOLDER-PB-PACTICIPANT-VERSION-Foo-5556b8149bf8bac76bc30f50a8a2dd4c22c85f30",
-        headers: get_request_headers
-      )
-      .will_respond_with(
-        status: 200,
-        headers: pact_broker_response_headers,
-        body: {
-          _links: {
-            "pb:record-release" => [
-              {
-                name: "test",
-                href: placeholder_url_term("pb:record-release-#{pacticipant_name}-#{version_number}-#{environment_name}")
-              }
-            ]
-          }
-        }
-      )
-  end
-
-  def mock_environments
-    pact_broker
-      .given("an environment with name test exists")
-      .upon_receiving("a request for the environments")
-      .with(
-        method: "GET",
-        path: "/HAL-REL-PLACEHOLDER-PB-ENVIRONMENTS",
-        headers: get_request_headers
-      )
-      .will_respond_with(
-        status: 200,
-        headers: pact_broker_response_headers,
-        body: {
-          _links: {
-            "pb:environments" => [
-              {
-                name: "test",
-                href: Pact.like("href")
-              }
-            ]
-          }
-        }
-      )
-  end
-
-  def mock_record_release
-    pact_broker
-      .given("version 5556b8149bf8bac76bc30f50a8a2dd4c22c85f30 of pacticipant Foo exists with a test environment available for deployment")
-      .upon_receiving("a request to record a release")
-      .with(
-        method: "POST",
-        path: "/HAL-REL-PLACEHOLDER-PB-RECORD-RELEASE-FOO-5556B8149BF8BAC76BC30F50A8A2DD4C22C85F30-TEST",
-        headers: post_request_headers
-      )
-      .will_respond_with(
-        status: 201,
-        headers: pact_broker_response_headers
-      )
-  end
-
-  context "when the deployment is recorded successfully" do
-    before do
-      mock_index
-      mock_pacticipant_version_with_test_environment_available_for_release
-      mock_record_release
-    end
-
-    it "returns a success message" do
-      expect(subject.success).to be true
-      expect(subject.message).to include "Recorded release of Foo version 5556b8149bf8bac76bc30f50a8a2dd4c22c85f30 to test environment in the Pact Broker."
-    end
-  end
-end

data/spec/service_providers/record_undeployment_spec.rb

@@ -1,164 +0,0 @@
-require 'service_providers/pact_helper'
-require 'pact_broker/client/deployments/record_undeployment'
-
-RSpec.describe "recording an undeployment", pact: true do
-  include_context "pact broker"
-  include PactBrokerPactHelperMethods
-
-  let(:pacticipant_name) { "Foo" }
-  let(:environment_name) { "test" }
-  let(:output) { "text" }
-  let(:application_instance) { "customer-1" }
-  let(:params) do
-    {
-      pacticipant_name: pacticipant_name,
-      environment_name: environment_name,
-      application_instance: application_instance
-    }
-  end
-  let(:options) do
-    {
-      output: output,
-      verbose: true
-    }
-  end
-  let(:webmock_base_url) { "http://broker" }
-  let(:pact_broker_client_options) { { pact_broker_base_url: webmock_base_url } }
-  let(:test_environment_placeholder_path) { "/HAL-REL-PLACEHOLDER-PB-ENVIRONMENT-16926ef3-590f-4e3f-838e-719717aa88c9" }
-  let(:currently_deployed_versions_placeholder_path) { "/PLACEHOLDER-ENVIRONMENT-CURRENTLY-DEPLOYED-16926ef3-590f-4e3f-838e-719717aa88c9" }
-  let(:deployed_version_placeholder_path) { "/PLACEHOLDER-DEPLOYED-VERSION-ff3adecf-cfc5-4653-a4e3-f1861092f8e0"}
-
-  subject { PactBroker::Client::Deployments::RecordUndeployment.call(params, options, pact_broker_client_options) }
-
-  let(:index_body_hash) do
-    {
-      _links: {
-        :'pb:environments' => {
-          href: "#{webmock_base_url}/environments"
-        }
-      }
-    }
-  end
-
-  let(:environments_hash) do
-    {
-      _links: {
-        :'pb:environments' => [
-          {
-            name: "test",
-            href: pact_broker.mock_service_base_url + test_environment_placeholder_path
-          }
-        ]
-      }
-    }
-  end
-
-  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
-
-  def mock_test_environment
-    pact_broker
-      .given("an environment with name test and UUID 16926ef3-590f-4e3f-838e-719717aa88c9 exists")
-      .upon_receiving("a request for an environment")
-      .with(
-        method: "GET",
-        path: test_environment_placeholder_path,
-        headers: get_request_headers
-      )
-      .will_respond_with(
-        status: 200,
-        headers: pact_broker_response_headers,
-        body: {
-          _links: {
-            :'pb:currently-deployed-deployed-versions' => {
-              href: Pact.term( pact_broker.mock_service_base_url + currently_deployed_versions_placeholder_path, /^http.*/)
-            }
-          }
-        }
-      )
-  end
-
-  def mock_deployed_versions_search_results
-    pact_broker
-      .given("an version is deployed to environment with UUID 16926ef3-590f-4e3f-838e-719717aa88c9 with target customer-1")
-      .upon_receiving("a request to list the versions deployed to an environment for a pacticipant name and application instance")
-      .with(
-        method: "GET",
-        path: currently_deployed_versions_placeholder_path,
-        query: { pacticipant: pacticipant_name },
-        headers: get_request_headers
-      )
-      .will_respond_with(
-        status: 200,
-        headers: pact_broker_response_headers,
-        body: {
-          _embedded: {
-            deployedVersions: [
-              {
-                applicationInstance: application_instance,
-                _links: {
-                  self: {
-                    href: Pact.term(pact_broker.mock_service_base_url + deployed_version_placeholder_path, /^http/)
-                  }
-                }
-              }
-            ]
-          }
-        }
-      )
-  end
-
-  def mock_mark_deployed_version_as_undeployed
-    pact_broker
-      .given("a currently deployed version exists")
-      .upon_receiving("a request to mark a deployed version as not currently deploye")
-      .with(
-        method: "PATCH",
-        path: deployed_version_placeholder_path,
-        body: { currentlyDeployed: false },
-        headers: patch_request_headers
-      )
-      .will_respond_with(
-        status: 200,
-        headers: pact_broker_response_headers,
-        body: deployed_version_hash
-      )
-  end
-
-  let(:deployed_version_hash) do
-    {
-      "currentlyDeployed" => false,
-      "_embedded" => {
-        "version" => {
-          "number" => Pact.like("2")
-        }
-      }
-    }
-  end
-
-  context "when the deployment is recorded successfully" do
-    before do
-      mock_test_environment
-      mock_deployed_versions_search_results
-      mock_mark_deployed_version_as_undeployed
-    end
-
-    it "returns a success message" do
-      expect(subject.success).to be true
-      expect(subject.message).to include "Recorded undeployment of Foo version 2 from test environment (application instance customer-1) in the Pact Broker"
-    end
-
-    context "when the output is json" do
-      let(:output) { "json" }
-
-      it "returns the JSON payload" do
-        expect(JSON.parse(subject.message)).to eq [Pact::Reification.from_term(deployed_version_hash)]
-      end
-    end
-  end
-end

data/spec/service_providers/webhooks_create_spec.rb

@@ -1,391 +0,0 @@
-require_relative 'pact_helper'
-require 'pact_broker/client/webhooks/create'
-
-RSpec.describe "creating a webhook", pact: true do
-
-  include_context "pact broker"
-  include PactBrokerPactHelperMethods
-
-  let(:event_names) { %w{contract_content_changed contract_published provider_verification_published provider_verification_succeeded provider_verification_failed}  }
-
-  let(:params) do
-    {
-      description: "a webhook",
-      events: %w{contract_content_changed},
-      http_method: "POST",
-      url: "https://webhook",
-      headers: { "Foo" => "bar", "Bar" => "foo"},
-      username: "username",
-      password: "password",
-      body: body,
-      consumer: "Condor",
-      provider: "Pricing Service"
-    }.tap { |it| Pact::Fixture.add_fixture(:create_webhook_params, it) }
-  end
-
-  let(:body) { { some: "body" }.to_json }
-
-  let(:request_body) do
-    {
-      "description" => "a webhook",
-      "events" => [
-        "name" => "contract_content_changed"
-      ],
-      "request" => {
-        "url" => "https://webhook",
-        "method" => "POST",
-        "headers" => {
-          "Foo" => "bar",
-          "Bar" => "foo"
-        },
-        "body" => {
-          "some" => "body"
-        },
-        "username" => "username",
-        "password" => "password"
-      }
-    }
-  end
-
-  let(:response_status) { 201 }
-  let(:success_response) do
-    {
-      status: response_status,
-      headers: pact_broker_response_headers,
-      body: {
-        description: Pact.like("a webhook"),
-        request: {
-          body: {
-            some: "body"
-          }
-        },
-        events: [
-          name: "contract_content_changed"
-        ],
-        _links: {
-          self: {
-            href: Pact.term('http://localhost:1234/some-url', %r{http://.*}),
-            title: Pact.like("A title")
-          }
-        }
-      }
-    }
-  end
-
-  let(:pact_broker_client_options) { {} }
-
-  subject { PactBroker::Client::Webhooks::Create.call(params, broker_base_url, pact_broker_client_options) }
-
-  context "when a valid webhook with a JSON body is submitted" do
-    before do
-      pact_broker
-        .given("the 'Pricing Service' and 'Condor' already exist in the pact-broker")
-        .upon_receiving("a request to create a webhook with a JSON body for a consumer and provider")
-        .with(
-            method: :post,
-            path: '/webhooks/provider/Pricing%20Service/consumer/Condor',
-            headers: post_request_headers,
-            body: request_body)
-        .will_respond_with(success_response)
-    end
-
-    it "returns a CommandResult with success = true" do
-      expect(subject).to be_a PactBroker::Client::CommandResult
-      expect(subject.success).to be true
-      expect(subject.message).to eq "Webhook \"a webhook\" created"
-    end
-  end
-
-  context "when a valid webhook with every possible event type is sumbitted" do
-    before do
-      params.merge!(events: event_names)
-      request_body.merge!("events" => event_names.map{ |event_name| { "name" => event_name } })
-      success_response[:body].merge!(events: event_names.map{ |event_name| { "name" => event_name } })
-
-      pact_broker
-        .given("the 'Pricing Service' and 'Condor' already exist in the pact-broker")
-        .upon_receiving("a request to create a webhook with every possible event type")
-        .with(
-            method: :post,
-            path: '/webhooks/provider/Pricing%20Service/consumer/Condor',
-            headers: post_request_headers,
-            body: request_body)
-        .will_respond_with(success_response)
-    end
-
-    it "returns a CommandResult with success = true" do
-      expect(subject.success).to be true
-    end
-  end
-
-  context "when a valid webhook with an XML body is submitted" do
-    before do
-      request_body["request"]["body"] = body
-      success_response[:body][:request][:body] = body
-
-      pact_broker
-        .given("the 'Pricing Service' and 'Condor' already exist in the pact-broker")
-        .upon_receiving("a request to create a webhook with a non-JSON body for a consumer and provider")
-        .with(
-            method: :post,
-            path: '/webhooks/provider/Pricing%20Service/consumer/Condor',
-            headers: post_request_headers,
-            body: request_body)
-        .will_respond_with(success_response)
-    end
-
-    let(:body) { "<xml></xml>" }
-
-    it "returns a CommandResult with success = true" do
-      expect(subject.success).to be true
-    end
-  end
-
-  context "when an invalid webhook is submitted" do
-    before do
-      params[:url] = nil
-      request_body["request"].delete("url")
-
-      pact_broker
-        .given("the 'Pricing Service' and 'Condor' already exist in the pact-broker")
-        .upon_receiving("an invalid request to create a webhook for a consumer and provider")
-        .with(
-            method: :post,
-            path: '/webhooks/provider/Pricing%20Service/consumer/Condor',
-            headers: post_request_headers,
-            body: request_body).
-          will_respond_with(
-            status: 400,
-            headers: pact_broker_response_headers,
-            body: {
-              errors: {
-                "request.url" => Pact.each_like("Some error")
-              }
-            }
-          )
-    end
-
-    it "returns a CommandResult with success = false" do
-      expect(subject.success).to be false
-      expect(subject.message).to match /400/
-      expect(subject.message).to match /Some error/
-    end
-  end
-
-  context "when one of the pacticipants does not exist" do
-    before do
-      pact_broker
-        .given("'Condor' does not exist in the pact-broker")
-        .upon_receiving("a request to create a webhook for a consumer and provider")
-        .with(
-            method: :post,
-            path: '/webhooks/provider/Pricing%20Service/consumer/Condor',
-            headers: post_request_headers,
-            body: request_body).
-          will_respond_with(
-            status: 404,
-            headers: pact_broker_response_headers
-          )
-    end
-
-    it "returns a CommandResult with success = false" do
-      expect(subject.success).to be false
-      expect(subject.message).to match /404/
-    end
-  end
-
-  context "when only a consumer is specified" do
-    before do
-      params.delete(:provider)
-      request_body["consumer"] = { "name" => "Condor" }
-      mock_pact_broker_index(self)
-
-      pact_broker
-        .given("the 'Pricing Service' and 'Condor' already exist in the pact-broker")
-        .upon_receiving("a request to create a webhook with a JSON body for a consumer")
-        .with(
-            method: :post,
-            path: placeholder_path('pb:webhooks'),
-            headers: post_request_headers,
-            body: request_body)
-        .will_respond_with(success_response)
-    end
-
-    it "returns a CommandResult with success = true" do
-      expect(subject.success).to be true
-      expect(subject.message).to eq "Webhook \"a webhook\" created"
-    end
-  end
-
-  context "when consumer is specified using a label" do
-    before do
-      params.delete(:consumer)
-      params.delete(:provider)
-      params.merge!(consumer_label: "consumer_label")
-      request_body["consumer"] = { "label" => "consumer_label" }
-      mock_pact_broker_index(self)
-
-      pact_broker
-        .upon_receiving("a request to create a webhook with a JSON body for a consumer specified by a label")
-        .with(
-          method: :post,
-          path: placeholder_path('pb:webhooks'),
-          headers: post_request_headers,
-          body: request_body)
-        .will_respond_with(success_response)
-    end
-
-    it "returns a CommandResult with success = true" do
-      expect(subject.success).to be true
-      expect(subject.message).to eq "Webhook \"a webhook\" created"
-    end
-  end
-
-  context "when only a consumer is specified and it does not exist" do
-    before do
-      params.delete(:provider)
-      request_body["consumer"] = { "name" => "Condor" }
-      mock_pact_broker_index(self)
-
-      pact_broker
-        .upon_receiving("a request to create a webhook with a JSON body for a consumer that does not exist")
-        .with(
-            method: :post,
-            path: placeholder_path('pb:webhooks'),
-            headers: post_request_headers,
-            body: request_body)
-        .will_respond_with(
-            status: 400,
-            headers: pact_broker_response_headers,
-            body: {
-              errors: {
-                "consumer.name" => Pact.each_like("Some error")
-              }
-            })
-    end
-
-    it "returns a CommandResult with success = true" do
-      expect(subject.success).to be false
-    end
-  end
-
-  context "when only a provider is specified" do
-    before do
-      params.delete(:consumer)
-      request_body["provider"] = { "name" => "Pricing Service" }
-      mock_pact_broker_index(self)
-
-      pact_broker
-        .given("the 'Pricing Service' and 'Condor' already exist in the pact-broker")
-        .upon_receiving("a request to create a webhook with a JSON body for a provider")
-        .with(
-            method: :post,
-            path: placeholder_path('pb:webhooks'),
-            headers: post_request_headers,
-            body: request_body)
-        .will_respond_with(success_response)
-    end
-
-    it "returns a CommandResult with success = true" do
-      expect(subject.success).to be true
-    end
-  end
-
-  context "when provider is specified using a label" do
-    before do
-      params.delete(:consumer)
-      params.delete(:provider)
-      params.merge!(provider_label: "provider_label")
-      request_body["provider"] = { "label" => "provider_label" }
-      mock_pact_broker_index(self)
-
-      pact_broker
-        .upon_receiving("a request to create a webhook with a JSON body for a provider specified by a label")
-        .with(
-          method: :post,
-          path: placeholder_path('pb:webhooks'),
-          headers: post_request_headers,
-          body: request_body)
-        .will_respond_with(success_response)
-    end
-
-    it "returns a CommandResult with success = true" do
-      expect(subject.success).to be true
-      expect(subject.message).to eq "Webhook \"a webhook\" created"
-    end
-  end
-
-  context "when neither consumer nor provider are specified" do
-    before do
-      params.delete(:consumer)
-      params.delete(:provider)
-      mock_pact_broker_index(self)
-
-      pact_broker
-        .upon_receiving("a request to create a global webhook with a JSON body")
-        .with(
-            method: :post,
-            path: placeholder_path('pb:webhooks'),
-            headers: post_request_headers,
-            body: request_body)
-        .will_respond_with(success_response)
-    end
-
-    it "returns a CommandResult with success = true" do
-      expect(subject.success).to be true
-    end
-  end
-
-  context "when a uuid is specified" do
-    before do
-      params.merge!(uuid: uuid)
-      request_body["provider"] = { "name" => "Pricing Service" }
-      request_body["consumer"] = { "name" => "Condor" }
-      mock_pact_broker_index_with_webhook_relation(self)
-    end
-
-    let(:uuid) { '696c5f93-1b7f-44bc-8d03-59440fcaa9a0' }
-
-    context "when the webhook does not already exist" do
-      before do
-        pact_broker
-          .upon_receiving("a request to create a webhook with a JSON body and a uuid")
-          .given("the 'Pricing Service' and 'Condor' already exist in the pact-broker")
-          .with(
-              method: :put,
-              path: "/webhooks/#{uuid}",
-              headers: put_request_headers,
-              body: request_body)
-          .will_respond_with(success_response)
-      end
-
-      it "returns a CommandResult with success = true" do
-        expect(subject).to be_a PactBroker::Client::CommandResult
-        expect(subject.success).to be true
-        expect(subject.message).to eq "Webhook \"a webhook\" created"
-      end
-    end
-
-    context "when the webhook does exist" do
-      before do
-        pact_broker
-          .upon_receiving("a request to update a webhook")
-          .given("a webhook with the uuid #{uuid} exists")
-          .with(
-              method: :put,
-              path: "/webhooks/#{uuid}",
-              headers: put_request_headers,
-              body: request_body)
-          .will_respond_with(success_response)
-      end
-
-      let(:response_status) { 200 }
-
-      it "returns a CommandResult with success = true" do
-        expect(subject).to be_a PactBroker::Client::CommandResult
-        expect(subject.success).to be true
-        expect(subject.message).to eq "Webhook \"a webhook\" updated"
-      end
-    end
-  end
-end