pact_broker 2.84.0 → 2.87.0

data/spec/lib/pact_broker/api/contracts/webhook_contract_spec.rb

@@ -85,6 +85,31 @@ module PactBroker
             end
           end
 
+          context "with a consumer label" do
+            let(:json) do
+              valid_webhook_with do |hash|
+                hash["consumer"].delete("name")
+                hash["consumer"]["label"] = "my_label"
+              end
+            end
+
+            it "contains no errors" do
+              expect(subject.errors).to be_empty
+            end
+          end
+
+          context "with a consumer label and name provided" do
+            let(:json) do
+              valid_webhook_with do |hash|
+                hash["consumer"]["label"] = "my_label"
+              end
+            end
+
+            it "contains consumer.label error" do
+              expect(subject.errors.messages).to eq({:'consumer.label' => ["cannot be provided"]})
+            end
+          end
+
           context "with a nil provider name" do
             let(:json) do
               valid_webhook_with do |hash|
@@ -131,6 +156,31 @@ module PactBroker
             end
           end
 
+          context "with provider label" do
+            let(:json) do
+              valid_webhook_with do |hash|
+                hash["provider"].delete("name")
+                hash["provider"]["label"] = "my_label"
+              end
+            end
+
+            it "contains no errors" do
+              expect(subject.errors).to be_empty
+            end
+          end
+
+          context "with a provider label and name" do
+            let(:json) do
+              valid_webhook_with do |hash|
+                hash["provider"]["label"] = "my_label"
+              end
+            end
+
+            it "contains provider.label error" do
+              expect(subject.errors.messages).to eq({:'provider.label' => ["cannot be provided"]})
+            end
+          end
+
           context "with no request defined" do
             let(:json) { {}.to_json }
 

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

@@ -129,7 +129,7 @@ module PactBroker
               verifiedAt: "2017-12-31T00:00:00+00:00",
               _links: {
                 self: {
-                  href: "http://example.org/pacts/provider/Provider/consumer/Consumer/pact-version/1234/verification-results/1"
+                  href: "http://example.org/pacts/provider/Provider/consumer/Consumer/pact-version/1234/metadata/Y3ZuPTEuMC4w/verification-results/1"
                 }
               }
             }

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

@@ -80,13 +80,13 @@ module PactBroker
           context "when the reason is NoEnvironmentSpecified" do
             let(:reason) { PactBroker::Matrix::NoEnvironmentSpecified.new }
 
-            its(:to_s) { is_expected.to start_with "WARN: For production use of can-i-deploy, it is recommended to specify the environment" }
+            its(:to_s) { is_expected.to start_with "WARN: It is recommended to specify the environment" }
           end
 
           context "when the reason is SelectorWithoutPacticipantVersionNumberSpecified" do
             let(:reason) { PactBroker::Matrix::SelectorWithoutPacticipantVersionNumberSpecified.new }
 
-            its(:to_s) { is_expected.to start_with "WARN: For production use of can-i-deploy, it is recommended to specify the version number" }
+            its(:to_s) { is_expected.to start_with "WARN: It is recommended to specify the version number" }
           end
         end
       end

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

@@ -6,6 +6,7 @@ module PactBroker
       describe VerificationDecorator do
         before do
           allow_any_instance_of(VerificationDecorator).to receive(:verification_triggered_webhooks_url).and_return("http://triggered-webhooks")
+          allow_any_instance_of(VerificationDecorator).to receive(:pact_version_with_consumer_version_metadata_url).and_return("http://pact")
         end
 
         let(:verification) do
@@ -18,23 +19,25 @@ module PactBroker
             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)
+            provider_version_tags: provider_version_tags,
+            verified_by_implementation: "Ruby",
+            verified_by_version: "1234")
         end
 
-        let(:pact_publication) do
-          instance_double("PactBroker::Pacts::PactPublication",
+        let(:pact) do
+          instance_double("PactBroker::Domain::Pact",
             name: "A name",
             provider_name: "Provider",
             consumer_name: "Consumer",
-            consumer_version_number: "1.2.3"
+            consumer_version_number: "1.2.3",
+            pact_version_sha: "1234",
           )
         end
 
         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", pact: pact } } }
 
         let(:json) { VerificationDecorator.new(verification).to_json(options) }
 
@@ -61,12 +64,17 @@ module PactBroker
         end
 
         it "includes a link to its pact" do
-          expect(subject[:_links][:'pb:pact-version'][:href]).to match %r{http://example.org/pacts/}
+          expect(subject[:_links][:'pb:pact-version'][:href]).to eq "http://pact"
         end
 
         it "includes a link to the triggered webhooks" do
           expect(subject[:_links][:'pb:triggered-webhooks'][:href]).to eq "http://triggered-webhooks"
         end
+
+        it "includes the framework that did the verification" do
+          expect(subject[:verifiedBy][:implementation]).to eq "Ruby"
+          expect(subject[:verifiedBy][:version]).to eq "1234"
+        end
       end
     end
   end

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

@@ -21,14 +21,18 @@ module PactBroker
             latest_pact_publication: pact,
             test_results: nil,
             execution_date: DateTime.now,
-            provider_version_tags: provider_version_tags)
+            provider_version_tags: provider_version_tags,
+            verified_by_implementation: "Ruby",
+            verified_by_version: "1234")
         end
+
         let(:pact_version) do
           instance_double("PactBroker::Pacts::PactVersion", name: "Name")
         end
 
         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(:pact) { instance_double("PactBroker::Domain::Pact", name: "Some pact", consumer_name: "Foo", provider_name: "Bar", consumer_version_number: "1.2.3", pact_version_sha: "1234") }
+        let(:is_pending) { true }
         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/webhook_decorator_spec.rb

@@ -20,8 +20,8 @@ module PactBroker
           Webhooks::WebhookRequestTemplate.new(request)
         end
 
-        let(:consumer) { Domain::Pacticipant.new(name: "Consumer") }
-        let(:provider) { Domain::Pacticipant.new(name: "Provider") }
+        let(:consumer) { Domain::WebhookPacticipant.new(name: "Consumer") }
+        let(:provider) { Domain::WebhookPacticipant.new(name: "Provider") }
         let(:event)    { Webhooks::WebhookEvent.new(name: "something_happened") }
         let(:created_at) { DateTime.now }
         let(:updated_at) { created_at + 1 }
@@ -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::WebhookPacticipant.new(name: "consumer"),
+                provider: Domain::WebhookPacticipant.new(name: "provider")
               )
             end
 

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

@@ -6,7 +6,7 @@ module PactBroker
     module Decorators
       describe WebhookExecutionResultDecorator do
         describe "to_json" do
-          let(:webhook_execution_result) { PactBroker::Webhooks::WebhookExecutionResult.new(request, response, logs, error) }
+          let(:webhook_execution_result) { PactBroker::Webhooks::WebhookExecutionResult.new(request, response, true, logs, error) }
           let(:logs) { "logs" }
           let(:headers) { { "Something" => ["blah", "thing"]} }
           let(:request) do

data/spec/lib/pact_broker/api/middleware/configuration_spec.rb

@@ -0,0 +1,43 @@
+require "pact_broker/api/middleware/configuration"
+
+module PactBroker
+  module Api
+    module Middleware
+      class TestApp
+        def call(_)
+          [200, {}, [PactBroker.configuration.allow_dangerous_contract_modification.to_s]]
+        end
+      end
+
+      describe Configuration do
+        describe "#call" do
+          let(:configuration) do
+            conf = PactBroker::Configuration.default_configuration
+            conf.allow_dangerous_contract_modification = false
+            conf
+          end
+          let(:app) { Configuration.new(TestApp.new, configuration) }
+          let(:rack_env) { {} }
+
+          subject { get("/", nil, rack_env) }
+
+          context "with no overrides" do
+            it "uses the default configuration" do
+              expect(subject.body).to eq "false"
+            end
+          end
+
+          context "with overrides" do
+            let(:rack_env) do
+              { "pactbroker.configuration_overrides" => { allow_dangerous_contract_modification: true }}
+            end
+
+            it "overrides the configuration for the duration of the request" do
+              expect(subject.body).to eq "true"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/pact_broker/api/pact_broker_urls_spec.rb

@@ -100,6 +100,24 @@ module PactBroker
         end
       end
 
+      describe "verification_url_from_params" do
+        context "with consumer_version_number" do
+          let(:params) do
+            {
+              consumer_name: consumer_name,
+              provider_name: provider_name,
+              pact_version_sha: "1234",
+              consumer_version_number: "2",
+              verification_number: "1"
+            }
+          end
+
+          subject { PactBrokerUrls.verification_url_from_params(params, base_url)}
+
+          it { is_expected.to eq "http://example.org/pacts/provider/Bar%2FBar/consumer/Foo%2FFoo/pact-version/1234/metadata/Y3ZuPTI/verification-results/1" }
+        end
+      end
+
       describe "templated_diff_url" do
         subject { PactBrokerUrls.templated_diff_url(pact, base_url) }
 

data/spec/lib/pact_broker/api/resources/triggered_webhook_logs_spec.rb

@@ -15,15 +15,16 @@ module PactBroker
             .create_webhook_execution(logs: "waffle")
         end
 
-        let(:path) { "/webhooks/5432/trigger/1234/logs" }
-
         subject { get(path) }
 
         let(:triggered_webhook_uuid) { PactBroker::Webhooks::TriggeredWebhook.first.uuid }
-        let(:path) { "/triggered-webhooks/#{triggered_webhook_uuid}/logs" }
 
-        it "returns the concatenated webhook execution logs" do
-          expect(subject.body).to eq "foo\nbar"
+        describe "by triggered webhook uuid" do
+          let(:path) { "/triggered-webhooks/1234/logs" }
+
+          it "returns the concatenated webhook execution logs" do
+            expect(subject.body).to eq "foo\nbar"
+          end
         end
       end
     end

data/spec/lib/pact_broker/api/resources/verifications_spec.rb

@@ -1,4 +1,3 @@
-require "spec_helper"
 require "pact_broker/api/resources/verifications"
 require "pact_broker/pacts/service"
 require "pact_broker/verifications/service"
@@ -17,7 +16,7 @@ module PactBroker
           let(:database_connector) { double("database_connector" )}
           let(:verification) { double(PactBroker::Domain::Verification) }
           let(:errors_empty) { true }
-          let(:parsed_metadata) { { the: "metadata", consumer_version_number: "2"} }
+          let(:parsed_metadata) { { the: "metadata", consumer_version_number: "2", pending: true } }
           let(:base_url) { "http://example.org" }
           let(:webhook_execution_configuration) { instance_double(PactBroker::Webhooks::ExecutionConfiguration) }
 
@@ -86,7 +85,7 @@ module PactBroker
             it "stores the verification in the database" do
               expect(PactBroker::Verifications::Service).to receive(:create).with(
                 next_verification_number,
-                hash_including("some" => "params", "wip" => false),
+                hash_including("some" => "params", "wip" => false, "pending" => true),
                 verified_pacts,
                 parsed_metadata
               )

data/spec/lib/pact_broker/api/resources/webhook_execution_spec.rb

@@ -30,7 +30,7 @@ module PactBroker
             let(:pact) { instance_double("PactBroker::Domain::Pact") }
             let(:consumer_name) { "foo" }
             let(:provider_name) { "bar" }
-            let(:webhook_execution_configuration) { instance_double(PactBroker::Webhooks::ExecutionConfiguration, webhook_context: event_context) }
+            let(:webhook_execution_configuration) { instance_double(PactBroker::Webhooks::ExecutionConfiguration, retry_schedule: [], webhook_context: event_context) }
             let(:event_context) { { some: "data" } }
 
             before do

data/spec/lib/pact_broker/badges/service_spec.rb

@@ -203,6 +203,18 @@ module PactBroker
           end
         end
 
+        context "when the pseudo_branch_verification_status is :failed_pending" do
+          let(:pseudo_branch_verification_status) { :failed_pending }
+          let(:expected_color) { "red" }
+          let(:expected_right_text) { "failed%20%28pending%29" }
+
+          it "create a red badge with left text 'failed'" do
+            subject
+            expect(http_request).to have_been_made
+            expect(pact_verification_badge_url).to eq URI(expected_url)
+          end
+        end
+
         context "when the pseudo_branch_verification_status is :stale" do
           let(:pseudo_branch_verification_status) { :stale }
           let(:expected_color) { "orange" }
@@ -248,6 +260,16 @@ module PactBroker
             end
           end
 
+          # TODO save a static image for this
+          context "when the pseudo_branch_verification_status is failed_pending" do
+            let(:pseudo_branch_verification_status) { :failed_pending }
+
+            it "returns a static failed image" do
+              expect(subject).to include ">pact</"
+              expect(subject).to include ">failed</"
+            end
+          end
+
           context "when the pseudo_branch_verification_status is stale" do
             let(:pseudo_branch_verification_status) { :stale }
 

data/spec/lib/pact_broker/config/runtime_configuration_documentation_spec.rb

@@ -0,0 +1,30 @@
+require "pact_broker/config/runtime_configuration"
+
+module PactBroker
+  module Config
+    describe RuntimeConfiguration do
+      ATTRIBUTES = RuntimeConfiguration.config_attributes
+      DOCUMENTATION = File.read("docs/configuration.yml")
+      DOCUMENTED_ATTRIBUTES = YAML.load(DOCUMENTATION)["groups"].flat_map{ | group | group["vars"].keys.collect(&:to_sym) }
+      DELIBERATELY_UNDOCUMENTED_ATTRIBUTES = [
+        :warning_error_class_names,
+        :log_configuration_on_startup,
+        :use_hal_browser,
+        :use_rack_protection,
+        :use_case_sensitive_resource_names,
+        :order_versions_by_date,
+        :base_equality_only_on_content_that_affects_verification_results,
+        :semver_formats,
+        :seed_example_data,
+        :use_first_tag_as_branch_time_limit,
+        :validate_database_connection_config
+      ]
+
+      (ATTRIBUTES - DELIBERATELY_UNDOCUMENTED_ATTRIBUTES).each do | attribute_name |
+        it "has documentation for #{attribute_name}" do
+          expect(DOCUMENTED_ATTRIBUTES & [attribute_name]).to include(attribute_name)
+        end
+      end
+    end
+  end
+end

data/spec/lib/pact_broker/deployments/environment_service_spec.rb

@@ -2,7 +2,7 @@ require "pact_broker/deployments/environment_service"
 
 module PactBroker
   module Deployments
-    module EnvironmentService
+    describe EnvironmentService do
       describe ".create" do
         let(:environment) do
           Environment.new(

data/spec/lib/pact_broker/domain/webhook_request_spec.rb

@@ -19,7 +19,8 @@ module PactBroker
           headers: headers,
           username: username,
           password: password,
-          body: body)
+          body: body,
+          user_agent: "Pact Broker")
       end
 
       let(:execute) { subject.execute }

data/spec/lib/pact_broker/domain/webhook_spec.rb

@@ -11,10 +11,11 @@ module PactBroker
       let(:webhook_template_parameters) { instance_double(PactBroker::Webhooks::PactAndVerificationParameters, to_hash: webhook_template_parameters_hash) }
       let(:webhook_template_parameters_hash) { { "foo" => "bar" } }
       let(:http_request) { double("http request") }
-      let(:http_response) { double("http response", code: "200") }
+      let(:http_response) { double("http response", code: response_code) }
+      let(:response_code) { "200" }
       let(:event_context) { { some: "things" } }
       let(:logging_options) { { other: "options" } }
-      let(:options) { { logging_options: logging_options } }
+      let(:options) { { logging_options: logging_options, http_success_codes: [200], user_agent: "user agent" } }
       let(:pact) { double("pact") }
       let(:verification) { double("verification") }
       let(:logger) { double("logger").as_null_object }
@@ -71,7 +72,7 @@ module PactBroker
         end
 
         it "builds the request" do
-          expect(request_template).to receive(:build).with(webhook_template_parameters_hash)
+          expect(request_template).to receive(:build).with(webhook_template_parameters_hash, "user agent")
           execute
         end
 
@@ -81,7 +82,7 @@ module PactBroker
         end
 
         it "generates the execution logs" do
-          expect(webhook_request_logger).to receive(:log).with(uuid, webhook_request, http_response, nil, event_context)
+          expect(webhook_request_logger).to receive(:log).with(uuid, webhook_request, http_response, true, nil, event_context)
           execute
         end
 
@@ -90,6 +91,7 @@ module PactBroker
           expect(execute.response).to_not be nil
           expect(execute.logs).to eq "logs"
           expect(execute.error).to be nil
+          expect(execute.success?).to be true
         end
 
         it "logs before and after" do
@@ -98,6 +100,14 @@ module PactBroker
           execute
         end
 
+        context "when a response status is returned that is not in the http_success_codes" do
+          let(:response_code) { "301" }
+
+          it "returns a result with success? false" do
+            expect(execute.success?).to be false
+          end
+        end
+
         context "when an error is thrown" do
           let(:error_class) { Class.new(StandardError) }
 
@@ -106,7 +116,7 @@ module PactBroker
           end
 
           it "generates the execution logs" do
-            expect(webhook_request_logger).to receive(:log).with(uuid, webhook_request, nil, instance_of(error_class), event_context)
+            expect(webhook_request_logger).to receive(:log).with(uuid, webhook_request, nil, false, instance_of(error_class), event_context)
             execute
           end
 

data/spec/lib/pact_broker/index/service_spec.rb

@@ -1,12 +1,8 @@
-require "spec_helper"
 require "pact_broker/index/service"
-require "pact_broker/domain/tag"
-require "pact_broker/domain/pact"
 
 module PactBroker
   module Index
     describe Service do
-      let(:td) { TestDataBuilder.new }
       let(:tags) { ["prod", "production"] }
       let(:options) { { tags: tags, page_size: page_size, page_number: page_number } }
       let(:page_number) { nil }
@@ -19,7 +15,7 @@ module PactBroker
 
       subject { Service }
 
-      describe "find_relationships integration test" do
+      describe "find_index_items integration test" do
         context "when a prod pact exists and is not the latest version" do
           before do
             td.create_pact_with_hierarchy("Foo", "1.2.3", "Bar")

data/spec/lib/pact_broker/index/service_view_spec.rb

@@ -0,0 +1,144 @@
+require "pact_broker/index/service"
+
+module PactBroker
+  module Index
+    describe Service do
+      let(:tags) { ["prod", "production"] }
+      let(:options) do
+        {
+          page_size: page_size,
+          page_number: page_number,
+          view: view,
+          consumer_name: consumer_name,
+          provider_name: provider_name
+        }
+      end
+      let(:page_number) { nil }
+      let(:page_size) { nil }
+      let(:consumer_name) { "Foo"}
+      let(:provider_name) { "Bar"}
+
+      subject { Service.find_index_items(options) }
+
+      describe "find_index_items" do
+        context "when view == branch" do
+          before do
+            td.create_consumer("Foo")
+              .create_provider("Bar")
+              .create_consumer_version("1", branch: "main", tag_names: ["dev"])
+              .create_pact
+              .create_consumer_version("2", tag_names: ["dev"])
+              .create_pact
+              .create_consumer_version("3", branch: "feat/x", tag_names: ["dev-1"])
+              .create_pact
+              .create_consumer_version("4", branch: "main", tag_names: ["dev-2"])
+              .create_pact
+              .create_consumer_version("4", branch: "feat/y")
+              .create_consumer("NotFoo")
+              .create_consumer_version("10", branch: "main")
+              .create_pact
+          end
+
+          let(:view) { "branch" }
+
+          let(:consumer_version_numbers) { subject.collect(&:consumer_version_number) }
+
+          it "returns the latest pacts for each branch" do
+            expect(consumer_version_numbers).to eq ["4", "3"]
+          end
+        end
+
+        context "when view == tag" do
+          before do
+            td.create_consumer("Foo")
+              .create_provider("Bar")
+              .create_consumer_version("1", branch: "main", tag_names: ["dev"])
+              .create_pact
+              .create_consumer_version("2", tag_names: ["dev"])
+              .create_pact
+              .create_consumer_version("3", branch: "feat/x", tag_names: ["dev-2"])
+              .create_pact
+              .create_consumer_version("4", branch: "main", tag_names: ["dev-3"])
+              .create_pact
+              .create_consumer_version("4", branch: "feat/y")
+              .create_consumer("NotFoo")
+              .create_consumer_version("10", branch: "main")
+              .create_pact
+          end
+
+          let(:view) { "tag" }
+
+          let(:consumer_version_numbers) { subject.collect(&:consumer_version_number) }
+
+          it "returns the latest pacts for each tag" do
+            expect(consumer_version_numbers).to eq ["4", "3", "2"]
+          end
+        end
+
+        context "when view == environment" do
+          before do
+            td.create_environment("test")
+              .create_consumer("Foo")
+              .create_provider("Bar")
+              .create_consumer_version("1")
+              .create_pact
+              .create_deployed_version_for_consumer_version(currently_deployed: false)
+              .create_consumer_version("2")
+              .create_pact
+              .create_deployed_version_for_consumer_version
+              .create_consumer_version("3")
+              .create_pact
+              .create_released_version_for_consumer_version(currently_supported: false)
+              .create_consumer_version("4")
+              .create_pact
+              .create_released_version_for_consumer_version
+              .create_consumer_version("5")
+              .create_pact
+          end
+
+          let(:view) { "environment" }
+
+          let(:consumer_version_numbers) { subject.collect(&:consumer_version_number) }
+
+          it "returns the currently deployed and released+supported pacts" do
+            expect(consumer_version_numbers).to eq ["4", "2"]
+          end
+        end
+
+        context "when view == all" do
+          before do
+            td.create_environment("test")
+              .create_consumer("Foo")
+              .create_provider("Bar")
+              .create_consumer_version("1")
+              .create_pact
+              .create_deployed_version_for_consumer_version
+              .create_consumer_version("2")
+              .create_pact
+              .create_released_version_for_consumer_version
+              .create_consumer_version("3", branch: "main")
+              .create_pact
+              .create_consumer_version("4", branch: "main")
+              .create_pact
+              .create_consumer_version("5", tag_names: "dev")
+              .create_pact
+              .create_consumer_version("6", tag_names: "dev")
+              .create_pact
+              .create_consumer_version("7")
+              .create_pact
+              .create_consumer_version("8")
+              .create_pact
+          end
+
+          let(:view) { "all" }
+
+          let(:consumer_version_numbers) { subject.collect(&:consumer_version_number) }
+
+          it "returns the latest for each branch, tag, deployed, released + overall latest" do
+            expect(consumer_version_numbers).to eq ["8", "6", "4", "2", "1"]
+          end
+        end
+      end
+    end
+  end
+end