pact_broker 2.89.1 → 2.90.0

data/spec/features/publish_pact_all_in_one_spec.rb

@@ -1,61 +0,0 @@
-RSpec.describe "publishing a pact using the all in one endpoint" do
-  let(:request_body_hash) do
-    {
-      :pacticipantName => "Foo",
-      :pacticipantVersionNumber => "1",
-      :branch => "main",
-      :tags => ["a", "b"],
-      :buildUrl => "http://ci/builds/1234",
-      :contracts => [
-        {
-          :consumerName => "Foo",
-          :providerName => "Bar",
-          :specification => "pact",
-          :contentType => "application/json",
-          :content => encoded_contract,
-          :onConflict => "overwrite",
-        }
-      ]
-    }
-  end
-  let(:rack_headers) { { "CONTENT_TYPE" => "application/json", "HTTP_ACCEPT" => "application/hal+json" } }
-  let(:contract) { { consumer: { name: "Foo" }, provider: { name: "Bar" }, interactions: [] }.to_json }
-  let(:encoded_contract) { Base64.strict_encode64(contract) }
-  let(:path) { "/contracts/publish" }
-
-  subject { post(path, request_body_hash.to_json, rack_headers) }
-
-  it { is_expected.to be_a_hal_json_success_response }
-
-  it "creates a pact" do
-    expect { subject }.to change { PactBroker::Pacts::PactPublication.count }.by(1)
-    expect(PactBroker::Pacts::PactVersion.last.content).to eq contract
-  end
-
-  context "with a validation error" do
-    before do
-      request_body_hash.delete(:pacticipantName)
-    end
-
-    it { is_expected.to be_a_json_error_response("missing") }
-  end
-
-  context "with a conflicting pact" do
-    before do
-      allow(PactBroker.configuration).to receive(:allow_dangerous_contract_modification).and_return(false)
-      td.create_pact_with_hierarchy("Foo", "1", "Bar")
-    end
-
-    its(:status) { is_expected.to eq 409 }
-
-    it "returns notices" do
-      expect(JSON.parse(subject.body)["notices"]).to be_a(Array)
-    end
-
-    it "returns errors" do
-      contract_errors = JSON.parse(subject.body)["errors"]["contracts"]
-      expect(contract_errors).to be_a(Array)
-      expect(contract_errors.size).to eq 1
-    end
-  end
-end

data/spec/features/publish_pact_spec.rb

@@ -1,124 +0,0 @@
-describe "Publishing a pact" do
-
-  let(:pact_content) { load_fixture("a_consumer-a_provider.json") }
-  let(:path) { "/pacts/provider/A%20Provider/consumer/A%20Consumer/versions/1.2.3" }
-  let(:response_body_json) { JSON.parse(subject.body) }
-  let(:rack_env) do
-    {
-      "CONTENT_TYPE" => "application/json",
-      "pactbroker.database_connector" => lambda { |&block| block.call }
-    }
-  end
-
-  subject { put(path, pact_content, rack_env)  }
-
-  context "when a pact for this consumer version does not exist" do
-    it "returns a 201 Created" do
-      expect(subject.status).to be 201
-    end
-
-    it "returns a json body" do
-      expect(subject.headers["Content-Type"]).to eq "application/hal+json;charset=utf-8"
-    end
-
-    it "returns the pact in the body" do
-      expect(response_body_json).to match_pact JSON.parse(pact_content)
-    end
-  end
-
-  context "when a pact for this consumer version does exist" do
-
-    before do
-      td.create_pact_with_hierarchy("A Consumer", "1.2.3", "A Provider").and_return(:pact)
-      allow(PactBroker.configuration).to receive(:allow_dangerous_contract_modification).and_return(allow_dangerous_contract_modification)
-    end
-
-    context "when the content is different" do
-      context "when pact modification is allowed" do
-        let(:allow_dangerous_contract_modification) { true }
-
-        it "returns a 200 Success" do
-          expect(subject.status).to be 200
-        end
-
-        it "returns an application/json Content-Type" do
-          expect(subject.headers["Content-Type"]).to eq "application/hal+json;charset=utf-8"
-        end
-
-        it "returns the pact in the response body" do
-          expect(response_body_json).to match_pact JSON.parse(pact_content)
-        end
-      end
-    end
-
-    context "when pact modification is not allowed" do
-      let(:allow_dangerous_contract_modification) { false }
-
-      its(:status) { is_expected.to eq 409 }
-      its(:body) { is_expected.to include "Cannot change the content of the pact for A Consumer version 1.2.3" }
-    end
-  end
-
-  context "when the pacticipant names in the path do not match those in the pact" do
-    let(:path) { "/pacts/provider/Another%20Provider/consumer/A%20Consumer/version/1.2.3" }
-
-    it "returns a json error response" do
-      expect(subject).to be_a_json_error_response "does not match"
-    end
-  end
-
-  context "when the pacticipant name is an almost duplicate of an existing pacticipant name" do
-    before do
-      td.create_pacticipant("A Provider Service")
-    end
-
-    context "when duplicate checking is on" do
-      before do
-        PactBroker.configuration.check_for_potential_duplicate_pacticipant_names = true
-      end
-
-      it "returns a 409" do
-        expect(subject.status).to eq 409
-      end
-    end
-
-    context "when duplicate checking is off" do
-      before do
-        PactBroker.configuration.check_for_potential_duplicate_pacticipant_names = false
-      end
-
-      it "returns a 201" do
-        expect(subject.status).to eq 201
-      end
-    end
-  end
-
-  context "with a webhook configured", job: true do
-    before do
-      td.create_webhook(
-        method: "POST",
-        url: "http://example.org",
-        events: [{ name: PactBroker::Webhooks::WebhookEvent::CONTRACT_PUBLISHED }]
-      )
-    end
-    let!(:request) do
-      stub_request(:post, "http://example.org").to_return(:status => 200)
-    end
-
-    it "executes the webhook" do
-      subject
-      expect(request).to have_been_made
-    end
-
-    context "when an error occurs rendering the pact" do
-      before do
-        allow_any_instance_of(PactBroker::Api::Decorators::PactDecorator).to receive(:to_json).and_raise("an error")
-      end
-
-      it "does not execute the webhook" do
-        subject
-        expect(request).to_not have_been_made
-      end
-    end
-  end
-end

data/spec/features/publish_verification_results_and_version_spec.rb

@@ -1,70 +0,0 @@
-require "pact_broker/domain/verification"
-
-describe "Publishing a pact verification and provider version" do
-  let(:path) { "/pacts/provider/Provider/consumer/Consumer/pact-version/#{pact.pact_version_sha}/verification-results" }
-  let(:verification_content) { load_fixture("verification.json") }
-  let(:parsed_response_body) { JSON.parse(subject.body) }
-  let(:pact) { td.pact }
-  let(:rack_env) do
-    {
-      "CONTENT_TYPE" => "application/json",
-      "HTTP_ACCEPT" => "application/hal+json",
-      "pactbroker.database_connector" => lambda { |&block| block.call }
-    }
-  end
-
-  subject { post(path, verification_content, rack_env)  }
-
-  before do
-    td.create_provider("Provider")
-      .create_consumer("Consumer")
-      .create_consumer_version("1.0.0")
-      .create_pact
-      .create_consumer_version("1.2.3")
-      .create_pact
-      .revise_pact
-  end
-
-  it "Responds with a 201 Created" do
-    expect(subject.status).to be 201
-  end
-
-  it "saves new verification" do
-    expect { subject }.to change { PactBroker::Domain::Verification.count }.by(1)
-  end
-
-  it "saves the verification against the correct pact" do
-    subject
-    expect(PactBroker::Domain::Verification.order(:id).last.pact_version_sha).to eq pact.pact_version_sha
-  end
-
-  it "saves the test results" do
-    subject
-    expect(PactBroker::Domain::Verification.order(:id).last.test_results).to eq("some" => "results")
-  end
-
-  it "returns a link to itself that can be followed" do
-    get_verification_link = parsed_response_body["_links"]["self"]["href"]
-    get get_verification_link, nil, { "HTTP_ACCEPT" => "application/hal+json" }
-    expect(last_response.status).to be 200
-    expect(JSON.parse(subject.body)).to include JSON.parse(verification_content)
-  end
-
-  context "with a webhook configured", job: true do
-    before do
-      td.create_webhook(
-        method: "POST",
-        url: "http://example.org",
-        events: [{ name: PactBroker::Webhooks::WebhookEvent::VERIFICATION_PUBLISHED }]
-      )
-    end
-    let!(:request) do
-      stub_request(:post, "http://example.org").to_return(:status => 200)
-    end
-
-    it "executes the webhook" do
-      subject
-      expect(request).to have_been_made
-    end
-  end
-end

data/spec/features/publish_verification_spec.rb

@@ -1,72 +0,0 @@
-require "pact_broker/domain/verification"
-
-describe "Publishing a pact verification" do
-
-  let(:td) { TestDataBuilder.new }
-  let(:path) { "/pacts/provider/Provider/consumer/Consumer/pact-version/#{pact.pact_version_sha}/verification-results" }
-  let(:verification_content) { load_fixture("verification.json") }
-  let(:parsed_response_body) { JSON.parse(subject.body) }
-  let(:pact) { td.pact }
-  let(:rack_env) do
-    {
-      "CONTENT_TYPE" => "application/json",
-      "HTTP_ACCEPT" => "application/hal+json",
-      "pactbroker.database_connector" => lambda { |&block| block.call }
-    }
-  end
-
-  subject { post path, verification_content, rack_env; last_response  }
-
-  before do
-    td.create_provider("Provider")
-      .create_consumer("Consumer")
-      .create_consumer_version("1.0.0")
-      .create_pact
-      .create_consumer_version("1.2.3")
-      .create_pact
-      .revise_pact
-  end
-
-  it "Responds with a 201 Created" do
-    expect(subject.status).to be 201
-  end
-
-  it "saves new verification" do
-    expect { subject }.to change { PactBroker::Domain::Verification.count }.by(1)
-  end
-
-  it "saves the verification against the correct pact" do
-    subject
-    expect(PactBroker::Domain::Verification.order(:id).last.pact_version_sha).to eq pact.pact_version_sha
-  end
-
-  it "saves the test results" do
-    subject
-    expect(PactBroker::Domain::Verification.order(:id).last.test_results).to eq("some" => "results")
-  end
-
-  it "returns a link to itself that can be followed" do
-    get_verification_link = parsed_response_body["_links"]["self"]["href"]
-    get get_verification_link, nil, { "HTTP_ACCEPT" => "application/hal+json" }
-    expect(last_response.status).to be 200
-    expect(JSON.parse(subject.body)).to include JSON.parse(verification_content)
-  end
-
-  context "with a webhook configured", job: true do
-    before do
-      td.create_webhook(
-        method: "POST",
-        url: "http://example.org",
-        events: [{ name: PactBroker::Webhooks::WebhookEvent::VERIFICATION_PUBLISHED }]
-      )
-    end
-    let!(:request) do
-      stub_request(:post, "http://example.org").to_return(:status => 200)
-    end
-
-    it "executes the webhook" do
-      subject
-      expect(request).to have_been_made
-    end
-  end
-end

data/spec/features/record_deployment_spec.rb

@@ -1,106 +0,0 @@
-#
-# pact-broker record-deployment --pacticipant Foo --version 1 --environment test --target instance1
-#
-
-describe "Record deployment" do
-  before do
-    td.create_environment("test", uuid: "1234")
-      .create_consumer("Foo")
-      .create_consumer_version("1")
-      .create_deployed_version_for_consumer_version
-      .create_consumer_version("2")
-  end
-  let(:headers) { {"CONTENT_TYPE" => "application/json"} }
-  let(:response_body) { JSON.parse(subject.body, symbolize_names: true) }
-  let(:version_path) { "/pacticipants/Foo/versions/2" }
-  let(:version_response) { get(version_path, nil, { "HTTP_ACCEPT" => "application/hal+json" } ) }
-  let(:application_instance) { nil }
-  let(:path) do
-    JSON.parse(version_response.body)["_links"]["pb:record-deployment"]
-      .find{ |relation| relation["name"] == "test" }
-      .fetch("href")
-  end
-  let(:request_body) { { applicationInstance: application_instance }.to_json }
-
-  subject { post(path, request_body, headers) }
-
-  it { is_expected.to be_a_hal_json_created_response }
-
-  it "returns the Location header" do
-    expect(subject.headers["Location"]).to start_with "http://example.org/deployed-versions/"
-  end
-
-  it "returns the newly created deployment" do
-    expect(response_body[:currentlyDeployed]).to be true
-    expect(response_body).to_not have_key(:target)
-    expect(response_body).to_not have_key(:application_instance)
-  end
-
-  it "creates a new deployed version" do
-    expect { subject }.to change { PactBroker::Deployments::DeployedVersion.count }.by(1)
-  end
-
-  it "marks the previous deployment as not currently deployed" do
-    expect { subject }.to change { PactBroker::Deployments::DeployedVersion.undeployed.count }.by(1)
-  end
-
-  it "does not change the overall count of currently deployed versions" do
-    expect { subject }.to_not change { PactBroker::Deployments::DeployedVersion.currently_deployed.count }
-  end
-
-  context "when the version is already currently deployed to the environment and target" do
-    before do
-      td.create_deployed_version_for_consumer_version(uuid: "1234")
-    end
-
-    it "does not mark anything as undeployed" do
-      expect { subject }.to_not change { PactBroker::Deployments::DeployedVersion.undeployed.collect(&:uuid) }
-    end
-
-    it "returns the existing deployed version" do
-      expect(response_body[:uuid]).to eq "1234"
-    end
-  end
-
-  context "when the version was previously deployed to the environment and target but isn't any more" do
-    before do
-      td.create_deployed_version_for_consumer_version(uuid: "1234")
-        .create_consumer_version("3")
-        .create_deployed_version_for_consumer_version(uuid: "5678")
-    end
-
-    it "creates a new deployed version" do
-      expect { subject }.to change { PactBroker::Deployments::DeployedVersion.count }.by(1)
-    end
-  end
-
-  context "with an empty body" do
-    let(:request_body) { nil }
-
-    it { is_expected.to be_a_hal_json_created_response }
-  end
-
-  context "when the deployment is to a different application instance" do
-    let(:application_instance) { "foo" }
-
-    it "creates a new deployed version" do
-      expect { subject }.to change { PactBroker::Deployments::DeployedVersion.currently_deployed.count }.by(1)
-    end
-
-    it "sets the applicationInstance" do
-      expect(response_body).to have_key(:applicationInstance)
-    end
-  end
-
-  context "when the deployment is to a different target (deprecated)" do
-    let(:request_body) { { target: "foo" }.to_json }
-
-    it "creates a new deployed version" do
-      expect { subject }.to change { PactBroker::Deployments::DeployedVersion.currently_deployed.count }.by(1)
-    end
-
-    it "sets the target" do
-      expect(response_body).to have_key(:target)
-    end
-  end
-end

data/spec/features/record_release_spec.rb

@@ -1,84 +0,0 @@
-#
-# pact-broker record-release --pacticipant Foo --version 1 --environment production
-#
-
-describe "Record release" do
-  before do
-    td.create_environment("production", uuid: "1234")
-      .create_consumer("Foo")
-      .create_consumer_version("1")
-  end
-  let(:headers) { {"CONTENT_TYPE" => "application/json"} }
-  let(:response_body) { JSON.parse(subject.body, symbolize_names: true) }
-  let(:version_path) { "/pacticipants/Foo/versions/1" }
-  let(:version_response) { get(version_path, nil, { "HTTP_ACCEPT" => "application/hal+json" } ) }
-  let(:target) { nil }
-  let(:path) do
-    JSON.parse(version_response.body)["_links"]["pb:record-release"]
-      .find{ |relation| relation["name"] == "production" }
-      .fetch("href")
-  end
-
-  subject { post(path, nil, headers) }
-
-  it { is_expected.to be_a_hal_json_created_response }
-
-  it "returns the Location header" do
-    expect(subject.headers["Location"]).to start_with "http://example.org/released-versions/"
-  end
-
-  it "returns the newly created release" do
-    expect(response_body[:currentlySupported]).to be true
-  end
-
-  it "creates a new released version" do
-    expect { subject }.to change { PactBroker::Deployments::ReleasedVersion.count }.by(1)
-  end
-
-  context "when the version is already released" do
-    before do
-      td.create_released_version_for_consumer_version(uuid: "1234")
-    end
-
-    it "returns the Location header" do
-      expect(subject.headers["Location"]).to include "1234"
-    end
-
-    it "does not change the overall count of released versions" do
-      expect { subject }.to_not change { PactBroker::Deployments::ReleasedVersion.count }
-    end
-
-    it "returns the existing released version" do
-      expect(response_body[:uuid]).to eq "1234"
-    end
-
-    it { is_expected.to be_a_hal_json_success_response }
-  end
-
-  context "when the version is currently unsupported" do
-    before do
-      td.create_released_version_for_consumer_version(uuid: "1234", currently_supported: false, created_at: DateTime.now - 1 )
-    end
-
-    it "returns the Location header" do
-      expect(subject.headers["Location"]).to include "1234"
-    end
-
-    it "returns the existing release with the currentlySupported parameter set back to true" do
-      expect(response_body[:currentlySupported]).to be true
-    end
-
-    it "does not change the createdAt" do
-      expect { subject }.to_not change { PactBroker::Deployments::ReleasedVersion.find(uuid: "1234").created_at }
-    end
-
-    it "updates the updatedAt" do
-      expect { subject }.to change { PactBroker::Deployments::ReleasedVersion.find(uuid: "1234").updated_at }
-    end
-  end
-
-  it "creates a released version resource" do
-    get(subject.headers["Location"])
-    expect(last_response.status).to eq 200
-  end
-end

data/spec/features/record_undeployment_spec.rb

@@ -1,67 +0,0 @@
-RSpec.describe "Record undeployment" do
-  let!(:version) { td.create_consumer("Foo").create_consumer_version("1").and_return(:consumer_version) }
-  let!(:test_environment) { td.create_environment("test").and_return(:environment) }
-  let!(:deployed_version) do
-    td.create_deployed_version_for_consumer_version(environment_name: "test", target: "customer-1", created_at: DateTime.now - 2, currently_deployed: currently_deployed)
-      .and_return(:deployed_version)
-  end
-  let(:currently_deployed) { true }
-  let(:path) { PactBroker::Api::PactBrokerUrls.deployed_version_url(deployed_version) }
-  let(:request_body) { { currentlyDeployed: false }.to_json }
-  let(:response_body_hash) { JSON.parse(subject.body) }
-  let(:rack_headers) do
-    { "HTTP_ACCEPT" => "application/hal+json", "CONTENT_TYPE" => "application/merge-patch+json" }
-  end
-
-  subject { patch(path, request_body, rack_headers) }
-
-  it "marks the deployed version as not currently deployed" do
-    expect{ subject }.to change {
-      PactBroker::Deployments::DeployedVersion.find(uuid: deployed_version.uuid).currently_deployed
-    }.from(true).to(false)
-  end
-
-  it "returns the updated resource" do
-    expect(response_body_hash["currentlyDeployed"]).to be false
-    expect(response_body_hash["undeployedAt"]).to_not be nil
-  end
-
-  context "with an empty body" do
-    let(:request_body) { {}.to_json }
-
-    it "does nothing to the resource" do
-      expect{ subject }.to_not change {
-        PactBroker::Deployments::DeployedVersion.find(uuid: deployed_version.uuid).values
-      }
-    end
-
-    it "returns the resource" do
-      expect(response_body_hash["uuid"]).to eq deployed_version.uuid
-    end
-  end
-
-  context "when the version is already undeployed" do
-    let(:currently_deployed) { false }
-
-    it "returns the resource" do
-      expect(response_body_hash["currentlyDeployed"]).to be false
-      expect(response_body_hash["undeployedAt"]).to_not be nil
-    end
-
-    it "does not change the undeployedAt date" do
-      expect{ subject }.to_not change {
-        PactBroker::Deployments::DeployedVersion.find(uuid: deployed_version.uuid).undeployed_at
-      }
-    end
-
-    context "when trying to mark it as currentlyDeployed again" do
-      let(:request_body) { { currentlyDeployed: true }.to_json }
-
-      its(:status) { is_expected.to eq 422 }
-
-      it "returns an error" do
-        expect(response_body_hash["errors"]["currentlyDeployed"].first).to include "cannot be set back"
-      end
-    end
-  end
-end

data/spec/features/tag_version_spec.rb

@@ -1,13 +0,0 @@
-describe "tagging a pacticipant version" do
-  let(:path) { "/pacticipants/Foo/versions/1.2.3/tags/feat%2Fbar" }
-
-  subject { put path, nil, {"CONTENT_TYPE" => "application/json"}; last_response }
-
-  context "when the pacticipant/version/tag do not exist" do
-    it "creates a tag" do
-      expect{ subject }.to change {
-        PactBroker::Domain::Tag.where(name: "feat/bar").count
-      }.by(1)
-    end
-  end
-end

data/spec/features/update_environment_spec.rb

@@ -1,44 +0,0 @@
-require "pact_broker/api/pact_broker_urls"
-
-describe "Updating an environment" do
-  before do
-    td.create_environment("test", uuid: "1234", contacts: [ { name: "Foo" } ] )
-  end
-  let(:path) { PactBroker::Api::PactBrokerUrls.environment_url(td.and_return(:environment)) }
-  let(:headers) { {"CONTENT_TYPE" => "application/json"} }
-  let(:response_body) { JSON.parse(last_response.body, symbolize_names: true)}
-  let(:environment_hash) do
-    {
-      name: "test",
-      production: false,
-      displayName: "Testing"
-    }
-  end
-
-  subject { put(path, environment_hash.to_json, headers) }
-
-  it { is_expected.to be_a_hal_json_success_response }
-
-  it "returns the updated environment" do
-    subject
-    expect(response_body[:displayName]).to eq "Testing"
-    expect(response_body[:contacts]).to be nil
-  end
-
-  context "when the environment doesn't exist" do
-    let(:path) { "/environments/5678" }
-
-    it "returns a 404" do
-      expect(subject.status).to eq 404
-    end
-  end
-
-  context "with invalid params" do
-    let(:environment_hash) { {} }
-
-    it "returns a 400 response" do
-      expect(subject.status).to be 400
-      expect(response_body[:errors]).to_not be nil
-    end
-  end
-end