RubyGems - gds-api-adapters - Versions diffs - 38.1.0 → 39.0.0 - Mend

gds-api-adapters 38.1.0 → 39.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (55) hide show

checksums.yaml +4 -4
data/lib/gds_api/test_helpers/need_api.rb +0 -15
data/lib/gds_api/test_helpers/organisations.rb +5 -0
data/lib/gds_api/version.rb +1 -1
metadata +3 -103
data/test/asset_manager_test.rb +0 -94
data/test/business_support_api_test.rb +0 -45
data/test/content_api_test.rb +0 -712
data/test/content_store_test.rb +0 -55
data/test/email_alert_api_test.rb +0 -189
data/test/fixtures/finder_api/cma-case-schema.json +0 -103
data/test/fixtures/hello.txt +0 -1
data/test/fixtures/new_policies_for_dwp.json +0 -298
data/test/fixtures/no_services_and_info_data_found_fixture.json +0 -14
data/test/fixtures/old_policies_for_dwp.json +0 -413
data/test/fixtures/services_and_info_fixture.json +0 -73
data/test/fixtures/sub_sector_organisations.json +0 -57
data/test/fixtures/world_organisations_australia.json +0 -490
data/test/gds_api_base_test.rb +0 -110
data/test/gov_uk_delivery_test.rb +0 -67
data/test/govuk_headers_test.rb +0 -30
data/test/helpers_test.rb +0 -23
data/test/imminence_api_test.rb +0 -196
data/test/json_client_test.rb +0 -879
data/test/licence_application_api_test.rb +0 -196
data/test/list_response_test.rb +0 -189
data/test/local_links_manager_api_test.rb +0 -236
data/test/mapit_test.rb +0 -117
data/test/maslow_test.rb +0 -12
data/test/middleware/govuk_header_sniffer_test.rb +0 -18
data/test/need_api_test.rb +0 -345
data/test/organisations_api_test.rb +0 -58
data/test/panopticon_registerer_test.rb +0 -118
data/test/panopticon_test.rb +0 -190
data/test/pp_data_in_test.rb +0 -52
data/test/pp_data_out_test.rb +0 -24
data/test/publishing_api/special_route_publisher_test.rb +0 -104
data/test/publishing_api_test.rb +0 -186
data/test/publishing_api_v2/get_expanded_links_test.rb +0 -85
data/test/publishing_api_v2/get_links_test.rb +0 -89
data/test/publishing_api_v2/lookup_test.rb +0 -70
data/test/publishing_api_v2_test.rb +0 -1649
data/test/response_test.rb +0 -245
data/test/router_test.rb +0 -456
data/test/rummager_helpers_test.rb +0 -20
data/test/rummager_test.rb +0 -150
data/test/support_api_test.rb +0 -189
data/test/support_test.rb +0 -95
data/test/test_helper.rb +0 -55
data/test/test_helpers/email_alert_api_test.rb +0 -24
data/test/test_helpers/pact_helper.rb +0 -13
data/test/test_helpers/panopticon_test.rb +0 -44
data/test/test_helpers/publishing_api_test.rb +0 -129
data/test/test_helpers/publishing_api_v2_test.rb +0 -170
data/test/worldwide_api_test.rb +0 -82

data/test/publishing_api_test.rb DELETED

@@ -1,186 +0,0 @@
-require 'test_helper'
-require 'gds_api/publishing_api'
-require 'gds_api/test_helpers/publishing_api'
-describe GdsApi::PublishingApi do
-  include GdsApi::TestHelpers::PublishingApi
-  include PactTest
-  before do
-    @base_api_url = Plek.current.find("publishing-api")
-    @api_client = GdsApi::PublishingApi.new(publishing_api_host)
-  end
-  describe "#put_intent" do
-    it "responds with 200 OK if publish intent is valid" do
-      base_path = "/test-intent"
-      publish_intent = intent_for_publishing_api(base_path)
-      publishing_api
-        .given("no content exists")
-        .upon_receiving("a request to create a publish intent")
-        .with(
-          method: :put,
-          path: "/publish-intent#{base_path}",
-          body: publish_intent,
-          headers: {
-            "Content-Type" => "application/json"
-          },
-        )
-        .will_respond_with(
-          status: 200,
-          body: {},
-          headers: {
-            "Content-Type" => "application/json; charset=utf-8"
-          },
-        )
-      response = @api_client.put_intent(base_path, publish_intent)
-      assert_equal 200, response.code
-    end
-  end
-  describe "#delete_intent" do
-    it "returns 200 OK if intent existed and was deleted" do
-      base_path = "/test-intent"
-      publishing_api
-        .given("a publish intent exists at /test-intent")
-        .upon_receiving("a request to delete a publish intent")
-        .with(
-          method: :delete,
-          path: "/publish-intent#{base_path}",
-        )
-        .will_respond_with(
-          status: 200,
-          body: {},
-          headers: {
-            "Content-Type" => "application/json; charset=utf-8"
-          }
-        )
-      response = @api_client.destroy_intent(base_path)
-      assert_equal 200, response.code
-    end
-    it "returns 404 Not found if the intent does not exist" do
-      base_path = "/test-intent"
-      publishing_api
-        .given("no content exists")
-        .upon_receiving("a request to delete a publish intent")
-        .with(
-          method: :delete,
-          path: "/publish-intent#{base_path}",
-        )
-        .will_respond_with(
-          status: 404,
-          body: {},
-          headers: {
-            "Content-Type" => "application/json; charset=utf-8"
-          }
-        )
-      response = @api_client.destroy_intent(base_path)
-      assert_equal 404, response.code
-    end
-  end
-  describe "#put_path" do
-    it "returns 200 if the path was successfully reserved" do
-      base_path = "/test-intent"
-      payload = {
-        publishing_app: "publisher"
-      }
-      publishing_api
-        .given("no content exists")
-        .upon_receiving("a request to put a path")
-        .with(
-          method: :put,
-          path: "/paths#{base_path}",
-          body: payload,
-          headers: {
-            "Content-Type" => "application/json"
-          },
-        )
-        .will_respond_with(
-          status: 200,
-          body: {},
-          headers: {
-            "Content-Type" => "application/json; charset=utf-8"
-          }
-        )
-      response = @api_client.put_path(base_path, payload)
-      assert_equal 200, response.code
-    end
-    it "returns 422 if the request is invalid" do
-      base_path = "/test-item"
-      payload = {
-        publishing_app: "whitehall"
-      }
-      publishing_api
-        .given("/test-item has been reserved by the Publisher application")
-        .upon_receiving("a request to change publishing app")
-        .with(
-          method: :put,
-          path: "/paths#{base_path}",
-          body: payload,
-          headers: {
-            "Content-Type" => "application/json"
-          },
-        )
-        .will_respond_with(
-          status: 422,
-          body: {
-            "error" => {
-              "code" => 422,
-              "message" => Pact.term(generate: "Unprocessable", matcher: /\S+/),
-              "fields" => {
-                "base_path" => Pact.each_like("has been reserved", min: 1),
-              },
-            },
-          },
-        )
-      error = assert_raises GdsApi::HTTPClientError do
-        @api_client.put_path(base_path, payload)
-      end
-      assert_equal "Unprocessable", error.error_details["error"]["message"]
-    end
-    it "returns 200 if an existing path was overridden" do
-      base_path = "/test-item"
-      payload = {
-        publishing_app: "whitehall",
-        override_existing: "true",
-      }
-      publishing_api
-        .given("/test-item has been reserved by the Publisher application")
-        .upon_receiving("a request to change publishing app with override_existing set")
-        .with(
-          method: :put,
-          path: "/paths#{base_path}",
-          body: payload,
-          headers: {
-            "Content-Type" => "application/json"
-          },
-        )
-        .will_respond_with(
-          status: 200,
-          body: {},
-          headers: {
-            "Content-Type" => "application/json; charset=utf-8"
-          }
-        )
-      response = @api_client.put_path(base_path, payload)
-      assert_equal 200, response.code
-    end
-  end
-end

data/test/publishing_api_v2/get_expanded_links_test.rb DELETED

@@ -1,85 +0,0 @@
-require 'test_helper'
-require 'gds_api/publishing_api_v2'
-require 'json'
-describe GdsApi::PublishingApiV2 do
-  include PactTest
-  before do
-    @api_client = GdsApi::PublishingApiV2.new(publishing_api_host)
-    @content_id = "bed722e6-db68-43e5-9079-063f623335a7"
-  end
-  describe "#get_expanded_links" do
-    it "responds with the links when there's a links entry with links" do
-      publishing_api
-        .given("organisation links exist for content_id #{@content_id}")
-        .upon_receiving("a get-expanded-links request")
-        .with(
-          method: :get,
-          path: "/v2/expanded-links/#{@content_id}",
-        )
-        .will_respond_with(
-          status: 200,
-          body: {
-            expanded_links: {
-              organisations: [
-                { content_id: "20583132-1619-4c68-af24-77583172c070" }
-              ]
-            }
-          }
-        )
-      response = @api_client.get_expanded_links(@content_id)
-      expected_body = {
-        "expanded_links" => {
-          "organisations" => [
-            { "content_id" => "20583132-1619-4c68-af24-77583172c070" }
-          ]
-        }
-      }
-      assert_equal 200, response.code
-      assert_equal expected_body, response.to_h
-    end
-    it "responds with the empty thing set if there's an empty link set" do
-      publishing_api
-        .given("empty links exist for content_id #{@content_id}")
-        .upon_receiving("a get-expanded-links request")
-        .with(
-          method: :get,
-          path: "/v2/expanded-links/#{@content_id}",
-        )
-        .will_respond_with(
-          status: 200,
-          body: {
-            expanded_links: {
-            }
-          }
-        )
-      response = @api_client.get_expanded_links(@content_id)
-      assert_equal 200, response.code
-      assert_equal({}, response.to_h['expanded_links'])
-    end
-    it "responds with 404 if there's no link set entry" do
-      publishing_api
-        .given("no links exist for content_id #{@content_id}")
-        .upon_receiving("a get-expanded-links request")
-        .with(
-          method: :get,
-          path: "/v2/expanded-links/#{@content_id}",
-        )
-        .will_respond_with(
-          status: 404
-        )
-      assert_raises(GdsApi::HTTPNotFound) do
-        @api_client.get_expanded_links(@content_id)
-      end
-    end
-  end
-end

data/test/publishing_api_v2/get_links_test.rb DELETED

@@ -1,89 +0,0 @@
-require 'test_helper'
-require 'gds_api/publishing_api_v2'
-require 'json'
-describe GdsApi::PublishingApiV2 do
-  include PactTest
-  before do
-    @api_client = GdsApi::PublishingApiV2.new(publishing_api_host)
-    @content_id = "bed722e6-db68-43e5-9079-063f623335a7"
-  end
-  describe "#get_links" do
-    describe "when there's a links entry with links" do
-      before do
-        publishing_api
-          .given("organisation links exist for content_id #{@content_id}")
-          .upon_receiving("a get-links request")
-          .with(
-            method: :get,
-            path: "/v2/links/#{@content_id}",
-          )
-          .will_respond_with(
-            status: 200,
-            body: {
-              links: {
-                organisations: ["20583132-1619-4c68-af24-77583172c070"]
-              }
-            }
-          )
-      end
-      it "responds with the links" do
-        response = @api_client.get_links(@content_id)
-        assert_equal 200, response.code
-        assert_equal(
-          ["20583132-1619-4c68-af24-77583172c070"],
-          response['links']['organisations']
-        )
-      end
-    end
-    describe "when there's an empty links entry" do
-      before do
-        publishing_api
-          .given("empty links exist for content_id #{@content_id}")
-          .upon_receiving("a get-links request")
-          .with(
-            method: :get,
-            path: "/v2/links/#{@content_id}",
-          )
-          .will_respond_with(
-            status: 200,
-            body: {
-              links: {
-              }
-            }
-          )
-      end
-      it "responds with the empty link set" do
-        response = @api_client.get_links(@content_id)
-        assert_equal 200, response.code
-        assert_equal({}, response['links'])
-      end
-    end
-    describe "when there's no links entry" do
-      before do
-        publishing_api
-          .given("no links exist for content_id #{@content_id}")
-          .upon_receiving("a get-links request")
-          .with(
-            method: :get,
-            path: "/v2/links/#{@content_id}",
-          )
-          .will_respond_with(
-            status: 404
-          )
-      end
-      it "responds with 404" do
-        assert_raises(GdsApi::HTTPNotFound) do
-          @api_client.get_links(@content_id)
-        end
-      end
-    end
-  end
-end

data/test/publishing_api_v2/lookup_test.rb DELETED

@@ -1,70 +0,0 @@
-require 'test_helper'
-require 'gds_api/publishing_api_v2'
-require 'json'
-describe GdsApi::PublishingApiV2 do
-  include PactTest
-  before do
-    @api_client = GdsApi::PublishingApiV2.new(publishing_api_host)
-  end
-  describe "#lookup_content_id" do
-    it "returns the content_id for a base_path" do
-      publishing_api
-        .given("there are live content items with base_paths /foo and /bar")
-        .upon_receiving("a /lookup-by-base-path-request")
-        .with(
-          method: :post,
-          path: "/lookup-by-base-path",
-          body: {
-            base_paths: ["/foo"]
-          },
-          headers: {
-            "Content-Type" => "application/json",
-          },
-        )
-        .will_respond_with(
-          status: 200,
-          body: {
-            "/foo" => "08f86d00-e95f-492f-af1d-470c5ba4752e"
-          }
-        )
-      content_id = @api_client.lookup_content_id(base_path: "/foo")
-      assert_equal "08f86d00-e95f-492f-af1d-470c5ba4752e", content_id
-    end
-  end
-  describe "#lookup_content_ids" do
-    it "returns the content_id for a base_path" do
-      reponse_hash = {
-        "/foo" => "08f86d00-e95f-492f-af1d-470c5ba4752e",
-        "/bar" => "ca6c58a6-fb9d-479d-b3e6-74908781cb18",
-      }
-      publishing_api
-        .given("there are live content items with base_paths /foo and /bar")
-        .upon_receiving("a request for multiple base_paths")
-        .with(
-          method: :post,
-          path: "/lookup-by-base-path",
-          body: {
-            base_paths: ["/foo", "/bar"]
-          },
-          headers: {
-            "Content-Type" => "application/json",
-          },
-        )
-        .will_respond_with(
-          status: 200,
-          body: reponse_hash,
-        )
-      content_id = @api_client.lookup_content_ids(base_paths: ["/foo", "/bar"])
-      assert_equal(reponse_hash, content_id)
-    end
-  end
-end

data/test/publishing_api_v2_test.rb DELETED

@@ -1,1649 +0,0 @@
-require 'test_helper'
-require 'gds_api/publishing_api_v2'
-require 'json'
-describe GdsApi::PublishingApiV2 do
-  include PactTest
-  def content_item_for_content_id(content_id, attrs = {})
-    {
-      "base_path" => "/robots.txt",
-      "content_id" => content_id,
-      "title" => "Instructions for crawler robots",
-      "description" => "robots.txt provides rules for which parts of GOV.UK are permitted to be crawled by different bots.",
-      "schema_name" => "special_route",
-      "document_type" => "special_route",
-      "public_updated_at" => "2015-07-30T13:58:11.000Z",
-      "publishing_app" => "static",
-      "rendering_app" => "static",
-      "routes" => [
-        {
-          "path" => attrs["base_path"] || "/robots.txt",
-          "type" => "exact"
-        }
-      ],
-      "update_type" => "major"
-    }.merge(attrs)
-  end
-  before do
-    @bearer_token = "example-bearer-token"
-    @base_api_url = Plek.current.find("publishing-api")
-    @api_client = GdsApi::PublishingApiV2.new(
-      publishing_api_host,
-      bearer_token: @bearer_token,
-    )
-    @content_id = "bed722e6-db68-43e5-9079-063f623335a7"
-  end
-  describe "#put_content" do
-    describe "if the entry is valid" do
-      before do
-        @content_item = content_item_for_content_id(@content_id)
-        publishing_api
-          .given("no content exists")
-          .upon_receiving("a request to create a content item without links")
-          .with(
-            method: :put,
-            path: "/v2/content/#{@content_id}",
-            body: @content_item,
-            headers: GdsApi::JsonClient.default_request_with_json_body_headers.merge(
-              "Authorization" => "Bearer #{@bearer_token}"
-            ),
-          )
-          .will_respond_with(
-            status: 200,
-          )
-      end
-      it "responds with 200 OK" do
-        response = @api_client.put_content(@content_id, @content_item)
-        assert_equal 200, response.code
-      end
-    end
-    describe "if the path is reserved by a different app" do
-      before do
-        @content_item = content_item_for_content_id(@content_id, "base_path" => "/test-item", "publishing_app" => "whitehall")
-        publishing_api
-          .given("/test-item has been reserved by the Publisher application")
-          .upon_receiving("a request from the Whitehall application to create a content item at /test-item")
-          .with(
-            method: :put,
-            path: "/v2/content/#{@content_id}",
-            body: @content_item,
-            headers: GdsApi::JsonClient.default_request_with_json_body_headers.merge(
-              "Authorization" => "Bearer #{@bearer_token}"
-            ),
-          )
-          .will_respond_with(
-            status: 422,
-            body: {
-              "error" => {
-                "code" => 422,
-                "message" => Pact.term(generate: "Conflict", matcher: /\S+/),
-                "fields" => {
-                  "base_path" => Pact.each_like("is already in use by the 'publisher' app", min: 1),
-                },
-              },
-            },
-            headers: {
-              "Content-Type" => "application/json; charset=utf-8"
-            }
-          )
-      end
-      it "responds with 422 Unprocessable Entity" do
-        error = assert_raises GdsApi::HTTPClientError do
-          @api_client.put_content(@content_id, @content_item)
-        end
-        assert_equal "Conflict", error.error_details["error"]["message"]
-      end
-    end
-    describe "with an invalid item" do
-      before do
-        @content_item = content_item_for_content_id(@content_id, "base_path" => "not a url path")
-        publishing_api
-          .given("no content exists")
-          .upon_receiving("a request to create an invalid content-item")
-          .with(
-            method: :put,
-            path: "/v2/content/#{@content_id}",
-            body: @content_item,
-            headers: GdsApi::JsonClient.default_request_with_json_body_headers.merge(
-              "Authorization" => "Bearer #{@bearer_token}"
-            ),
-          )
-          .will_respond_with(
-            status: 422,
-            body: [
-              {
-                fragment: "#/base_path",
-                failed_attribute: "Pattern"
-              }
-            ],
-            headers: {
-              "Content-Type" => "application/json; charset=utf-8"
-            }
-          )
-      end
-      it "responds with 422 Unprocessable Entity" do
-        assert_raises GdsApi::HTTPClientError do
-          @api_client.put_content(@content_id, @content_item)
-        end
-      end
-    end
-    describe "optimistic locking" do
-      describe "if the content item has not changed since it was requested" do
-        before do
-          @content_item = content_item_for_content_id(@content_id,
-            "document_type" => "manual",
-            "schema_name" => "manual",
-            "locale" => "en",
-            "details" => { "body" => [] },
-            "previous_version" => "3"
-          )
-          publishing_api
-            .given("the content item #{@content_id} is at version 3")
-            .upon_receiving("a request to update the content item at version 3")
-            .with(
-              method: :put,
-              path: "/v2/content/#{@content_id}",
-              body: @content_item,
-              headers: GdsApi::JsonClient.default_request_with_json_body_headers.merge(
-                "Authorization" => "Bearer #{@bearer_token}"
-              ),
-            )
-            .will_respond_with(
-              status: 200,
-            )
-        end
-        it "responds with 200 OK" do
-          response = @api_client.put_content(@content_id, @content_item)
-          assert_equal 200, response.code
-        end
-      end
-      describe "if the content item has changed in the meantime" do
-        before do
-          @content_item = content_item_for_content_id(@content_id,
-            "document_type" => "manual",
-            "schema_name" => "manual",
-            "locale" => "en",
-            "details" => { "body" => [] },
-            "previous_version" => "2"
-          )
-          publishing_api
-            .given("the content item #{@content_id} is at version 3")
-            .upon_receiving("a request to update the content item at version 2")
-            .with(
-              method: :put,
-              path: "/v2/content/#{@content_id}",
-              body: @content_item,
-              headers: GdsApi::JsonClient.default_request_with_json_body_headers.merge(
-                "Authorization" => "Bearer #{@bearer_token}"
-              ),
-            )
-            .will_respond_with(
-              status: 409,
-              body: {
-                "error" => {
-                  "code" => 409,
-                  "message" => Pact.term(generate: "Conflict", matcher: /\S+/),
-                  "fields" => {
-                    "previous_version" => Pact.each_like("does not match", min: 1),
-                  },
-                },
-              },
-              headers: {
-                "Content-Type" => "application/json; charset=utf-8"
-              }
-            )
-        end
-        it "responds with 409 Conflict" do
-          error = assert_raises GdsApi::HTTPClientError do
-            @api_client.put_content(@content_id, @content_item)
-          end
-          assert_equal 409, error.code
-          assert_equal "Conflict", error.error_details["error"]["message"]
-        end
-      end
-    end
-  end
-  describe "#get_content" do
-    describe "when the content item exists" do
-      before do
-        @content_item = content_item_for_content_id(@content_id)
-        publishing_api
-          .given("a content item exists with content_id: #{@content_id}")
-          .upon_receiving("a request to return the content item")
-          .with(
-            method: :get,
-            path: "/v2/content/#{@content_id}",
-            headers: GdsApi::JsonClient.default_request_headers.merge(
-              "Authorization" => "Bearer #{@bearer_token}"
-            ),
-          )
-          .will_respond_with(
-            status: 200,
-            body: {
-              "content_id" => @content_id,
-              "document_type" => Pact.like("special_route"),
-              "schema_name" => Pact.like("special_route"),
-              "publishing_app" => Pact.like("publisher"),
-              "rendering_app" => Pact.like("frontend"),
-              "locale" => Pact.like("en"),
-              "routes" => Pact.like([{}]),
-              "public_updated_at" => Pact.like("2015-07-30T13:58:11.000Z"),
-              "details" => Pact.like({})
-            },
-            headers: {
-              "Content-Type" => "application/json; charset=utf-8",
-            },
-          )
-      end
-      it "responds with 200 and the content item" do
-        response = @api_client.get_content(@content_id)
-        assert_equal 200, response.code
-        assert_equal @content_item["document_type"], response["document_type"]
-      end
-    end
-    describe "when a content item exists in multiple locales" do
-      before do
-        @content_item = content_item_for_content_id(@content_id)
-        publishing_api
-          .given("a content item exists in multiple locales with content_id: #{@content_id}")
-          .upon_receiving("a request to return the content item")
-          .with(
-            method: :get,
-            path: "/v2/content/#{@content_id}",
-            query: "locale=fr",
-            headers: GdsApi::JsonClient.default_request_headers.merge(
-              "Authorization" => "Bearer #{@bearer_token}"
-            ),
-          )
-          .will_respond_with(
-            status: 200,
-            body: {
-              "content_id" => @content_id,
-              "document_type" => Pact.like("special_route"),
-              "schema_name" => Pact.like("special_route"),
-              "publishing_app" => Pact.like("publisher"),
-              "rendering_app" => Pact.like("frontend"),
-              "locale" => "fr",
-              "routes" => Pact.like([{}]),
-              "public_updated_at" => Pact.like("2015-07-30T13:58:11.000Z"),
-              "details" => Pact.like({})
-            },
-            headers: {
-              "Content-Type" => "application/json; charset=utf-8",
-            },
-          )
-      end
-      it "responds with 200 and the content item" do
-        response = @api_client.get_content(@content_id, locale: "fr")
-        assert_equal 200, response.code
-        assert_equal response["locale"], "fr"
-      end
-    end
-    describe "when a content item exists in with a superseded version" do
-      describe "when requesting the superseded version" do
-        before do
-          @content_item = content_item_for_content_id(@content_id)
-          publishing_api
-            .given("a content item exists in with a superseded version with content_id: #{@content_id}")
-            .upon_receiving("a request to return the superseded content item")
-            .with(
-              method: :get,
-              path: "/v2/content/#{@content_id}",
-              query: "version=1",
-              headers: GdsApi::JsonClient.default_request_headers.merge(
-                "Authorization" => "Bearer #{@bearer_token}"
-              ),
-            )
-            .will_respond_with(
-              status: 200,
-              body: {
-                "content_id" => @content_id,
-                "document_type" => Pact.like("special_route"),
-                "schema_name" => Pact.like("special_route"),
-                "publishing_app" => Pact.like("publisher"),
-                "rendering_app" => Pact.like("frontend"),
-                "locale" => Pact.like("en"),
-                "routes" => Pact.like([{}]),
-                "public_updated_at" => Pact.like("2015-07-30T13:58:11.000Z"),
-                "details" => Pact.like({}),
-                "publication_state" => "superseded"
-              },
-              headers: {
-                "Content-Type" => "application/json; charset=utf-8",
-              },
-            )
-        end
-        it "responds with 200 and the superseded content item" do
-          response = @api_client.get_content(@content_id, version: 1)
-          assert_equal 200, response.code
-          assert_equal response["publication_state"], "superseded"
-        end
-      end
-      describe "when a content item cannot be published because of a path conflict" do
-        before do
-          @content_item = content_item_for_content_id(@content_id)
-          publishing_api
-            .given("a draft content item exists with content_id #{@content_id} with a blocking live item at the same path")
-            .upon_receiving("a request to return the draft content item")
-            .with(
-              method: :get,
-              path: "/v2/content/#{@content_id}",
-              headers: GdsApi::JsonClient.default_request_headers.merge(
-                "Authorization" => "Bearer #{@bearer_token}"
-              ),
-            )
-            .will_respond_with(
-              status: 200,
-              body: {
-                "warnings" => Pact.like("content_item_blocking_publish" => "message"),
-                "content_id" => @content_id,
-                "document_type" => Pact.like("special_route"),
-                "schema_name" => Pact.like("special_route"),
-                "publishing_app" => Pact.like("publisher"),
-                "rendering_app" => Pact.like("frontend"),
-                "locale" => Pact.like("en"),
-                "routes" => Pact.like([{}]),
-                "public_updated_at" => Pact.like("2015-07-30T13:58:11.000Z"),
-                "details" => Pact.like({}),
-                "publication_state" => "draft"
-              },
-              headers: {
-                "Content-Type" => "application/json; charset=utf-8",
-              },
-            )
-        end
-        it "responds with 200 and the draft content item containing a warning" do
-          response = @api_client.get_content(@content_id, version: 2)
-          assert_equal 200, response.code
-          assert_equal hash_including("content_item_blocking_publish"), response["warnings"]
-        end
-      end
-      describe "when requesting the published version" do
-        before do
-          @content_item = content_item_for_content_id(@content_id)
-          publishing_api
-            .given("a content item exists in with a superseded version with content_id: #{@content_id}")
-            .upon_receiving("a request to return the published content item")
-            .with(
-              method: :get,
-              path: "/v2/content/#{@content_id}",
-              query: "version=2",
-              headers: GdsApi::JsonClient.default_request_headers.merge(
-                "Authorization" => "Bearer #{@bearer_token}"
-              ),
-            )
-            .will_respond_with(
-              status: 200,
-              body: {
-                "content_id" => @content_id,
-                "document_type" => Pact.like("special_route"),
-                "schema_name" => Pact.like("special_route"),
-                "publishing_app" => Pact.like("publisher"),
-                "rendering_app" => Pact.like("frontend"),
-                "locale" => Pact.like("en"),
-                "routes" => Pact.like([{}]),
-                "public_updated_at" => Pact.like("2015-07-30T13:58:11.000Z"),
-                "details" => Pact.like({}),
-                "publication_state" => "published"
-              },
-              headers: {
-                "Content-Type" => "application/json; charset=utf-8",
-              },
-            )
-        end
-        it "responds with 200 and the published content item" do
-          response = @api_client.get_content(@content_id, version: 2)
-          assert_equal 200, response.code
-          assert_equal response["publication_state"], "published"
-        end
-      end
-      describe "when requesting no specific version" do
-        before do
-          @content_item = content_item_for_content_id(@content_id)
-          publishing_api
-            .given("a content item exists in with a superseded version with content_id: #{@content_id}")
-            .upon_receiving("a request to return the content item")
-            .with(
-              method: :get,
-              path: "/v2/content/#{@content_id}",
-              headers: GdsApi::JsonClient.default_request_headers.merge(
-                "Authorization" => "Bearer #{@bearer_token}"
-              ),
-            )
-            .will_respond_with(
-              status: 200,
-              body: {
-                "content_id" => @content_id,
-                "document_type" => Pact.like("special_route"),
-                "schema_name" => Pact.like("special_route"),
-                "publishing_app" => Pact.like("publisher"),
-                "rendering_app" => Pact.like("frontend"),
-                "locale" => Pact.like("en"),
-                "routes" => Pact.like([{}]),
-                "public_updated_at" => Pact.like("2015-07-30T13:58:11.000Z"),
-                "details" => Pact.like({}),
-                "publication_state" => "published"
-              },
-              headers: {
-                "Content-Type" => "application/json; charset=utf-8",
-              },
-            )
-        end
-        it "responds with 200 and the published content item" do
-          response = @api_client.get_content(@content_id)
-          assert_equal 200, response.code
-          assert_equal response["publication_state"], "published"
-        end
-      end
-    end
-    describe "a non-existent item" do
-      before do
-        publishing_api
-          .given("no content exists")
-          .upon_receiving("a request for a non-existent content item")
-          .with(
-            method: :get,
-            path: "/v2/content/#{@content_id}",
-            headers: GdsApi::JsonClient.default_request_headers.merge(
-              "Authorization" => "Bearer #{@bearer_token}"
-            ),
-          )
-          .will_respond_with(
-            status: 404,
-            body: {
-              "error" => {
-                "code" => 404,
-                "message" => Pact.term(generate: "not found", matcher: /\S+/)
-              },
-            },
-            headers: {
-              "Content-Type" => "application/json; charset=utf-8",
-            },
-          )
-      end
-      it "responds with 404" do
-        assert_raises(GdsApi::HTTPNotFound) do
-          @api_client.get_content(@content_id)
-        end
-      end
-    end
-  end
-  describe "#publish" do
-    describe "if the publish command succeeds" do
-      before do
-        publishing_api
-          .given("a draft content item exists with content_id: #{@content_id}")
-          .upon_receiving("a publish request")
-          .with(
-            method: :post,
-            path: "/v2/content/#{@content_id}/publish",
-            body: {
-              update_type: "major",
-            },
-            headers: GdsApi::JsonClient.default_request_with_json_body_headers.merge(
-              "Authorization" => "Bearer #{@bearer_token}"
-            ),
-          )
-          .will_respond_with(
-            status: 200
-          )
-      end
-      it "responds with 200 if the publish command succeeds" do
-        response = @api_client.publish(@content_id, "major")
-        assert_equal 200, response.code
-      end
-    end
-    describe "if the content item does not exist" do
-      before do
-        publishing_api
-          .given("no content exists")
-          .upon_receiving("a publish request")
-          .with(
-            method: :post,
-            path: "/v2/content/#{@content_id}/publish",
-            body: {
-              update_type: "major",
-            },
-            headers: GdsApi::JsonClient.default_request_with_json_body_headers.merge(
-              "Authorization" => "Bearer #{@bearer_token}"
-            ),
-          )
-          .will_respond_with(
-            status: 404
-          )
-      end
-      it "responds with 404" do
-        error = assert_raises GdsApi::HTTPClientError do
-          @api_client.publish(@content_id, "major")
-        end
-        assert_equal 404, error.code
-      end
-    end
-    describe "if the update information is invalid" do
-      before do
-        publishing_api
-          .given("a draft content item exists with content_id: #{@content_id}")
-          .upon_receiving("an invalid publish request")
-          .with(
-            method: :post,
-            path: "/v2/content/#{@content_id}/publish",
-            body: {
-              "update_type" => ""
-            },
-            headers: GdsApi::JsonClient.default_request_with_json_body_headers.merge(
-              "Authorization" => "Bearer #{@bearer_token}"
-            ),
-          )
-          .will_respond_with(
-            status: 422,
-            body: {
-              "error" => {
-                "code" => 422,
-                "message" => Pact.term(generate: "Unprocessable entity", matcher: /\S+/),
-                "fields" => {
-                  "update_type" => Pact.each_like("is required", min: 1),
-                },
-              },
-            }
-          )
-      end
-      it "responds with 422" do
-        error = assert_raises GdsApi::HTTPClientError do
-          @api_client.publish(@content_id, "")
-        end
-        assert_equal 422, error.code
-        assert_equal "Unprocessable entity", error.error_details["error"]["message"]
-      end
-    end
-    describe "if the content item is already published" do
-      before do
-        publishing_api
-          .given("a published content item exists with content_id: #{@content_id}")
-          .upon_receiving("a publish request")
-          .with(
-            method: :post,
-            path: "/v2/content/#{@content_id}/publish",
-            body: {
-              update_type: "major",
-            },
-            headers: GdsApi::JsonClient.default_request_with_json_body_headers.merge(
-              "Authorization" => "Bearer #{@bearer_token}"
-            ),
-          )
-          .will_respond_with(
-            status: 400,
-            body: {
-              "error" => {
-                "code" => 400, "message" => Pact.term(generate: "Cannot publish an already published content item", matcher: /\S+/),
-              },
-            }
-          )
-      end
-      it "responds with 400" do
-        error = assert_raises GdsApi::HTTPClientError do
-          @api_client.publish(@content_id, "major")
-        end
-        assert_equal 400, error.code
-        assert_equal "Cannot publish an already published content item", error.error_details["error"]["message"]
-      end
-    end
-    describe "if the update information contains a locale" do
-      before do
-        publishing_api
-          .given("a draft content item exists with content_id: #{@content_id} and locale: fr")
-          .upon_receiving("a publish request")
-          .with(
-            method: :post,
-            path: "/v2/content/#{@content_id}/publish",
-            body: {
-              update_type: "major",
-              locale: "fr",
-            },
-            headers: GdsApi::JsonClient.default_request_with_json_body_headers.merge(
-              "Authorization" => "Bearer #{@bearer_token}"
-            ),
-          )
-          .will_respond_with(
-            status: 200,
-          )
-      end
-      it "responds with 200 if the publish command succeeds" do
-        response = @api_client.publish(@content_id, "major", locale: "fr")
-        assert_equal 200, response.code
-      end
-    end
-    describe "optimistic locking" do
-      describe "if the content item has not changed since it was requested" do
-        before do
-          publishing_api
-            .given("the content item #{@content_id} is at version 3")
-            .upon_receiving("a publish request for version 3")
-            .with(
-              method: :post,
-              path: "/v2/content/#{@content_id}/publish",
-              body: {
-                update_type: "minor",
-                previous_version: 3,
-              },
-              headers: GdsApi::JsonClient.default_request_with_json_body_headers.merge(
-                "Authorization" => "Bearer #{@bearer_token}"
-              ),
-            )
-            .will_respond_with(
-              status: 200,
-            )
-        end
-        it "responds with 200 OK" do
-          response = @api_client.publish(@content_id, "minor", previous_version: 3)
-          assert_equal 200, response.code
-        end
-      end
-      describe "if the content item has changed in the meantime" do
-        before do
-          publishing_api
-            .given("the content item #{@content_id} is at version 3")
-            .upon_receiving("a publish request for version 2")
-            .with(
-              method: :post,
-              path: "/v2/content/#{@content_id}/publish",
-              body: {
-                update_type: "minor",
-                previous_version: 2,
-              },
-              headers: GdsApi::JsonClient.default_request_with_json_body_headers.merge(
-                "Authorization" => "Bearer #{@bearer_token}"
-              ),
-            )
-            .will_respond_with(
-              status: 409,
-              body: {
-                "error" => {
-                  "code" => 409,
-                  "message" => Pact.term(generate: "Conflict", matcher: /\S+/),
-                  "fields" => {
-                    "previous_version" => Pact.each_like("does not match", min: 1),
-                  },
-                },
-              },
-              headers: {
-                "Content-Type" => "application/json; charset=utf-8"
-              }
-            )
-        end
-        it "responds with 409 Conflict" do
-          error = assert_raises GdsApi::HTTPClientError do
-            @api_client.publish(@content_id, "minor", previous_version: 2)
-          end
-          assert_equal 409, error.code
-          assert_equal "Conflict", error.error_details["error"]["message"]
-        end
-      end
-    end
-  end
-  describe "#unpublish" do
-    describe "if the unpublish command succeeds" do
-      before do
-        publishing_api
-          .given("a published content item exists with content_id: #{@content_id}")
-          .upon_receiving("an unpublish request")
-          .with(
-            method: :post,
-            path: "/v2/content/#{@content_id}/unpublish",
-            body: {
-              type: "gone",
-            },
-            headers: GdsApi::JsonClient.default_request_with_json_body_headers.merge(
-              "Authorization" => "Bearer #{@bearer_token}"
-            ),
-          )
-          .will_respond_with(
-            status: 200
-          )
-      end
-      it "responds with 200" do
-        response = @api_client.unpublish(@content_id, type: "gone")
-        assert_equal 200, response.code
-      end
-    end
-    describe "if the content item does not exist" do
-      before do
-        publishing_api
-          .given("no content exists")
-          .upon_receiving("an unpublish request")
-          .with(
-            method: :post,
-            path: "/v2/content/#{@content_id}/unpublish",
-            body: {
-              type: "gone",
-            },
-            headers: GdsApi::JsonClient.default_request_with_json_body_headers.merge(
-              "Authorization" => "Bearer #{@bearer_token}"
-            ),
-          )
-          .will_respond_with(
-            status: 404
-          )
-      end
-      it "responds with 404" do
-        error = assert_raises GdsApi::HTTPClientError do
-          @api_client.unpublish(@content_id, type: "gone")
-        end
-        assert_equal 404, error.code
-      end
-    end
-    describe "if the type is incorrect" do
-      before do
-        publishing_api
-          .given("a published content item exists with content_id: #{@content_id}")
-          .upon_receiving("an invalid unpublish request")
-          .with(
-            method: :post,
-            path: "/v2/content/#{@content_id}/unpublish",
-            body: {
-              type: "not-a-valid-type",
-            },
-            headers: GdsApi::JsonClient.default_request_with_json_body_headers.merge(
-              "Authorization" => "Bearer #{@bearer_token}"
-            ),
-          )
-          .will_respond_with(
-            status: 422,
-            body: {
-              "error" => {
-                "code" => 422,
-                "message" => Pact.term(generate: "not-a-valid-type is not a valid unpublishing type", matcher: /\S+/),
-                "fields" => {},
-              },
-            }
-          )
-      end
-      it "responds with 422" do
-        error = assert_raises GdsApi::HTTPClientError do
-          @api_client.unpublish(@content_id, type: "not-a-valid-type")
-        end
-        assert_equal 422, error.code
-        assert_equal "not-a-valid-type is not a valid unpublishing type", error.error_details["error"]["message"]
-      end
-    end
-    describe "if the content item is already unpublished" do
-      before do
-        publishing_api
-          .given("an unpublished content item exists with content_id: #{@content_id}")
-          .upon_receiving("an unpublish request")
-          .with(
-            method: :post,
-            path: "/v2/content/#{@content_id}/unpublish",
-            body: {
-              type: "gone",
-            },
-            headers: GdsApi::JsonClient.default_request_with_json_body_headers.merge(
-              "Authorization" => "Bearer #{@bearer_token}"
-            ),
-          )
-          .will_respond_with(
-            status: 200
-          )
-      end
-      it "responds with 200 and updates the unpublishing" do
-        response = @api_client.unpublish(@content_id, type: "gone")
-        assert_equal 200, response.code
-      end
-    end
-    describe "optimistic locking" do
-      describe "if the content item has not changed since it was requested" do
-        before do
-          publishing_api
-            .given("the published content item #{@content_id} is at version 3")
-            .upon_receiving("an unpublish request for version 3")
-            .with(
-              method: :post,
-              path: "/v2/content/#{@content_id}/unpublish",
-              body: {
-                type: "gone",
-                previous_version: 3,
-              },
-              headers: GdsApi::JsonClient.default_request_with_json_body_headers.merge(
-                "Authorization" => "Bearer #{@bearer_token}"
-              ),
-            )
-            .will_respond_with(
-              status: 200,
-            )
-        end
-        it "responds with 200 OK" do
-          response = @api_client.unpublish(@content_id, type: "gone", previous_version: 3)
-          assert_equal 200, response.code
-        end
-      end
-      describe "if the content item has changed in the meantime" do
-        before do
-          publishing_api
-            .given("the published content item #{@content_id} is at version 3")
-            .upon_receiving("an unpublish request for version 2")
-            .with(
-              method: :post,
-              path: "/v2/content/#{@content_id}/unpublish",
-              body: {
-                type: "gone",
-                previous_version: 2,
-              },
-              headers: GdsApi::JsonClient.default_request_with_json_body_headers.merge(
-                "Authorization" => "Bearer #{@bearer_token}"
-              ),
-            )
-            .will_respond_with(
-              status: 409,
-              body: {
-                "error" => {
-                  "code" => 409,
-                  "message" => Pact.term(generate: "Conflict", matcher: /\S+/),
-                  "fields" => {
-                    "previous_version" => Pact.each_like("does not match", min: 1),
-                  },
-                },
-              },
-              headers: {
-                "Content-Type" => "application/json; charset=utf-8"
-              }
-            )
-        end
-        it "responds with 409 Conflict" do
-          error = assert_raises GdsApi::HTTPClientError do
-            @api_client.unpublish(@content_id, type: "gone", previous_version: 2)
-          end
-          assert_equal 409, error.code
-          assert_equal "Conflict", error.error_details["error"]["message"]
-        end
-      end
-    end
-  end
-  describe "#patch_links" do
-    describe "when setting links of the same type" do
-      before do
-        publishing_api
-          .given("organisation links exist for content_id #{@content_id}")
-          .upon_receiving("a patch organisation links request")
-          .with(
-            method: :patch,
-            path: "/v2/links/#{@content_id}",
-            body: {
-              links: {
-                organisations: ["591436ab-c2ae-416f-a3c5-1901d633fbfb"],
-              }
-            },
-            headers: {
-              "Content-Type" => "application/json",
-            },
-          )
-          .will_respond_with(
-            status: 200,
-            body: {
-              links: {
-                organisations: ["591436ab-c2ae-416f-a3c5-1901d633fbfb"],
-              }
-            }
-          )
-      end
-      it "replaces the links and responds with the new links" do
-        response = @api_client.patch_links(@content_id, links: {
-          organisations: ["591436ab-c2ae-416f-a3c5-1901d633fbfb"],
-        })
-        assert_equal 200, response.code
-        assert_equal(
-          ["591436ab-c2ae-416f-a3c5-1901d633fbfb"],
-          response['links']['organisations']
-        )
-      end
-    end
-    describe "when setting links of a different type" do
-      before do
-        publishing_api
-          .given("organisation links exist for content_id #{@content_id}")
-          .upon_receiving("a patch topic links request")
-          .with(
-            method: :patch,
-            path: "/v2/links/#{@content_id}",
-            body: {
-              links: {
-                topics: ["225df4a8-2945-4e9b-8799-df7424a90b69"],
-              }
-            },
-            headers: {
-              "Content-Type" => "application/json",
-            },
-          )
-          .will_respond_with(
-            status: 200,
-            body: {
-              links: {
-                topics: ["225df4a8-2945-4e9b-8799-df7424a90b69"],
-                organisations: ["20583132-1619-4c68-af24-77583172c070"]
-              }
-            }
-          )
-      end
-      it "adds the new type of links and responds with the whole link set" do
-        response = @api_client.patch_links(@content_id, links: {
-          topics: ["225df4a8-2945-4e9b-8799-df7424a90b69"],
-        })
-        assert_equal 200, response.code
-        assert_equal(
-          {
-            'topics' => ["225df4a8-2945-4e9b-8799-df7424a90b69"],
-            'organisations' => ["20583132-1619-4c68-af24-77583172c070"],
-          },
-          response['links']
-        )
-      end
-    end
-    describe "when deleting links of a specific type" do
-      before do
-        publishing_api
-          .given("organisation links exist for content_id #{@content_id}")
-          .upon_receiving("a patch blank organisation links request")
-          .with(
-            method: :patch,
-            path: "/v2/links/#{@content_id}",
-            body: {
-              links: {
-                organisations: [],
-              }
-            },
-            headers: {
-              "Content-Type" => "application/json",
-            },
-          )
-          .will_respond_with(
-            status: 200,
-            body: {
-              links: {}
-            }
-          )
-      end
-      it "responds with the links" do
-        response = @api_client.patch_links(@content_id, links: {
-          organisations: [],
-        })
-        assert_equal 200, response.code
-        assert_equal({}, response['links'])
-      end
-    end
-    describe "when there's no links entry" do
-      before do
-        publishing_api
-          .given("no links exist for content_id #{@content_id}")
-          .upon_receiving("a patch organisation links request")
-          .with(
-            method: :patch,
-            path: "/v2/links/#{@content_id}",
-            body: {
-              links: {
-                organisations: ["591436ab-c2ae-416f-a3c5-1901d633fbfb"],
-              }
-            },
-            headers: {
-              "Content-Type" => "application/json",
-            },
-          )
-          .will_respond_with(
-            status: 200,
-            body: {
-              links: {
-                organisations: ["591436ab-c2ae-416f-a3c5-1901d633fbfb"],
-              }
-            },
-          )
-      end
-      it "responds with the links" do
-        response = @api_client.patch_links(@content_id, links: {
-          organisations: ["591436ab-c2ae-416f-a3c5-1901d633fbfb"],
-        })
-        assert_equal 200, response.code
-        assert_equal(
-          {
-            'organisations' => ["591436ab-c2ae-416f-a3c5-1901d633fbfb"],
-          },
-          response['links']
-        )
-      end
-    end
-    describe "optimistic locking" do
-      describe "if the linkset has not changed since it was requested" do
-        before do
-          publishing_api
-            .given("the linkset for #{@content_id} is at version 3")
-            .upon_receiving("a request to update the linkset at version 3")
-            .with(
-              method: :patch,
-              path: "/v2/links/#{@content_id}",
-              body: {
-                links: {
-                  organisations: ["591436ab-c2ae-416f-a3c5-1901d633fbfb"],
-                },
-                previous_version: 3,
-              },
-              headers: {
-                "Content-Type" => "application/json",
-              },
-            )
-            .will_respond_with(
-              status: 200,
-            )
-        end
-        it "responds with 200 OK" do
-          response = @api_client.patch_links(@content_id,
-            links: {
-              organisations: ["591436ab-c2ae-416f-a3c5-1901d633fbfb"],
-            },
-            previous_version: 3,
-          )
-          assert_equal 200, response.code
-        end
-      end
-      describe "if the content item has changed in the meantime" do
-        before do
-          publishing_api
-            .given("the linkset for #{@content_id} is at version 3")
-            .upon_receiving("a request to update the linkset at version 2")
-            .with(
-              method: :patch,
-              path: "/v2/links/#{@content_id}",
-              body: {
-                links: {
-                  organisations: ["591436ab-c2ae-416f-a3c5-1901d633fbfb"],
-                },
-                previous_version: 2,
-              },
-              headers: {
-                "Content-Type" => "application/json",
-              },
-            )
-            .will_respond_with(
-              status: 409,
-              body: {
-                "error" => {
-                  "code" => 409,
-                  "message" => Pact.term(generate: "Conflict", matcher: /\S+/),
-                  "fields" => {
-                    "previous_version" => Pact.each_like("does not match", min: 1),
-                  },
-                },
-              },
-              headers: {
-                "Content-Type" => "application/json; charset=utf-8"
-              }
-            )
-        end
-        it "responds with 409 Conflict" do
-          error = assert_raises GdsApi::HTTPClientError do
-            @api_client.patch_links(@content_id,
-              links: {
-                organisations: ["591436ab-c2ae-416f-a3c5-1901d633fbfb"],
-              },
-              previous_version: 2,
-            )
-          end
-          assert_equal 409, error.code
-          assert_equal "Conflict", error.error_details["error"]["message"]
-        end
-      end
-    end
-  end
-  describe "#get_linkables" do
-    let(:linkables) {
-      [
-        {
-          "title" => "Content Item A",
-          "internal_name" => "an internal name",
-          "content_id" => "aaaaaaaa-aaaa-1aaa-aaaa-aaaaaaaaaaaa",
-          "publication_state" => "draft",
-          "base_path" => "/a-base-path",
-        },
-        {
-          "title" => "Content Item B",
-          "internal_name" => "Content Item B",
-          "content_id" => "bbbbbbbb-bbbb-2bbb-bbbb-bbbbbbbbbbbb",
-          "publication_state" => "published",
-          "base_path" => "/another-base-path",
-        },
-      ]
-    }
-    it "returns the content items of a given document_type" do
-      publishing_api
-        .given("there is content with document_type 'topic'")
-        .upon_receiving("a get linkables request")
-        .with(
-          method: :get,
-          path: "/v2/linkables",
-          query: "document_type=topic",
-          headers: GdsApi::JsonClient.default_request_headers.merge(
-            "Authorization" => "Bearer #{@bearer_token}"
-          ),
-        )
-        .will_respond_with(
-          status: 200,
-          body: linkables,
-        )
-      response = @api_client.get_linkables(document_type: "topic")
-      assert_equal 200, response.code
-      assert_equal linkables, response.to_a
-    end
-  end
-  describe "#get_content_items" do
-    it "returns the content items of a certain document_type" do
-      publishing_api
-        .given("there is content with document_type 'topic'")
-        .upon_receiving("a get entries request")
-        .with(
-          method: :get,
-          path: "/v2/content",
-          query: "document_type=topic&fields%5B%5D=title&fields%5B%5D=base_path",
-          headers: GdsApi::JsonClient.default_request_headers.merge(
-            "Authorization" => "Bearer #{@bearer_token}"
-          ),
-        )
-        .will_respond_with(
-          status: 200,
-          body: {
-            total: 2,
-            pages: 1,
-            current_page: 1,
-            links: [{
-              href: "http://example.org/v2/content?document_type=topic&fields[]=title&fields[]=base_path&page=1",
-              rel: "self"
-            }],
-            results: [
-              { title: 'Content Item A', base_path: '/a-base-path' },
-              { title: 'Content Item B', base_path: '/another-base-path' },
-            ]
-          }
-        )
-      response = @api_client.get_content_items(
-        document_type: 'topic',
-        fields: [:title, :base_path],
-      )
-      assert_equal 200, response.code
-      assert_equal [
-        ["total", 2],
-        ["pages", 1],
-        ["current_page", 1],
-        ["links", [{ "href" => "http://example.org/v2/content?document_type=topic&fields[]=title&fields[]=base_path&page=1", "rel" => "self" }]],
-        ["results", [{ "title" => "Content Item A", "base_path" => "/a-base-path" }, { "title" => "Content Item B", "base_path" => "/another-base-path" }]]
-      ], response.to_a
-    end
-    it "returns the content items in english locale by default" do
-      publishing_api
-        .given("a content item exists in multiple locales with content_id: #{@content_id}")
-        .upon_receiving("a get entries request")
-        .with(
-          method: :get,
-          path: "/v2/content",
-          query: "document_type=topic&fields%5B%5D=content_id&fields%5B%5D=locale",
-          headers: GdsApi::JsonClient.default_request_headers.merge(
-            "Authorization" => "Bearer #{@bearer_token}"
-          ),
-        )
-        .will_respond_with(
-          status: 200,
-          body: {
-            total: 1,
-            pages: 1,
-            current_page: 1,
-            links: [{
-              href: "http://example.org/v2/content?document_type=topic&fields[]=content_id&fields[]=locale&page=1",
-              rel: "self"
-            }],
-            results: [
-              { content_id: @content_id, locale: "en" }
-            ]
-          }
-        )
-      response = @api_client.get_content_items(
-        document_type: 'topic',
-        fields: [:content_id, :locale],
-      )
-      assert_equal 200, response.code
-      assert_equal [
-        ["total", 1],
-        ["pages", 1],
-        ["current_page", 1],
-        ["links", [{ "href" => "http://example.org/v2/content?document_type=topic&fields[]=content_id&fields[]=locale&page=1", "rel" => "self" }]],
-        ["results", [{ "content_id" => "bed722e6-db68-43e5-9079-063f623335a7", "locale" => "en" }]]
-      ], response.to_a
-    end
-    it "returns the content items in a specific locale" do
-      publishing_api
-        .given("a content item exists in multiple locales with content_id: #{@content_id}")
-        .upon_receiving("a get entries request with a specific locale")
-        .with(
-          method: :get,
-          path: "/v2/content",
-          query: "document_type=topic&fields%5B%5D=content_id&fields%5B%5D=locale&locale=fr",
-          headers: GdsApi::JsonClient.default_request_headers.merge(
-            "Authorization" => "Bearer #{@bearer_token}"
-          ),
-        )
-        .will_respond_with(
-          status: 200,
-          body: {
-            total: 1,
-            pages: 1,
-            current_page: 1,
-            links: [{
-              href: "http://example.org/v2/content?document_type=topic&fields[]=content_id&fields[]=locale&locale=fr&page=1",
-              rel: "self"
-            }],
-            results: [
-              { content_id: @content_id, locale: "fr" }
-            ]
-          }
-        )
-      response = @api_client.get_content_items(
-        document_type: 'topic',
-        fields: [:content_id, :locale],
-        locale: 'fr',
-      )
-      assert_equal 200, response.code
-      assert_equal [
-        ["total", 1],
-        ["pages", 1],
-        ["current_page", 1],
-        ["links", [{ "href" => "http://example.org/v2/content?document_type=topic&fields[]=content_id&fields[]=locale&locale=fr&page=1", "rel" => "self" }]],
-        ["results", [{ "content_id" => "bed722e6-db68-43e5-9079-063f623335a7", "locale" => "fr" }]]
-      ], response.to_a
-    end
-    it "returns the content items in all the available locales" do
-      publishing_api
-        .given("a content item exists in multiple locales with content_id: #{@content_id}")
-        .upon_receiving("a get entries request with an 'all' locale")
-        .with(
-          method: :get,
-          path: "/v2/content",
-          query: "document_type=topic&fields%5B%5D=content_id&fields%5B%5D=locale&locale=all",
-          headers: GdsApi::JsonClient.default_request_headers.merge(
-            "Authorization" => "Bearer #{@bearer_token}"
-          ),
-        )
-        .will_respond_with(
-          status: 200,
-          body: {
-            total: 3,
-            pages: 1,
-            current_page: 1,
-            links: [{
-              href: "http://example.org/v2/content?document_type=topic&fields[]=content_id&fields[]=locale&locale=all&page=1",
-              rel: "self"
-            }],
-            results: [
-              { content_id: @content_id, locale: "en" },
-              { content_id: @content_id, locale: "fr" },
-              { content_id: @content_id, locale: "ar" },
-            ]
-          }
-        )
-      response = @api_client.get_content_items(
-        document_type: 'topic',
-        fields: [:content_id, :locale],
-        locale: 'all',
-      )
-      assert_equal 200, response.code
-      assert_equal [
-        ["total", 3],
-        ["pages", 1], ["current_page", 1],
-        ["links",
-         [{ "href" => "http://example.org/v2/content?document_type=topic&fields[]=content_id&fields[]=locale&locale=all&page=1", "rel" => "self" }]],
-        ["results",
-         [{ "content_id" => "bed722e6-db68-43e5-9079-063f623335a7", "locale" => "en" },
-          { "content_id" => "bed722e6-db68-43e5-9079-063f623335a7", "locale" => "fr" },
-          { "content_id" => "bed722e6-db68-43e5-9079-063f623335a7", "locale" => "ar" }]]
-      ], response.to_a
-    end
-    it "returns details hashes" do
-      publishing_api
-        .given("a content item exists with content_id: #{@content_id} and it has details")
-        .upon_receiving("a get entries request with details field")
-        .with(
-          method: :get,
-          path: "/v2/content",
-          query: "document_type=topic&fields%5B%5D=content_id&fields%5B%5D=details",
-          headers: GdsApi::JsonClient.default_request_headers.merge(
-            "Authorization" => "Bearer #{@bearer_token}"
-          ),
-        )
-        .will_respond_with(
-          status: 200,
-          body: {
-            total: 1,
-            pages: 1,
-            current_page: 1,
-            links: [{
-              href: "http://example.org/v2/content?document_type=topic&fields[]=content_id&fields[]=details&page=1",
-              rel: "self"
-            }],
-            results: [
-              { content_id: @content_id, details: { foo: :bar } }
-            ]
-          }
-        )
-      response = @api_client.get_content_items(
-        document_type: 'topic',
-        fields: [:content_id, :details],
-      )
-      assert_equal 200, response.code
-      assert_equal [
-        ["total", 1],
-        ["pages", 1],
-        ["current_page", 1],
-        ["links", [{ "href" => "http://example.org/v2/content?document_type=topic&fields[]=content_id&fields[]=details&page=1", "rel" => "self" }]],
-        ["results", [{ "content_id" => "bed722e6-db68-43e5-9079-063f623335a7", "details" => { "foo" => "bar" } }]]
-      ], response.to_a
-    end
-  end
-  describe "#discard_draft(content_id, options = {})" do
-    describe "when the content item exists" do
-      before do
-        publishing_api
-          .given("a content item exists with content_id: #{@content_id}")
-          .upon_receiving("a request to discard draft content")
-          .with(
-            method: :post,
-            path: "/v2/content/#{@content_id}/discard-draft",
-            body: {},
-            headers: GdsApi::JsonClient.default_request_with_json_body_headers.merge(
-              "Authorization" => "Bearer #{@bearer_token}"
-            ),
-          )
-          .will_respond_with(
-            status: 200,
-          )
-      end
-      it "responds with 200" do
-        response = @api_client.discard_draft(@content_id)
-        assert_equal 200, response.code
-      end
-    end
-    describe "when the content item exists and is French" do
-      before do
-        publishing_api
-          .given("a French content item exists with content_id: #{@content_id}")
-          .upon_receiving("a request to discard French draft content")
-          .with(
-            method: :post,
-            path: "/v2/content/#{@content_id}/discard-draft",
-            body: {
-              locale: "fr",
-            },
-            headers: GdsApi::JsonClient.default_request_with_json_body_headers.merge(
-              "Authorization" => "Bearer #{@bearer_token}"
-            ),
-          )
-          .will_respond_with(
-            status: 200,
-          )
-      end
-      it "responds with 200" do
-        response = @api_client.discard_draft(@content_id, locale: "fr")
-        assert_equal 200, response.code
-      end
-    end
-    describe "when there is no content with that content_id" do
-      before do
-        publishing_api
-          .given("no content exists")
-          .upon_receiving("a request to discard draft content")
-          .with(
-            method: :post,
-            path: "/v2/content/#{@content_id}/discard-draft",
-            body: {},
-            headers: GdsApi::JsonClient.default_request_with_json_body_headers.merge(
-              "Authorization" => "Bearer #{@bearer_token}"
-            ),
-          )
-          .will_respond_with(
-            status: 404,
-          )
-      end
-      it "responds with a 404" do
-        error = assert_raises GdsApi::HTTPClientError do
-          @api_client.discard_draft(@content_id)
-        end
-        assert_equal 404, error.code
-      end
-    end
-  end
-  describe "#get_linked_items" do
-    describe "if the content item does not exist" do
-      before do
-        publishing_api
-          .given("no content exists")
-          .upon_receiving("a request to return the items linked to it")
-          .with(
-            method: :get,
-            path: "/v2/linked/#{@content_id}",
-            query: "fields%5B%5D=content_id&fields%5B%5D=base_path&link_type=topic",
-            headers: GdsApi::JsonClient.default_request_headers.merge(
-              "Authorization" => "Bearer #{@bearer_token}"
-            ),
-          )
-          .will_respond_with(
-            status: 404,
-            body: {
-              "error" => {
-                "code" => 404,
-                "message" => Pact.term(generate: "not found", matcher: /\S+/)
-              },
-            },
-            headers: {
-              "Content-Type" => "application/json; charset=utf-8",
-            },
-          )
-      end
-      it "404s" do
-        assert_raises(GdsApi::HTTPNotFound) do
-          @api_client.get_linked_items(
-            @content_id,
-            link_type: "topic",
-            fields: %w(content_id base_path),
-          )
-        end
-      end
-    end
-    describe "there are two documents that link to the wanted document" do
-      before do
-        content_id2 = "08dfd5c3-d935-4e81-88fd-cfe65b78893d"
-        content_id3 = "e2961462-bc37-48e9-bb98-c981ef1a2d59"
-        @linked_content_item = content_item_for_content_id("6cb2cf8c-670f-4de3-97d5-6ad9114581c7")
-        @linking_content_item1 = content_item_for_content_id(content_id3,
-          "base_path" => "/item-b",
-          "links" => {
-            "topic" => [@linked_content_item['content_id1']]
-        })
-        @linking_content_item2 = content_item_for_content_id(content_id2,
-          "base_path" => "/item-a",
-          "links" => {
-            "topic" => [@linked_content_item['content_id1']],
-        })
-        publishing_api
-          .given("there are two documents with a 'topic' link to another document")
-          .upon_receiving("a get linked request")
-          .with(
-            method: :get,
-            path: "/v2/linked/" + @linked_content_item['content_id'],
-            query: "fields%5B%5D=content_id&fields%5B%5D=base_path&link_type=topic",
-            headers: GdsApi::JsonClient.default_request_headers.merge(
-              "Authorization" => "Bearer #{@bearer_token}"
-            ),
-          )
-          .will_respond_with(
-            status: 200,
-            body: [
-              {
-                content_id: @linking_content_item1["content_id"],
-                base_path: @linking_content_item1["base_path"]
-              },
-              {
-                content_id: @linking_content_item2["content_id"],
-                base_path: @linking_content_item2["base_path"]
-              }
-            ]
-          )
-      end
-      it "returns the requested fields of linking items" do
-        response = @api_client.get_linked_items(
-          @linked_content_item["content_id"],
-                      link_type: "topic",
-            fields: %w(content_id base_path)
-        )
-        assert_equal 200, response.code
-        expected_documents = [
-          { "content_id" => @linking_content_item2["content_id"], "base_path" => "/item-a" },
-          { "content_id" => @linking_content_item1["content_id"], "base_path" => "/item-b" },
-        ]
-        expected_documents.each do |document|
-          response.to_a.must_include document
-        end
-      end
-    end
-  end
-  describe "content ID validation" do
-    [:get_content, :get_links, :get_linked_items, :discard_draft].each do |method|
-      it "happens on #{method}" do
-        proc { @api_client.send(method, nil) }.must_raise ArgumentError
-      end
-    end
-    it "happens on publish" do
-      proc { @api_client.publish(nil, "major") }.must_raise ArgumentError
-    end
-    it "happens on put_content" do
-      proc { @api_client.put_content(nil, {}) }.must_raise ArgumentError
-    end
-    it "happens on patch_links" do
-      proc { @api_client.patch_links(nil, links: {}) }.must_raise ArgumentError
-    end
-  end
-end