pact_broker 2.89.1 → 2.90.0

data/spec/features/create_webhook_spec.rb

@@ -1,189 +0,0 @@
-describe "Creating a webhook" do
-  before do
-    td.create_pact_with_hierarchy("Some Consumer", "1", "Some Provider")
-  end
-
-  let(:headers) { {"CONTENT_TYPE" => "application/json"} }
-  let(:response_body) { JSON.parse(subject.body, symbolize_names: true)}
-  let(:webhook_json) { webhook_hash.to_json }
-  let(:provider) { nil }
-  let(:consumer) { nil }
-  let(:webhook_hash) do
-    {
-      description: "trigger build",
-      enabled: false,
-      provider: provider,
-      consumer: consumer,
-      events: [{
-        name: "contract_content_changed"
-      }],
-      request: {
-        method: "POST",
-        url: "https://example.org",
-        headers: {
-          :"Content-Type" => "application/json"
-        },
-        body: {
-          a: "body"
-        }
-      }
-    }.compact
-  end
-
-  subject { post(path, webhook_json, headers) }
-
-  context "for a consumer and provider" do
-    let(:path) { "/webhooks/provider/Some%20Provider/consumer/Some%20Consumer" }
-
-    context "with invalid attributes" do
-      let(:webhook_hash) { {} }
-
-      its(:status) { is_expected.to be 400 }
-
-      it "returns a JSON content type" do
-        expect(subject.headers["Content-Type"]).to eq "application/hal+json;charset=utf-8"
-      end
-
-      it "returns the validation errors" do
-        expect(response_body[:errors]).to_not be_empty
-      end
-    end
-
-    context "with valid attributes" do
-      its(:status) { is_expected.to be 201 }
-
-      it "returns the Location header" do
-        expect(subject.headers["Location"]).to match(%r{http://example.org/webhooks/.+})
-      end
-
-      it "returns a JSON Content Type" do
-        expect(subject.headers["Content-Type"]).to eq "application/hal+json;charset=utf-8"
-      end
-
-      it "returns the newly created webhook" do
-        expect(response_body).to include webhook_hash
-      end
-    end
-  end
-
-  context "for a provider" do
-    let(:path) { "/webhooks" }
-    let(:provider) { { name: "Some Provider" } }
-
-    its(:status) { is_expected.to eq 201 }
-
-    it "creates a webhook without a consumer" do
-      subject
-      expect(PactBroker::Webhooks::Webhook.first.provider).to_not be nil
-      expect(PactBroker::Webhooks::Webhook.first.consumer).to be nil
-    end
-
-    context "with label" do
-      let(:provider) { { label: "my_label" } }
-
-      its(:status) { is_expected.to eq 201 }
-
-      it "creates a webhook without explicit consumer and provider with provider label" do
-        subject
-        expect(PactBroker::Webhooks::Webhook.first.provider).to be nil
-        expect(PactBroker::Webhooks::Webhook.first.consumer).to be nil
-        expect(PactBroker::Webhooks::Webhook.first.provider_label).to eq "my_label"
-      end
-    end
-
-    context "with both label and name" do
-      let(:provider) { { name: "Some Provider", label: "my_label" } }
-
-      its(:status) { is_expected.to eq 400 }
-
-      it "returns the validation errors" do
-        expect(response_body[:errors]).to_not be_empty
-      end
-    end
-  end
-
-  context "for a consumer" do
-    let(:path) { "/webhooks" }
-    let(:consumer) { { name: "Some Consumer" } }
-
-    its(:status) { is_expected.to eq 201 }
-
-    it "creates a webhook without a provider" do
-      subject
-      expect(PactBroker::Webhooks::Webhook.first.consumer).to_not be nil
-      expect(PactBroker::Webhooks::Webhook.first.provider).to be nil
-    end
-
-    context "with label" do
-      let(:consumer) { { label: "my_label" } }
-
-      its(:status) { is_expected.to eq 201 }
-
-      it "creates a webhook without explicit consumer and provider with consumer label" do
-        subject
-        expect(PactBroker::Webhooks::Webhook.first.provider).to be nil
-        expect(PactBroker::Webhooks::Webhook.first.consumer).to be nil
-        expect(PactBroker::Webhooks::Webhook.first.consumer_label).to eq "my_label"
-      end
-    end
-
-    context "with both label and name" do
-      let(:consumer) { { name: "Some Consumer", label: "my_label" } }
-
-      its(:status) { is_expected.to eq 400 }
-
-      it "returns the validation errors" do
-        expect(response_body[:errors]).to_not be_empty
-      end
-    end
-  end
-
-  context "with no consumer or provider" do
-    let(:path) { "/webhooks" }
-
-    its(:status) { is_expected.to be 201 }
-
-    it "creates a webhook without a provider" do
-      subject
-      expect(PactBroker::Webhooks::Webhook.first.consumer).to be nil
-      expect(PactBroker::Webhooks::Webhook.first.provider).to be nil
-    end
-  end
-
-  context "with a UUID" do
-    let(:path) { "/webhooks/1234123412341234" }
-
-    before do
-      webhook_hash[:provider] = { name: "Some Provider" }
-      webhook_hash[:consumer] = { name: "Some Consumer" }
-    end
-
-    subject { put(path, webhook_json, headers) }
-
-    its(:status) { is_expected.to be 201 }
-
-    it "is expected to have a consumer and provider" do
-      subject
-      expect(PactBroker::Webhooks::Webhook.first.consumer).to_not be nil
-      expect(PactBroker::Webhooks::Webhook.first.provider).to_not be nil
-    end
-  end
-
-  context "with the old path" do
-    let(:path) { "/pacts/provider/Some%20Provider/consumer/Some%20Consumer/webhooks" }
-
-    its(:status) { is_expected.to be 201 }
-
-    it "returns the Location header" do
-      expect(subject.headers["Location"]).to match(%r{http://example.org/webhooks/.+})
-    end
-
-    it "returns a JSON Content Type" do
-      expect(subject.headers["Content-Type"]).to eq "application/hal+json;charset=utf-8"
-    end
-
-    it "returns the newly created webhook" do
-      expect(response_body).to include webhook_hash
-    end
-  end
-end

data/spec/features/delete_environment_spec.rb

@@ -1,16 +0,0 @@
-require "pact_broker/api/pact_broker_urls"
-
-describe "Deleting an environment" do
-  before do
-    td.create_environment("test", uuid: "1234")
-  end
-
-  let(:path) { PactBroker::Api::PactBrokerUrls.environment_url(td.and_return(:environment)) }
-
-  subject { delete(path, nil) }
-
-  it "returns a 204 response" do
-    subject
-    expect(last_response.status).to be 204
-  end
-end

data/spec/features/delete_integration_spec.rb

@@ -1,27 +0,0 @@
-describe "Deleting an integration" do
-
-  let(:path) { "/integrations/provider/Bar/consumer/Foo" }
-
-  subject { delete(path)  }
-
-  context "when the integration exists" do
-    before do
-      TestDataBuilder.new
-        .create_pact_with_hierarchy("Foo", "1.2.3", "Bar")
-    end
-
-    it "deletes the resource associated with the integration" do
-      expect{ subject }.to change{ PactBroker::Pacts::PactPublication.count }.by(-1)
-    end
-
-    it "returns a 204" do
-      expect(subject.status).to be 204
-    end
-  end
-
-  context "when the integration does not exist" do
-    it "returns a 404 Not Found" do
-      expect(subject.status).to be 404
-    end
-  end
-end

data/spec/features/delete_label_spec.rb

@@ -1,28 +0,0 @@
-describe "Deleting a label" do
-
-  before do
-    TestDataBuilder.new
-      .create_pacticipant("foo")
-      .create_label("ios")
-      .create_label("consumer")
-      .create_pacticipant("bar")
-      .create_label("ios")
-      .create_label("consumer")
-  end
-
-  let(:path) { "/pacticipants/foo/labels/ios" }
-  let(:response_body_hash) { JSON.parse(subject.body, symbolize_names: true) }
-  let(:expected_response_body) { {name: "ios"} }
-
-  subject { delete path; last_response  }
-
-  context "when the label exists" do
-    it "returns a 204 No Content" do
-      expect(subject.status).to be 204
-    end
-
-    it "deletes the label" do
-      expect { subject }.to change { PactBroker::Domain::Label.count }.by(-1)
-    end
-  end
-end

data/spec/features/delete_pact_spec.rb

@@ -1,31 +0,0 @@
-describe "Deleting a pact" do
-
-  let(:pact_content) { load_fixture("a_consumer-a_provider.json") }
-  let(:path) { "/pacts/provider/A%20Provider/consumer/A%20Consumer/version/1.2.3" }
-  let(:response_body_json) { JSON.parse(subject.body) }
-
-  subject { delete path; last_response  }
-
-  context "when the pact exists" do
-    before do
-      TestDataBuilder.new
-        .create_pact_with_hierarchy("A Consumer", "1.2.3", "A Provider")
-        .create_webhook
-        .create_triggered_webhook
-    end
-
-    it "deletes the pact" do
-      expect{ subject }.to change{ PactBroker::Pacts::PactPublication.count }.by(-1)
-    end
-
-    it "returns a 200" do
-      expect(subject.status).to be 200
-    end
-  end
-
-  context "when the pact does not exist" do
-    it "returns a 404 Not Found" do
-      expect(subject.status).to be 404
-    end
-  end
-end

data/spec/features/delete_pact_versions_for_branch_spec.rb

@@ -1,34 +0,0 @@
-describe "Deleting pact versions for branch" do
-
-  let(:path) { "/pacts/provider/Bar/consumer/Foo/branch/main" }
-
-  subject { delete(path)  }
-
-  context "when the pact exists" do
-    before do
-      td.create_consumer("Foo")
-        .create_provider("Bar")
-        .create_consumer_version("1", branch: "main")
-        .create_pact
-        .create_consumer_version("2", branch: "not-main")
-        .create_pact
-        .create_consumer("NotFoo")
-        .create_consumer_version("1", branch: "main")
-        .create_pact
-    end
-
-    it "deletes the pacts for the relevant branch" do
-      expect{ subject }.to change{ PactBroker::Pacts::PactPublication.count }.by(-1)
-    end
-
-    it "returns a 200" do
-      expect(subject.status).to be 200
-    end
-  end
-
-  context "when the pact does not exist" do
-    it "returns a 404 Not Found" do
-      expect(subject.status).to be 404
-    end
-  end
-end

data/spec/features/delete_pact_versions_spec.rb

@@ -1,29 +0,0 @@
-describe "Deleting pact versions" do
-
-  let(:path) { "/pacts/provider/Bar/consumer/Foo/versions" }
-
-  subject { delete(path)  }
-
-  context "when the pact exists" do
-    before do
-      TestDataBuilder.new
-        .create_pact_with_hierarchy("Foo", "1.2.3", "Bar")
-        .create_provider("Baz")
-        .create_pact
-    end
-
-    it "deletes the pacts" do
-      expect{ subject }.to change{ PactBroker::Pacts::PactPublication.count }.by(-1)
-    end
-
-    it "returns a 204" do
-      expect(subject.status).to be 204
-    end
-  end
-
-  context "when the pact does not exist" do
-    it "returns a 404 Not Found" do
-      expect(subject.status).to be 404
-    end
-  end
-end

data/spec/features/delete_tagged_pact_versions_spec.rb

@@ -1,28 +0,0 @@
-describe "Deleting tagged pact versions" do
-
-  let(:path) { "/pacts/provider/Bar/consumer/Foo/tag/prod" }
-
-  subject { delete(path)  }
-
-  context "when the pact exists" do
-    before do
-      TestDataBuilder.new
-        .create_pact_with_hierarchy("Foo", "1.2.3", "Bar")
-        .create_consumer_version_tag("prod")
-    end
-
-    it "deletes the pact" do
-      expect{ subject }.to change{ PactBroker::Pacts::PactPublication.count }.by(-1)
-    end
-
-    it "returns a 200" do
-      expect(subject.status).to be 200
-    end
-  end
-
-  context "when the pact does not exist" do
-    it "returns a 404 Not Found" do
-      expect(subject.status).to be 404
-    end
-  end
-end

data/spec/features/delete_verification_spec.rb

@@ -1,27 +0,0 @@
-require "support/test_data_builder"
-require "pact_broker/api/pact_broker_urls"
-
-describe "Delete a verification" do
-  let!(:verification) do
-    TestDataBuilder.new
-      .create_pact_with_verification("Foo", "1", "Bar", "2")
-      .create_provider_webhook(event_names: ["provider_verification_published"])
-      .create_triggered_webhook
-      .create_webhook_execution
-      .and_return(:verification)
-  end
-
-  let(:path) { PactBroker::Api::PactBrokerUrls.verification_url(verification, "") }
-  let(:response_body) { JSON.parse(last_response.body, symbolize_names: true)}
-
-  subject { delete(path) }
-
-  it "deletes the verification" do
-    expect { subject }.to change { PactBroker::Domain::Verification.count }.by(-1)
-  end
-
-  it "returns a 204 response" do
-    subject
-    expect(last_response.status).to eq 204
-  end
-end

data/spec/features/delete_version_spec.rb

@@ -1,22 +0,0 @@
-require "spec/support/test_data_builder"
-
-describe "Delete version" do
-
-  let(:path) { "/pacticipants/Consumer/versions/1.2.3" }
-  let(:last_response_body) { JSON.parse(subject.body, symbolize_names: true) }
-
-  subject { delete path; last_response }
-
-  before do
-    TestDataBuilder.new
-      .create_consumer("Another Consumer")
-      .create_consumer("Consumer")
-      .create_consumer_version("1.2.3")
-      .create_consumer_version_tag("prod")
-      .create_consumer_version("1.2.4")
-  end
-
-  it "returns a 200 HAL JSON response" do
-    expect(subject.status).to eq 204
-  end
-end

data/spec/features/delete_webhook_spec.rb

@@ -1,34 +0,0 @@
-require "support/test_data_builder"
-
-describe "Delete a webhook" do
-
-  let!(:webhook) do
-    TestDataBuilder.new
-      .create_consumer("Some Consumer")
-      .create_consumer_version("Some Provider")
-      .create_provider
-      .create_pact
-      .create_webhook
-      .create_triggered_webhook
-      .and_return(:webhook)
-  end
-
-  let(:path) { "/webhooks/#{webhook.uuid}" }
-  let(:response_body) { JSON.parse(last_response.body, symbolize_names: true)}
-  let(:webhook_json) { webhook_hash.to_json }
-
-  subject { delete path }
-
-  it "deletes the webhook" do
-    expect { subject }.to change { PactBroker::Webhooks::Webhook.count }.by(-1)
-  end
-
-  it "returns a 204 response" do
-    subject
-    expect(last_response.status).to eq 204
-  end
-
-  it "does not delete the triggered webhooks because these are needed to calculate the webhook status" do
-    expect { subject }.to_not change { PactBroker::Webhooks::TriggeredWebhook.count }
-  end
-end

data/spec/features/edit_webhook_spec.rb

@@ -1,61 +0,0 @@
-require "support/test_data_builder"
-
-describe "Creating a webhook" do
-
-  let(:td) { TestDataBuilder.new }
-
-  before do
-    td.create_pact_with_hierarchy("Some Consumer", "1", "Some Provider")
-      .create_webhook
-  end
-
-  let(:path) { "/webhooks/#{td.webhook.uuid}" }
-  let(:headers) { {"CONTENT_TYPE" => "application/json"} }
-  let(:response_body) { JSON.parse(last_response.body, symbolize_names: true)}
-  let(:webhook_json) do
-    h = load_json_fixture("webhook_valid.json")
-    h["request"]["url"] = "https://bar.com"
-    h.to_json
-  end
-
-  let(:reloaded_webhook) { PactBroker::Webhooks::Repository.new.find_by_uuid(td.webhook.uuid) }
-
-  subject { put path, webhook_json, headers; last_response }
-
-  context "with invalid attributes" do
-    let(:webhook_json) { "{}" }
-
-    it "returns a 400" do
-      subject
-      expect(last_response.status).to be 400
-    end
-
-    it "returns the validation errors" do
-      subject
-      expect(response_body[:errors]).to_not be_empty
-    end
-
-    it "does not update the webhook" do
-      expect(reloaded_webhook.request.method).to eq "POST"
-    end
-  end
-
-  context "with valid attributes" do
-    let(:webhook_hash) { JSON.parse(webhook_json, symbolize_names: true) }
-
-    it "returns a 200 response" do
-      subject
-      expect(last_response.status).to be 200
-    end
-
-    it "returns a JSON Content Type" do
-      subject
-      expect(last_response.headers["Content-Type"]).to eq "application/hal+json;charset=utf-8"
-    end
-
-    it "updates the webhook" do
-      subject
-      expect(reloaded_webhook.request.url).to eq "https://bar.com"
-    end
-  end
-end

data/spec/features/end_deployment_spec.rb

@@ -1,29 +0,0 @@
-#
-# RPC style seems cleaner than REST here, as setting the endedAt parameter directly
-# seems likely to end in Timezone tears
-# This endpoint would be called by the pact broker client during `record-deployment` if the
-# --end-previous-deployment (on by default) was specified.
-# This allows us to know exactly what is deployed to a particular environment at a given time,
-# (eg. /environments/test/deployments/current)
-# and provides first class support for mobile clients that have multiple versions in prod
-# at once.
-
-describe "Record deployment ended", skip: "Not yet implemented" do
-  before do
-    td.create_environment("test")
-      .create_pacticipant("Foo")
-      .create_pacticipant_version("1")
-      .create_deployment("test")
-  end
-  let(:path) { "/pacticipants/Foo/deployments/test/latest/end" }
-  let(:headers) { {} }
-  let(:response_body) { JSON.parse(last_response.body, symbolize_names: true) }
-
-  subject { post(path, nil, headers) }
-
-  it { is_expected.be_a_hal_json_success_response }
-
-  it "returns the updated deployment" do
-    expect(subject[:endedAt]).to_not be nil
-  end
-end

data/spec/features/end_support_spec.rb

@@ -1,67 +0,0 @@
-RSpec.describe "End support" 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!(:released_version) do
-    td.create_released_version_for_consumer_version(environment_name: "test", created_at: DateTime.now - 2, currently_supported: currently_supported)
-      .and_return(:released_version)
-  end
-  let(:currently_supported) { true }
-  let(:path) { PactBroker::Api::PactBrokerUrls.released_version_url(released_version) }
-  let(:request_body) { { currentlySupported: 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 supported" do
-    expect{ subject }.to change {
-      PactBroker::Deployments::ReleasedVersion.find(uuid: released_version.uuid).currently_supported
-    }.from(true).to(false)
-  end
-
-  it "returns the updated resource" do
-    expect(response_body_hash["currentlySupported"]).to be false
-    expect(response_body_hash["supportEndedAt"]).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::ReleasedVersion.find(uuid: released_version.uuid).values
-      }
-    end
-
-    it "returns the resource" do
-      expect(response_body_hash["uuid"]).to eq released_version.uuid
-    end
-  end
-
-  context "when the version is already unsupported" do
-    let(:currently_supported) { false }
-
-    it "returns the resource" do
-      expect(response_body_hash["currentlySupported"]).to be false
-      expect(response_body_hash["supportEndedAt"]).to_not be nil
-    end
-
-    it "does not change the supportEndedAt date" do
-      expect{ subject }.to_not change {
-        PactBroker::Deployments::ReleasedVersion.find(uuid: released_version.uuid).support_ended_at
-      }
-    end
-
-    context "when trying to mark it as currentlySupported again" do
-      let(:request_body) { { currentlySupported: true }.to_json }
-
-      its(:status) { is_expected.to eq 422 }
-
-      it "returns an error" do
-        expect(response_body_hash["errors"]["currentlySupported"].first).to include "cannot be set back"
-      end
-    end
-  end
-end

data/spec/features/execute_unsaved_webhook_spec.rb

@@ -1,53 +0,0 @@
-require "support/test_data_builder"
-require "webmock/rspec"
-require "rack/pact_broker/database_transaction"
-
-describe "Execute a webhook" do
-  before do
-    td.create_pact_with_hierarchy("Foo", "1", "Bar")
-    allow(PactBroker.configuration).to receive(:webhook_scheme_whitelist).and_return(%w[http])
-  end
-
-  let(:params) do
-    {
-      request: {
-        method: "POST",
-        url: "http://example.org",
-        headers: {"Content-Type" => "application/json"},
-        body: "${pactbroker.pactUrl}"
-      }
-    }
-  end
-  let(:rack_headers) { { "CONTENT_TYPE" => "application/json", "HTTP_ACCEPT" => "application/hal+json" } }
-
-  let(:path) { "/webhooks/execute" }
-  let(:response_body) { JSON.parse(last_response.body, symbolize_names: true)}
-
-  subject { post(path, params.to_json, rack_headers) }
-
-  context "when the execution is successful" do
-    let!(:request) do
-      stub_request(:post, /http/).with(body: expected_webhook_url).to_return(:status => 200, body: response_body)
-    end
-
-    let(:expected_webhook_url) { %r{http://example.org/pacts/provider/Bar/consumer/Foo.*} }
-    let(:response_body) { "webhook-response-body" }
-
-    it "performs the HTTP request" do
-      subject
-      expect(request).to have_been_made
-    end
-
-    it "returns a 200 response" do
-      expect(subject.status).to be 200
-    end
-  end
-
-  context "when there is a validation error" do
-    let(:params) { {} }
-
-    it "returns a 400" do
-      expect(subject.status).to be 400
-    end
-  end
-end