pact_broker 1.18.0 → 2.0.0.beta.1

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

@@ -8,9 +8,11 @@ module PactBroker
 
         let(:consumer) { instance_double("PactBroker::Domain::Pacticipant", name: 'Consumer Name')}
         let(:provider) { instance_double("PactBroker::Domain::Pacticipant", name: 'Provider Name')}
-        let(:relationship) { PactBroker::Domain::Relationship.new(consumer, provider)}
+        let(:latest_pact) { instance_double("PactBroker::Domain::Pact") }
+        let(:latest_verification) { instance_double("PactBroker::Domain::Verification") }
+        let(:domain_relationship) { PactBroker::Domain::Relationship.new(consumer, provider, latest_pact, latest_verification)}
 
-        subject { Relationship.new(relationship) }
+        subject { Relationship.new(domain_relationship) }
 
         its(:consumer_name) { should eq 'Consumer Name'}
         its(:provider_name) { should eq 'Provider Name'}
@@ -18,6 +20,50 @@ module PactBroker
         its(:consumer_group_url) { should eq "/groups/Consumer%20Name" }
         its(:provider_group_url) { should eq "/groups/Provider%20Name" }
 
+        describe "verification_status" do
+          let(:domain_relationship) do
+            instance_double("PactBroker::Domain::Relationship",
+              ever_verified?: ever_verified,
+              pact_changed_since_last_verification?: pact_changed,
+              latest_verification_successful?: success,
+              provider_name: "Foo",
+              latest_verification_provider_version: "4.5.6")
+          end
+          let(:ever_verified) { true }
+          let(:pact_changed) { false }
+          let(:success) { true }
+
+          subject { Relationship.new(domain_relationship) }
+
+          context "when the pact has never been verified" do
+            let(:ever_verified) { false }
+            its(:verification_status) { is_expected.to eq "" }
+            its(:warning?) { is_expected.to be false }
+            its(:verification_tooltip) { is_expected.to eq nil }
+          end
+
+          context "when the pact has changed since the last successful verification" do
+            let(:pact_changed) { true }
+            its(:verification_status) { is_expected.to eq "warning" }
+            its(:warning?) { is_expected.to be true }
+            its(:verification_tooltip) { is_expected.to eq "Pact has changed since last successful verification by Foo (v4.5.6)" }
+          end
+
+          context "when the pact has not changed since the last successful verification" do
+            let(:pact_changed) { false }
+            its(:verification_status) { is_expected.to eq "success" }
+            its(:warning?) { is_expected.to be false }
+            its(:verification_tooltip) { is_expected.to eq "Successfully verified by Foo (v4.5.6)" }
+          end
+
+          context "when the pact verification failed" do
+            let(:success) { false }
+            its(:verification_status) { is_expected.to eq "danger" }
+            its(:warning?) { is_expected.to be false }
+            its(:verification_tooltip) { is_expected.to eq "Verification by Foo (v4.5.6) failed" }
+          end
+        end
+
         describe "<=>" do
 
           let(:relationship_model_4) { double("PactBroker::Domain::Relationship", consumer_name: "A", provider_name: "X") }

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

@@ -0,0 +1,92 @@
+require 'pact_broker/verifications/repository'
+
+module PactBroker
+  module Verifications
+    describe Repository do
+
+      describe "#verification_count_for_pact" do
+        let!(:pact_1) do
+          ProviderStateBuilder.new
+            .create_consumer("Consumer")
+            .create_provider("Provider")
+            .create_consumer_version("1.2.3")
+            .create_pact
+            .create_verification(number: 1)
+            .create_verification(number: 2)
+            .and_return(:pact)
+        end
+        let!(:pact_2) do
+          ProviderStateBuilder.new
+            .create_consumer("Foo")
+            .create_provider("Bar")
+            .create_consumer_version("4.5.6")
+            .create_pact
+            .create_verification(number: 1)
+            .and_return(:pact)
+        end
+
+        it "returns the number of verifications for the given pact" do
+          expect(Repository.new.verification_count_for_pact(pact_1)).to eq 2
+        end
+      end
+
+      describe "#find_latest_verifications_for_consumer_version" do
+        before do
+          ProviderStateBuilder.new
+            .create_provider("Provider1")
+            .create_consumer("Consumer1")
+            .create_consumer_version("1.0.0")
+            .create_pact
+            .create_verification(number: 1)
+            .create_consumer_version("1.2.3")
+            .create_pact
+            .create_verification(number: 1)
+            .create_verification(number: 2, provider_version: "7.8.9")
+            .create_provider("Provider2")
+            .create_pact
+            .create_verification(number: 1, provider_version: "6.5.4")
+
+            ProviderStateBuilder.new
+            .create_provider("Provider3")
+            .create_consumer("Consumer2")
+            .create_consumer_version("1.2.3")
+            .create_pact
+            .create_verification(number: 1)
+        end
+
+        let(:latest_verifications) { Repository.new.find_latest_verifications_for_consumer_version("Consumer1", "1.2.3")}
+
+        it "finds the latest verifications for the given consumer version" do
+          expect(latest_verifications.first.provider_version).to eq "7.8.9"
+          expect(latest_verifications.last.provider_version).to eq "6.5.4"
+        end
+      end
+
+      describe "#find_latest_verification_for" do
+        before do
+          ProviderStateBuilder.new
+            .create_provider("Provider1")
+            .create_consumer("Consumer1")
+            .create_consumer_version("1.2.3")
+            .create_pact
+            .create_verification(number: 1, provider_version: "2.3.4")
+            .create_verification(number: 2, provider_version: "7.8.9")
+            .create_consumer_version("1.0.0")
+            .create_pact
+            .create_verification(number: 1, provider_version: "5.4.3")
+            .create_provider("Provider2")
+            .create_pact
+            .create_verification(number: 1, provider_version: "6.5.4")
+            .create_consumer_version("2.0.0")
+            .create_pact
+        end
+
+        let(:latest_verification) { Repository.new.find_latest_verification_for("Consumer1", "Provider1")}
+
+        it "finds the latest verifications for the given consumer version" do
+          expect(latest_verification.provider_version).to eq "7.8.9"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+require 'pact_broker/verifications/service'
+require 'pact_broker/verifications/repository'
+
+module PactBroker
+
+  module Verifications
+    describe Service do
+
+      subject { PactBroker::Verifications::Service }
+
+      describe "#next_number_for" do
+
+        let(:pact) { double(:pact) }
+
+        before do
+          allow_any_instance_of(PactBroker::Verifications::Repository).to receive(:verification_count_for_pact).and_return(2)
+        end
+
+        it "returns the number for the next build to be recorded for a pact" do
+          expect(subject.next_number_for(pact)).to eq 3
+        end
+      end
+
+      describe "#create" do
+        let(:params) { {'success' => true, 'providerApplicationVersion' => '4.5.6'} }
+        let(:pact) { ProviderStateBuilder.new.create_pact_with_hierarchy }
+        let(:create_verification) { subject.create 3, params, pact }
+
+        it "logs the creation" do
+          allow(PactBroker.logger).to receive(:info).and_call_original
+          expect(PactBroker.logger).to receive(:info).with(/.*verification.*3.*success/)
+          create_verification
+        end
+
+        it "sets the verification attributes" do
+          verification = create_verification
+          expect(verification.success).to be true
+          expect(verification.number).to eq 3
+        end
+
+        it "sets the pact content for the verification" do
+          verification = create_verification
+          expect(verification.pact_version_id).to_not be_nil
+          expect(verification.pact_version.id).to eq pact.id
+        end
+      end
+
+      describe "#errors" do
+        let(:params) { {} }
+
+        it "returns errors" do
+          expect(subject.errors(params)).to_not be_empty
+        end
+
+        it "returns something that responds to :messages" do
+          expect(subject.errors(params).messages).to_not be_empty
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+require 'spec_helper'
+require 'pact_broker/versions/parse_semantic_version'
+
+module PactBroker
+  module Versions
+    describe ParseSemanticVersion do
+
+      describe ".call" do
+        context "when parsing a semantic version" do
+
+          subject { ParseSemanticVersion.call("1.2.3") }
+
+          it "returns the version" do
+            expect(subject.major).to eq 1
+            expect(subject.minor).to eq 2
+            expect(subject.to_s).to eq "1.2.3"
+          end
+
+          it "returns a comparable version" do
+            expect(subject).to be > ParseSemanticVersion.call("1.2.2")
+            expect(subject).to be == ParseSemanticVersion.call("1.2.3")
+            expect(subject).to be < ParseSemanticVersion.call("1.3.1")
+          end
+
+          it "returns nil when version is invalid" do
+            expect(ParseSemanticVersion.call("abc")).to be_nil
+            expect(ParseSemanticVersion.call("1")).to be_nil
+            expect(ParseSemanticVersion.call("1.2")).to be_nil
+          end
+
+          it "accepts semver metadata" do
+            expect(ParseSemanticVersion.call("1.2.3+abc.234")).not_to be_nil
+          end
+        end
+      end
+
+    end
+  end
+end

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

@@ -1,7 +1,5 @@
 require 'spec_helper'
 require 'pact_broker/webhooks/service'
-require 'webmock/rspec'
-require 'sucker_punch/testing/inline'
 
 module PactBroker
 
@@ -14,11 +12,11 @@ module PactBroker
         let(:consumer_version) { PactBroker::Domain::Version.new(number: '1.2.3') }
         let(:consumer) { PactBroker::Domain::Pacticipant.new(name: 'Consumer') }
         let(:provider) { PactBroker::Domain::Pacticipant.new(name: 'Provider') }
-        let(:webhooks) { [instance_double(PactBroker::Domain::Webhook, description: 'description', uuid: '1244')]}
+        let(:webhooks) { [instance_double(PactBroker::Domain::Webhook)]}
 
         before do
           allow_any_instance_of(PactBroker::Webhooks::Repository).to receive(:find_by_consumer_and_provider).and_return(webhooks)
-          allow(Job).to receive(:perform_async)
+          allow(Service).to receive(:run_later)
         end
 
         subject { Service.execute_webhooks pact }
@@ -47,42 +45,7 @@ module PactBroker
             subject
           end
         end
-
-        context "when there is a scheduling error" do
-          before do
-            allow(Job).to receive(:perform_async).and_raise("an error")
-          end
-
-          it "logs the error" do
-            allow(Service.logger).to receive(:error)
-            expect(Service.logger).to receive(:error).with(/an error/)
-            subject
-          end
-        end
-      end
-
-      describe ".execute_webhooks integration test" do
-        let!(:http_request) do
-          stub_request(:get, "http://example.org").
-            to_return(:status => 200)
-        end
-
-        let(:pact) do
-          ProviderStateBuilder.new
-            .create_consumer
-            .create_provider
-            .create_consumer_version
-            .create_pact
-            .create_webhook(method: 'GET', url: 'http://example.org')
-            .and_return(:pact)
-        end
-
-
-        it "executes the HTTP request of the webhook" do
-          PactBroker::Webhooks::Service.execute_webhooks pact
-          expect(http_request).to have_been_made
-        end
       end
     end
   end
-end
+end

data/spec/migrations/23_pact_versions_spec.rb

@@ -0,0 +1,95 @@
+require 'tasks/database'
+
+describe 'migrate to pact versions (migrate 22-31)', no_db_clean: :true do
+
+  def create table_name, params, id_column_name = :id
+    database[table_name].insert(params);
+    database[table_name].order(id_column_name).last
+  end
+
+  def clean table_name
+    database[table_name].delete rescue puts "Error cleaning #{table_name} #{$!}"
+  end
+
+  def new_connection
+    Sequel::DATABASES.clear
+    DB.connection_for_env 'test'
+  end
+
+  let(:database) { new_connection }
+
+  before do
+    PactBroker::Database.delete_database_file
+    PactBroker::Database.ensure_database_dir_exists
+    database = new_connection
+    PactBroker::Database.migrate(22)
+  end
+
+  let(:now) { DateTime.new(2017, 1, 1) }
+  let(:pact_updated_at) { DateTime.new(2017, 1, 2) }
+  let!(:consumer) { create(:pacticipants, {name: 'Consumer', created_at: now, updated_at: now}) }
+  let!(:provider) { create(:pacticipants, {name: 'Provider', created_at: now, updated_at: now}) }
+  let!(:consumer_version_1) { create(:versions, {number: '1.2.3', order: 1, pacticipant_id: consumer[:id], created_at: now, updated_at: now}) }
+  let!(:consumer_version_2) { create(:versions, {number: '4.5.6', order: 2, pacticipant_id: consumer[:id], created_at: now, updated_at: now}) }
+  let!(:pact_version_content) { create(:pact_version_contents, {content: {some: 'json'}.to_json, sha: '1234', created_at: now, updated_at: now}, :sha) }
+  let!(:pact_1) { create(:pacts, {version_id: consumer_version_1[:id], provider_id: provider[:id], pact_version_content_sha: '1234', created_at: now, updated_at: pact_updated_at}) }
+  let!(:pact_2) { create(:pacts, {version_id: consumer_version_2[:id], provider_id: provider[:id], pact_version_content_sha: '1234', created_at: now, updated_at: pact_updated_at}) }
+
+
+  let(:do_migration) do
+    PactBroker::Database.migrate(34)
+  end
+
+  it "keeps the same number of pacts" do
+    do_migration
+    expect(database[:latest_pact_publications_by_consumer_versions].count).to eq 2
+  end
+
+  it "uses the old updated date for the new creation date" do
+    do_migration
+    # expect(new_connection[:latest_pact_publications_by_consumer_versions].order(:id).first[:created_at]).to eq pact_updated_at
+    expect(database[:latest_pact_publications_by_consumer_versions].order(:id).first[:created_at]).to eq pact_updated_at
+  end
+
+  it "sets each revision number to 1" do
+    do_migration
+    expect(database[:latest_pact_publications_by_consumer_versions].order(:id).first[:revision_number]).to eq 1
+    expect(database[:latest_pact_publications_by_consumer_versions].order(:id).last[:revision_number]).to eq 1
+  end
+
+  it "migrates the values correctly for the first pact" do
+
+    old_all_pact = database[:all_pacts].order(:id).first
+    old_all_pact.delete(:updated_at)
+    old_all_pact.delete(:created_at)
+    old_all_pact.delete(:created_at)
+    old_all_pact[:pact_version_sha] = old_all_pact.delete(:pact_version_content_sha)
+    do_migration
+    database[:latest_pact_publications_by_consumer_versions]
+    new_all_pact = database[:latest_pact_publications_by_consumer_versions].order(:id).first
+    new_all_pact.delete(:created_at)
+    new_all_pact.delete(:revision_number)
+    new_all_pact.delete(:pact_version_id)
+    expect(new_all_pact).to eq old_all_pact
+  end
+
+  it "migrates the values correctly for the second pact" do
+    old_all_pact = database[:all_pacts].order(:id).last
+    old_all_pact.delete(:updated_at)
+    old_all_pact.delete(:created_at)
+    old_all_pact[:pact_version_sha] = old_all_pact.delete(:pact_version_content_sha)
+    do_migration
+    new_all_pact = database[:latest_pact_publications_by_consumer_versions].order(:id).last
+    new_all_pact.delete(:created_at)
+    new_all_pact.delete(:revision_number)
+    new_all_pact.delete(:pact_version_id)
+    expect(new_all_pact).to eq old_all_pact
+  end
+
+  after do
+    PactBroker::Database.delete_database_file
+    PactBroker::Database.ensure_database_dir_exists
+    database = new_connection
+    PactBroker::Database.migrate
+  end
+end

data/spec/migrations/24_populate_pact_contents_spec.rb

@@ -0,0 +1,48 @@
+require 'tasks/database'
+
+describe 'migrate to pact versions (migrate 22-24)', no_db_clean: :true do
+
+  def create table_name, params, id_column_name = :id
+    database[table_name].insert(params);
+    database[table_name].order(id_column_name).last
+  end
+
+  def new_connection
+    DB.connection_for_env 'test'
+  end
+
+  let(:database) { new_connection }
+
+  before do
+    PactBroker::Database.delete_database_file
+    PactBroker::Database.ensure_database_dir_exists
+    database = new_connection
+    PactBroker::Database.migrate(22)
+  end
+
+  let(:now) { DateTime.new(2017, 1, 1) }
+  let(:pact_updated_at) { DateTime.new(2017, 1, 2) }
+  let!(:consumer) { create(:pacticipants, {name: 'Consumer', created_at: now, updated_at: now}) }
+  let!(:provider) { create(:pacticipants, {name: 'Provider', created_at: now, updated_at: now}) }
+  let!(:consumer_version) { create(:versions, {number: '1.2.3', order: 1, pacticipant_id: consumer[:id], created_at: now, updated_at: now}) }
+  let!(:pact_version_content) { create(:pact_version_contents, {content: {some: 'json'}.to_json, sha: '1234', created_at: now, updated_at: now}, :sha) }
+  let!(:pact_1) { create(:pacts, {version_id: consumer_version[:id], provider_id: provider[:id], pact_version_content_sha: '1234', created_at: now, updated_at: pact_updated_at}) }
+
+  let!(:pact_version_content_orphan) { create(:pact_version_contents, {content: {some: 'json'}.to_json, sha: '4567', created_at: now, updated_at: now}, :sha) }
+
+  let(:do_migration) do
+    PactBroker::Database.migrate(34)
+  end
+
+  it "deletes orphan pact_versions" do
+    do_migration
+    expect(database[:pact_versions].count).to eq 1
+  end
+
+  after do
+    PactBroker::Database.delete_database_file
+    PactBroker::Database.ensure_database_dir_exists
+    database = new_connection
+    PactBroker::Database.migrate
+  end
+end