pact_broker 2.79.1 → 2.80.0

data/spec/features/publish_not_a_pact_spec.rb

@@ -3,27 +3,27 @@ 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  }
+  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 }
+    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'
+      expect(parsed_response_body).to include "a" => "not pact"
     end
 
     it "returns _links" do
-      expect(parsed_response_body).to have_key '_links'
+      expect(parsed_response_body).to have_key "_links"
     end
   end
 
   context "when the content is an array" do
 
-    let(:pact_content) { '[1]' }
+    let(:pact_content) { "[1]" }
 
     it "accepts the un-pact Pact" do
       expect(subject.status).to be 201

data/spec/features/publish_pact_all_in_one_approval_spec.rb

@@ -0,0 +1,72 @@
+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

data/spec/features/publish_pact_all_in_one_spec.rb

@@ -0,0 +1,43 @@
+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 => "main",
+      :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(:encoded_contract) { Base64.strict_encode64(contract) }
+  let(:path) { "/contracts/publish" }
+
+  subject { post(path, request_body_hash.to_json, rack_headers) }
+
+  it { is_expected.to be_a_hal_json_success_response }
+
+  it "creates a pact" do
+    expect { subject }.to change { PactBroker::Pacts::PactPublication.count }.by(1)
+    expect(PactBroker::Pacts::PactVersion.last.content).to eq contract
+  end
+
+  context "with a validation error" do
+    before do
+      request_body_hash.delete(:pacticipantName)
+    end
+
+    it { is_expected.to be_a_json_error_response("missing") }
+  end
+end

data/spec/features/publish_pact_spec.rb

@@ -1,10 +1,16 @@
 describe "Publishing a pact" do
 
-  let(:pact_content) { load_fixture('a_consumer-a_provider.json') }
+  let(:pact_content) { load_fixture("a_consumer-a_provider.json") }
   let(:path) { "/pacts/provider/A%20Provider/consumer/A%20Consumer/versions/1.2.3" }
   let(:response_body_json) { JSON.parse(subject.body) }
+  let(:rack_env) do
+    {
+      "CONTENT_TYPE" => "application/json",
+      "pactbroker.database_connector" => lambda { |&block| block.call }
+    }
+  end
 
-  subject { put path, pact_content, {'CONTENT_TYPE' => 'application/json' }; last_response  }
+  subject { put(path, pact_content, rack_env)  }
 
   context "when a pact for this consumer version does not exist" do
     it "returns a 201 Created" do
@@ -12,7 +18,7 @@ describe "Publishing a pact" do
     end
 
     it "returns a json body" do
-      expect(subject.headers['Content-Type']).to eq "application/hal+json;charset=utf-8"
+      expect(subject.headers["Content-Type"]).to eq "application/hal+json;charset=utf-8"
     end
 
     it "returns the pact in the body" do
@@ -23,7 +29,7 @@ describe "Publishing a pact" do
   context "when a pact for this consumer version does exist" do
 
     before do
-      TestDataBuilder.new.create_pact_with_hierarchy("A Consumer", "1.2.3", "A Provider").and_return(:pact)
+      td.create_pact_with_hierarchy("A Consumer", "1.2.3", "A Provider").and_return(:pact)
     end
 
     it "returns a 200 Success" do
@@ -31,7 +37,7 @@ describe "Publishing a pact" do
     end
 
     it "returns an application/json Content-Type" do
-      expect(subject.headers['Content-Type']).to eq "application/hal+json;charset=utf-8"
+      expect(subject.headers["Content-Type"]).to eq "application/hal+json;charset=utf-8"
     end
 
     it "returns the pact in the response body" do
@@ -49,7 +55,7 @@ describe "Publishing a pact" do
 
   context "when the pacticipant name is an almost duplicate of an existing pacticipant name" do
     before do
-      TestDataBuilder.new.create_pacticipant("A Provider Service")
+      td.create_pacticipant("A Provider Service")
     end
 
     context "when duplicate checking is on" do
@@ -72,4 +78,33 @@ describe "Publishing a pact" do
       end
     end
   end
+
+  context "with a webhook configured", job: true do
+    before do
+      td.create_webhook(
+        method: "POST",
+        url: "http://example.org",
+        events: [{ name: PactBroker::Webhooks::WebhookEvent::CONTRACT_PUBLISHED }]
+      )
+    end
+    let!(:request) do
+      stub_request(:post, "http://example.org").to_return(:status => 200)
+    end
+
+    it "executes the webhook" do
+      subject
+      expect(request).to have_been_made
+    end
+
+    context "when an error occurs rendering the pact" do
+      before do
+        allow_any_instance_of(PactBroker::Api::Decorators::PactDecorator).to receive(:to_json).and_raise("an error")
+      end
+
+      it "does not execute the webhook" do
+        subject
+        expect(request).to_not have_been_made
+      end
+    end
+  end
 end

data/spec/features/publish_verification_spec.rb

@@ -1,17 +1,17 @@
-require 'pact_broker/domain/verification'
+require "pact_broker/domain/verification"
 
 describe "Publishing a pact verification" do
 
   let(:td) { TestDataBuilder.new }
   let(:path) { "/pacts/provider/Provider/consumer/Consumer/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 }
   let(:rack_env) do
     {
-      'CONTENT_TYPE' => 'application/json',
-      'HTTP_ACCEPT' => 'application/hal+json',
-      'pactbroker.database_connector' => lambda { |&block| block.call }
+      "CONTENT_TYPE" => "application/json",
+      "HTTP_ACCEPT" => "application/hal+json",
+      "pactbroker.database_connector" => lambda { |&block| block.call }
     }
   end
 
@@ -42,12 +42,12 @@ describe "Publishing a pact verification" do
 
   it "saves the test results" do
     subject
-    expect(PactBroker::Domain::Verification.order(:id).last.test_results).to eq('some' => 'results')
+    expect(PactBroker::Domain::Verification.order(:id).last.test_results).to eq("some" => "results")
   end
 
   it "returns a link to itself that can be followed" do
-    get_verification_link = parsed_response_body['_links']['self']['href']
-    get get_verification_link, nil, { 'HTTP_ACCEPT' => 'application/hal+json' }
+    get_verification_link = parsed_response_body["_links"]["self"]["href"]
+    get get_verification_link, nil, { "HTTP_ACCEPT" => "application/hal+json" }
     expect(last_response.status).to be 200
     expect(JSON.parse(subject.body)).to include JSON.parse(verification_content)
   end
@@ -55,13 +55,13 @@ describe "Publishing a pact verification" do
   context "with a webhook configured", job: true do
     before do
       td.create_webhook(
-        method: 'POST',
-        url: 'http://example.org',
+        method: "POST",
+        url: "http://example.org",
         events: [{ name: PactBroker::Webhooks::WebhookEvent::VERIFICATION_PUBLISHED }]
       )
     end
     let!(:request) do
-      stub_request(:post, 'http://example.org').to_return(:status => 200)
+      stub_request(:post, "http://example.org").to_return(:status => 200)
     end
 
     it "executes the webhook" do

data/spec/features/record_deployment_spec.rb

@@ -1,28 +1,93 @@
 #
-# pact-broker record-deployment --pacticipant Foo --version 1 --environment test --end-previous-deployment
+# pact-broker record-deployment --pacticipant Foo --version 1 --environment test --target instance1
 #
 
-describe "Record deployment", skip: "Not yet implemented" do
+describe "Record deployment" do
   before do
-    td.create_environment("test")
-      .create_pacticipant("Foo")
-      .create_pacticipant_version("1")
+    td.create_environment("test", uuid: "1234")
+      .create_consumer("Foo")
+      .create_consumer_version("1")
+      .create_deployed_version_for_consumer_version
+      .create_consumer_version("2")
   end
-  let(:path) { "/pacticipants/Foo/versions/1/deployments/test" }
   let(:headers) { {"CONTENT_TYPE" => "application/json"} }
-  let(:response_body) { JSON.parse(last_response.body, symbolize_names: true)}
+  let(:response_body) { JSON.parse(subject.body, symbolize_names: true) }
+  let(:version_path) { "/pacticipants/Foo/versions/2" }
+  let(:version_response) { get(version_path, nil, { "HTTP_ACCEPT" => "application/hal+json" } ) }
+  let(:target) { nil }
+  let(:path) do
+    JSON.parse(version_response.body)["_links"]["pb:record-deployment"]
+      .find{ |relation| relation["name"] == "test" }
+      .fetch("href")
+  end
+  let(:request_body) { { target: target }.to_json }
 
-  subject { post(path, nil, headers) }
+  subject { post(path, request_body, headers) }
 
   it { is_expected.to be_a_hal_json_created_response }
 
   it "returns the Location header" do
-    subject
-    expect(last_response.headers["Location"]).to eq "http://example.org/deployments/123456"
+    expect(subject.headers["Location"]).to start_with "http://example.org/deployed-versions/"
   end
 
   it "returns the newly created deployment" do
-    subject
-    expect(response_body).to include_key(:createdAt)
+    expect(response_body[:currentlyDeployed]).to be true
+    expect(response_body).to_not have_key(:target)
+  end
+
+  it "creates a new deployed version" do
+    expect { subject }.to change { PactBroker::Deployments::DeployedVersion.count }.by(1)
+  end
+
+  it "marks the previous deployment as not currently deployed" do
+    expect { subject }.to change { PactBroker::Deployments::DeployedVersion.undeployed.count }.by(1)
+  end
+
+  it "does not change the overall count of currently deployed versions" do
+    expect { subject }.to_not change { PactBroker::Deployments::DeployedVersion.currently_deployed.count }
+  end
+
+  context "when the version is already currently deployed to the environment and target" do
+    before do
+      td.create_deployed_version_for_consumer_version(uuid: "1234")
+    end
+
+    it "does not mark anything as undeployed" do
+      expect { subject }.to_not change { PactBroker::Deployments::DeployedVersion.undeployed.collect(&:uuid) }
+    end
+
+    it "returns the existing deployed version" do
+      expect(response_body[:uuid]).to eq "1234"
+    end
+  end
+
+  context "when the version was previously deployed to the environment and target but isn't any more" do
+    before do
+      td.create_deployed_version_for_consumer_version(uuid: "1234")
+        .create_consumer_version("3")
+        .create_deployed_version_for_consumer_version(uuid: "5678")
+    end
+
+    it "creates a new deployed version" do
+      expect { subject }.to change { PactBroker::Deployments::DeployedVersion.count }.by(1)
+    end
+  end
+
+  context "with an empty body" do
+    let(:request_body) { nil }
+
+    it { is_expected.to be_a_hal_json_created_response }
+  end
+
+  context "when the deployment is to a different target" do
+    let(:target) { "foo" }
+
+    it "creates a new deployed version" do
+      expect { subject }.to change { PactBroker::Deployments::DeployedVersion.currently_deployed.count }.by(1)
+    end
+
+    it "sets the target" do
+      expect(response_body).to have_key(:target)
+    end
   end
 end

data/spec/features/record_release_spec.rb

@@ -0,0 +1,84 @@
+#
+# pact-broker record-release --pacticipant Foo --version 1 --environment production
+#
+
+describe "Record release" do
+  before do
+    td.create_environment("production", uuid: "1234")
+      .create_consumer("Foo")
+      .create_consumer_version("1")
+  end
+  let(:headers) { {"CONTENT_TYPE" => "application/json"} }
+  let(:response_body) { JSON.parse(subject.body, symbolize_names: true) }
+  let(:version_path) { "/pacticipants/Foo/versions/1" }
+  let(:version_response) { get(version_path, nil, { "HTTP_ACCEPT" => "application/hal+json" } ) }
+  let(:target) { nil }
+  let(:path) do
+    JSON.parse(version_response.body)["_links"]["pb:record-release"]
+      .find{ |relation| relation["name"] == "production" }
+      .fetch("href")
+  end
+
+  subject { post(path, nil, headers) }
+
+  it { is_expected.to be_a_hal_json_created_response }
+
+  it "returns the Location header" do
+    expect(subject.headers["Location"]).to start_with "http://example.org/released-versions/"
+  end
+
+  it "returns the newly created release" do
+    expect(response_body[:currentlySupported]).to be true
+  end
+
+  it "creates a new released version" do
+    expect { subject }.to change { PactBroker::Deployments::ReleasedVersion.count }.by(1)
+  end
+
+  context "when the version is already released" do
+    before do
+      td.create_released_version_for_consumer_version(uuid: "1234")
+    end
+
+    it "returns the Location header" do
+      expect(subject.headers["Location"]).to include "1234"
+    end
+
+    it "does not change the overall count of released versions" do
+      expect { subject }.to_not change { PactBroker::Deployments::ReleasedVersion.count }
+    end
+
+    it "returns the existing released version" do
+      expect(response_body[:uuid]).to eq "1234"
+    end
+
+    it { is_expected.to be_a_hal_json_success_response }
+  end
+
+  context "when the version is currently unsupported" do
+    before do
+      td.create_released_version_for_consumer_version(uuid: "1234", currently_supported: false, created_at: DateTime.now - 1 )
+    end
+
+    it "returns the Location header" do
+      expect(subject.headers["Location"]).to include "1234"
+    end
+
+    it "returns the existing release with the currentlySupported parameter set back to true" do
+      expect(response_body[:currentlySupported]).to be true
+    end
+
+    it "does not change the createdAt" do
+      expect { subject }.to_not change { PactBroker::Deployments::ReleasedVersion.find(uuid: "1234").created_at }
+    end
+
+    it "updates the updatedAt" do
+      expect { subject }.to change { PactBroker::Deployments::ReleasedVersion.find(uuid: "1234").updated_at }
+    end
+  end
+
+  it "creates a released version resource" do
+    get(subject.headers["Location"])
+    expect(last_response.status).to eq 200
+  end
+end