pact_broker-client 1.75.3 → 1.75.4

data/spec/service_providers/pactflow_publish_provider_contract_the_old_way_spec.rb

@@ -1,129 +0,0 @@
-require_relative "pact_helper"
-require "yaml"
-require "pactflow/client/provider_contracts/publish_the_old_way"
-require "pact_broker/client/versions/create"
-
-
-RSpec.describe "publishing a provider contract to PactFlow the old way", pact: true do
-  before do
-    # no point re-testing this
-    allow(PactBroker::Client::Versions::Create).to receive(:call).and_return(double("result", success: true))
-  end
-
-  include_context "pact broker"
-  include PactBrokerPactHelperMethods
-
-  let(:command_params) do
-    {
-      provider_name: "Bar",
-      provider_version_number: "1",
-      branch_name: "main",
-      tags: ["dev"],
-      contract: {
-        content: { "some" => "contract" }.to_yaml,
-        content_type: "application/yaml",
-        specification: "oas"
-      },
-      verification_results: {
-        success: true,
-        content: "some results",
-        content_type: "text/plain",
-        format: "text",
-        verifier: "my custom tool",
-        verifier_version: "1.0"
-      }
-    }
-  end
-
-  let(:body) { { some: "body" }.to_json }
-
-  let(:request_body) do
-     {
-        "content" => "LS0tCnNvbWU6IGNvbnRyYWN0Cg==",
-        "contractType" => "oas",
-        "contentType" => "application/yaml",
-        "verificationResults" => {
-          "success" => true,
-          "content" => "c29tZSByZXN1bHRz",
-          "contentType" => "text/plain",
-          "format" => "text",
-          "verifier" => "my custom tool",
-          "verifierVersion" => "1.0"
-        }
-     }
-  end
-
-  let(:response_status) { 201 }
-  let(:success_response) do
-    {
-      status: response_status,
-      headers: pact_broker_response_headers
-    }
-  end
-
-  let(:options) do
-    {
-      verbose: false
-    }
-  end
-
-  let(:pact_broker_client_options) do
-    { pact_broker_base_url: pactflow.mock_service_base_url }
-  end
-
-  subject { Pactflow::Client::ProviderContracts::PublishTheOldWay.call(command_params, options, pact_broker_client_options) }
-
-  context "creating a provider contract with valid parameters" do
-    before do
-      pactflow
-        .upon_receiving("a request to create a provider contract")
-        .with(
-            method: :put,
-            path: "/contracts/provider/Bar/version/1",
-            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 include "Successfully published provider contract for Bar version 1"
-      expect(subject.message).not_to include pactflow.mock_service_base_url
-    end
-  end
-
-  context "creating a provider contract with valid parameters with pf:ui return results" do
-    let(:success_response_with_pf_ui_url) do
-      {
-        status: response_status,
-        headers: pact_broker_response_headers,
-        body: { "_links": {
-          "pf:ui": {
-            "href": Pact.like("some-url")
-          }
-        } }
-      }
-    end
-    before do
-      pactflow
-        .given("there is a pf:ui href in the response")
-        .upon_receiving("a request to create a provider contract")
-        .with(
-          method: :put,
-          path: "/contracts/provider/Bar/version/1",
-          headers: put_request_headers,
-          body: request_body
-        )
-        .will_respond_with(success_response_with_pf_ui_url)
-    end
-
-    it "returns a CommandResult with success = true and a provider contract ui url" do
-      expect(subject).to be_a PactBroker::Client::CommandResult
-      expect(subject.success).to be true
-      expect(subject.message).to include "Successfully published provider contract for Bar version 1"
-      expect(subject.message).to include "Next steps:"
-      expect(subject.message).to include "some-url"
-    end
-  end
-end

data/spec/service_providers/pactflow_webhooks_create_spec.rb

@@ -1,86 +0,0 @@
-require_relative 'pact_helper'
-require 'pact_broker/client/webhooks/create'
-
-RSpec.describe "creating a webhook in PactFlow", pact: true do
-
-  include_context "pact broker"
-  include PactBrokerPactHelperMethods
-
-  let(:params) do
-    {
-      description: "a webhook",
-      events: %w{contract_content_changed},
-      http_method: "POST",
-      url: "https://webhook",
-      headers: { "Foo" => "bar", "Bar" => "foo"},
-      body: body,
-      team_uuid: "2abbc12a-427d-432a-a521-c870af1739d9"
-    }
-  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"
-        },
-      },
-      "teamUuid" => "2abbc12a-427d-432a-a521-c870af1739d9"
-    }
-  end
-
-  let(:response_status) { 201 }
-  let(:success_response) do
-    {
-      status: response_status,
-      headers: pact_broker_response_headers,
-      body: {
-        description: Pact.like("a webhook"),
-        teamUuid: "2abbc12a-427d-432a-a521-c870af1739d9",
-        _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, pactflow.mock_service_base_url, pact_broker_client_options) }
-
-  context "when a valid webhook with a team specified is submitted" do
-    before do
-      mock_pact_broker_index(self, pactflow)
-      pactflow
-        .given("a team with UUID 2abbc12a-427d-432a-a521-c870af1739d9 exists")
-        .upon_receiving("a request to create a webhook for a team")
-        .with(
-            method: :post,
-            path: '/HAL-REL-PLACEHOLDER-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).to be_a PactBroker::Client::CommandResult
-      expect(subject.success).to be true
-      expect(subject.message).to eq "Webhook \"a webhook\" created"
-    end
-  end
-end

data/spec/service_providers/pacticipants_create_spec.rb

@@ -1,119 +0,0 @@
-require_relative 'pact_helper'
-require 'pact_broker/client/pacticipants/create'
-
-RSpec.describe "creating or updating a pacticipant", pact: true do
-  include_context "pact broker"
-  include PactBrokerPactHelperMethods
-
-  before do
-    index_links = {
-      'pb:pacticipants' => Pact.term('http://localhost:1234/pacticipants', %r{http://.*}),
-      'pb:pacticipant' => Pact.term('http://localhost:1234/pacticipants/{pacticipant}', %r{http://.*\{pacticipant\}}),
-    }
-    mock_pact_broker_index_with_relations(self, index_links, "the pacticipant relations are present")
-  end
-
-  let(:params) do
-    {
-      name: "Foo",
-      repository_url: "http://foo"
-    }
-  end
-
-  let(:request_body) { { name: "Foo", repositoryUrl: "http://foo" } }
-
-
-  let(:response_status) { 201 }
-  let(:create_success_response) do
-    {
-      status: response_status,
-      headers: pact_broker_response_headers,
-      body: {
-        name: "Foo",
-        repositoryUrl: "http://foo",
-        _links: {
-          self: {
-            href: Pact.term('http://localhost:1234/pacticipants/Foo', %r{http://.*}),
-          }
-        }
-      }
-    }
-  end
-
-  let(:get_success_response) do
-    {
-      status: 200,
-      headers: pact_broker_response_headers,
-      body: {
-        _links: {
-          self: {
-            href: Pact.term('http://localhost:1234/pacticipants/Foo', %r{http://.*}),
-          }
-        }
-      }
-    }
-  end
-
-  let(:pact_broker_client_options) { { pact_broker_base_url: broker_base_url} }
-  let(:options) { {} }
-
-  subject { PactBroker::Client::Pacticipants2::Create.call(params, options, pact_broker_client_options) }
-
-  context "when the pacticipant does not already exist" do
-    before do
-      pact_broker
-        .upon_receiving("a request to retrieve a pacticipant")
-        .with(
-            method: :get,
-            path: '/pacticipants/Foo',
-            headers: get_request_headers)
-        .will_respond_with(status: 404)
-
-      pact_broker
-        .upon_receiving("a request to create a pacticipant")
-        .with(
-            method: :post,
-            path: '/pacticipants',
-            headers: post_request_headers,
-            body: request_body)
-        .will_respond_with(create_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 include "Pacticipant \"Foo\" created"
-    end
-  end
-
-  context "when the pacticipant does already exist" do
-    before do
-      pact_broker
-        .given("a pacticipant with name Foo exists")
-        .upon_receiving("a request to retrieve a pacticipant")
-        .with(
-          method: :get,
-          path: '/pacticipants/Foo',
-          headers: get_request_headers)
-        .will_respond_with(get_success_response)
-
-      pact_broker
-        .given("a pacticipant with name Foo exists")
-        .upon_receiving("a request to update a pacticipant")
-        .with(
-          method: :patch,
-          path: '/pacticipants/Foo',
-          headers: post_request_headers,
-          body: request_body)
-        .will_respond_with(create_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 include "Pacticipant \"Foo\" updated"
-    end
-  end
-end

data/spec/service_providers/publish_pacts_spec.rb

@@ -1,114 +0,0 @@
-require 'pact_broker/client/publish_pacts'
-require 'service_providers/pact_helper'
-
-RSpec.describe "publishing contracts", pact: true do
-  before do
-    allow_any_instance_of(PactBroker::Client::Hal::HttpClient).to receive(:sleep)
-    allow_any_instance_of(PactBroker::Client::Hal::HttpClient).to receive(:default_max_tries).and_return(1)
-  end
-  include_context "pact broker"
-  include PactBrokerPactHelperMethods
-
-  let(:pacticipant_name) { "Foo" }
-  let(:version_number) { "5556b8149bf8bac76bc30f50a8a2dd4c22c85f30" }
-  let(:output) { "text" }
-  let(:build_url) { "http://build" }
-  let(:consumer_version_params) do
-    {
-      pacticipant_name: pacticipant_name,
-      number: version_number,
-      tags: ["dev"],
-      branch: "main",
-      build_url: build_url,
-      output: output
-    }
-  end
-  let(:pact_file_path_1) { "spec/fixtures/foo-bar.json" }
-  let(:pact_file_paths) { [pact_file_path_1] }
-  let(:options) { { merge: true } }
-  let(:pact_broker_client_options) { {} }
-  let(:expected_content) { Base64.strict_encode64(JSON.parse(File.read(pact_file_path_1)).to_json) }
-  let(:request_body) do
-    {
-      pacticipantName: pacticipant_name,
-      pacticipantVersionNumber: version_number,
-      branch: "main",
-      tags: ["dev"],
-      buildUrl: "http://build",
-      contracts: [
-        {
-          consumerName: pacticipant_name,
-          providerName: "Bar",
-          specification: "pact",
-          contentType: "application/json",
-          content: expected_content,
-          onConflict: "merge"
-        }
-      ]
-    }
-  end
-
-  subject { PactBroker::Client::PublishPacts.call(broker_base_url, pact_file_paths, consumer_version_params, options, pact_broker_client_options) }
-
-  def mock_index
-    pact_broker
-      .given("the pb:publish-contracts relations exists 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:publish-contracts' => {
-                href: placeholder_url_term("pb:publish-contracts")
-              }
-            }
-          }
-        )
-  end
-
-  def mock_contract_publication
-    pact_broker
-      .upon_receiving("a request to publish contracts")
-      .with(
-          method: "POST",
-          path: '/HAL-REL-PLACEHOLDER-PB-PUBLISH-CONTRACTS',
-          headers: post_request_headers,
-          body: request_body).
-        will_respond_with(
-          status: 200,
-          headers: pact_broker_response_headers,
-          body: {
-            _embedded: {
-              pacticipant: {
-                name: pacticipant_name
-              },
-              version: {
-                number: version_number
-              }
-            },
-            logs: Pact.each_like(level: "info", message: "some message"),
-            _links: {
-              :'pb:pacticipant-version-tags' => [{ name: "dev"} ],
-              :'pb:contracts' => [{ href: Pact.like("http://some-pact") }]
-            }
-          }
-        )
-  end
-
-  context "with valid params" do
-    before do
-      mock_index
-      mock_contract_publication
-    end
-
-    it "returns a success result" do
-      expect(subject.success).to be true
-      expect(subject.message).to include "some message"
-    end
-  end
-end

data/spec/service_providers/record_deployment_spec.rb

@@ -1,199 +0,0 @@
-require 'service_providers/pact_helper'
-require 'pact_broker/client/deployments/record_deployment'
-
-RSpec.describe "recording a deployment", 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(:application_instance) { "blue" }
-  let(:params) do
-    {
-      pacticipant_name: pacticipant_name,
-      version_number: version_number,
-      environment_name: environment_name,
-      application_instance: application_instance
-    }
-  end
-  let(:options) do
-    {
-      output: output
-    }
-  end
-  let(:pact_broker_client_options) { { pact_broker_base_url: broker_base_url } }
-
-  subject { PactBroker::Client::Deployments::RecordDeployment.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_deployment
-    pact_broker
-      .given("version 5556b8149bf8bac76bc30f50a8a2dd4c22c85f30 of pacticipant Foo exists with a test environment available for deployment")
-      .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-deployment" => [
-              {
-                name: "test",
-                href: placeholder_url_term("pb:record-deployment-#{pacticipant_name}-#{version_number}-#{environment_name}")
-              }
-            ]
-          }
-        }
-      )
-  end
-
-  def mock_pacticipant_version_without_test_environment_available_for_deployment
-    pact_broker
-      .given("version 5556b8149bf8bac76bc30f50a8a2dd4c22c85f30 of pacticipant Foo exists with 2 environments that aren't test available for deployment")
-      .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-deployment" => [
-              Pact.like(
-                name: "prod",
-                href: "href"
-              ),
-              Pact.like(
-                name: "dev",
-                href: "href"
-              ),
-            ]
-          }
-        }
-      )
-  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_deployment
-    pact_broker
-      .given("version 5556b8149bf8bac76bc30f50a8a2dd4c22c85f30 of pacticipant Foo exists with a test environment available for deployment")
-      .upon_receiving("a request to record a deployment")
-      .with(
-        method: "POST",
-        path: "/HAL-REL-PLACEHOLDER-PB-RECORD-DEPLOYMENT-FOO-5556B8149BF8BAC76BC30F50A8A2DD4C22C85F30-TEST",
-        headers: post_request_headers,
-        body: {
-          applicationInstance: application_instance,
-          target: application_instance
-        }
-      )
-      .will_respond_with(
-        status: 201,
-        headers: pact_broker_response_headers,
-        body: {
-          target: application_instance
-        }
-      )
-  end
-
-  context "when the deployment is recorded successfully" do
-    before do
-      mock_index
-      mock_pacticipant_version_with_test_environment_available_for_deployment
-      mock_record_deployment
-    end
-
-    it "returns a success message" do
-      expect(subject.success).to be true
-      expect(subject.message).to include "Recorded deployment of Foo version 5556b8149bf8bac76bc30f50a8a2dd4c22c85f30 to test environment (application instance blue) 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 "target" => application_instance
-      end
-    end
-  end
-
-  context "when the specified environment is not available for recording a deployment" do
-    before do
-      mock_index
-      mock_pacticipant_version_without_test_environment_available_for_deployment
-      mock_environments
-    end
-
-    context "when the specified environment does not exist" do
-      let(:environment_name) { "foo" }
-
-      it "returns an error response" do
-        expect(subject.success).to be false
-        expect(subject.message).to include "No environment found"
-      end
-    end
-
-    context "when the specified environment does exist" do
-      it "returns an error response" do
-        expect(subject.success).to be false
-        expect(subject.message).to include "not an available option"
-      end
-    end
-  end
-end