pact_broker 2.58.0 → 2.58.2

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

@@ -125,7 +125,7 @@ module PactBroker
             end
 
             it "renders the tag" do
-              expect(tag_decorator).to receive(:to_json).with(user_options: { base_url: "http://example.org" })
+              expect(tag_decorator).to receive(:to_json).with(user_options: hash_including(base_url: "http://example.org"))
               subject
               expect(last_response.body).to eq tag_json
             end
@@ -149,7 +149,7 @@ module PactBroker
             end
 
             it "renders the tag" do
-              expect(tag_decorator).to receive(:to_json).with(user_options: { base_url: "http://example.org" })
+              expect(tag_decorator).to receive(:to_json).with(user_options: hash_including(base_url: "http://example.org"))
               subject
               expect(last_response.body).to eq tag_json
             end

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

@@ -40,7 +40,7 @@ module PactBroker::Api
 
           it "generates a JSON representation of the webhook" do
             expect(Decorators::WebhookDecorator).to receive(:new).with(webhook)
-            expect(decorator).to receive(:to_json).with(user_options: { base_url: 'http://example.org'})
+            expect(decorator).to receive(:to_json).with(user_options: hash_including(base_url: 'http://example.org'))
             subject
           end
 

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

@@ -223,7 +223,7 @@ module PactBroker::Api
 
           it "generates the JSON response body" do
             expect(Decorators::WebhookDecorator).to receive(:new).with(saved_webhook).and_return(webhook_decorator)
-            expect(webhook_decorator).to receive(:to_json).with(user_options: { base_url: 'http://example.org' })
+            expect(webhook_decorator).to receive(:to_json).with(user_options: hash_including(base_url: 'http://example.org'))
             subject
           end
 

data/spec/lib/pact_broker/db/clean_old_spec.rb

@@ -0,0 +1,125 @@
+require 'pact_broker/db/clean'
+
+IS_MYSQL = !!DB.mysql?
+
+module PactBroker
+  module DB
+    # Inner queries don't work on MySQL. Seriously, MySQL???
+    describe Clean, skip: true, pending: IS_MYSQL  do
+      let(:options) { {} }
+      let(:db) { PactBroker::DB.connection }
+
+      subject { Clean.call(PactBroker::DB.connection, options) }
+
+      describe ".call"do
+
+        before do
+          td.create_pact_with_hierarchy("Foo", "0", "Bar")
+            .create_consumer_version_tag("prod")
+            .create_consumer_version("1")
+            .create_pact
+            .create_consumer_version_tag("prod")
+            .comment("keep")
+            .create_verification(provider_version: "20")
+            .create_consumer_version("2")
+            .create_pact
+            .comment("don't keep")
+            .create_webhook
+            .create_triggered_webhook
+            .create_webhook_execution
+            .create_verification(provider_version: "30")
+            .create_verification_webhook
+            .create_triggered_webhook
+            .create_webhook_execution
+            .create_consumer_version("3")
+            .create_pact
+            .comment("keep")
+            .create_verification(provider_version: "40")
+            .create_verification(provider_version: "40", number: 2)
+            .create_verification(provider_version: "50", number: 3)
+        end
+
+
+        it "does not delete any rows in the head matrix" do
+          head_matrix_before = db[:head_matrix].select_all
+          subject
+          head_matrix_after = db[:head_matrix].select_all
+          expect(head_matrix_before).to eq head_matrix_after
+        end
+
+        it "deletes rows that aren't the latest or latest tagged" do
+          subject
+          expect(db[:matrix].where(consumer_version_number: "2").count).to eq 0
+        end
+
+        it "deletes orphan pact_versions" do
+          subject
+          expect(db[:pact_versions].count).to eq 2
+        end
+
+        it "deletes orphan versions" do
+          subject
+          expect(db[:versions].where(number: "20").count).to be 1
+          expect(db[:versions].where(number: "30").count).to be 0
+          expect(db[:versions].where(number: "40").count).to be 1
+          expect(db[:versions].where(number: "50").count).to be 1
+        end
+
+        it "deletes overwritten verifications" do
+          expect(db[:matrix].where(provider_version_number: "40").count).to eq 2
+          subject
+          expect(db[:matrix].where(provider_version_number: "40", verification_number: 2).count).to eq 1
+        end
+      end
+
+      describe ".call with a date" do
+        before do
+          td.set_now(DateTime.new(2019, 1, 1))
+            .create_pact_with_hierarchy
+            .create_verification
+        end
+        let(:options) { { date: date } }
+
+        context "when the data is older than the given date" do
+          let(:date) { DateTime.new(2019, 1, 2) }
+          let(:expected_report) do
+            {
+              kept: { pact_publications: 0, verification_results: 0 },
+              deleted: { pact_publications: 1, verification_results: 1 }
+            }
+          end
+
+          it "is deleted" do
+            subject
+            expect(db[:head_matrix].count).to be 0
+          end
+
+          it "returns a report" do
+            expect(subject).to include(expected_report)
+          end
+        end
+
+        context "when the data is not older than the given date" do
+          let(:date) { DateTime.new(2019, 1, 1) }
+          let(:expected_report) do
+            {
+              kept: { pact_publications: 1, verification_results: 1 },
+              deleted: { pact_publications: 0, verification_results: 0 }
+            }
+          end
+
+          it "is not deleted" do
+            subject
+            expect(db[:head_matrix].count).to be 1
+            expect(db[:pact_publications].count).to be 1
+            expect(db[:verifications].count).to be 1
+          end
+
+          it "returns a report" do
+            expect(subject).to include(expected_report)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/pact_broker/db/clean_spec.rb

@@ -11,31 +11,26 @@ module PactBroker
       let(:db) { PactBroker::DB.connection }
 
       subject { Clean.call(PactBroker::DB.connection, options) }
+      let(:latest_dev_selector) { PactBroker::Matrix::UnresolvedSelector.new(tag: "dev", latest: true) }
+      let(:all_prod_selector) { PactBroker::Matrix::UnresolvedSelector.new(tag: "prod") }
 
       describe ".call"do
         context "when there are specified versions to keep" do
           before do
             td.create_pact_with_hierarchy("Foo", "1", "Bar")
               .create_consumer_version_tag("prod")
-              .create_consumer_version_tag("master")
+              .create_consumer_version_tag("dev")
               .create_consumer_version("3", tag_names: %w{prod})
               .create_pact
-              .create_consumer_version("4", tag_names: %w{master})
+              .create_consumer_version("4", tag_names: %w{dev})
               .create_pact
-              .create_consumer_version("5", tag_names: %w{master})
+              .create_consumer_version("5", tag_names: %w{dev})
               .create_pact
               .create_consumer_version("6", tag_names: %w{foo})
               .create_pact
           end
 
-          let(:options) do
-            {
-              keep: [
-                PactBroker::Matrix::UnresolvedSelector.new(tag: "prod"),
-                PactBroker::Matrix::UnresolvedSelector.new(tag: "master", latest: true)
-              ]
-            }
-          end
+          let(:options) { { keep: [all_prod_selector, latest_dev_selector] } }
 
           it "does not delete the consumer versions specified" do
             expect(PactBroker::Domain::Version.where(number: "1").count).to be 1
@@ -51,6 +46,45 @@ module PactBroker
             expect(PactBroker::Domain::Version.where(number: "6").count).to be 0
           end
         end
+
+        context "with orphan pact versions" do
+          before do
+            # Create a pact that will not be deleted
+            td.create_pact_with_hierarchy("Foo", "0", "Bar", json_content_1)
+              .create_consumer_version_tag("dev")
+            # Create an orphan pact version
+            pact_version_params = PactBroker::Pacts::PactVersion.first.to_hash
+            pact_version_params.delete(:id)
+            pact_version_params[:sha] = "1234"
+            PactBroker::Pacts::PactVersion.create(pact_version_params)
+          end
+
+          let(:json_content_1) { { interactions: ['a', 'b']}.to_json }
+          let(:json_content_2) { { interactions: ['a', 'c']}.to_json }
+
+          let(:options) { { keep: [latest_dev_selector] } }
+
+          it "deletes them" do
+            expect { subject }.to change { PactBroker::Pacts::PactVersion.count }.by(-1)
+          end
+        end
+
+        context "with triggered and executed" do
+          before do
+            td.create_pact_with_hierarchy("Foo", "1", "Bar")
+              .create_consumer_version_tag("dev").comment("keep")
+              .create_webhook
+              .create_triggered_webhook
+              .create_webhook_execution
+              .add_day
+              .create_triggered_webhook
+              .create_webhook_execution
+          end
+
+          xit "deletes all but the most recent triggered webhook" do
+
+          end
+        end
       end
     end
   end

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

@@ -8,17 +8,16 @@ module PactBroker
     describe Service do
       let(:td) { TestDataBuilder.new }
       let(:tags) { ['prod', 'production'] }
-      let(:options) { { tags: tags, optimised: optimised, page_size: page_size, page_number: page_number } }
+      let(:options) { { tags: tags, page_size: page_size, page_number: page_number } }
       let(:page_number) { nil }
       let(:page_size) { nil }
       let(:rows) { subject.find_index_items(options) }
-      let(:optimised) { true }
 
       before do
         td.create_global_webhook
       end
 
-      subject{ Service }
+      subject { Service }
 
       describe "find_relationships integration test" do
         context "when a prod pact exists and is not the latest version" do

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

@@ -20,6 +20,42 @@ module PactBroker
           end
         end
 
+        context "when there are multiple wip pacts" do
+          before do
+            td.create_provider("bar")
+              .create_provider_version("333")
+              .create_provider_version_tag("dev")
+              .add_day
+              .create_pact_with_hierarchy("foo", "1", "bar")
+              .create_consumer_version_tag("feat-1")
+              .add_day
+              .create_pact_with_hierarchy("meep", "2", "bar")
+              .create_consumer_version_tag("feat-2")
+              .add_day
+              .create_pact_with_hierarchy("foo", "2", "bar")
+              .create_consumer_version_tag("feat-2")
+              .add_day
+              .create_pact_with_hierarchy("meep", "1", "bar")
+              .create_consumer_version_tag("feat-1")
+          end
+
+          let(:provider_tags) { %w[dev] }
+
+          it "sorts them" do
+            expect(subject[0].consumer_name).to eq "foo"
+            expect(subject[0].consumer_version_number).to eq "1"
+
+            expect(subject[1].consumer_name).to eq "foo"
+            expect(subject[1].consumer_version_number).to eq "2"
+
+            expect(subject[2].consumer_name).to eq "meep"
+            expect(subject[2].consumer_version_number).to eq "2"
+
+            expect(subject[3].consumer_name).to eq "meep"
+            expect(subject[3].consumer_version_number).to eq "1"
+          end
+        end
+
         context "when the latest pact for a tag has been successfully verified by the given provider tag" do
           before do
             td.create_pact_with_hierarchy("foo", "1", "bar")

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

@@ -39,6 +39,10 @@ module PactBroker
 
           subject { Repository.new.create pacticipant_id: existing_version.pacticipant_id, number: "1.2.4" }
 
+          it "creates a new version" do
+            expect { subject }.to change { PactBroker::Domain::Version.count }.by(1)
+          end
+
           it "sets the order to the previous version's order plus one" do
             expect(subject.order).to eq existing_version.order + 1
           end
@@ -49,6 +53,10 @@ module PactBroker
 
           subject { Repository.new.create pacticipant_id: existing_version.pacticipant_id, number: version_number }
 
+          it "does not create a new version" do
+            expect { subject }.to_not change { PactBroker::Domain::Version.count }
+          end
+
           it "returns the pre-existing version" do
             expect(subject.id).to eq existing_version.id
           end

data/spec/lib/rack/pact_broker/request_target_spec.rb

@@ -56,6 +56,13 @@ module Rack
 
           it { is_expected.to be false }
         end
+
+        context "when the request is for a badge resource with a svg content type" do
+          let(:accept) { "image/svg+xml;charset=utf-8" }
+          let(:path) { "/pacts/provider/foo/consumer/bar/latest/badge" }
+
+          it { is_expected.to be false }
+        end
       end
     end
   end

data/spec/lib/sequel/plugins/insert_ignore_spec.rb

@@ -0,0 +1,82 @@
+require 'sequel/plugins/insert_ignore'
+require 'sequel'
+
+module Sequel
+  module Plugins
+    module InsertIgnore
+      class PacticipantNoInsertIgnore < Sequel::Model(:pacticipants)
+        plugin :timestamps, update_on_create: true
+      end
+
+      class Pacticipant < Sequel::Model
+        plugin :insert_ignore, identifying_columns: [:name]
+        plugin :timestamps, update_on_create: true
+      end
+
+      class Version < Sequel::Model
+        plugin :insert_ignore, identifying_columns: [:pacticipant_id, :number]
+        plugin :timestamps, update_on_create: true
+      end
+
+      context "when a duplicate is inserted with no insert_ignore" do
+        before do
+          PacticipantNoInsertIgnore.new(name: "Foo").save
+        end
+
+        subject do
+          PacticipantNoInsertIgnore.new(name: "Foo").save
+        end
+
+        it "raises an error" do
+          expect { subject }.to raise_error Sequel::UniqueConstraintViolation
+        end
+      end
+
+      # This doesn't work on MSQL because the _insert_raw method
+      # does not return the row ID of the duplicated row when insert_ignore is used
+      # May have to go back to the old method of doing this
+      context "when a duplicate Pacticipant is inserted with insert_ignore" do
+        before do
+          Pacticipant.new(name: "Foo", repository_url: "http://foo").insert_ignore
+        end
+
+        subject do
+          Pacticipant.new(name: "Foo").insert_ignore
+        end
+
+        it "does not raise an error" do
+          expect { subject }.to_not raise_error
+        end
+
+        it "sets the values on the object" do
+          expect(subject.repository_url).to eq "http://foo"
+        end
+
+        it "does not insert another row" do
+          expect { subject }.to_not change { Pacticipant.count }
+        end
+      end
+
+      context "when a duplicate Version is inserted with insert_ignore" do
+        let!(:pacticipant) { Pacticipant.new(name: "Foo").save }
+        let!(:original_version) { Version.new(number: "1", pacticipant_id: pacticipant.id).insert_ignore }
+
+        subject do
+          Version.new(number: "1", pacticipant_id: pacticipant.id).insert_ignore
+        end
+
+        it "does not raise an error" do
+          expect { subject }.to_not raise_error
+        end
+
+        it "sets the values on the object" do
+          expect(subject.id).to eq original_version.id
+        end
+
+        it "does not insert another row" do
+          expect { subject }.to_not change { Version.count }
+        end
+      end
+    end
+  end
+end

data/spec/lib/sequel/plugins/upsert_spec.rb

@@ -0,0 +1,125 @@
+require 'sequel/plugins/upsert'
+require 'sequel'
+
+module Sequel
+  module Plugins
+    module Upsert
+      class PacticipantNoUpsert < Sequel::Model(:pacticipants)
+        plugin :timestamps, update_on_create: true
+      end
+
+      class Pacticipant < Sequel::Model
+        plugin :upsert, identifying_columns: [:name]
+        plugin :timestamps, update_on_create: true
+      end
+
+      class Version < Sequel::Model
+        plugin :upsert, identifying_columns: [:pacticipant_id, :number]
+        plugin :timestamps, update_on_create: true
+      end
+
+      class LatestPactPublicationIdForConsumerVersion < Sequel::Model(:latest_pact_publication_ids_for_consumer_versions)
+        set_primary_key [:provider_id, :consumer_version_id]
+        unrestrict_primary_key
+        plugin :upsert, identifying_columns: [:provider_id, :consumer_version_id]
+      end
+
+      describe "LatestPactPublicationIdForConsumerVersion" do
+        before do
+          td.create_pact_with_hierarchy("Foo", "1", "Bar")
+            .create_consumer_version("2")
+        end
+
+        let!(:new_pact_publication) do
+          pact_publication_values = PactBroker::Pacts::PactPublication.first.values.dup
+          pact_publication_values.delete(:id)
+          pact_publication_values.delete(:created_at)
+          pact_publication_values.delete(:updated_at)
+          pact_publication_values[:revision_number] = 2
+          PactBroker::Pacts::PactPublication.new(pact_publication_values).save
+        end
+
+        let(:new_latest_pact_publication_id_for_consumer_version) do
+          values = LatestPactPublicationIdForConsumerVersion.first.values
+          LatestPactPublicationIdForConsumerVersion.new(values.merge(pact_publication_id: new_pact_publication.id))
+        end
+
+        describe "save" do
+          subject { new_latest_pact_publication_id_for_consumer_version.save }
+
+          it "raises an error" do
+            expect { subject }.to raise_error Sequel::UniqueConstraintViolation
+          end
+        end
+
+        describe "upsert" do
+          subject { new_latest_pact_publication_id_for_consumer_version.upsert }
+
+          it "updates the new object with the values from the existing object" do
+            expect(subject.pact_publication_id).to eq new_pact_publication.id
+          end
+        end
+      end
+
+      context "when a duplicate is inserted with no upsert" do
+        before do
+          PacticipantNoUpsert.new(name: "Foo").save
+        end
+
+        subject do
+          PacticipantNoUpsert.new(name: "Foo").save
+        end
+
+        it "raises an error" do
+          expect { subject }.to raise_error Sequel::UniqueConstraintViolation
+        end
+      end
+
+      # This doesn't work on MSQL because the _insert_raw method
+      # does not return the row ID of the duplicated row when upsert is used
+      # May have to go back to the old method of doing this
+      context "when a duplicate Pacticipant is inserted with upsert" do
+        before do
+          Pacticipant.new(name: "Foo", repository_url: "http://foo").upsert
+        end
+
+        subject do
+          Pacticipant.new(name: "Foo", repository_url: "http://bar").upsert
+        end
+
+        it "does not raise an error" do
+          expect { subject }.to_not raise_error
+        end
+
+        it "sets the values on the object" do
+          expect(subject.repository_url).to eq "http://bar"
+        end
+
+        it "does not insert another row" do
+          expect { subject }.to_not change { Pacticipant.count }
+        end
+      end
+
+      context "when a duplicate Version is inserted with upsert" do
+        let!(:pacticipant) { Pacticipant.new(name: "Foo").save }
+        let!(:original_version) { Version.new(number: "1", pacticipant_id: pacticipant.id).upsert }
+
+        subject do
+          Version.new(number: "1", pacticipant_id: pacticipant.id).upsert
+        end
+
+        it "does not raise an error" do
+          expect { subject }.to_not raise_error
+        end
+
+        it "sets the values on the object" do
+          expect(subject.id).to eq original_version.id
+        end
+
+        it "does not insert another row" do
+          expect { subject }.to_not change { Version.count }
+        end
+      end
+    end
+  end
+end