pact_broker 2.15.0 → 2.16.0

data/spec/lib/pact_broker/api/resources/group_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require 'pact_broker/api/resources/group'
+require 'pact_broker/groups/service'
 require 'rack/test'
 
 module PactBroker::Api

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

@@ -10,41 +10,10 @@ module PactBroker
       let(:td) { TestDataBuilder.new }
       let(:tags) { ['prod', 'production'] }
       let(:options) { { tags: tags } }
+      let(:rows) { subject.find_index_items(options) }
 
       subject{ Service }
 
-      describe ".find_index_items" do
-        let(:consumer) { instance_double("PactBroker::Domain::Pacticipant")}
-        let(:provider) { instance_double("PactBroker::Domain::Pacticipant")}
-        let(:pact) { instance_double("PactBroker::Domain::Pact", id: 1, consumer: consumer, provider: provider, consumer_name: 'foo', provider_name: 'bar', consumer_version_tag_names: [])}
-        let(:verification) { instance_double("PactBroker::Domain::Verification")}
-        let(:pacts) { [pact]}
-        let(:webhooks) { [instance_double("PactBroker::Domain::Webhook")]}
-        let(:triggered_webhooks) { [instance_double("PactBroker::Webhooks::TriggeredWebhook")] }
-
-        before do
-          allow_any_instance_of(PactBroker::Pacts::Repository).to receive(:find_latest_pacts).and_return(pacts)
-          allow_any_instance_of(PactBroker::Pacts::Repository).to receive(:find_latest_pact).and_return(pact)
-          allow(PactBroker::Verifications::Service).to receive(:find_latest_verification_for).and_return(verification)
-          allow(PactBroker::Webhooks::Service).to receive(:find_by_consumer_and_provider).and_return(webhooks)
-          allow(PactBroker::Webhooks::Service).to receive(:find_latest_triggered_webhooks).and_return(triggered_webhooks)
-        end
-
-        it "retrieves the webhooks for the pact" do
-          expect(PactBroker::Webhooks::Service).to receive(:find_by_consumer_and_provider).with(consumer, provider)
-          subject.find_index_items(options)
-        end
-
-        it "retrieves the latest verification for the pact" do
-          expect(PactBroker::Verifications::Service).to receive(:find_latest_verification_for).with(consumer, provider)
-          subject.find_index_items(options)
-        end
-
-        it "returns a list of relationships" do
-          expect(subject.find_index_items(options)).to eq([PactBroker::Domain::IndexItem.create(consumer, provider, pact, true, verification, webhooks)])
-        end
-      end
-
       describe "find_relationships integration test" do
         context "when a prod pact exists and is not the latest version" do
           before do
@@ -56,6 +25,7 @@ module PactBroker
               .create_consumer_version_tag("also-ignored")
               .create_pact
               .create_verification(provider_version: "2.1.0")
+              .use_provider_version("2.1.0")
           end
 
           let(:rows) { subject.find_index_items(options) }
@@ -125,6 +95,150 @@ module PactBroker
             expect(rows.first.latest_verification.provider_version_number).to eq '2.0.0'
           end
         end
+
+        context "when the verification is the latest for a given tag" do
+          before do
+            td.create_pact_with_hierarchy("Foo", "1", "Bar")
+              .create_verification(provider_version: "1.0.0", tag_names: ['dev', 'prod'])
+              .create_verification(provider_version: "2.0.0", number: 2, tag_names: ['dev'])
+          end
+
+          let(:rows) { subject.find_index_items(options) }
+          let(:options) { { tags: true } }
+
+          it "includes the names of the tags for which the verification is the latest of that tag" do
+            expect(rows.first.provider_version_number).to eq "2.0.0"
+            expect(rows.first.latest_verification_latest_tags.collect(&:name)).to eq ['dev']
+          end
+        end
+
+        context "when there are multiple verifications for the latest consumer version" do
+
+          context "with no tags" do
+            before do
+              td.create_pact_with_hierarchy("Foo", "1", "Bar")
+                .create_verification(provider_version: "1.0.0")
+                .create_verification(provider_version: "2.0.0", number: 2)
+            end
+
+            let(:options) { {} }
+
+            it "only returns the row for the latest provider version" do
+              expect(rows.count).to eq 1
+            end
+          end
+
+          context "with tags=true" do
+            before do
+              td.create_pact_with_hierarchy("Foo", "1", "Bar")
+                .create_consumer_version("2")
+                .create_consumer_version_tag("prod")
+                .create_consumer_version_tag("master")
+                .create_pact
+                .revise_pact
+                .create_verification(provider_version: "1.0.0")
+                .create_verification(provider_version: "2.0.0", number: 2)
+            end
+
+            let(:options) { {tags: true} }
+
+            it "only returns the row for the latest provider version" do
+              expect(rows.size).to eq 1
+              expect(rows.first.tag_names.sort).to eq ["master","prod"]
+              expect(rows.first.provider_version_number).to eq "2.0.0"
+            end
+          end
+
+          context "with tags=true" do
+            before do
+              td.create_pact_with_hierarchy("Foo", "1.0.0", "Bar")
+                .create_verification(provider_version: "4.5.6")
+                .create_consumer_version("2.0.0")
+                .create_consumer_version_tag("dev")
+                .create_pact
+                .revise_pact
+                .create_consumer_version("2.1.0")
+                .create_consumer_version_tag("prod")
+                .create_pact
+                .revise_pact
+                .create_verification(provider_version: "4.5.6", number: 1)
+                .create_verification(provider_version: "4.5.7", number: 2)
+                .create_verification(provider_version: "4.5.8", number: 3)
+                .create_verification(provider_version: "4.5.9", number: 4)
+                .create_provider("Wiffle")
+                .create_pact
+            end
+
+            let(:options) { {tags: true} }
+
+            it "returns a row for each of the head pacts" do
+              expect(rows.size).to eq 3
+
+              expect(rows[0].latest?).to be true
+              expect(rows[0].provider_name).to eq "Bar"
+              expect(rows[0].tag_names).to eq ["prod"]
+              expect(rows[0].provider_version_number).to eq "4.5.9"
+
+              expect(rows[2].latest?).to be false
+              expect(rows[2].provider_name).to eq "Bar"
+              expect(rows[2].tag_names).to eq ["dev"]
+
+              expect(rows[1].latest?).to be true
+              expect(rows[1].provider_name).to eq "Wiffle"
+            end
+          end
+        end
+
+        context "when a pact with a tag has been verified, and then a new changed version has been published with the same tag" do
+          before do
+            td.create_pact_with_hierarchy("Foo", "1", "Bar")
+              .create_consumer_version_tag("feat-x")
+              .comment("latest verification for feat-x tag")
+              .create_verification(provider_version: "1")
+              .comment("latest feat-x version")
+              .create_consumer_version("2")
+              .create_consumer_version_tag("feat-x")
+              .comment("latest overall version")
+              .create_consumer_version("3")
+              .create_pact
+              .comment("latest overall verification")
+              .create_verification(provider_version: "2")
+
+          end
+
+          let(:options) { { tags: true } }
+
+          it "returns the latest feat-x verification for the latest feat-x pact" do
+            expect(rows.last.tag_names).to eq ["feat-x"]
+            expect(rows.last.provider_version_number).to eq "1"
+          end
+        end
+
+        context "when a pact with two tags has been verified, and then a new changed version has been published with two tags" 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(:options) { { tags: true } }
+
+          it "returns the latest of the feat-x and feat-y verifications" do
+            expect(rows.last.consumer_version_number).to eq "3"
+            expect(rows.last.tag_names.sort).to eq ["feat-x", "feat-y"]
+            expect(rows.last.provider_version_number).to eq "2"
+          end
+        end
       end
     end
   end

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

@@ -41,7 +41,9 @@ module PactBroker
             .create_pact
         end
 
-        subject { shorten_rows(Repository.new.find(selectors, options)) }
+        subject { shorten_rows(rows) }
+        let(:rows) { Repository.new.find(selectors, options) }
+
 
         let(:options) { { latestby: latestby } }
         let(:latestby) { nil }
@@ -248,6 +250,47 @@ module PactBroker
         end
       end
 
+      describe "find" do
+        describe "when a pact for a particular consumer version is published, then re-published with different content, then published again with the original content" do
+          before do
+            first_pact = td.create_pact_with_hierarchy("billy", "1", "bobby").and_return(:pact)
+            td.create_verification(provider_version: "1")
+              .revise_pact
+              .revise_pact(first_pact.json_content)
+          end
+
+          let(:selectors) { build_selectors('billy' => nil, 'bobby' => nil) }
+
+          subject { Repository.new.find(selectors, options) }
+
+          context "when latestby: cvpv" do
+            let(:options) { { latestby: 'cvpv' } }
+
+            it "only includes the row for the latest revision" do
+              expect(subject.size).to eq 1
+              expect(subject).to contain_hash(pact_revision_number: 3)
+            end
+          end
+
+          context "when latestby: cvp" do
+            let(:options) { { latestby: 'cvp' } }
+
+            it "only includes the row for the latest revision" do
+              expect(subject.size).to eq 1
+              expect(subject).to contain_hash(pact_revision_number: 3)
+            end
+          end
+
+          context "when latestby: nil" do
+            let(:options) { {} }
+
+            it "includes all the rows" do
+              expect(subject.size).to eq 3
+            end
+          end
+        end
+      end
+
       describe "find" do
         let(:options) { {} }
 
@@ -510,6 +553,10 @@ module PactBroker
             expect(subject).to include_hash_matching provider_version_number: "2.0.0"
             expect(subject.size).to eq 1
           end
+
+          it "returns the tag information" do
+            expect(subject.first[:provider_version_tags]).to include_hash_matching name: 'prod', latest: 1
+          end
         end
 
         context "when the latest version is specified for a provider without a tag" do

data/spec/lib/pact_broker/matrix/row_spec.rb

@@ -3,6 +3,65 @@ require 'pact_broker/matrix/row'
 module PactBroker
   module Matrix
     describe Row do
+      describe "refresh", migration: true do
+        before do
+          PactBroker::Database.migrate
+        end
+
+        let(:td) { TestDataBuilder.new(auto_refresh_matrix: false) }
+
+        before do
+          td.create_pact_with_hierarchy("Foo", "1", "Bar")
+        end
+
+        context "with only a consumer_name" do
+          subject { Row.refresh(consumer_name: "Foo") }
+
+          it "refreshes the data for the consumer" do
+            subject
+            expect(Row.all.collect(&:values)).to contain_hash(provider_name: "Bar", consumer_name: "Foo")
+          end
+        end
+
+        context "with only a provider_name" do
+          subject { Row.refresh(provider_name: "Bar") }
+
+          it "refreshes the data for the provider" do
+            subject
+            expect(Row.all.collect(&:values)).to contain_hash(provider_name: "Bar", consumer_name: "Foo")
+          end
+        end
+
+        context "with both consumer_name and provider_name" do
+          subject { Row.refresh(provider_name: "Bar", consumer_name: "Foo") }
+
+          it "refreshes the data for the consumer and provider" do
+            subject
+            expect(Row.all.collect(&:values)).to contain_hash(provider_name: "Bar", consumer_name: "Foo")
+          end
+        end
+
+        context "when there was existing data" do
+          it "deletes the existing data before inserting the new data" do
+            Row.refresh(provider_name: "Bar", consumer_name: "Foo")
+            expect(Row.count).to eq 1
+            td.create_consumer_version("2")
+              .create_pact
+            Row.refresh(provider_name: "Bar", consumer_name: "Foo")
+            expect(Row.count).to eq 2
+          end
+        end
+
+        context "with a pacticipant_name" do
+          subject { Row.refresh(pacticipant_name: "Bar") }
+
+          it "refreshes the data for both consumer and provider roles" do
+            subject
+            expect(Row.all.collect(&:values)).to contain_hash(provider_name: "Bar", consumer_name: "Foo")
+          end
+        end
+      end
+
       describe "<=>" do
         let(:row_1) do
           Row.new(

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

@@ -11,8 +11,11 @@ module PactBroker
         let(:provider) { instance_double("PactBroker::Domain::Pacticipant", name: 'Provider Name')}
         let(:latest_pact) { instance_double("PactBroker::Domain::Pact") }
         let(:latest_verification) { instance_double("PactBroker::Domain::Verification") }
-        let(:domain_relationship) { PactBroker::Domain::IndexItem.new(consumer, provider, latest_pact, latest, latest_verification, [], [], tags)}
+        let(:domain_relationship) { PactBroker::Domain::IndexItem.new(consumer, provider, latest_pact, latest, latest_verification, [], [], tags, latest_verification_latest_tags)}
         let(:tags) { [] }
+        let(:verification_tag_1) { instance_double("PactBroker::Tags::TagWithLatestFlag", name: 'dev') }
+        let(:verification_tag_2) { instance_double("PactBroker::Tags::TagWithLatestFlag", name: 'prod') }
+        let(:latest_verification_latest_tags) { [verification_tag_1, verification_tag_2]  }
         let(:latest) { true }
 
         subject { IndexItem.new(domain_relationship) }
@@ -111,22 +114,24 @@ module PactBroker
           end
         end
 
-        describe "tag_names" do
-          context "when the pact is the overall latest and it has no tag names" do
-            its(:tag_names) { is_expected.to eq " (latest) " }
+        describe "latest?" do
+          context "when the pact is the overall latest" do
+            its(:latest?) { is_expected.to be true }
           end
 
-          context "when the pact is the overall latest and also has tag names" do
-            let(:tags) { ["master", "prod"] }
-            its(:tag_names) { is_expected.to eq " (latest & latest master, prod) " }
-          end
-
-          context "when the pact is not the latest and has tag names" do
+          context "when the pact is not the latest" do
             let(:latest) { false }
-            let(:tags) { ["master", "prod"] }
-            its(:tag_names) { is_expected.to eq " (latest master, prod) " }
+            its(:latest?) { is_expected.to be false }
           end
+        end
+
+        describe "consumer_version_latest_tag_names" do
+          let(:tags) { ["master", "prod"] }
+          its(:consumer_version_latest_tag_names) { is_expected.to eq ["master", "prod"] }
+        end
 
+        describe "provider_version_latest_tag_names" do
+          its(:provider_version_latest_tag_names) { is_expected.to eq ["dev", "prod"] }
         end
 
         describe "<=>" do

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

@@ -0,0 +1,22 @@
+require 'pact_broker/versions/abbreviate_number'
+
+module PactBroker
+  module Versions
+    describe AbbreviateNumber do
+      describe "#call" do
+        TEST_CASES = [
+          ['202326572516dea6998a7f311fcaa161c0768fc2', '2023265'],
+          ['1.2.3+areallyreallyreallylongexplanation', '1.2.3+areallyreallyreallylongexplanation'],
+          ['2516dea6998a7f', '2516dea6998a7f'],
+          ['1.2.3+202326572516dea6998a7f311fcaa161c0768fc2', '1.2.3+2023265']
+        ]
+
+        TEST_CASES.each do |(input, output)|
+          it "shortens #{input} to #{output}" do
+            expect(AbbreviateNumber.call(input)).to eq output
+          end
+        end
+      end
+    end
+  end
+end

data/spec/migrations/20180201_create_head_matrix_spec.rb

@@ -0,0 +1,132 @@
+describe "latest tagged matrix", migration: true do
+  let(:td) { TestDataBuilder.new }
+
+  before do
+    PactBroker::Database.migrate
+  end
+
+  subject { database[:head_matrix].all }
+
+  context "with a single consumer version tag on the latest version" do
+    before do
+      td.create_pact_with_hierarchy("Foo", "1", "Bar")
+        .create_consumer_version_tag("prod")
+        .create_consumer_version("2")
+        .create_consumer_version_tag("prod")
+        .create_pact
+        .revise_pact
+    end
+
+    context "without a verification" do
+      it "returns a line with no tag and a line with a tag" do
+        expect(subject).to contain_hash(
+          consumer_version_tag_name: nil,
+          consumer_version_number: "2"
+        )
+        expect(subject).to contain_hash(
+          consumer_version_tag_name: "prod",
+          consumer_version_number: "2"
+        )
+      end
+    end
+
+    context "with a verification" do
+      before do
+        td.create_verification(provider_version: "3")
+      end
+      it "returns the verification details" do
+        expect(subject).to contain_hash(
+          consumer_version_tag_name: nil,
+          consumer_version_number: "2",
+          provider_version_number: "3"
+        )
+        expect(subject).to contain_hash(
+          consumer_version_tag_name: "prod",
+          consumer_version_number: "2",
+          provider_version_number: "3"
+        )
+      end
+    end
+  end
+  context "with two tags on the latest version" do
+    before do
+      td.create_pact_with_hierarchy("Foo", "1", "Bar")
+        .create_consumer_version_tag("prod")
+        .create_consumer_version_tag("master")
+        .create_consumer_version("2")
+        .create_consumer_version_tag("prod")
+        .create_consumer_version_tag("master")
+        .create_pact
+        .revise_pact
+    end
+
+    it "returns a line with no tag, and a line for each tag" do
+      expect(subject).to contain_hash(
+        consumer_version_tag_name: nil,
+        consumer_version_number: "2"
+      )
+      expect(subject).to contain_hash(
+        consumer_version_tag_name: "prod",
+        consumer_version_number: "2"
+      )
+
+      expect(subject).to contain_hash(
+        consumer_version_tag_name: "master",
+        consumer_version_number: "2"
+      )
+    end
+
+    context "with a verification" do
+      before do
+        td.create_verification(provider_version: "3")
+      end
+      it "returns the verification details" do
+        expect(subject).to contain_hash(
+          consumer_version_tag_name: nil,
+          consumer_version_number: "2",
+          provider_version_number: "3"
+        )
+        expect(subject).to contain_hash(
+          consumer_version_tag_name: "prod",
+          consumer_version_number: "2",
+          provider_version_number: "3"
+        )
+
+        expect(subject).to contain_hash(
+          consumer_version_tag_name: "master",
+          consumer_version_number: "2",
+          provider_version_number: "3"
+        )
+      end
+    end
+  end
+  context "with different versions for overall latest, and two other tags" do
+    before do
+      td.create_pact_with_hierarchy("Foo", "1", "Bar")
+        .create_consumer_version_tag("prod")
+        .create_consumer_version_tag("master")
+        .create_consumer_version("2")
+        .create_consumer_version_tag("master")
+        .create_pact
+        .revise_pact
+        .create_consumer_version("3")
+        .create_pact
+    end
+
+    it "returns a line for each" do
+      expect(subject).to contain_hash(
+        consumer_version_tag_name: nil,
+        consumer_version_number: "3"
+      )
+      expect(subject).to contain_hash(
+        consumer_version_tag_name: "prod",
+        consumer_version_number: "1"
+      )
+
+      expect(subject).to contain_hash(
+        consumer_version_tag_name: "master",
+        consumer_version_number: "2"
+      )
+    end
+  end
+end