publishing_api.rb

require "gds_api/test_helpers/json_client_helper"
require "gds_api/test_helpers/content_item_helpers"
require "json"

module GdsApi
  module TestHelpers
    # @api documented
    module PublishingApi
      include ContentItemHelpers

      PUBLISHING_API_V2_ENDPOINT = "#{Plek.find('publishing-api')}/v2".freeze
      PUBLISHING_API_ENDPOINT = Plek.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:).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:).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 request to the publishing API
      def stub_any_publishing_api_call
        stub_request(:any, %r{\A#{PUBLISHING_API_ENDPOINT}})
      end

      # Stub any 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_ENDPOINT}})
          .to_return(status: 404, headers: { "Content-Type" => "application/json; charset=utf-8" })
      end

      # Stub any request to the publishing API to return a 503 response
      def stub_publishing_api_isnt_available
        stub_request(:any, /#{PUBLISHING_API_ENDPOINT}\/.*/).to_return(status: 503)
      end

      # Stub a POST /graphql request
      #
      # @param query [String]
      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 a POST /graphql content item request
      #
      # @param query [String]
      def stub_publishing_api_graphql_content_item(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

      # 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)
        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

      # Get a request matcher that checks if a JSON request includes a set of attributes
      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

      # Get a request matcher that checks if a JSON request matches a hash
      def request_json_matches(required_attributes)
        lambda do |request|
          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

      # Stub GET /v2/content/:content_id/embedded to return a list of content items that embed the target content_id
      #
      # @example
      #
      #   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
      #     rollup: {
      #       "views" => 1
      #       "locations" => 1
      #       "instances" => 1
      #       "organisations" => 1
      #     } # metadata with the total counts across all pages
      #   )
      # @param content_id [UUID]
      # @param total Integer
      # @param total_pages Integer
      # @param results [Array]
      # @param rollup [Hash]
      def stub_publishing_api_has_embedded_content(
        content_id:,
        total: 0,
        total_pages: 0,
        results: [],
        page_number: nil,
        order: nil,
        rollup: {}
      )
        url = "#{PUBLISHING_API_V2_ENDPOINT}/content/#{content_id}/host-content"

        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,
            "rollup" => rollup,
            "results" => results,
          }.to_json)
      end

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

        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,
            "rollup" => rollup,
            "results" => results,
          }.to_json)
      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 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 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, 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 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 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 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:,
          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

      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

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

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

      # Stub a PUT /publish-intent/:base_path request with the given base_path
      # and request body.
      #
      # @example
      #   stub_publishing_api_put_intent(
      #     "/path/to/content",
      #     publishing_app: "publisher",
      #     rendering_app: "frontend",
      #     publish_time: "2019-11-11T17:56:17+00:00",
      #   )
      #
      # @param base_path [String]
      # @param params [Hash]
      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

      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

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

      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

      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

      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

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

      # Stub a PUT /paths/:base_path request with the given base_path and
      # request body.
      #
      # @example
      #   stub_publishing_api_path_reservation(
      #     "/path/to",
      #     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:).to_json,
        }

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

      # 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:)
          {
            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)
        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 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?

        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 a request to get a schema by schema name
      #
      # @param [String] schema name
      #
      # @example
      #   stub_publishing_api_has_schemas_for_schema_name(
      #     "email_address",
      #     { "email_address" =>  {
      #         "type": "email_address",
      #         "required": ["email"],
      #         "properties": {
      #           "email": { "type" => "string" },
      #         },
      #       },
      #     }
      #   )
      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

      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 a request to get all schemas
      #
      #
      # @example
      #   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" },
      #           },
      #         }
      #     }
      #   )
      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

    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:).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: }
        stub_request(:delete, url).with(body:).to_return(status: code, body: "{}", headers: { "Content-Type" => "application/json; charset=utf-8" })
      end

      def values_match_recursively(expected_value, actual_value)
        case expected_value
        when Hash
          return false unless actual_value.is_a?(Hash)

          expected_value.all? do |expected_sub_key, expected_sub_value|
            actual_value.key?(expected_sub_key.to_s) &&
              values_match_recursively(expected_sub_value, actual_value[expected_sub_key.to_s])
          end
        when Array
          return false unless actual_value.is_a?(Array)
          return false unless actual_value.size == expected_value.size

          expected_value.each.with_index.all? do |expected_sub_value, i|
            values_match_recursively(expected_sub_value, actual_value[i])
          end
        else
          expected_value == actual_value
        end
      end

      def content_item_for_publishing_api(base_path, publishing_app = "publisher")
        content_item_for_base_path(base_path).merge("publishing_app" => publishing_app)
      end
    end
  end
end