Class: PactBroker::Pacts::Repository

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

Constant Summary

Constants included from Logging

Logging::LOG_DIR, Logging::LOG_FILE_NAME

Instance Method Summary collapse

Methods included from Logging

included, #log_error, #logger, #logger=

Instance Method Details

#create(params) ⇒ Object 



19
20
21
22
23
24
25
 
# File 'lib/pact_broker/pacts/repository.rb', line 19

def create params
  PactPublication.new(
    consumer_version_id: params[:version_id],
    provider_id: params[:provider_id],
    pact_version: find_or_create_pact_version(params.fetch(:consumer_id), params.fetch(:provider_id), params[:json_content]),
  ).save.to_domain
end

#delete(params) ⇒ Object 



42
43
44
45
46
47
48
49
 
# File 'lib/pact_broker/pacts/repository.rb', line 42

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_by_version_id(version_id) ⇒ Object 



51
52
53
 
# File 'lib/pact_broker/pacts/repository.rb', line 51

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 



55
56
57
58
59
60
61
62
63
 
# File 'lib/pact_broker/pacts/repository.rb', line 55

def find_all_pact_versions_between consumer_name, options
  provider_name = options.fetch(:and)
  LatestPactPublicationsByConsumerVersion
    .eager(:tags)
    .consumer(consumer_name)
    .provider(provider_name)
    .reverse_order(:consumer_version_order)
    .collect(&:to_domain)
end

#find_all_revisions(consumer_name, consumer_version, provider_name) ⇒ Object 



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

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



74
75
76
77
78
79
 
# File 'lib/pact_broker/pacts/repository.rb', line 74

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 



81
82
83
84
85
86
 
# File 'lib/pact_broker/pacts/repository.rb', line 81

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_latest_pact(consumer_name, provider_name, tag = nil) ⇒ Object 



92
93
94
95
96
97
98
99
100
101
102
103
 
# File 'lib/pact_broker/pacts/repository.rb', line 92

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 



65
66
67
68
69
70
71
 
# File 'lib/pact_broker/pacts/repository.rb', line 65

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 



88
89
90
 
# File 'lib/pact_broker/pacts/repository.rb', line 88

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

#find_next_pact(pact) ⇒ Object 



139
140
141
142
143
144
145
146
 
# File 'lib/pact_broker/pacts/repository.rb', line 139

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 



105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
# File 'lib/pact_broker/pacts/repository.rb', line 105

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_previous_distinct_pact(pact) ⇒ Object 



148
149
150
151
152
153
154
155
 
# File 'lib/pact_broker/pacts/repository.rb', line 148

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) ⇒ Object 



130
131
132
133
134
135
136
137
 
# File 'lib/pact_broker/pacts/repository.rb', line 130

def find_previous_pact pact
  LatestPactPublicationsByConsumerVersion
    .eager(:tags)
    .consumer(pact.consumer.name)
    .provider(pact.provider.name)
    .consumer_version_order_before(pact.consumer_version.order)
    .latest.collect(&:to_domain_with_content)[0]
end

#update(id, params) ⇒ Object 



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

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[:json_content])
  if existing_model.pact_version_id != pact_version.id
    PactPublication.new(
      consumer_version_id: existing_model.consumer_version_id,
      provider_id: existing_model.provider_id,
      revision_number: (existing_model.revision_number + 1),
      pact_version: pact_version,
    ).save.to_domain
  else
    existing_model.to_domain
  end
end