pact_broker 2.81.0 → 2.82.0

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

@@ -80,6 +80,152 @@ module PactBroker
 
       end
 
+      describe "#calculate_required_verifications_for_pact" do
+        subject { Service.calculate_required_verifications_for_pact(pact) }
+
+        context "when there is no verification from the latest version from the main branch" do
+          let!(:pact) do
+            td.create_consumer("Foo")
+              .create_provider("Bar", main_branch: "main")
+              .create_provider_version("1", branch: "main")
+              .create_consumer_version("1")
+              .create_pact
+              .and_return(:pact)
+          end
+
+          it "returns the required verification for the main branch" do
+            expect(subject).to eq [
+              RequiredVerification.new(
+                provider_version: td.find_version("Bar", "1"),
+                provider_version_descriptions: ["latest version from main branch"]
+              )
+            ]
+          end
+        end
+
+        context "when there is a verification from the latest version from the main branch" do
+          let!(:pact) do
+            td.create_consumer("Foo")
+              .create_provider("Bar", main_branch: "main")
+              .create_provider_version("1", branch: "main")
+              .create_consumer_version("1")
+              .create_pact
+              .create_verification(provider_version: "2", branch: "main")
+              .and_return(:pact)
+          end
+
+          it "does not return a required verification" do
+            expect(subject).to eq []
+          end
+        end
+
+        context "when there is no verification for a deployed version" do
+          let!(:pact) do
+            td.create_environment("test")
+              .create_consumer("Foo")
+              .create_provider("Bar")
+              .create_provider_version("1")
+              .create_consumer_version("1")
+              .create_pact
+              .create_deployed_version_for_provider_version
+              .and_return(:pact)
+          end
+
+          it "returns the required verification for the deployed version" do
+            expect(subject).to eq [
+              RequiredVerification.new(
+                provider_version: td.find_version("Bar", "1"),
+                provider_version_descriptions: ["currently deployed version (test)"]
+              )
+            ]
+          end
+        end
+
+        context "when there is a verification for a deployed version" do
+          let!(:pact) do
+            td.create_environment("test")
+              .create_consumer("Foo")
+              .create_provider("Bar")
+              .create_provider_version("1")
+              .create_consumer_version("1")
+              .create_pact
+              .create_verification(provider_version: "1")
+              .create_deployed_version_for_provider_version
+              .and_return(:pact)
+          end
+
+          it "does not return a required verification for the deployed version" do
+            expect(subject).to eq []
+          end
+        end
+
+        context "when there is no verification for a released version" do
+          let!(:pact) do
+            td.create_environment("test")
+              .create_consumer("Foo")
+              .create_provider("Bar")
+              .create_provider_version("1")
+              .create_consumer_version("1")
+              .create_pact
+              .create_released_version_for_provider_version
+              .and_return(:pact)
+          end
+
+          it "returns the required verification for the released version" do
+            expect(subject).to eq [
+              RequiredVerification.new(
+                provider_version: td.find_version("Bar", "1"),
+                provider_version_descriptions: ["currently released version (test)"]
+              )
+            ]
+          end
+        end
+
+        context "when there is a verification for a released version" do
+          let!(:pact) do
+            td.create_environment("test")
+              .create_consumer("Foo")
+              .create_provider("Bar")
+              .create_provider_version("1")
+              .create_consumer_version("1")
+              .create_pact
+              .create_verification(provider_version: "1")
+              .create_released_version_for_provider_version
+              .and_return(:pact)
+          end
+
+          it "does not return a required verification for the deployed version" do
+            expect(subject).to eq []
+          end
+        end
+
+        context "when the latest version from the main branch is deployed and released and has no verification" do
+          let!(:pact) do
+            td.create_environment("test")
+              .create_consumer("Foo")
+              .create_provider("Bar", main_branch: "main")
+              .create_provider_version("1", branch: "main")
+              .create_consumer_version("1")
+              .create_pact
+              .create_deployed_version_for_provider_version
+              .create_released_version_for_provider_version
+              .and_return(:pact)
+          end
+
+          it "deduplicates the required versions" do
+            expect(subject).to eq [
+              RequiredVerification.new(
+              provider_version: td.find_version("Bar", "1"),
+              provider_version_descriptions: [
+                "latest version from main branch",
+                "currently deployed version (test)",
+                "currently released version (test)"
+              ])
+            ]
+          end
+        end
+      end
+
       describe "#errors" do
         let(:params) { {} }
 

data/spec/lib/pact_broker/versions/repository_spec.rb

@@ -4,8 +4,6 @@ require "pact_broker/versions/repository"
 module PactBroker
   module Versions
     describe Repository do
-
-      let(:td) { TestDataBuilder.new }
       let(:pacticipant_name) { "test_pacticipant" }
       let(:version_number) { "1.2.3" }
 
@@ -176,6 +174,44 @@ module PactBroker
           end
         end
       end
+
+      describe "#find_latest_version_from_main_branch" do
+        subject { Repository.new.find_latest_version_from_main_branch(td.find_pacticipant("Foo")) }
+
+        context "when there is a version with the provider's configured main branch as the branch" do
+          before do
+            td.create_consumer("Foo", main_branch: "main")
+              .create_consumer_version("1", branch: "main")
+              .create_consumer_version("2", branch: "main")
+              .create_consumer_version("3", tag_name: "main")
+              .create_consumer_version("4", branch: "not-main")
+          end
+
+          its(:number) { is_expected.to eq "2" }
+        end
+
+        context "when there is a version with the provider's configured main branch as the tag" do
+          before do
+            td.create_consumer("Foo", main_branch: "main")
+              .create_consumer_version("1", branch: "not-main")
+              .create_consumer_version("2", branch: "not-main")
+              .create_consumer_version("3", tag_name: "main")
+              .create_consumer_version("4", branch: "not-main")
+          end
+
+          its(:number) { is_expected.to eq "3" }
+        end
+
+        context "when there are no versions with a matching branch or tag set" do
+          before do
+            td.create_consumer("Foo", main_branch: "main")
+              .create_consumer_version("1", branch: "not-main")
+              .create_consumer_version("2", tag_name: "not-main")
+          end
+
+          it { is_expected.to be_nil }
+        end
+      end
     end
   end
 end

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

@@ -1,11 +1,102 @@
 require "pact_broker/versions/service"
 
 module PactBroker
-
   module Versions
     describe Service do
+      describe ".maybe_set_version_branch_from_tag" do
+        before do
+          allow(PactBroker.configuration).to receive(:use_first_tag_as_branch).and_return(use_first_tag_as_branch)
+        end
+
+        let(:pacticipant_name) { "test_pacticipant" }
+        let(:version_number) { "1.2.3" }
+        let(:tag_name) { "prod" }
+
+        subject { Service.maybe_set_version_branch_from_tag(td.find_version(pacticipant_name, version_number), tag_name) }
+
+        context "when use_first_tag_as_branch is true" do
+          let(:use_first_tag_as_branch) { true }
+
+          context "when there is already a tag" do
+            before do
+              td.create_consumer(pacticipant_name)
+                .create_consumer_version(version_number, tag_name: "foo")
+            end
+
+            it "does not set the branch" do
+              subject
+              expect(td.find_version(pacticipant_name, version_number).branch).to be_nil
+            end
+          end
+
+          context "when the branch is already set" do
+            before do
+              td.create_consumer(pacticipant_name)
+                .create_consumer_version(version_number, branch: "foo")
+            end
+
+            it "does not update the branch" do
+              subject
+              expect(td.find_version(pacticipant_name, version_number).branch).to eq "foo"
+            end
+          end
+
+          context "when use_first_tag_as_branch is false" do
+            before do
+              td.create_consumer(pacticipant_name)
+                .create_consumer_version(version_number)
+            end
+
+            let(:use_first_tag_as_branch) { false }
+
+            it "does not set the branch" do
+              subject
+              expect(td.find_version(pacticipant_name, version_number).branch).to be_nil
+            end
+          end
+
+          context "when the version was outside of the time difference limit" do
+            before do
+              version = td.create_consumer(pacticipant_name)
+                .create_consumer_version(version_number)
+                .and_return(:consumer_version)
+
+              version.update(created_at: created_at)
+              allow(PactBroker.configuration).to receive(:use_first_tag_as_branch_time_limit).and_return(10)
+              allow(Time).to receive(:now).and_return(td.in_utc { Time.new(2021, 1, 2, 10, 10, 11) } )
+            end
+
+            let(:created_at) { td.in_utc { Time.new(2021, 1, 2, 10, 10, 0) }.to_datetime  }
+            let(:one_second) { 1/(24 * 60 * 60) }
+
+            it "does not set the branch" do
+              subject
+              expect(td.find_version(pacticipant_name, version_number).branch).to be_nil
+            end
+          end
+
+          context "when the version was created within the limit" do
+            before do
+              version = td.create_consumer(pacticipant_name)
+                .create_consumer_version(version_number)
+                .and_return(:consumer_version)
+
+              version.update(created_at: created_at)
+              allow(PactBroker.configuration).to receive(:use_first_tag_as_branch_time_limit).and_return(10)
+              allow(Time).to receive(:now).and_return(td.in_utc { Time.new(2021, 1, 2, 10, 10, 10) } )
+            end
+
+            let(:created_at) { td.in_utc { Time.new(2021, 1, 2, 10, 10, 0) }.to_datetime  }
+            let(:one_second) { 1/(24 * 60 * 60) }
+
+            it "sets the branch" do
+              subject
+              expect(td.find_version(pacticipant_name, version_number).branch).to eq "prod"
+            end
+          end
+        end
+      end
       describe ".delete" do
-        let(:td) { TestDataBuilder.new }
         let!(:version) do
           td
             .create_consumer

data/spec/lib/pact_broker/webhooks/trigger_service_spec.rb

@@ -62,13 +62,18 @@ module PactBroker
         let(:provider) { PactBroker::Domain::Pacticipant.new(name: "Provider") }
         let(:webhooks) { [webhook]}
         let(:webhook) do
-          instance_double(PactBroker::Domain::Webhook, description: "description", uuid: "1244", expand_currently_deployed_provider_versions?: expand_currently_deployed)
+          instance_double(PactBroker::Domain::Webhook,
+            description: "description",
+            uuid: "1244",
+            expand_currently_deployed_provider_versions?: expand_currently_deployed
+          )
         end
         let(:expand_currently_deployed) { false }
+        let(:trigger_on_contract_requiring_verification_published) { false }
         let(:triggered_webhook) { instance_double(PactBroker::Webhooks::TriggeredWebhook) }
         let(:event_name) { PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED }
         let(:event_context) { { some: "data" } }
-        let(:expected_event_context) { { some: "data", event_name: PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED } }
+        let(:expected_event_context) { { some: "data", event_name: event_name } }
         let(:webhook_repository) { instance_double(Repository, create_triggered_webhook: triggered_webhook, find_webhooks_to_trigger: webhooks) }
 
         subject { TriggerService.create_triggered_webhooks_for_event(pact, verification, event_name, event_context) }
@@ -111,6 +116,53 @@ module PactBroker
             end
           end
 
+          context "when the event is contract_requiring_verification_published" do
+            before do
+              allow(TriggerService).to receive(:verification_service).and_return(verification_service)
+              allow(verification_service).to receive(:calculate_required_verifications_for_pact).and_return(required_verifications)
+            end
+
+            let(:event_name) { PactBroker::Webhooks::WebhookEvent::CONTRACT_REQUIRING_VERIFICATION_PUBLISHED }
+            let(:verification_service) { class_double("PactBroker::Verifications::Service").as_stubbed_const }
+            let(:required_verifications) { [required_verification] }
+            let(:required_verification) do
+              instance_double("PactBroker::Verifications::RequiredVerification",
+                provider_version: double("version", number: "1"),
+                provider_version_descriptions: ["foo"]
+              )
+            end
+
+            it "creates a triggered webhook for each required verification" do
+              expect(webhook_repository).to receive(:create_triggered_webhook).with(
+                anything,
+                webhook,
+                pact,
+                verification,
+                TriggerService::RESOURCE_CREATION,
+                PactBroker::Webhooks::WebhookEvent::CONTRACT_REQUIRING_VERIFICATION_PUBLISHED,
+                expected_event_context.merge(provider_version_number: "1", provider_version_descriptions: ["foo"])
+              )
+              subject
+            end
+
+            it "returns the triggered webhooks" do
+              expect(subject.size).to eq 1
+            end
+
+            context "when there are no required verifications" do
+              let(:required_verifications) { [] }
+
+              it "does not create any triggered webhooks" do
+                expect(webhook_repository).to_not receive(:create_triggered_webhook)
+                subject
+              end
+
+              it "returns an empty array" do
+                expect(subject).to eq []
+              end
+            end
+          end
+
           context "when there should be a webhook triggered for each consumer version that had a pact verified" do
             # let(:triggered_webhooks) { [instance_double(TriggeredWebhook, event_context: { some: 'context'}, webhook: instance_double(Webhook, uuid: "webhook-uuid"))]}
 

data/spec/lib/rack/pact_broker/invalid_uri_protection_spec.rb

@@ -5,7 +5,7 @@ module Rack
     describe InvalidUriProtection do
       let(:target_app) { ->(_env){ [200, {}, []] } }
       let(:app) { InvalidUriProtection.new(target_app) }
-      let(:path) { URI.encode("/foo") }
+      let(:path) { "/foo" }
 
       subject { get(path) }
 
@@ -28,7 +28,7 @@ module Rack
         end
 
         context "when the URI contains a new line because someone forgot to strip the result of `git rev-parse HEAD`, and I have totally never done this before myself" do
-          let(:path) { URI.encode("/foo\n/bar") }
+          let(:path) { "/foo%0A/bar" }
 
           it "returns a 422" do
             expect(subject.status).to eq 422
@@ -37,7 +37,7 @@ module Rack
         end
 
         context "when the URI contains a tab because sooner or later someone is eventually going to do this" do
-          let(:path) { URI.encode("/foo\t/bar") }
+          let(:path) { "/foo%09/bar" }
 
           it "returns a 422" do
             expect(subject.status).to eq 422

data/spec/spec_helper.rb

@@ -5,6 +5,7 @@ return if ENV["REGRESSION"] == "true"
 $: << File.expand_path("../../", __FILE__)
 
 RACK_ENV = ENV["RACK_ENV"] = "test"
+ENV["PACT_BROKER_LOG_LEVEL"] ||= "info"
 require "spec/support/simplecov"
 
 require "support/logging"
@@ -60,5 +61,5 @@ end
 
 if ENV["DEBUG"] == "true"
   SemanticLogger.add_appender(io: $stdout)
-  SemanticLogger.default_level = :info
+  SemanticLogger.default_level = :debug
 end

data/spec/support/approvals.rb

@@ -1,5 +1,16 @@
 require "approvals/rspec"
 require "pact/support"
+require "yaml"
+
+class YamlFormat < Approvals::Writers::TextWriter
+  def format(data)
+    data.to_yaml
+  end
+
+  def filter(data)
+    # Custom data filtering here
+  end
+end
 
 Approvals.configure do |c|
   c.approvals_path = "spec/fixtures/approvals/"
@@ -17,10 +28,28 @@ def print_diff(exception)
   end
 end
 
+module MatrixQueryContentForApproval
+  def matrix_query_content_for_approval(result)
+    {
+      "deployable" => result.deployment_status_summary.deployable?,
+      "reasons" => result.deployment_status_summary.reasons.collect(&:class).collect(&:name).sort
+    }
+  end
+end
+
 RSpec.configure do | config |
   config.after(:each) do | example |
     if example.exception.is_a?(Approvals::ApprovalError)
       print_diff(example.exception)
     end
   end
+
+  def file_name_to_approval_name(filename)
+    sanitize_filename(filename.split("spec/lib/pact_broker/", 2).last.gsub(".rb", ""))
+  end
+
+  def sanitize_filename(filename)
+    filename.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: "�").strip.tr("\u{202E}%$|:;/\t\r\n\\", "-")
+  end
+
 end