Class: PactBroker::Test::TestDataBuilder

Inherits:
Object
  • Object
show all
Includes:
Repositories, Services
Defined in:
lib/pact_broker/test/test_data_builder.rb

Constant Summary

Constants included from Services

Services::FACTORIES

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Services

#badge_service, #branch_service, #certificate_service, #contract_service, #deployed_version_service, #environment_service, #get, #group_service, #index_service, #integration_service, #label_service, #matrix_service, #metrics_service, #pact_service, #pacticipant_service, #register_default_services, #register_service, #released_version_service, #tag_service, #verification_service, #version_service, #webhook_service, #webhook_trigger_service

Methods included from Repositories

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

Constructor Details

#initialize(_params = {}) ⇒ TestDataBuilder

Returns a new instance of TestDataBuilder.



61
62
63
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 61

def initialize(_params = {})
  @now = DateTime.now
end

Instance Attribute Details

#consumer ⇒ Object (readonly)

Returns the value of attribute consumer.



46
47
48
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 46

def consumer
  @consumer
end

#consumer_version ⇒ Object (readonly)

Returns the value of attribute consumer_version.



48
49
50
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 48

def consumer_version
  @consumer_version
end

#deployed_version ⇒ Object (readonly)

Returns the value of attribute deployed_version.



58
59
60
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 58

def deployed_version
  @deployed_version
end

#environment ⇒ Object (readonly)

Returns the value of attribute environment.



57
58
59
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 57

def environment
  @environment
end

#pact ⇒ Object (readonly)

Returns the value of attribute pact.



51
52
53
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 51

def pact
  @pact
end

#pact_version ⇒ Object (readonly)

Returns the value of attribute pact_version.



52
53
54
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 52

def pact_version
  @pact_version
end

#pacticipant ⇒ Object (readonly)

Returns the value of attribute pacticipant.



45
46
47
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 45

def pacticipant
  @pacticipant
end

#provider ⇒ Object (readonly)

Returns the value of attribute provider.



47
48
49
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 47

def provider
  @provider
end

#provider_version ⇒ Object (readonly)

Returns the value of attribute provider_version.



49
50
51
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 49

def provider_version
  @provider_version
end

#released_version ⇒ Object (readonly)

Returns the value of attribute released_version.



59
60
61
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 59

def released_version
  @released_version
end

#triggered_webhook ⇒ Object (readonly)

Returns the value of attribute triggered_webhook.



56
57
58
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 56

def triggered_webhook
  @triggered_webhook
end

#verification ⇒ Object (readonly)

Returns the value of attribute verification.



53
54
55
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 53

def verification
  @verification
end

#version ⇒ Object (readonly)

Returns the value of attribute version.



50
51
52
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 50

def version
  @version
end

#webhook ⇒ Object (readonly)

Returns the value of attribute webhook.



54
55
56
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 54

def webhook
  @webhook
end

#webhook_execution ⇒ Object (readonly)

Returns the value of attribute webhook_execution.



55
56
57
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 55

def webhook_execution
  @webhook_execution
end

Instance Method Details

#add_day ⇒ Object 



515
516
517
518
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 515

def add_day
  @now = @now + 1
  self
end

#add_days(days = 1) ⇒ Object 



520
521
522
523
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 520

def add_days(days = 1)
  @now = @now + days
  self
end

#add_five_minutes ⇒ Object 



540
541
542
543
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 540

def add_five_minutes
  @now = @now + (1.0/(24*60)*5)
  self
end

#add_minute ⇒ Object 



535
536
537
538
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 535

def add_minute
  @now = @now + (1.0/(24*60))
  self
end

#and_return(instance_variable_name) ⇒ Object 



501
502
503
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 501

def and_return instance_variable_name
  instance_variable_get("@#{instance_variable_name}")
end

#comment(*_args) ⇒ Object 



65
66
67
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 65

def comment *_args
  self
end

#create_certificate(options = {path: "spec/fixtures/single-certificate.pem"}) ⇒ Object 



421
422
423
424
425
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 421

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

#create_condor ⇒ Object 



84
85
86
87
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 84

def create_condor
  create_consumer("Condor")
  self
end

#create_consumer(consumer_name = "Consumer #{model_counter}", params = {}) ⇒ Object 



142
143
144
145
146
147
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 142

def create_consumer consumer_name = "Consumer #{model_counter}", params = {}
  params.delete(:comment)
  create_pacticipant consumer_name, params
  @consumer = @pacticipant
  self
end

#create_consumer_version(version_number = "1.0.#{model_counter}", params = {}) ⇒ Object 



177
178
179
180
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 177

def create_consumer_version version_number = "1.0.#{model_counter}", params = {}
  @consumer_version = create_pacticipant_version(version_number, consumer, params)
  self
end

#create_consumer_version_tag(tag_name, params = {}) ⇒ Object 



204
205
206
207
208
209
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 204

def create_consumer_version_tag tag_name, params = {}
  params.delete(:comment)
  @tag = PactBroker::Domain::Tag.create(name: tag_name, version: @consumer_version)
  set_created_at_if_set params[:created_at], :tags, { name: @tag.name, version_id: @tag.version_id }
  self
end

#create_consumer_webhook(parameters = {}) ⇒ Object 



362
363
364
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 362

def create_consumer_webhook parameters = {}
  create_webhook(parameters.merge(provider: nil))
end

#create_contract_email_service ⇒ Object 



79
80
81
82
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 79

def create_contract_email_service
  create_consumer("Contract Email Service", :repository_url => "[email protected]:business-systems/contract-email-service")
  self
end

#create_contract_proposal_service ⇒ Object 



74
75
76
77
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 74

def create_contract_proposal_service
  create_provider("Contract Proposal Service", :repository_url => "[email protected]:business-systems/contract-proposal-service")
  self
end

#create_deployed_version_for_consumer_version(uuid: SecureRandom.uuid, currently_deployed: true, environment_name: environment&.name, target: nil, created_at: nil) ⇒ Object 



437
438
439
440
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 437

def create_deployed_version_for_consumer_version(uuid: SecureRandom.uuid, currently_deployed: true, environment_name: environment&.name, target: nil, created_at: nil)
  create_deployed_version(uuid: uuid, currently_deployed: currently_deployed, version: consumer_version, environment_name: environment_name, target: target, created_at: created_at)
  self
end

#create_deployed_version_for_provider_version(uuid: SecureRandom.uuid, currently_deployed: true, environment_name: environment&.name, target: nil, created_at: nil) ⇒ Object 



442
443
444
445
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 442

def create_deployed_version_for_provider_version(uuid: SecureRandom.uuid, currently_deployed: true, environment_name: environment&.name, target: nil, created_at: nil)
  create_deployed_version(uuid: uuid, currently_deployed: currently_deployed, version: provider_version, environment_name: environment_name, target: target, created_at: created_at)
  self
end

#create_environment(name, params = {}) ⇒ Object 



427
428
429
430
431
432
433
434
435
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 427

def create_environment(name, params = {})
  uuid = params[:uuid] || PactBroker::Deployments::EnvironmentService.next_uuid
  production = params[:production] || false
  display_name = params[:display_name] || name.camelcase(true)
  the_params = params.merge(name: name, production: production, display_name: display_name)
  @environment = PactBroker::Deployments::EnvironmentService.create(uuid, PactBroker::Deployments::Environment.new(the_params))
  set_created_at_if_set(params[:created_at], :environments, id: environment.id)
  self
end

#create_everything_for_an_integration ⇒ Object 



458
459
460
461
462
463
464
465
466
467
468
469
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 458

def create_everything_for_an_integration
  create_pact_with_verification("Foo", "1", "Bar", "2")
    .create_label("label")
    .create_consumer_version_tag("master")
    .create_provider_version_tag("master")
    .create_webhook
    .create_triggered_webhook
    .create_webhook_execution
    .create_environment("test")
    .create_deployed_version_for_consumer_version
    .create_released_version_for_consumer_version
end

#create_global_contract_content_changed_webhook(parameters = {}) ⇒ Object 



342
343
344
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 342

def create_global_contract_content_changed_webhook parameters = {}
  create_webhook(parameters.merge(consumer: nil, provider: nil, event_names: [PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED]))
end

#create_global_contract_published_webhook(parameters = {}) ⇒ Object 



338
339
340
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 338

def create_global_contract_published_webhook parameters = {}
  create_webhook(parameters.merge(consumer: nil, provider: nil, event_names: [PactBroker::Webhooks::WebhookEvent::CONTRACT_PUBLISHED]))
end

#create_global_verification_failed_webhook(parameters = {}) ⇒ Object 



354
355
356
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 354

def create_global_verification_failed_webhook parameters = {}
  create_webhook(parameters.merge(consumer: nil, provider: nil, event_names: [PactBroker::Webhooks::WebhookEvent::VERIFICATION_FAILED]))
end

#create_global_verification_succeeded_webhook(parameters = {}) ⇒ Object 



350
351
352
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 350

def create_global_verification_succeeded_webhook parameters = {}
  create_webhook(parameters.merge(consumer: nil, provider: nil, event_names: [PactBroker::Webhooks::WebhookEvent::VERIFICATION_SUCCEEDED]))
end

#create_global_verification_webhook(parameters = {}) ⇒ Object 



346
347
348
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 346

def create_global_verification_webhook parameters = {}
  create_webhook(parameters.merge(consumer: nil, provider: nil, event_names: [PactBroker::Webhooks::WebhookEvent::VERIFICATION_PUBLISHED]))
end

#create_global_webhook(parameters = {}) ⇒ Object 



334
335
336
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 334

def create_global_webhook parameters = {}
  create_webhook(parameters.merge(consumer: nil, provider: nil))
end

#create_integration ⇒ Object 



162
163
164
165
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 162

def create_integration
  PactBroker::Integrations::Repository.new.create_for_pact(consumer.id, provider.id)
  self
end

#create_label(label_name) ⇒ Object 



218
219
220
221
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 218

def create_label label_name
  @label = PactBroker::Domain::Label.create(name: label_name, pacticipant: @pacticipant)
  self
end

#create_pact(params = {}) ⇒ Object 



244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 244

def create_pact params = {}
  params.delete(:comment)
  json_content = params[:json_content] || default_json_content
  pact_version_sha = params[:pact_version_sha] || generate_pact_version_sha(json_content)
  pact_versions_count_before = PactBroker::Pacts::PactVersion.count
  @pact = PactBroker::Pacts::Repository.new.create(
    version_id: @consumer_version.id,
    consumer_id: @consumer.id,
    provider_id: @provider.id,
    pact_version_sha: pact_version_sha,
    json_content: prepare_json_content(json_content),
    version: @consumer_version
  )
  pact_versions_count_after = PactBroker::Pacts::PactVersion.count
  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) if pact_versions_count_after > pact_versions_count_before
  set_created_at_if_set(params[:created_at], :latest_pact_publication_ids_for_consumer_versions, consumer_version_id: @consumer_version.id)
  @pact = PactBroker::Pacts::PactPublication.find(id: @pact.id).to_domain
  consumer_version.reload
  consumer_version.pact_publications.each{ | pp | pp.allow_lazy_load if pp.respond_to?(:allow_lazy_load) }
  self
end

#create_pact_version_without_publication(json_content = nil) ⇒ Object 



288
289
290
291
292
293
294
295
296
297
298
299
300
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 288

def create_pact_version_without_publication(json_content = nil )
  json_content = json_content ? json_content : {random: rand}.to_json
  pact_version_sha = generate_pact_version_sha(json_content)

  @pact_version = PactBroker::Pacts::PactVersion.new(
    consumer_id: consumer.id,
    provider_id: provider.id,
    sha: pact_version_sha,
    content: json_content,
    created_at: Sequel.datetime_class.now
  ).save
  self
end

#create_pact_with_consumer_version_tag(consumer_name, consumer_version_number, consumer_version_tag_name, provider_name) ⇒ Object 



100
101
102
103
104
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 100

def create_pact_with_consumer_version_tag consumer_name, consumer_version_number, consumer_version_tag_name, provider_name
  create_pact_with_hierarchy(consumer_name, consumer_version_number, provider_name)
  create_consumer_version_tag(consumer_version_tag_name)
  self
end

#create_pact_with_different_content(params = {}) ⇒ Object 



267
268
269
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 267

def create_pact_with_different_content params = {}
  create_pact(params.merge(json_content: random_json_content(consumer.name, provider.name)))
end

#create_pact_with_hierarchy(consumer_name = "Consumer", consumer_version_number = "1.2.3", provider_name = "Provider", json_content = nil) ⇒ Object 



89
90
91
92
93
94
95
96
97
98
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 89

def create_pact_with_hierarchy consumer_name = "Consumer", consumer_version_number = "1.2.3", provider_name = "Provider", json_content = nil
  use_consumer(consumer_name)
  create_consumer(consumer_name) if !consumer
  use_provider(provider_name)
  create_provider provider_name if !provider
  use_consumer_version(consumer_version_number)
  create_consumer_version(consumer_version_number) if !consumer_version
  create_pact json_content: json_content || default_json_content
  self
end

#create_pact_with_verification(consumer_name = "Consumer", consumer_version = "1.0.#{model_counter}", provider_name = "Provider", provider_version = "1.0.#{model_counter}", success = true) ⇒ Object 



106
107
108
109
110
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 106

def create_pact_with_verification consumer_name = "Consumer", consumer_version = "1.0.#{model_counter}", provider_name = "Provider", provider_version = "1.0.#{model_counter}", success = true
  create_pact_with_hierarchy(consumer_name, consumer_version, provider_name)
  create_verification(number: model_counter, provider_version: provider_version, success: success)
  self
end

#create_pact_with_verification_and_tags(consumer_name = "Consumer", consumer_version = "1.0.#{model_counter}", consumer_version_tags = [], provider_name = "Provider", provider_version = "1.0.#{model_counter}", provider_version_tags = []) ⇒ Object 



112
113
114
115
116
117
118
119
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 112

def create_pact_with_verification_and_tags consumer_name = "Consumer", consumer_version = "1.0.#{model_counter}", consumer_version_tags = [], provider_name = "Provider", provider_version = "1.0.#{model_counter}", provider_version_tags = []
  create_pact_with_hierarchy(consumer_name, consumer_version, provider_name)
  consumer_version_tags.each do | tag |
    create_consumer_version_tag(tag)
  end
  create_verification(number: model_counter, provider_version: provider_version, tag_names: provider_version_tags)
  self
end

#create_pacticipant(pacticipant_name, params = {}) ⇒ Object 



134
135
136
137
138
139
140
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 134

def create_pacticipant pacticipant_name, params = {}
  params.delete(:comment)
  repository_url = "https://github.com/#{params[:repository_namespace] || "example-organization"}/#{params[:repository_name] || pacticipant_name}"
  merged_params = { name: pacticipant_name, repository_url: repository_url }.merge(params)
  @pacticipant = PactBroker::Domain::Pacticipant.create(merged_params)
  self
end

#create_pricing_service ⇒ Object 



69
70
71
72
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 69

def create_pricing_service
  create_provider("Pricing Service", :repository_url => "[email protected]:business-systems/pricing-service")
  self
end

#create_provider(provider_name = "Provider #{model_counter}", params = {}) ⇒ Object 



155
156
157
158
159
160
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 155

def create_provider provider_name = "Provider #{model_counter}", params = {}
  params.delete(:comment)
  create_pacticipant provider_name, params
  @provider = @pacticipant
  self
end

#create_provider_version(version_number = "1.0.#{model_counter}", params = {}) ⇒ Object 



182
183
184
185
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 182

def create_provider_version version_number = "1.0.#{model_counter}", params = {}
  @provider_version = create_pacticipant_version(version_number, provider, params)
  self
end

#create_provider_version_tag(tag_name, params = {}) ⇒ Object 



211
212
213
214
215
216
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 211

def create_provider_version_tag tag_name, params = {}
  params.delete(:comment)
  @tag = PactBroker::Domain::Tag.create(name: tag_name, version: @provider_version)
  set_created_at_if_set params[:created_at], :tags, { name: @tag.name, version_id: @tag.version_id }
  self
end

#create_provider_webhook(parameters = {}) ⇒ Object 



358
359
360
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 358

def create_provider_webhook parameters = {}
  create_webhook(parameters.merge(consumer: nil))
end

#create_released_version_for_consumer_version(uuid: SecureRandom.uuid, currently_supported: true, environment_name: environment&.name, created_at: nil) ⇒ Object 



447
448
449
450
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 447

def create_released_version_for_consumer_version(uuid: SecureRandom.uuid, currently_supported: true, environment_name: environment&.name, created_at: nil)
  create_released_version(uuid: uuid, currently_supported: currently_supported, version: consumer_version, environment_name: environment_name, created_at: created_at)
  self
end

#create_released_version_for_provider_version(uuid: SecureRandom.uuid, currently_supported: true, environment_name: environment&.name, created_at: nil) ⇒ Object 



452
453
454
455
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 452

def create_released_version_for_provider_version(uuid: SecureRandom.uuid, currently_supported: true, environment_name: environment&.name, created_at: nil)
  create_released_version(uuid: uuid, currently_supported: currently_supported, version: provider_version, environment_name: environment_name, created_at: created_at)
  self
end

#create_tag(tag_name, params = {}) ⇒ Object 



197
198
199
200
201
202
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 197

def create_tag tag_name, params = {}
  params.delete(:comment)
  @tag = PactBroker::Domain::Tag.create(name: tag_name, version: @version, version_order: @version.order, pacticipant_id: @version.pacticipant_id)
  set_created_at_if_set params[:created_at], :tags, { name: @tag.name, version_id: @tag.version_id }
  self
end

#create_tag_with_hierarchy(pacticipant_name, pacticipant_version, tag_name) ⇒ Object 



128
129
130
131
132
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 128

def create_tag_with_hierarchy pacticipant_name, pacticipant_version, tag_name
  create_version_with_hierarchy pacticipant_name, pacticipant_version
  PactBroker::Domain::Tag.create(name: tag_name, version: @version)
  self
end

#create_triggered_webhook(params = {}) ⇒ Object 



366
367
368
369
370
371
372
373
374
375
376
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 366

def create_triggered_webhook params = {}
  params.delete(:comment)
  uuid = params[:uuid] || webhook_service.next_uuid
  event_name = params.key?(:event_name) ? params[:event_name] : @webhook.events.first.name # could be nil, for backwards compatibility
  verification = @webhook.trigger_on_provider_verification_published? ? @verification : nil
  event_context = params[:event_context]
  @triggered_webhook = webhook_repository.create_triggered_webhook(uuid, @webhook, @pact, verification, PactBroker::Webhooks::TriggerService::RESOURCE_CREATION, event_name, event_context)
  @triggered_webhook.update(status: params[:status]) if params[:status]
  set_created_at_if_set params[:created_at], :triggered_webhooks, { id: @triggered_webhook.id }
  self
end

#create_verification(parameters = {}) ⇒ Object 



389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 389

def create_verification parameters = {}
  # This should use the verification service. what a mess
  parameters.delete(:comment)
  branch = parameters.delete(:branch)
  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" }, wip: false }
  default_parameters[:execution_date] = @now if @now
  parameters = default_parameters.merge(parameters)
  parameters.delete(:provider_version)
  verification = PactBroker::Domain::Verification.new(parameters)
  pact_version = PactBroker::Pacts::Repository.new.find_pact_version(@consumer, @provider, pact.pact_version_sha)
  @provider_version = version_repository.find_by_pacticipant_id_and_number_or_create(provider.id, provider_version_number)
  PactBroker::Versions::BranchVersionRepository.new.add_branch(@provider_version, branch) if branch

  if tag_names.any?
    tag_names.each do | tag_name |
      PactBroker::Domain::Tag.new(name: tag_name, version: @provider_version, version_order: @provider_version.order).insert_ignore
      set_created_at_if_set(parameters[:created_at], :tags, version_id: @provider_version.id, name: tag_name)
    end
  end

  @verification = PactBroker::Verifications::Repository.new.create(verification, provider_version_number, pact_version)

  set_created_at_if_set(parameters[:created_at], :verifications, id: @verification.id)
  set_created_at_if_set(parameters[:created_at], :versions, id: @provider_version.id)
  set_created_at_if_set(parameters[:created_at], :latest_verification_id_for_pact_version_and_provider_version, pact_version_id: pact_version_id, provider_version_id: @provider_version.id)
  set_created_at_if_set(parameters[:created_at], :pact_version_provider_tag_successful_verifications, { verification_id: @verification.id }, :execution_date)

  self
end

#create_verification_webhook(parameters = {}) ⇒ Object

rubocop: enable Metrics/CyclomaticComplexity



330
331
332
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 330

def create_verification_webhook parameters = {}
  create_webhook(parameters.merge(event_names: [PactBroker::Webhooks::WebhookEvent::VERIFICATION_PUBLISHED]))
end

#create_version(version_number = "1.0.#{model_counter}", params = {}) ⇒ Object 



172
173
174
175
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 172

def create_version version_number = "1.0.#{model_counter}", params = {}
  @version = create_pacticipant_version(version_number, pacticipant, params)
  self
end

#create_version_with_hierarchy(pacticipant_name, pacticipant_version) ⇒ Object 



121
122
123
124
125
126
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 121

def create_version_with_hierarchy pacticipant_name, pacticipant_version
  pacticipant = pacticipant_service.create(:name => pacticipant_name)
  version = PactBroker::Domain::Version.create(:number => pacticipant_version, :pacticipant => pacticipant)
  @version = PactBroker::Domain::Version.find(id: version.id) # Get version with populated order
  self
end

#create_webhook(parameters = {}) ⇒ Object 



302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 302

def create_webhook parameters = {}
  params = parameters.dup
  consumer, webhook_consumer = webhook_pacticipant(:consumer, params)
  provider, webhook_provider = webhook_pacticipant(:provider, params)
  uuid = params[:uuid] || PactBroker::Webhooks::Service.next_uuid
  enabled = params.key?(:enabled) ? params.delete(:enabled) : true
  event_params = if params[:event_names]
                   params[:event_names].collect{ |event_name| {name: event_name} }
                 else
                   params[:events] || [{ name: PactBroker::Webhooks::WebhookEvent::DEFAULT_EVENT_NAME }]
                 end
  events = event_params.collect{ |e| PactBroker::Webhooks::WebhookEvent.new(e) }
  template_params = { method: "POST", url: "http://example.org", headers: {"Content-Type" => "application/json"}, username: params[:username], password: params[:password] }
  request = PactBroker::Webhooks::WebhookRequestTemplate.new(template_params.merge(params))
  new_webhook = PactBroker::Domain::Webhook.new(
    request: request,
    events: events,
    description: params[:description],
    enabled: enabled,
    consumer: webhook_consumer,
    provider: webhook_provider
  )
  @webhook = PactBroker::Webhooks::Repository.new.create uuid, new_webhook, consumer, provider
  set_created_at_if_set(params[:created_at], :webhooks, uuid: @webhook.uuid)
  self
end

#create_webhook_execution(params = {}) ⇒ Object 



378
379
380
381
382
383
384
385
386
387
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 378

def create_webhook_execution params = {}
  params.delete(:comment)
  logs = params[:logs] || "logs"
  webhook_execution_result = PactBroker::Webhooks::WebhookExecutionResult.new(nil, OpenStruct.new(code: "200"), true, logs, nil)
  @webhook_execution = PactBroker::Webhooks::Repository.new.create_execution @triggered_webhook, webhook_execution_result
  created_at = params[:created_at] || @pact.created_at + Rational(1, 86400)
  set_created_at_if_set created_at, :webhook_executions, {id: @webhook_execution.id}
  @webhook_execution = PactBroker::Webhooks::Execution.find(id: @webhook_execution.id)
  self
end

#find_environment(environment_name) ⇒ Object 



491
492
493
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 491

def find_environment(environment_name)
  PactBroker::Deployments::EnvironmentService.find_by_name(environment_name)
end

#find_pact(consumer_name, consumer_version_number, provider_name) ⇒ Object 



479
480
481
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 479

def find_pact(consumer_name, consumer_version_number, provider_name)
  pact_repository.find_pact(consumer_name, consumer_version_number, provider_name)
end

#find_pact_publication(consumer_name, consumer_version_number, provider_name) ⇒ Object 



483
484
485
486
487
488
489
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 483

def find_pact_publication(consumer_name, consumer_version_number, provider_name)
  PactBroker::Pacts::PactPublication
    .remove_overridden_revisions
    .where(provider: find_pacticipant(provider_name))
    .where(consumer_version: find_version(consumer_name, consumer_version_number))
    .single_record
end

#find_pacticipant(name) ⇒ Object 



471
472
473
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 471

def find_pacticipant(name)
  PactBroker::Domain::Pacticipant.where(name: name).single_record
end

#find_version(pacticipant_name, version_number) ⇒ Object 



475
476
477
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 475

def find_version(pacticipant_name, version_number)
  PactBroker::Domain::Version.for(pacticipant_name, version_number)
end

#in_utc ⇒ Object 



545
546
547
548
549
550
551
552
553
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 545

def in_utc
  original_tz = ENV["TZ"]
  begin
    ENV["TZ"] = "UTC"
    yield
  ensure
    ENV["TZ"] = original_tz
  end
end

#model_counter ⇒ Object 



495
496
497
498
499
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 495

def model_counter
  @@model_counter ||= 0
  @@model_counter += 1
  @@model_counter
end

#publish_pact(consumer_name:, provider_name:, consumer_version_number:, tags: nil, branch: nil, build_url: nil, json_content: nil) ⇒ Object 



223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 223

def publish_pact(consumer_name:, provider_name:, consumer_version_number: , tags: nil, branch: nil, build_url: nil, json_content: nil)
  json_content = json_content || random_json_content(consumer_name, provider_name)
  contracts = [
    PactBroker::Contracts::ContractToPublish.from_hash(consumer_name: consumer_name, provider_name: provider_name, decoded_content: json_content, content_type: "application/json", specification: "pact")
  ]
  contracts_to_publish = PactBroker::Contracts::ContractsToPublish.from_hash(
    pacticipant_name: consumer_name,
    pacticipant_version_number: consumer_version_number,
    tags: tags,
    branch: branch,
    build_url: build_url,
    contracts: contracts
  )
  PactBroker::Contracts::Service.publish(contracts_to_publish, base_url: "http://example.org")
  @consumer = find_pacticipant(consumer_name)
  @consumer_version = find_version(consumer_name, consumer_version_number)
  @provider = find_pacticipant(provider_name)
  @pact = PactBroker::Pacts::PactPublication.last.to_domain
  self
end

#random_json_content(consumer_name, provider_name) ⇒ Object 



555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 555

def random_json_content(consumer_name, provider_name)
  {
    "consumer" => {
       "name" => consumer_name
     },
     "provider" => {
       "name" => provider_name
     },
     "interactions" => [{
        "request" => {
          "method" => "GET",
          "path" => "/things/#{rand}"
        },
        "response" => {
          "status" => 200
        }
     }],
   }.to_json
end

#republish_same_pact(params = {}) ⇒ Object 



271
272
273
274
275
276
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 271

def republish_same_pact params = {}
  params.delete(:comment)
  last_pact_version = PactBroker::Pacts::PactVersion.order(:id).last
  create_pact pact_version_sha: last_pact_version.sha, json_content: last_pact_version.content, created_at: params[:created_at]
  self
end

#revise_pact(json_content = nil) ⇒ Object 



278
279
280
281
282
283
284
285
286
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 278

def revise_pact json_content = nil
  json_content = json_content ? json_content : {random: rand}.to_json
  pact_version_sha = generate_pact_version_sha(json_content)
  @pact = PactBroker::Pacts::Repository.new.update(@pact.id,
    json_content: prepare_json_content(json_content),
    pact_version_sha: pact_version_sha
  )
  self
end

#set_now(date) ⇒ Object 



505
506
507
508
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 505

def set_now date
  @now = date.to_date
  self
end

#set_now_date_time(date_time) ⇒ Object 



510
511
512
513
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 510

def set_now_date_time date_time
  @now = date_time
  self
end

#subtract_day ⇒ Object 



525
526
527
528
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 525

def subtract_day
  @now = @now - 1
  self
end

#subtract_days(days = 1) ⇒ Object 



530
531
532
533
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 530

def subtract_days(days = 1)
  @now = @now - days
  self
end

#use_consumer(consumer_name, params = {}) ⇒ Object 



149
150
151
152
153
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 149

def use_consumer consumer_name, params = {}
  params.delete(:comment)
  @consumer = PactBroker::Domain::Pacticipant.find(:name => consumer_name)
  self
end

#use_consumer_version(version_number) ⇒ Object 



187
188
189
190
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 187

def use_consumer_version version_number
  @consumer_version = PactBroker::Domain::Version.where(pacticipant_id: @consumer.id, number: version_number).single_record
  self
end

#use_provider(provider_name) ⇒ Object 



167
168
169
170
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 167

def use_provider provider_name
  @provider = PactBroker::Domain::Pacticipant.find(:name => provider_name)
  self
end

#use_provider_version(version_number) ⇒ Object 



192
193
194
195
 
# File 'lib/pact_broker/test/test_data_builder.rb', line 192

def use_provider_version version_number
  @provider_version = PactBroker::Domain::Version.where(pacticipant_id: @provider.id, number: version_number).single_record
  self
end