pact_broker 2.77.0 → 2.80.0

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

@@ -1,4 +1,4 @@
-require 'pact_broker/pacts/pact_version'
+require "pact_broker/pacts/pact_version"
 
 module PactBroker
   module Pacts
@@ -112,7 +112,7 @@ module PactBroker
       describe "select_provider_tags_with_successful_verifications" do
         before do
           td.create_pact_with_hierarchy("Foo", "1", "Bar")
-            .create_verification(provider_version: "20", tag_names: ['dev'], success: true)
+            .create_verification(provider_version: "20", tag_names: ["dev"], success: true)
             .create_verification(provider_version: "21", number: 2)
         end
 
@@ -135,7 +135,7 @@ module PactBroker
 
         context "when the pact version has been verified unsuccessfully by all of the specified tags" do
           before do
-            td.create_verification(provider_version: "30", number: 10, tag_names: ['feat-bar'], success: false)
+            td.create_verification(provider_version: "30", number: 10, tag_names: ["feat-bar"], success: false)
           end
 
           let(:tags) { %w[feat-bar] }
@@ -144,6 +144,50 @@ module PactBroker
         end
       end
 
+      describe "select_provider_tags_with_successful_verifications_from_another_branch_from_before_this_branch_created" do
+        let(:pact_version) { PactVersion.last }
+
+        subject { pact_version.select_provider_tags_with_successful_verifications_from_another_branch_from_before_this_branch_created(tags) }
+
+        context "when the provider version tag specified does not exist yet but there are previous successful verifications from another branch" do
+          before do
+            td.create_pact_with_hierarchy("Foo", "1", "Bar")
+              .create_verification(provider_version: "20", tag_names: ["dev"], success: true)
+              .create_verification(provider_version: "21", number: 2)
+          end
+
+          let(:tags) { %w[feat-new-branch] }
+
+          it { is_expected.to eq ["feat-new-branch"] }
+        end
+
+        context "when there is a successful verification from before the first provider version with the specified tag was created" do
+          before do
+            td.create_pact_with_hierarchy("Foo", "1", "Bar")
+              .create_verification(provider_version: "20", tag_names: ["dev"], success: true)
+              .add_day
+              .create_verification(provider_version: "21", tag_names: ["feat-new-branch"], number: 2, success: false)
+          end
+
+          let(:tags) { %w[feat-new-branch] }
+
+          it { is_expected.to eq ["feat-new-branch"] }
+        end
+
+        context "when there is a successful verification from after the first provider version with the specified tag was created" do
+          before do
+            td.create_pact_with_hierarchy("Foo", "1", "Bar")
+              .create_verification(provider_version: "21", tag_names: ["feat-new-branch"], number: 2, success: false)
+              .add_day
+              .create_verification(provider_version: "20", tag_names: ["dev"], success: true)
+          end
+
+          let(:tags) { %w[feat-new-branch] }
+
+          it { is_expected.to eq [] }
+        end
+      end
+
       describe "#verified_successfully_by_any_provider_version?" do
 
         let(:pact_version) { PactVersion.last }

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

@@ -0,0 +1,124 @@
+require "pact_broker/pacts/repository"
+
+module PactBroker
+  module Pacts
+    describe Repository do
+      describe "#find_for_verification" do
+        def find_by_consumer_version_number(consumer_version_number)
+          subject.find{ |pact| pact.consumer_version_number == consumer_version_number }
+        end
+
+        def find_by_consumer_name_and_consumer_version_number(consumer_name, consumer_version_number)
+          subject.find{ |pact| pact.consumer_name == consumer_name && pact.consumer_version_number == consumer_version_number }
+        end
+
+        subject { Repository.new.find_for_verification("Bar", consumer_version_selectors) }
+
+        context "when currently_deployed is true" do
+          before do
+            td.create_environment("test")
+              .create_pact_with_hierarchy("Foo", "1", "Bar")
+              .create_deployed_version_for_consumer_version(currently_deployed: false)
+              .create_pact_with_hierarchy("Foo", "2", "Bar")
+              .create_deployed_version_for_consumer_version(currently_deployed: true, target: "1")
+              .create_pact_with_hierarchy("Waffle", "3", "Bar")
+              .create_pact_with_hierarchy("Waffle", "4", "Bar")
+              .create_deployed_version_for_consumer_version(currently_deployed: true, target: "2")
+          end
+
+          let(:consumer_version_selectors) do
+            PactBroker::Pacts::Selectors.new(
+              PactBroker::Pacts::Selector.for_currently_deployed
+            )
+          end
+
+          it "returns the pacts for the currently deployed versions" do
+            expect(subject.size).to eq 2
+            expect(subject.first.selectors).to eq [PactBroker::Pacts::Selector.for_currently_deployed.resolve_for_environment(td.find_version("Foo", "2"), td.find_environment("test"), "1")]
+            expect(subject.last.selectors).to eq [PactBroker::Pacts::Selector.for_currently_deployed.resolve_for_environment(td.find_version("Waffle", "4"), td.find_environment("test"), "2")]
+          end
+        end
+
+        context "when currently_deployed is true and an environment is specified" do
+          before do
+            td.create_environment("test")
+              .create_pact_with_hierarchy("Foo", "1", "Bar")
+              .create_deployed_version_for_consumer_version(currently_deployed: false)
+              .create_pact_with_hierarchy("Foo", "2", "Bar")
+              .create_deployed_version_for_consumer_version(currently_deployed: true)
+              .create_pact_with_hierarchy("Waffle", "3", "Bar")
+              .create_pact_with_hierarchy("Waffle", "4", "Bar")
+              .create_deployed_version_for_consumer_version(currently_deployed: true)
+              .create_environment("prod")
+              .create_pact_with_hierarchy("Foo", "5", "Bar")
+              .comment("not included, wrong environment")
+              .create_deployed_version_for_consumer_version(currently_deployed: true)
+          end
+
+          let(:consumer_version_selectors) do
+            PactBroker::Pacts::Selectors.new(
+              PactBroker::Pacts::Selector.for_currently_deployed("test")
+            )
+          end
+
+          it "returns the pacts for the currently deployed versions" do
+            expect(subject.size).to eq 2
+            expect(subject.first.selectors).to eq [PactBroker::Pacts::Selector.for_currently_deployed("test").resolve_for_environment(td.find_version("Foo", "2"), td.find_environment("test"))]
+            expect(subject.last.selectors).to eq [PactBroker::Pacts::Selector.for_currently_deployed("test").resolve_for_environment(td.find_version("Waffle", "4"), td.find_environment("test"))]
+          end
+        end
+
+        context "when currently_deployed is true and an environment is and consumer specified" do
+          before do
+            td.create_environment("test")
+              .create_pact_with_hierarchy("Foo", "1", "Bar")
+              .create_deployed_version_for_consumer_version(currently_deployed: false)
+              .create_pact_with_hierarchy("Foo", "2", "Bar")
+              .create_deployed_version_for_consumer_version(currently_deployed: true)
+              .create_pact_with_hierarchy("Waffle", "3", "Bar")
+              .create_pact_with_hierarchy("Waffle", "4", "Bar")
+              .create_deployed_version_for_consumer_version(currently_deployed: true)
+              .create_environment("prod")
+              .create_pact_with_hierarchy("Foo", "5", "Bar")
+              .comment("not included, wrong environment")
+              .create_deployed_version_for_consumer_version(currently_deployed: true)
+          end
+
+          let(:consumer_version_selectors) do
+            PactBroker::Pacts::Selectors.new(
+              PactBroker::Pacts::Selector.for_currently_deployed_and_environment_and_consumer("test", "Foo")
+            )
+          end
+
+          it "returns the pacts for the currently deployed versions" do
+            expect(subject.size).to eq 1
+            expect(subject.first.selectors.first).to eq consumer_version_selectors.first.resolve_for_environment(td.find_version("Foo", "2"), td.find_environment("test"))
+          end
+        end
+
+        context "when the same version is deployed to multiple environments" do
+          before do
+            td.create_environment("test")
+              .create_environment("prod")
+              .create_pact_with_hierarchy("Foo", "1", "Bar")
+              .create_deployed_version_for_consumer_version(environment_name: "test")
+              .create_deployed_version_for_consumer_version(environment_name: "prod")
+          end
+
+          let(:consumer_version_selectors) do
+            PactBroker::Pacts::Selectors.new(
+              PactBroker::Pacts::Selector.for_currently_deployed
+            )
+          end
+
+          it "returns one pact_publication with multiple selectors" do
+            expect(subject.size).to eq 1
+            expect(subject.first.selectors.size).to eq 2
+            expect(subject.first.selectors.first.environment.name).to eq "test"
+            expect(subject.first.selectors.last.environment.name).to eq "prod"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,159 @@
+require "pact_broker/pacts/repository"
+
+module PactBroker
+  module Pacts
+    describe Repository do
+      describe "#find_for_verification" do
+        def find_by_consumer_version_number(consumer_version_number)
+          subject.find{ |pact| pact.consumer_version_number == consumer_version_number }
+        end
+
+        def find_by_consumer_name_and_consumer_version_number(consumer_name, consumer_version_number)
+          subject.find{ |pact| pact.consumer_name == consumer_name && pact.consumer_version_number == consumer_version_number }
+        end
+
+        subject { Repository.new.find_for_verification("Bar", consumer_version_selectors) }
+
+        context "when currently_supported is true" do
+          before do
+            td.create_environment("test")
+              .create_pact_with_hierarchy("Foo", "1", "Bar")
+              .create_released_version_for_consumer_version(currently_supported: false)
+              .create_pact_with_hierarchy("Foo", "2", "Bar")
+              .create_released_version_for_consumer_version(currently_supported: true)
+              .create_pact_with_hierarchy("Waffle", "3", "Bar")
+              .create_pact_with_hierarchy("Waffle", "4", "Bar")
+              .create_released_version_for_consumer_version(currently_supported: true)
+          end
+
+          let(:consumer_version_selectors) do
+            PactBroker::Pacts::Selectors.new(
+              PactBroker::Pacts::Selector.for_currently_supported
+            )
+          end
+
+          it "returns the pacts for the currently supported versions" do
+            expect(subject.size).to eq 2
+            expect(subject.first.selectors).to eq [
+              PactBroker::Pacts::Selector
+                .for_currently_supported
+                .resolve_for_environment(
+                  td.find_version("Foo", "2"),
+                  td.find_environment("test")
+                )
+            ]
+            expect(subject.last.selectors).to eq [
+              PactBroker::Pacts::Selector
+                .for_currently_supported
+                .resolve_for_environment(
+                  td.find_version("Waffle", "4"),
+                  td.find_environment("test")
+                )
+            ]
+          end
+        end
+
+        context "when currently_supported is true and an environment is specified" do
+          before do
+            td.create_environment("test")
+              .create_pact_with_hierarchy("Foo", "1", "Bar")
+              .create_released_version_for_consumer_version(currently_supported: false)
+              .create_pact_with_hierarchy("Foo", "2", "Bar")
+              .create_released_version_for_consumer_version(currently_supported: true)
+              .create_pact_with_hierarchy("Waffle", "3", "Bar")
+              .create_pact_with_hierarchy("Waffle", "4", "Bar")
+              .create_released_version_for_consumer_version(currently_supported: true)
+              .create_environment("prod")
+              .create_pact_with_hierarchy("Foo", "5", "Bar")
+              .comment("not included, wrong environment")
+              .create_released_version_for_consumer_version(currently_supported: true)
+          end
+
+          let(:consumer_version_selectors) do
+            PactBroker::Pacts::Selectors.new(
+              PactBroker::Pacts::Selector.for_currently_supported("test")
+            )
+          end
+
+          it "returns the pacts for the currently supported versions" do
+            expect(subject.size).to eq 2
+            expect(subject.first.selectors).to eq [
+              PactBroker::Pacts::Selector
+                .for_currently_supported("test")
+                .resolve_for_environment(
+                  td.find_version("Foo", "2"),
+                  td.find_environment("test")
+                )
+            ]
+            expect(subject.last.selectors).to eq [
+              PactBroker::Pacts::Selector
+                .for_currently_supported("test")
+                .resolve_for_environment(
+                  td.find_version("Waffle", "4"),
+                  td.find_environment("test")
+                )
+            ]
+          end
+        end
+
+        context "when currently_supported is true and an environment is and consumer specified" do
+          before do
+            td.create_environment("test")
+              .create_pact_with_hierarchy("Foo", "1", "Bar")
+              .create_released_version_for_consumer_version(currently_supported: false)
+              .create_pact_with_hierarchy("Foo", "2", "Bar")
+              .create_released_version_for_consumer_version(currently_supported: true)
+              .create_pact_with_hierarchy("Waffle", "3", "Bar")
+              .create_pact_with_hierarchy("Waffle", "4", "Bar")
+              .create_released_version_for_consumer_version(currently_supported: true)
+              .create_environment("prod")
+              .create_pact_with_hierarchy("Foo", "5", "Bar")
+              .comment("not included, wrong environment")
+              .create_released_version_for_consumer_version(currently_supported: true)
+          end
+
+          let(:consumer_version_selectors) do
+            PactBroker::Pacts::Selectors.new(
+              PactBroker::Pacts::Selector.for_currently_supported_and_environment_and_consumer("test", "Foo")
+            )
+          end
+
+          it "returns the pacts for the currently supported versions" do
+            expect(subject.size).to eq 1
+            expect(subject.first.selectors).to eq [
+              PactBroker::Pacts::Selector
+                .for_currently_supported_and_environment_and_consumer("test", "Foo")
+                .resolve_for_environment(
+                  td.find_version("Foo", "2"),
+                  td.find_environment("test")
+                )
+            ]
+          end
+        end
+
+        context "when the same version is supported in multiple environments" do
+          before do
+            td.create_environment("test")
+              .create_environment("prod")
+              .create_pact_with_hierarchy("Foo", "1", "Bar")
+              .create_released_version_for_consumer_version(environment_name: "test")
+              .create_released_version_for_consumer_version(environment_name: "prod")
+          end
+
+          let(:consumer_version_selectors) do
+            PactBroker::Pacts::Selectors.new(
+              PactBroker::Pacts::Selector.for_currently_supported
+            )
+          end
+
+          it "returns one pact_publication with multiple selectors" do
+            expect(subject.size).to eq 1
+            expect(subject.first.selectors.size).to eq 2
+            expect(subject.first.selectors.first.environment.name).to eq "test"
+            expect(subject.first.selectors.last.environment.name).to eq "prod"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,4 @@
-require 'pact_broker/pacts/repository'
+require "pact_broker/pacts/repository"
 
 module PactBroker
   module Pacts

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

@@ -1,4 +1,4 @@
-require 'pact_broker/pacts/repository'
+require "pact_broker/pacts/repository"
 
 module PactBroker
   module Pacts
@@ -116,27 +116,27 @@ module PactBroker
               .create_pact
           end
 
-          let(:pact_selector_1) { Selector.latest_for_tag('dev') }
-          let(:pact_selector_2) { Selector.latest_for_tag('prod') }
+          let(:pact_selector_1) { Selector.latest_for_tag("dev") }
+          let(:pact_selector_2) { Selector.latest_for_tag("prod") }
           let(:consumer_version_selectors) do
             Selectors.new(pact_selector_1, pact_selector_2)
           end
           let(:expected_sorted_selectors) do
             [
-              ResolvedSelector.new({ tag: 'dev', latest: true }, PactBroker::Domain::Version.for("Baz", "baz-latest-dev-version")),
-              ResolvedSelector.new({ tag: 'prod', latest: true }, PactBroker::Domain::Version.for("Baz", "baz-latest-dev-version"))
+              ResolvedSelector.new({ tag: "dev", latest: true }, PactBroker::Domain::Version.for("Baz", "baz-latest-dev-version")),
+              ResolvedSelector.new({ tag: "prod", latest: true }, PactBroker::Domain::Version.for("Baz", "baz-latest-dev-version"))
             ]
           end
 
           it "returns the latest pact with the specified tags for each consumer" do
-            expect(find_by_consumer_version_number("foo-latest-prod-version").selectors).to eq [Selector.latest_for_tag('prod').resolve(PactBroker::Domain::Version.for("Foo", "foo-latest-prod-version"))]
-            expect(find_by_consumer_version_number("foo-latest-dev-version").selectors).to eq [Selector.latest_for_tag('dev').resolve(PactBroker::Domain::Version.for("Foo", "foo-latest-dev-version"))]
+            expect(find_by_consumer_version_number("foo-latest-prod-version").selectors).to eq [Selector.latest_for_tag("prod").resolve(PactBroker::Domain::Version.for("Foo", "foo-latest-prod-version"))]
+            expect(find_by_consumer_version_number("foo-latest-dev-version").selectors).to eq [Selector.latest_for_tag("dev").resolve(PactBroker::Domain::Version.for("Foo", "foo-latest-dev-version"))]
             expect(find_by_consumer_version_number("baz-latest-dev-version").selectors.sort_by{ |s| s[:tag] }).to eq expected_sorted_selectors
             expect(subject.size).to eq 3
           end
 
           it "sets the latest_consumer_version_tag_names" do
-            expect(find_by_consumer_version_number("foo-latest-prod-version").selectors.collect(&:tag)).to eq ['prod']
+            expect(find_by_consumer_version_number("foo-latest-prod-version").selectors.collect(&:tag)).to eq ["prod"]
           end
 
           context "when a consumer name is specified" do
@@ -151,17 +151,17 @@ module PactBroker
             end
 
             let(:consumer_version_selectors) do
-              Selectors.new(Selector.all_for_tag_and_consumer('prod', 'Foo'))
+              Selectors.new(Selector.all_for_tag_and_consumer("prod", "Foo"))
             end
 
             it "returns all the pacts with that tag for that consumer" do
               expect(subject.size).to eq 3
-              expect(find_by_consumer_version_number("foo-latest-prod-version").selectors).to eq [Selector.all_for_tag_and_consumer('prod', 'Foo').resolve(PactBroker::Domain::Version.for("Foo", "foo-latest-prod-version"))]
+              expect(find_by_consumer_version_number("foo-latest-prod-version").selectors).to eq [Selector.all_for_tag_and_consumer("prod", "Foo").resolve(PactBroker::Domain::Version.for("Foo", "foo-latest-prod-version"))]
             end
 
             it "uses the latest consumer verison number as the resolved version when the same pact content is selected multiple times" do
               expect(find_by_consumer_version_number("3")).to be nil
-              expect(find_by_consumer_version_number("4").selectors).to eq [Selector.all_for_tag_and_consumer('prod', 'Foo').resolve(PactBroker::Domain::Version.for("Foo", "4"))]
+              expect(find_by_consumer_version_number("4").selectors).to eq [Selector.all_for_tag_and_consumer("prod", "Foo").resolve(PactBroker::Domain::Version.for("Foo", "4"))]
             end
           end
         end
@@ -177,7 +177,7 @@ module PactBroker
           end
 
           let(:consumer_version_selectors) { Selectors.new(pact_selector_1) }
-          let(:pact_selector_1) { Selector.all_for_tag('prod') }
+          let(:pact_selector_1) { Selector.all_for_tag("prod") }
 
           subject { Repository.new.find_for_verification("Bar2", consumer_version_selectors) }
 
@@ -209,7 +209,7 @@ module PactBroker
           end
 
           let(:consumer_version_selectors) { Selectors.new(pact_selector_1) }
-          let(:pact_selector_1) { Selector.all_for_tag_and_consumer('prod', "Foo2") }
+          let(:pact_selector_1) { Selector.all_for_tag_and_consumer("prod", "Foo2") }
 
           subject { Repository.new.find_for_verification("Bar2", consumer_version_selectors) }
 
@@ -221,8 +221,8 @@ module PactBroker
           end
 
           it "sets the selectors" do
-            expect(find_by_consumer_version_number("prod-version-1").selectors.first.tag).to eq 'prod'
-            expect(find_by_consumer_version_number("prod-version-1").selectors.first.consumer).to eq 'Foo2'
+            expect(find_by_consumer_version_number("prod-version-1").selectors.first.tag).to eq "prod"
+            expect(find_by_consumer_version_number("prod-version-1").selectors.first.consumer).to eq "Foo2"
           end
         end
 
@@ -233,8 +233,8 @@ module PactBroker
               .create_consumer_version_tag("prod")
           end
 
-          let(:pact_selector_1) { Selector.all_for_tag('prod') }
-          let(:pact_selector_2) { Selector.latest_for_tag('dev') }
+          let(:pact_selector_1) { Selector.all_for_tag("prod") }
+          let(:pact_selector_2) { Selector.latest_for_tag("dev") }
           let(:consumer_version_selectors) { Selectors.new(pact_selector_1, pact_selector_2) }
 
           it "returns a single selected pact with multiple selectors" do
@@ -276,10 +276,10 @@ module PactBroker
             td.create_consumer
               .create_provider("Bar")
               .create_consumer_version
-              .create_pact(json_content: { interactions: ['foo'] }.to_json )
+              .create_pact(json_content: { interactions: ["foo"] }.to_json )
               .create_consumer
               .create_consumer_version
-              .create_pact(json_content: { interactions: ['foo'] }.to_json )
+              .create_pact(json_content: { interactions: ["foo"] }.to_json )
           end
 
           let(:consumer_version_selectors) { Selectors.new }