pact_broker 2.89.1 → 2.90.0

data/spec/features/get_latest_untagged_pact_spec.rb

@@ -1,22 +0,0 @@
-describe "retrieving the latest untagged pact" do
-
-  let(:path) { "/pacts/provider/Provider/consumer/Consumer/latest-untagged"}
-
-  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_pact
-      .create_consumer_version("4.5.6")
-      .create_consumer_version_tag("prod")
-      .create_pact
-  end
-
-  it "returns the latest untagged pact version" do
-    expect(json_response_body[:_links][:self][:href]).to end_with("1.2.3")
-  end
-end

data/spec/features/get_latest_verification_for_pact_spec.rb

@@ -1,59 +0,0 @@
-require "spec/support/test_data_builder"
-
-describe "Get latest verification for pact" do
-  before do
-    td
-      .create_consumer("Consumer")
-      .create_consumer_version("1.2.3")
-      .create_consumer_version_tag("master")
-      .create_provider("Another provider")
-      .create_pact
-      .create_verification(number: 1, provider_version: "5")
-      .create_provider("Provider")
-      .create_pact
-      .create_verification(number: 1, provider_version: "3")
-      .create_verification(number: 2, provider_version: "4")
-  end
-
-  let(:last_response_body) { JSON.parse(subject.body, symbolize_names: true) }
-  let(:content_type) { "application/vnd.pactbrokerextended.v1+json" }
-
-  subject { get(path, nil, "HTTP_ACCEPT" => content_type) }
-
-  context "by pact version" do
-    let!(:path) { "/pacts/provider/Provider/consumer/Consumer/pact-version/#{td.pact.pact_version_sha}/verification-results/latest" }
-
-    it "returns a 200 OK" do
-      expect(subject.status).to eq 200
-      expect(subject.headers["Content-Type"]).to include content_type
-    end
-
-    it "returns the verification" do
-      expect(last_response_body[:providerApplicationVersion]).to eq "4"
-    end
-  end
-
-  context "by consumer version" do
-    let(:path) { "/pacts/provider/Provider/consumer/Consumer/version/1.2.3/verification-results/latest" }
-
-    it "returns the verification" do
-      expect(last_response_body[:providerApplicationVersion]).to eq "4"
-    end
-  end
-
-  context "for latest pact" do
-    let(:path) { "/pacts/provider/Provider/consumer/Consumer/latest/verification-results/latest" }
-
-    it "returns the verification" do
-      expect(last_response_body[:providerApplicationVersion]).to eq "4"
-    end
-  end
-
-  context "for latest pact for tag" do
-    let(:path) { "/pacts/provider/Provider/consumer/Consumer/latest/master/verification-results/latest" }
-
-    it "returns the verification" do
-      expect(last_response_body[:providerApplicationVersion]).to eq "4"
-    end
-  end
-end

data/spec/features/get_matrix_badge_spec.rb

@@ -1,50 +0,0 @@
-require "webmock/rspec"
-
-describe "get latest matrix badge with tags" 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")
-      .create_consumer_version_tag("prod")
-      .create_pact
-      .create_verification(provider_version: "4")
-      .use_provider_version("4")
-      .create_provider_version_tag("master")
-  end
-
-  let!(:http_request) do
-    stub_request(:get, /http/).to_return(:status => 200, :body => "<svg/>")
-  end
-
-  let(:path) { "/matrix/provider/provider/latest/master/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"}) }
-
-  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 one of the pacticipants does not exist" do
-    let(:path) { "/matrix/provider/provider/latest/master/consumer/consumer2/latest/prod/badge" }
-
-    it "returns a 200 status as the badge content indicated the pact is not found" do
-      expect(subject.status).to eq 200
-      expect(subject.body).to include "not found"
-    end
-  end
-end

data/spec/features/get_matrix_for_consumer_and_provider_spec.rb

@@ -1,22 +0,0 @@
-describe "Get matrix for consumer and provider" do
-  before do
-    td.create_pact_with_hierarchy("Consumer", "1.0.0", "Provider")
-      .create_verification(provider_version: "4.5.6")
-  end
-
-  let(:path) { "/matrix/provider/Provider/consumer/Consumer" }
-  let(:last_response_body) { JSON.parse(subject.body, symbolize_names: true) }
-
-  subject { get(path) }
-
-  it "returns a 200 HAL JSON response" do
-    expect(subject).to be_a_hal_json_success_response
-  end
-
-  it "returns the JSON representation of the matrix" do
-    expect(last_response_body[:matrix][0][:consumer]).to be_instance_of(Hash)
-    expect(last_response_body[:matrix][0][:provider]).to be_instance_of(Hash)
-    expect(last_response_body[:matrix][0][:pact]).to be_instance_of(Hash)
-    expect(last_response_body[:matrix][0][:verificationResult]).to be_instance_of(Hash)
-  end
-end

data/spec/features/get_matrix_spec.rb

@@ -1,34 +0,0 @@
-require "spec/support/test_data_builder"
-
-describe "Get matrix for consumer and provider" do
-  before do
-    TestDataBuilder.new
-      .create_pact_with_hierarchy("Consumer", "1.0.0", "Provider")
-      .create_verification(provider_version: "4.5.6")
-  end
-
-  let(:path) { "/matrix" }
-  let(:params) do
-    {
-      q: [
-        { pacticipant: "Consumer", version: "1.0.0" },
-        { pacticipant: "Provider", version: "4.5.6" }
-      ]
-    }
-  end
-  let(:last_response_body) { JSON.parse(subject.body, symbolize_names: true) }
-
-  subject { get path, params; last_response }
-
-  it "returns a 200 HAL JSON response" do
-    expect(subject).to be_a_hal_json_success_response
-  end
-
-  it "returns the JSON representation of the matrix" do
-    expect(last_response_body[:matrix][0][:consumer]).to be_instance_of(Hash)
-    expect(last_response_body[:matrix][0][:provider]).to be_instance_of(Hash)
-    expect(last_response_body[:matrix][0][:pact]).to be_instance_of(Hash)
-    expect(last_response_body[:matrix][0][:verificationResult]).to be_instance_of(Hash)
-  end
-end
-

data/spec/features/get_pact_spec.rb

@@ -1,65 +0,0 @@
-describe "retrieving a pact" do
-  subject { get(path)  }
-
-  context "when differing case is used in the consumer and provider names" do
-
-    let(:path) { "/pacts/provider/a%20provider/consumer/a%20consumer/version/1.2.3A" }
-
-    before do
-      td.create_pact_with_hierarchy("A Consumer", "1.2.3a", "A Provider").and_return(:pact)
-    end
-
-    context "when case sensitivity is turned on" do
-      before do
-        allow(PactBroker.configuration).to receive(:use_case_sensitive_resource_names).and_return(true)
-      end
-
-      it "returns a 404 Not found" do
-        expect(subject.status).to be 404
-      end
-    end
-
-    context "when case sensitivity is turned off" do
-      before do
-        allow(PactBroker.configuration).to receive(:use_case_sensitive_resource_names).and_return(false)
-      end
-
-      it "returns a 200 Success" do
-        expect(subject.status).to be 200
-      end
-    end
-  end
-
-  context "when differing case is used in the tag name" do
-
-    let(:path) { "/pacts/provider/a%20provider/consumer/a%20consumer/latest/PROD" }
-
-    before do
-      td.create_consumer("A Consumer")
-        .create_consumer_version("1.2.3")
-        .create_consumer_version_tag("prod")
-        .create_provider("A Provider")
-        .create_pact
-    end
-
-    context "when case sensitivity is turned on" do
-      before do
-        allow(PactBroker.configuration).to receive(:use_case_sensitive_resource_names).and_return(true)
-      end
-
-      it "returns a 404 Not found" do
-        expect(subject.status).to be 404
-      end
-    end
-
-    context "when case sensitivity is turned off" do
-      before do
-        allow(PactBroker.configuration).to receive(:use_case_sensitive_resource_names).and_return(false)
-      end
-
-      it "returns a 200 Success" do
-        expect(subject.status).to be 200
-      end
-    end
-  end
-end

data/spec/features/get_pact_version.rb

@@ -1,36 +0,0 @@
-RSpec.describe "retrieving a pact" do
-  subject { get(path)  }
-
-  context "when differing case is used in the consumer and provider names" do
-    let(:pact) { td.create_pact_with_hierarchy("Foo", "1", "Bar").and_return(:pact) }
-    let!(:path) { "/pacts/provider/Bar/consumer/Foo/pact-version/#{pact.pact_version_sha}" }
-
-    it "returns a 200 Success" do
-      expect(subject.status).to be 200
-    end
-  end
-
-  context "when there are multiple consumer versions for the same sha" do
-    before do
-      td.create_pact_with_hierarchy("Foo", "1", "Bar")
-        .create_consumer_version("2")
-        .republish_same_pact
-    end
-
-    let(:pact) { PactBroker::Pacts::PactPublication.order(:id).first.to_domain }
-    let(:path) { PactBroker::Api::PactBrokerUrls.pact_version_url(pact) }
-
-    it "returns the latest" do
-      expect(JSON.parse(subject.body)["_links"]["pb:consumer-version"]["name"]).to eq "2"
-    end
-
-    context "when there is metadata specifying the consumer version number" do
-      let(:pact) { PactBroker::Pacts::PactPublication.order(:id).first.to_domain }
-      let(:path) { PactBroker::Api::PactBrokerUrls.pact_version_url_with_webhook_metadata(pact) }
-
-      it "returns the pact with the matching consumer version number" do
-        expect(JSON.parse(subject.body)["_links"]["pb:consumer-version"]["name"]).to eq "1"
-      end
-    end
-  end
-end

data/spec/features/get_pact_versions_spec.rb

@@ -1,34 +0,0 @@
-require "spec/support/test_data_builder"
-
-describe "Get pact versions" do
-  let(:path) { "/pacts/provider/Provider/consumer/Consumer/versions" }
-  let(:last_response_body) { JSON.parse(subject.body, symbolize_names: true) }
-
-  subject { get path; last_response }
-
-  context "when the pacts exist" do
-    before do
-      TestDataBuilder.new
-        .create_provider("Provider")
-        .create_consumer("Consumer")
-        .create_consumer_version("1.0.0")
-        .create_pact
-        .create_consumer_version("1.0.1")
-        .create_pact
-    end
-
-    it "returns a 200 response" do
-      expect(subject.status).to be 200
-    end
-
-    it "returns a list of links to the pacts" do
-      expect(last_response_body[:_links][:"pact-versions"].size).to eq 2
-    end
-  end
-
-  context "when the pacts do not exist" do
-    it "returns a 404 response" do
-      expect(subject).to be_a_404_response
-    end
-  end
-end

data/spec/features/get_pacticipants_by_label_spec.rb

@@ -1,27 +0,0 @@
-describe "Get pacticipants by label" do
-
-  let(:path) { "/pacticipants/label/ios" }
-  let(:response_body_hash) { JSON.parse(subject.body, symbolize_names: true) }
-  let(:expected_response_body) { {name: "Foo"} }
-
-  subject { get path; last_response }
-
-  context "when the pacts exist" do
-
-    before do
-      TestDataBuilder.new
-        .create_pacticipant("Foo")
-        .create_label("ios")
-        .create_pacticipant("Bar")
-        .create_label("android")
-    end
-
-    it "returns a 200 OK" do
-      expect(subject).to be_a_hal_json_success_response
-    end
-
-    it "returns a list of pacticipants" do
-      expect(response_body_hash[:_embedded][:pacticipants].first).to include expected_response_body
-    end
-  end
-end

data/spec/features/get_previous_distinct_version.rb

@@ -1,51 +0,0 @@
-require "spec/support/test_data_builder"
-
-describe "Get previous distinct version of pact" do
-
-  let(:path) { "/pacts/provider/Provider/consumer/Consumer/version/3/previous-distinct" }
-  let(:last_response_body) { JSON.parse(subject.body, symbolize_names: true) }
-
-  subject { get path; last_response }
-
-  let(:pact_content_version_1) { load_fixture("consumer-provider.json") }
-  let(:pact_content_version_2) do
-    hash = load_json_fixture("consumer-provider.json")
-    hash["interactions"].first["request"]["method"] = "post"
-    hash.to_json
-  end
-  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 pact version exists" do
-
-    it "returns a 200 HAL JSON response" do
-      expect(subject).to be_a_hal_json_success_response
-    end
-
-    it "returns the JSON representation of the version" do
-      expect(last_response_body[:_links][:self][:href]).to end_with "/1"
-    end
-
-  end
-
-  context "when the version does not exist" do
-
-    let(:path) { "/pacts/provider/Provider/consumer/Consumer/version/1/previous-distinct" }
-
-    it "returns a 404 response" do
-      expect(subject).to be_a_404_response
-    end
-
-  end
-end

data/spec/features/get_provider_pacts_for_verification_spec.rb

@@ -1,95 +0,0 @@
-describe "Get provider pacts for verification" do
-  let(:last_response_body) { JSON.parse(subject.body, symbolize_names: true) }
-  let(:pacts) { last_response_body[:_embedded][:'pacts'] }
-  let(:query) do
-    {
-      consumer_version_selectors: [ { tag: "prod", latest: "true" }]
-    }
-  end
-
-  subject { get(path, query) }
-
-  context "when the provider exists" do
-    before do
-      td.create_provider("Provider")
-        .create_consumer("Consumer")
-        .create_consumer_version("0.0.1")
-        .create_pact(json_content: { some: "content" }.to_json)
-        .create_consumer("Consumer 2")
-        .create_consumer_version("4.5.6")
-        .create_consumer_version_tag("prod")
-        .create_pact(json_content: { some: "other content" }.to_json)
-    end
-
-    let(:path) { "/pacts/provider/Provider/for-verification" }
-
-    context "when using GET" do
-      it "returns a 200 HAL JSON response" do
-        expect(subject).to be_a_hal_json_success_response
-      end
-
-      it "returns a list of links to the pacts" do
-        expect(pacts.size).to eq 1
-      end
-
-      it "returns a deprecation notice" do
-        expect(last_response_body[:_embedded][:pacts].first[:verificationProperties][:notices].first[:text]).to start_with("WARNING")
-      end
-
-      context "when the provider does not exist" do
-        let(:path) { "/pacts/provider/ProviderThatDoesNotExist/for-verification" }
-
-        it "returns a 404 response" do
-          expect(subject).to be_a_404_response
-        end
-      end
-    end
-
-    context "when using POST" do
-      let(:request_body) do
-        {
-          consumerVersionSelectors: [ { tag: "prod", latest: true }],
-          includePendingStatus: false,
-          providerVersionTags: ["main"]
-        }
-      end
-
-      let(:request_headers) do
-        {
-          "CONTENT_TYPE" => "application/json",
-          "HTTP_ACCEPT" => "application/hal+json"
-        }
-      end
-
-      let(:fixture) do
-        {
-          request: { path: path, headers: rack_env_to_http_headers(request_headers), body: request_body },
-          response: { status: subject.status, headers: determinate_headers(subject.headers), body: JSON.parse(subject.body)}
-        }
-      end
-
-      subject { post(path, request_body.to_json, request_headers) }
-
-      # The metadata is different when the database IDs are different
-      it "matches the expected body", skip: !DB.sqlite? do
-        Approvals.verify(fixture, :name => "get_provider_pacts_for_verification", format: :json)
-      end
-
-      it "returns a list of links to the pacts" do
-        expect(pacts.size).to eq 1
-      end
-
-      it "does not include a deprecation notice" do
-        expect(last_response_body[:_embedded][:pacts].first[:verificationProperties][:notices].first[:text]).to_not start_with("WARNING")
-      end
-
-      context "when the provider does not exist" do
-        let(:path) { "/pacts/provider/ProviderThatDoesNotExist/for-verification" }
-
-        it "returns a 404 response" do
-          expect(subject).to be_a_404_response
-        end
-      end
-    end
-  end
-end

data/spec/features/get_provider_pacts_spec.rb

@@ -1,93 +0,0 @@
-describe "Get provider pacts" do
-  let(:last_response_body) { JSON.parse(subject.body, symbolize_names: true) }
-  let(:pact_links) { last_response_body[:_links][:'pb:pacts'] }
-  subject { get path; last_response }
-
-  context "when the provider exists" do
-    before do
-      TestDataBuilder.new
-        .create_provider("Provider")
-        .create_consumer("Consumer")
-        .create_consumer_version("0.0.1")
-        .create_consumer_version_tag("prod")
-        .create_pact
-        .create_consumer_version("1.0.0")
-        .create_consumer_version_tag("prod")
-        .create_pact
-        .create_consumer_version("1.2.3")
-        .create_pact
-        .create_consumer("Consumer 2")
-        .create_consumer_version("4.5.6")
-        .create_consumer_version_tag("prod")
-        .create_pact
-    end
-
-    context "with no tag specified" do
-      let(:path) { "/pacts/provider/Provider/latest" }
-
-      it "returns a 200 HAL JSON response" do
-        expect(subject).to be_a_hal_json_success_response
-      end
-
-      it "returns a list of links to the pacts" do
-        expect(pact_links.size).to eq 2
-      end
-    end
-
-    context "with a tag specified" do
-      let(:path) { "/pacts/provider/Provider/latest/prod" }
-
-      it "returns a 200 HAL JSON response" do
-        expect(subject).to be_a_hal_json_success_response
-      end
-
-      it "returns a list of links to the pacts" do
-        expect(pact_links.size).to eq 2
-      end
-    end
-
-    context "with a tag with no pacts" do
-      let(:path) { "/pacts/provider/Provider/latest/foo" }
-
-      it "returns a 200 HAL JSON response" do
-        expect(subject).to be_a_hal_json_success_response
-      end
-
-      it "returns a list of links to the pacts" do
-        expect(pact_links.size).to eq 0
-      end
-    end
-
-    context "with a tag for all pacts" do
-      let(:path) { "/pacts/provider/Provider/tag/prod" }
-
-      it "returns a 200 HAL JSON response" do
-        expect(subject).to be_a_hal_json_success_response
-      end
-
-      it "returns a list of links to the pacts" do
-        expect(pact_links.size).to eq 3
-      end
-    end
-
-    context "with no tag for all pacts" do
-      let(:path) { "/pacts/provider/Provider" }
-
-      it "returns a 200 HAL JSON response" do
-        expect(subject).to be_a_hal_json_success_response
-      end
-
-      it "returns a list of links to the pacts" do
-        expect(last_response_body[:_links][:'pb:pacts'].size).to eq 4
-      end
-    end
-  end
-
-  context "when the provider does not exist" do
-    let(:path) { "/pacts/provider/Provider" }
-
-    it "returns a 404 response" do
-      expect(subject).to be_a_404_response
-    end
-  end
-end

data/spec/features/get_released_versions_for_version_and_environment.rb

@@ -1,27 +0,0 @@
-RSpec.describe "Get released versions for version and 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_released_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.released_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 released versions" do
-    expect(response_body_hash[:_embedded][:releasedVersions]).to be_a(Array)
-    expect(response_body_hash[:_embedded][:releasedVersions].size).to eq 1
-    expect(response_body_hash[:_links][:self][:title]).to eq "Released versions for Foo version 1 in Test"
-    expect(response_body_hash[:_links][:self][:href]).to end_with(path)
-  end
-end

data/spec/features/get_tagged_pact_versions_spec.rb

@@ -1,26 +0,0 @@
-describe "retrieving tagged pact versions" do
-
-  let(:path) { "/pacts/provider/Provider/consumer/Consumer/tag/prod"}
-
-  subject { get(path) }
-  let(:json_response_body) { JSON.parse(subject.body) }
-
-  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 a 200 HAL JSON response" do
-    expect(subject).to be_a_hal_json_success_response
-  end
-
-  it "returns the list of tagged pact versions" do
-    expect(json_response_body["_links"]["pb:pact-versions"]).to be_a Array
-  end
-end

data/spec/features/get_triggered_webhooks_for_pact_spec.rb

@@ -1,20 +0,0 @@
-RSpec.describe "Get triggered webhooks for pact" do
-  before do
-    td.create_pact_with_hierarchy
-      .create_webhook
-      .create_triggered_webhook
-      .create_webhook_execution
-  end
-
-  let(:td) { TestDataBuilder.new }
-  let(:path) { PactBroker::Api::PactBrokerUrls.pact_triggered_webhooks_url(td.pact) }
-  let(:json_response_body) { JSON.parse(subject.body) }
-
-  subject { get(path); last_response }
-
-  it { is_expected.to be_a_hal_json_success_response }
-
-  it "contains a list of triggered webhooks" do
-    expect(json_response_body["_embedded"]["triggeredWebhooks"].size).to be 1
-  end
-end