pact_broker 2.79.1 → 2.80.0

data/spec/features/record_undeployment_spec.rb

@@ -0,0 +1,67 @@
+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,12 +1,12 @@
 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 }
+  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
+        PactBroker::Domain::Tag.where(name: "feat/bar").count
       }.by(1)
     end
   end

data/spec/features/update_environment_spec.rb

@@ -1,11 +1,11 @@
-require 'pact_broker/api/pact_broker_urls'
+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(:headers) { {"CONTENT_TYPE" => "application/json"} }
   let(:response_body) { JSON.parse(last_response.body, symbolize_names: true)}
   let(:environment_hash) do
     {

data/spec/features/update_matrix_spec.rb

@@ -89,7 +89,7 @@ describe "Creating a resource that affects the matrix" do
   let(:td) { TestDataBuilder.new }
   let(:response_body_json) { JSON.parse(subject.body) }
 
-  subject { put(path, nil, {'CONTENT_TYPE' => 'application/json'}); last_response }
+  subject { put(path, nil, {"CONTENT_TYPE" => "application/json"}); last_response }
 
   context "creating a tag" do
     before do
@@ -108,10 +108,10 @@ describe "Creating a resource that affects the matrix" do
   end
 
   context "creating a pact" do
-    let(:pact_content) { load_fixture('foo-bar.json') }
+    let(:pact_content) { load_fixture("foo-bar.json") }
     let(:path) { "/pacts/provider/Bar/consumer/Foo/versions/1.2.3" }
 
-    subject { put path, pact_content, {'CONTENT_TYPE' => 'application/json'}; last_response }
+    subject { put path, pact_content, {"CONTENT_TYPE" => "application/json"}; last_response }
 
     it "adds the relevant lines to the matrix" do
       expect{ subject }.to change{ PactBroker::Matrix::Row.count }.by(1)
@@ -125,11 +125,11 @@ describe "Creating a resource that affects the matrix" do
   context "creating a verification" do
     let(:td) { TestDataBuilder.new }
     let(:path) { "/pacts/provider/Bar/consumer/Foo/pact-version/#{pact.pact_version_sha}/verification-results" }
-    let(:verification_content) { load_fixture('verification.json') }
+    let(:verification_content) { load_fixture("verification.json") }
     let(:parsed_response_body) { JSON.parse(subject.body) }
     let(:pact) { td.pact }
 
-    subject { post path, verification_content, {'CONTENT_TYPE' => 'application/json' }; last_response  }
+    subject { post path, verification_content, {"CONTENT_TYPE" => "application/json" }; last_response  }
 
     before do
       td.create_pact_with_hierarchy("Foo", "1", "Bar")

data/spec/features/update_pacticipant_spec.rb

@@ -1,23 +1,98 @@
-describe "Publishing a pact" do
+describe "Update a pacticipant" do
 
-  let(:request_body) { {'repositoryUrl' => 'http://foo'} }
+  let(:request_body) { {"repositoryUrl" => "http://foo"} }
   let(:path) { "/pacticipants/Some%20Consumer" }
-  let(:response_body_json) { JSON.parse(subject.body) }
+  let(:response_body_hash) { JSON.parse(subject.body, symbolize_names: true) }
 
-  subject { patch path, request_body.to_json, {'CONTENT_TYPE' => 'application/json' }; last_response  }
+  context "with a PUT" do
+    let(:request_body_hash) do
+      {
+        repositoryUrl: "http://foo",
+        repositoryName: "name",
+        repositoryNamespace: "org",
+        mainBranch: "main"
+      }
+    end
+
+    subject { put(path, request_body_hash.to_json, { "CONTENT_TYPE" => "application/json" }) }
+
+    context "when the pacticipant exists" do
+      before do
+        td.create_pacticipant("Some Consumer")
+      end
 
-  context "when the pacticipant exists" do
+      it { is_expected.to be_a_hal_json_success_response }
 
-    before do
-      TestDataBuilder.new.create_pacticipant("Some Consumer")
+      it "updates the properties" do
+        expect(response_body_hash).to include(request_body_hash)
+      end
+
+      context "with only some of the properties set" do
+        let(:request_body_hash) do
+          {
+            repositoryUrl: "http://foo",
+          }
+        end
+
+        it "blanks out the missing ones" do
+          expect(response_body_hash[:repositoryName]).to be nil
+        end
+      end
     end
-    it "returns a 200 OK" do
-      puts subject.body unless subject.status == 200
-      expect(subject.status).to be 200
+
+    context "when the pacticipant does not exist" do
+      it { is_expected.to be_a_404_response }
     end
 
-    it "returns a json body with the updated pacticipant" do
-      expect(subject.headers['Content-Type']).to eq "application/hal+json;charset=utf-8"
+    context "with application/merge-patch+json" do
+      subject { put(path, request_body.to_json, {"CONTENT_TYPE" => "application/merge-patch+json" })  }
+
+      its(:status) { is_expected.to eq 415 }
+    end
+
+  end
+
+  context "with a PATCH" do
+    subject { patch(path, request_body.to_json, {"CONTENT_TYPE" => "application/json" })  }
+
+    context "when the pacticipant exists" do
+      before do
+        td.create_pacticipant("Some Consumer", repository_name: "existing")
+      end
+
+      it "returns a 200 OK" do
+        puts subject.body unless subject.status == 200
+        expect(subject.status).to be 200
+      end
+
+      it "leaves any existing properties that were not defined" do
+        expect(response_body_hash[:repositoryName]).to eq "existing"
+      end
+
+      it "returns a json body with the updated pacticipant" do
+        expect(subject.headers["Content-Type"]).to eq "application/hal+json;charset=utf-8"
+      end
+    end
+
+    context "with application/merge-patch+json" do
+      before do
+        td.create_pacticipant("Some Consumer", repository_name: "existing")
+      end
+
+      subject { patch(path, request_body.to_json, {"CONTENT_TYPE" => "application/merge-patch+json" })  }
+
+      it "returns a 200 OK" do
+        puts subject.body unless subject.status == 200
+        expect(subject.status).to be 200
+      end
+
+      it "leaves any existing properties that were not defined" do
+        expect(response_body_hash[:repositoryName]).to eq "existing"
+      end
+
+      it "returns a json body with the updated pacticipant" do
+        expect(subject.headers["Content-Type"]).to eq "application/hal+json;charset=utf-8"
+      end
     end
   end
 end

data/spec/features/update_version_spec.rb

@@ -0,0 +1,155 @@
+describe "Updating a pacticipant version" do
+  let(:path) { "/pacticipants/Foo/versions/1234" }
+  let(:headers) { { "CONTENT_TYPE" => content_type } }
+  let(:content_type) { "application/merge-patch+json" }
+  let(:response_body) { JSON.parse(subject.body, symbolize_names: true)}
+  let(:version_hash) do
+    {
+      buildUrl: "http://build"
+    }
+  end
+
+  context "with a PATCH" do
+    subject { patch(path, version_hash.to_json, headers) }
+
+    context "when the version already exists" do
+      before do
+        td.subtract_day
+          .create_consumer("Foo")
+          .create_consumer_version("1234", branch: original_branch, build_url: "original-build-url")
+          .create_consumer_version_tag("dev")
+      end
+      let(:original_branch) { "original-branch" }
+
+      let(:version_hash) { { buildUrl: "new-build-url" } }
+
+      it "returns a 200" do
+        expect(subject.status).to be 200
+      end
+
+      it "does not overwrites any properties that weren't specified" do
+        expect(response_body[:branch]).to eq "original-branch"
+        expect(response_body[:buildUrl]).to eq "new-build-url"
+      end
+
+      context "when the same not null branch is specified" do
+        let(:version_hash) { { branch: "original-branch" } }
+
+        its(:status) { is_expected.to eq 200 }
+      end
+
+      context "when the existing version has a branch, and the new branch is different", skip: true do
+        let(:version_hash) { { branch: "new-branch" } }
+
+        its(:status) { is_expected.to eq 409 }
+
+        it "returns an error" do
+          expect(response_body[:errors][:branch].first).to include "cannot be changed"
+        end
+      end
+
+      context "when the existing version has a branch, and the new branch is nil", skip: true do
+        let(:version_hash) { { branch: nil } }
+
+        its(:status) { is_expected.to eq 409 }
+
+        it "returns an error" do
+          expect(response_body[:errors][:branch].first).to include "cannot be changed"
+        end
+      end
+
+      context "when the existing version does not have a branch, and the new branch is specified" do
+        let(:original_branch) { nil }
+
+        its(:status) { is_expected.to eq 200 }
+      end
+
+      context "when the existing version does not have a branch, and the new branch is also nil" do
+        let(:original_branch) { nil }
+        let(:version_hash) { { branch: nil } }
+
+        its(:status) { is_expected.to eq 200 }
+      end
+
+      context "when no tags are specified" do
+        it "does not change the tags" do
+          expect { subject }.to_not change { PactBroker::Domain::Version.for("Foo", "1234").tags }
+        end
+      end
+
+      context "when tags are specified" do
+        let(:version_hash) { { tags: [ { name: "main" }] } }
+
+        it "overwrites the tags" do
+          expect(response_body[:_embedded][:tags].size).to eq 1
+          expect(response_body[:_embedded][:tags].first[:name]).to eq "main"
+        end
+      end
+
+      it "does not change the created date" do
+        expect { subject }.to_not change { PactBroker::Domain::Version.for("Foo", "1234").created_at }
+      end
+    end
+
+    context "when using a PATCH with application/json" do
+      let(:content_type) { "application/json" }
+
+      its(:status) { is_expected.to eq 415 }
+    end
+
+    context "when using a PUT with application/merge-patch+json" do
+      subject { put(path, version_hash.to_json, headers) }
+
+      its(:status) { is_expected.to eq 415 }
+    end
+  end
+
+  context "with a PUT" do
+    let(:content_type) { "application/json" }
+
+    subject { put(path, version_hash.to_json, headers) }
+
+    context "when the version already exists" do
+      before do
+        td.subtract_day
+          .create_consumer("Foo")
+          .create_consumer_version("1234", branch: "original-branch", build_url: "original-build-url")
+          .create_consumer_version_tag("dev")
+      end
+
+      context "when the branch is attempted to be changed", skip: true do
+        let(:version_hash) { { branch: "new-branch" } }
+
+        its(:status) { is_expected.to eq 409 }
+      end
+
+      context "when the branch is not attempted to be changed" do
+        let(:version_hash) { { branch: "original-branch" } }
+
+        it "overwrites the direct properties and blanks out any unprovided ones" do
+          expect(response_body[:branch]).to eq "original-branch"
+          expect(response_body).to_not have_key(:buildUrl)
+        end
+      end
+
+      context "when no tags are specified" do
+        it "does not change the tags" do
+          expect { subject }.to_not change { PactBroker::Domain::Version.for("Foo", "1234").tags }
+        end
+      end
+
+      context "when tags are specified" do
+        let(:version_hash) { { branch: "original-branch", tags: [ { name: "main" }] } }
+
+        it "overwrites the tags" do
+          expect(response_body[:_embedded][:tags].size).to eq 1
+          expect(response_body[:_embedded][:tags].first[:name]).to eq "main"
+        end
+      end
+
+      it "does not change the created date" do
+        expect { subject }.to_not change { PactBroker::Domain::Version.for("Foo", "1234").created_at }
+      end
+    end
+  end
+end

data/spec/features/update_webhook_spec.rb

@@ -1,4 +1,4 @@
-require 'support/test_data_builder'
+require "support/test_data_builder"
 
 describe "Updating a webhook" do
   let(:webhook) do
@@ -8,7 +8,7 @@ describe "Updating a webhook" do
       .and_return(:webhook)
   end
 
-  let(:headers) { {'CONTENT_TYPE' => 'application/json'} }
+  let(:headers) { {"CONTENT_TYPE" => "application/json"} }
   let(:response_body) { JSON.parse(last_response.body, symbolize_names: true)}
   let(:webhook_json) { webhook_hash.to_json }
   let(:webhook_hash) do
@@ -19,16 +19,16 @@ describe "Updating a webhook" do
       },
       enabled: false,
       events: [{
-        name: 'contract_published'
+        name: "contract_published"
       }],
       request: {
-        method: 'POST',
-        url: 'https://example.org',
+        method: "POST",
+        url: "https://example.org",
         headers: {
           :"Content-Type" => "application/json"
         },
         body: {
-          a: 'body'
+          a: "body"
         }
       }
     }

data/spec/features/wip_pacts_spec.rb

@@ -1,14 +1,15 @@
 RSpec.describe "the lifecycle of a WIP pact" do
-  let(:pact_content_1) { { interactions: [{ some: 'interaction'}] }.to_json }
-  let(:pact_content_2) { { interactions: [{ some: 'other interaction'}] }.to_json }
-  let(:pact_content_3) { { interactions: [{ some: 'other other interaction'}] }.to_json }
+  let(:pact_content_1) { { interactions: [{ some: "interaction"}] }.to_json }
+  let(:pact_content_2) { { interactions: [{ some: "other interaction"}] }.to_json }
+  let(:pact_content_3) { { interactions: [{ some: "other other interaction"}] }.to_json }
   let(:request_headers) { { "CONTENT_TYPE" => "application/json", "HTTP_ACCEPT" => "application/hal+json"} }
   let(:provider_version_number) { "2" }
   let(:pacts_for_verification_request_body) do
     {
       consumerVersionSelectors: [ { tag: "master", latest: true } ],
       providerVersionTags: ["master"],
-      includeWipPactsSince: start_date
+      includeWipPactsSince: start_date,
+      includePendingStatus: true
     }.to_json
   end
 
@@ -91,7 +92,8 @@ RSpec.describe "the lifecycle of a WIP pact" do
     {
       consumerVersionSelectors: [ { tag: consumer_version_tag || provider_version_tag, latest: true, fallbackTag: "master" } ],
       providerVersionTags: [provider_version_tag],
-      includeWipPactsSince: start_date
+      includeWipPactsSince: start_date,
+      includePendingStatus: true
     }.to_json
   end
 
@@ -99,8 +101,6 @@ RSpec.describe "the lifecycle of a WIP pact" do
     context "a pact published afer the specified date, with a tag that is not specified explictly in the 'pacts for verification' request" do
       describe "when it is first published" do
         it "is included in the list of pacts to verify as a WIP pact" do
-          create_initial_provider_version_on_master
-
           publish_pact_with_master_tag
           publish_pact_with_feature_tag
 
@@ -111,8 +111,6 @@ RSpec.describe "the lifecycle of a WIP pact" do
 
       describe "when it is verified unsuccessfully" do
         it "is still included as a WIP pact" do
-          create_initial_provider_version_on_master
-
           # CONSUMER BUILD
           # publish pact
           publish_pact_with_master_tag
@@ -140,17 +138,16 @@ RSpec.describe "the lifecycle of a WIP pact" do
 
       describe "when it is verified successfully while included as a WIP pact" do
         it "is still included as a WIP pact" do
-          create_initial_provider_version_on_master
-
           # CONSUMER BUILD
           publish_pact_with_master_tag
           publish_pact_with_feature_tag
 
-          # PROVIDER BUILD
+          # PROVIDER BUILD - master
           # fetch pacts to verify
           pacts_for_verification_response = get_pacts_for_verification
           pact_url = wip_pact_url_from(pacts_for_verification_response)
           pact_response = get_pact(pact_url)
+          expect(wip_pacts_from(pacts_for_verification_response).first["verificationProperties"]["pending"]).to be true
 
           # verify pact... success!
 
@@ -158,19 +155,19 @@ RSpec.describe "the lifecycle of a WIP pact" do
           verification_results_url = verification_results_url_from(pact_response)
           publish_verification_results_with_tag_master(verification_results_url, true)
 
-          # ANOTHER PROVIDER BUILD 2
+          # ANOTHER PROVIDER BUILD 2 - master
           # get pacts for verification
           # publish successful verification results
           pacts_for_verification_response = get_pacts_for_verification
           # still wip
           expect(wip_pacts_from(pacts_for_verification_response).size).to eq 1
+          # still pending - but maybe it should not be?
+          expect(wip_pacts_from(pacts_for_verification_response).first["verificationProperties"]["pending"]).to be true
         end
       end
 
       describe "when it is verified successfully when included explicitly" do
         it "is no longer included as a WIP pact" do
-          create_initial_provider_version_on_master
-
           # CONSUMER BUILD
           publish_pact_with_master_tag
           publish_pact_with_feature_tag
@@ -178,6 +175,7 @@ RSpec.describe "the lifecycle of a WIP pact" do
           # PROVIDER BUILD
           # fetch pacts to verify
           pacts_for_verification_response = get_pacts_for_verification
+          expect(wip_pacts_from(pacts_for_verification_response).size).to eq 1
           pact_url = wip_pact_url_from(pacts_for_verification_response)
           pact_response = get_pact(pact_url)
 
@@ -202,8 +200,6 @@ RSpec.describe "the lifecycle of a WIP pact" do
 
       describe "a feature branching scenario" do
         it "keeps being WIP until the branch is merged" do
-          create_initial_provider_version_on_master
-
           # CONSUMER BUILD - master
           publish_pact_with_master_tag
 
@@ -235,8 +231,8 @@ RSpec.describe "the lifecycle of a WIP pact" do
 
           # however feat-x pact is no longer pending because it has a successful verification from master!!!
           # Question: do we want this behaviour? Or should pending use the same logic?
-          expect(wip_pacts_from(pacts_for_verification_response).first['verificationProperties']['wip']).to be true
-          expect(wip_pacts_from(pacts_for_verification_response).first['verificationProperties']['pending']).to be nil
+          expect(wip_pacts_from(pacts_for_verification_response).first["verificationProperties"]["wip"]).to be true
+          expect(wip_pacts_from(pacts_for_verification_response).first["verificationProperties"]["pending"]).to be true
 
           # verify pact... success!
 
@@ -259,13 +255,31 @@ RSpec.describe "the lifecycle of a WIP pact" do
         end
       end
 
-      describe "a feature branching scenario with matching feature branches" do
-        it "stays wip on master even after it has been successfully verified on the provider's feature branch" do
-          create_initial_provider_version_on_master
+      describe "a feature branching scenario with multiple provider feature branches" do
+        it "is WIP on a second feature branch even if the first feature branch successfully verified it" do
+          # CONSUMER BUILD - feature branch
+          publish_pact_with_feature_tag
 
-          # CONSUMER BUILD - master
-          publish_pact_with_master_tag
+          # PROVIDER BUILD for feature branch 1
+          # fetch pacts to verify
+          pacts_for_verification_response = get_pacts_for_verification(build_pacts_for_verification_request_body("feat-1", "master"))
+          pact_response = get_pact(wip_pact_url_from(pacts_for_verification_response))
+
+          # verify pact... success!
+
+          # publish success verification results
+          publish_verification_results("1", "feat-1", verification_results_url_from(pact_response), true)
+
+          # ANOTHER PROVIDER BUILD on a different new feature branch
+          # fetch pacts to verify
+          sleep 1 if ::DB.mysql?
+          pacts_for_verification_response = get_pacts_for_verification(build_pacts_for_verification_request_body("feat-2", "master"))
+          expect(wip_pacts_from(pacts_for_verification_response).size).to eq 1
+        end
+      end
 
+      describe "a feature branching scenario with matching feature branches" do
+        it "stays wip on master even after it has been successfully verified on the provider's feature branch" do
           # CONSUMER BUILD - feature branch
           publish_pact_with_feature_tag
 
@@ -283,7 +297,7 @@ RSpec.describe "the lifecycle of a WIP pact" do
 
           # PROVIDER BUILD - on a matching feature branch
           # fetch pacts to verify
-          pacts_for_verification_response = get_pacts_for_verification(build_pacts_for_verification_request_body("feat-x"))
+          pacts_for_verification_response = get_pacts_for_verification(build_pacts_for_verification_request_body("feat-x", "feat-x"))
           # pact is not WIP because it has been explicitly included
           expect(wip_pacts_from(pacts_for_verification_response).size).to eq 0
           pact_url = pact_urls_from(pacts_for_verification_response).first
@@ -303,36 +317,42 @@ RSpec.describe "the lifecycle of a WIP pact" do
       end
 
       describe "when a brand new provider branch is created" do
-        it "does not include any previously created WIP pacts because every single pact is pending for this new branch, and we don't want to verify the world" do
-          create_initial_provider_version_on_master
-
+        it "does not include any pacts already successfully verified by another branch before this branch was created" do
           # CONSUMER BUILD - master
           publish_pact_with_master_tag
 
+          # PROVIDER BUILD - master
+          pacts_for_verification_response = get_pacts_for_verification(build_pacts_for_verification_request_body("master", "master"))
+
+          # verify master pact successfully from provider master branch
+          pact_url = pact_urls_from(pacts_for_verification_response).first
+          pact_response = get_pact(pact_url)
+          verification_results_url = verification_results_url_from(pact_response)
+          publish_verification_results("1", "master", verification_results_url, true)
+          sleep 1 if ::DB.mysql?
+
           # CONSUMER BUILD - feature branch
           publish_pact_with_feature_tag
 
           # PROVIDER BUILD - brand new feature branch
           pacts_for_verification_response = get_pacts_for_verification(build_pacts_for_verification_request_body("feat-y", "master"))
-          expect(wip_pacts_from(pacts_for_verification_response).size).to eq 0
+          expect(wip_pacts_from(pacts_for_verification_response).size).to eq 1
 
-          # verify master pact successfully
-          pact_url = pact_urls_from(pacts_for_verification_response).first
-          pact_response = get_pact(pact_url)
+          # verify feature pact successfully
+          # pact_url = pact_urls_from(pacts_for_verification_response).first
+          # pact_response = get_pact(pact_url)
 
-          # publish successful results from feature branch
-          verification_results_url = verification_results_url_from(pact_response)
-          publish_verification_results("2", "feat-y", verification_results_url, true)
+          # # publish successful results from feature branch
+          # verification_results_url = verification_results_url_from(pact_response)
+          # publish_verification_results("2", "feat-y", verification_results_url, true)
 
-          # PROVIDER BUILD 2 - feature branch
-          pacts_for_verification_response = get_pacts_for_verification(build_pacts_for_verification_request_body("feat-y", "master"))
-          # still no wip pacts
-          expect(wip_pacts_from(pacts_for_verification_response).size).to eq 0
+          # # PROVIDER BUILD 2 - feature branch
+          # pacts_for_verification_response = get_pacts_for_verification(build_pacts_for_verification_request_body("feat-y", "master"))
+          # # still no wip pacts
+          # expect(wip_pacts_from(pacts_for_verification_response).size).to eq 0
         end
 
         it "does include any subsequently created new pacts" do
-          create_initial_provider_version_on_master
-
           # CONSUMER BUILD - master
           publish_pact_with_master_tag
 
@@ -341,7 +361,8 @@ RSpec.describe "the lifecycle of a WIP pact" do
 
           # PROVIDER BUILD - brand new feature branch
           pacts_for_verification_response = get_pacts_for_verification(build_pacts_for_verification_request_body("feat-y", "master"))
-          expect(wip_pacts_from(pacts_for_verification_response).size).to eq 0
+          expect(wip_pacts_from(pacts_for_verification_response).size).to eq 1
+
           # verify master pact successfully (creates a new provider version with tag feat-y)
           pact_url = pact_urls_from(pacts_for_verification_response).first
           pact_response = get_pact(pact_url)
@@ -356,7 +377,7 @@ RSpec.describe "the lifecycle of a WIP pact" do
           # CONSUMER BUILD - another feature branch
           publish_pact_with_feature_tag("4", "feat-z", pact_content_3)
 
-          # PROVIDER BUILD - brand new feature branch again
+          # PROVIDER BUILD - new feature branch again
           pacts_for_verification_response = get_pacts_for_verification(build_pacts_for_verification_request_body("feat-y", "master"))
           expect(wip_pacts_from(pacts_for_verification_response).size).to eq 2
         end