pact_broker 2.15.0 → 2.16.0

data/spec/migrations/23_pact_versions_spec.rb

@@ -14,7 +14,7 @@ describe 'migrate to pact versions (migrate 22-31)', migration: true do
   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}) }
 
 
-  subject { PactBroker::Database.migrate(34) }
+  subject { PactBroker::Database.migrate }
 
   it "keeps the same number of pacts" do
     subject
@@ -65,7 +65,7 @@ describe 'migrate to pact versions (migrate 22-31)', migration: true do
     subject
 
     PactBroker::Pacts::Service.create_or_update_pact(
-      consumer_id: consumer[:id], provider_id: provider[:id], consumer_version_number: '1.2.3', json_content: load_fixture('a_consumer-a_provider.json')
+      consumer_name: consumer[:name], provider_name: provider[:name], consumer_version_number: '1.2.3', json_content: load_fixture('a_consumer-a_provider.json')
     )
   end
 end

data/spec/migrations/50_create_latest_matrix_spec.rb

@@ -1,6 +1,6 @@
 describe 'create latest matrix (latest pact revision/latest verification for provider version)', migration: true do
   before do
-    PactBroker::Database.migrate(50)
+    PactBroker::Database.migrate(20180129)
   end
 
   def shorten_row row
@@ -9,18 +9,24 @@ describe 'create latest matrix (latest pact revision/latest verification for pro
 
   let(:now) { DateTime.new(2018, 2, 2) }
   let!(:consumer) { create(:pacticipants, {name: 'C', created_at: now, updated_at: now}) }
-  let!(:provider) { create(:pacticipants, {name: 'P', created_at: now, updated_at: now}) }
+  let!(:provider_1) { create(:pacticipants, {name: 'P', created_at: now, updated_at: now}) }
+  let!(:provider_2) { create(:pacticipants, {name: 'Q', created_at: now, updated_at: now}) }
   let!(:consumer_version_1) { create(:versions, {number: '1', order: 1, pacticipant_id: consumer[:id], created_at: now, updated_at: now}) }
   let!(:consumer_version_2) { create(:versions, {number: '2', order: 2, pacticipant_id: consumer[:id], created_at: now, updated_at: now}) }
-  let!(:provider_version_1) { create(:versions, {number: '1', order: 1, pacticipant_id: provider[:id], created_at: now, updated_at: now}) }
-  let!(:provider_version_2) { create(:versions, {number: '2', order: 2, pacticipant_id: provider[:id], created_at: now, updated_at: now}) }
-  let!(:pact_version_1) { create(:pact_versions, {content: {some: 'json'}.to_json, sha: '1', consumer_id: consumer[:id], provider_id: provider[:id], created_at: now}) }
-  let!(:pact_version_2) { create(:pact_versions, {content: {some: 'json other'}.to_json, sha: '2', consumer_id: consumer[:id], provider_id: provider[:id], created_at: now}) }
-  let!(:pact_version_3) { create(:pact_versions, {content: {some: 'json more'}.to_json, sha: '3', consumer_id: consumer[:id], provider_id: provider[:id], created_at: now}) }
+  let!(:provider_1_version_1) { create(:versions, {number: '1', order: 1, pacticipant_id: provider_1[:id], created_at: now, updated_at: now}) }
+  let!(:provider_1_version_2) { create(:versions, {number: '2', order: 2, pacticipant_id: provider_1[:id], created_at: now, updated_at: now}) }
+  let!(:provider_2_version_1) { create(:versions, {number: '1', order: 1, pacticipant_id: provider_2[:id], created_at: now, updated_at: now}) }
+  let!(:provider_2_version_2) { create(:versions, {number: '2', order: 2, pacticipant_id: provider_2[:id], created_at: now, updated_at: now}) }
+
+  let!(:pact_version_1) { create(:pact_versions, {content: {some: 'json'}.to_json, sha: '1', consumer_id: consumer[:id], provider_id: provider_1[:id], created_at: now}) }
+  let!(:pact_version_2) { create(:pact_versions, {content: {some: 'json other'}.to_json, sha: '2', consumer_id: consumer[:id], provider_id: provider_1[:id], created_at: now}) }
+  let!(:pact_version_3) { create(:pact_versions, {content: {some: 'json more'}.to_json, sha: '3', consumer_id: consumer[:id], provider_id: provider_1[:id], created_at: now}) }
+  let!(:pact_version_4) { create(:pact_versions, {content: {some: 'json more blah'}.to_json, sha: '4', consumer_id: consumer[:id], provider_id: provider_2[:id], created_at: now}) }
+
   let!(:pact_publication_1) do
     create(:pact_publications, {
       consumer_version_id: consumer_version_1[:id],
-      provider_id: provider[:id],
+      provider_id: provider_1[:id],
       revision_number: 1,
       pact_version_id: pact_version_1[:id],
       created_at: now
@@ -30,7 +36,7 @@ describe 'create latest matrix (latest pact revision/latest verification for pro
   let!(:pact_publication_2) do
     create(:pact_publications, {
       consumer_version_id: consumer_version_1[:id],
-      provider_id: provider[:id],
+      provider_id: provider_1[:id],
       revision_number: 2,
       pact_version_id: pact_version_2[:id],
       created_at: now
@@ -41,19 +47,30 @@ describe 'create latest matrix (latest pact revision/latest verification for pro
   let!(:pact_publication_3) do
     create(:pact_publications, {
       consumer_version_id: consumer_version_2[:id],
-      provider_id: provider[:id],
+      provider_id: provider_1[:id],
       revision_number: 1,
       pact_version_id: pact_version_3[:id],
       created_at: now
     })
   end
 
+  # C2 Q1 (r1/n1)
+  let!(:pact_publication_4) do
+    create(:pact_publications, {
+      consumer_version_id: consumer_version_2[:id],
+      provider_id: provider_2[:id],
+      revision_number: 1,
+      pact_version_id: pact_version_4[:id],
+      created_at: now
+    })
+  end
+
   # C1 P3 (r1n3)
   let!(:verification_1) do
     create(:verifications, {
       number: 1,
       success: true,
-      provider_version_id: provider_version_1[:id],
+      provider_version_id: provider_1_version_1[:id],
       pact_version_id: pact_version_1[:id],
       execution_date: now,
       created_at: now
@@ -65,7 +82,7 @@ describe 'create latest matrix (latest pact revision/latest verification for pro
     create(:verifications, {
       number: 1,
       success: true,
-      provider_version_id: provider_version_1[:id],
+      provider_version_id: provider_1_version_1[:id],
       pact_version_id: pact_version_2[:id],
       execution_date: now,
       created_at: now
@@ -77,7 +94,7 @@ describe 'create latest matrix (latest pact revision/latest verification for pro
     create(:verifications, {
       number: 2,
       success: true,
-      provider_version_id: provider_version_1[:id],
+      provider_version_id: provider_1_version_1[:id],
       pact_version_id: pact_version_2[:id],
       execution_date: now,
       created_at: now
@@ -89,25 +106,76 @@ describe 'create latest matrix (latest pact revision/latest verification for pro
     create(:verifications, {
       number: 3,
       success: true,
-      provider_version_id: provider_version_2[:id],
+      provider_version_id: provider_1_version_2[:id],
       pact_version_id: pact_version_2[:id],
       execution_date: now,
       created_at: now
     })
   end
 
+  # include
+  # C1 Q1 (r1/n1)
+  let!(:verification_5) do
+    create(:verifications, {
+      number: 1,
+      success: true,
+      provider_version_id: provider_2_version_1[:id],
+      pact_version_id: pact_version_4[:id],
+      execution_date: now,
+      created_at: now
+    })
+  end
+
+  # include
+  # C1 Q2 (r1/n2)
+  let!(:verification_6) do
+    create(:verifications, {
+      number: 2,
+      success: true,
+      provider_version_id: provider_2_version_2[:id],
+      pact_version_id: pact_version_4[:id],
+      execution_date: now,
+      created_at: now
+    })
+  end
+
   # C1 P1 (r1/n1) this pact version is overwritten by r2
   # C1 P1 (r2/n1) this verification is overwritten by n2
   # C1 P1 (r2/n2)
   # C1 P2 (r2/n3)
   # C2 P? (r1/n?)
 
+  describe "matrix" do
+    it "includes every revision and every verification" do
+      rows = database[:matrix].order(:verification_id).all.collect{|row| shorten_row(row) }
+      expect(rows).to include "C1 P1 (r1/n1)"
+      expect(rows).to include "C1 P1 (r2/n1)"
+      expect(rows.count).to eq 7
+    end
+  end
+
   it "only includes the latest pact revisions and latest verifications" do
-    rows = database[:latest_matrix].order(:verification_id).all.collect{|row| shorten_row(row) }
+    rows = database[:latest_matrix_for_consumer_version_and_provider_version].order(:verification_id).all.collect{|row| shorten_row(row) }
     expect(rows).to include "C1 P1 (r2/n2)"
     expect(rows).to include "C1 P2 (r2/n3)"
     expect(rows).to include "C2 P? (r1/n?)"
+    expect(rows).to include "C2 Q1 (r1/n1)"
+    expect(rows).to include "C2 Q2 (r1/n2)"
+    expect(rows).to_not include "C1 P1 (r1/n1)"
     expect(rows).to_not include "C1 P1 (r2/n1)"
-    expect(database[:latest_matrix].count).to eq 3
+    expect(database[:latest_matrix_for_consumer_version_and_provider_version].count).to eq 5
+  end
+
+  describe "latest matrix" do
+    it "only includes the latest pact revisions and latest verifications for the latest consumer versions" do
+      rows = database[:latest_matrix].order(:verification_id).all.collect{|row| shorten_row(row) }
+      expect(rows).to include "C2 P? (r1/n?)"
+      expect(rows).to include "C2 Q2 (r1/n2)"
+      expect(rows).to_not include "C2 Q1 (r1/n1)" # not latest provider version
+      expect(rows).to_not include "C1 P1 (r2/n2)" # not latest consumer version
+      expect(rows).to_not include "C1 P2 (r2/n3)" # not latest consumer version
+      expect(rows).to_not include "C1 P1 (r2/n1)" # not latest consumer version
+      expect(database[:latest_matrix].count).to eq 2
+    end
   end
 end

data/spec/migrations/change_migration_strategy_spec.rb

@@ -45,7 +45,7 @@ describe "changing from integer to timestamp migrations", no_db_clean: true do
   it "allows data to be inserted" do
     consumer_id = @db[:pacticipants].insert(name: 'Foo', created_at: DateTime.now, updated_at: DateTime.now)
     provider_id = @db[:pacticipants].insert(name: 'Bar', created_at: DateTime.now, updated_at: DateTime.now)
-    version_id = @db[:versions].insert(number: '1.2.3', pacticipant_id: consumer_id, created_at: DateTime.now, updated_at: DateTime.now)
+    version_id = @db[:versions].insert(number: '1.2.3', order: 1, pacticipant_id: consumer_id, created_at: DateTime.now, updated_at: DateTime.now)
     pact_json = {consumer: {name: 'Foo'}, provider: {name: 'Bar'}, interactions: []}.to_json
     pact_version_id = @db[:pact_versions].insert(sha: '123', content: pact_json, created_at: DateTime.now, consumer_id: consumer_id, provider_id: provider_id)
     pact_publication_id = @db[:pact_publications].insert(consumer_version_id: version_id, provider_id: provider_id, revision_number: 1, pact_version_id: pact_version_id, created_at: DateTime.now)

data/spec/service_consumers/pact_helper.rb

@@ -10,7 +10,10 @@ require 'pact_broker'
 require 'pact_broker/app'
 
 require_relative 'hal_relation_proxy_app'
-require_relative 'provider_states_for_pact_broker_client'
+
+Dir.glob(File.join(File.dirname(__FILE__), "provider_states_for*.rb")).each do | path |
+  require path
+end
 
 pact_broker = PactBroker::App.new { |c| c.database_connection = DB::PACT_BROKER_DB }
 app_to_verify = HalRelationProxyApp.new(pact_broker)

data/spec/spec_helper.rb

@@ -15,6 +15,7 @@ PactBroker::DB.connection = PactBroker::Database.database = DB::PACT_BROKER_DB
 require 'rack/test'
 require 'pact_broker/api'
 require 'rspec/its'
+require 'rspec/pact/matchers'
 require 'sucker_punch/testing/inline'
 require 'webmock/rspec'
 

data/spec/support/migration_helpers.rb

@@ -3,7 +3,7 @@ require 'tasks/database'
 module MigrationHelpers
   def create table_name, params, id_column_name = :id
     database[table_name].insert(params);
-    database[table_name].order(id_column_name).last
+    database[table_name].order(id_column_name).last if id_column_name
   end
 
   def clean table_name

data/spec/support/rspec_match_hash.rb

@@ -8,8 +8,12 @@ end
 
 
 def contains_hash?(expected, actual)
-  expected.all? do |key, value|
-    unordered_match(actual[key], value)
+  if actual.is_a?(Array)
+    actual.any? && actual.any?{|actual_item| contains_hash?(expected, actual_item)}
+  else
+    expected.all? do |key, value|
+      unordered_match(actual[key], value)
+    end
   end
 end
 

data/spec/support/shared_examples_for_responses.rb

@@ -67,6 +67,6 @@ RSpec::Matchers.define :include_hash_matching do |expected|
   end
 
   def slice actual, keys
-    keys.each_with_object({}) { |k, hash| hash[k] = actual[k] if actual.has_key?(k) }
+    keys.each_with_object({}) { |k, hash| hash[k] = actual[k] if (actual.respond_to?(:has_key?) && actual.has_key?(k)) || actual.respond_to?(k)  }
   end
 end

data/spec/support/test_data_builder.rb

@@ -22,6 +22,7 @@ require 'pact_broker/verifications/service'
 require 'pact_broker/tags/repository'
 require 'pact_broker/webhooks/repository'
 require 'pact_broker/certificates/certificate'
+require 'pact_broker/matrix/row'
 require 'ostruct'
 
 class TestDataBuilder
@@ -37,6 +38,26 @@ class TestDataBuilder
   attr_reader :webhook
   attr_reader :webhook_execution
   attr_reader :triggered_webhook
+  attr_accessor :auto_refresh_matrix
+
+  def initialize(params = {})
+    @auto_refresh_matrix = params.fetch(:auto_refresh_matrix, true)
+  end
+
+  def comment *args
+    self
+  end
+
+  def refresh_matrix
+    if auto_refresh_matrix
+      params = {}
+      params[:consumer_name] = consumer.name if consumer
+      params[:provider_name] = provider.name if provider
+      matrix_service.refresh(params)
+      # Row is not used in production code, but the tests depend on it
+      PactBroker::Matrix::Row.refresh(params)
+    end
+  end
 
   def create_pricing_service
     @pricing_service_id = pacticipant_repository.create(:name => 'Pricing Service', :repository_url => 'git@git.realestate.com.au:business-systems/pricing-service').save(raise_on_save_failure: true).id
@@ -107,23 +128,27 @@ class TestDataBuilder
     PactBroker::Domain::Tag.create(name: tag_name, version: version)
   end
 
-  def create_pacticipant pacticipant_name
+  def create_pacticipant pacticipant_name, params = {}
+    params.delete(:comment)
     @pacticipant = PactBroker::Domain::Pacticipant.create(:name => pacticipant_name)
     self
   end
 
-  def create_consumer consumer_name = "Consumer #{model_counter}"
+  def create_consumer consumer_name = "Consumer #{model_counter}", params = {}
+    params.delete(:comment)
     create_pacticipant consumer_name
     @consumer = @pacticipant
     self
   end
 
-  def use_consumer consumer_name
+  def use_consumer consumer_name, params = {}
+    params.delete(:comment)
     @consumer = PactBroker::Domain::Pacticipant.find(:name => consumer_name)
     self
   end
 
-  def create_provider provider_name = "Provider #{model_counter}"
+  def create_provider provider_name = "Provider #{model_counter}", params = {}
+    params.delete(:comment)
     create_pacticipant provider_name
     @provider = @pacticipant
     self
@@ -134,17 +159,20 @@ class TestDataBuilder
     self
   end
 
-  def create_version version_number = "1.0.#{model_counter}"
+  def create_version version_number = "1.0.#{model_counter}", params = {}
+    params.delete(:comment)
     @version = PactBroker::Domain::Version.create(:number => version_number, :pacticipant => @pacticipant)
     self
   end
 
-  def create_consumer_version version_number = "1.0.#{model_counter}"
+  def create_consumer_version version_number = "1.0.#{model_counter}", params = {}
+    params.delete(:comment)
     @consumer_version = PactBroker::Domain::Version.create(:number => version_number, :pacticipant => @consumer)
     self
   end
 
-  def create_provider_version version_number = "1.0.#{model_counter}"
+  def create_provider_version version_number = "1.0.#{model_counter}", params = {}
+    params.delete(:comment)
     @version = PactBroker::Domain::Version.create(:number => version_number, :pacticipant => @provider)
     @provider_version = @version
     self
@@ -160,17 +188,20 @@ class TestDataBuilder
     self
   end
 
-  def create_tag tag_name
+  def create_tag tag_name, params = {}
+    params.delete(:comment)
     @tag = PactBroker::Domain::Tag.create(name: tag_name, version: @version)
     self
   end
 
-  def create_consumer_version_tag tag_name
+  def create_consumer_version_tag tag_name, params = {}
+    params.delete(:comment)
     @tag = PactBroker::Domain::Tag.create(name: tag_name, version: @consumer_version)
     self
   end
 
-  def create_provider_version_tag tag_name
+  def create_provider_version_tag tag_name, params = {}
+    params.delete(:comment)
     @tag = PactBroker::Domain::Tag.create(name: tag_name, version: @provider_version)
     self
   end
@@ -181,25 +212,31 @@ class TestDataBuilder
   end
 
   def create_pact params = {}
+    params.delete(:comment)
     @pact = PactBroker::Pacts::Repository.new.create({version_id: @consumer_version.id, consumer_id: @consumer.id, provider_id: @provider.id, json_content: params[:json_content] || default_json_content})
     set_created_at_if_set params[:created_at], :pact_publications, {id: @pact.id}
     set_created_at_if_set params[:created_at], :pact_versions, {sha: @pact.pact_version_sha}
     @pact = PactBroker::Pacts::PactPublication.find(id: @pact.id).to_domain
+    refresh_matrix
     self
   end
 
-  def create_same_pact params = {}
+  def republish_same_pact params = {}
+    params.delete(:comment)
     last_pact_version = PactBroker::Pacts::PactVersion.order(:id).last
     create_pact json_content: last_pact_version.content
+    self
   end
 
   def revise_pact json_content = nil
     json_content = json_content ? json_content : {random: rand}.to_json
     @pact = PactBroker::Pacts::Repository.new.update(@pact.id, json_content: json_content)
+    refresh_matrix
     self
   end
 
   def create_webhook params = {}
+    params.delete(:comment)
     uuid = params[:uuid] || PactBroker::Webhooks::Service.next_uuid
     event_params = params[:events] || [{ name: PactBroker::Webhooks::WebhookEvent::DEFAULT_EVENT_NAME }]
     events = event_params.collect{ |e| PactBroker::Webhooks::WebhookEvent.new(e) }
@@ -210,6 +247,7 @@ class TestDataBuilder
   end
 
   def create_triggered_webhook params = {}
+    params.delete(:comment)
     trigger_uuid = params[:trigger_uuid] || webhook_service.next_uuid
     @triggered_webhook = webhook_repository.create_triggered_webhook trigger_uuid, @webhook, @pact, PactBroker::Webhooks::Service::RESOURCE_CREATION
     @triggered_webhook.update(status: params[:status]) if params[:status]
@@ -218,6 +256,7 @@ class TestDataBuilder
   end
 
   def create_webhook_execution params = {}
+    params.delete(:comment)
     logs = params[:logs] || "logs"
     webhook_execution_result = PactBroker::Domain::WebhookExecutionResult.new(OpenStruct.new(code: "200"), logs, nil)
     @webhook_execution = PactBroker::Webhooks::Repository.new.create_execution @triggered_webhook, webhook_execution_result
@@ -228,6 +267,7 @@ class TestDataBuilder
   end
 
   def create_deprecated_webhook_execution params = {}
+    params.delete(:comment)
     create_webhook_execution params
     Sequel::Model.db[:webhook_executions].where(id: webhook_execution.id).update(
       triggered_webhook_id: nil,
@@ -240,16 +280,26 @@ class TestDataBuilder
   end
 
   def create_verification parameters = {}
+    parameters.delete(:comment)
+    tag_names = [parameters.delete(:tag_names), parameters.delete(:tag_name)].flatten.compact
     provider_version_number = parameters[:provider_version] || '4.5.6'
     default_parameters = {success: true, number: 1, test_results: {some: 'results'}}
     parameters = default_parameters.merge(parameters)
     parameters.delete(:provider_version)
     verification = PactBroker::Domain::Verification.new(parameters)
     @verification = PactBroker::Verifications::Repository.new.create(verification, provider_version_number, @pact)
+    if tag_names.any?
+      provider_version = PactBroker::Domain::Version.where(pacticipant_id: @provider.id, number: provider_version_number).single_record
+      tag_names.each do | tag_name |
+        PactBroker::Domain::Tag.create(name: tag_name, version: provider_version)
+      end
+    end
+    refresh_matrix
     self
   end
 
   def create_certificate options = {path: 'spec/fixtures/single-certificate.pem'}
+    options.delete(:comment)
     PactBroker::Certificates::Certificate.create(uuid: SecureRandom.urlsafe_base64, content: File.read(options[:path]))
     self
   end