pact_broker 2.77.0 → 2.80.0

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

@@ -1,6 +1,6 @@
-require 'spec_helper'
-require 'pact_broker/pacts/service'
-require 'pact_broker/pacts/pact_params'
+require "spec_helper"
+require "pact_broker/pacts/service"
+require "pact_broker/pacts/pact_params"
 
 module PactBroker
   module Pacts
@@ -15,8 +15,8 @@ module PactBroker
         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(:domain_pact_1) { double("pact1", pending?: true) }
+        let(:domain_pact_2) { double("pact2", pending?: true) }
 
         let(:pact_1) do
           double("HeadPact",

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

@@ -1,20 +1,15 @@
-require 'spec_helper'
-require 'pact_broker/pacts/service'
-require 'pact_broker/pacts/pact_params'
-require 'pact_broker/webhooks/execution_configuration'
+require "spec_helper"
+require "pact_broker/pacts/service"
+require "pact_broker/pacts/pact_params"
+require "pact_broker/webhooks/execution_configuration"
 
 module PactBroker
-
   module Pacts
     describe Service do
-      let(:td) { TestDataBuilder.new }
-
       describe "create_or_update_pact" do
         include_context "stubbed repositories"
 
         before do
-          allow(described_class).to receive(:webhook_service).and_return(webhook_service)
-          allow(described_class).to receive(:webhook_trigger_service).and_return(webhook_trigger_service)
           allow(pacticipant_repository).to receive(:find_by_name_or_create).with(params[:consumer_name]).and_return(consumer)
           allow(pacticipant_repository).to receive(:find_by_name_or_create).with(params[:provider_name]).and_return(provider)
           allow(version_repository).to receive(:find_by_pacticipant_id_and_number_or_create).and_return(version)
@@ -22,18 +17,13 @@ module PactBroker
           allow(pact_repository).to receive(:create).and_return(new_pact)
           allow(pact_repository).to receive(:update).and_return(new_pact)
           allow(pact_repository).to receive(:find_previous_pacts).and_return(previous_pacts)
-          allow(webhook_service).to receive(:trigger_webhooks)
-          allow(webhook_trigger_service).to receive(:trigger_webhooks_for_new_pact)
-          allow(webhook_trigger_service).to receive(:trigger_webhooks_for_updated_pact)
         end
 
-        let(:webhook_service) { class_double("PactBroker::Webhooks::Service").as_stubbed_const }
-        let(:webhook_trigger_service) { class_double("PactBroker::Webhooks::TriggerService").as_stubbed_const }
-        let(:consumer) { double('consumer', id: 1) }
-        let(:provider) { double('provider', id: 2) }
-        let(:version) { double('version', id: 3, pacticipant_id: 1) }
+        let(:consumer) { double("consumer", id: 1) }
+        let(:provider) { double("provider", id: 2) }
+        let(:version) { double("version", id: 3, pacticipant_id: 1) }
         let(:existing_pact) { nil }
-        let(:new_pact) { double('new_pact', consumer_version_tag_names: %w[dev], json_content: json_content) }
+        let(:new_pact) { double("new_pact", consumer_version_tag_names: %w[dev], json_content: json_content, pact_version_sha: "1", consumer_name: "Foo", consumer_version_number: "2") }
         let(:json_content) { { the: "contract" }.to_json }
         let(:json_content_with_ids) { { the: "contract with ids" }.to_json }
         let(:previous_pacts) { [] }
@@ -45,20 +35,18 @@ module PactBroker
             json_content: json_content
           }
         end
-        let(:content) { double('content') }
-        let(:content_with_interaction_ids) { double('content_with_interaction_ids', to_json: json_content_with_ids) }
-        let(:webhook_options) { { webhook_execution_configuration: webhook_execution_configuration } }
-        let(:webhook_execution_configuration) { instance_double(PactBroker::Webhooks::ExecutionConfiguration) }
+        let(:content) { double("content") }
+        let(:content_with_interaction_ids) { double("content_with_interaction_ids", to_json: json_content_with_ids) }
         let(:expected_event_context) { { consumer_version_tags: ["dev"] } }
 
         before do
           allow(Content).to receive(:from_json).and_return(content)
           allow(content).to receive(:with_ids).and_return(content_with_interaction_ids)
           allow(PactBroker::Pacts::GenerateSha).to receive(:call).and_call_original
-          allow(webhook_execution_configuration).to receive(:with_webhook_context).and_return(webhook_execution_configuration)
+          allow(Service).to receive(:broadcast)
         end
 
-        subject { Service.create_or_update_pact(params, webhook_options) }
+        subject { Service.create_or_update_pact(params) }
 
         context "when no pact exists with the same params" do
           it "creates the sha before adding the interaction ids" do
@@ -72,25 +60,79 @@ module PactBroker
             subject
           end
 
-          it "sets the consumer version tags" do
-            expect(webhook_execution_configuration).to receive(:with_webhook_context).with(consumer_version_tags: %w[dev]).and_return(webhook_execution_configuration)
-            subject
+          # TODO test all this contract_content_changed logic properly!
+          context "when the latest pact for one of the tags has a different pact_version_sha" do
+            before do
+              allow(pact_repository).to receive(:find_previous_pacts).and_return(previous_pacts_by_tag)
+            end
+
+            let(:previous_dev_pact_version_sha) { "2" }
+            let(:previous_pacts_by_tag) do
+              {
+                dev: double("previous pact", pact_version_sha: previous_dev_pact_version_sha)
+              }
+            end
+
+            it "broadcasts the contract_published event" do
+              expect(Service).to receive(:broadcast).with(
+                :contract_published,
+                  {
+                    pact: new_pact,
+                    event_context: { consumer_version_tags: %w[dev] }
+                  }
+              )
+              subject
+            end
+
+            it "broadcasts the contract_content_changed event" do
+              expect(Service).to receive(:broadcast).with(
+                :contract_content_changed,
+                  {
+                    pact: new_pact,
+                    event_comment: "pact content has changed since the last consumer version tagged with dev",
+                    event_context: { consumer_version_tags: %w[dev] }
+                  }
+              )
+              subject
+            end
           end
 
-          it "triggers webhooks" do
-            expect(webhook_trigger_service).to receive(:trigger_webhooks_for_new_pact).with(new_pact, expected_event_context, webhook_options)
-            subject
+          context "when the new pact has not changed content or tags since the previous version with the same tags" do
+            before do
+              allow(pact_repository).to receive(:find_previous_pacts).and_return(previous_pacts_by_tag)
+            end
+
+            let(:previous_dev_pact_version_sha) { "1" }
+            let(:previous_pacts_by_tag) do
+              {
+                dev: double("previous pact", pact_version_sha: previous_dev_pact_version_sha)
+              }
+            end
+
+            it "broadcasts the contract_published event" do
+              expect(Service).to receive(:broadcast).with(
+                :contract_published,
+                  {
+                    pact: new_pact,
+                    event_comment: "pact content is the same as previous version with tag dev and no new tags were applied",
+                    event_context: { consumer_version_tags: %w[dev] }
+                  }
+              )
+              subject
+            end
           end
         end
 
         context "when a pact exists with the same params" do
           let(:existing_pact) do
-            double('existing_pact',
+            double("existing_pact",
               id: 4,
               consumer_version_tag_names: %[dev],
-              json_content: { the: "contract" }.to_json
+              json_content: { the: "contract" }.to_json,
+              pact_version_sha: pact_version_sha
             )
           end
+          let(:pact_version_sha) { "1" }
 
           let(:expected_event_context) { { consumer_version_tags: ["dev"] } }
 
@@ -105,18 +147,48 @@ module PactBroker
             subject
           end
 
-          it "triggers webhooks" do
-            expect(webhook_trigger_service).to receive(:trigger_webhooks_for_updated_pact).with(existing_pact, new_pact, expected_event_context, webhook_options)
+          it "broadcasts the contract_published event" do
+            expect(Service).to receive(:broadcast).with(:contract_published, pact: new_pact, event_context: { consumer_version_tags: %w[dev] })
             subject
           end
+
+          context "when the pact_version_sha is different" do
+            let(:pact_version_sha) { "2" }
+
+            it "broadcasts the contract_content_changed event" do
+              expect(Service).to receive(:broadcast).with(
+                :contract_content_changed,
+                  {
+                    pact: new_pact,
+                    event_comment: "pact content modified since previous publication for Foo version 2",
+                    event_context: { consumer_version_tags: %w[dev] }
+                  }
+              )
+              subject
+            end
+          end
+
+          context "when the pact_version_sha is the same" do
+            it "broadcasts the contract_content_unchanged event" do
+              expect(Service).to receive(:broadcast).with(
+                :contract_content_unchanged,
+                  {
+                    pact: new_pact,
+                    event_comment: "pact content was unchanged",
+                    event_context: { consumer_version_tags: %w[dev] }
+                  }
+              )
+              subject
+            end
+          end
         end
       end
 
       describe "find_distinct_pacts_between" do
-        let(:pact_1) { double('pact 1', json_content: 'content 1')}
-        let(:pact_2) { double('pact 2', json_content: 'content 2')}
-        let(:pact_3) { double('pact 3', json_content: 'content 2')}
-        let(:pact_4) { double('pact 4', json_content: 'content 3')}
+        let(:pact_1) { double("pact 1", json_content: "content 1")}
+        let(:pact_2) { double("pact 2", json_content: "content 2")}
+        let(:pact_3) { double("pact 3", json_content: "content 2")}
+        let(:pact_4) { double("pact 4", json_content: "content 3")}
 
         let(:all_pacts) { [pact_4, pact_3, pact_2, pact_1]}
 
@@ -124,7 +196,7 @@ module PactBroker
           allow_any_instance_of(Pacts::Repository).to receive(:find_all_pact_versions_between).and_return(all_pacts)
         end
 
-        subject { Service.find_distinct_pacts_between 'consumer', :and => 'provider' }
+        subject { Service.find_distinct_pacts_between "consumer", :and => "provider" }
 
         it "returns the distinct pacts" do
           expect(subject).to eq [pact_4, pact_2, pact_1]

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

@@ -1,19 +1,19 @@
-require 'pact_broker/pacts/sort_content'
+require "pact_broker/pacts/sort_content"
 
 module PactBroker
   module Pacts
     describe SortContent do
       let(:pact_content_1) do
         {
-          'a' => 1,
-          'interactions' => [{ 'a' => 1, 'b' => 2 }, { 'a' => [2, 1, 3], 'b' => 3 }]
+          "a" => 1,
+          "interactions" => [{ "a" => 1, "b" => 2 }, { "a" => [2, 1, 3], "b" => 3 }]
         }
       end
 
       let(:pact_content_2) do
         {
-          'interactions' => [{ 'b' => 3, 'a' => [2, 1, 3]}, { 'b' => 2, 'a' => 1 }],
-          'a' => 1
+          "interactions" => [{ "b" => 3, "a" => [2, 1, 3]}, { "b" => 2, "a" => 1 }],
+          "a" => 1
         }
       end
 
@@ -29,9 +29,9 @@ module PactBroker
       context "when there is no messages or interactions key" do
         let(:other_content) do
           {
-            'z' => 1,
-            'a' => 1,
-            'b' => 1,
+            "z" => 1,
+            "a" => 1,
+            "b" => 1,
           }
         end
 
@@ -39,6 +39,19 @@ module PactBroker
           expect(SortContent.call(other_content)).to eq other_content
         end
       end
+
+      context "when interactions is a string" do
+        let(:other_content) do
+          {
+            "a" => 1,
+            "interactions" => "interactions"
+          }
+        end
+
+        it "does not blow up" do
+          expect(SortContent.call(other_content)).to eq other_content
+        end
+      end
     end
   end
 end

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

@@ -1,4 +1,4 @@
-require 'pact_broker/pacts/squash_pacts_for_verification'
+require "pact_broker/pacts/squash_pacts_for_verification"
 
 module PactBroker
   module Pacts
@@ -10,7 +10,7 @@ module PactBroker
         let(:pact_version_sha_1) { "1" }
         let(:pact_version_sha_2) { "2" }
         let(:domain_pact_1) do
-          double('pact1',
+          double("pact1",
             pending?: pending_1,
             select_pending_provider_version_tags: pending_provider_version_tags
           )
@@ -22,7 +22,7 @@ module PactBroker
           double("SelectedPact",
             tag_names_of_selectors_for_latest_pacts: %w[dev feat-x],
             pact: domain_pact_1,
-            selectors: double('selectors')
+            selectors: double("selectors")
           )
         end
 

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

@@ -1,6 +1,6 @@
-require 'pact_broker/pacts/verifiable_pact_messages'
-require 'pact_broker/pacts/verifiable_pact'
-require 'pact_broker/pacts/selectors'
+require "pact_broker/pacts/verifiable_pact_messages"
+require "pact_broker/pacts/verifiable_pact"
+require "pact_broker/pacts/selectors"
 
 module PactBroker
   module Pacts
@@ -25,54 +25,67 @@ module PactBroker
             provider_branch: provider_branch
         )
       end
+      let(:consumer_version) { double("version", number: "1234" )}
+      let(:environment) { instance_double("PactBroker::Deployments::Environment", name: "test") }
+      let(:test_environment) { environment }
+      let(:prod_environment) { instance_double("PactBroker::Deployments::Environment", name: "prod") }
 
       subject { VerifiablePactMessages.new(verifiable_pact, pact_version_url) }
 
       describe "#inclusion_reason" do
+        context "when there is one selector" do
+          let(:selectors) { Selectors.create_for_overall_latest.resolve(consumer_version) }
+          its(:inclusion_reason) { is_expected.to include "The pact at http://pact is being verified because the pact content belongs to the consumer version matching the following criterion:" }
+        end
+
+        context "when there is more than one selector" do
+          let(:selectors) { Selectors.create_for_latest_of_each_branch(%w[main feat-x]).resolve(consumer_version) }
+          its(:inclusion_reason) { is_expected.to include "The pact at http://pact is being verified because the pact content belongs to the consumer versions matching the following criteria:" }
+        end
+
+
         context "when there are no head consumer tags" do
-          let(:selectors) { Selectors.create_for_overall_latest }
-          its(:inclusion_reason) { is_expected.to include "The pact at http://pact is being verified because it matches the following configured selection criterion: latest pact between a consumer and Bar" }
+          let(:selectors) { Selectors.create_for_overall_latest.resolve(consumer_version) }
+          its(:inclusion_reason) { is_expected.to include "latest version of a consumer that has a pact with Bar (1234)" }
         end
 
         context "when there is 1 head consumer tags" do
-          let(:selectors) { Selectors.create_for_latest_of_each_tag(%w[dev]) }
-          its(:inclusion_reason) { is_expected.to include "The pact at http://pact is being verified because it matches the following configured selection criterion: latest pact for a consumer version tagged 'dev'" }
+          let(:selectors) { Selectors.create_for_latest_of_each_tag(%w[dev]).resolve(consumer_version) }
+          its(:inclusion_reason) { is_expected.to include "latest version tagged 'dev' (1234)" }
           its(:pact_description) { is_expected.to eq "Pact between Foo and Bar, consumer version 123, latest with tag dev"}
         end
 
         context "when there are branches" do
-          let(:selectors) { Selectors.create_for_latest_of_each_branch(%w[main feat-x]) }
-          its(:inclusion_reason) { is_expected.to include "latest pact for a consumer version from branch 'feat-x', latest pact for a consumer version from branch 'main'" }
+          let(:selectors) { Selectors.create_for_latest_of_each_branch(%w[main feat-x]).resolve(consumer_version) }
+          its(:inclusion_reason) { is_expected.to include "latest version from branch 'feat-x' (1234)" }
+          its(:inclusion_reason) { is_expected.to include "latest version from branch 'main' (1234)" }
           its(:pact_description) { is_expected.to eq "Pact between Foo and Bar, consumer version 123, latest from branch main, latest from branch feat-x"}
         end
 
         context "when there are branches and tags" do
-          let(:selectors) { Selectors.new([Selector.latest_for_branch("main"), Selector.latest_for_tag("prod")]) }
-          its(:inclusion_reason) { is_expected.to include "latest pact for a consumer version from branch 'main', latest pact for a consumer version tagged 'prod'" }
+          let(:selectors) { Selectors.new([Selector.latest_for_branch("main"), Selector.latest_for_tag("prod")]).resolve(consumer_version) }
+          its(:inclusion_reason) { is_expected.to include "latest version from branch 'main' (1234)" }
+          its(:inclusion_reason) { is_expected.to include "latest version tagged 'prod' (1234)" }
         end
 
         context "when there are 2 head consumer tags" do
-          let(:selectors) { Selectors.create_for_latest_of_each_tag(%w[dev prod]) }
-          its(:inclusion_reason) { is_expected.to include "The pact at http://pact is being verified because it matches the following configured selection criteria: latest pact for a consumer version tagged 'dev', latest pact for a consumer version tagged 'prod' (both have the same content)" }
-        end
-
-        context "when there are 3 head consumer tags" do
-          let(:selectors) { Selectors.create_for_latest_of_each_tag(%w[dev prod feat-x]) }
-          its(:inclusion_reason) { is_expected.to include " (all have the same content)" }
+          let(:selectors) { Selectors.create_for_latest_of_each_tag(%w[dev prod]).resolve(consumer_version) }
+          its(:inclusion_reason) { is_expected.to include "latest version tagged 'dev' (1234)" }
+          its(:inclusion_reason) { is_expected.to include "latest version tagged 'prod' (1234)" }
         end
 
         context "when the pact was selected by the fallback tag" do
-          let(:selectors) { Selectors.new(Selector.latest_for_tag_with_fallback("feat-x", "master")) }
-          its(:inclusion_reason) { is_expected.to include "latest pact for a consumer version tagged 'master' (fallback tag used as no pact was found with tag 'feat-x')" }
+          let(:selectors) { Selectors.new(Selector.latest_for_tag_with_fallback("feat-x", "master").resolve_for_fallback(consumer_version)) }
+          its(:inclusion_reason) { is_expected.to include "latest version tagged 'master' (fallback tag used as no pact was found with tag 'feat-x') (1234)" }
         end
 
         context "when the pact was selected by the fallback tag" do
-          let(:selectors) { Selectors.new(Selector.latest_for_branch_with_fallback("feat-x", "master")) }
-          its(:inclusion_reason) { is_expected.to include "latest pact for a consumer version from branch 'master' (fallback branch used as no pact was found from branch 'feat-x')" }
+          let(:selectors) { Selectors.new(Selector.latest_for_branch_with_fallback("feat-x", "master").resolve_for_fallback(consumer_version)) }
+          its(:inclusion_reason) { is_expected.to include "latest version from branch 'master' (fallback branch used as no pact was found from branch 'feat-x') (1234)" }
         end
 
         context "when the pact is a WIP pact for the specified provider tags" do
-          let(:selectors) { Selectors.create_for_latest_of_each_tag(%w[feat-x]) }
+          let(:selectors) { Selectors.create_for_latest_of_each_tag(%w[feat-x]).resolve(consumer_version) }
           let(:wip) { true }
           let(:pending) { true }
           let(:pending_provider_tags) { %w[dev] }
@@ -80,46 +93,97 @@ module PactBroker
           its(:inclusion_reason) { is_expected.to include "The pact at http://pact is being verified because it is a 'work in progress' pact (ie. it is the pact for the latest version of Foo tagged with 'feat-x' and is still in pending state)."}
 
           context "when the pact is a WIP pact for a consumer branch" do
-            let(:selectors) { Selectors.create_for_latest_of_each_branch(%w[feat-x feat-y]) }
+            let(:selectors) { Selectors.create_for_latest_of_each_branch(%w[feat-x feat-y]).resolve(consumer_version) }
 
             its(:inclusion_reason) { is_expected.to include "The pact at http://pact is being verified because it is a 'work in progress' pact (ie. it is the pact for the latest versions of Foo from branches 'feat-x' and 'feat-y' (both have the same content) and is still in pending state)."}
           end
 
           context "when the pact is a WIP pact for a consumer branch and consumer rags" do
-            let(:selectors) { Selectors.create_for_latest_of_each_branch(%w[feat-x feat-y]) + Selectors.create_for_latest_of_each_tag(%w[feat-z feat-w]) }
+            let(:selectors) { Selectors.create_for_latest_of_each_branch(%w[feat-x feat-y]).resolve(consumer_version) + Selectors.create_for_latest_of_each_tag(%w[feat-z feat-w]).resolve(consumer_version) }
 
             its(:inclusion_reason) { is_expected.to include "it is the pact for the latest versions of Foo from branches 'feat-x' and 'feat-y' and tagged with 'feat-z' and 'feat-w' (all have the same content)"}
           end
         end
 
         context "when the pact is one of all versions for a tag" do
-          let(:selectors) { Selectors.create_for_all_of_each_tag(%w[prod]) }
+          let(:selectors) { Selectors.create_for_all_of_each_tag(%w[prod]).resolve(consumer_version) }
 
-          its(:inclusion_reason) { is_expected.to include "The pact at http://pact is being verified because it matches the following configured selection criterion: pacts for all consumer versions tagged 'prod'"}
+          its(:inclusion_reason) { is_expected.to include "all consumer versions tagged 'prod' (1234)"}
         end
 
         context "when the pact is one of all versions for a tag and consumer" do
-          let(:selectors) { Selectors.new(Selector.all_for_tag_and_consumer('prod', 'Foo')) }
+          let(:selectors) { Selectors.new(Selector.all_for_tag_and_consumer("prod", "Foo")).resolve(consumer_version) }
 
-          its(:inclusion_reason) { is_expected.to include "The pact at http://pact is being verified because it matches the following configured selection criterion: pacts for all Foo versions tagged 'prod'"}
+          its(:inclusion_reason) { is_expected.to include "all Foo versions tagged 'prod' (1234)"}
         end
 
         context "when the pact is the latest version for a tag and consumer" do
-          let(:selectors) { Selectors.new(Selector.latest_for_tag_and_consumer('prod', 'Foo')) }
+          let(:selectors) { Selectors.new(Selector.latest_for_tag_and_consumer("prod", "Foo")).resolve(consumer_version) }
 
-          its(:inclusion_reason) { is_expected.to include "The pact at http://pact is being verified because it matches the following configured selection criterion: latest pact for a version of Foo tagged 'prod'"}
+          its(:inclusion_reason) { is_expected.to include "latest version of Foo tagged 'prod' (1234)"}
         end
 
         context "when the pact is the latest version for a branch and consumer" do
-          let(:selectors) { Selectors.new(Selector.latest_for_branch_and_consumer('main', 'Foo')) }
+          let(:selectors) { Selectors.new(Selector.latest_for_branch_and_consumer("main", "Foo")).resolve(consumer_version) }
 
-          its(:inclusion_reason) { is_expected.to include "The pact at http://pact is being verified because it matches the following configured selection criterion: latest pact for a version of Foo from branch 'main'"}
+          its(:inclusion_reason) { is_expected.to include "latest version of Foo from branch 'main' (1234)"}
         end
 
         context "when the pact is the latest version for a consumer" do
-          let(:selectors) { Selectors.new(Selector.latest_for_consumer('Foo')) }
+          let(:selectors) { Selectors.new(Selector.latest_for_consumer("Foo")).resolve(consumer_version) }
+
+          its(:inclusion_reason) { is_expected.to include "latest version of Foo that has a pact with Bar (1234)"}
+        end
+
+        context "when the consumer version is currently deployed to a single environment" do
+          let(:selectors) { Selectors.new(Selector.for_currently_deployed("test")).resolve_for_environment(consumer_version, environment) }
+
+          its(:inclusion_reason) { is_expected.to include "consumer version(s) currently deployed to test (1234)"}
+        end
+
+        context "when the consumer version is released and supported in a single environment" do
+          let(:selectors) { Selectors.new(Selector.for_currently_supported("test")).resolve_for_environment(consumer_version, environment) }
+
+          its(:inclusion_reason) { is_expected.to include "consumer version(s) released and supported in test (1234)"}
+        end
+
+        context "when the consumer version is currently released/deployed in single environment" do
+          let(:selectors) { Selectors.new(Selector.for_environment("test")).resolve_for_environment(consumer_version, environment) }
+
+          its(:inclusion_reason) { is_expected.to include "a consumer version in environment test (1234)"}
+        end
+
+        context "when the verison of a specific consumer is currently released/deployed in single environment" do
+          let(:selectors) { Selectors.new(Selector.for_environment_and_consumer("test", "Foo")).resolve_for_environment(consumer_version, environment) }
+
+          its(:inclusion_reason) { is_expected.to include "Foo version in environment test (1234)"}
+        end
+
+        context "when the consumer version is currently deployed to a multiple environments" do
+          let(:selectors) do
+            Selectors.new(
+              Selector.for_currently_deployed("dev").resolve_for_environment(consumer_version, double("environment", name: "dev")),
+              Selector.for_currently_deployed("test").resolve_for_environment(consumer_version, test_environment),
+              Selector.for_currently_deployed("prod").resolve_for_environment(consumer_version, prod_environment)
+            )
+          end
+
+          its(:inclusion_reason) { is_expected.to include "consumer version(s) currently deployed to dev (1234), prod (1234) and test (1234)"}
+        end
+
+        context "when the currently deployed consumer version is for a consumer" do
+          let(:selectors) do
+            Selectors.new(
+              Selector.for_currently_deployed_and_environment_and_consumer("test", "Foo").resolve_for_environment(consumer_version, test_environment),
+              Selector.for_currently_deployed_and_environment_and_consumer("prod", "Foo").resolve_for_environment(consumer_version, prod_environment),
+              Selector.for_currently_deployed_and_environment_and_consumer("test", "Bar").resolve_for_environment(consumer_version, test_environment),
+              Selector.for_currently_deployed("test").resolve_for_environment(consumer_version, test_environment),
+            )
+          end
 
-          its(:inclusion_reason) { is_expected.to include "The pact at http://pact is being verified because it matches the following configured selection criterion: latest pact between Foo and Bar"}
+          its(:inclusion_reason) { is_expected.to include "version(s) of Foo currently deployed to prod (1234) and test (1234)"}
+          its(:inclusion_reason) { is_expected.to include "version(s) of Bar currently deployed to test (1234)"}
+          its(:inclusion_reason) { is_expected.to include "consumer version(s) currently deployed to test (1234)"}
         end
       end