pact_broker 2.80.0 → 2.81.0

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

@@ -363,29 +363,41 @@ module PactBroker
       end
 
       describe "find_index_items_for_api" do
-        before do
-          td.create_pact_with_hierarchy("Foo", "1", "Bar")
-            .create_consumer_version_tag("feat-x")
-            .create_verification(provider_version: "1", comment: "latest feat-x verif")
-            .create_consumer_version("2")
-            .create_consumer_version_tag("feat-y")
-            .create_pact
-            .create_verification(provider_version: "2", comment: "latest feat-y verif")
-            .create_consumer_version("3")
-            .create_consumer_version_tag("feat-x")
-            .create_consumer_version_tag("feat-y")
-            .create_pact
-            .create_consumer_version("4")
-            .create_pact
-        end
-
         let(:rows) { subject.find_index_items_for_api(consumer_name: td.consumer.name, provider_name: td.provider.name) }
 
         context "when the pact has not yet been verified" do
+          before do
+            td.create_pact_with_hierarchy("Foo", "1", "Bar")
+              .create_consumer_version_tag("feat-x")
+              .create_verification(provider_version: "1", comment: "latest feat-x verif")
+              .create_consumer_version("2")
+              .create_consumer_version_tag("feat-y")
+              .create_pact
+              .create_verification(provider_version: "2", comment: "latest feat-y verif")
+              .create_consumer_version("3")
+              .create_consumer_version_tag("feat-x")
+              .create_consumer_version_tag("feat-y")
+              .create_pact
+              .create_consumer_version("4")
+              .create_pact
+          end
           it "returns the latest verification as nil (unlike the pseudo branch code for the server side rendered UI)" do
             expect(rows.last.provider_version_number).to be nil
           end
         end
+
+        context "when a version is currently deployed" do
+          before do
+            td.create_environment("test")
+              .create_pact_with_hierarchy("Foo", "1", "Bar")
+              .create_deployed_version_for_consumer_version
+              .create_pact_with_hierarchy("Foo", "2", "Bar")
+          end
+
+          it "includes the deployed versions" do
+            expect(rows.size).to eq 2
+          end
+        end
       end
     end
   end

data/spec/lib/pact_broker/integrations/integration_spec.rb

@@ -5,7 +5,9 @@ module PactBroker
     describe Integration do
       describe "relationships" do
         before do
-          td.set_now(DateTime.new(2019, 1, 1))
+          td.set_now(DateTime.new(2018, 1, 7))
+            .create_pact_with_hierarchy("Zoo", "1", "Yab")
+            .set_now(DateTime.new(2019, 1, 1))
             .create_pact_with_hierarchy("Foo", "1", "Bar")
             .set_now(DateTime.new(2019, 1, 2))
             .create_consumer_version("2")
@@ -16,13 +18,20 @@ module PactBroker
             .create_verification(provider_version: "4", number: 2)
         end
 
-        it "has a relationship to the latest pact" do
-          integration = Integration.eager(:latest_pact).all.first
-          expect(integration.latest_pact.consumer_version_number).to eq "2"
+        it "has a relationship to the latest pact (eager)" do
+          integrations = Integration.eager(:latest_pact).order(:consumer_name, :provider_name).all
+          expect(integrations.first.latest_pact.consumer_version_number).to eq "2"
+          expect(integrations.last.latest_pact.consumer_version_number).to eq "1"
+        end
+
+        it "has a relationship to the latest pact (not eager)" do
+          integrations = Integration.order(:consumer_name, :provider_name).all
+          expect(integrations.first.latest_pact.consumer_version_number).to eq "2"
+          expect(integrations.last.latest_pact.consumer_version_number).to eq "1"
         end
 
         it "has a relationship to the latest verification via the latest pact" do
-          integration = Integration.eager(latest_pact: :latest_verification).all.first
+          integration = Integration.eager(latest_pact: :latest_verification).order(:consumer_name, :provider_name).all.first
           expect(integration.latest_pact.latest_verification.provider_version_number).to eq "4"
         end
 
@@ -31,14 +40,16 @@ module PactBroker
         end
 
         it "has a latest verification - this may not be the same as the latest verification for the latest pact" do
-          integration = Integration.eager(:latest_verification).all.first
+          integration = Integration.eager(:latest_verification).order(:consumer_name, :provider_name).all.first
           expect(integration.latest_verification.provider_version_number).to eq "4"
         end
 
         describe "latest_pact_or_verification_publication_date" do
+          let(:first_integration) { Integration.order(:consumer_name, :provider_name).first }
+
           context "when the last publication is a verification" do
             it "returns the verification execution date" do
-              expect(Integration.first.latest_pact_or_verification_publication_date.to_datetime).to eq Integration.first.latest_verification_publication_date.to_datetime
+              expect(first_integration.latest_pact_or_verification_publication_date.to_datetime).to eq first_integration.latest_verification_publication_date.to_datetime
             end
           end
 
@@ -51,7 +62,7 @@ module PactBroker
 
             it "returns the pact publication date" do
               date = td.in_utc { DateTime.new(2019, 1, 5) }
-              expect(Integration.first.latest_pact_or_verification_publication_date.to_datetime).to eq date
+              expect(first_integration.latest_pact_or_verification_publication_date.to_datetime).to eq date
             end
           end
         end
@@ -69,7 +80,7 @@ module PactBroker
         end
 
         it "returns a list of triggered webhooks" do
-          integrations = Integration.eager(:latest_triggered_webhooks).all
+          integrations = Integration.eager(:latest_triggered_webhooks).order(:consumer_name, :provider_name).all
           expect(integrations.first.latest_triggered_webhooks.count).to eq 1
         end
       end
@@ -88,7 +99,7 @@ module PactBroker
         end
 
         it "returns all the webhooks" do
-          integrations = Integration.eager(:webhooks).all
+          integrations = Integration.eager(:webhooks).order(:consumer_name, :provider_name).all
           expect(integrations.first.webhooks.count).to eq 3
         end
       end

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

@@ -6,6 +6,31 @@ module PactBroker
       describe "#metrics" do
         subject { Service.metrics }
 
+        describe "interactions latestCount" do
+          before do
+            td.create_consumer
+              .create_provider
+              .create_consumer_version
+              .create_pact(json_content: { interactions: [1, 2], messages: [1] }.to_json)
+              .create_consumer
+              .create_provider
+              .create_consumer_version
+              .create_pact(json_content: { interactions: [1, 2], messages: [1] }.to_json)
+              .create_consumer
+              .create_provider
+              .create_consumer_version
+              .create_pact(json_content: { foo: "bar" }.to_json)
+          end
+
+          it "includes a count of the number of interactions in the overall latest pacts" do
+            expect(subject[:interactions]).to eq({
+              latestInteractionsCount: 4,
+              latestMessagesCount: 2,
+              latestInteractionsAndMessagesCount: 6
+            })
+          end
+        end
+
         describe "verificationResultsPerPactVersion" do
           before do
             td.create_pact_with_hierarchy

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

@@ -123,7 +123,7 @@ module PactBroker
           end
         end
 
-        context "with both messages and interactions, even though this should never happen" do
+        context "with both messages and interactions (v4)" do
           let(:pact_hash) do
             {
               "ignored" => "foo",

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

@@ -7,7 +7,7 @@ module PactBroker
         let(:selectors) do
           Selectors.new([ResolvedSelector.new({ latest: true, consumer: "consumer", tag: "tag" }, consumer_version)])
         end
-        let(:consumer_version) { double("version", number: "2") }
+        let(:consumer_version) { double("version", number: "2", id: 1) }
         let(:verifiable_pact) { double("PactBroker::Pacts::VerifiablePact", wip: wip, selectors: selectors) }
         let(:wip) { false }
 
@@ -19,7 +19,7 @@ module PactBroker
               {
                 "l" => true,
                 "t" => "tag",
-                "cvn" => "2"
+                "cv" => 1
               }
             ]
           })
@@ -34,38 +34,104 @@ module PactBroker
       end
 
       describe "parse_metadata" do
-        let(:incoming_metadata) do
-          {
-            "cvn" => "2",
-            "cvt" => ["tag"],
-            "w" => true,
-            "s" => [
-              {
-                "l" => true,
-                "t" => "tag",
-                "cvn" => "2"
-              }
-            ]
-          }
-        end
+        context "with a consumer version id" do
+          before do
+            allow(PactBroker::Domain::Version).to receive(:find).with(id: 1).and_return(consumer_version)
+          end
+
+          let(:consumer_version) { double("version", number: "2", id: 1) }
+
+          let(:incoming_metadata) do
+            {
+              "cv" => 1,
+              "cvt" => ["tag"],
+              "w" => true,
+              "s" => [
+                {
+                  "l" => true,
+                  "t" => "tag",
+                  "cv" => 1
+                }
+              ]
+            }
+          end
 
-        let(:parsed_metadata) do
-          {
-            :consumer_version_number => "2",
-            :consumer_version_tags => ["tag"],
-            :wip => true,
-            :consumer_version_selectors => [
+          let(:parsed_metadata) do
+            {
+              :consumer_version_number => "2",
+              :consumer_version_tags => ["tag"],
+              :wip => true,
+              :consumer_version_selectors => [
+                {
+                  :latest => true,
+                  :tag => "tag",
+                  :consumer_version_number => "2"
+                }
+              ]
+            }
+          end
+
+          it "expands the key names" do
+            expect(Metadata.parse_metadata(incoming_metadata)).to eq parsed_metadata
+          end
+
+          context "when the version can't be found" do
+            let(:consumer_version) { nil }
+
+            let(:parsed_metadata) do
               {
-                :latest => true,
-                :tag => "tag",
-                :consumer_version_number => "2"
+                :consumer_version_number => nil,
+                :consumer_version_tags => ["tag"],
+                :wip => true,
+                :consumer_version_selectors => [
+                  {
+                    :latest => true,
+                    :tag => "tag",
+                    :consumer_version_number => nil
+                  }
+                ]
               }
-            ]
-          }
+            end
+
+            it "sets the consumer version number to nil" do
+              expect(Metadata.parse_metadata(incoming_metadata)).to eq parsed_metadata
+            end
+          end
         end
 
-        it "expands the key names" do
-          expect(Metadata.parse_metadata(incoming_metadata)).to eq parsed_metadata
+        context "with a consumer version number (support the old format for previously created URLs)" do
+          let(:incoming_metadata) do
+            {
+              "cvn" => "2",
+              "cvt" => ["tag"],
+              "w" => true,
+              "s" => [
+                {
+                  "l" => true,
+                  "t" => "tag"
+                }
+              ]
+            }
+          end
+
+          let(:parsed_metadata) do
+            {
+              :consumer_version_number => "2",
+              :consumer_version_tags => ["tag"],
+              :wip => true,
+              :consumer_version_selectors => [
+                {
+                  :latest => true,
+                  :tag => "tag"
+                }
+              ]
+            }
+          end
+
+          it "expands the key names" do
+            expect(Metadata.parse_metadata(incoming_metadata)).to eq parsed_metadata
+          end
+
         end
       end
     end

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

@@ -7,6 +7,45 @@ module PactBroker
 
         subject { PactPublication.for_provider_and_consumer_version_selector(provider, consumer_version_selector).all }
 
+        context "for main branch" do
+          let(:consumer_version_selector) { Selector.for_main_branch }
+          let(:provider) { td.find_pacticipant("Bar") }
+
+          before do
+            td.create_provider("Bar")
+              .create_consumer("Foo", main_branch: "main")
+              .create_consumer_version("1", branch: "main")
+              .create_pact
+              .create_consumer_version("2", branch: "main")
+              .create_pact
+              .create_consumer_version("3", branch: "not-main")
+              .create_pact
+              .create_consumer("Bob", main_branch: "develop")
+              .create_consumer_version("3", branch: "develop")
+              .create_pact
+              .create_consumer_version("5", branch: "develop")
+              .create_pact
+              .create_consumer_version("6", branch: "not-develop")
+              .create_pact
+              .create_provider("NotBar")
+              .create_pact
+              .create_consumer("Waffle")
+              .create_consumer_version("7")
+              .create_pact
+          end
+
+          it "returns the latest pact for the main branch of every consumer" do
+            expect(subject.size).to eq 2
+            expect(subject.sort_by(&:id).first.consumer.name).to eq "Foo"
+            expect(subject.sort_by(&:id).first.consumer_version.branch).to eq "main"
+            expect(subject.sort_by(&:id).first.consumer_version.number).to eq "2"
+
+            expect(subject.sort_by(&:id).last.consumer.name).to eq "Bob"
+            expect(subject.sort_by(&:id).last.consumer_version.branch).to eq "develop"
+            expect(subject.sort_by(&:id).last.consumer_version.number).to eq "5"
+          end
+        end
+
         context "for environment" do
           before do
             td.create_environment("test")

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

@@ -6,8 +6,7 @@ module PactBroker
 
       describe "pacticipant names" do
         subject(:pact_version) do
-          TestDataBuilder.new
-            .create_consumer("consumer")
+          td.create_consumer("consumer")
             .create_provider("provider")
             .create_consumer_version("1.0.1")
             .create_pact
@@ -18,12 +17,50 @@ module PactBroker
         its(:provider_name) { is_expected.to eq("provider") }
       end
 
-      describe "#latest_pact_publication" do
+      describe "consumer_versions" do
+        subject(:pact_version) do
+          td.create_consumer("consumer")
+            .create_provider("provider")
+            .create_consumer_version("1")
+            .create_pact
+            .create_consumer_version("2")
+            .republish_same_pact
+            .create_consumer_version("3")
+            .create_pact
+
+          PactVersion.order(:id).first
+        end
+
+        it "returns the consuemr versions" do
+          expect(subject.consumer_versions.collect(&:number).sort).to eq ["1", "2"]
+        end
+      end
+
+      describe "latest_consumer_version" do
+        before do
+          td.create_consumer("consumer")
+            .create_provider("provider")
+            .create_consumer_version("1")
+            .create_pact
+            .create_consumer_version("2")
+            .republish_same_pact
+            .create_consumer_version("3")
+            .create_pact
+            .create_consumer_version("4")
+            .republish_same_pact
+        end
 
+        it "does not work eager loading because the Version needs a latest_by_pact_version method, but we don't need it for now", skip: true do
+          pact_versions = PactVersion.eager(:latest_consumer_version).order(:id).all
+          expect(pact_versions.first.latest_consumer_version.number).to eq 2
+          expect(pact_versions.last.latest_consumer_version.number).to eq 4
+        end
+      end
+
+      describe "#latest_pact_publication" do
         context "when the latest pact publication is not an overwritten one" do
           before do
-            TestDataBuilder.new
-              .create_provider("Bar")
+            td.create_provider("Bar")
               .create_consumer("Foo")
               .create_consumer_version("1.2.100")
               .create_pact
@@ -48,7 +85,6 @@ module PactBroker
         end
 
         context "when the only pact publication with the given sha is an overwritten one" do
-          let(:td) { TestDataBuilder.new }
           let!(:first_version) do
             td.create_provider("Bar")
               .create_consumer("Foo")
@@ -64,6 +100,7 @@ module PactBroker
             pact_version = PactBroker::Pacts::PactVersion.find(sha: first_version.pact_version_sha)
             latest_pact_publication = pact_version.latest_pact_publication
             expect(latest_pact_publication.revision_number).to eq 1
+            expect(latest_pact_publication.id).to eq PactBroker::Pacts::PactPublication.order(:id).first.id
           end
         end
       end
@@ -96,16 +133,35 @@ module PactBroker
       describe "#latest_verification" do
         before do
           td.create_pact_with_hierarchy
+            .create_verification(provider_version: "4", number: 1)
+            .create_verification(provider_version: "5", number: 2)
+            .create_verification(provider_version: "6", number: 3)
+            .create_pact_with_hierarchy
             .create_verification
-            .create_verification(number: 2)
-            .create_verification(number: 3)
+            .create_verification(provider_version: "1", number: 2)
+            .create_verification(provider_version: "2", number: 3)
         end
-        let(:pact_version) { PactVersion.last }
 
-        subject { pact_version.latest_verification }
+        describe "lazy loading" do
+          let(:pact_version) { PactVersion.last }
+
+          subject { pact_version.latest_verification }
 
-        it "returns the latest verification by execution date" do
-          expect(subject.number).to eq 3
+          it "returns the latest verification by verification id" do
+            expect(subject.number).to eq 3
+          end
+        end
+
+        describe "eager loading" do
+          let(:first_pact_latest_verification) { PactVersion.eager(:latest_verification).order(:id).all.first.associations[:latest_verification] }
+          let(:last_pact_latest_verification) { PactVersion.eager(:latest_verification).order(:id).all.last.associations[:latest_verification] }
+
+          it "returns the latest verification by verification id" do
+            expect(first_pact_latest_verification.number).to eq 3
+            expect(first_pact_latest_verification.provider_version_number).to eq "6"
+            expect(last_pact_latest_verification.number).to eq 3
+            expect(last_pact_latest_verification.provider_version_number).to eq "2"
+          end
         end
       end