class PactBroker::Verifications::Repository

Public Instance Methods

any_verifications?(consumer, provider) click to toggle source
# File lib/pact_broker/verifications/repository.rb, line 67
def any_verifications?(consumer, provider)
  PactBroker::Domain::Verification.where(consumer_id: consumer.id, provider_id: provider.id).any?
end
create(verification, provider_version_number, pact_version) click to toggle source
# File lib/pact_broker/verifications/repository.rb, line 21
def create verification, provider_version_number, pact_version
  version = version_repository.find_by_pacticipant_id_and_number_or_create(pact_version.provider_id, provider_version_number)
  verification.pact_version_id = pact_version.id
  verification.provider_version = version
  verification.provider_id = pact_version.provider_id
  verification.consumer_id = pact_version.consumer_id
  verification.tag_names = version.tag_names # TODO pass this in from contracts service
  verification.save
  update_latest_verification_id(verification)
  verification
end
delete(verification_id) click to toggle source
# File lib/pact_broker/verifications/repository.rb, line 33
def delete(verification_id)
  PactBroker::Domain::Verification.where(id: verification_id).delete
end
delete_all_verifications_between(consumer_name, options) click to toggle source
# File lib/pact_broker/verifications/repository.rb, line 150
def delete_all_verifications_between(consumer_name, options)
  consumer = pacticipant_repository.find_by_name!(consumer_name)
  provider = pacticipant_repository.find_by_name!(options.fetch(:and))
  PactBroker::Domain::Verification.where(provider: provider, consumer: consumer).delete
end
delete_by_provider_version_id(version_id) click to toggle source
# File lib/pact_broker/verifications/repository.rb, line 146
def delete_by_provider_version_id version_id
  PactBroker::Domain::Verification.where(provider_version_id: version_id).delete
end
find(consumer_name, provider_name, pact_version_sha, verification_number) click to toggle source
# File lib/pact_broker/verifications/repository.rb, line 49
def find consumer_name, provider_name, pact_version_sha, verification_number
  PactBroker::Domain::Verification
    .select_all_qualified
    .join(:all_pact_publications, pact_version_id: :pact_version_id)
    .consumer(consumer_name)
    .provider(provider_name)
    .pact_version_sha(pact_version_sha)
    .verification_number(verification_number).single_record
end
find_latest_for_pact(pact) click to toggle source
# File lib/pact_broker/verifications/repository.rb, line 59
def find_latest_for_pact(pact)
  PactBroker::Pacts::PactPublication.where(id: pact.id).single_record.latest_verification
end
find_latest_from_main_branch_for_pact(pact) click to toggle source
# File lib/pact_broker/verifications/repository.rb, line 63
def find_latest_from_main_branch_for_pact(pact)
  PactBroker::Pacts::PactPublication.where(id: pact.id).single_record.latest_main_branch_verification
end
find_latest_verification_for(consumer_name, provider_name, consumer_version_tag = nil) click to toggle source

The most recent verification for the latest revision of the pact belonging to the version with the largest consumer_version_order.

# File lib/pact_broker/verifications/repository.rb, line 94
def find_latest_verification_for consumer_name, provider_name, consumer_version_tag = nil
  consumer = pacticipant_repository.find_by_name!(consumer_name)
  provider = pacticipant_repository.find_by_name!(provider_name)
  join_cols = {
    Sequel[:lp][:pact_version_id] => Sequel[:verifications][:pact_version_id],
    Sequel[:lp][:consumer_id] => consumer.id,
    Sequel[:lp][:provider_id] => provider.id
  }
  query = PactBroker::Domain::Verification
    .select_all_qualified
    .join(:latest_verification_ids_for_pact_versions, { Sequel[:verifications][:id] => Sequel[:lv][:latest_verification_id] }, { table_alias: :lv })
    .join(:latest_pact_publication_ids_for_consumer_versions, join_cols, { table_alias: :lp })
    .join(:versions, { Sequel[:cv][:id] => Sequel[:lp][:consumer_version_id] }, { table_alias: :cv })
  if consumer_version_tag == :untagged
    query = query.left_outer_join(:tags, { Sequel[:cv][:id] => Sequel[:tags][:version_id] })
                  .where(Sequel[:tags][:name] => nil)
  elsif consumer_version_tag
    query = query.join(:tags, { Sequel[:cv][:id] => Sequel[:tags][:version_id], Sequel[:tags][:name] => consumer_version_tag })
  end
  query.reverse_order(
    Sequel[:cv][:order],
    Sequel[:verifications][:number]
  ).limit(1).single_record
end
find_latest_verification_for_tags(consumer_name, provider_name, consumer_version_tag, provider_version_tag) click to toggle source
# File lib/pact_broker/verifications/repository.rb, line 119
def find_latest_verification_for_tags consumer_name, provider_name, consumer_version_tag, provider_version_tag
  view_name = PactBroker::Domain::Verification.table_name
  consumer = pacticipant_repository.find_by_name!(consumer_name)
  provider = pacticipant_repository.find_by_name!(provider_name)

  consumer_tag_filter = PactBroker::Repositories::Helpers.name_like(Sequel.qualify(:consumer_tags, :name), consumer_version_tag)
  provider_tag_filter = PactBroker::Repositories::Helpers.name_like(Sequel.qualify(:provider_tags, :name), provider_version_tag)

  query = PactBroker::Domain::Verification
    .select_all_qualified
    .join(:versions, { Sequel[:provider_versions][:id] => Sequel[view_name][:provider_version_id] }, { table_alias: :provider_versions })
    .join(:latest_verification_id_for_pact_version_and_provider_version, { Sequel[:lv][:verification_id] => Sequel[view_name][:id] }, { table_alias: :lv })
    .join(:latest_pact_publication_ids_for_consumer_versions, { Sequel[view_name][:pact_version_id] => Sequel[:lp][:pact_version_id] }, { table_alias: :lp })
    .join(:versions, { Sequel[:consumer_versions][:id] => Sequel[:lp][:consumer_version_id] }, { table_alias: :consumer_versions })
    .join(:tags, { Sequel[:consumer_tags][:version_id] => Sequel[:lp][:consumer_version_id]}, { table_alias: :consumer_tags })
    .join(:tags, { Sequel[:provider_tags][:version_id] => Sequel[view_name][:provider_version_id]}, { table_alias: :provider_tags })
    .where(consumer: consumer, provider: provider)
    .where(consumer_tag_filter)
    .where(provider_tag_filter)

  query.reverse_order(
    Sequel[:consumer_versions][:order],
    Sequel[:provider_versions][:order],
    Sequel[view_name][:execution_date]
  ).limit(1).single_record
end
find_latest_verifications_for_consumer_version(consumer_name, consumer_version_number) click to toggle source
# File lib/pact_broker/verifications/repository.rb, line 78
def find_latest_verifications_for_consumer_version consumer_name, consumer_version_number
  # Use remove_verifications_for_overridden_consumer_versions because we don't
  # want verifications for shadowed revisions as it would be misleading.
  PactBroker::Domain::Verification
    .select_all_qualified
    .remove_verifications_for_overridden_consumer_versions
    .for_consumer_name_and_consumer_version_number(consumer_name, consumer_version_number)
    .latest_by_pact_version
    .eager(:provider)
    .all
    .sort_by { | v | v.provider_name.downcase }
end
next_number() click to toggle source

Ideally this would just be a sequence, but Sqlite and MySQL don't support sequences in the way we need to use them ie. determining what the next number will be before we create the record, because Webmachine wants to set the URL of the resource that is about to be created before we actually create it.

# File lib/pact_broker/verifications/repository.rb, line 17
def next_number
  Sequence.next_val
end
search_for_latest(consumer_name, provider_name) click to toggle source
# File lib/pact_broker/verifications/repository.rb, line 71
def search_for_latest consumer_name, provider_name
  query = PactBroker::Domain::Verification.select_all_qualified
  query = query.for_consumer_name(consumer_name) if consumer_name
  query = query.for_provider_name(provider_name) if provider_name
  query.reverse(:execution_date, :id).first
end
update_latest_verification_id(verification) click to toggle source
# File lib/pact_broker/verifications/repository.rb, line 37
def update_latest_verification_id verification
  params = {
    pact_version_id: verification.pact_version_id,
    provider_version_id: verification.provider_version_id,
    provider_id: verification.provider_version.pacticipant_id,
    verification_id: verification.id,
    consumer_id: verification.consumer_id,
    created_at: verification.created_at
  }
  LatestVerificationIdForPactVersionAndProviderVersion.new(params).upsert
end