pact_broker 2.89.1 → 2.90.0

data/spec/features/get_triggered_webhooks_for_verification_spec.rb

@@ -1,21 +0,0 @@
-RSpec.describe "Get triggered webhooks for verification" do
-  before do
-    td.create_pact_with_hierarchy
-      .create_verification_webhook
-      .create_verification
-      .create_triggered_webhook
-      .create_webhook_execution
-  end
-
-  let(:td) { TestDataBuilder.new }
-  let(:path) { PactBroker::Api::PactBrokerUrls.verification_triggered_webhooks_url(td.verification) }
-  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

data/spec/features/get_verifications_for_consumer_version_spec.rb

@@ -1,33 +0,0 @@
-require "spec/support/test_data_builder"
-
-describe "Get verifications for consumer version" do
-
-  let(:path) { "/verification-results/consumer/Consumer/version/1.2.3/latest" }
-  let(:last_response_body) { JSON.parse(subject.body, symbolize_names: true) }
-
-  subject { get path; last_response }
-
-  context "when the consumer exists" do
-
-    before do
-      TestDataBuilder.new
-        .create_provider("Provider")
-        .create_consumer("Consumer")
-        .create_consumer_version("1.2.3")
-        .create_pact
-        .create_verification(number: 1)
-        .create_verification(number: 2)
-        .create_provider("Another provider")
-        .create_pact
-        .create_verification(number: 1)
-    end
-
-    it "returns a 200 HAL JSON response" do
-      expect(subject).to be_a_hal_json_success_response
-    end
-
-    it "returns a list of verifications" do
-      expect(last_response_body[:_embedded][:verificationResults].size).to eq 2
-    end
-  end
-end

data/spec/features/get_version_spec.rb

@@ -1,44 +0,0 @@
-require "spec/support/test_data_builder"
-
-describe "Get version" do
-
-  let(:path) { "/pacticipants/Consumer/versions/1.2.3" }
-  let(:last_response_body) { JSON.parse(subject.body, symbolize_names: true) }
-
-  subject { get path; last_response }
-
-  context "when the version exists" do
-
-    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).to be_a_hal_json_success_response
-    end
-
-    it "returns the JSON representation of the version" do
-      expect(last_response_body).to include number: "1.2.3"
-    end
-
-  end
-
-  context "when the version does not exist" do
-
-    before do
-      TestDataBuilder.new
-        .create_consumer("Consumer")
-        .create_version("1.2.4")
-    end
-
-    it "returns a 404 response" do
-      expect(subject).to be_a_404_response
-    end
-
-  end
-end

data/spec/features/get_versions_spec.rb

@@ -1,39 +0,0 @@
-require "spec/support/test_data_builder"
-
-describe "Get versions" do
-  let(:path) { "/pacticipants/Consumer/versions" }
-  let(:last_response_body) { JSON.parse(subject.body, symbolize_names: true) }
-
-  subject { get(path) }
-
-  context "when the pacticipant exists" do
-    before do
-      TestDataBuilder.new
-        .create_consumer("Consumer")
-        .create_consumer_version("1.0.0")
-        .create_consumer_version("1.0.1")
-    end
-
-    it "returns a 200 response" do
-      expect(subject.status).to be 200
-    end
-
-    it "returns a list of links to the versions" do
-      expect(last_response_body[:_links][:"versions"].size).to eq 2
-    end
-
-    context "with pagination options" do
-      subject { get(path, { "pageSize" => "1", "pageNumber" => "1" }) }
-
-      it "paginates the response" do
-        expect(last_response_body[:_links][:"versions"].size).to eq 1
-      end
-    end
-  end
-
-  context "when the pacticipant does not exist" do
-    it "returns a 404 response" do
-      expect(subject).to be_a_404_response
-    end
-  end
-end

data/spec/features/label_pacticipant_spec.rb

@@ -1,22 +0,0 @@
-describe "Labelling a pacticipant" do
-
-  let(:path) { "/pacticipants/foo/labels/ios" }
-  let(:response_body_hash) { JSON.parse(subject.body, symbolize_names: true) }
-  let(:expected_response_body) { {name: "ios"} }
-
-  subject { put path, nil, {"CONTENT_TYPE" => "application/json"}; last_response  }
-
-  context "when the pacticipant exists" 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 label in the body" do
-      expect(response_body_hash).to include expected_response_body
-    end
-  end
-end

data/spec/features/merge_pact_spec.rb

@@ -1,63 +0,0 @@
-require "spec/support/test_data_builder"
-
-describe "Merging 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 do
-    patch path, pact_content, {"CONTENT_TYPE" => "application/json" }; last_response
-  end
-
-  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
-    let(:existing_pact_content) { load_fixture("a_consumer-a_provider-3.json") }
-    let(:merged_pact_content) { load_fixture("a_consumer-a_provider-merged.json") }
-
-    before do
-      TestDataBuilder.new.create_pact_with_hierarchy("A Consumer", "1.2.3", "A Provider", existing_pact_content)
-    end
-
-    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 merged pact in the response body" do
-      expect(response_body_json).to contain_hash JSON.parse(merged_pact_content)
-    end
-
-    context "with a conflicting request" do
-      let(:existing_pact_content) { load_fixture("a_consumer-a_provider-conflict.json") }
-
-      it "returns a 409 Conflict" do
-        expect(subject.status).to be 409
-      end
-    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
-end

data/spec/features/metadata_spec.rb

@@ -1,66 +0,0 @@
-require "webmock/rspec"
-require "pact_broker/api/pact_broker_urls"
-
-RSpec.describe "passing the pact selection criteria through the verification results to the triggered webhooks" do
-  before do
-    allow(PactBroker::Webhooks::Job).to receive(:perform_in)
-  end
-
-  let!(:pact) do
-    td.create_pact_with_hierarchy("Foo", "1", "Bar")
-      .create_consumer_version_tag("dev")
-      .create_consumer_version_tag("prod")
-      .create_global_verification_webhook
-  end
-
-  let(:verification_content) { load_fixture("verification.json") }
-  let(:event_context) { PactBroker::Webhooks::TriggeredWebhook.last.event_context }
-
-  context "when verifying the latest pact by URL" do
-    let(:pact_url) { PactBroker::Api::PactBrokerUrls.latest_pact_url("", pact) }
-    it "passes the consumer version number into the verification event context" do
-      response = get(pact_url)
-      publish_verification_results_url = JSON.parse(response.body)["_links"]["pb:publish-verification-results"]["href"]
-      post(publish_verification_results_url, verification_content, { "CONTENT_TYPE" => "application/json" })
-      expect(event_context["consumer_version_number"]).to eq "1"
-    end
-  end
-
-  context "when verifying the latest pact for a tag by URL" do
-    let(:pact_url) { PactBroker::Api::PactBrokerUrls.latest_pact_url("", pact) + "/dev" }
-    let(:event_context) { PactBroker::Webhooks::TriggeredWebhook.last.event_context }
-
-    it "passes the consumer version number and tag into the triggered webhook event context" do
-      response = get(pact_url)
-      publish_verification_results_url = JSON.parse(response.body)["_links"]["pb:publish-verification-results"]["href"]
-      post(publish_verification_results_url, verification_content, { "CONTENT_TYPE" => "application/json" })
-      expect(event_context).to include "consumer_version_number" => "1", "consumer_version_tags" => ["dev"]
-    end
-  end
-
-  context "when verifying pacts via the pacts for verification API" do
-    let(:request_body) do
-      {
-        consumerVersionSelectors: [ { tag: "dev", latest: true } ],
-      }
-    end
-
-    let(:request_headers) do
-      {
-        "CONTENT_TYPE" => "application/json",
-        "HTTP_ACCEPT" => "application/hal+json"
-      }
-    end
-
-    let(:path) { "/pacts/provider/Bar/for-verification" }
-
-    it "passes the consumer version number and tag into the triggered webhook event context" do
-      response = post(path, request_body.to_json, request_headers)
-      pact_url = JSON.parse(response.body)["_embedded"]["pacts"].first["_links"]["self"]["href"]
-      response = get(pact_url)
-      publish_verification_results_url = JSON.parse(response.body)["_links"]["pb:publish-verification-results"]["href"]
-      post(publish_verification_results_url, verification_content, { "CONTENT_TYPE" => "application/json" })
-      expect(event_context).to include "consumer_version_number" => "1", "consumer_version_tags" => ["dev"]
-    end
-  end
-end

data/spec/features/metrics_spec.rb

@@ -1,23 +0,0 @@
-describe "get metrics" do
-  let(:path) { "/metrics"}
-  let(:json_response_body) { JSON.parse(subject.body, symbolize_names: true) }
-
-  subject { get(path)  }
-
-  before do
-    TestDataBuilder.new
-      .create_consumer("Consumer")
-      .create_provider("Provider")
-      .create_consumer_version("1.2.3")
-      .create_consumer_version_tag("prod")
-      .create_pact
-      .create_verification(provider_version: "4.5.6")
-      .create_webhook
-      .create_triggered_webhook
-      .create_webhook_execution
-  end
-
-  it "returns some metrics" do
-    expect(json_response_body[:pacticipants]).to be_instance_of(Hash)
-  end
-end

data/spec/features/pending_pacts_spec.rb

@@ -1,109 +0,0 @@
-RSpec.describe "the pending lifecycle of a pact (with no tags)" do
-  let(:pact_content_1) { { some: "interactions" }.to_json }
-  let(:pact_content_2) { { some: "other interactions" }.to_json }
-  let(:request_headers) { { "CONTENT_TYPE" => "application/json", "HTTP_ACCEPT" => "application/hal+json"} }
-  let(:failed_verification_results) do
-    {
-      providerApplicationVersion: "2",
-      success: false
-    }.to_json
-  end
-  let(:successful_verification_results) do
-    {
-      providerApplicationVersion: "2",
-      success: true
-    }.to_json
-  end
-
-  def publish_pact
-    put("/pacts/provider/Bar/consumer/Foo/version/1", pact_content_1, request_headers)
-  end
-
-  def get_pacts_for_verification
-    post("/pacts/provider/Bar/for-verification", { includePendingStatus: true }.to_json, request_headers)
-  end
-
-  def pact_url_from(pacts_for_verification_response)
-    JSON.parse(pacts_for_verification_response.body)["_embedded"]["pacts"][0]["_links"]["self"]["href"]
-  end
-
-  def get_pact(pact_url)
-    get pact_url, nil, request_headers
-  end
-
-  def verification_results_url_from(pact_response)
-    JSON.parse(pact_response.body)["_links"]["pb:publish-verification-results"]["href"]
-  end
-
-  def publish_verification_results(verification_results_url, results)
-    post(verification_results_url, results, request_headers)
-  end
-
-  def pending_status_from(pacts_for_verification_response)
-    JSON.parse(pacts_for_verification_response.body)["_embedded"]["pacts"][0]["verificationProperties"]["pending"]
-  end
-
-
-  context "a pact" do
-    describe "when it is first published" do
-      it "is pending" do
-        publish_pact
-        pacts_for_verification_response = get_pacts_for_verification
-        expect(pending_status_from(pacts_for_verification_response)).to be true
-      end
-    end
-
-    describe "when it is verified unsuccessfully" do
-      it "is still pending" do
-        # CONSUMER BUILD
-        # publish pact
-        publish_pact
-
-        # PROVIDER BUILD
-        # fetch pacts to verify
-        pacts_for_verification_response = get_pacts_for_verification
-        pact_url = pact_url_from(pacts_for_verification_response)
-        pact_response = get_pact(pact_url)
-
-        # verify pact... failure...
-
-        # publish failure verification results
-        verification_results_url = verification_results_url_from(pact_response)
-        publish_verification_results(verification_results_url, failed_verification_results)
-
-        # ANOTHER PROVIDER BUILD
-        # get pacts for verification
-        pacts_for_verification_response = get_pacts_for_verification
-        # still pending
-        expect(pending_status_from(pacts_for_verification_response)).to be true
-      end
-    end
-
-    describe "when it is verified successfully" do
-      it "is no longer pending" do
-        # CONSUMER BUILD
-        publish_pact
-
-        # PROVIDER BUILD
-        pacts_for_verification_response = get_pacts_for_verification
-
-        # fetch pact
-        pact_url = pact_url_from(pacts_for_verification_response)
-        pact_response = get_pact(pact_url)
-
-        # verify pact... success!
-
-        # publish failure verification results
-        verification_results_url = verification_results_url_from(pact_response)
-        publish_verification_results(verification_results_url, successful_verification_results)
-
-        # ANOTHER PROVIDER BUILD 2
-        # get pacts for verification
-        # publish successful verification results
-        pacts_for_verification_response = get_pacts_for_verification
-        # not pending any more
-        expect(pending_status_from(pacts_for_verification_response)).to be false
-      end
-    end
-  end
-end

data/spec/features/pending_pacts_with_tags_spec.rb

@@ -1,138 +0,0 @@
-RSpec.describe "the pending lifecycle of a pact (with tags)" do
-  let(:pact_content_1) { { some: "interactions" }.to_json }
-  let(:pact_content_2) { { some: "other interactions" }.to_json }
-  let(:request_headers) { { "CONTENT_TYPE" => "application/json", "HTTP_ACCEPT" => "application/hal+json"} }
-  let(:failed_verification_results) do
-    {
-      providerApplicationVersion: "2",
-      success: false
-    }.to_json
-  end
-  let(:successful_verification_results) do
-    {
-      providerApplicationVersion: "2",
-      success: true
-    }.to_json
-  end
-
-  def publish_pact
-    put("/pacts/provider/Bar/consumer/Foo/version/1", pact_content_1, request_headers)
-  end
-
-  def get_pacts_for_verification(provider_version_tag = "main")
-    post("/pacts/provider/Bar/for-verification", { includePendingStatus: true, providerVersionTags: [*provider_version_tag] }.to_json, request_headers)
-  end
-
-  def pact_url_from(pacts_for_verification_response)
-    JSON.parse(pacts_for_verification_response.body)["_embedded"]["pacts"][0]["_links"]["self"]["href"]
-  end
-
-  def get_pact(pact_url)
-    get pact_url, nil, request_headers
-  end
-
-  def verification_results_url_from(pact_response)
-    JSON.parse(pact_response.body)["_links"]["pb:publish-verification-results"]["href"]
-  end
-
-  def publish_verification_results(verification_results_url, results)
-    put("/pacticipants/Bar/versions/#{JSON.parse(results)["providerApplicationVersion"]}/tags/main", nil, { "CONTENT_TYPE" => "application/json" })
-    post(verification_results_url, results, request_headers)
-  end
-
-  def pending_status_from(pacts_for_verification_response)
-    JSON.parse(pacts_for_verification_response.body)["_embedded"]["pacts"][0]["verificationProperties"]["pending"]
-  end
-
-
-  context "a pact" do
-    describe "when it is first published" do
-      it "is pending" do
-        publish_pact
-        pacts_for_verification_response = get_pacts_for_verification
-        expect(pending_status_from(pacts_for_verification_response)).to be true
-      end
-    end
-
-    describe "when it is verified unsuccessfully" do
-      it "is still pending" do
-        # CONSUMER BUILD
-        # publish pact
-        publish_pact
-
-        # PROVIDER BUILD
-        # fetch pacts to verify
-        pacts_for_verification_response = get_pacts_for_verification
-        pact_url = pact_url_from(pacts_for_verification_response)
-        pact_response = get_pact(pact_url)
-
-        # verify pact... failure...
-
-        # publish failure verification results
-        verification_results_url = verification_results_url_from(pact_response)
-        publish_verification_results(verification_results_url, failed_verification_results)
-
-        # ANOTHER PROVIDER BUILD
-        # get pacts for verification
-        pacts_for_verification_response = get_pacts_for_verification
-        # still pending
-        expect(pending_status_from(pacts_for_verification_response)).to be true
-      end
-    end
-
-    describe "when it is verified successfully" do
-      it "is no longer pending" do
-        # CONSUMER BUILD
-        publish_pact
-
-        # PROVIDER BUILD
-        pacts_for_verification_response = get_pacts_for_verification
-
-        # fetch pact
-        pact_url = pact_url_from(pacts_for_verification_response)
-        pact_response = get_pact(pact_url)
-
-        # verify pact... success!
-
-        # publish failure verification results
-        verification_results_url = verification_results_url_from(pact_response)
-        publish_verification_results(verification_results_url, successful_verification_results)
-
-        # ANOTHER PROVIDER BUILD 2
-        # get pacts for verification
-        # publish successful verification results
-        pacts_for_verification_response = get_pacts_for_verification
-        # not pending any more
-        expect(pending_status_from(pacts_for_verification_response)).to be false
-      end
-    end
-
-
-    describe "when it is verified successfully by one branch, and then another branch of the provider is created" do
-      it "is not pending for the new branch" do
-        # CONSUMER BUILD
-        publish_pact
-
-        # PROVIDER BUILD
-        pacts_for_verification_response = get_pacts_for_verification
-
-        # fetch pact
-        pact_url = pact_url_from(pacts_for_verification_response)
-        pact_response = get_pact(pact_url)
-
-        # verify pact... success!
-
-        # publish failure verification results
-        verification_results_url = verification_results_url_from(pact_response)
-        publish_verification_results(verification_results_url, successful_verification_results)
-
-        # ANOTHER PROVIDER BUILD 2 from another branch
-        # get pacts for verification
-        # publish successful verification results
-        pacts_for_verification_response = get_pacts_for_verification("feat/foo")
-        # not pending
-        expect(pending_status_from(pacts_for_verification_response)).to be false
-      end
-    end
-  end
-end

data/spec/features/publish_not_a_pact_spec.rb

@@ -1,37 +0,0 @@
-describe "Publishing a contract that is not a pact" do
-
-  let(:path) { "/pacts/provider/A%20Provider/consumer/A%20Consumer/versions/1.2.3" }
-  let(:parsed_response_body) { JSON.parse(subject.body) }
-
-  subject { put path, pact_content, {"CONTENT_TYPE" => "application/json" }; last_response  }
-
-  context "when the pact is another type of CDC that doesn't have the Consumer or Provider names in the expected places" do
-    let(:pact_content) { {a: "not pact"}.to_json }
-
-    it "accepts the un-pact Pact" do
-      expect(subject.status).to be 201
-    end
-
-    it "returns the content" do
-      expect(parsed_response_body).to include "a" => "not pact"
-    end
-
-    it "returns _links" do
-      expect(parsed_response_body).to have_key "_links"
-    end
-  end
-
-  context "when the content is an array" do
-
-    let(:pact_content) { "[1]" }
-
-    it "accepts the un-pact Pact" do
-      expect(subject.status).to be 201
-    end
-
-    it "returns the content" do
-      expect(parsed_response_body).to eq [1]
-    end
-
-  end
-end

data/spec/features/publish_pact_all_in_one_approval_spec.rb

@@ -1,72 +0,0 @@
-RSpec.describe "publishing a pact using the all in one endpoint" do
-  # TODO merge branches
-  let(:request_body_hash) do
-    {
-      :pacticipantName => "Foo",
-      :pacticipantVersionNumber => "1",
-      :branch => branch,
-      :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(:branch) { "main" }
-  let(:encoded_contract) { Base64.strict_encode64(contract) }
-  let(:path) { "/contracts/publish" }
-  let(:fixture) do
-    {
-      request: { path: path, headers: rack_env_to_http_headers(rack_headers), body: request_body_hash },
-      response: { status: subject.status, headers: determinate_headers(subject.headers), body: JSON.parse(subject.body)}
-    }
-  end
-
-  subject { post(path, request_body_hash.to_json, rack_headers) }
-
-  it { is_expected.to be_a_hal_json_success_response }
-
-  context "with no webhooks" do
-    it { Approvals.verify(fixture, :name => "publish_contract_nothing_exists", format: :json) }
-  end
-
-  context "with a webhooks that gets triggered" do
-    before do
-      allow(PactBroker::Webhooks::TriggerService).to receive(:next_uuid).and_return("1234")
-      td.create_global_webhook(description: "foo webhook")
-    end
-
-    it { Approvals.verify(fixture, :name => "publish_contract_nothing_exists_with_webhook", format: :json) }
-  end
-
-  context "with a validation error" do
-    before do
-      request_body_hash.delete(:pacticipantVersionNumber)
-    end
-
-    it { Approvals.verify(fixture, :name => "publish_contract_with_validation_error", format: :json) }
-  end
-
-  context "when a verification already exists for the consumer/provider" do
-    before do
-      td.create_pact_with_verification("Foo", "1", "Bar", "2")
-    end
-
-    it { Approvals.verify(fixture, :name => "publish_contract_verification_already_exists", format: :json) }
-  end
-
-  context "with no branch set" do
-    let(:branch) { nil }
-
-    it { Approvals.verify(fixture, :name => "publish_contract_no_branch", format: :json) }
-  end
-end