pact_broker 2.6.0 → 2.7.0.beta.1

data/spec/lib/pact_broker/domain/relationship_spec.rb

@@ -13,7 +13,7 @@ module PactBroker
           allow(webhook_executions).to receive(:sort).and_return(webhook_executions)
         end
 
-        subject { Relationship.create(nil, nil, nil, nil, [], webhook_executions) }
+        subject { Relationship.create(nil, nil, nil, true, nil, [], webhook_executions) }
 
         it "returns the created_at date of the last execution" do
           expect(subject.last_webhook_execution_date).to eq DateTime.new(2015)

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

@@ -0,0 +1,153 @@
+require 'pact_broker/matrix/repository'
+
+module PactBroker
+  module Matrix
+    describe Repository do
+      describe "#find" do
+        before do
+          TestDataBuilder.new
+            .create_pact_with_hierarchy("Consumer", "1.2.3", "Provider")
+            .create_verification(provider_version: "6.7.8", execution_date: DateTime.new(2016))
+            .revise_pact
+            .create_verification(provider_version: "4.5.6", execution_date: DateTime.new(2017))
+            .create_consumer_version("2.0.0")
+            .create_pact
+        end
+
+        subject { Repository.new.find("Consumer", "Provider") }
+
+        it "returns the latest revision of each pact" do
+          expect(subject.count).to eq 2
+          expect(subject[0][:consumer_version_number]).to eq "2.0.0"
+          expect(subject[1][:consumer_version_number]).to eq "1.2.3"
+        end
+
+        it "returns the latest verification for the pact version" do
+          expect(subject[1][:provider_version_number]).to eq "4.5.6"
+        end
+
+        it "doesn't matter which way you order the pacticipant names" do
+          expect(subject).to eq(Repository.new.find "Provider", "Consumer")
+        end
+      end
+
+      describe "#find_compatible_pacticipant_versions" do
+        let(:td) { TestDataBuilder.new }
+
+        context "when compatible versions can be found" do
+          before do
+            td.create_pact_with_hierarchy("A", "1", "B")
+              .create_verification(provider_version: '0')
+              .revise_pact
+              .create_verification(provider_version: '1')
+              .create_verification(provider_version: '2', number: 2)
+              .use_consumer("B")
+              .use_consumer_version("1")
+              .create_provider("C")
+              .create_pact
+              .create_verification(provider_version: '1')
+              .use_consumer_version("2")
+              .create_pact
+              .create_verification(provider_version: '2')
+              .create_verification(provider_version: '3', number: 2)
+          end
+
+          subject { Repository.new.find_compatible_pacticipant_versions("A" => "1", "B" => "2", "C" => "2") }
+
+          it "returns matrix lines for each compatible version pair" do
+            expect(subject.first[:consumer_name]).to eq "A"
+            expect(subject.first[:consumer_version_number]).to eq "1"
+            expect(subject.first[:provider_name]).to eq "B"
+            expect(subject.first[:provider_version_number]).to eq "2"
+            expect(subject.first[:number]).to eq 2
+            expect(subject.first[:pact_created_at]).to be_datey
+            expect(subject.first[:verification_executed_at]).to be_datey
+
+            expect(subject.last[:consumer_name]).to eq "B"
+            expect(subject.last[:consumer_version_number]).to eq "2"
+            expect(subject.last[:provider_name]).to eq "C"
+            expect(subject.last[:provider_version_number]).to eq "2"
+            expect(subject.last[:number]).to eq 1
+            expect(subject.last[:pact_created_at]).to be_datey
+
+            expect(subject.size).to eq 2
+          end
+
+          context "when one or more pacticipants does not have a version specified" do
+            subject { Repository.new.find_compatible_pacticipant_versions("A" => "1", "B" => "2", "C" => nil) }
+
+            it "returns all the rows for that pacticipant" do
+              expect(subject[1]).to include(provider_name: "C", provider_version_number: "2")
+              expect(subject[2]).to include(provider_name: "C", provider_version_number: "3")
+              expect(subject.size).to eq 3
+            end
+          end
+
+          context "none of the pacticipants have a version specified" do
+            subject { Repository.new.find_compatible_pacticipant_versions("A" => nil, "B" => nil, "C" => nil) }
+
+            it "returns all the rows" do
+              expect(subject.size).to eq 4
+            end
+          end
+        end
+
+        context "when there is more than one compatible version pair" do
+          before do
+            td.create_pact_with_hierarchy("X", "1", "Y")
+              .create_verification(provider_version: "1")
+              .create_verification(provider_version: "1", number: 2)
+          end
+          subject { Repository.new.find_compatible_pacticipant_versions("X" => "1", "Y" => "1") }
+
+          it "returns the last line" do
+            expect(subject.size).to eq 1
+            expect(subject.first[:number]).to eq 2
+          end
+        end
+
+        context "when there is more than one compatible verison pair and the last one is a failure" do
+          before do
+            td.create_pact_with_hierarchy("X", "1", "Y")
+              .create_verification(provider_version: "1")
+              .create_verification(provider_version: "1", number: 2, success: false)
+          end
+
+          subject { Repository.new.find_compatible_pacticipant_versions("X" => "1", "Y" => "1") }
+
+          it "does not return a matrix line" do
+            expect(subject.size).to eq 0
+          end
+        end
+
+        context "when a pact is verified, but then revised and the new revision is not verified" do
+          before do
+            td.create_pact_with_hierarchy("X", "1", "Y")
+              .create_verification(provider_version: "1")
+              .revise_pact
+          end
+
+          subject { Repository.new.find_compatible_pacticipant_versions("X" => "1", "Y" => "1") }
+
+          it "does not return a matrix line" do
+            expect(subject.size).to eq 0
+          end
+        end
+
+        context "when the verification result is false" do
+          before do
+            TestDataBuilder.new
+              .create_pact_with_hierarchy("D", "1", "E")
+              .create_verification(provider_version: '1', success: false)
+          end
+
+          subject { Repository.new.find_compatible_pacticipant_versions("D" => "1", "E" => "1") }
+
+          it "does not return the matrix line" do
+            expect(subject.count).to eq 0
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+require 'pact_broker/matrix/service'
+
+module PactBroker
+  module Matrix
+    describe Service do
+      describe "validate_selectors" do
+        let(:td) { TestDataBuilder.new }
+
+        subject { Service.validate_selectors(selectors) }
+
+        context "when a selector format is invalid" do
+          let(:selectors) { ["Foo/1"] }
+
+          it "returns error messages" do
+            expect(subject.first).to eq "Invalid version selector 'Foo/1'. Format must be <pacticipant_name>/version/<version>"
+          end
+        end
+
+        context "when one or more of the selectors does not match any known version" do
+          before do
+            td.create_pacticipant("Foo")
+              .create_version("1")
+              .create_pacticipant("Bar")
+              .create_version("2")
+
+          end
+
+          let(:selectors) { ["Foo/version/1", "Bar/version/1"] }
+
+          it "returns error messages" do
+            expect(subject).to eq ["No pact or verification found for Bar/version/1"]
+          end
+        end
+
+        context "when the pacticipant does not exist" do
+          let(:selectors) { ["Foo/version/1"] }
+
+          it "returns error messages" do
+            expect(subject.first).to eq "Pacticipant 'Foo' not found"
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -8,6 +8,8 @@ module PactBroker
   module Pacticipants
     describe Service do
 
+      let(:td) { TestDataBuilder.new }
+
       subject{ Service }
 
       describe ".messages_for_potential_duplicate_pacticipants" do
@@ -97,10 +99,9 @@ module PactBroker
       end
 
       describe ".find_relationships" do
-
         let(:consumer) { instance_double("PactBroker::Domain::Pacticipant")}
         let(:provider) { instance_double("PactBroker::Domain::Pacticipant")}
-        let(:pact) { instance_double("PactBroker::Domain::Pact", consumer: consumer, provider: provider)}
+        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")]}
@@ -108,6 +109,7 @@ module PactBroker
 
         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)
@@ -124,13 +126,85 @@ module PactBroker
         end
 
         it "returns a list of relationships" do
-          expect(subject.find_relationships).to eq([PactBroker::Domain::Relationship.create(consumer, provider, pact, verification, webhooks)])
+          expect(subject.find_relationships).to eq([PactBroker::Domain::Relationship.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
+            td.create_pact_with_hierarchy("Foo", "1.2.3", "Bar")
+              .create_consumer_version_tag("prod")
+              .create_consumer_version_tag("ignored")
+              .create_verification(provider_version: "2.0.0")
+              .create_consumer_version("1.2.4")
+              .create_consumer_version_tag("also-ignored")
+              .create_pact
+              .create_verification(provider_version: "2.1.0")
+          end
 
+          let(:rows) { subject.find_relationships }
+
+          it "returns both rows" do
+            expect(rows.count).to eq 2
+          end
+
+          it "returns the latest row first" do
+            expect(rows.first.consumer_version_number).to eq "1.2.4"
+            expect(rows.last.consumer_version_number).to eq "1.2.3"
+          end
+
+          it "designates the first row as the latest row, and the second as not latest" do
+            expect(rows.first.latest?).to be true
+            expect(rows.last.latest?).to be false
+          end
+
+          it "doesn't return any tag names for the latest row" do
+            expect(rows.first.tag_names).to eq []
+          end
+
+          it "includes the prod tag name for the prod row" do
+            expect(rows.last.tag_names).to eq ['prod']
+          end
+
+          it "includes the latest overall verification for the latest pact" do
+            expect(rows.first.latest_verification.provider_version_number).to eq '2.1.0'
+          end
+
+          it "includes the latest prod verification for the prod pact" do
+            expect(rows.last.latest_verification.provider_version_number).to eq '2.0.0'
+          end
+        end
+
+        context "when the prod version is the latest version" do
+          before do
+            td.create_pact_with_hierarchy("Foo", "1.2.3", "Bar")
+              .create_consumer_version_tag("prod")
+              .create_consumer_version_tag("ignored")
+              .create_verification(provider_version: "2.0.0")
+          end
+
+          let(:rows) { subject.find_relationships }
+
+          it "returns one row" do
+            expect(rows.count).to eq 1
+          end
+
+          it "designates the row as the latest row" do
+            expect(rows.first.latest?).to be true
+          end
+
+          it "includes the prod tag name for the row" do
+            expect(rows.first.tag_names).to eq ['prod']
+          end
+
+          it "includes the latest overall verification for the latest pact" do
+            expect(rows.first.latest_verification.provider_version_number).to eq '2.0.0'
+          end
+        end
       end
 
       describe "delete" do
-
         before do
           TestDataBuilder.new
             .create_consumer("Consumer")

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

@@ -0,0 +1,35 @@
+require 'pact_broker/pacts/pact_publication'
+
+module PactBroker
+  module Pacts
+    describe PactPublication do
+
+      describe "#latest_tag_names" do
+        before do
+          td.create_pact_with_hierarchy("Foo", "1.2.3", "Bar")
+            .create_consumer_version_tag("no")
+            .create_consumer_version("3.4.5")
+            .create_consumer_version_tag("yes")
+            .create_pact
+            .create_consumer_version("5.6.7")
+            .create_consumer_version_tag("no")
+        end
+
+        let(:td) { TestDataBuilder.new }
+        let(:pact_publication) { PactPublication.find(id: td.pact.id) }
+
+        context "when the pact is the latest for a tag" do
+          it "returns the relevant tag names" do
+            expect(pact_publication.latest_tag_names).to eq ["yes"]
+          end
+        end
+
+        context "when the pact is not the latest for a tag" do
+          it "returns the relevant tag names" do
+            expect(pact_publication.latest_tag_names).to eq ["yes"]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -576,19 +576,20 @@ module PactBroker
       describe "find_latest_pacts" do
         before do
           TestDataBuilder.new
-            .create_condor
-            .create_condor_version('1.3.0')
-            .create_pricing_service
-            .create_condor_pricing_service_pact
-            .create_condor_version('1.4.0')
-            .create_condor_pricing_service_pact
-            .create_contract_email_service
-            .create_contract_email_service_version('2.6.0')
-            .create_contract_proposal_service
-            .create_ces_cps_pact
-            .create_contract_email_service_version('2.7.0')
-            .create_ces_cps_pact
-            .create_contract_email_service_version('2.8.0') # Create a version without a pact, it shouldn't be used
+            .create_consumer("Condor")
+            .create_consumer_version('1.3.0')
+            .create_provider("Pricing Service")
+            .create_pact
+            .create_consumer_version('1.4.0')
+            .create_consumer_version_tag("prod")
+            .create_pact
+            .create_consumer("Contract Email Service")
+            .create_consumer_version("2.6.0")
+            .create_provider("Contract Proposal Service")
+            .create_pact
+            .create_consumer_version('2.7.0')
+            .create_pact
+            .create_consumer_version('2.8.0') # Create a version without a pact, it shouldn't be used
         end
 
         it "finds the latest pact for each consumer/provider pair" do
@@ -600,12 +601,13 @@ module PactBroker
           expect(pacts[0].provider.name).to eq("Pricing Service")
           expect(pacts[0].provider.id).to_not be nil
           expect(pacts[0].consumer_version.number).to eq("1.4.0")
-          expect(pacts[1].consumer_version.tags).to be nil # Not used, don't bother loading
+          expect(pacts[0].consumer_version.tags.collect(&:name)).to eq ["prod"]
 
           expect(pacts[1].consumer_version.pacticipant.name).to eq("Contract Email Service")
           expect(pacts[1].consumer.name).to eq("Contract Email Service")
           expect(pacts[1].provider.name).to eq("Contract Proposal Service")
           expect(pacts[1].consumer_version.number).to eq("2.7.0")
+          expect(pacts[1].consumer_version.tags.collect(&:name)).to eq []
         end
 
         it "includes the timestamps - need to update view" do

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

@@ -16,7 +16,7 @@ module PactBroker
 
         its(:consumer_name) { should eq 'Consumer Name'}
         its(:provider_name) { should eq 'Provider Name'}
-        its(:latest_pact_url) { should eq "/pacts/provider/Provider%20Name/consumer/Consumer%20Name/latest" }
+        its(:pact_url) { should eq "/pacts/provider/Provider%20Name/consumer/Consumer%20Name/latest" }
         its(:consumer_group_url) { should eq "/groups/Consumer%20Name" }
         its(:provider_group_url) { should eq "/groups/Provider%20Name" }
 
@@ -25,7 +25,7 @@ module PactBroker
             instance_double("PactBroker::Domain::Relationship",
               verification_status: verification_status,
               provider_name: "Foo",
-              latest_verification_provider_version: "4.5.6")
+              latest_verification_provider_version_number: "4.5.6")
           end
           let(:ever_verified) { true }
           let(:pact_changed) { false }
@@ -67,7 +67,8 @@ module PactBroker
             instance_double("PactBroker::Domain::Relationship",
               webhook_status: webhook_status,
               last_webhook_execution_date: DateTime.now - 1,
-              latest_pact: double("pact", consumer: consumer, provider: provider)
+              latest_pact: double("pact", consumer: consumer, provider: provider),
+              latest?: true
             )
           end
           let(:webhook_status) { :none }
@@ -122,10 +123,8 @@ module PactBroker
             expect(relationship_view_models.sort.collect{ |r| [r.consumer_name, r.provider_name]})
               .to eq([["A", "X"],["a","y"],["A","Z"],["C", "A"]])
           end
-
         end
-
       end
     end
   end
-end
+end