gds-api-adapters 63.0.0 → 63.1.0

data/lib/gds_api/test_helpers/publishing_api.rb

@@ -5,12 +5,630 @@ require "json"
 
 module GdsApi
   module TestHelpers
+    # @api documented
     module PublishingApi
       include ContentItemHelpers
       include IntentHelpers
 
+      PUBLISHING_API_V2_ENDPOINT = Plek.current.find("publishing-api") + "/v2"
       PUBLISHING_API_ENDPOINT = Plek.current.find("publishing-api")
 
+      # 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:
+      # {status: 200, body: '{}', headers: {"Content-Type" => "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:
+      # @example
+      #   stub_publishing_api_put_content(my_content_id, my_request_body, { status: 201, body: {version: 33}.to_json })
+      #
+      # @example
+      #   stub_publishing_api_put_content(my_content_id, my_request_body, { status: 201, body: {version: 33} })
+      #
+      # @param content_id [UUID]
+      # @param body  [String]
+      # @param response_hash [Hash]
+      def stub_publishing_api_put_content(content_id, body, response_hash = {})
+        stub_publishing_api_put(content_id, body, "/content", response_hash)
+      end
+
+      # Stub a PATCH /v2/links/:content_id request
+      #
+      # @example
+      #   stub_publishing_api_patch_links(
+      #     my_content_id,
+      #     "links" => {
+      #       "taxons" => %w(level_one_topic level_two_topic),
+      #     },
+      #     "previous_version" => 3,
+      #   )
+      #
+      # @param content_id [UUID]
+      # @param body  [String]
+      def stub_publishing_api_patch_links(content_id, body)
+        stub_publishing_api_patch(content_id, body, "/links")
+      end
+
+      # Stub a PATCH /v2/links/:content_id request to return a 409 response
+      #
+      # @example
+      #   stub_publishing_api_patch_links_conflict(
+      #     my_content_id,
+      #     "links" => {
+      #       "taxons" => %w(level_one_topic level_two_topic),
+      #     },
+      #     "previous_version" => 3,
+      #   )
+      #
+      # @param content_id [UUID]
+      # @param body  [String]
+      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 a POST /v2/content/:content_id/publish request
+      #
+      # @param content_id [UUID]
+      # @param body  [String]
+      # @param response_hash [Hash]
+      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 a POST /v2/content/:content_id/republish request
+      #
+      # @param content_id [UUID]
+      # @param body  [String]
+      # @param response_hash [Hash]
+      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 a POST /v2/content/:content_id/unpublish request
+      #
+      # @param content_id [UUID]
+      # @param params [Hash]
+      # @param body  [String]
+      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 a POST /v2/content/:content_id/discard-draft request
+      #
+      # @param content_id [UUID]
+      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 requests issued when publishing a new draft.
+      # - PUT /v2/content/:content_id
+      # - POST /v2/content/:content_id/publish
+      # - PATCH /v2/links/:content_id
+      #
+      # @param body  [String]
+      # @param content_id [UUID]
+      # @param publish_body [Hash]
+      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 any PUT /v2/content/* request
+      def stub_any_publishing_api_put_content
+        stub_request(:put, %r{\A#{PUBLISHING_API_V2_ENDPOINT}/content/})
+      end
+
+      # Stub any PATCH /v2/links/* request
+      def stub_any_publishing_api_patch_links
+        stub_request(:patch, %r{\A#{PUBLISHING_API_V2_ENDPOINT}/links/})
+      end
+
+      # Stub any POST /v2/content/*/publish request
+      def stub_any_publishing_api_publish
+        stub_request(:post, %r{\A#{PUBLISHING_API_V2_ENDPOINT}/content/.*/publish})
+      end
+
+      # Stub any POST /v2/content/*/publish request
+      def stub_any_publishing_api_republish
+        stub_request(:post, %r{\A#{PUBLISHING_API_V2_ENDPOINT}/content/.*/republish})
+      end
+
+      # Stub any POST /v2/content/*/unpublish request
+      def stub_any_publishing_api_unpublish
+        stub_request(:post, %r{\A#{PUBLISHING_API_V2_ENDPOINT}/content/.*/unpublish})
+      end
+
+      # Stub any POST /v2/content/*/discard-draft request
+      def stub_any_publishing_api_discard_draft
+        stub_request(:post, %r{\A#{PUBLISHING_API_V2_ENDPOINT}/content/.*/discard-draft})
+      end
+
+      # Stub any version 2 request to the publishing API
+      def stub_any_publishing_api_call
+        stub_request(:any, %r{\A#{PUBLISHING_API_V2_ENDPOINT}})
+      end
+
+      # Stub any version 2 request to the publishing API to return a 404 response
+      def stub_any_publishing_api_call_to_return_not_found
+        stub_request(:any, %r{\A#{PUBLISHING_API_V2_ENDPOINT}})
+          .to_return(status: 404, headers: { "Content-Type" => "application/json; charset=utf-8" })
+      end
+
+      # Stub any version 2 request to the publishing API to return a 503 response
+      def stub_publishing_api_isnt_available
+        stub_request(:any, /#{PUBLISHING_API_V2_ENDPOINT}\/.*/).to_return(status: 503)
+        stub_request(:any, /#{PUBLISHING_API_ENDPOINT}\/.*/).to_return(status: 503)
+      end
+
+      # 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
+      #
+      # @param body  [String]
+      # @param content_id [UUID]
+      # @param publish_body [Hash]
+      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 that content was saved (PUT /v2/content/:content_id)
+      #
+      # @param content_id [UUID]
+      # @param attributes_or_matcher [Object]
+      # @param times [Integer]
+      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 that content was published (POST /v2/content/:content_id/publish)
+      #
+      # @param content_id [UUID]
+      # @param attributes_or_matcher [Object]
+      # @param times [Integer]
+      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 that content was unpublished (POST /v2/content/:content_id/unpublish)
+      #
+      # @param content_id [UUID]
+      # @param attributes_or_matcher [Object]
+      # @param times [Integer]
+      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
+
+      # Assert that links were updated (PATCH /v2/links/:content_id)
+      #
+      # @param content_id [UUID]
+      # @param attributes_or_matcher [Object]
+      # @param times [Integer]
+      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 that a draft was discarded (POST /v2/content/:content_id/discard-draft)
+      #
+      # @param content_id [UUID]
+      # @param attributes_or_matcher [Object]
+      # @param times [Integer]
+      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 that a request was made to the publishing API
+      #
+      # @param verb [String]
+      # @param url [String]
+      # @param attributes_or_matcher [Object]
+      # @param times [Integer]
+      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
+
+      # Get a request matcher that checks if a JSON request includes a set of attributes
+      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
+
+      # Get a request matcher that checks if a JSON request matches a hash
+      def request_json_matches(required_attributes)
+        ->(request) do
+          data = JSON.parse(request.body)
+          deep_stringify_keys(required_attributes) == data
+        end
+      end
+
+      # Stub GET /v2/content/ to return a set of content items
+      #
+      # @example
+      #
+      #   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
+      #   )
+      # @param items [Array]
+      # @param params [Hash]
+      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
+
+      # 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
+      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 GET /v2/linkables to return a set of content items with a specific document type
+      #
+      # @param linkables [Array]
+      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 GET /v2/content/:content_id to return a specific content item hash
+      #
+      # @param item [Hash]
+      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 GET /v2/content/:content_id to progress through a series of responses.
+      #
+      # @param items [Array]
+      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 GET /v2/content/:content_id to return a 404 response
+      #
+      # @param content_id [UUID]
+      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 a request to links endpoint
+      #
+      # @param [Hash] links the structure of the links hash
+      #
+      # @example
+      #
+      #  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
+      #    }
+      #  )
+      #
+      # @example
+      #
+      #   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
+      #      }
+      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 a request to the expanded links endpoint
+      #
+      # @param [Hash] links the structure of the links hash
+      #
+      # @example
+      #   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",
+      #             # ...
+      #           },
+      #         ]
+      #       }
+      #     }
+      #   )
+      #
+      # @example
+      #   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",
+      #               ...
+      #             },
+      #           ]
+      #         }
+      #       }
+      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 a request to get links for content ids
+      #
+      # @param [Hash] links the links for each content id
+      #
+      # @example
+      #   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" => {}
+      #       }
+      #     }
+      #   )
+      #
+      # @example
+      #   Services.publishing_api.get_links_for_content_ids(["2878337b-bed9-4e7f-85b6-10ed2cbcd504"])
+      #   =>  {
+      #         "2878337b-bed9-4e7f-85b6-10ed2cbcd504" => {
+      #           "links" => [
+      #             "eb6965c7-3056-45d0-ae50-2f0a5e2e0854"
+      #           ]
+      #         }
+      #       }
+      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 GET /v2/links/:content_id to return a 404 response
+      #
+      # @param content_id [UUID]
+      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 calls to the lookups endpoint
+      #
+      # @param lookup_hash [Hash] Hash with base_path as key, content_id as value.
+      #
+      # @example
+      #
+      #   stub_publishing_api_has_lookups({
+      #     "/foo" => "51ac4247-fd92-470a-a207-6b852a97f2db",
+      #     "/bar" => "261bd281-f16c-48d5-82d2-9544019ad9ca"
+      #   })
+      #
+      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 calls to the get linked items endpoint
+      #
+      # @param items [Array] The linked items we wish to return
+      # @param params [Hash] A hash of parameters
+      #
+      # @example
+      #
+      #   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"]
+      #     }
+      #   )
+      #
+      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 GET /v2/editions to return a set of editions
+      #
+      # @example
+      #
+      #   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
+      #   )
+      # @param items [Array]
+      # @param params [Hash]
+      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
+
       def stub_publishing_api_unreserve_path(base_path, publishing_app = /.*/)
         stub_publishing_api_unreserve_path_with_code(base_path, publishing_app, 200)
       end
@@ -34,7 +652,7 @@ module GdsApi
         stub_request(:delete, url).to_return(status: 200, body: "{}", headers: { "Content-Type" => "application/json; charset=utf-8" })
       end
 
-      def stub_default_publishing_api_put_intent
+      def stub_any_publishing_api_put_intent
         stub_request(:put, %r{\A#{PUBLISHING_API_ENDPOINT}/publish-intent})
       end
 
@@ -71,48 +689,171 @@ module GdsApi
         end
       end
 
-      def stub_publishing_api_isnt_available
-        stub_request(:any, /#{PUBLISHING_API_ENDPOINT}\/.*/).to_return(status: 503)
+      # Stub a PUT /paths/:base_path request with the given content id and request body.
+      #
+      # @example
+      #   stub_publishing_api_path_reservation(
+      #     my_content_id,
+      #     publishing_app: "content-publisher",
+      #     override_existing: true,
+      #   )
+      #
+      # @param base_path [String]
+      # @param params [Hash]
+      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
 
-      def stub_default_publishing_api_path_reservation
-        stub_request(:put, %r[\A#{PUBLISHING_API_ENDPOINT}/paths/]).to_return { |request|
-          base_path = request.uri.path.sub(%r{\A/paths/}, "")
-          { status: 200, headers: { content_type: "application/json" },
-            body: publishing_api_path_data_for(base_path).to_json }
-        }
+      # Stub all PUT /paths/:base_path requests
+      #
+      # @example
+      #   stub_any_publishing_api_path_reservation
+      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 a PUT /paths/:base_path request for a particular publishing
+      # application. Calling for a different publishing application will return
+      # a 422 response.
+      #
+      # @example
+      #   stub_publishing_api_has_path_reservation_for("/foo", "content-publisher")
+      #
+      # @param base_path [String]
+      # @param publishing_app [String]
       def stub_publishing_api_has_path_reservation_for(path, publishing_app)
-        data = publishing_api_path_data_for(path, "publishing_app" => publishing_app)
-        error_data = data.merge("errors" => { "path" => ["is already reserved by the #{publishing_app} application"] })
+        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, body: error_data.to_json,
-                            headers: { content_type: "application/json" })
+                  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: data.to_json)
+                    body: { publishing_app: publishing_app, base_path: path }.to_json)
       end
 
-      def stub_publishing_api_returns_path_reservation_validation_error_for(path, error_details = nil)
-        error_details ||= { "base" => ["computer says no"] }
-        error_data = publishing_api_path_data_for(path).merge("errors" => error_details)
+      # Stub a PUT /paths/:base_path request for a particular publishing
+      # application. Calling for a different publishing application will return
+      # a 422 response.
+      #
+      # @example
+      #   stub_publishing_api_returns_path_reservation_validation_error_for(
+      #     "/foo",
+      #     "field" => ["error 1", "error 2"]
+      #   )
+      #
+      # @param base_path [String]
+      # @param error_fields [Hash]
+      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?
 
-        stub_request(:put, "#{PUBLISHING_API_ENDPOINT}/paths#{path}").
-          to_return(status: 422, body: error_data.to_json, headers: { content_type: "application/json" })
+        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
 
       # Aliases for DEPRECATED methods
       alias_method :publishing_api_isnt_available, :stub_publishing_api_isnt_available
+      alias_method :publishing_api_has_content, :stub_publishing_api_has_content
+      alias_method :publishing_api_has_fields_for_document, :stub_publishing_api_has_fields_for_document
+      alias_method :publishing_api_has_linkables, :stub_publishing_api_has_linkables
+      alias_method :publishing_api_has_item, :stub_publishing_api_has_item
+      alias_method :publishing_api_has_item_in_sequence, :stub_publishing_api_has_item_in_sequence
+      alias_method :publishing_api_does_not_have_item, :stub_publishing_api_does_not_have_item
+      alias_method :publishing_api_has_links, :stub_publishing_api_has_links
+      alias_method :publishing_api_has_expanded_links, :stub_publishing_api_has_expanded_links
+      alias_method :publishing_api_has_links_for_content_ids, :stub_publishing_api_has_links_for_content_ids
+      alias_method :publishing_api_does_not_have_links, :stub_publishing_api_does_not_have_links
+      alias_method :publishing_api_has_lookups, :stub_publishing_api_has_lookups
+      alias_method :publishing_api_has_linked_items, :stub_publishing_api_has_linked_items
+      alias_method :publishing_api_get_editions, :stub_publishing_api_get_editions
       alias_method :publishing_api_has_path_reservation_for, :stub_publishing_api_has_path_reservation_for
       alias_method :publishing_api_returns_path_reservation_validation_error_for, :stub_publishing_api_returns_path_reservation_validation_error_for
+      alias_method :stub_default_publishing_api_path_reservation, :stub_any_publishing_api_path_reservation
+      alias_method :stub_default_publishing_api_put_intent, :stub_any_publishing_api_put_intent
 
     private
 
+      def stub_publishing_api_put(*args)
+        stub_publishing_api_postlike_call(:put, *args)
+      end
+
+      def stub_publishing_api_patch(*args)
+        stub_publishing_api_postlike_call(:patch, *args)
+      end
+
+      def stub_publishing_api_postlike_call(method, content_id, body, resource_path, override_response_hash = {})
+        response_hash = { status: 200, body: "{}", headers: { "Content-Type" => "application/json; charset=utf-8" } }
+        response_hash.merge!(override_response_hash)
+        response_hash[:body] = response_hash[:body].to_json if response_hash[:body].is_a?(Hash)
+        url = PUBLISHING_API_V2_ENDPOINT + resource_path + "/" + content_id
+        stub_request(method, url).with(body: body).to_return(response_hash)
+      end
+
+      def deep_stringify_keys(hash)
+        deep_transform_keys(hash, &:to_s)
+      end
+
+      def deep_transform_keys(object, &block)
+        case object
+        when Hash
+          object.each_with_object({}) do |(key, value), result|
+            result[yield(key)] = deep_transform_keys(value, &block)
+          end
+        when Array
+          object.map { |item| deep_transform_keys(item, &block) }
+        else
+          object
+        end
+      end
+
+      def resource_not_found(content_id, type)
+        {
+          error: {
+            code: 404,
+            message: "Could not find #{type} with content_id: #{content_id}",
+          },
+        }
+      end
+
+      def version_conflict(expected_version, actual_version = expected_version + 1)
+        {
+          error: {
+            code: 409,
+            message: "A lock-version conflict occurred. The `previous_version` you've sent (#{expected_version}) is not the same as the current lock version of the edition (#{actual_version}).",
+            fields: { previous_version: ["does not match"] },
+          },
+        }
+      end
+
       def stub_publishing_api_unreserve_path_with_code(base_path, publishing_app, code)
         url = PUBLISHING_API_ENDPOINT + "/paths" + base_path
         body = { publishing_app: publishing_app }
@@ -147,16 +888,6 @@ module GdsApi
       def intent_for_publishing_api(base_path, publishing_app = "publisher")
         intent_for_base_path(base_path).merge("publishing_app" => publishing_app)
       end
-
-      def publishing_api_path_data_for(path, override_attributes = {})
-        now = Time.zone.now.utc.iso8601
-        {
-          "path" => path,
-          "publishing_app" => "foo-publisher",
-          "created_at" => now,
-          "updated_at" => now,
-        }.merge(override_attributes)
-      end
     end
   end
 end