pact_broker 2.9.0 → 2.10.0

data/spec/integration/ui/index_spec.rb

@@ -0,0 +1,36 @@
+require 'pact_broker/ui/app'
+
+describe "UI index" do
+
+  let(:app) { PactBroker::UI::App.new }
+  let(:td) { TestDataBuilder.new }
+  let(:params) { {} }
+
+  before do
+    td.create_pact_with_hierarchy("Foo", "1", "Bar")
+      .create_consumer_version_tag("prod")
+      .create_consumer_version("2")
+      .create_pact
+    get "/"
+  end
+
+  subject { get("/", params, {}); last_response }
+
+  describe "GET" do
+    it "returns a success response" do
+      expect(subject.status).to eq 200
+    end
+
+    it "returns a table of pacts" do
+      expect(subject.body.scan('<tr').to_a.count).to eq 1
+    end
+
+    context "with an array of tags" do
+      let(:params) { { tags: ['prod'] } }
+
+      it "returns a table of pacts with the specfied tags" do
+        expect(subject.body.scan('<tr').to_a.count).to eq 2
+      end
+    end
+  end
+end

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

@@ -1,6 +1,6 @@
 require 'spec_helper'
 require 'pact_broker/domain/group'
-require 'pact_broker/domain/relationship'
+require 'pact_broker/domain/index_item'
 
 module PactBroker
   module Domain
@@ -15,8 +15,8 @@ module PactBroker
         let(:provider_x) { double('provider x') }
         let(:provider_y) { double('provider y') }
 
-        let(:relationship_1) { Domain::Relationship.new(consumer_a, provider_x)}
-        let(:relationship_2) { Domain::Relationship.new(consumer_b, provider_y)}
+        let(:relationship_1) { Domain::IndexItem.new(consumer_a, provider_x)}
+        let(:relationship_2) { Domain::IndexItem.new(consumer_b, provider_y)}
 
         subject { Group.new(relatio)}
       end

data/spec/lib/pact_broker/domain/{relationship_spec.rb → index_items_spec.rb}

@@ -1,8 +1,8 @@
-require 'pact_broker/domain/relationship'
+require 'pact_broker/domain/index_item'
 
 module PactBroker
   module Domain
-    describe Relationship do
+    describe IndexItem do
       describe "#last_webhook_execution_date" do
         let(:webhook_execution_1) { double('webhook_execution', created_at: DateTime.new(2013)) }
         let(:webhook_execution_2) { double('webhook_execution', created_at: DateTime.new(2015)) }
@@ -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 { IndexItem.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/groups/service_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require 'pact_broker/groups/service'
+require 'pact_broker/index/service'
 
 module PactBroker
 
@@ -15,8 +16,8 @@ module PactBroker
         let(:provider_x) { double('provider x', name: 'provider x', id: 3)}
         let(:provider_y) { double('provider y', name: 'provider y', id: 4)}
 
-        let(:relationship_1) { Domain::Relationship.new(consumer_a, provider_x) }
-        let(:relationship_2) { Domain::Relationship.new(consumer_b, provider_y) }
+        let(:relationship_1) { Domain::IndexItem.new(consumer_a, provider_x) }
+        let(:relationship_2) { Domain::IndexItem.new(consumer_b, provider_y) }
 
         let(:group_1) { Domain::Group.new(relationship_1) }
         let(:group_2) { Domain::Group.new(relationship_2) }
@@ -27,12 +28,12 @@ module PactBroker
         subject  { Service.find_group_containing(consumer_b) }
 
         before do
-          allow(Pacticipants::Service).to receive(:find_relationships).and_return(relationship_list)
+          allow(PactBroker::Index::Service).to receive(:find_index_items).and_return(relationship_list)
           allow(Relationships::Groupify).to receive(:call).and_return(groups)
         end
 
         it "retrieves a list of the relationships" do
-          allow(Pacticipants::Service).to receive(:find_relationships)
+          allow(Index::Service).to receive(:find_index_items)
           subject
         end
 

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

@@ -0,0 +1,131 @@
+require 'spec_helper'
+require 'pact_broker/index/service'
+require 'pact_broker/domain/tag'
+require 'pact_broker/domain/pact'
+
+module PactBroker
+
+  module Index
+    describe Service do
+      let(:td) { TestDataBuilder.new }
+      let(:tags) { ['prod', 'production'] }
+      let(:options) { { tags: tags } }
+
+      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
+            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_index_items(options) }
+
+          it "returns both rows" do
+            expect(rows.count).to eq 2
+          end
+
+          context "when the tags are not specified" do
+            let(:options) { {} }
+
+            it "only returns the latest row" do
+              expect(rows.count).to eq 1
+            end
+          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_index_items(options) }
+
+          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
+    end
+  end
+end

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

@@ -8,10 +8,10 @@ module PactBroker
   module Pacticipants
     describe Service do
 
-      subject{ Service }
-
       let(:td) { TestDataBuilder.new }
 
+      subject{ Service }
+
       describe ".update" do
         before do
           td.create_pacticipant("Foo")
@@ -112,40 +112,7 @@ module PactBroker
         end
       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(: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(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_relationships
-        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_relationships
-        end
-
-        it "returns a list of relationships" do
-          expect(subject.find_relationships).to eq([PactBroker::Domain::Relationship.create(consumer, provider, pact, verification, webhooks)])
-        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/relationships/groupify_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 require 'pact_broker/relationships/groupify'
-require 'pact_broker/domain/relationship'
+require 'pact_broker/domain/index_item'
 
 module PactBroker
 
@@ -24,15 +24,15 @@ module PactBroker
         let(:provider_z) { double('provider z', id: 9, name: 'provider z') }
 
 
-        let(:relationship_1) { Domain::Relationship.new(consumer_a, provider_x) }
-        let(:relationship_4) { Domain::Relationship.new(consumer_a, provider_y) }
-        let(:relationship_2) { Domain::Relationship.new(consumer_b, provider_y) }
+        let(:relationship_1) { Domain::IndexItem.new(consumer_a, provider_x) }
+        let(:relationship_4) { Domain::IndexItem.new(consumer_a, provider_y) }
+        let(:relationship_2) { Domain::IndexItem.new(consumer_b, provider_y) }
 
-        let(:relationship_3) { Domain::Relationship.new(consumer_c, provider_z) }
+        let(:relationship_3) { Domain::IndexItem.new(consumer_c, provider_z) }
 
 
-        let(:relationship_5) { Domain::Relationship.new(consumer_l, provider_p) }
-        let(:relationship_6) { Domain::Relationship.new(consumer_m, provider_p) }
+        let(:relationship_5) { Domain::IndexItem.new(consumer_l, provider_p) }
+        let(:relationship_6) { Domain::IndexItem.new(consumer_m, provider_p) }
 
         let(:relationships) { [relationship_1, relationship_2, relationship_3, relationship_4, relationship_5, relationship_6] }
 

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

@@ -5,6 +5,8 @@ module PactBroker
   module Tags
     describe Repository do
 
+      let(:td) { TestDataBuilder.new }
+
       describe ".find" do
 
         let(:pacticipant_name) { "test_pacticipant" }
@@ -80,9 +82,29 @@ module PactBroker
         it "deletes the tag" do
           expect{ subject }.to change { PactBroker::Domain::Tag.count }.by(-2)
         end
-
       end
 
+
+      describe "find_all_tag_names_for_pacticipant" do
+        before do
+          td.create_consumer("Foo")
+            .create_consumer_version("1")
+            .create_consumer_version_tag("prod")
+            .create_consumer_version_tag("master")
+            .create_consumer_version("2")
+            .create_consumer_version_tag("prod")
+            .create_consumer_version_tag("dev")
+            .create_consumer("Bar")
+            .create_consumer_version("1")
+            .create_consumer_version_tag("ignore")
+        end
+
+        subject { Repository.new.find_all_tag_names_for_pacticipant("Foo") }
+
+        it "returns all the tag names for the pacticipant" do
+          expect(subject).to eq ["dev", "master", "prod"]
+        end
+      end
     end
   end
 end