pact_broker 2.77.0 → 2.80.0

data/spec/lib/pact_broker/api/decorators/verification_decorator_spec.rb

@@ -1,4 +1,4 @@
-require 'pact_broker/api/decorators/verification_decorator'
+require "pact_broker/api/decorators/verification_decorator"
 
 module PactBroker
   module Api
@@ -9,32 +9,32 @@ module PactBroker
         end
 
         let(:verification) do
-          instance_double('PactBroker::Domain::Verification',
+          instance_double("PactBroker::Domain::Verification",
             number: 1,
             success: true,
             provider_version_number: "4.5.6",
-            provider_name: 'Provider',
-            consumer_name: 'Consumer',
-            test_results: { 'arbitrary' => 'json' },
-            build_url: 'http://build-url',
-            pact_version_sha: '1234',
+            provider_name: "Provider",
+            consumer_name: "Consumer",
+            test_results: { "arbitrary" => "json" },
+            build_url: "http://build-url",
+            pact_version_sha: "1234",
             latest_pact_publication: pact_publication,
             execution_date: DateTime.now,
             provider_version_tags: provider_version_tags)
         end
 
         let(:pact_publication) do
-          instance_double('PactBroker::Pacts::PactPublication',
-            name: 'A name',
-            provider_name: 'Provider',
-            consumer_name: 'Consumer',
-            consumer_version_number: '1.2.3'
+          instance_double("PactBroker::Pacts::PactPublication",
+            name: "A name",
+            provider_name: "Provider",
+            consumer_name: "Consumer",
+            consumer_version_number: "1.2.3"
           )
         end
 
-        let(:provider_version_tags) { [instance_double(PactBroker::Tags::TagWithLatestFlag, name: 'prod', latest?: true)] }
+        let(:provider_version_tags) { [instance_double(PactBroker::Tags::TagWithLatestFlag, name: "prod", latest?: true)] }
 
-        let(:options) { { user_options: { base_url: 'http://example.org' } } }
+        let(:options) { { user_options: { base_url: "http://example.org" } } }
 
         let(:json) { VerificationDecorator.new(verification).to_json(options) }
 
@@ -49,7 +49,7 @@ module PactBroker
         end
 
         it "includes the test results" do
-          expect(subject[:testResults]).to eq(arbitrary: 'json')
+          expect(subject[:testResults]).to eq(arbitrary: "json")
         end
 
         it "includes the build URL" do

data/spec/lib/pact_broker/api/decorators/verification_summary_decorator_spec.rb

@@ -1,4 +1,4 @@
-require 'pact_broker/api/decorators/verification_summary_decorator'
+require "pact_broker/api/decorators/verification_summary_decorator"
 
 module PactBroker
   module Api
@@ -12,24 +12,24 @@ module PactBroker
         let(:verification) do
           instance_double("PactBroker::Domain::Verification",
             success: true, number: 1,
-            provider_version_number: '4.5.6',
-            build_url: 'http://some-build',
-            provider_name: 'Provider',
-            consumer_name: 'Consumer',
+            provider_version_number: "4.5.6",
+            build_url: "http://some-build",
+            provider_name: "Provider",
+            consumer_name: "Consumer",
             pact_version: pact_version,
-            pact_version_sha: '1234',
+            pact_version_sha: "1234",
             latest_pact_publication: pact,
             test_results: nil,
             execution_date: DateTime.now,
             provider_version_tags: provider_version_tags)
         end
         let(:pact_version) do
-          instance_double("PactBroker::Pacts::PactVersion", name: 'Name')
+          instance_double("PactBroker::Pacts::PactVersion", name: "Name")
         end
 
-        let(:provider_version_tags) { [instance_double(PactBroker::Tags::TagWithLatestFlag, name: 'prod', latest?: true)] }
+        let(:provider_version_tags) { [instance_double(PactBroker::Tags::TagWithLatestFlag, name: "prod", latest?: true)] }
         let(:pact) { instance_double("PactBroker::Domain::Pact", name: "Some pact", consumer_name: "Foo", provider_name: "Bar", consumer_version_number: "1.2.3") }
-        let(:options) { {base_url: 'http://example.org', consumer_name: "Foo", consumer_version_number: "1.2.3", resource_url: "http://self"} }
+        let(:options) { {base_url: "http://example.org", consumer_name: "Foo", consumer_version_number: "1.2.3", resource_url: "http://self"} }
 
         subject { JSON.parse VerificationSummaryDecorator.new(summary).to_json(user_options: options), symbolize_names: true }
 

data/spec/lib/pact_broker/api/decorators/version_decorator_spec.rb

@@ -1,70 +1,115 @@
-require 'spec_helper'
-require 'pact_broker/api/decorators/version_decorator'
+require "spec_helper"
+require "pact_broker/api/decorators/version_decorator"
 
 module PactBroker
   module Api
     module Decorators
       describe VersionDecorator do
+        describe "from_json" do
+          let(:hash) do
+            {
+              branch: "branch",
+              buildUrl: "buildUrl",
+              tags: [{ name: "main" }]
+            }
+          end
 
-        let(:version) do
-          TestDataBuilder.new
-            .create_consumer("Consumer")
-            .create_provider("providerA")
-            .create_consumer_version("1.2.3")
-            .create_consumer_version_tag("prod")
-            .create_pact
-            .create_provider("ProviderB")
-            .create_pact
-            .and_return(:consumer_version)
+          subject { VersionDecorator.new(OpenStruct.new).from_json(hash.to_json) }
+
+          it "sets the properties" do
+            expect(subject.branch).to eq "branch"
+            expect(subject.build_url).to eq "buildUrl"
+            expect(subject.tags.first.name).to eq "main"
+          end
         end
 
-        let(:options) { { user_options: { base_url: 'http://example.org' } } }
+        describe "to_json" do
+          before do
+            allow(decorator).to receive(:deployed_versions_for_version_and_environment_url).and_return("http://deployed-versions")
+          end
 
-        subject { JSON.parse VersionDecorator.new(version).to_json(options), symbolize_names: true }
+          let(:version) do
+            TestDataBuilder.new
+              .create_consumer("Consumer")
+              .create_provider("providerA")
+              .create_consumer_version("1.2.3")
+              .create_consumer_version_tag("prod")
+              .create_pact
+              .create_provider("ProviderB")
+              .create_pact
+              .and_return(:consumer_version)
+          end
 
-        it "includes a link to itself" do
-          expect(subject[:_links][:self][:href]).to eq "http://example.org/pacticipants/Consumer/versions/1.2.3"
-        end
+          let(:environments) do
+            [
+              instance_double("PactBroker::Deployments::Environment",
+                uuid: "1234",
+                name: "test",
+                display_name: "Test"
+              )
+            ]
+          end
 
-        it "includes the version number in the link" do
-          expect(subject[:_links][:self][:name]).to eq "1.2.3"
-        end
+          let(:base_url) { "http://example.org" }
+          let(:options) { { user_options: { base_url: base_url, environments: environments } } }
+          let(:decorator) { VersionDecorator.new(version) }
 
-        it "includes its title in the link" do
-          expect(subject[:_links][:self][:title]).to eq "Version"
-        end
+          subject { JSON.parse(decorator.to_json(options), symbolize_names: true) }
 
-        it "includes the version number" do
-          expect(subject[:number]).to eq "1.2.3"
-        end
+          it "includes a link to itself" do
+            expect(subject[:_links][:self][:href]).to eq "http://example.org/pacticipants/Consumer/versions/1.2.3"
+          end
 
-        it "includes a link to the pacticipant" do
-          expect(subject[:_links][:'pb:pacticipant']).to eq title: "Pacticipant", name: "Consumer", href: "http://example.org/pacticipants/Consumer"
-        end
+          it "includes the version number in the link" do
+            expect(subject[:_links][:self][:name]).to eq "1.2.3"
+          end
 
-        it "includes a link to get, create or delete a tag" do
-          expect(subject[:_links][:'pb:tag']).to include href: "http://example.org/pacticipants/Consumer/versions/1.2.3/tags/{tag}", templated: true
-        end
+          it "includes its title in the link" do
+            expect(subject[:_links][:self][:title]).to eq "Version"
+          end
 
-        it "includes a list of the tags" do
-          expect(subject[:_embedded][:tags]).to be_instance_of(Array)
-          expect(subject[:_embedded][:tags].first[:name]).to eq "prod"
-        end
+          it "includes the version number" do
+            expect(subject[:number]).to eq "1.2.3"
+          end
 
-        it "includes the timestamps" do
-          expect(subject[:createdAt]).to_not be nil
-        end
+          it "includes a link to the pacticipant" do
+            expect(subject[:_links][:'pb:pacticipant']).to eq title: "Pacticipant", name: "Consumer", href: "http://example.org/pacticipants/Consumer"
+          end
 
-        it "includes a list of sorted pacts" do
-          expect(subject[:_links][:'pb:pact-versions']).to be_instance_of(Array)
-          expect(subject[:_links][:'pb:pact-versions'].first[:href]).to include ("1.2.3")
-          expect(subject[:_links][:'pb:pact-versions'].first[:name]).to include ("Pact between")
-          expect(subject[:_links][:'pb:pact-versions'].first[:name]).to include ("providerA")
-          expect(subject[:_links][:'pb:pact-versions'].last[:name]).to include ("ProviderB")
-        end
+          it "includes a link to get, create or delete a tag" do
+            expect(subject[:_links][:'pb:tag']).to include href: "http://example.org/pacticipants/Consumer/versions/1.2.3/tags/{tag}", templated: true
+          end
+
+          it "includes a list of the tags" do
+            expect(subject[:_embedded][:tags]).to be_instance_of(Array)
+            expect(subject[:_embedded][:tags].first[:name]).to eq "prod"
+          end
+
+          it "includes the timestamps" do
+            expect(subject[:createdAt]).to_not be nil
+          end
+
+          it "includes a list of sorted pacts" do
+            expect(subject[:_links][:'pb:pact-versions']).to be_instance_of(Array)
+            expect(subject[:_links][:'pb:pact-versions'].first[:href]).to include("1.2.3")
+            expect(subject[:_links][:'pb:pact-versions'].first[:name]).to include("Pact between")
+            expect(subject[:_links][:'pb:pact-versions'].first[:name]).to include("providerA")
+            expect(subject[:_links][:'pb:pact-versions'].last[:name]).to include("ProviderB")
+          end
+
+          it "includes a link to the latest verification results for the pacts for this version" do
+            expect(subject[:_links][:'pb:latest-verification-results-where-pacticipant-is-consumer'][:href]).to match(%r{http://.*/verification-results/.*/latest})
+          end
 
-        it "includes a link to the latest verification results for the pacts for this version" do
-          expect(subject[:_links][:'pb:latest-verification-results-where-pacticipant-is-consumer'][:href]).to match(%r{http://.*/verification-results/.*/latest})
+          it "includes a list of environments that this version can be deployed to" do
+            expect(decorator).to receive(:deployed_versions_for_version_and_environment_url).with(version, environments.first, base_url)
+            expect(subject[:_links][:'pb:record-deployment']).to be_instance_of(Array)
+            expect(subject[:_links][:'pb:record-deployment'].first).to eq(
+              name: "test",
+              title: "Record deployment to Test",
+              href: "http://deployed-versions"
+            )
+          end
         end
       end
     end

data/spec/lib/pact_broker/api/decorators/versions_decorator_spec.rb

@@ -1,25 +1,25 @@
-require 'spec_helper'
-require 'pact_broker/api/decorators/versions_decorator'
-require 'pact_broker/domain/version'
+require "spec_helper"
+require "pact_broker/api/decorators/versions_decorator"
+require "pact_broker/domain/version"
 
 module PactBroker
   module Api
     module Decorators
       describe VersionsDecorator do
 
-        let(:options) { { resource_url: 'http://versions', base_url: 'http://example.org', pacticipant_name: "Consumer", query_string: query_string}}
+        let(:options) { { resource_url: "http://versions", base_url: "http://example.org", pacticipant_name: "Consumer", query_string: query_string}}
         let(:query_string) { nil }
         let(:versions) { [] }
 
         subject { JSON.parse VersionsDecorator.new(versions).to_json(user_options: options), symbolize_names: true }
 
         context "with no query string" do
-          its([:_links, :self, :href]) { is_expected.to eq 'http://versions' }
+          its([:_links, :self, :href]) { is_expected.to eq "http://versions" }
         end
 
         context "with a query string" do
-          let(:query_string) { 'foo=bar' }
-          its([:_links, :self, :href]) { is_expected.to eq 'http://versions?foo=bar' }
+          let(:query_string) { "foo=bar" }
+          its([:_links, :self, :href]) { is_expected.to eq "http://versions?foo=bar" }
         end
 
         context "with no versions" do

data/spec/lib/pact_broker/api/decorators/webhook_decorator_spec.rb

@@ -1,18 +1,18 @@
-require 'pact_broker/api/decorators/webhook_decorator'
-require 'pact_broker/domain/webhook'
+require "pact_broker/api/decorators/webhook_decorator"
+require "pact_broker/domain/webhook"
 
 module PactBroker
   module Api
     module Decorators
       describe WebhookDecorator do
         let(:description) { "Trigger build" }
-        let(:headers) { { :'Content-Type' => 'application/json' } }
+        let(:headers) { { :'Content-Type' => "application/json" } }
         let(:request) do
           {
-            method: 'POST',
-            url: 'http://example.org/hook',
+            method: "POST",
+            url: "http://example.org/hook",
             headers: headers,
-            body: { some: 'body' }
+            body: { some: "body" }
           }
         end
 
@@ -20,9 +20,9 @@ module PactBroker
           Webhooks::WebhookRequestTemplate.new(request)
         end
 
-        let(:consumer) { Domain::Pacticipant.new(name: 'Consumer') }
-        let(:provider) { Domain::Pacticipant.new(name: 'Provider') }
-        let(:event)    { Webhooks::WebhookEvent.new(name: 'something_happened') }
+        let(:consumer) { Domain::Pacticipant.new(name: "Consumer") }
+        let(:provider) { Domain::Pacticipant.new(name: "Provider") }
+        let(:event)    { Webhooks::WebhookEvent.new(name: "something_happened") }
         let(:created_at) { DateTime.now }
         let(:updated_at) { created_at + 1 }
 
@@ -30,7 +30,7 @@ module PactBroker
           Domain::Webhook.new(
             description: description,
             request: webhook_request,
-            uuid: 'some-uuid',
+            uuid: "some-uuid",
             consumer: consumer,
             provider: provider,
             events: [event],
@@ -42,103 +42,103 @@ module PactBroker
 
         subject { WebhookDecorator.new(webhook) }
 
-        describe 'to_json' do
-          let(:parsed_json) { JSON.parse(subject.to_json(user_options: { base_url: 'http://example.org' }), symbolize_names: true) }
+        describe "to_json" do
+          let(:parsed_json) { JSON.parse(subject.to_json(user_options: { base_url: "http://example.org" }), symbolize_names: true) }
 
-          it 'includes the description' do
+          it "includes the description" do
             expect(parsed_json[:description]).to eq "Trigger build"
           end
 
-          it 'includes the request' do
+          it "includes the request" do
             expect(parsed_json[:request]).to eq request
           end
 
-          it 'includes the consumer' do
+          it "includes the consumer" do
             expect(parsed_json[:consumer]).to eq name: "Consumer"
           end
 
-          it 'includes the provider' do
+          it "includes the provider" do
             expect(parsed_json[:provider]).to eq name: "Provider"
           end
 
-          it 'includes a link to the consumer' do
-            expect(parsed_json[:_links][:'pb:consumer'][:name]).to eq 'Consumer'
-            expect(parsed_json[:_links][:'pb:consumer'][:href]).to eq 'http://example.org/pacticipants/Consumer'
+          it "includes a link to the consumer" do
+            expect(parsed_json[:_links][:'pb:consumer'][:name]).to eq "Consumer"
+            expect(parsed_json[:_links][:'pb:consumer'][:href]).to eq "http://example.org/pacticipants/Consumer"
           end
 
-          it 'includes a link to the provider' do
-            expect(parsed_json[:_links][:'pb:provider'][:name]).to eq 'Provider'
-            expect(parsed_json[:_links][:'pb:provider'][:href]).to eq 'http://example.org/pacticipants/Provider'
+          it "includes a link to the provider" do
+            expect(parsed_json[:_links][:'pb:provider'][:name]).to eq "Provider"
+            expect(parsed_json[:_links][:'pb:provider'][:href]).to eq "http://example.org/pacticipants/Provider"
           end
 
-          it 'includes a link to itself' do
-            expect(parsed_json[:_links][:self][:href]).to eq 'http://example.org/webhooks/some-uuid'
+          it "includes a link to itself" do
+            expect(parsed_json[:_links][:self][:href]).to eq "http://example.org/webhooks/some-uuid"
             expect(parsed_json[:_links][:self][:title]).to_not be_nil
           end
 
-          it 'includes a link to its parent collection' do
+          it "includes a link to its parent collection" do
             expect(parsed_json[:_links][:'pb:pact-webhooks'][:href]).to_not be_nil
           end
 
-          it 'includes a link to the webhooks resource' do
+          it "includes a link to the webhooks resource" do
             expect(parsed_json[:_links][:'pb:webhooks'][:href]).to_not be_nil
           end
 
-          it 'includes a link to execute the webhook directly' do
-            expect(parsed_json[:_links][:'pb:execute'][:href]).to eq 'http://example.org/webhooks/some-uuid/execute'
+          it "includes a link to execute the webhook directly" do
+            expect(parsed_json[:_links][:'pb:execute'][:href]).to eq "http://example.org/webhooks/some-uuid/execute"
           end
 
-          it 'includes the events' do
-            expect(parsed_json[:events].first).to eq name: 'something_happened'
+          it "includes the events" do
+            expect(parsed_json[:events].first).to eq name: "something_happened"
           end
 
-          it 'includes timestamps' do
+          it "includes timestamps" do
             expect(parsed_json[:createdAt]).to eq FormatDateTime.call(created_at)
             expect(parsed_json[:updatedAt]).to eq FormatDateTime.call(updated_at)
           end
 
-          it 'includes the enabled flag' do
+          it "includes the enabled flag" do
             expect(parsed_json[:enabled]).to eq false
           end
 
-          context 'when the headers are empty' do
+          context "when the headers are empty" do
             let(:headers) { nil }
-            it 'does not include the headers' do
+            it "does not include the headers" do
               expect(parsed_json[:request]).to_not have_key :headers
             end
           end
 
-          context 'when there is no consumer' do
+          context "when there is no consumer" do
             before do
               webhook.consumer = nil
             end
 
-            it 'does not include the consumer relation' do
+            it "does not include the consumer relation" do
               expect(parsed_json[:_links][:'pb:consumer']).to be nil
             end
 
-            it 'does not include the pact webhooks relation' do
+            it "does not include the pact webhooks relation" do
               expect(parsed_json[:_links][:'pb:pact-webhooks']).to be nil
             end
           end
 
-          context 'when there is no provider' do
+          context "when there is no provider" do
             before do
               webhook.provider = nil
             end
 
-            it 'does not include the provider relation' do
+            it "does not include the provider relation" do
               expect(parsed_json[:_links][:'pb:provider']).to be nil
             end
 
-            it 'does not include the pact webhooks relation' do
+            it "does not include the pact webhooks relation" do
               expect(parsed_json[:_links][:'pb:pact-webhooks']).to be nil
             end
           end
 
-          context 'when the headers contain sensitve information' do
-            let(:headers) { { 'Authorization' => 'foo' } }
-            it 'redacts them' do
+          context "when the headers contain sensitve information" do
+            let(:headers) { { "Authorization" => "foo" } }
+            it "redacts them" do
               expect(parsed_json[:request][:headers][:'Authorization']).to eq "**********"
             end
           end
@@ -146,38 +146,38 @@ module PactBroker
           context "when the description is empty" do
             let(:description) { " " }
 
-            it 'uses the scope description' do
-              expect(parsed_json[:description]).to match /example.org/
+            it "uses the scope description" do
+              expect(parsed_json[:description]).to match(/example.org/)
             end
           end
         end
 
-        describe 'from_json' do
+        describe "from_json" do
           let(:hash) { { request: request, events: [event] } }
-          let(:event) { {name: 'something_happened'} }
+          let(:event) { {name: "something_happened"} }
           let(:json) { hash.to_json }
           let(:webhook) { Domain::Webhook.new }
           let(:parsed_object) { subject.from_json(json) }
 
-          it 'parses the request method' do
-            expect(parsed_object.request.method).to eq 'POST'
+          it "parses the request method" do
+            expect(parsed_object.request.method).to eq "POST"
           end
 
-          it 'parses the request URL' do
-            expect(parsed_object.request.url).to eq 'http://example.org/hook'
+          it "parses the request URL" do
+            expect(parsed_object.request.url).to eq "http://example.org/hook"
           end
 
-          it 'parses the request headers' do
-            expect(parsed_object.request.headers).to eq 'Content-Type' => 'application/json'
+          it "parses the request headers" do
+            expect(parsed_object.request.headers).to eq "Content-Type" => "application/json"
           end
 
-          it 'parses the request body' do
-            expect(parsed_object.request.body).to eq 'some' => 'body'
+          it "parses the request body" do
+            expect(parsed_object.request.body).to eq "some" => "body"
           end
 
-          it 'parses the events' do
+          it "parses the events" do
             expect(parsed_object.events.size).to eq 1
-            expect(parsed_object.events.first.name).to eq 'something_happened'
+            expect(parsed_object.events.first.name).to eq "something_happened"
           end
 
           context "when no events are specified" do
@@ -193,8 +193,8 @@ module PactBroker
           context "when the decorated object has a consumer/provider but the incoming JSON does not" do
             let(:webhook) do
               Domain::Webhook.new(
-                consumer: Domain::Pacticipant.new(name: 'consumer'),
-                provider: Domain::Pacticipant.new(name: 'provider')
+                consumer: Domain::Pacticipant.new(name: "consumer"),
+                provider: Domain::Pacticipant.new(name: "provider")
               )
             end