pact_broker 2.89.1 → 2.90.0

data/spec/features/execute_webhook_spec.rb

@@ -1,92 +0,0 @@
-require "webmock/rspec"
-require "rack/pact_broker/database_transaction"
-
-describe "Execute a webhook" do
-  before do
-    td.create_pact_with_hierarchy("Foo", "1", "Bar")
-      .create_webhook(method: "POST", body: "${pactbroker.pactUrl}")
-  end
-
-  let(:path) { "/webhooks/#{td.webhook.uuid}/execute" }
-  let(:response_body) { JSON.parse(last_response.body, symbolize_names: true)}
-
-  subject { post(path) }
-
-  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/pact-version/.*/metadata/.*} }
-    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
-
-    it "does not save a TriggeredWebhook" do
-      expect { subject }.to_not change { PactBroker::Webhooks::TriggeredWebhook.count }
-    end
-
-    it "does not save a WebhookExecution" do
-      expect { subject }.to_not change { PactBroker::Webhooks::Execution.count }
-    end
-
-    context "when a webhook host whitelist is not configured" do
-      before do
-        allow(PactBroker.configuration).to receive(:show_webhook_response?).and_return(false)
-      end
-
-      it "does not show any response details" do
-        expect(subject.body).to_not include response_body
-      end
-    end
-
-    context "when a webhook host whitelist is configured" do
-      before do
-        allow(PactBroker.configuration).to receive(:show_webhook_response?).and_return(true)
-      end
-
-      it "includes response details" do
-        expect(subject.body).to include response_body
-      end
-    end
-  end
-
-  context "when an error occurs", no_db_clean: true do
-    let(:app) { Rack::PactBroker::DatabaseTransaction.new(PactBroker::API, PactBroker::DB.connection) }
-
-    let!(:request) do
-      stub_request(:post, /http/).to_raise(Errno::ECONNREFUSED)
-    end
-
-    before do
-      PactBroker::Database.truncate
-      td.create_pact_with_hierarchy("Some Consumer", "1", "Some Provider")
-        .create_webhook(method: "POST")
-    end
-
-    after do
-      PactBroker::Database.truncate
-    end
-
-    subject { post(path) }
-
-    it "returns a 200 response" do
-      expect(subject.status).to be 200
-    end
-
-    it "does not save a TriggeredWebhook" do
-      expect { subject }.to_not change { PactBroker::Webhooks::TriggeredWebhook.count }
-    end
-
-    it "does not save a WebhookExecution" do
-      expect { subject }.to_not change { PactBroker::Webhooks::Execution.count }
-    end
-  end
-end

data/spec/features/get_branch_version_spec.rb

@@ -1,12 +0,0 @@
-describe "Get a branch version" do
-  before do
-    td.create_consumer("Foo")
-      .create_consumer_version("1234", branch: "main")
-  end
-  let(:path) { PactBroker::Api::PactBrokerUrls.branch_version_url(PactBroker::Versions::BranchVersion.first) }
-  let(:headers) { { "CONTENT_TYPE" => "application/json" } }
-
-  subject { get(path, {}, headers) }
-
-  it { is_expected.to be_a_hal_json_success_response }
-end

data/spec/features/get_can_i_deploy_badge_spec.rb

@@ -1,13 +0,0 @@
-RSpec.describe "can i deploy badge" do
-  before do
-    td.create_pact_with_hierarchy("Foo", "1.2.3", "Bar")
-      .create_consumer_version_tag("main")
-  end
-
-  subject { get("/pacticipants/Foo/latest-version/main/can-i-deploy/to/prod/badge", nil, { "HTTP_ACCEPT" => "image/svg+xml"}) }
-
-  it "returns a redirect response" do
-    expect(subject.status).to eq 307
-    expect(subject.headers["Location"]).to start_with "https://img.shields.io/badge"
-  end
-end

data/spec/features/get_currently_deployed_versions_for_environment_spec.rb

@@ -1,76 +0,0 @@
-RSpec.describe "Get currently deployed versions for environment" 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!(:prod_environment) { td.create_environment("prod").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)
-      .create_deployed_version_for_consumer_version(environment_name: "prod", created_at: DateTime.now - 1)
-      .create_provider("Bar")
-      .create_provider_version("4")
-      .create_deployed_version_for_provider_version(environment_name: "test", target: "customer-1")
-      .create_provider_version("5")
-      .create_deployed_version_for_provider_version(environment_name: "test")
-  end
-
-  let(:path) do
-    PactBroker::Api::PactBrokerUrls.currently_deployed_versions_for_environment_url(test_environment)
-  end
-
-  let(:query_params) { {} }
-  let(:response_body_hash) { JSON.parse(subject.body, symbolize_names: true) }
-
-  subject { get(path, query_params, { "HTTP_ACCEPT" => "application/hal+json" }) }
-
-  it "returns a list of deployed versions" do
-    expect(response_body_hash[:_embedded][:deployedVersions]).to be_a(Array)
-    expect(response_body_hash[:_embedded][:deployedVersions].size).to eq 3
-    expect(response_body_hash[:_links][:self][:title]).to eq "Currently deployed versions for Test"
-    expect(response_body_hash[:_links][:self][:href]).to end_with(path)
-  end
-
-  context "with query params" do
-    context "with a pacticipant name and applicationInstance" do
-      let(:query_params) { { pacticipant: "Bar", applicationInstance: "customer-1" } }
-
-      it "returns a list of matching deployed versions" do
-        expect(response_body_hash[:_embedded][:deployedVersions].size).to eq 1
-        expect(response_body_hash[:_embedded][:deployedVersions].first[:_embedded][:version][:number]).to eq "4"
-      end
-    end
-
-    context "with pacticipant name and a blank applicationInstance" do
-      let(:query_params) { { pacticipant: "Bar", applicationInstance: "" } }
-
-      it "returns a list of matching deployed versions" do
-        expect(response_body_hash[:_embedded][:deployedVersions].size).to eq 1
-        expect(response_body_hash[:_embedded][:deployedVersions].first[:_embedded][:version][:number]).to eq "5"
-      end
-    end
-
-    context "with pacticipant name and no target or applicationInstance" do
-      let(:query_params) { { pacticipant: "Bar" } }
-
-      it "returns a list of matching deployed versions" do
-        expect(response_body_hash[:_embedded][:deployedVersions].size).to eq 2
-      end
-    end
-
-    context "with a pacticipant name and target (deprecated)" do
-      let(:query_params) { { pacticipant: "Bar", target: "customer-1" } }
-
-      it "returns a list of matching deployed versions" do
-        expect(response_body_hash[:_embedded][:deployedVersions].size).to eq 1
-        expect(response_body_hash[:_embedded][:deployedVersions].first[:_embedded][:version][:number]).to eq "4"
-      end
-    end
-
-    context "with pacticipant name and a blank target (deprecated)" do
-      let(:query_params) { { pacticipant: "Bar", target: "" } }
-
-      it "returns a list of matching deployed versions" do
-        expect(response_body_hash[:_embedded][:deployedVersions].size).to eq 1
-        expect(response_body_hash[:_embedded][:deployedVersions].first[:_embedded][:version][:number]).to eq "5"
-      end
-    end
-  end
-end

data/spec/features/get_currently_deployed_versions_for_version_spec.rb

@@ -1,27 +0,0 @@
-RSpec.describe "Get currently deployed versions for version" 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!(:prod_environment) { td.create_environment("prod").and_return(:environment) }
-  let!(:deployed_version) do
-    td.create_deployed_version_for_consumer_version(environment_name: "test", created_at: DateTime.now - 2)
-      .create_deployed_version_for_consumer_version(environment_name: "prod", created_at: DateTime.now - 1)
-  end
-
-  let(:path) do
-    PactBroker::Api::PactBrokerUrls.deployed_versions_for_version_and_environment_url(
-      version,
-      test_environment
-    )
-  end
-
-  let(:response_body_hash) { JSON.parse(subject.body, symbolize_names: true) }
-
-  subject { get(path, nil, { "HTTP_ACCEPT" => "application/hal+json" }) }
-
-  it "returns a list of deployed versions" do
-    expect(response_body_hash[:_embedded][:deployedVersions]).to be_a(Array)
-    expect(response_body_hash[:_embedded][:deployedVersions].size).to eq 1
-    expect(response_body_hash[:_links][:self][:title]).to eq "Deployed versions for Foo version 1"
-    expect(response_body_hash[:_links][:self][:href]).to end_with(path)
-  end
-end

data/spec/features/get_currently_supported_versions_for_environment_spec.rb

@@ -1,57 +0,0 @@
-RSpec.describe "Get currently supported versions for environment" 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!(:prod_environment) { td.create_environment("prod").and_return(:environment) }
-  let!(:released_version) do
-    td.create_released_version_for_consumer_version(environment_name: "test", created_at: DateTime.now - 2)
-      .create_released_version_for_consumer_version(environment_name: "prod", created_at: DateTime.now - 1)
-      .create_provider("Bar")
-      .create_provider_version("4")
-      .create_released_version_for_provider_version(environment_name: "test")
-      .create_provider_version("5")
-      .create_released_version_for_provider_version(environment_name: "test")
-  end
-
-  let(:path) do
-    PactBroker::Api::PactBrokerUrls.currently_supported_versions_for_environment_url(test_environment)
-  end
-
-  let(:query_params) { {} }
-  let(:response_body_hash) { JSON.parse(subject.body, symbolize_names: true) }
-
-  subject { get(path, query_params, { "HTTP_ACCEPT" => "application/hal+json" }) }
-
-  it "returns a list of released versions" do
-    expect(response_body_hash[:_embedded][:releasedVersions]).to be_a(Array)
-    expect(response_body_hash[:_embedded][:releasedVersions].size).to eq 3
-    expect(response_body_hash[:_links][:self][:title]).to eq "Currently supported versions in Test"
-    expect(response_body_hash[:_links][:self][:href]).to end_with(path)
-  end
-
-  context "with query params" do
-    context "with a pacticipant name and version" do
-      let(:query_params) { { pacticipant: "Bar", version: "4" } }
-
-      it "returns a list of matching released versions" do
-        expect(response_body_hash[:_embedded][:releasedVersions].size).to eq 1
-        expect(response_body_hash[:_embedded][:releasedVersions].first[:_embedded][:version][:number]).to eq "4"
-      end
-    end
-
-    context "with pacticipant name and no version" do
-      let(:query_params) { { pacticipant: "Bar" } }
-
-      it "returns a list of matching released versions" do
-        expect(response_body_hash[:_embedded][:releasedVersions].size).to eq 2
-      end
-    end
-
-    context "with no matching versions" do
-      let(:query_params) { { pacticipant: "waffle" } }
-
-      it "returns an emtpy list" do
-        expect(response_body_hash[:_embedded][:releasedVersions]).to eq []
-      end
-    end
-  end
-end

data/spec/features/get_dashboard_spec.rb

@@ -1,29 +0,0 @@
-describe "Get dashboard" do
-
-  let(:path) { "/dashboard" }
-  let(:last_response_body) { JSON.parse(subject.body, symbolize_names: true) }
-
-  before do
-    TestDataBuilder.new
-      .create_consumer("Foo")
-      .create_provider("Bar")
-      .create_consumer_version("1.2.3")
-      .create_consumer_version_tag("prod")
-      .create_pact
-      .create_verification(provider_version: "4.5.6", tag_names: "dev")
-      .create_webhook
-      .create_triggered_webhook
-      .create_webhook_execution
-  end
-
-  subject { get path; last_response }
-
-  it "returns a 200 HAL JSON response" do
-    expect(subject).to be_a_hal_json_success_response
-  end
-
-  it "returns a list of items" do
-    items = JSON.parse(subject.body)["items"]
-    expect(items).to be_instance_of(Array)
-  end
-end

data/spec/features/get_deployed_versions_for_version_and_environment.rb

@@ -1,27 +0,0 @@
-RSpec.describe "Get deployed versions for version" 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!(:prod_environment) { td.create_environment("prod").and_return(:environment) }
-  let!(:deployed_version) do
-    td.create_deployed_version_for_consumer_version(environment_name: "test", created_at: DateTime.now - 2)
-      .create_deployed_version_for_consumer_version(environment_name: "prod", created_at: DateTime.now - 1)
-  end
-
-  let(:path) do
-    PactBroker::Api::PactBrokerUrls.deployed_versions_for_version_and_environment_url(
-      version,
-      test_environment
-    )
-  end
-
-  let(:response_body_hash) { JSON.parse(subject.body, symbolize_names: true) }
-
-  subject { get(path, nil, { "HTTP_ACCEPT" => "application/hal+json" }) }
-
-  it "returns a list of deployed versions" do
-    expect(response_body_hash[:_embedded][:deployedVersions]).to be_a(Array)
-    expect(response_body_hash[:_embedded][:deployedVersions].size).to eq 1
-    expect(response_body_hash[:_links][:self][:title]).to eq "Deployed versions for Foo version 1"
-    expect(response_body_hash[:_links][:self][:href]).to end_with(path)
-  end
-end

data/spec/features/get_diff_spec.rb

@@ -1,53 +0,0 @@
-require "spec/support/test_data_builder"
-
-describe "Get diff between versions" do
-
-  let(:path) { "/pacts/provider/Provider/consumer/Consumer/version/3/diff/previous-distinct" }
-
-  let(:last_response_body) { subject.body }
-
-  subject { get path; last_response }
-
-  let(:pact_content_version_1) do
-    hash = load_json_fixture("consumer-provider.json")
-    hash["interactions"].first["request"]["method"] = "post"
-    hash.to_json
-  end
-  let(:pact_content_version_2) { load_fixture("consumer-provider.json") }
-  let(:pact_content_version_3) { pact_content_version_2 }
-
-  before do
-    TestDataBuilder.new
-      .create_consumer("Consumer")
-      .create_provider("Provider")
-      .create_consumer_version("1")
-      .create_pact(json_content: pact_content_version_1)
-      .create_consumer_version("2")
-      .create_pact(json_content: pact_content_version_2)
-      .create_consumer_version("3")
-      .create_pact(json_content: pact_content_version_3)
-  end
-
-  context "when the versions exist" do
-
-    it "returns a 200 text response" do
-      expect(subject.headers["Content-Type"]).to eq "text/plain;charset=utf-8"
-    end
-
-    it "returns the JSON representation of the diff" do
-      expect(last_response_body).to include('"method": "post"')
-      expect(last_response_body).to include('"method": "get"')
-    end
-
-  end
-
-  context "when either version does not exist" do
-
-    let(:path) { "/pacts/provider/Provider/consumer/Consumer/versions/1/diff/previous-distinct" }
-
-    it "returns a 404 response" do
-      expect(subject).to be_a_404_response
-    end
-
-  end
-end

data/spec/features/get_environment_spec.rb

@@ -1,19 +0,0 @@
-require "pact_broker/api/pact_broker_urls"
-
-describe "Get an environment" do
-  before do
-    td.create_environment("test", display_name: "Test", uuid: "1234", contacts: [ { name: "Foo" } ] )
-  end
-  let(:path) { PactBroker::Api::PactBrokerUrls.environment_url(td.and_return(:environment)) }
-  let(:headers) { {"HTTP_ACCEPT" => "application/hal+json"} }
-  let(:response_body) { JSON.parse(subject.body, symbolize_names: true)}
-
-  subject { get(path, nil, headers) }
-
-  it { is_expected.to be_a_hal_json_success_response }
-
-  it "returns the environment" do
-    expect(response_body[:uuid]).to eq "1234"
-    expect(response_body[:name]).to eq "test"
-  end
-end

data/spec/features/get_environments_spec.rb

@@ -1,30 +0,0 @@
-require "pact_broker/api/pact_broker_urls"
-
-describe "Get all environments" do
-  before do
-    td.create_environment("test", display_name: "Test", uuid: "1234", contacts: [ { name: "Foo" } ] )
-      .create_environment("prod", display_name: "Production", uuid: "5678", contacts: [ { name: "Foo" } ] )
-  end
-  let(:path) { PactBroker::Api::PactBrokerUrls.environments_url }
-  let(:headers) { {"HTTP_ACCEPT" => "application/hal+json"} }
-  let(:response_body) { JSON.parse(last_response.body, symbolize_names: true)}
-
-  subject { get(path, nil, headers) }
-
-  it { is_expected.to be_a_hal_json_success_response }
-
-  it "returns the environments" do
-    subject
-    expect(response_body[:_embedded][:environments].size).to be 2
-  end
-
-  context "by name" do
-    let(:path) { PactBroker::Api::PactBrokerUrls.environments_url + "?name=test" }
-
-    it "returns the environment with the matching name" do
-      subject
-      expect(response_body[:_embedded][:environments].size).to be 1
-      expect(response_body[:_embedded][:environments].first[:name]).to eq "test"
-    end
-  end
-end

data/spec/features/get_integrations_dot_file_spec.rb

@@ -1,23 +0,0 @@
-describe "Get integrations dot file" do
-  before do
-    TestDataBuilder.new
-      .create_pact_with_hierarchy("Foo", "1", "Bar")
-  end
-
-  let(:path) { "/integrations" }
-  let(:response_body_hash) { JSON.parse(subject.body, symbolize_names: true) }
-
-  subject { get path, nil, {"HTTP_ACCEPT" => "text/vnd.graphviz" }; last_response  }
-
-  it "returns a 200 OK" do
-    expect(subject.status).to eq 200
-  end
-
-  it "returns a dot file content type" do
-    expect(subject.headers["Content-Type"]).to eq "text/vnd.graphviz;charset=utf-8"
-  end
-
-  it "returns dot file content" do
-    expect(subject.body).to include "Foo -> Bar"
-  end
-end

data/spec/features/get_integrations_spec.rb

@@ -1,17 +0,0 @@
-describe "Get integrations dot file" do
-  before do
-    td.create_pact_with_hierarchy("Foo", "1", "Bar")
-      .create_verification(provider_version: "2")
-  end
-
-  let(:path) { "/integrations" }
-  let(:response_body_hash) { JSON.parse(subject.body, symbolize_names: true) }
-
-  subject { get path, nil, {"HTTP_ACCEPT" => "application/hal+json" }  }
-
-  it { is_expected.to be_a_hal_json_success_response }
-
-  it "returns a json body with embedded integrations" do
-    expect(JSON.parse(subject.body)["_embedded"]["integrations"]).to be_a(Array)
-  end
-end

data/spec/features/get_label_spec.rb

@@ -1,28 +0,0 @@
-describe "Get 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 { get path; last_response  }
-
-  context "when the label exists" do
-    it "returns a 200 OK" do
-      expect(subject).to be_a_hal_json_success_response
-    end
-
-    it "returns the label in the body" do
-      expect(response_body_hash).to include expected_response_body
-    end
-  end
-end

data/spec/features/get_latest_pact_badge_spec.rb

@@ -1,54 +0,0 @@
-require "webmock/rspec"
-
-describe "get latest pact badge" do
-
-  before do
-    PactBroker.configuration.enable_public_badge_access = true
-    PactBroker.configuration.badge_provider_mode = :proxy
-    TestDataBuilder.new
-      .create_consumer("consumer")
-      .create_provider("provider")
-      .create_consumer_version("1.2.3")
-      .create_pact
-      .create_verification
-  end
-
-  let!(:http_request) do
-    stub_request(:get, /http/).to_return(:status => 200, :body => "<svg/>")
-  end
-
-  let(:path) { "/pacts/provider/provider/consumer/consumer/latest/badge" }
-
-  # In the full app, the .svg extension is turned into an Accept header
-  # by ConvertFileExtensionToAcceptHeader
-
-  subject { get path, nil, {"HTTP_ACCEPT" => "image/svg+xml"}; last_response  }
-
-  it "returns a 200 status" do
-    expect(subject.status).to eq 200
-  end
-
-  it "returns an svg/xml response" do
-    expect(subject.headers["Content-Type"]).to include("image/svg+xml")
-  end
-
-  it "returns an svg body" do
-    expect(subject.body).to include "<svg/>"
-  end
-
-  context "when the pact doesn't exist" do
-    let(:path) { "/pacts/provider/foo/consumer/bar/latest/badge" }
-
-    it "returns a 200 status" do
-      expect(subject.status).to eq 200
-    end
-
-    it "returns an svg/xml response" do
-      expect(subject.headers["Content-Type"]).to include("image/svg+xml")
-    end
-
-    it "returns a static svg image" do
-      expect(subject.body).to include ">unknown<"
-    end
-  end
-end

data/spec/features/get_latest_tagged_pact_badge_spec.rb

@@ -1,38 +0,0 @@
-require "webmock/rspec"
-
-describe "get latest tagged pact badge" do
-
-  before do
-    PactBroker.configuration.enable_public_badge_access = true
-    PactBroker.configuration.shields_io_base_url = nil
-    TestDataBuilder.new
-      .create_consumer("consumer")
-      .create_provider("provider")
-      .create_consumer_version("1.0.0")
-      .create_consumer_version_tag("prod")
-      .create_pact
-      .create_verification(success: true)
-      .create_consumer_version("1.2.3")
-      .create_pact
-      .create_verification(success: false)
-  end
-
-  let(:path) { "/pacts/provider/provider/consumer/consumer/latest/prod/badge" }
-
-  # In the full app, the .svg extension is turned into an Accept header
-  # by ConvertFileExtensionToAcceptHeader
-
-  subject { get path, nil, {"HTTP_ACCEPT" => "image/svg+xml"}; last_response  }
-
-  it "returns a 200 status" do
-    expect(subject.status).to eq 200
-  end
-
-  it "returns an svg/xml response" do
-    expect(subject.headers["Content-Type"]).to include("image/svg+xml")
-  end
-
-  it "returns an svg body" do
-    expect(subject.body).to include ">verified<"
-  end
-end

data/spec/features/get_latest_tagged_pact_spec.rb

@@ -1,22 +0,0 @@
-describe "retrieving the latest tagged pact" do
-
-  let(:path) { "/pacts/provider/Provider/consumer/Consumer/latest/prod"}
-
-  subject { get path; last_response  }
-  let(:json_response_body) { JSON.parse(subject.body, symbolize_names: true) }
-
-  before do
-    TestDataBuilder.new
-      .create_consumer("Consumer")
-      .create_provider("Provider")
-      .create_consumer_version("1.2.3")
-      .create_consumer_version_tag("prod")
-      .create_pact
-      .create_consumer_version("4.5.6")
-      .create_pact
-  end
-
-  it "returns the latest tagged pact version" do
-    expect(json_response_body[:_links][:self][:href]).to end_with("1.2.3")
-  end
-end

data/spec/features/get_latest_untagged_pact_badge_spec.rb

@@ -1,38 +0,0 @@
-require "webmock/rspec"
-
-describe "get latest untagged pact badge" do
-
-  before do
-    PactBroker.configuration.enable_public_badge_access = true
-    PactBroker.configuration.shields_io_base_url = nil
-    TestDataBuilder.new
-      .create_consumer("consumer")
-      .create_provider("provider")
-      .create_consumer_version("1.0.0")
-      .create_pact
-      .create_verification(success: true)
-      .create_consumer_version("1.2.3")
-      .create_consumer_version_tag("prod")
-      .create_pact
-      .create_verification(success: false)
-  end
-
-  let(:path) { "/pacts/provider/provider/consumer/consumer/latest-untagged/badge" }
-
-  # In the full app, the .svg extension is turned into an Accept header
-  # by ConvertFileExtensionToAcceptHeader
-
-  subject { get path, nil, {"HTTP_ACCEPT" => "image/svg+xml"}; last_response  }
-
-  it "returns a 200 status" do
-    expect(subject.status).to eq 200
-  end
-
-  it "returns an svg/xml response" do
-    expect(subject.headers["Content-Type"]).to include("image/svg+xml")
-  end
-
-  it "returns an svg body" do
-    expect(subject.body).to include ">verified<"
-  end
-end