pact_broker 2.7.0.beta.1 → 2.7.0.beta.2

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

@@ -3,7 +3,225 @@ require 'pact_broker/matrix/repository'
 module PactBroker
   module Matrix
     describe Repository do
-      describe "#find" do
+      let(:td) { TestDataBuilder.new}
+
+      def build_selectors(hash)
+        hash.collect do | key, value |
+          { pacticipant_name: key, pacticipant_version_number: value }
+        end
+      end
+
+      describe "find" do
+        context "when the provider version resource exists but there is no verification for that version" do
+          before do
+            # A/1.2.3 -> B
+            # B/2.0.0
+            # C/3.0.0
+            td.create_pact_with_hierarchy("A", "1.2.3", "B")
+              .use_provider("B")
+              .create_version("2.0.0")
+              .create_provider("C")
+              .create_version("3.0.0")
+              .create_pact
+          end
+
+          subject { Repository.new.find build_selectors("A" => "1.2.3", "B" => "2.0.0", "C" => "3.0.0") }
+
+          it "returns a row for each pact" do
+            expect(subject.size).to eq 2
+          end
+
+          it "returns an row with a blank provider_version_number" do
+            expect(subject.first).to include consumer_name: "A",
+              provider_name: "B",
+              consumer_version_number: "1.2.3",
+              provider_version_number: nil
+
+            expect(subject.last).to include consumer_name: "A",
+              provider_name: "C",
+              consumer_version_number: "1.2.3",
+              provider_version_number: nil
+          end
+
+          context "when only 2 version selectors are specified" do
+            let(:selectors) { build_selectors("A" => "1.2.3", "B" => "2.0.0") }
+
+            subject { Repository.new.find(selectors) }
+
+            it "only returns 1 row" do
+              expect(subject.size).to eq 1
+            end
+          end
+        end
+
+        context "when only one pacticipant/version is specified and it is a consumer" do
+          before do
+            td.create_pact_with_hierarchy("A", "1.2.3", "B")
+              .create_verification(provider_version: "4.5.6")
+              .create_provider("D")
+              .create_pact
+              .create_verification(provider_version: "6.7.8")
+              .create_consumer_version("5.5.5")
+              .create_pact
+              .create_verification(provider_version: "4.5.6")
+          end
+
+          subject { Repository.new.find build_selectors("A" => "1.2.3") }
+
+          it "returns a row for each verification for that version" do
+            expect(subject.size).to eq 2
+            expect(subject.collect{|r| r[:consumer_version_number]}.sort).to eq ["1.2.3", "1.2.3"]
+            expect(subject.collect{|r| r[:provider_version_number]}.sort).to eq ["4.5.6", "6.7.8"]
+          end
+        end
+
+        context "when only one pacticipant name is specified and it is a consumer" do
+          before do
+            td.create_pact_with_hierarchy("A", "1.2.3", "B")
+              .create_verification(provider_version: "4.5.6")
+              .create_provider("D")
+              .create_pact
+              .create_pact_with_hierarchy("X", "1.2.3", "Y")
+          end
+
+          subject { Repository.new.find build_selectors("A" => nil) }
+
+          it "returns a row for each verification for the pacticipant" do
+            expect(subject.collect{|r| r[:consumer_name]}.uniq).to eq ["A"]
+            provider_version_numbers = subject.collect{|r| r[:provider_version_number]}
+            expect(provider_version_numbers).to include nil
+            expect(provider_version_numbers).to include "4.5.6"
+          end
+        end
+
+        context "when only one pacticipant/version is specified and it is a provider" do
+          before do
+            td.create_pact_with_hierarchy("A", "1.2.3", "B")
+              .create_verification(provider_version: "4.5.6")
+              .create_consumer("D")
+              .create_consumer_version("3.4.5")
+              .create_pact
+              .create_verification(provider_version: "4.5.6")
+              .create_verification(provider_version: "6.7.8", number: 2)
+          end
+
+          subject { Repository.new.find build_selectors("B" => "4.5.6") }
+
+          it "returns a row for each verification for that version" do
+            expect(subject.size).to eq 2
+            expect(subject.collect{|r| r[:consumer_version_number]}.sort).to eq ["1.2.3", "3.4.5"]
+            expect(subject.collect{|r| r[:provider_version_number]}.sort).to eq ["4.5.6", "4.5.6"]
+          end
+        end
+
+        context "when only one pacticipant name is specified and it is a provider" do
+          before do
+            td.create_pact_with_hierarchy("A", "1.2.3", "B")
+              .create_verification(provider_version: "4.5.6")
+              .create_consumer("D")
+              .create_consumer_version("3.4.5")
+              .create_pact
+              .create_verification(provider_version: "4.5.6")
+              .create_verification(provider_version: "6.7.8", number: 2)
+          end
+
+          subject { Repository.new.find build_selectors("B" => nil) }
+
+          it "returns a row for each verification for that version" do
+            expect(subject.size).to eq 3
+            expect(subject.collect{|r| r[:consumer_version_number]}.sort).to eq ["1.2.3", "3.4.5", "3.4.5"]
+            expect(subject.collect{|r| r[:provider_version_number]}.sort).to eq ["4.5.6", "4.5.6", "6.7.8"]
+          end
+        end
+
+        context "when only one pacticipant/version is specified and it is a consumer and provider" do
+          before do
+            td.create_pact_with_hierarchy("A", "1", "B")
+              .create_verification(provider_version: '1')
+              .create_verification(provider_version: '2', number: 2, success: false)
+              .create_verification(provider_version: '4', number: 3)
+              .create_provider_version("5")
+              .use_consumer("B")
+              .use_consumer_version("1")
+              .create_provider("C")
+              .create_pact
+              .create_verification(provider_version: '1', success: false)
+          end
+
+          subject { Repository.new.find build_selectors("B" => "1") }
+
+          it "returns rows where the pacticipant is the consumer and rows where the pacticipant is the provider" do
+            # A/1 and B/1
+            # B/1 and C/1
+            expect(subject.size).to eq 2
+          end
+        end
+
+        context "using the success option" do
+          before do
+            td.create_pact_with_hierarchy("A", "1.2.3", "B")
+              .create_verification(provider_version: "1.0.0")
+              .create_consumer_version("1.2.4")
+              .create_pact
+              .create_verification(provider_version: "2.0.0", success: false)
+              .create_consumer_version("1.2.5")
+              .create_pact
+          end
+
+          let(:selectors) { build_selectors("A" => nil, "B" => nil) }
+
+          subject { Repository.new.find(selectors, options) }
+
+          context "when the success option is not set" do
+            let(:options) { { } }
+
+            it "returns all rows specified by the selectors" do
+              expect(subject.size).to eq 3
+            end
+          end
+
+          context "when the success option is true" do
+            let(:options) { { success: [true] } }
+
+            it "only includes successes" do
+              expect(subject.first[:provider_version_number]).to eq "1.0.0"
+              expect(subject.size).to eq 1
+            end
+          end
+
+          context "when the success option is false" do
+            let(:options) { { success: [false] } }
+
+            it "only includes failures" do
+              expect(subject.first[:provider_version_number]).to eq "2.0.0"
+              expect(subject.size).to eq 1
+            end
+          end
+
+          context "when the success option is nil" do
+            let(:options) { { success: [nil] } }
+
+            it "only includes unverified rows" do
+              expect(subject.first[:provider_version_number]).to eq nil
+              expect(subject.size).to eq 1
+            end
+          end
+
+          context "when multiple success options are specified" do
+            let(:options) { { success: [false, nil] } }
+
+            it "returns all matching rows" do
+              # postgres orders differently, and ruby array sort blows up with a nil string
+              provider_version_numbers = subject.collect{ |r| r[:provider_version_number]}
+              expect(provider_version_numbers).to include nil
+              expect(provider_version_numbers).to include "2.0.0"
+              expect(provider_version_numbers.size).to eq 2
+            end
+          end
+        end
+      end
+
+      describe "#find_for_consumer_and_provider" do
         before do
           TestDataBuilder.new
             .create_pact_with_hierarchy("Consumer", "1.2.3", "Provider")
@@ -14,7 +232,7 @@ module PactBroker
             .create_pact
         end
 
-        subject { Repository.new.find("Consumer", "Provider") }
+        subject { Repository.new.find_for_consumer_and_provider("Consumer", "Provider") }
 
         it "returns the latest revision of each pact" do
           expect(subject.count).to eq 2
@@ -27,7 +245,7 @@ module PactBroker
         end
 
         it "doesn't matter which way you order the pacticipant names" do
-          expect(subject).to eq(Repository.new.find "Provider", "Consumer")
+          expect(subject).to eq(Repository.new.find_for_consumer_and_provider "Provider", "Consumer")
         end
       end
 
@@ -52,9 +270,11 @@ module PactBroker
               .create_verification(provider_version: '3', number: 2)
           end
 
-          subject { Repository.new.find_compatible_pacticipant_versions("A" => "1", "B" => "2", "C" => "2") }
+          let(:selectors){ build_selectors("A" => "1", "B" => "2", "C" => "2") }
+
+          subject { Repository.new.find_compatible_pacticipant_versions(selectors) }
 
-          it "returns matrix lines for each compatible version pair" do
+          it "returns matrix lines for each compatible version pair (A/1-B/2, B/2-C/2)" 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"
@@ -74,7 +294,8 @@ module PactBroker
           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) }
+            let(:selectors){ build_selectors("A" => "1", "B" => "2", "C" => nil) }
+            subject { Repository.new.find_compatible_pacticipant_versions(selectors) }
 
             it "returns all the rows for that pacticipant" do
               expect(subject[1]).to include(provider_name: "C", provider_version_number: "2")
@@ -84,10 +305,12 @@ module PactBroker
           end
 
           context "none of the pacticipants have a version specified" do
-            subject { Repository.new.find_compatible_pacticipant_versions("A" => nil, "B" => nil, "C" => nil) }
+            let(:selectors){ build_selectors("A" => nil, "B" => nil, "C" => nil) }
+
+            subject { Repository.new.find_compatible_pacticipant_versions(selectors) }
 
             it "returns all the rows" do
-              expect(subject.size).to eq 4
+              expect(subject.size).to eq 5
             end
           end
         end
@@ -98,7 +321,10 @@ module PactBroker
               .create_verification(provider_version: "1")
               .create_verification(provider_version: "1", number: 2)
           end
-          subject { Repository.new.find_compatible_pacticipant_versions("X" => "1", "Y" => "1") }
+
+          let(:selectors){ build_selectors("X" => "1", "Y" => "1") }
+
+          subject { Repository.new.find_compatible_pacticipant_versions(selectors) }
 
           it "returns the last line" do
             expect(subject.size).to eq 1
@@ -113,7 +339,9 @@ module PactBroker
               .create_verification(provider_version: "1", number: 2, success: false)
           end
 
-          subject { Repository.new.find_compatible_pacticipant_versions("X" => "1", "Y" => "1") }
+          let(:selectors){ build_selectors("X" => "1", "Y" => "1") }
+
+          subject { Repository.new.find_compatible_pacticipant_versions(selectors) }
 
           it "does not return a matrix line" do
             expect(subject.size).to eq 0
@@ -127,7 +355,9 @@ module PactBroker
               .revise_pact
           end
 
-          subject { Repository.new.find_compatible_pacticipant_versions("X" => "1", "Y" => "1") }
+          let(:selectors){ build_selectors("X" => "1", "Y" => "1") }
+
+          subject { Repository.new.find_compatible_pacticipant_versions(selectors) }
 
           it "does not return a matrix line" do
             expect(subject.size).to eq 0
@@ -141,7 +371,9 @@ module PactBroker
               .create_verification(provider_version: '1', success: false)
           end
 
-          subject { Repository.new.find_compatible_pacticipant_versions("D" => "1", "E" => "1") }
+          let(:selectors){ build_selectors("D" => "1", "E" => "1") }
+
+          subject { Repository.new.find_compatible_pacticipant_versions(selectors) }
 
           it "does not return the matrix line" do
             expect(subject.count).to eq 0

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

@@ -3,16 +3,17 @@ require 'pact_broker/matrix/service'
 module PactBroker
   module Matrix
     describe Service do
+      let(:td) { TestDataBuilder.new }
+
       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"] }
+        context "when there are no selectors" do
+          let(:selectors) { [] }
 
           it "returns error messages" do
-            expect(subject.first).to eq "Invalid version selector 'Foo/1'. Format must be <pacticipant_name>/version/<version>"
+            expect(subject.first).to eq "Please provide 1 or more version selectors."
           end
         end
 
@@ -22,25 +23,54 @@ module PactBroker
               .create_version("1")
               .create_pacticipant("Bar")
               .create_version("2")
-
           end
 
-          let(:selectors) { ["Foo/version/1", "Bar/version/1"] }
+          let(:selectors) { [{ pacticipant_name: "Foo", pacticipant_version_number: "1" }, { pacticipant_name: "Bar", pacticipant_version_number: "1" }] }
 
           it "returns error messages" do
-            expect(subject).to eq ["No pact or verification found for Bar/version/1"]
+            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"] }
+          let(:selectors) { [{ pacticipant_name: "Foo", pacticipant_version_number: "1" }] }
 
           it "returns error messages" do
             expect(subject.first).to eq "Pacticipant 'Foo' not found"
           end
         end
+
+        context "when the pacticipant name is not specified" do
+          let(:selectors) { [{ pacticipant_name: nil, pacticipant_version_number: "1" }] }
+
+          it "returns error messages" do
+            expect(subject.first).to eq "Please specify the pacticipant name"
+          end
+        end
+
+        context "when the pacticipant version is not specified" do
+          before do
+            td.create_pacticipant("Foo")
+              .create_version("1")
+              .create_pacticipant("Bar")
+              .create_version("2")
+          end
+
+          let(:selectors) { [ { pacticipant_name: "Foo", pacticipant_version_number: nil }, { pacticipant_name: "Bar", pacticipant_version_number: nil } ] }
+
+          it "returns no error messages" do
+            expect(subject).to eq []
+          end
+        end
+
+        context "when the pacticipant name and version are not specified" do
+          let(:selectors) { [{ pacticipant_name: nil, pacticipant_version_number: nil }] }
+
+          it "returns error messages" do
+            expect(subject.first).to eq "Please specify the pacticipant name and version"
+          end
+        end
       end
     end
   end
 end
-

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

@@ -8,8 +8,6 @@ module PactBroker
   module Pacticipants
     describe Service do
 
-      let(:td) { TestDataBuilder.new }
-
       subject{ Service }
 
       describe ".messages_for_potential_duplicate_pacticipants" do
@@ -99,9 +97,10 @@ 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", id: 1, consumer: consumer, provider: provider, consumer_name: 'foo', provider_name: 'bar', consumer_version_tag_names: [])}
+        let(:pact) { instance_double("PactBroker::Domain::Pact", consumer: consumer, provider: provider)}
         let(:verification) { instance_double("PactBroker::Domain::Verification")}
         let(:pacts) { [pact]}
         let(:webhooks) { [instance_double("PactBroker::Domain::Webhook")]}
@@ -109,7 +108,6 @@ 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)
@@ -126,85 +124,13 @@ module PactBroker
         end
 
         it "returns a list of relationships" do
-          expect(subject.find_relationships).to eq([PactBroker::Domain::Relationship.create(consumer, provider, pact, true, verification, webhooks)])
+          expect(subject.find_relationships).to eq([PactBroker::Domain::Relationship.create(consumer, provider, pact, 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/repository_spec.rb

@@ -576,20 +576,19 @@ module PactBroker
       describe "find_latest_pacts" do
         before do
           TestDataBuilder.new
-            .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
+            .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
         end
 
         it "finds the latest pact for each consumer/provider pair" do
@@ -601,13 +600,12 @@ 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[0].consumer_version.tags.collect(&:name)).to eq ["prod"]
+          expect(pacts[1].consumer_version.tags).to be nil # Not used, don't bother loading
 
           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(:pact_url) { should eq "/pacts/provider/Provider%20Name/consumer/Consumer%20Name/latest" }
+        its(:latest_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" }
 
@@ -67,8 +67,7 @@ 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?: true
+              latest_pact: double("pact", consumer: consumer, provider: provider)
             )
           end
           let(:webhook_status) { :none }
@@ -123,8 +122,10 @@ 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