Class: PactBroker::Pacts::Repository

Inherits:
Object
  • Object
show all
Includes:
Logging, Repositories
Defined in:
lib/pact_broker/pacts/repository.rb

Instance Method Summary collapse

Methods included from Repositories

#label_repository, #matrix_repository, #pact_repository, #pacticipant_repository, #tag_repository, #verification_repository, #version_repository, #webhook_repository

Methods included from Logging

included, #log_error

Instance Method Details

#create(params) ⇒ Object 



24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/pact_broker/pacts/repository.rb', line 24

def create params
  pact_version = find_or_create_pact_version(
    params.fetch(:consumer_id),
    params.fetch(:provider_id),
    params.fetch(:pact_version_sha),
    params.fetch(:json_content)
  )
  pact_publication = PactPublication.new(
    consumer_version_id: params[:version_id],
    provider_id: params[:provider_id],
    consumer_id: params[:consumer_id],
    pact_version: pact_version,
    revision_number: 1
  ).upsert
  update_latest_pact_publication_ids(pact_publication)
  pact_publication.to_domain
end

#delete(params) ⇒ Object 



83
84
85
86
87
88
89
90
 
# File 'lib/pact_broker/pacts/repository.rb', line 83

def delete params
  id = AllPactPublications
    .consumer(params.consumer_name)
    .provider(params.provider_name)
    .consumer_version_number(params.consumer_version_number)
    .select_for_subquery(:id)
  PactPublication.where(id: id).delete
end

#delete_all_pact_publications_between(consumer_name, options) ⇒ Object 



103
104
105
106
107
108
109
110
111
112
 
# File 'lib/pact_broker/pacts/repository.rb', line 103

def delete_all_pact_publications_between consumer_name, options
  consumer = pacticipant_repository.find_by_name(consumer_name)
  provider = pacticipant_repository.find_by_name(options.fetch(:and))
  query = PactPublication.where(consumer: consumer, provider: provider)
  query = query.tag(options[:tag]) if options[:tag]

  ids = query.select_for_subquery(:id)
  webhook_repository.delete_triggered_webhooks_by_pact_publication_ids(ids)
  PactPublication.where(id: ids).delete
end

#delete_all_pact_versions_between(consumer_name, options) ⇒ Object 



114
115
116
117
118
 
# File 'lib/pact_broker/pacts/repository.rb', line 114

def delete_all_pact_versions_between consumer_name, options
  consumer = pacticipant_repository.find_by_name(consumer_name)
  provider = pacticipant_repository.find_by_name(options.fetch(:and))
  PactVersion.where(consumer: consumer, provider: provider).delete
end

#delete_by_version_id(version_id) ⇒ Object 



92
93
94
 
# File 'lib/pact_broker/pacts/repository.rb', line 92

def delete_by_version_id version_id
  Sequel::Model.db[:pact_publications].where(consumer_version_id: version_id).delete
end

#find_all_pact_versions_between(consumer_name, options) ⇒ Object 



96
97
98
99
100
101
 
# File 'lib/pact_broker/pacts/repository.rb', line 96

def find_all_pact_versions_between consumer_name, options
  find_all_database_versions_between(consumer_name, options)
    .eager(:tags)
    .reverse_order(:consumer_version_order)
    .collect(&:to_domain)
end

#find_all_revisions(consumer_name, consumer_version, provider_name) ⇒ Object 



235
236
237
238
239
240
241
 
# File 'lib/pact_broker/pacts/repository.rb', line 235

def find_all_revisions consumer_name, consumer_version, provider_name
  AllPactPublications
    .consumer(consumer_name)
    .provider(provider_name)
    .consumer_version_number(consumer_version)
    .order(:consumer_version_order, :revision_number).collect(&:to_domain_with_content)
end

#find_by_consumer_version(consumer_name, consumer_version_number) ⇒ Object

Returns latest pact version for the consumer_version_number



173
174
175
176
177
178
 
# File 'lib/pact_broker/pacts/repository.rb', line 173

def find_by_consumer_version consumer_name, consumer_version_number
  LatestPactPublicationsByConsumerVersion
    .consumer(consumer_name)
    .consumer_version_number(consumer_version_number)
    .collect(&:to_domain_with_content)
end

#find_by_version_and_provider(version_id, provider_id) ⇒ Object 



180
181
182
183
184
185
 
# File 'lib/pact_broker/pacts/repository.rb', line 180

def find_by_version_and_provider version_id, provider_id
  LatestPactPublicationsByConsumerVersion
    .eager(:tags)
    .where(consumer_version_id: version_id, provider_id: provider_id)
    .limit(1).collect(&:to_domain_with_content)[0]
end

#find_for_verification(provider_name, consumer_version_selectors) ⇒ Object

Returns a list of Domain::Pact objects the represent pact publications



288
289
290
291
292
293
 
# File 'lib/pact_broker/pacts/repository.rb', line 288

def find_for_verification(provider_name, consumer_version_selectors)
  latest_tags = consumer_version_selectors.any? ?
    consumer_version_selectors.select(&:latest).collect(&:tag) :
    nil
  find_latest_pact_versions_for_provider(provider_name, latest_tags)
end

#find_latest_pact(consumer_name, provider_name, tag = nil) ⇒ Object 



191
192
193
194
195
196
197
198
199
200
201
202
 
# File 'lib/pact_broker/pacts/repository.rb', line 191

def find_latest_pact(consumer_name, provider_name, tag = nil)
  query = LatestPactPublicationsByConsumerVersion
    .select_all_qualified
    .consumer(consumer_name)
    .provider(provider_name)
  if tag == :untagged
    query = query.untagged
  elsif tag
    query = query.tag(tag)
  end
  query.latest.all.collect(&:to_domain_with_content)[0]
end

#find_latest_pact_versions_for_provider(provider_name, tag = nil) ⇒ Object 



120
121
122
123
124
125
126
 
# File 'lib/pact_broker/pacts/repository.rb', line 120

def find_latest_pact_versions_for_provider provider_name, tag = nil
  if tag
    LatestTaggedPactPublications.provider(provider_name).order_ignore_case(:consumer_name).where(tag_name: tag).collect(&:to_domain)
  else
    LatestPactPublications.provider(provider_name).order_ignore_case(:consumer_name).collect(&:to_domain)
  end
end

#find_latest_pacts ⇒ Object 



187
188
189
 
# File 'lib/pact_broker/pacts/repository.rb', line 187

def find_latest_pacts
  LatestPactPublications.order(:consumer_name, :provider_name).collect(&:to_domain)
end

#find_next_pact(pact) ⇒ Object 



259
260
261
262
263
264
265
266
 
# File 'lib/pact_broker/pacts/repository.rb', line 259

def find_next_pact pact
  LatestPactPublicationsByConsumerVersion
    .eager(:tags)
    .consumer(pact.consumer.name)
    .provider(pact.provider.name)
    .consumer_version_order_after(pact.consumer_version.order)
    .earliest.collect(&:to_domain_with_content)[0]
end

#find_pact(consumer_name, consumer_version, provider_name, pact_version_sha = nil) ⇒ Object 



218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
 
# File 'lib/pact_broker/pacts/repository.rb', line 218

def find_pact consumer_name, consumer_version, provider_name, pact_version_sha = nil
  query = if pact_version_sha
    AllPactPublications
      .pact_version_sha(pact_version_sha)
      .reverse_order(:consumer_version_order)
      .limit(1)
  else
    LatestPactPublicationsByConsumerVersion
  end
  query = query
    .eager(:tags)
    .consumer(consumer_name)
    .provider(provider_name)
  query = query.consumer_version_number(consumer_version) if consumer_version
  query.collect(&:to_domain_with_content)[0]
end

#find_pact_versions_for_provider(provider_name, tag = nil) ⇒ Object 



154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
 
# File 'lib/pact_broker/pacts/repository.rb', line 154

def find_pact_versions_for_provider provider_name, tag = nil
  if tag
    LatestPactPublicationsByConsumerVersion
      .join(:tags, {version_id: :consumer_version_id})
      .provider(provider_name)
      .order_ignore_case(:consumer_name)
      .order_append(:consumer_version_order)
      .where(Sequel[:tags][:name] => tag)
      .collect(&:to_domain)
  else
    LatestPactPublicationsByConsumerVersion
      .provider(provider_name)
      .order_ignore_case(:consumer_name)
      .order_append(:consumer_version_order)
      .collect(&:to_domain)
  end
end

#find_previous_distinct_pact(pact) ⇒ Object 



268
269
270
271
272
273
274
275
 
# File 'lib/pact_broker/pacts/repository.rb', line 268

def find_previous_distinct_pact pact
  previous, current = nil, pact
  loop do
    previous = find_previous_distinct_pact_by_sha current
    return previous if previous.nil? || different?(current, previous)
    current = previous
  end
end

#find_previous_pact(pact, tag = nil) ⇒ Object 



243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
 
# File 'lib/pact_broker/pacts/repository.rb', line 243

def find_previous_pact pact, tag = nil
  query = LatestPactPublicationsByConsumerVersion
      .eager(:tags)
      .consumer(pact.consumer.name)
      .provider(pact.provider.name)

  if tag == :untagged
    query = query.untagged
  elsif tag
    query = query.tag(tag)
  end

  query.consumer_version_order_before(pact.consumer_version.order)
      .latest.collect(&:to_domain_with_content)[0]
end

#find_previous_pacts(pact) ⇒ Object 



277
278
279
280
281
282
283
284
285
 
# File 'lib/pact_broker/pacts/repository.rb', line 277

def find_previous_pacts pact
  if pact.consumer_version_tag_names.any?
    pact.consumer_version_tag_names.each_with_object({}) do |tag, tags_to_pacts|
      tags_to_pacts[tag] = find_previous_pact(pact, tag)
    end
  else
    { :untagged => find_previous_pact(pact, :untagged) }
  end
end

#find_wip_pact_versions_for_provider(provider_name, provider_tags = []) ⇒ Object 



128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
 
# File 'lib/pact_broker/pacts/repository.rb', line 128

def find_wip_pact_versions_for_provider provider_name, provider_tags = []
  return [] if provider_tags.empty?
  successfully_verified_pact_publication_ids_for_each_tag = provider_tags.collect do | provider_tag |
    ids = LatestTaggedPactPublications
      .join(:verifications, { pact_version_id: :pact_version_id })
      .join(:tags, { Sequel[:verifications][:provider_version_id] => Sequel[:provider_tags][:version_id] }, {table_alias: :provider_tags})
      .where(Sequel[:provider_tags][:name] => provider_tag)
      .provider(provider_name)
      .where(Sequel[:verifications][:success] => true)
      .select(Sequel[:latest_tagged_pact_publications][:id].as(:id))
      .collect(&:id)
    [provider_tag, ids]
  end

  successfully_verified_pact_publication_ids_for_all_tags = successfully_verified_pact_publication_ids_for_each_tag.collect(&:last).reduce(:&)
  pact_publication_ids = LatestTaggedPactPublications.provider(provider_name).exclude(id: successfully_verified_pact_publication_ids_for_all_tags).select_for_subquery(:id)

  pacts = AllPactPublications.where(id: pact_publication_ids).order_ignore_case(:consumer_name).order_append(:consumer_version_order).collect(&:to_domain)
  pacts.collect do | pact|
    pending_tags = successfully_verified_pact_publication_ids_for_each_tag.select do | (provider_tag, pact_publication_ids) |
     !pact_publication_ids.include?(pact.id)
    end.collect(&:first)
    VerifiablePact.new(pact, true, pending_tags, [], pact.consumer_version_tag_names)
  end
end

#next_revision_number(existing_model) ⇒ Object

This logic is a separate method so we can stub it to create a “conflict” scenario



67
68
69
 
# File 'lib/pact_broker/pacts/repository.rb', line 67

def next_revision_number(existing_model)
  existing_model.revision_number + 1
end

#search_for_latest_pact(consumer_name, provider_name, tag = nil) ⇒ Object

Allows optional consumer_name and provider_name



205
206
207
208
209
210
211
212
213
214
215
216
 
# File 'lib/pact_broker/pacts/repository.rb', line 205

def search_for_latest_pact(consumer_name, provider_name, tag = nil)
  query = LatestPactPublicationsByConsumerVersion.select_all_qualified
  query = query.consumer(consumer_name) if consumer_name
  query = query.provider(provider_name) if provider_name

  if tag == :untagged
    query = query.untagged
  elsif tag
    query = query.tag(tag)
  end
  query.latest.all.collect(&:to_domain_with_content)[0]
end

#update(id, params) ⇒ Object 



42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/pact_broker/pacts/repository.rb', line 42

def update id, params
  existing_model = PactPublication.find(id: id)
  pact_version = find_or_create_pact_version(
    existing_model.consumer_version.pacticipant_id,
    existing_model.provider_id,
    params.fetch(:pact_version_sha),
    params.fetch(:json_content)
  )
  if existing_model.pact_version_id != pact_version.id
    pact_publication = PactPublication.new(
      consumer_version_id: existing_model.consumer_version_id,
      provider_id: existing_model.provider_id,
      revision_number: next_revision_number(existing_model),
      consumer_id: existing_model.consumer_id,
      pact_version_id: pact_version.id,
      created_at: Sequel.datetime_class.now
    ).upsert
    update_latest_pact_publication_ids(pact_publication)
    pact_publication.to_domain
  else
    existing_model.to_domain
  end
end

#update_latest_pact_publication_ids(pact_publication) ⇒ Object 



71
72
73
74
75
76
77
78
79
80
81
 
# File 'lib/pact_broker/pacts/repository.rb', line 71

def update_latest_pact_publication_ids(pact_publication)
  params = {
    consumer_version_id: pact_publication.consumer_version_id,
    provider_id: pact_publication.provider_id,
    pact_publication_id: pact_publication.id,
    consumer_id: pact_publication.consumer_id,
    pact_version_id: pact_publication.pact_version_id
  }

  LatestPactPublicationIdForConsumerVersion.new(params).upsert
end