Module: GdsApi::TestHelpers::PublishingApi

Extended by:
AliasDeprecated
Includes:
ContentItemHelpers
Included in:
PublishingApiV2
Defined in:
lib/gds_api/test_helpers/publishing_api.rb

Constant Summary collapse

PUBLISHING_API_V2_ENDPOINT = 
Plek.current.find("publishing-api") + "/v2"
PUBLISHING_API_ENDPOINT = 
Plek.current.find("publishing-api")

Instance Method Summary collapse

Methods included from AliasDeprecated

alias_deprecated

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) 


268
269
270
271
272
273
274
275
276
277
278
279
280
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 268

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

  if matcher
    assert_requested(verb, url, times: times, &matcher)
  else
    assert_requested(verb, url, times: 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) 


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

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) 


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

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) 


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

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 



686
687
688
689
690
691
692
693
694
695
696
697
698
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 686

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

  if matcher
    assert_requested(:put, url, times: times, &matcher)
  else
    assert_requested(:put, url, times: 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) 


217
218
219
220
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 217

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) 


201
202
203
204
205
206
207
208
209
210
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 201

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 



681
682
683
684
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 681

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) 


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

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



283
284
285
286
287
288
289
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 283

def request_json_includes(required_attributes)
  ->(request) do
    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 



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

def request_json_including(required_attributes)
  ->(request) do
    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



292
293
294
295
296
297
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 292

def request_json_matches(required_attributes)
  ->(request) do
    data = JSON.parse(request.body)
    deep_stringify_keys(required_attributes) == data
  end
end

#request_json_matching(required_attributes) ⇒ Object 



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

def request_json_matching(required_attributes)
  ->(request) do
    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



178
179
180
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 178

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



183
184
185
186
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 183

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



173
174
175
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 173

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



153
154
155
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 153

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


741
742
743
744
745
746
747
748
749
750
751
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 741

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: 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



158
159
160
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 158

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



148
149
150
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 148

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 



677
678
679
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 677

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



163
164
165
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 163

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



168
169
170
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 168

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 



643
644
645
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 643

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 



672
673
674
675
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 672

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) 


121
122
123
124
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 121

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

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

Parameters:

  • content_id (UUID) 


399
400
401
402
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 399

def stub_publishing_api_does_not_have_item(content_id)
  url = PUBLISHING_API_V2_ENDPOINT + "/content/" + content_id
  stub_request(:get, url).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) 


538
539
540
541
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 538

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: {}) 


607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 607

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: 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_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: {}) 


312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 312

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_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



494
495
496
497
498
499
500
501
502
503
504
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 494

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 if !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



347
348
349
350
351
352
353
354
355
356
357
358
359
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 347

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

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

  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) 


372
373
374
375
376
377
378
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 372

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) 


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

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) 


364
365
366
367
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 364

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



576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 576

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



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

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



530
531
532
533
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 530

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.



554
555
556
557
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 554

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) 


762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 762

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: 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: publishing_app, base_path: path }.to_json)
end

#stub_publishing_api_isnt_available ⇒ Object

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



189
190
191
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 189

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) 


50
51
52
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 50

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) 


67
68
69
70
71
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 67

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: {}) 


726
727
728
729
730
731
732
733
734
735
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 726

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: 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: {}) 


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

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: 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: {}) 


33
34
35
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 33

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) 


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

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: {}) 


660
661
662
663
664
665
666
667
668
669
670
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 660

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: 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: {}) 


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

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: 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: {}) 


792
793
794
795
796
797
798
799
800
801
802
803
804
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 792

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: message, fields: error_fields }

  stub_request(:put, "#{PUBLISHING_API_ENDPOINT}/paths#{base_path}").
    to_return(status: 422,
              headers: { content_type: "application/json" },
              body: { error: error }.to_json)
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) 


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

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 



631
632
633
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 631

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 



639
640
641
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 639

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 



635
636
637
 
# File 'lib/gds_api/test_helpers/publishing_api.rb', line 635

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