Module: GdsApi::TestHelpers::PublishingApi

Includes:
ContentItemHelpers
Defined in:
lib/gds_api/test_helpers/publishing_api.rb

Constant Summary collapse

PUBLISHING_API_V2_ENDPOINT = 
"#{Plek.find('publishing-api')}/v2".freeze
PUBLISHING_API_ENDPOINT = 
Plek.find("publishing-api")

Instance Method Summary collapse

Methods included from ContentItemHelpers

#content_item_for_base_path, #gone_content_item_for_base_path, #titleize_base_path

Instance Method Details

#assert_publishing_api(verb, url, attributes_or_matcher = nil, times = 1) ⇒ Object

Assert that a request was made to the publishing API

Parameters:

  • verb (String)
  • url (String)
  • attributes_or_matcher (Object) (defaults to: nil)
  • times (Integer) (defaults to: 1) 


279
280
281
282
283
284
285
286
287
288
289
290
291
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 279

def assert_publishing_api(verb, url, attributes_or_matcher = nil, times = 1)
  matcher = if attributes_or_matcher.is_a?(Hash)
              request_json_matches(attributes_or_matcher)
            else
              attributes_or_matcher
            end

  if matcher
    assert_requested(verb, url, times:, &matcher)
  else
    assert_requested(verb, url, times:)
  end
end

#assert_publishing_api_discard_draft(content_id, attributes_or_matcher = nil, times = 1) ⇒ Object

Assert that a draft was discarded (POST /v2/content/:content_id/discard-draft)

Parameters:

  • content_id (UUID)
  • attributes_or_matcher (Object) (defaults to: nil)
  • times (Integer) (defaults to: 1) 


268
269
270
271
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 268

def assert_publishing_api_discard_draft(content_id, attributes_or_matcher = nil, times = 1)
  url = PUBLISHING_API_V2_ENDPOINT + "/content/#{content_id}/discard-draft"
  assert_publishing_api(:post, url, attributes_or_matcher, times)
end

#assert_publishing_api_patch_links(content_id, attributes_or_matcher = nil, times = 1) ⇒ Object

Assert that links were updated (PATCH /v2/links/:content_id)

Parameters:

  • content_id (UUID)
  • attributes_or_matcher (Object) (defaults to: nil)
  • times (Integer) (defaults to: 1) 


258
259
260
261
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 258

def assert_publishing_api_patch_links(content_id, attributes_or_matcher = nil, times = 1)
  url = "#{PUBLISHING_API_V2_ENDPOINT}/links/#{content_id}"
  assert_publishing_api(:patch, url, attributes_or_matcher, times)
end

#assert_publishing_api_publish(content_id, attributes_or_matcher = nil, times = 1) ⇒ Object

Assert that content was published (POST /v2/content/:content_id/publish)

Parameters:

  • content_id (UUID)
  • attributes_or_matcher (Object) (defaults to: nil)
  • times (Integer) (defaults to: 1) 


238
239
240
241
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 238

def assert_publishing_api_publish(content_id, attributes_or_matcher = nil, times = 1)
  url = PUBLISHING_API_V2_ENDPOINT + "/content/#{content_id}/publish"
  assert_publishing_api(:post, url, attributes_or_matcher, times)
end

#assert_publishing_api_put(url, attributes_or_matcher = {}, times = 1) ⇒ Object 



758
759
760
761
762
763
764
765
766
767
768
769
770
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 758

def assert_publishing_api_put(url, attributes_or_matcher = {}, times = 1)
  matcher = if attributes_or_matcher.is_a?(Hash)
              attributes_or_matcher.empty? ? nil : request_json_matching(attributes_or_matcher)
            else
              attributes_or_matcher
            end

  if matcher
    assert_requested(:put, url, times:, &matcher)
  else
    assert_requested(:put, url, times:)
  end
end

#assert_publishing_api_put_content(content_id, attributes_or_matcher = nil, times = 1) ⇒ Object

Assert that content was saved (PUT /v2/content/:content_id)

Parameters:

  • content_id (UUID)
  • attributes_or_matcher (Object) (defaults to: nil)
  • times (Integer) (defaults to: 1) 


228
229
230
231
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 228

def assert_publishing_api_put_content(content_id, attributes_or_matcher = nil, times = 1)
  url = "#{PUBLISHING_API_V2_ENDPOINT}/content/#{content_id}"
  assert_publishing_api(:put, url, attributes_or_matcher, times)
end

#assert_publishing_api_put_content_links_and_publish(body, content_id = nil, publish_body = nil) ⇒ Object

Assert that a draft was saved and published, and links were updated.

  • PUT /v2/content/:content_id

  • POST /v2/content/:content_id/publish

  • PATCH /v2/links/:content_id

Parameters:

  • body (String)
  • content_id (UUID) (defaults to: nil)
  • publish_body (Hash) (defaults to: nil) 


212
213
214
215
216
217
218
219
220
221
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 212

def assert_publishing_api_put_content_links_and_publish(body, content_id = nil, publish_body = nil)
  content_id ||= body[:content_id]
  if publish_body.nil?
    publish_body = { update_type: body.fetch(:update_type) }
    publish_body[:locale] = body[:locale] if body[:locale]
  end
  assert_publishing_api_put_content(content_id, body.except(:links))
  assert_publishing_api_patch_links(content_id, body.slice(:links)) unless body.slice(:links).empty?
  assert_publishing_api_publish(content_id, publish_body)
end

#assert_publishing_api_put_intent(base_path, attributes_or_matcher = {}, times = 1) ⇒ Object 



753
754
755
756
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 753

def assert_publishing_api_put_intent(base_path, attributes_or_matcher = {}, times = 1)
  url = "#{PUBLISHING_API_ENDPOINT}/publish-intent#{base_path}"
  assert_publishing_api_put(url, attributes_or_matcher, times)
end

#assert_publishing_api_unpublish(content_id, attributes_or_matcher = nil, times = 1) ⇒ Object

Assert that content was unpublished (POST /v2/content/:content_id/unpublish)

Parameters:

  • content_id (UUID)
  • attributes_or_matcher (Object) (defaults to: nil)
  • times (Integer) (defaults to: 1) 


248
249
250
251
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 248

def assert_publishing_api_unpublish(content_id, attributes_or_matcher = nil, times = 1)
  url = PUBLISHING_API_V2_ENDPOINT + "/content/#{content_id}/unpublish"
  assert_publishing_api(:post, url, attributes_or_matcher, times)
end

#request_json_includes(required_attributes) ⇒ Object

Get a request matcher that checks if a JSON request includes a set of attributes



294
295
296
297
298
299
300
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 294

def request_json_includes(required_attributes)
  lambda do |request|
    data = JSON.parse(request.body)
    deep_stringify_keys(required_attributes)
      .to_a.all? { |key, value| data[key] == value }
  end
end

#request_json_including(required_attributes) ⇒ Object 



779
780
781
782
783
784
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 779

def request_json_including(required_attributes)
  lambda do |request|
    data = JSON.parse(request.body)
    values_match_recursively(required_attributes, data)
  end
end

#request_json_matches(required_attributes) ⇒ Object

Get a request matcher that checks if a JSON request matches a hash



303
304
305
306
307
308
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 303

def request_json_matches(required_attributes)
  lambda do |request|
    data = JSON.parse(request.body)
    deep_stringify_keys(required_attributes) == data
  end
end

#request_json_matching(required_attributes) ⇒ Object 



772
773
774
775
776
777
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 772

def request_json_matching(required_attributes)
  lambda do |request|
    data = JSON.parse(request.body)
    required_attributes.to_a.all? { |key, value| data[key.to_s] == value }
  end
end

#stub_any_publishing_api_call ⇒ Object

Stub any request to the publishing API



176
177
178
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 176

def stub_any_publishing_api_call
  stub_request(:any, %r{\A#{PUBLISHING_API_ENDPOINT}})
end

#stub_any_publishing_api_call_to_return_not_found ⇒ Object

Stub any request to the publishing API to return a 404 response



181
182
183
184
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 181

def stub_any_publishing_api_call_to_return_not_found
  stub_request(:any, %r{\A#{PUBLISHING_API_ENDPOINT}})
    .to_return(status: 404, headers: { "Content-Type" => "application/json; charset=utf-8" })
end

#stub_any_publishing_api_discard_draft ⇒ Object

Stub any POST /v2/content/*/discard-draft request



171
172
173
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 171

def stub_any_publishing_api_discard_draft
  stub_request(:post, %r{\A#{PUBLISHING_API_V2_ENDPOINT}/content/.*/discard-draft})
end

#stub_any_publishing_api_patch_links ⇒ Object

Stub any PATCH /v2/links/* request



151
152
153
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 151

def stub_any_publishing_api_patch_links
  stub_request(:patch, %r{\A#{PUBLISHING_API_V2_ENDPOINT}/links/})
end

#stub_any_publishing_api_path_reservation ⇒ Object

Stub all PUT /paths/:base_path requests

Examples:

stub_any_publishing_api_path_reservation


813
814
815
816
817
818
819
820
821
822
823
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 813

def stub_any_publishing_api_path_reservation
  stub_request(:put, %r{\A#{PUBLISHING_API_ENDPOINT}/paths/}).to_return do |request|
    base_path = request.uri.path.sub(%r{\A/paths}, "")
    body = JSON.parse(request.body).merge(base_path:)
    {
      status: 200,
      headers: { content_type: "application/json" },
      body: body.to_json,
    }
  end
end

#stub_any_publishing_api_publish ⇒ Object

Stub any POST /v2/content/*/publish request



156
157
158
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 156

def stub_any_publishing_api_publish
  stub_request(:post, %r{\A#{PUBLISHING_API_V2_ENDPOINT}/content/.*/publish})
end

#stub_any_publishing_api_put_content ⇒ Object

Stub any PUT /v2/content/* request



146
147
148
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 146

def stub_any_publishing_api_put_content
  stub_request(:put, %r{\A#{PUBLISHING_API_V2_ENDPOINT}/content/})
end

#stub_any_publishing_api_put_intent ⇒ Object 



749
750
751
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 749

def stub_any_publishing_api_put_intent
  stub_request(:put, %r{\A#{PUBLISHING_API_ENDPOINT}/publish-intent})
end

#stub_any_publishing_api_republish ⇒ Object

Stub any POST /v2/content/*/publish request



161
162
163
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 161

def stub_any_publishing_api_republish
  stub_request(:post, %r{\A#{PUBLISHING_API_V2_ENDPOINT}/content/.*/republish})
end

#stub_any_publishing_api_unpublish ⇒ Object

Stub any POST /v2/content/*/unpublish request



166
167
168
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 166

def stub_any_publishing_api_unpublish
  stub_request(:post, %r{\A#{PUBLISHING_API_V2_ENDPOINT}/content/.*/unpublish})
end

#stub_any_publishing_api_unreserve_path ⇒ Object 



715
716
717
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 715

def stub_any_publishing_api_unreserve_path
  stub_request(:delete, %r{\A#{PUBLISHING_API_ENDPOINT}/paths/})
end

#stub_publishing_api_destroy_intent(base_path) ⇒ Object 



744
745
746
747
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 744

def stub_publishing_api_destroy_intent(base_path)
  url = "#{PUBLISHING_API_ENDPOINT}/publish-intent#{base_path}"
  stub_request(:delete, url).to_return(status: 200, body: "{}", headers: { "Content-Type" => "application/json; charset=utf-8" })
end

#stub_publishing_api_discard_draft(content_id) ⇒ Object

Stub a POST /v2/content/:content_id/discard-draft request

Parameters:

  • content_id (UUID) 


119
120
121
122
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 119

def stub_publishing_api_discard_draft(content_id)
  url = PUBLISHING_API_V2_ENDPOINT + "/content/#{content_id}/discard-draft"
  stub_request(:post, url).to_return(status: 200, headers: { "Content-Type" => "application/json; charset=utf-8" })
end

#stub_publishing_api_does_not_have_item(content_id, params = {}) ⇒ Object

Stub GET /v2/content/:content_id to return a 404 response

Parameters:

  • content_id (UUID) 


469
470
471
472
473
474
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 469

def stub_publishing_api_does_not_have_item(content_id, params = {})
  url = "#{PUBLISHING_API_V2_ENDPOINT}/content/#{content_id}"
  stub_request(:get, url)
    .with(query: hash_including(params))
    .to_return(status: 404, body: resource_not_found(content_id, "content item").to_json, headers: {})
end

#stub_publishing_api_does_not_have_links(content_id) ⇒ Object

Stub GET /v2/links/:content_id to return a 404 response

Parameters:

  • content_id (UUID) 


610
611
612
613
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 610

def stub_publishing_api_does_not_have_links(content_id)
  url = "#{PUBLISHING_API_V2_ENDPOINT}/links/#{content_id}"
  stub_request(:get, url).to_return(status: 404, body: resource_not_found(content_id, "link set").to_json, headers: {})
end

#stub_publishing_api_get_editions(editions, params = {}) ⇒ Object

Stub GET /v2/editions to return a set of editions

Examples:


stub_publishing_api_get_editions(
  vehicle_recalls_and_faults,   # this is a variable containing an array of editions
  fields: fields,   #example: let(:fields) { %i[base_path content_id public_updated_at title publication_state] }
  per_page: 50
)

Parameters:

  • items (Array)
  • params (Hash) (defaults to: {}) 


679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 679

def stub_publishing_api_get_editions(editions, params = {})
  url = "#{PUBLISHING_API_V2_ENDPOINT}/editions"

  results = editions.map do |edition|
    next edition unless params[:fields]

    edition.select { |k| params[:fields].include?(k) }
  end

  per_page = (params[:per_page] || 100).to_i
  results = results.take(per_page)

  body = {
    results:,
    links: [
      { rel: "self", href: "#{PUBLISHING_API_V2_ENDPOINT}/editions" },
    ],
  }

  stub_request(:get, url)
    .with(query: params)
    .to_return(status: 200, body: body.to_json, headers: {})
end

#stub_publishing_api_graphql_query(query, response_hash = {}) ⇒ Object

Stub a POST /graphql request

Parameters:

  • query (String) 


194
195
196
197
198
199
200
201
202
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 194

def stub_publishing_api_graphql_query(query, response_hash = {})
  url = "#{PUBLISHING_API_ENDPOINT}/graphql"
  response = {
    status: 200,
    body: response_hash.to_json,
    headers: { "Content-Type" => "application/json; charset=utf-8" },
  }
  stub_request(:post, url).with(body: { query: }).to_return(response)
end

#stub_publishing_api_has_content(items, params = {}) ⇒ Object

Stub GET /v2/content/ to return a set of content items

Examples:


stub_publishing_api_has_content(
  vehicle_recalls_and_faults,   # this is a variable containing an array of content items
  document_type: described_class.publishing_api_document_type,   #example of a document_type: "vehicle_recalls_and_faults_alert"
  fields: fields,   #example: let(:fields) { %i[base_path content_id public_updated_at title publication_state] }
  page: 1,
  per_page: 50
)

Parameters:

  • items (Array)
  • params (Hash) (defaults to: {}) 


323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 323

def stub_publishing_api_has_content(items, params = {})
  url = "#{PUBLISHING_API_V2_ENDPOINT}/content"

  if params.respond_to? :fetch
    per_page = params.fetch(:per_page, 50)
    page = params.fetch(:page, 1)
  else
    per_page = 50
    page = 1
  end

  start_position = (page - 1) * per_page
  page_items = items.slice(start_position, per_page) || []

  number_of_pages =
    if items.count < per_page
      1
    else
      (items.count / per_page.to_f).ceil
    end

  body = {
    results: page_items,
    total: items.count,
    pages: number_of_pages,
    current_page: page,
  }

  stub_request(:get, url)
    .with(query: params)
    .to_return(status: 200, body: body.to_json, headers: {})
end

#stub_publishing_api_has_embedded_content(content_id:, total: 0, total_pages: 0, results: [], page_number: nil, order: nil) ⇒ Object

Stub GET /v2/content/:content_id/embedded to return a list of content items that embed the target content_id

Examples:


stub_publishing_api_has_content_(
  content_id: "9faacf5c-f4e6-4bf9-ba90-413e997c1f22" # this is the content_id for a reusable edition
  total: 1 # the number of results returned
  results: [{
    "title" => "foo",
    "document_type" => "document",
    "base_path" => "/foo",
    "content_id" => "e60fae2a-5490-4e2f-9e80-2093c47608d4",
    "primary_publishing_organisation" => {
      "content_id" => "7662e1e7-79f9-4d0a-b754-6232186851f6",
      "title" => "bar",
      "base_path" => "/organisation/bar",
    },
  }] # an array of content items that embed the target content_id
)

Parameters:

  • content_id (UUID, Mocha::ParameterMatchers::Anything)
  • total (defaults to: 0) —

    Integer

  • total_pages (defaults to: 0) —

    Integer

  • results (Hash) (defaults to: []) 


379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 379

def stub_publishing_api_has_embedded_content(content_id:, total: 0, total_pages: 0, results: [], page_number: nil, order: nil)
  url = "#{PUBLISHING_API_V2_ENDPOINT}/content/#{content_id}/embedded"

  query = {
    "page" => page_number,
    "order" => order,
  }.compact

  stub_request(:get, url)
    .with(query:)
    .to_return(body: {
      "content_id" => content_id,
      "total" => total,
      "total_pages" => total_pages,
      "results" => results,
    }.to_json)
end

#stub_publishing_api_has_embedded_content_for_any_content_id(total: 0, total_pages: 0, results: [], page_number: nil, order: nil) ⇒ Object 



397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 397

def stub_publishing_api_has_embedded_content_for_any_content_id(total: 0, total_pages: 0, results: [], page_number: nil, order: nil)
  url = %r{\A#{PUBLISHING_API_V2_ENDPOINT}/content/[0-9a-fA-F-]{36}/embedded}

  query = {
    "page" => page_number,
    "order" => order,
  }.compact

  stub_request(:get, url)
    .with { |request| WebMock::Util::QueryMapper.query_to_values(request.uri.query) == query }
    .to_return(body: {
      "content_id" => SecureRandom.uuid,
      "total" => total,
      "total_pages" => total_pages,
      "results" => results,
    }.to_json)
end

#stub_publishing_api_has_expanded_links(links, with_drafts: true, generate: false) ⇒ Object

Stub a request to the expanded links endpoint

Examples:

stub_publishing_api_has_expanded_links(
  {
    "content_id" => "64aadc14-9bca-40d9-abb4-4f21f9792a05",
    "expanded_links" => {
      "mainstream_browse_pages" => [
        {
          "content_id" => "df2e7a3e-2078-45de-a76a-fd37d027427a",
          "base_path" => "/a/base/path",
          "document_type" => "mainstream_browse_page",
          "locale" => "en",
          "links" => {},
          # ...
        }
      ],
      "parent" => [
        {
          "content_id" => "df2e7a3e-2028-45de-a75a-fd37d027427e",
          "document_type" => "mainstream_browse_page",
          # ...
        },
      ]
    }
  }
)
Services.publishing_api.expanded_links("64aadc14-9bca-40d9-abb4-4f21f9792a05")
=>  {
      "content_id" => "64aadc14-9bca-40d9-abb4-4f21f9792a05",
      "expanded_links" => {
        "mainstream_browse_pages" => [
          {
            "content_id" => "df2e7a3e-2078-45de-a76a-fd37d027427a",
            "base_path" => "/a/base/path",
            "document_type" => "mainstream_browse_page",
            "locale" => "en",
            "links" => {},
            ...
          }
        ],
        "parent" => [
          {
            "content_id" => "df2e7a3e-2028-45de-a75a-fd37d027427e",
            "document_type" => "mainstream_browse_page",
            ...
          },
        ]
      }
    }

Parameters:

  • links (Hash) —

    the structure of the links hash



566
567
568
569
570
571
572
573
574
575
576
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 566

def stub_publishing_api_has_expanded_links(links, with_drafts: true, generate: false)
  links = deep_transform_keys(links, &:to_sym)
  request_params = {}
  request_params["with_drafts"] = false unless with_drafts
  request_params["generate"] = true if generate

  url = "#{PUBLISHING_API_V2_ENDPOINT}/expanded-links/#{links[:content_id]}"
  stub_request(:get, url)
    .with(query: request_params)
    .to_return(status: 200, body: links.to_json, headers: {})
end

#stub_publishing_api_has_fields_for_document(document_type, items, fields) ⇒ Object

This method has been refactored into publishing_api_has_content (above) publishing_api_has_content allows for flexible passing in of arguments, please use instead



417
418
419
420
421
422
423
424
425
426
427
428
429
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 417

def stub_publishing_api_has_fields_for_document(document_type, items, fields)
  body = Array(items).map do |item|
    deep_stringify_keys(item).slice(*fields)
  end

  query_params = fields.map do |f|
    "&fields%5B%5D=#{f}"
  end

  url = PUBLISHING_API_V2_ENDPOINT + "/content?document_type=#{document_type}#{query_params.join('')}"

  stub_request(:get, url).to_return(status: 200, body: { results: body }.to_json, headers: {})
end

#stub_publishing_api_has_item(item, params = {}) ⇒ Object

Stub GET /v2/content/:content_id to return a specific content item hash

Parameters:

  • item (Hash) 


442
443
444
445
446
447
448
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 442

def stub_publishing_api_has_item(item, params = {})
  item = deep_transform_keys(item, &:to_sym)
  url = "#{PUBLISHING_API_V2_ENDPOINT}/content/#{item[:content_id]}"
  stub_request(:get, url)
    .with(query: hash_including(params))
    .to_return(status: 200, body: item.to_json, headers: {})
end

#stub_publishing_api_has_item_in_sequence(content_id, items) ⇒ Object

Stub GET /v2/content/:content_id to progress through a series of responses.

Parameters:

  • items (Array) 


453
454
455
456
457
458
459
460
461
462
463
464
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 453

def stub_publishing_api_has_item_in_sequence(content_id, items)
  items = items.each { |item| deep_transform_keys(item, &:to_sym) }
  url = "#{PUBLISHING_API_V2_ENDPOINT}/content/#{content_id}"
  calls = -1

  stub_request(:get, url).to_return do |_request|
    calls += 1
    item = items[calls] || items.last

    { status: 200, body: item.to_json, headers: {} }
  end
end

#stub_publishing_api_has_linkables(linkables, document_type:) ⇒ Object

Stub GET /v2/linkables to return a set of content items with a specific document type

Parameters:

  • linkables (Array) 


434
435
436
437
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 434

def stub_publishing_api_has_linkables(linkables, document_type:)
  url = PUBLISHING_API_V2_ENDPOINT + "/linkables?document_type=#{document_type}"
  stub_request(:get, url).to_return(status: 200, body: linkables.to_json, headers: {})
end

#stub_publishing_api_has_linked_items(items, params = {}) ⇒ Object

Stub calls to the get linked items endpoint

Examples:


stub_publishing_api_has_linked_items(
  [ item_1, item_2 ],
  {
    content_id: "51ac4247-fd92-470a-a207-6b852a97f2db",
    link_type: "taxons",
    fields: ["title", "description", "base_path"]
  }
)

Parameters:

  • items (Array) —

    The linked items we wish to return

  • params (Hash) (defaults to: {}) —

    A hash of parameters



648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 648

def stub_publishing_api_has_linked_items(items, params = {})
  content_id = params.fetch(:content_id)
  link_type = params.fetch(:link_type)
  fields = params.fetch(:fields, %w[base_path content_id document_type title])

  url = PUBLISHING_API_V2_ENDPOINT + "/linked/#{content_id}"

  request_parmeters = {
    "fields" => fields,
    "link_type" => link_type,
  }

  stub_request(:get, url)
    .with(query: request_parmeters)
    .and_return(
      body: items.to_json,
      status: 200,
    )
end

#stub_publishing_api_has_links(links) ⇒ Object

Stub a request to links endpoint

Examples:


stub_publishing_api_has_links(
  {
    "content_id" => "64aadc14-9bca-40d9-abb6-4f21f9792a05",
    "links" => {
      "mainstream_browse_pages" => ["df2e7a3e-2078-45de-a75a-fd37d027427e"],
      "parent" => ["df2e7a3e-2078-45de-a75a-fd37d027427e"],
      "organisations" => ["569a9ee5-c195-4b7f-b9dc-edc17a09113f", "5c54ae52-341b-499e-a6dd-67f04633b8cf"]
    },
    "version" => 6
  }
)

Services.publishing_api.get_links("64aadc14-9bca-40d9-abb6-4f21f9792a05")
=> {
     "content_id" => "64aadc14-9bca-40d9-abb6-4f21f9792a05",
     "links" => {
       "mainstream_browse_pages" => ["df2e7a3e-2078-45de-a75a-fd37d027427e"],
       "parent" => ["df2e7a3e-2078-45de-a75a-fd37d027427e"],
       "organisations" => ["569a9ee5-c195-4b7f-b9dc-edc17a09113f", "5c54ae52-341b-499e-a6dd-67f04633b8cf"]
     },
     "version" => 6
   }

Parameters:

  • links (Hash) —

    the structure of the links hash



506
507
508
509
510
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 506

def stub_publishing_api_has_links(links)
  links = deep_transform_keys(links, &:to_sym)
  url = "#{PUBLISHING_API_V2_ENDPOINT}/links/#{links[:content_id]}"
  stub_request(:get, url).to_return(status: 200, body: links.to_json, headers: {})
end

#stub_publishing_api_has_links_for_content_ids(links) ⇒ Object

Stub a request to get links for content ids

Examples:

stub_publishing_api_has_links_for_content_ids(
  { "2878337b-bed9-4e7f-85b6-10ed2cbcd504" => {
      "links" => { "taxons" => ["eb6965c7-3056-45d0-ae50-2f0a5e2e0854"] }
    },
    "eec13cea-219d-4896-9c97-60114da23559" => {
      "links" => {}
    }
  }
)
Services.publishing_api.get_links_for_content_ids(["2878337b-bed9-4e7f-85b6-10ed2cbcd504"])
=>  {
      "2878337b-bed9-4e7f-85b6-10ed2cbcd504" => {
        "links" => [
          "eb6965c7-3056-45d0-ae50-2f0a5e2e0854"
        ]
      }
    }

Parameters:

  • links (Hash) —

    the links for each content id



602
603
604
605
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 602

def stub_publishing_api_has_links_for_content_ids(links)
  url = "#{PUBLISHING_API_V2_ENDPOINT}/links/by-content-id"
  stub_request(:post, url).with(body: { content_ids: links.keys }).to_return(status: 200, body: links.to_json, headers: {})
end

#stub_publishing_api_has_lookups(lookup_hash) ⇒ Object

Stub calls to the lookups endpoint

Examples:


stub_publishing_api_has_lookups({
  "/foo" => "51ac4247-fd92-470a-a207-6b852a97f2db",
  "/bar" => "261bd281-f16c-48d5-82d2-9544019ad9ca"
})

Parameters:

  • lookup_hash (Hash) —

    Hash with base_path as key, content_id as value.



626
627
628
629
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 626

def stub_publishing_api_has_lookups(lookup_hash)
  url = "#{PUBLISHING_API_ENDPOINT}/lookup-by-base-path"
  stub_request(:post, url).to_return(body: lookup_hash.to_json)
end

#stub_publishing_api_has_path_reservation_for(path, publishing_app) ⇒ Object

Stub a PUT /paths/:base_path request for a particular publishing application. Calling for a different publishing application will return a 422 response.

Examples:

stub_publishing_api_has_path_reservation_for("/foo", "content-publisher")

Parameters:

  • base_path (String)
  • publishing_app (String) 


834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 834

def stub_publishing_api_has_path_reservation_for(path, publishing_app)
  message = "#{path} is already reserved by #{publishing_app}"
  error = { code: 422,
            message: "Base path #{message}",
            fields: { base_path: [message] } }

  stub_request(:put, "#{PUBLISHING_API_ENDPOINT}/paths#{path}")
            .to_return(status: 422,
                       headers: { content_type: "application/json" },
                       body: { error: }.to_json)

  stub_request(:put, "#{PUBLISHING_API_ENDPOINT}/paths#{path}")
    .with(body: { "publishing_app" => publishing_app })
    .to_return(status: 200,
               headers: { content_type: "application/json" },
               body: { publishing_app:, base_path: path }.to_json)
end

#stub_publishing_api_has_schemas(schemas) ⇒ Object

Stub a request to get all schemas

Examples:

stub_publishing_api_has_schemas(
  {
      "email_address" =>  {
        "type": "email_address",
        "required": ["email"],
        "properties": {
          "email": { "type" => "string" },
        },
      },
      "tax_bracket" => {
        "type": "tax_bracket",
        "required": ["code"],
        "properties": {
          "code": { "type" => "string" },
        },
      }
  }
)


925
926
927
928
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 925

def stub_publishing_api_has_schemas(schemas)
  url = "#{PUBLISHING_API_V2_ENDPOINT}/schemas"
  stub_request(:get, url).to_return(status: 200, body: schemas.to_json, headers: {})
end

#stub_publishing_api_has_schemas_for_schema_name(schema_name, schema) ⇒ Object

Stub a request to get a schema by schema name

Examples:

stub_publishing_api_has_schemas_for_schema_name(
  "email_address",
  { "email_address" =>  {
      "type": "email_address",
      "required": ["email"],
      "properties": {
        "email": { "type" => "string" },
      },
    },
  }
)

Parameters:

  • schema (String) —

    name



893
894
895
896
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 893

def stub_publishing_api_has_schemas_for_schema_name(schema_name, schema)
  url = "#{PUBLISHING_API_V2_ENDPOINT}/schemas/#{schema_name}"
  stub_request(:get, url).to_return(status: 200, body: schema.to_json, headers: {})
end

#stub_publishing_api_isnt_available ⇒ Object

Stub any request to the publishing API to return a 503 response



187
188
189
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 187

def stub_publishing_api_isnt_available
  stub_request(:any, /#{PUBLISHING_API_ENDPOINT}\/.*/).to_return(status: 503)
end

#stub_publishing_api_patch_links(content_id, body) ⇒ Object

Stub a PATCH /v2/links/:content_id request

Examples:

stub_publishing_api_patch_links(
  my_content_id,
  "links" => {
    "taxons" => %w(level_one_topic level_two_topic),
  },
  "previous_version" => 3,
)

Parameters:

  • content_id (UUID)
  • body (String) 


48
49
50
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 48

def stub_publishing_api_patch_links(content_id, body)
  stub_publishing_api_patch(content_id, body, "/links")
end

#stub_publishing_api_patch_links_conflict(content_id, body) ⇒ Object

Stub a PATCH /v2/links/:content_id request to return a 409 response

Examples:

stub_publishing_api_patch_links_conflict(
  my_content_id,
  "links" => {
    "taxons" => %w(level_one_topic level_two_topic),
  },
  "previous_version" => 3,
)

Parameters:

  • content_id (UUID)
  • body (String) 


65
66
67
68
69
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 65

def stub_publishing_api_patch_links_conflict(content_id, body)
  previous_version = JSON.parse(body.to_json)["previous_version"]
  override_response_hash = { status: 409, body: version_conflict(previous_version) }
  stub_publishing_api_patch(content_id, body, "/links", override_response_hash)
end

#stub_publishing_api_path_reservation(base_path, params = {}) ⇒ Object

Stub a PUT /paths/:base_path request with the given base_path and request body.

Examples:

stub_publishing_api_path_reservation(
  "/path/to",
  publishing_app: "content-publisher",
  override_existing: true,
)

Parameters:

  • base_path (String)
  • params (Hash) (defaults to: {}) 


798
799
800
801
802
803
804
805
806
807
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 798

def stub_publishing_api_path_reservation(base_path, params = {})
  url = PUBLISHING_API_ENDPOINT + "/paths#{base_path}"
  response = {
    status: 200,
    headers: { content_type: "application/json" },
    body: params.merge(base_path:).to_json,
  }

  stub_request(:put, url).with(body: params).to_return(response)
end

#stub_publishing_api_publish(content_id, body, response_hash = {}) ⇒ Object

Stub a POST /v2/content/:content_id/publish request

Parameters:

  • content_id (UUID)
  • body (String)
  • response_hash (Hash) (defaults to: {}) 


76
77
78
79
80
81
82
83
84
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 76

def stub_publishing_api_publish(content_id, body, response_hash = {})
  url = PUBLISHING_API_V2_ENDPOINT + "/content/#{content_id}/publish"
  response = {
    status: 200,
    body: "{}",
    headers: { "Content-Type" => "application/json; charset=utf-8" },
  }.merge(response_hash)
  stub_request(:post, url).with(body:).to_return(response)
end

#stub_publishing_api_put_content(content_id, body, response_hash = {}) ⇒ Object

Stub a PUT /v2/content/:content_id request with the given content id and request body. if no response_hash is given, a default response as follows is created: 200, body: ‘{’, headers: => “application/json; charset=utf-8”}

if a response is given, then it will be merged with the default response. if the given parameter for the response body is a Hash, it will be converted to JSON.

The following two examples are equivalent:

Examples:

stub_publishing_api_put_content(my_content_id, my_request_body, { status: 201, body: {version: 33}.to_json })
stub_publishing_api_put_content(my_content_id, my_request_body, { status: 201, body: {version: 33} })

Parameters:

  • content_id (UUID)
  • body (String)
  • response_hash (Hash) (defaults to: {}) 


31
32
33
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 31

def stub_publishing_api_put_content(content_id, body, response_hash = {})
  stub_publishing_api_put(content_id, body, "/content", response_hash)
end

#stub_publishing_api_put_content_links_and_publish(body, content_id = nil, publish_body = nil) ⇒ Object

Stub requests issued when publishing a new draft.

  • PUT /v2/content/:content_id

  • POST /v2/content/:content_id/publish

  • PATCH /v2/links/:content_id

Parameters:

  • body (String)
  • content_id (UUID) (defaults to: nil)
  • publish_body (Hash) (defaults to: nil) 


132
133
134
135
136
137
138
139
140
141
142
143
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 132

def stub_publishing_api_put_content_links_and_publish(body, content_id = nil, publish_body = nil)
  content_id ||= body[:content_id]
  if publish_body.nil?
    publish_body = { update_type: body.fetch(:update_type) }
    publish_body[:locale] = body[:locale] if body[:locale]
  end
  stubs = []
  stubs << stub_publishing_api_put_content(content_id, body.except(:links))
  stubs << stub_publishing_api_patch_links(content_id, body.slice(:links)) unless body.slice(:links).empty?
  stubs << stub_publishing_api_publish(content_id, publish_body)
  stubs
end

#stub_publishing_api_put_intent(base_path, params = {}) ⇒ Object

Stub a PUT /publish-intent/:base_path request with the given base_path and request body.

Examples:

stub_publishing_api_put_intent(
  "/path/to/content",
  publishing_app: "publisher",
  rendering_app: "frontend",
  publish_time: "2019-11-11T17:56:17+00:00",
)

Parameters:

  • base_path (String)
  • params (Hash) (defaults to: {}) 


732
733
734
735
736
737
738
739
740
741
742
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 732

def stub_publishing_api_put_intent(base_path, params = {})
  url = PUBLISHING_API_ENDPOINT + "/publish-intent#{base_path}"
  body = params.is_a?(String) ? params : params.to_json

  response = {
    status: 200,
    headers: { content_type: "application/json" },
    body:,
  }
  stub_request(:put, url).with(body: params).to_return(response)
end

#stub_publishing_api_republish(content_id, body = {}, response_hash = {}) ⇒ Object

Stub a POST /v2/content/:content_id/republish request

Parameters:

  • content_id (UUID)
  • body (String) (defaults to: {})
  • response_hash (Hash) (defaults to: {}) 


91
92
93
94
95
96
97
98
99
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 91

def stub_publishing_api_republish(content_id, body = {}, response_hash = {})
  url = PUBLISHING_API_V2_ENDPOINT + "/content/#{content_id}/republish"
  response = {
    status: 200,
    body: "{}",
    headers: { "Content-Type" => "application/json; charset=utf-8" },
  }.merge(response_hash)
  stub_request(:post, url).with(body:).to_return(response)
end

#stub_publishing_api_returns_path_reservation_validation_error_for(base_path, error_fields = {}) ⇒ Object

Stub a PUT /paths/:base_path request for a particular publishing application. Calling for a different publishing application will return a 422 response.

Examples:

stub_publishing_api_returns_path_reservation_validation_error_for(
  "/foo",
  "field" => ["error 1", "error 2"]
)

Parameters:

  • base_path (String)
  • error_fields (Hash) (defaults to: {}) 


864
865
866
867
868
869
870
871
872
873
874
875
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 864

def stub_publishing_api_returns_path_reservation_validation_error_for(base_path, error_fields = {})
  error_fields = { "base_path" => ["Computer says no"] } if error_fields.empty?

  message = "#{error_fields.keys.first.to_s.capitalize.gsub(/_/, ' ')} #{error_fields.values.flatten.first}"

  error = { code: 422, message:, fields: error_fields }

  stub_request(:put, "#{PUBLISHING_API_ENDPOINT}/paths#{base_path}")
    .to_return(status: 422,
               headers: { content_type: "application/json" },
               body: { error: }.to_json)
end

#stub_publishing_api_schema_name_path_to_return_not_found(schema_name) ⇒ Object 



898
899
900
901
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 898

def stub_publishing_api_schema_name_path_to_return_not_found(schema_name)
  url = "#{PUBLISHING_API_V2_ENDPOINT}/schemas/#{schema_name}"
  stub_request(:get, url).to_return(status: 404, headers: { "Content-Type" => "application/json; charset=utf-8" })
end

#stub_publishing_api_unpublish(content_id, params, response_hash = {}) ⇒ Object

Stub a POST /v2/content/:content_id/unpublish request

Parameters:

  • content_id (UUID)
  • params (Hash)
  • body (String) 


106
107
108
109
110
111
112
113
114
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 106

def stub_publishing_api_unpublish(content_id, params, response_hash = {})
  url = PUBLISHING_API_V2_ENDPOINT + "/content/#{content_id}/unpublish"
  response = {
    status: 200,
    body: "{}",
    headers: { "Content-Type" => "application/json; charset=utf-8" },
  }.merge(response_hash)
  stub_request(:post, url).with(params).to_return(response)
end

#stub_publishing_api_unreserve_path(base_path, publishing_app = /.*/) ⇒ Object 



703
704
705
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 703

def stub_publishing_api_unreserve_path(base_path, publishing_app = /.*/)
  stub_publishing_api_unreserve_path_with_code(base_path, publishing_app, 200)
end

#stub_publishing_api_unreserve_path_invalid(base_path, publishing_app = /.*/) ⇒ Object 



711
712
713
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 711

def stub_publishing_api_unreserve_path_invalid(base_path, publishing_app = /.*/)
  stub_publishing_api_unreserve_path_with_code(base_path, publishing_app, 422)
end

#stub_publishing_api_unreserve_path_not_found(base_path, publishing_app = /.*/) ⇒ Object 



707
708
709
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 707

def stub_publishing_api_unreserve_path_not_found(base_path, publishing_app = /.*/)
  stub_publishing_api_unreserve_path_with_code(base_path, publishing_app, 404)
end