publishing_platform_api_adapters 0.8.3 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 33684b80242329f1ddf7d6fd786c86adffa6118b3f9b4e4d81243148d90755c0
-  data.tar.gz: 3b3c0d5c7ea79a368629f349b71432e374b19f989d4a176b08b28c829e609f64
+  metadata.gz: c6ec8b5ba55f54de30a2717ff57716d1e121ca531cbcc86208e653dda3f2c675
+  data.tar.gz: 652114d6c57ea3550e48bd039ec2769617e9721e20a46ae069759ad8be072bfd
 SHA512:
-  metadata.gz: 1189194963db42488c2dcd753b9fe0e41c43adcaf002cef403d2ae4b864af4d959398f4fedc34247dce88e2d2d2df3ea41b5800054e4a9ae17242bbea9042d01
-  data.tar.gz: e43738770632d4739fe78080e4faf2b1067294e456366e7fa0b7b8218d1d292978485c1ec13f6e2642c1a888bf52e657c1c6741fbb5982dbd0261a160141b0e1
+  metadata.gz: 3c19ef7a204e52ad5179dae74e62399a52ed2005c0b6020166f93ed083183ecb2a26bdc355a967a1b147eecb1666a758a09fb5c00e9ce2a328500a630134832d
+  data.tar.gz: 3e6f94598b557c5494a6399e0b6b9de732944ee7ed8dfc48037a53d31fc3d0905cbba7dc34d6e5b68ecde14a7c515b12a72baaab8b6af0dec90caf7d0e57b725

data/lib/publishing_platform_api/response.rb

@@ -61,7 +61,7 @@ module PublishingPlatformApi
       alias_method :r_maxage, :reverse_max_age
 
       def shared_max_age
-        self["s-maxage"].to_i if key?("r-maxage")
+        self["s-maxage"].to_i if key?("s-maxage")
       end
       alias_method :s_maxage, :shared_max_age
 

data/lib/publishing_platform_api/router.rb

@@ -1,20 +1,6 @@
 require_relative "base"
 
 class PublishingPlatformApi::Router < PublishingPlatformApi::Base
-  ### Backends
-
-  def get_backend(id)
-    get_json("#{endpoint}/backends/#{CGI.escape(id)}")
-  end
-
-  def add_backend(id, url)
-    put_json("#{endpoint}/backends/#{CGI.escape(id)}", backend: { backend_url: url })
-  end
-
-  def delete_backend(id)
-    delete_json("#{endpoint}/backends/#{CGI.escape(id)}")
-  end
-
   ### Routes
 
   def get_route(path)

data/lib/publishing_platform_api/test_helpers/common_responses.rb

@@ -0,0 +1,41 @@
+module PublishingPlatformApi
+  module TestHelpers
+    module CommonResponses
+      def titleize_slug(slug, options = {})
+        if options[:title_case]
+          slug.tr("-", " ").gsub(/\b./, &:upcase)
+        else
+          slug.tr("-", " ").capitalize
+        end
+      end
+
+      # expects a slug like "ministry-of-funk"
+      # returns an acronym like "MOF"
+      def acronymize_slug(slug)
+        initials = slug.gsub(/\b\w+/) { |m| m[0] }.delete("-")
+        initials.upcase
+      end
+
+      def response_base
+        {
+          "_response_info" => {
+            "status" => "ok",
+          },
+        }
+      end
+      alias_method :singular_response_base, :response_base
+
+      def plural_response_base
+        response_base.merge(
+          "description" => "Tags!",
+          "total" => 100,
+          "start_index" => 1,
+          "page_size" => 100,
+          "current_page" => 1,
+          "pages" => 1,
+          "results" => [],
+        )
+      end
+    end
+  end
+end

data/lib/publishing_platform_api/test_helpers/organisations.rb

@@ -0,0 +1,103 @@
+# require "gds_api/test_helpers/json_client_helper"
+require "publishing_platform_api/test_helpers/common_responses"
+# require "plek"
+# require "securerandom"
+
+module PublishingPlatformApi
+  module TestHelpers
+    module Organisations
+      include PublishingPlatformApi::TestHelpers::CommonResponses
+
+      WEBSITE_ROOT = PublishingPlatformLocation.new.website_root
+
+      def stub_organisations_api_has_organisations(organisation_slugs)
+        bodies = organisation_slugs.map { |slug| organisation_for_slug(slug) }
+        stub_organisations_api_has_organisations_with_bodies(bodies)
+      end
+
+      # Sets up the index endpoints for the given organisation slugs
+      # The stubs are setup to paginate in chunks of 20
+      #
+      # This also sets up the individual endpoints for each slug
+      # by calling organisations_api_has_organisation below
+      def stub_organisations_api_has_organisations_with_bodies(organisation_bodies)
+        # Stub API call to the endpoint for an individual organisation
+        organisation_bodies.each do |body|
+          slug = body["details"]["slug"]
+          stub_organisations_api_has_organisation(slug, body)
+        end
+
+        pages = []
+        organisation_bodies.each_slice(20) do |bodies|
+          pages << bodies
+        end
+
+        pages.each_with_index do |page, i|
+          page_details = plural_response_base.merge(
+            "results" => page,
+            "total" => organisation_bodies.size,
+            "pages" => pages.size,
+            "current_page" => i + 1,
+            "page_size" => 20,
+            "start_index" => i * 20 + 1,
+          )
+
+          links = { self: "#{WEBSITE_ROOT}/api/organisations?page=#{i + 1}" }
+          links[:next] = "#{WEBSITE_ROOT}/api/organisations?page=#{i + 2}" if pages[i + 1]
+          links[:previous] = "#{WEBSITE_ROOT}/api/organisations?page=#{i}" unless i.zero?
+          page_details["_response_info"]["links"] = []
+          link_headers = []
+          links.each do |rel, href|
+            page_details["_response_info"]["links"] << { "rel" => rel, "href" => href }
+            link_headers << "<#{href}>; rel=\"#{rel}\""
+          end
+
+          stub_request(:get, links[:self])
+            .to_return(status: 200, body: page_details.to_json, headers: { "Link" => link_headers.join(", ") })
+
+          next unless i.zero?
+
+          # First page exists at URL with and without page param
+          stub_request(:get, links[:self].sub(/\?page=1/, ""))
+            .to_return(status: 200, body: page_details.to_json, headers: { "Link" => link_headers.join(", ") })
+        end
+
+        if pages.empty?
+          # If there are no pages - and so no organisations specified - then stub /api/organisations.
+          stub_request(:get, "#{WEBSITE_ROOT}/api/organisations").to_return(status: 200, body: plural_response_base.to_json, headers: {})
+        end
+      end
+
+      def stub_organisations_api_has_organisation(organisation_slug, details = nil)
+        details ||= organisation_for_slug(organisation_slug)
+        stub_request(:get, "#{WEBSITE_ROOT}/api/organisations/#{organisation_slug}")
+          .to_return(status: 200, body: details.to_json)
+      end
+
+      def stub_organisations_api_does_not_have_organisation(organisation_slug)
+        stub_request(:get, "#{WEBSITE_ROOT}/api/organisations/#{organisation_slug}").to_return(status: 404)
+      end
+
+      def organisation_for_slug(slug)
+        singular_response_base.merge(organisation_details_for_slug(slug))
+      end
+
+      # Constructs a sample organisation
+      def organisation_details_for_slug(slug, content_id = SecureRandom.uuid)
+        {
+          "id" => "#{WEBSITE_ROOT}/api/organisations/#{slug}",
+          "title" => titleize_slug(slug, title_case: true),
+          "format" => "Department",
+          "updated_at" => "2013-03-25T13:06:42+00:00",
+          "web_url" => "#{WEBSITE_ROOT}/government/organisations/#{slug}",
+          "details" => {
+            "slug" => slug,
+            "abbreviation" => acronymize_slug(slug),
+            "status" => "live",
+            "content_id" => content_id,
+          },
+        }
+      end
+    end
+  end
+end

data/lib/publishing_platform_api/test_helpers/publishing_api.rb

@@ -0,0 +1,762 @@
+require "publishing_platform_api/test_helpers/content_item_helpers"
+require "json"
+
+module PublishingPlatformApi
+  module TestHelpers
+    # @api documented
+    module PublishingApi
+      include ContentItemHelpers
+
+      PUBLISHING_API_ENDPOINT = PublishingPlatformLocation.find("publishing-api")
+
+      # Stub a PUT /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 /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 /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 /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_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 /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_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 /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_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 /content/:content_id/discard-draft request
+      #
+      # @param content_id [UUID]
+      def stub_publishing_api_discard_draft(content_id)
+        url = PUBLISHING_API_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 /content/:content_id
+      # - POST /content/:content_id/publish
+      # - PATCH /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 /content/* request
+      def stub_any_publishing_api_put_content
+        stub_request(:put, %r{\A#{PUBLISHING_API_ENDPOINT}/content/})
+      end
+
+      # Stub any PATCH /links/* request
+      def stub_any_publishing_api_patch_links
+        stub_request(:patch, %r{\A#{PUBLISHING_API_ENDPOINT}/links/})
+      end
+
+      # Stub any POST /content/*/publish request
+      def stub_any_publishing_api_publish
+        stub_request(:post, %r{\A#{PUBLISHING_API_ENDPOINT}/content/.*/publish})
+      end
+
+      # Stub any POST /content/*/publish request
+      def stub_any_publishing_api_republish
+        stub_request(:post, %r{\A#{PUBLISHING_API_ENDPOINT}/content/.*/republish})
+      end
+
+      # Stub any POST /content/*/unpublish request
+      def stub_any_publishing_api_unpublish
+        stub_request(:post, %r{\A#{PUBLISHING_API_ENDPOINT}/content/.*/unpublish})
+      end
+
+      # Stub any POST /content/*/discard-draft request
+      def stub_any_publishing_api_discard_draft
+        stub_request(:post, %r{\A#{PUBLISHING_API_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
+
+      # Assert that a draft was saved and published, and links were updated.
+      # - PUT /content/:content_id
+      # - POST /content/:content_id/publish
+      # - PATCH /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 /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_ENDPOINT}/content/#{content_id}"
+        assert_publishing_api(:put, url, attributes_or_matcher, times)
+      end
+
+      # Assert that content was published (POST /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_ENDPOINT + "/content/#{content_id}/publish"
+        assert_publishing_api(:post, url, attributes_or_matcher, times)
+      end
+
+      # Assert that content was unpublished (POST /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_ENDPOINT + "/content/#{content_id}/unpublish"
+        assert_publishing_api(:post, url, attributes_or_matcher, times)
+      end
+
+      # Assert that links were updated (PATCH /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_ENDPOINT}/links/#{content_id}"
+        assert_publishing_api(:patch, url, attributes_or_matcher, times)
+      end
+
+      # Assert that a draft was discarded (POST /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_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 /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_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 do |item|
+          deep_stringify_keys(item).slice(*fields)
+        end
+
+        query_params = fields.map do |f|
+          "&fields%5B%5D=#{f}"
+        end
+
+        url = PUBLISHING_API_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 /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_ENDPOINT + "/linkables?document_type=#{document_type}"
+        stub_request(:get, url).to_return(status: 200, body: linkables.to_json, headers: {})
+      end
+
+      # Stub GET /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_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 /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_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 /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_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_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_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_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 /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_ENDPOINT}/links/#{content_id}"
+        stub_request(:get, url).to_return(status: 404, body: resource_not_found(content_id, "link set").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
+
+      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
+
+    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_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

data/lib/publishing_platform_api/test_helpers/router.rb

@@ -19,8 +19,8 @@ module PublishingPlatformApi
         stub_router_has_route(path, handler: "backend", backend_id:, disabled:, route_type:)
       end
 
-      def stub_router_has_redirect_route(path, redirect_to:, route_type: "exact", disabled: false)
-        stub_router_has_route(path, handler: "redirect", redirect_to:, disabled:, route_type:)
+      def stub_router_has_redirect_route(path, redirect_to:, redirect_type: "permanent", route_type: "exact", disabled: false)
+        stub_router_has_route(path, handler: "redirect", redirect_to:, redirect_type:, disabled:, route_type:)
       end
 
       def stub_router_has_gone_route(path, route_type: "exact", disabled: false)
@@ -42,13 +42,14 @@ module PublishingPlatformApi
         })
       end
 
-      def stub_redirect_registration(path, type, destination, segments_mode = nil)
+      def stub_redirect_registration(path, type, destination, redirect_type, segments_mode = nil)
         stub_route_put({
           route: {
             incoming_path: path,
             route_type: type,
             handler: "redirect",
             redirect_to: destination,
+            redirect_type:,
             segments_mode:,
           },
         })

data/lib/publishing_platform_api/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PublishingPlatformApi
-  VERSION = "0.8.3"
+  VERSION = "0.10.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: publishing_platform_api_adapters
 version: !ruby/object:Gem::Version
-  version: 0.8.3
+  version: 0.10.0
 platform: ruby
 authors:
 - Publishing Platform
@@ -79,6 +79,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: climate_control
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: publishing_platform_rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -93,6 +107,76 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: publishing_platform_schemas
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Adapters to work with Publishing Platform APIs
 executables: []
 extensions: []
@@ -114,8 +198,11 @@ files:
 - lib/publishing_platform_api/railtie.rb
 - lib/publishing_platform_api/response.rb
 - lib/publishing_platform_api/router.rb
+- lib/publishing_platform_api/test_helpers/common_responses.rb
 - lib/publishing_platform_api/test_helpers/content_item_helpers.rb
 - lib/publishing_platform_api/test_helpers/content_store.rb
+- lib/publishing_platform_api/test_helpers/organisations.rb
+- lib/publishing_platform_api/test_helpers/publishing_api.rb
 - lib/publishing_platform_api/test_helpers/router.rb
 - lib/publishing_platform_api/version.rb
 - lib/publishing_platform_api_adapters.rb