pact_broker 2.38.1 → 2.39.0

data/spec/lib/pact_broker/pacts/repository_find_wip_pact_versions_for_provider_spec.rb

@@ -5,77 +5,107 @@ module PactBroker
     describe Repository do
       let(:td) { TestDataBuilder.new }
 
-      describe "find_pending_pact_versions_for_provider" do
-        subject { Repository.new.find_pending_pact_versions_for_provider("bar") }
+      describe "find_wip_pact_versions_for_provider" do
 
-        context "when the latest pact for a tag has been successfully verified" do
+        let(:provider_tags) { %w[dev] }
+        subject { Repository.new.find_wip_pact_versions_for_provider("bar", provider_tags) }
+
+        context "when there are no tags" do
+          let(:provider_tags) { [] }
+
+          it "returns an empty list" do
+            expect(subject).to eq []
+          end
+        end
+
+        context "when the latest pact for a tag has been successfully verified by the given provider tag" do
           before do
             td.create_pact_with_hierarchy("foo", "1", "bar")
               .comment("above not included because it's not the latest prod")
               .create_consumer_version("2")
               .create_consumer_version_tag("prod")
               .create_pact
-              .create_verification(provider_version: "3", comment: "not included because already verified")
+              .create_verification(provider_version: "3", tag_names: %w[dev], comment: "not included because already verified")
           end
 
+          let(:provider_tags) { %w[dev] }
+
           it "is not included" do
             expect(subject.size).to be 0
           end
         end
 
-        context "when the latest pact without a tag has failed verification" do
+        context "when the latest pact for a tag has been successfully verified by one of the given provider tags, but not the other" do
           before do
             td.create_pact_with_hierarchy("foo", "1", "bar")
-              .create_verification(provider_version: "3", success: false)
+              .create_consumer_version_tag("prod")
+              .create_verification(provider_version: "3", tag_names: %w[dev], comment: "not included because already verified")
           end
 
+          let(:provider_tags) { %w[dev feat-1] }
+
           it "is included" do
             expect(subject.size).to be 1
           end
+
+          it "sets the pending tags to the tag that has not yet been verified" do
+            expect(subject.first.pending_provider_tags).to eq %w[feat-1]
+          end
         end
 
-        context "when the latest pact without a tag has not been verified" do
+        context "when the latest pact for a tag has failed verification from the specified provider version" do
           before do
             td.create_pact_with_hierarchy("foo", "1", "bar")
-              .create_consumer_version("2")
-              .create_pact
+              .create_consumer_version_tag("feat-1")
+              .create_verification(provider_version: "3", success: false, tag_names: %[dev])
           end
 
           it "is included" do
-            expect(subject.first.consumer_version_number).to eq "2"
             expect(subject.size).to be 1
           end
+
+          it "sets the pending tags" do
+            expect(subject.first.pending_provider_tags).to eq %w[dev]
+          end
         end
 
-        context "when the latest pact for a tag has failed verification" do
+        context "when there are no consumer tags" do
           before do
             td.create_pact_with_hierarchy("foo", "1", "bar")
-              .create_consumer_version_tag("prod")
-              .create_verification(provider_version: "3", success: true)
-              .create_consumer_version("2", tag_names: ["prod"])
-              .create_pact
-              .create_verification(provider_version: "5", success: false)
+              .create_verification(provider_version: "3", success: false, tag_names: %[dev])
           end
 
-          it "is included" do
-            expect(subject.first.consumer_version_number).to eq "2"
-            expect(subject.size).to be 1
+          it "returns an empty list" do
+            expect(subject).to eq []
+          end
+        end
+
+        context "when the latest pact for a tag has successful and failed verifications" do
+          before do
+            td.create_pact_with_hierarchy("foo", "1", "bar")
+              .create_consumer_version_tag("dev")
+              .create_verification(provider_version: "3", success: true, tag_names: %[dev])
+              .create_verification(provider_version: "5", success: false, number: 2, tag_names: %[dev])
+          end
+
+          it "is not included, but maybe it should be? can't really work out a scenario where this is likely to happen" do
+            expect(subject).to eq []
           end
         end
 
         context "when the latest pact for a tag has not been verified" do
           before do
             td.create_pact_with_hierarchy("foo", "1", "bar")
-              .create_consumer_version_tag("prod")
-              .create_verification(provider_version: "5")
-              .create_consumer_version("2", tag_names: ["prod"])
-              .create_pact
+              .create_consumer_version_tag("dev")
           end
 
           it "is included" do
-            expect(subject.first.consumer_version_number).to eq "2"
             expect(subject.size).to be 1
           end
+
+          it "sets the pending tags" do
+            expect(subject.first.pending_provider_tags).to eq %w[dev]
+          end
         end
 
         context "when the provider name does not match the given provider name" do

data/spec/lib/pact_broker/pacts/service_find_for_verification_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'pact_broker/pacts/service'
+require 'pact_broker/pacts/pact_params'
+
+
+module PactBroker
+
+  module Pacts
+    describe Service do
+      let(:td) { TestDataBuilder.new }
+
+      describe "find_for_verification" do
+        include_context "stubbed repositories"
+
+        let(:head_pacts) { [pact_1, pact_2] }
+        let(:head_tag_1) { "dev" }
+        let(:head_tag_2) { "feat-x" }
+        let(:pact_version_sha_1) { "1" }
+        let(:pact_version_sha_2) { "2" }
+        let(:domain_pact_1) { double('pact1', pending?: true) }
+        let(:domain_pact_2) { double('pact2', pending?: true) }
+
+        let(:pact_1) do
+          double("HeadPact",
+            head_tag: head_tag_1,
+            pact_version_sha: pact_version_sha_1,
+            pact: domain_pact_1
+          )
+        end
+
+        let(:pact_2) do
+          double("HeadPact",
+            head_tag: head_tag_2,
+            pact_version_sha: pact_version_sha_2,
+            pact: domain_pact_2
+          )
+        end
+
+        let(:provider_name) { "Bar" }
+        let(:provider_version_tags) { [] }
+        let(:consumer_version_selectors) { [] }
+
+        before do
+          allow(pact_repository).to receive(:find_for_verification).and_return(head_pacts)
+        end
+
+        subject { Service.find_for_verification(provider_name, provider_version_tags, consumer_version_selectors) }
+      end
+    end
+  end
+end

data/spec/lib/pact_broker/pacts/squash_pacts_for_verification_spec.rb

@@ -0,0 +1,92 @@
+require 'pact_broker/pacts/squash_pacts_for_verification'
+
+module PactBroker
+  module Pacts
+    module SquashPactsForVerification
+      describe ".call" do
+        let(:head_pacts) { [pact_1, pact_2] }
+        let(:head_tag_1) { "dev" }
+        let(:head_tag_2) { "feat-x" }
+        let(:pact_version_sha_1) { "1" }
+        let(:pact_version_sha_2) { "2" }
+        let(:domain_pact_1) do
+          double('pact1',
+            pending?: pending_1,
+            select_pending_provider_version_tags: pending_provider_version_tags
+          )
+        end
+        let(:domain_pact_2) { double('pact2', pending?: pending_2) }
+        let(:pending_1) { false }
+        let(:pending_2) { false }
+        let(:pending_provider_version_tags) { [] }
+
+        let(:pact_1) do
+          double("HeadPact",
+            tag: head_tag_1,
+            pact_version_sha: pact_version_sha_1,
+            pact: domain_pact_1
+          )
+        end
+
+        let(:pact_2) do
+          double("HeadPact",
+            tag: head_tag_2,
+            pact_version_sha: pact_version_sha_2,
+            pact: domain_pact_2
+          )
+        end
+
+        let(:provider_name) { "Bar" }
+        let(:provider_version_tags) { [] }
+
+        subject { SquashPactsForVerification.call(provider_version_tags, head_pacts) }
+
+        context "when all of the consumer tags are not nil" do
+          its(:head_consumer_tags) { is_expected.to eq %w[dev feat-x] }
+          its(:overall_latest?) { is_expected.to be false }
+        end
+
+        context "when one of the consumer tags is nil" do
+          let(:head_tag_2) { nil }
+          its(:head_consumer_tags) { is_expected.to eq %w[dev] }
+          its(:overall_latest?) { is_expected.to be true }
+        end
+
+        context "when there are no provider tags" do
+          context "when the pact version is not pending" do
+            its(:pending) { is_expected.to be false }
+            its(:pending_provider_tags) { is_expected.to eq [] }
+            its(:non_pending_provider_tags) { is_expected.to eq [] }
+          end
+
+          context "when the pact version is pending" do
+            let(:pending_1) { true }
+            its(:pending) { is_expected.to be true }
+            its(:pending_provider_tags) { is_expected.to eq [] }
+            its(:non_pending_provider_tags) { is_expected.to eq [] }
+          end
+        end
+
+        context "when there are provider version tags" do
+          let(:provider_version_tags) { %w[dev feat-x] }
+
+          context "when a pact is pending for any of the provider tags" do
+            let(:pending_provider_version_tags) { %w[dev] }
+
+            its(:pending) { is_expected.to be true }
+            its(:pending_provider_tags) { is_expected.to eq %w[dev] }
+            its(:non_pending_provider_tags) { is_expected.to eq %w[feat-x] }
+          end
+
+          context "when a pact is not pending for any of the provider tags" do
+            let(:pending_provider_version_tags) { [] }
+
+            its(:pending) { is_expected.to be false }
+            its(:pending_provider_tags) { is_expected.to eq [] }
+            its(:non_pending_provider_tags) { is_expected.to eq %w[dev feat-x] }
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/pact_broker/pacts/verifiable_pact_messages_spec.rb

@@ -0,0 +1,93 @@
+require 'pact_broker/pacts/verifiable_pact_messages'
+require 'pact_broker/pacts/verifiable_pact'
+
+module PactBroker
+  module Pacts
+    describe VerifiablePactMessages do
+      let(:head_consumer_tags) { [] }
+      let(:pending_provider_tags) { [] }
+      let(:non_pending_provider_tags) { [] }
+      let(:pending) { false }
+      let(:verifiable_pact) do
+        double(VerifiablePact,
+          head_consumer_tags: head_consumer_tags,
+          consumer_name: "Foo",
+          provider_name: "Bar",
+          pending_provider_tags: pending_provider_tags,
+          non_pending_provider_tags: non_pending_provider_tags,
+          pending?: pending
+        )
+      end
+
+      subject { VerifiablePactMessages.new(verifiable_pact) }
+
+      describe "#inclusion_reason" do
+        context "when there are no head consumer tags" do
+          its(:inclusion_reason) { is_expected.to include "This pact is being verified because it is the latest pact between Foo and Bar." }
+        end
+
+        context "when there is 1 head consumer tags" do
+          let(:head_consumer_tags) { %w[dev] }
+          its(:inclusion_reason) { is_expected.to include "This pact is being verified because it is the pact for the latest version of Foo tagged with 'dev'" }
+        end
+
+        context "when there are 2 head consumer tags" do
+          let(:head_consumer_tags) { %w[dev prod] }
+          its(:inclusion_reason) { is_expected.to include "This pact is being verified because it is the pact for the latest versions of Foo tagged with 'dev' and 'prod' (both have the same content)" }
+        end
+
+        context "when there are 3 head consumer tags" do
+          let(:head_consumer_tags) { %w[dev prod feat-x] }
+          its(:inclusion_reason) { is_expected.to include "This pact is being verified because it is the pact for the latest versions of Foo tagged with 'dev', 'prod' and 'feat-x' (all have the same content)" }
+        end
+
+        context "when there are 4 head consumer tags" do
+          let(:head_consumer_tags) { %w[dev prod feat-x feat-y] }
+          its(:inclusion_reason) { is_expected.to include "'dev', 'prod', 'feat-x' and 'feat-y'" }
+        end
+      end
+
+      describe "#pending_reason" do
+        context "when the pact is not pending" do
+          context "when there are no non_pending_provider_tags" do
+            its(:pending_reason) { is_expected.to include "This pact has previously been successfully verified by Bar. If this verification fails, it will fail the build." }
+          end
+
+          context "when there is 1 non_pending_provider_tag" do
+            let(:non_pending_provider_tags) { %w[dev] }
+
+            its(:pending_reason) { is_expected.to include "This pact has previously been successfully verified by a version of Bar with tag 'dev'. If this verification fails, it will fail the build."}
+          end
+        end
+
+        context "when the pact is pending" do
+          let(:pending) { true }
+
+          context "when there are no pending_provider_tags" do
+            context "when there are no non_pending_provider_tags" do
+              its(:pending_reason) { is_expected.to include "This pact is in pending state because it has not yet been successfully verified by Bar. If this verification fails, it will not cause the overall build to fail." }
+            end
+          end
+
+          context "when there is 1 pending_provider_tag" do
+            let(:pending_provider_tags) { %w[dev] }
+
+            its(:pending_reason) { is_expected.to include "This pact is in pending state because it has not yet been successfully verified by any version of Bar with tag 'dev'. If this verification fails, it will not cause the overall build to fail." }
+          end
+
+          context "when there are 2 pending_provider_tags" do
+            let(:pending_provider_tags) { %w[dev feat-x] }
+
+            its(:pending_reason) { is_expected.to include "This pact is in pending state because it has not yet been successfully verified by any versions of Bar with tag 'dev' and 'feat-x'." }
+          end
+
+          context "when there are 3 pending_provider_tags" do
+            let(:pending_provider_tags) { %w[dev feat-x feat-y] }
+
+            its(:pending_reason) { is_expected.to include "'dev', 'feat-x' and 'feat-y'" }
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/pact_broker/ui/view_models/index_item_spec.rb

@@ -28,10 +28,10 @@ module PactBroker
         its(:consumer_group_url) { should eq "/groups/Consumer%20Name" }
         its(:provider_group_url) { should eq "/groups/Provider%20Name" }
 
-        describe "verification_status" do
+        describe "pseudo_branch_verification_status" do
           let(:domain_relationship) do
             instance_double("PactBroker::Domain::IndexItem",
-              verification_status: verification_status,
+              pseudo_branch_verification_status: pseudo_branch_verification_status,
               provider_name: "Foo",
               latest_verification_provider_version_number: "4.5.6")
           end
@@ -42,29 +42,29 @@ module PactBroker
           subject { IndexItem.new(domain_relationship) }
 
           context "when the pact has never been verified" do
-            let(:verification_status) { :never }
-            its(:verification_status) { is_expected.to eq "" }
+            let(:pseudo_branch_verification_status) { :never }
+            its(:pseudo_branch_verification_status) { is_expected.to eq "" }
             its(:warning?) { is_expected.to be false }
             its(:verification_tooltip) { is_expected.to eq nil }
           end
 
           context "when the pact has changed since the last successful verification" do
-            let(:verification_status) { :stale }
-            its(:verification_status) { is_expected.to eq "warning" }
+            let(:pseudo_branch_verification_status) { :stale }
+            its(:pseudo_branch_verification_status) { is_expected.to eq "warning" }
             its(:warning?) { is_expected.to be true }
             its(:verification_tooltip) { is_expected.to eq "Pact has changed since last successful verification by Foo (v4.5.6)" }
           end
 
           context "when the pact has not changed since the last successful verification" do
-            let(:verification_status) { :success }
-            its(:verification_status) { is_expected.to eq "success" }
+            let(:pseudo_branch_verification_status) { :success }
+            its(:pseudo_branch_verification_status) { is_expected.to eq "success" }
             its(:warning?) { is_expected.to be false }
             its(:verification_tooltip) { is_expected.to eq "Successfully verified by Foo (v4.5.6)" }
           end
 
           context "when the pact verification failed" do
-            let(:verification_status) { :failed }
-            its(:verification_status) { is_expected.to eq "danger" }
+            let(:pseudo_branch_verification_status) { :failed }
+            its(:pseudo_branch_verification_status) { is_expected.to eq "danger" }
             its(:warning?) { is_expected.to be false }
             its(:verification_tooltip) { is_expected.to eq "Verification by Foo (v4.5.6) failed" }
           end

data/spec/lib/pact_broker/verifications/{verification_status_spec.rb → pseudo_branch_status_spec.rb}

@@ -1,9 +1,9 @@
-require 'pact_broker/verifications/verification_status'
+require 'pact_broker/verifications/pseudo_branch_status'
 
 module PactBroker
   module Verifications
-    describe Status do
-      describe "verification_status" do
+    describe PseudoBranchStatus do
+      describe "pseudo_branch_verification_status" do
 
         let(:latest_verification) { instance_double("PactBroker::Domain::Verification", pact_version_sha: latest_verification_pact_version_sha, success: success) }
         let(:latest_pact) { instance_double("PactBroker::Domain::Pact", pact_version_sha: pact_pact_version_sha) }
@@ -11,7 +11,7 @@ module PactBroker
         let(:latest_verification_pact_version_sha) { '1234' }
         let(:success) { true }
 
-        subject { PactBroker::Verifications::Status.new(latest_pact, latest_verification) }
+        subject { PseudoBranchStatus.new(latest_pact, latest_verification) }
 
         context "when the pact is nil (used in badge resource)" do
           let(:latest_pact) { nil }

data/spec/support/shared_examples_for_responses.rb

@@ -67,6 +67,12 @@ RSpec::Matchers.define :include_hash_matching do |expected|
   end
 
   def slice actual, keys
-    keys.each_with_object({}) { |k, hash| hash[k] = actual[k] if (actual.respond_to?(:has_key?) && actual.has_key?(k)) || actual.respond_to?(k)  }
+    keys.each_with_object({}) do |k, hash|
+      if (actual.respond_to?(:has_key?) && actual.has_key?(k))
+        hash[k] = actual[k]
+      elsif actual.respond_to?(k)
+        hash[k] = actual.send(k)
+      end
+    end
   end
 end