gds-api-adapters 38.1.0 → 39.0.0

data/test/gds_api_base_test.rb

@@ -1,110 +0,0 @@
-require 'test_helper'
-require 'gds_api/base'
-require 'uri'
-
-class GdsApiBaseTest < Minitest::Test
-  class ConcreteApi < GdsApi::Base
-    def base_url
-      endpoint
-    end
-  end
-
-  def setup
-    @orig_cache = GdsApi::JsonClient.cache
-  end
-
-  def teardown
-    GdsApi::Base.default_options = nil
-    GdsApi::JsonClient.cache = @orig_cache
-  end
-
-  def test_should_construct_escaped_query_string
-    api = ConcreteApi.new('http://foo')
-    url = api.url_for_slug("slug", "a" => " ", "b" => "/")
-    u = URI.parse(url)
-    assert_equal "a=+&b=%2F", u.query
-  end
-
-  def test_should_construct_escaped_query_string_for_rails
-    api = ConcreteApi.new('http://foo')
-
-    url = api.url_for_slug("slug", "b" => ['123'])
-    u = URI.parse(url)
-    assert_equal "b%5B%5D=123", u.query
-
-    url = api.url_for_slug("slug", "b" => %w(123 456))
-    u = URI.parse(url)
-    assert_equal "b%5B%5D=123&b%5B%5D=456", u.query
-  end
-
-  def test_should_not_add_a_question_mark_if_there_are_no_parameters
-    api = ConcreteApi.new('http://foo')
-    url = api.url_for_slug("slug")
-    refute_match(/\?/, url)
-  end
-
-  def test_should_use_endpoint_in_url
-    api = ConcreteApi.new("http://foobarbaz")
-    url = api.url_for_slug("slug")
-    u = URI.parse(url)
-    assert_match(/foobarbaz$/, u.host)
-  end
-
-  def test_should_accept_options_as_second_arg
-    api = ConcreteApi.new("http://foo", foo: "bar")
-    assert_equal "bar", api.options[:foo]
-  end
-
-  def test_setting_cache_size_from_options
-    GdsApi::JsonClient.cache = false
-    api = ConcreteApi.new("https://foo", cache_size: 2)
-    assert_equal 2, api.client.cache.max_size
-  end
-
-  def test_setting_cache_size_from_default_options
-    GdsApi::JsonClient.cache = false
-    GdsApi::Base.default_options = { cache_size: 4 }
-    api = ConcreteApi.new("http://bar")
-    assert_equal 4, api.client.cache.max_size
-  end
-
-  def test_disabling_cache
-    # Ensure that there is a non-null cache by default
-    GdsApi::JsonClient.cache = true
-    api = ConcreteApi.new("http://bar", disable_cache: true)
-    assert api.client.cache.is_a? GdsApi::NullCache
-  end
-
-  def test_disabling_cache_old_style
-    # Ensure that there is a non-null cache by default
-    GdsApi::JsonClient.cache = true
-    api = ConcreteApi.new("http://bar", cache_size: 0)
-    assert api.client.cache.is_a? GdsApi::NullCache
-  end
-
-  def test_should_barf_if_not_given_valid_url
-    assert_raises GdsApi::Base::InvalidAPIURL do
-      ConcreteApi.new('invalid-url')
-    end
-  end
-
-  def test_should_set_json_client_logger_to_own_logger_by_default
-    api = ConcreteApi.new("http://bar")
-    assert_same GdsApi::Base.logger, api.client.logger
-  end
-
-  def test_should_set_json_client_logger_to_logger_in_default_options
-    custom_logger = stub('custom-logger')
-    GdsApi::Base.default_options = { logger: custom_logger }
-    api = ConcreteApi.new("http://bar")
-    assert_same custom_logger, api.client.logger
-  end
-
-  def test_should_set_json_client_logger_to_logger_in_options
-    custom_logger = stub('custom-logger')
-    GdsApi::Base.default_options = { logger: custom_logger }
-    another_logger = stub('another-logger')
-    api = ConcreteApi.new("http://bar", logger: another_logger)
-    assert_same another_logger, api.client.logger
-  end
-end

data/test/gov_uk_delivery_test.rb

@@ -1,67 +0,0 @@
-require 'test_helper'
-require 'gds_api/gov_uk_delivery'
-require 'gds_api/test_helpers/gov_uk_delivery'
-
-describe GdsApi::GovUkDelivery do
-  include GdsApi::TestHelpers::GovUkDelivery
-
-  before do
-    @base_api_url = Plek.current.find("govuk-delivery")
-    @api = GdsApi::GovUkDelivery.new(@base_api_url)
-  end
-
-  it "can create a topic" do
-    expected_payload = { feed_url: 'http://example.com/feed', title: 'Title', description: nil }
-    stub = stub_gov_uk_delivery_post_request('lists', expected_payload).to_return(created_response_hash)
-
-    assert @api.topic("http://example.com/feed", "Title")
-    assert_requested stub
-  end
-
-  it "can subscribe a new email" do
-    expected_payload = { email: 'me@example.com', feed_urls: ['http://example.com/feed'] }
-    stub = stub_gov_uk_delivery_post_request('subscriptions', expected_payload).to_return(created_response_hash)
-
-    assert @api.subscribe('me@example.com', ['http://example.com/feed'])
-    assert_requested stub
-  end
-
-  it "can post a notification" do
-    expected_payload = { feed_urls: ['http://example.com/feed'], subject: 'Test', body: '<p>Something</p>' }
-    stub = stub_gov_uk_delivery_post_request('notifications', expected_payload).to_return(created_response_hash)
-
-    assert @api.notify(['http://example.com/feed'], 'Test', '<p>Something</p>')
-    assert_requested stub
-  end
-
-  it "can get a subscription URL" do
-    expected_payload = { feed_url: 'http://example.com/feed' }
-    stub = stub_gov_uk_delivery_get_request('list-url', expected_payload).to_return(created_response_json_hash(list_url: 'thing'))
-
-    assert @api.signup_url('http://example.com/feed')
-    assert_requested stub
-  end
-
-  it "raises if the API 404s" do
-    expected_payload = { feed_url: 'http://example.com/feed' }
-    stub_gov_uk_delivery_get_request('list-url', expected_payload).to_return(not_found_hash)
-
-    assert_raises(GdsApi::HTTPNotFound) do
-      @api.signup_url('http://example.com/feed')
-    end
-  end
-
-  private
-
-  def created_response_hash
-    { body: '', status: 201 }
-  end
-
-  def not_found_hash
-    { body: '', status: 404 }
-  end
-
-  def created_response_json_hash(data)
-    { body: data.to_json, status: 201 }
-  end
-end

data/test/govuk_headers_test.rb

@@ -1,30 +0,0 @@
-require_relative "test_helper"
-require "gds_api/govuk_headers"
-
-describe GdsApi::GovukHeaders do
-  before :each do
-    Thread.current[:headers] = nil if Thread.current[:headers]
-  end
-
-  after :each do
-    GdsApi::GovukHeaders.clear_headers
-  end
-
-  it "supports read/write of headers" do
-    GdsApi::GovukHeaders.set_header("GDS-Request-Id", "123-456")
-    GdsApi::GovukHeaders.set_header("Content-Type", "application/pdf")
-
-    assert_equal({
-      "GDS-Request-Id" => "123-456",
-      "Content-Type" => "application/pdf",
-    }, GdsApi::GovukHeaders.headers)
-  end
-
-  it "supports clearing of headers" do
-    GdsApi::GovukHeaders.set_header("GDS-Request-Id", "123-456")
-
-    GdsApi::GovukHeaders.clear_headers
-
-    assert_equal({}, GdsApi::GovukHeaders.headers)
-  end
-end

data/test/helpers_test.rb

@@ -1,23 +0,0 @@
-require 'test_helper'
-require 'gds_api/helpers'
-
-describe GdsApi::Helpers do
-  class TestDouble
-    include GdsApi::Helpers
-  end
-
-  it "should define helpers for the various apis" do
-    test_with_helpers = TestDouble.new
-
-    refute_nil test_with_helpers.asset_manager_api
-    refute_nil test_with_helpers.business_support_api
-    refute_nil test_with_helpers.content_api
-    refute_nil test_with_helpers.content_store
-    refute_nil test_with_helpers.imminence_api
-    refute_nil test_with_helpers.licence_application_api
-    refute_nil test_with_helpers.need_api
-    refute_nil test_with_helpers.panopticon_api
-    refute_nil test_with_helpers.worldwide_api
-    refute_nil test_with_helpers.email_alert_api
-  end
-end

data/test/imminence_api_test.rb

@@ -1,196 +0,0 @@
-require "test_helper"
-require "gds_api/imminence"
-
-class ImminenceApiTest < Minitest::Test
-  ROOT = "https://imminence.test.alphagov.co.uk".freeze
-  LATITUDE = 52.1327584352089
-  LONGITUDE = -0.4702813074674147
-
-  def api_client
-    GdsApi::Imminence.new(ROOT)
-  end
-
-  def dummy_place
-    {
-      "access_notes" => nil,
-      "address1" => "Cauldwell Street",
-      "address2" => "Bedford",
-      "fax" => nil,
-      "general_notes" => nil,
-      "geocode_error" => nil,
-      "location" => [LATITUDE, LONGITUDE],
-      "name" => "Town Hall",
-      "phone" => nil,
-      "postcode" => "MK42 9AP",
-      "source_address" => "Town Hall, Cauldwell Street, Bedford",
-      "text_phone" => nil,
-      "town" => nil,
-      "url" => "http://www.bedford.gov.uk/advice_and_benefits/registration_service.aspx"
-    }
-  end
-
-  def test_no_second_address_line
-    c = api_client
-    url = "#{ROOT}/places/wibble.json?limit=5&lat=52&lng=0"
-    place_info = dummy_place.merge "address2" => nil
-    c.expects(:get_json).with(url).returns([place_info])
-    places = c.places("wibble", 52, 0)
-
-    assert_equal 1, places.size
-    assert_equal "Cauldwell Street", places[0]["address"]
-  end
-
-  def test_search_for_places
-    c = api_client
-    url = "#{ROOT}/places/wibble.json?limit=5&lat=52&lng=0"
-    c.expects(:get_json).with(url).returns([dummy_place])
-    places = c.places("wibble", 52, 0)
-
-    assert_equal 1, places.size
-    place = places[0]
-    assert_equal LATITUDE, place["latitude"]
-    assert_equal LONGITUDE, place["longitude"]
-    assert_equal "Cauldwell Street, Bedford", place["address"]
-  end
-
-  def test_empty_location
-    # Test behaviour when the location field is an empty array
-    c = api_client
-    url = "#{ROOT}/places/wibble.json?limit=5&lat=52&lng=0"
-    place_info = dummy_place.merge("location" => [])
-    c.expects(:get_json).with(url).returns([place_info])
-    places = c.places("wibble", 52, 0)
-
-    assert_equal 1, places.size
-    place = places[0]
-    assert_nil place["latitude"]
-    assert_nil place["longitude"]
-  end
-
-  def test_nil_location
-    # Test behaviour when the location field is nil
-    c = api_client
-    url = "#{ROOT}/places/wibble.json?limit=5&lat=52&lng=0"
-    place_info = dummy_place.merge("location" => nil)
-    c.expects(:get_json).with(url).returns([place_info])
-    places = c.places("wibble", 52, 0)
-
-    assert_equal 1, places.size
-    place = places[0]
-    assert_nil place["latitude"]
-    assert_nil place["longitude"]
-  end
-
-  def test_hash_location
-    # Test behaviour when the location field is a longitude/latitude hash
-    c = api_client
-    url = "#{ROOT}/places/wibble.json?limit=5&lat=52&lng=0"
-    place_info = dummy_place.merge(
-      "location" => { "longitude" => LONGITUDE, "latitude" => LATITUDE }
-    )
-    c.expects(:get_json).with(url).returns([place_info])
-    places = c.places("wibble", 52, 0)
-
-    assert_equal 1, places.size
-    place = places[0]
-    assert_equal LATITUDE, place["latitude"]
-    assert_equal LONGITUDE, place["longitude"]
-  end
-
-  def test_postcode_search
-    # Test behaviour when searching by postcode
-    c = api_client
-    url = "#{ROOT}/places/wibble.json?limit=5&postcode=MK42+9AA"
-    c.expects(:get_json).with(url).returns([dummy_place])
-    places = c.places_for_postcode("wibble", "MK42 9AA")
-
-    assert_equal 1, places.size
-  end
-
-  def test_invalid_postcode_search
-    # Test behaviour when searching by invalid postcode
-    c = api_client
-    url = "#{ROOT}/places/wibble.json?limit=5&postcode=MK99+9AA"
-    c.expects(:get_json).with(url).raises(GdsApi::HTTPErrorResponse.new(400))
-    assert_raises GdsApi::HTTPErrorResponse do
-      c.places_for_postcode("wibble", "MK99 9AA")
-    end
-  end
-
-  def test_places_kml
-    kml_body = <<-EOS
-<?xml version="1.0" encoding="UTF-8"?>
-<kml xmlns="http://www.opengis.net/kml/2.2" xmlns:atom="http://www.w3.org/2005/Atom">
-  <Document>
-    <name>DVLA Offices</name>
-    <Placemark>
-      <atom:link/>
-      <name>DVLA Aberdeen local office</name>
-      <description>For enquiries about vehicles: 0300 790 6802 (Textphone minicom users 0300 123 1279).For enquiries about driving licences: 0300 790 6801 (Textphone minicom users 0300 123 1278).Please note, all calls are handled initially by our call centre based in Swansea</description>
-      <address>Greyfriars House, Gallowgate, Aberdeen, AB10 1WG, UK</address>
-      <Point>
-        <coordinates>-2.0971999005177566,57.150739708305785,0</coordinates>
-      </Point>
-    </Placemark>
-  </document>
-</kml>
-EOS
-
-    stub_request(:get, "#{ROOT}/places/test.kml").
-      with(headers: GdsApi::JsonClient.default_request_headers).
-      to_return(status: 200, body: kml_body)
-
-    response_body = api_client.places_kml("test")
-    assert_equal kml_body, response_body
-  end
-
-  def test_areas_for_postcode
-    areas = [
-      { "id" => 12, "type" => "LBO", "name" => "Westminster City Council", "country_name" => "England" },
-      { "id" => 66, "type" => "EUR", "name" => "London", "country_name" => "England" }
-    ]
-    results = {
-      "_response_info" => { "status" => "ok" },
-      "total" => areas.size, "startIndex" => 1, "pageSize" => areas.size,
-      "currentPage" => 1, "pages" => 1, "results" => areas
-    }
-
-    stub_request(:get, "#{ROOT}/areas/WC2B%206SE.json").
-      with(headers: GdsApi::JsonClient.default_request_headers).
-      to_return(status: 200, body: results.to_json)
-
-    response = api_client.areas_for_postcode("WC2B 6SE")
-
-    assert_equal "ok", response["_response_info"]["status"]
-    areas_from_response = response["results"]
-    assert_equal 2, areas_from_response.size
-    assert_equal "LBO", areas_from_response.first["type"]
-    assert_equal 12, areas_from_response.first["id"]
-  end
-
-  def test_areas_by_type
-    areas = [
-      { "id" => 122, "type" => "EUR", "name" => "Yorkshire and the Humber", "country_name" => "England" },
-      { "id" => 665, "type" => "EUR", "name" => "London", "country_name" => "England" }
-    ]
-    results = {
-      "_response_info" => { "status" => "ok" },
-      "total" => areas.size, "startIndex" => 1, "pageSize" => areas.size,
-      "currentPage" => 1, "pages" => 1, "results" => areas
-    }
-
-    stub_request(:get, "#{ROOT}/areas/EUR.json").
-      with(headers: GdsApi::JsonClient.default_request_headers).
-      to_return(status: 200, body: results.to_json)
-
-    response = api_client.areas_for_type("EUR")
-
-    assert_equal "ok", response["_response_info"]["status"]
-    areas_from_response = response["results"]
-    assert_equal 2, areas_from_response.size
-    assert_equal "EUR", areas_from_response.first["type"]
-    assert_equal "EUR", areas_from_response.last["type"]
-    assert_equal 122, areas_from_response.first["id"]
-    assert_equal 665, areas_from_response.last["id"]
-  end
-end

data/test/json_client_test.rb

@@ -1,879 +0,0 @@
-require_relative 'test_helper'
-require 'gds_api/base'
-require 'gds_api/json_client'
-require 'base64'
-require 'null_logger'
-
-class JsonClientTest < MiniTest::Spec
-  def setup
-    @json_client_cache = GdsApi::JsonClient.cache
-
-    # Set the cache to nil so the JsonClient recreates it on each test run
-    # This used to initialise the cache to an empty Hash, eliminating the
-    # potential problem of cache entries expiring during a test run, but that
-    # no longer works now our code calls the `store` method with an expiry time
-    GdsApi::JsonClient.cache = nil
-
-    @client = GdsApi::JsonClient.new
-
-    WebMock.disable_net_connect!
-  end
-
-  def teardown
-    super
-    GdsApi::JsonClient.cache = @json_client_cache
-  end
-
-  def options;
-    {}
-  end
-
-  def test_long_get_requests_timeout
-    url = "http://www.example.com/timeout.json"
-    stub_request(:get, url).to_timeout
-    assert_raises GdsApi::TimedOutException do
-      @client.get_json(url)
-    end
-  end
-
-  def test_long_connections_timeout
-    url = "http://www.example.com/timeout.json"
-    exception = defined?(Net::OpenTimeout) ? Net::OpenTimeout : TimeoutError
-    stub_request(:get, url).to_raise(exception)
-    assert_raises GdsApi::TimedOutException do
-      @client.get_json(url)
-    end
-  end
-
-  def test_request_an_invalid_url
-    url = "http://www.example.com/there-is-a-space-in-this-slug /"
-    assert_raises GdsApi::InvalidUrl do
-      @client.get_json(url)
-    end
-  end
-
-  def test_get_should_raise_endpoint_not_found_if_connection_refused
-    url = "http://some.endpoint/some.json"
-    stub_request(:get, url).to_raise(Errno::ECONNREFUSED)
-    assert_raises GdsApi::EndpointNotFound do
-      @client.get_json(url)
-    end
-  end
-
-  def test_post_should_raise_endpoint_not_found_if_connection_refused
-    url = "http://some.endpoint/some.json"
-    stub_request(:get, url).to_raise(Errno::ECONNREFUSED)
-    assert_raises GdsApi::EndpointNotFound do
-      @client.get_json(url)
-    end
-  end
-
-  def test_post_requests_timeout
-    url = "http://some.endpoint/some.json"
-    stub_request(:post, url).to_timeout
-    assert_raises GdsApi::TimedOutException do
-      @client.post_json(url, {})
-    end
-  end
-
-  def test_get_should_raise_error_on_restclient_error
-    url = "http://some.endpoint/some.json"
-    stub_request(:get, url).to_raise(RestClient::ServerBrokeConnection)
-    assert_raises GdsApi::HTTPErrorResponse do
-      @client.get_json(url)
-    end
-  end
-
-  def test_should_fetch_and_parse_json_into_response
-    url = "http://some.endpoint/some.json"
-    stub_request(:get, url).to_return(body: "{}", status: 200)
-    assert_equal GdsApi::Response, @client.get_json(url).class
-  end
-
-  def test_should_cache_multiple_requests_to_same_url_across_instances
-    url = "http://some.endpoint/some.json"
-    result = { "foo" => "bar" }
-    stub_request(:get, url).to_return(body: JSON.dump(result), status: 200)
-    response_a = GdsApi::JsonClient.new.get_json(url)
-    response_b = GdsApi::JsonClient.new.get_json(url)
-    assert_equal response_a.to_hash, response_b.to_hash
-    assert_requested :get, url, times: 1
-  end
-
-  def test_allow_overriding_the_number_of_cached_items
-    # Clear out the default cache instance, because otherwise the customisation
-    # doesn't take effect, due to some non-obvious behaviour in JsonClient.
-    GdsApi::JsonClient.cache = nil
-
-    url = "http://some.endpoint/"
-
-    stub_request(:get, %r{\A#{url}}).to_return do |request|
-      { body: { "url" => request.uri }.to_json, status: 200 }
-    end
-
-    response_a = GdsApi::JsonClient.new(cache_size: 5).get_json("#{url}/first.json")
-    response_b = GdsApi::JsonClient.new.get_json("#{url}/second.json")
-    4.times { |n| GdsApi::JsonClient.new.get_json("#{url}/#{n}.json") }
-
-    response_c = GdsApi::JsonClient.new.get_json("#{url}/second.json")
-    response_d = GdsApi::JsonClient.new.get_json("#{url}/first.json")
-
-    assert_requested :get, "#{url}/second.json", times: 1
-    assert_requested :get, "#{url}/first.json", times: 2
-    assert_equal response_b.to_hash, response_c.to_hash
-    assert_equal response_a.to_hash, response_d.to_hash
-  end
-
-  def test_should_cache_requests_for_15_mins_by_default
-    url = "http://some.endpoint/some.json"
-    result = { "foo" => "bar" }
-    stub_request(:get, url).to_return(body: JSON.dump(result), status: 200)
-    response_a = GdsApi::JsonClient.new.get_json(url)
-    response_b = GdsApi::JsonClient.new.get_json(url)
-
-    assert_requested :get, url, times: 1
-    assert_equal response_a.to_hash, response_b.to_hash
-
-    Timecop.travel(15 * 60 - 30) do # now + 14 mins 30 secs
-      response_c = GdsApi::JsonClient.new.get_json(url)
-
-      assert_requested :get, url, times: 1
-      assert_equal response_a.to_hash, response_c.to_hash
-    end
-
-    Timecop.travel(15 * 60 + 30) do # now + 15 mins 30 secs
-      response_d = GdsApi::JsonClient.new.get_json(url)
-
-      assert_requested :get, url, times: 2
-      assert_equal response_a.to_hash, response_d.to_hash
-    end
-  end
-
-  def test_should_allow_overriding_cache_ttl
-    # Clear out the default cache instance, because otherwise the customisation
-    # doesn't take effect, due to some non-obvious behaviour in JsonClient.
-    GdsApi::JsonClient.cache = nil
-
-    url = "http://some.endpoint/some.json"
-    result = { "foo" => "bar" }
-    stub_request(:get, url).to_return(body: JSON.dump(result), status: 200)
-    response_a = GdsApi::JsonClient.new(cache_ttl: 5 * 60).get_json(url)
-    response_b = GdsApi::JsonClient.new.get_json(url)
-
-    assert_requested :get, url, times: 1
-    assert_equal response_a.to_hash, response_b.to_hash
-
-    Timecop.travel(5 * 60 - 30) do # now + 4 mins 30 secs
-      response_c = GdsApi::JsonClient.new.get_json(url)
-
-      assert_requested :get, url, times: 1
-      assert_equal response_a.to_hash, response_c.to_hash
-    end
-
-    Timecop.travel(5 * 60 + 30) do # now + 5 mins 30 secs
-      response_d = GdsApi::JsonClient.new.get_json(url)
-
-      assert_requested :get, url, times: 2
-      assert_equal response_a.to_hash, response_d.to_hash
-    end
-  end
-
-  def test_should_allow_disabling_caching
-    url = "http://some.endpoint/some.json"
-    result = { "foo" => "bar" }
-    stub_request(:get, url).to_return(body: JSON.dump(result), status: 200)
-
-    client = GdsApi::JsonClient.new(disable_cache: true)
-
-    response_a = client.get_json(url)
-    response_b = client.get_json(url)
-
-    assert_requested :get, url, times: 2
-
-    [response_a, response_b].each do |r|
-      assert_equal result, r.to_hash
-    end
-  end
-
-  def test_should_respect_expiry_headers
-    url = "http://some.endpoint/some.json"
-    result = { "foo" => "bar" }
-    stub_request(:get, url).to_return(
-      body: JSON.dump(result),
-      status: 200,
-      headers: { "Expires" => (Time.now + 7 * 60).utc.httpdate }
-    )
-
-    response_a = GdsApi::JsonClient.new.get_json(url)
-
-    Timecop.travel(7 * 60 - 30) do # now + 6 mins 30 secs
-      response_b = GdsApi::JsonClient.new.get_json(url)
-
-      assert_requested :get, url, times: 1
-      assert_equal response_a.to_hash, response_b.to_hash
-    end
-
-    Timecop.travel(7 * 60 + 30) do # now + 7 mins 30 secs
-      response_c = GdsApi::JsonClient.new.get_json(url)
-
-      assert_requested :get, url, times: 2
-      assert_equal response_a.to_hash, response_c.to_hash
-    end
-  end
-
-  def test_should_respect_cache_control_headers_with_max_age
-    url = "http://some.endpoint/max_age.json"
-    result = { "foo" => "bar" }
-    stub_request(:get, url).to_return(
-      body: JSON.dump(result),
-      status: 200,
-      headers: { "Cache-Control" => "max-age=420, public" } # 7 minutes
-    )
-
-    response_a = GdsApi::JsonClient.new.get_json(url)
-
-    Timecop.travel(7 * 60 - 30) do # now + 6 mins 30 secs
-      response_b = GdsApi::JsonClient.new.get_json(url)
-
-      assert_requested :get, url, times: 1
-      assert_equal response_a.to_hash, response_b.to_hash
-    end
-
-    Timecop.travel(7 * 60 + 30) do # now + 7 mins 30 secs
-      response_c = GdsApi::JsonClient.new.get_json(url)
-
-      assert_requested :get, url, times: 2
-      assert_equal response_a.to_hash, response_c.to_hash
-    end
-  end
-
-  def test_should_respect_cache_control_headers_with_no_cache
-    url = "http://some.endpoint/no_cache.json"
-    result = { "foo" => "bar" }
-    stub_request(:get, url).to_return(
-      body: JSON.dump(result),
-      status: 200,
-      headers: { "Cache-Control" => "no-cache, public" }
-    )
-
-    response_a = GdsApi::JsonClient.new.get_json(url)
-
-    Timecop.travel(7 * 60 - 30) do # now + 6 mins 30 secs
-      response_b = GdsApi::JsonClient.new.get_json(url)
-
-      assert_requested :get, url, times: 2
-      assert_equal response_a.to_hash, response_b.to_hash
-    end
-  end
-
-  def test_does_not_cache_responses_with_cache_control_private
-    url = "http://some.endpoint/private.json"
-    result = { "foo" => "bar" }
-    stub_request(:get, url).to_return(
-      body: JSON.dump(result),
-      status: 200,
-      headers: { "Cache-Control" => "max-age=600, private" }
-    )
-
-    response_a = GdsApi::JsonClient.new.get_json(url)
-
-    Timecop.travel(7 * 60 - 30) do # now + 6 mins 30 secs
-      response_b = GdsApi::JsonClient.new.get_json(url)
-
-      assert_requested :get, url, times: 2
-      assert_equal response_a.to_hash, response_b.to_hash
-    end
-  end
-
-  def test_does_not_cache_responses_with_cache_control_no_store
-    url = "http://some.endpoint/private.json"
-    result = { "foo" => "bar" }
-    stub_request(:get, url).to_return(
-      body: JSON.dump(result),
-      status: 200,
-      headers: { "Cache-Control" => "max-age=600, no-store" }
-    )
-
-    response_a = GdsApi::JsonClient.new.get_json(url)
-
-    Timecop.travel(7 * 60 - 30) do # now + 6 mins 30 secs
-      response_b = GdsApi::JsonClient.new.get_json(url)
-
-      assert_requested :get, url, times: 2
-      assert_equal response_a.to_hash, response_b.to_hash
-    end
-  end
-
-  def test_should_respect_cache_control_headers_with_no_cache_and_max_age
-    url = "http://some.endpoint/no_cache_and_max_age.json"
-    result = { "foo" => "bar" }
-    stub_request(:get, url).to_return(
-      body: JSON.dump(result),
-      status: 200,
-      headers: { "Cache-Control" => "max-age=600, no-cache, public" }
-    )
-
-    response_a = GdsApi::JsonClient.new.get_json(url)
-
-    Timecop.travel(7 * 60 - 30) do # now + 6 mins 30 secs
-      response_b = GdsApi::JsonClient.new.get_json(url)
-
-      assert_requested :get, url, times: 2
-      assert_equal response_a.to_hash, response_b.to_hash
-    end
-  end
-
-  def test_should_use_cache_control_headers_over_expires_headers
-    url = "http://some.endpoint/url.json"
-    result = { "foo" => "bar" }
-    stub_request(:get, url).to_return(
-      body: JSON.dump(result),
-      status: 200,
-      headers: {
-        "Cache-Control" => "no-cache",
-        "Expires" => (Time.now + 7 * 60).utc.httpdate
-      }
-    )
-
-    response_a = GdsApi::JsonClient.new.get_json(url)
-
-    Timecop.travel(7 * 60 - 30) do # now + 6 mins 30 secs
-      response_b = GdsApi::JsonClient.new.get_json(url)
-
-      assert_requested :get, url, times: 2
-      assert_equal response_a.to_hash, response_b.to_hash
-    end
-  end
-
-  def test_should_fallback_to_expires_headers_if_cache_control_is_malformed
-    url = "http://some.endpoint/url.json"
-    result = { "foo" => "bar" }
-    stub_request(:get, url).to_return(
-      body: JSON.dump(result),
-      status: 200,
-      headers: {
-        "Cache-Control" => "foo, bar, baz",
-        "Expires" => (Time.now + 7 * 60).utc.httpdate
-      }
-    )
-
-    response_a = GdsApi::JsonClient.new.get_json(url)
-
-    Timecop.travel(7 * 60 - 30) do # now + 6 mins 30 secs
-      response_b = GdsApi::JsonClient.new.get_json(url)
-
-      assert_requested :get, url, times: 1
-      assert_equal response_a.to_hash, response_b.to_hash
-    end
-  end
-
-  def test_get_bang_should_raise_http_not_found_if_404_returned_from_endpoint
-    url = "http://some.endpoint/some.json"
-    stub_request(:get, url).to_return(body: "{}", status: 404)
-    assert_raises GdsApi::HTTPNotFound do
-      @client.get_json(url)
-    end
-  end
-
-  def test_get_bang_should_raise_http_gone_if_410_returned_from_endpoint
-    url = "http://some.endpoint/some.json"
-    stub_request(:get, url).to_return(body: "{}", status: 410)
-    assert_raises GdsApi::HTTPGone do
-      @client.get_json(url)
-    end
-  end
-
-  def test_get_bang_should_raise_http_forbidden_if_403_returned_from_endpoint
-    url = "http://some.endpoint/some.json"
-    stub_request(:get, url).to_return(body: "{}", status: 403)
-    assert_raises GdsApi::HTTPForbidden do
-      @client.get_json(url)
-    end
-  end
-
-  def test_get_should_raise_if_404_returned_from_endpoint
-    url = "http://some.endpoint/some.json"
-    stub_request(:get, url).to_return(body: "{}", status: 404)
-    assert_raises GdsApi::HTTPNotFound do
-      @client.get_json(url)
-    end
-  end
-
-  def test_get_should_raise_if_410_returned_from_endpoint
-    url = "http://some.endpoint/some.json"
-    stub_request(:get, url).to_return(body: "{}", status: 410)
-    assert_raises GdsApi::HTTPGone do
-      @client.get_json(url)
-    end
-  end
-
-  def test_get_raw_should_raise_if_404_returned_from_endpoint
-    url = "http://some.endpoint/some.json"
-    stub_request(:get, url).to_return(body: "{}", status: 404)
-    assert_raises GdsApi::HTTPNotFound do
-      @client.get_raw(url)
-    end
-  end
-
-  def test_get_raw_should_be_nil_if_410_returned_from_endpoint
-    url = "http://some.endpoint/some.json"
-    stub_request(:get, url).to_return(body: "{}", status: 410)
-    assert_raises GdsApi::HTTPGone do
-      @client.get_raw(url)
-    end
-  end
-
-  def test_get_should_raise_error_if_non_404_non_410_error_code_returned_from_endpoint
-    url = "http://some.endpoint/some.json"
-    stub_request(:get, url).to_return(body: "{}", status: 500)
-    assert_raises GdsApi::HTTPServerError do
-      @client.get_json(url)
-    end
-  end
-
-  def test_get_should_raise_conflict_for_409
-    url = "http://some.endpoint/some.json"
-    stub_request(:delete, url).to_return(body: "{}", status: 409)
-    assert_raises GdsApi::HTTPConflict do
-      @client.delete_json(url)
-    end
-  end
-
-  def test_get_should_follow_permanent_redirect
-    url = "http://some.endpoint/some.json"
-    new_url = "http://some.endpoint/other.json"
-    stub_request(:get, url).to_return(
-      body: "",
-      status: 301,
-      headers: { "Location" => new_url }
-    )
-    stub_request(:get, new_url).to_return(body: '{"a": 1}', status: 200)
-    result = @client.get_json(url)
-    assert_equal 1, result['a']
-  end
-
-  def test_get_should_follow_found_redirect
-    url = "http://some.endpoint/some.json"
-    new_url = "http://some.endpoint/other.json"
-    stub_request(:get, url).to_return(
-      body: "",
-      status: 302,
-      headers: { "Location" => new_url }
-    )
-    stub_request(:get, new_url).to_return(body: '{"a": 1}', status: 200)
-    result = @client.get_json(url)
-    assert_equal 1, result['a']
-  end
-
-  def test_get_should_follow_see_other
-    url = "http://some.endpoint/some.json"
-    new_url = "http://some.endpoint/other.json"
-    stub_request(:get, url).to_return(
-      body: "",
-      status: 303,
-      headers: { "Location" => new_url }
-    )
-    stub_request(:get, new_url).to_return(body: '{"a": 1}', status: 200)
-    result = @client.get_json(url)
-    assert_equal 1, result['a']
-  end
-
-  def test_get_should_follow_temporary_redirect
-    url = "http://some.endpoint/some.json"
-    new_url = "http://some.endpoint/other.json"
-    stub_request(:get, url).to_return(
-      body: "",
-      status: 307,
-      headers: { "Location" => new_url }
-    )
-    stub_request(:get, new_url).to_return(body: '{"a": 1}', status: 200)
-    result = @client.get_json(url)
-    assert_equal 1, result['a']
-  end
-
-  def test_should_handle_infinite_redirects
-    url = "http://some.endpoint/some.json"
-    redirect = {
-      body: "",
-      status: 302,
-      headers: { "Location" => url }
-    }
-
-    # Theoretically, we could set this up to mock out any number of requests
-    # with a redirect to the same URL, but we'd risk getting the test code into
-    # an infinite loop if the code didn't do what it was supposed to. The
-    # failure response block aborts the test if we have too many requests.
-    failure = lambda { |_request| flunk("Request called too many times") }
-    stub_request(:get, url).to_return(redirect).times(11).then.to_return(failure)
-
-    assert_raises GdsApi::HTTPErrorResponse do
-      @client.get_json(url)
-    end
-  end
-
-  def test_should_handle_mutual_redirects
-    first_url = "http://some.endpoint/some.json"
-    second_url = "http://some.endpoint/some-other.json"
-
-    first_redirect = {
-      body: "",
-      status: 302,
-      headers: { "Location" => second_url }
-    }
-    second_redirect = {
-      body: "",
-      status: 302,
-      headers: { "Location" => first_url }
-    }
-
-    # See the comment in the above test for an explanation of this
-    failure = lambda { |_request| flunk("Request called too many times") }
-    stub_request(:get, first_url).to_return(first_redirect).times(6).then.to_return(failure)
-    stub_request(:get, second_url).to_return(second_redirect).times(6).then.to_return(failure)
-
-    assert_raises GdsApi::HTTPErrorResponse do
-      @client.get_json(first_url)
-    end
-  end
-
-  def test_post_should_be_raise_if_404_returned_from_endpoint
-    url = "http://some.endpoint/some.json"
-    stub_request(:post, url).to_return(body: "{}", status: 404)
-    assert_raises(GdsApi::HTTPNotFound) do
-      @client.post_json(url, {})
-    end
-  end
-
-  def test_post_should_raise_error_if_non_404_error_code_returned_from_endpoint
-    url = "http://some.endpoint/some.json"
-    stub_request(:post, url).to_return(body: "{}", status: 500)
-    assert_raises GdsApi::HTTPServerError do
-      @client.post_json(url, {})
-    end
-  end
-
-  def test_post_should_error_on_found_redirect
-    url = "http://some.endpoint/some.json"
-    new_url = "http://some.endpoint/other.json"
-    stub_request(:post, url).to_return(
-      body: "",
-      status: 302,
-      headers: { "Location" => new_url }
-    )
-    assert_raises GdsApi::HTTPErrorResponse do
-      @client.post_json(url, {})
-    end
-  end
-
-  def test_put_should_be_raise_if_404_returned_from_endpoint
-    url = "http://some.endpoint/some.json"
-    stub_request(:put, url).to_return(body: "{}", status: 404)
-
-    assert_raises(GdsApi::HTTPNotFound) do
-      @client.put_json(url, {})
-    end
-  end
-
-  def test_put_should_raise_error_if_non_404_error_code_returned_from_endpoint
-    url = "http://some.endpoint/some.json"
-    stub_request(:put, url).to_return(body: "{}", status: 500)
-    assert_raises GdsApi::HTTPServerError do
-      @client.put_json(url, {})
-    end
-  end
-
-  def empty_response
-    net_http_response = stub(body: '{}')
-    GdsApi::Response.new(net_http_response)
-  end
-
-  def test_put_json_does_put_with_json_encoded_packet
-    url = "http://some.endpoint/some.json"
-    payload = { a: 1 }
-    stub_request(:put, url).with(body: payload.to_json).to_return(body: "{}", status: 200)
-    assert_equal({}, @client.put_json(url, payload).to_hash)
-  end
-
-  def test_does_not_encode_json_if_payload_is_nil
-    url = "http://some.endpoint/some.json"
-    stub_request(:put, url).with(body: nil).to_return(body: "{}", status: 200)
-    assert_equal({}, @client.put_json(url, nil).to_hash)
-  end
-
-  def test_can_build_custom_response_object
-    url = "http://some.endpoint/some.json"
-    stub_request(:get, url).to_return(body: "Hello there!")
-
-    response = @client.get_json(url, &:body)
-    assert response.is_a? String
-    assert_equal "Hello there!", response
-  end
-
-  def test_raises_on_custom_response_404
-    url = "http://some.endpoint/some.json"
-    stub_request(:get, url).to_return(body: "", status: 404)
-
-    assert_raises(GdsApi::HTTPNotFound) do
-      @client.get_json(url, &:body)
-    end
-  end
-
-  def test_can_build_custom_response_object_in_bang_method
-    url = "http://some.endpoint/some.json"
-    stub_request(:get, url).to_return(body: "Hello there!")
-
-    response = @client.get_json(url, &:body)
-    assert response.is_a? String
-    assert_equal "Hello there!", response
-  end
-
-  def test_can_access_attributes_of_response_directly
-    url = "http://some.endpoint/some.json"
-    payload = { a: 1 }
-    stub_request(:put, url).with(body: payload.to_json).to_return(body: '{"a":{"b":2}}', status: 200)
-    response = @client.put_json(url, payload)
-    assert_equal 2, response['a']['b']
-  end
-
-  def test_a_response_is_always_considered_present_and_not_blank
-    url = "http://some.endpoint/some.json"
-    stub_request(:put, url).to_return(body: '{"a":1}', status: 200)
-    response = @client.put_json(url, {})
-    assert ! response.blank?
-    assert response.present?
-  end
-
-  def test_client_can_use_basic_auth
-    client = GdsApi::JsonClient.new(basic_auth: { user: 'user', password: 'password' })
-
-    stub_request(:put, "http://user:password@some.endpoint/some.json").
-      to_return(body: '{"a":1}', status: 200)
-
-    response = client.put_json("http://some.endpoint/some.json", {})
-    assert_equal 1, response['a']
-  end
-
-  def test_client_can_use_bearer_token
-    client = GdsApi::JsonClient.new(bearer_token: 'SOME_BEARER_TOKEN')
-    expected_headers = GdsApi::JsonClient.default_request_with_json_body_headers.
-      merge('Authorization' => 'Bearer SOME_BEARER_TOKEN')
-
-    stub_request(:put, "http://some.other.endpoint/some.json").
-      with(headers: expected_headers).
-      to_return(body: '{"a":2}', status: 200)
-
-    response = client.put_json("http://some.other.endpoint/some.json", {})
-    assert_equal 2, response['a']
-  end
-
-  def test_client_can_set_custom_headers_on_gets
-    stub_request(:get, "http://some.other.endpoint/some.json").to_return(status: 200)
-
-    GdsApi::JsonClient.new.get_json("http://some.other.endpoint/some.json",
-                                               "HEADER-A" => "B", "HEADER-C" => "D")
-
-    assert_requested(:get, %r{/some.json}) do |request|
-      headers_with_uppercase_names = Hash[request.headers.collect { |key, value| [key.upcase, value] }]
-      headers_with_uppercase_names["HEADER-A"] == "B" && headers_with_uppercase_names["HEADER-C"] == "D"
-    end
-  end
-
-  def test_client_can_set_custom_headers_on_posts
-    stub_request(:post, "http://some.other.endpoint/some.json").to_return(status: 200)
-
-    GdsApi::JsonClient.new.post_json("http://some.other.endpoint/some.json", {},
-                                                "HEADER-A" => "B", "HEADER-C" => "D")
-
-    assert_requested(:post, %r{/some.json}) do |request|
-      headers_with_uppercase_names = Hash[request.headers.collect { |key, value| [key.upcase, value] }]
-      headers_with_uppercase_names["HEADER-A"] == "B" && headers_with_uppercase_names["HEADER-C"] == "D"
-    end
-  end
-
-  def test_client_can_set_custom_headers_on_puts
-    stub_request(:put, "http://some.other.endpoint/some.json").to_return(status: 200)
-
-    GdsApi::JsonClient.new.put_json("http://some.other.endpoint/some.json", {},
-                                               "HEADER-A" => "B", "HEADER-C" => "D")
-
-    assert_requested(:put, %r{/some.json}) do |request|
-      headers_with_uppercase_names = Hash[request.headers.collect { |key, value| [key.upcase, value] }]
-      headers_with_uppercase_names["HEADER-A"] == "B" && headers_with_uppercase_names["HEADER-C"] == "D"
-    end
-  end
-
-  def test_client_can_set_custom_headers_on_deletes
-    stub_request(:delete, "http://some.other.endpoint/some.json").to_return(status: 200)
-
-    GdsApi::JsonClient.new.delete_json("http://some.other.endpoint/some.json",
-                                                  "HEADER-A" => "B", "HEADER-C" => "D")
-
-    assert_requested(:delete, %r{/some.json}) do |request|
-      headers_with_uppercase_names = Hash[request.headers.collect { |key, value| [key.upcase, value] }]
-      headers_with_uppercase_names["HEADER-A"] == "B" && headers_with_uppercase_names["HEADER-C"] == "D"
-    end
-  end
-
-  def test_govuk_headers_are_included_in_requests_if_present
-    # set headers which would be set by middleware GovukHeaderSniffer
-    GdsApi::GovukHeaders.set_header(:govuk_request_id, "12345")
-    GdsApi::GovukHeaders.set_header(:govuk_original_url, "http://example.com")
-
-    stub_request(:get, "http://some.other.endpoint/some.json").to_return(status: 200)
-
-    GdsApi::JsonClient.new.get_json("http://some.other.endpoint/some.json")
-
-    assert_requested(:get, %r{/some.json}) do |request|
-      request.headers['Govuk-Request-Id'] == '12345' &&
-        request.headers['Govuk-Original-Url'] == 'http://example.com'
-    end
-  end
-
-  def test_govuk_headers_ignored_in_requests_if_not_present
-    GdsApi::GovukHeaders.set_header(:x_govuk_authenticated_user, "")
-    stub_request(:get, "http://some.other.endpoint/some.json").to_return(status: 200)
-
-    GdsApi::JsonClient.new.get_json("http://some.other.endpoint/some.json")
-
-    assert_requested(:get, %r{/some.json}) do |request|
-      !request.headers.has_key?('X-Govuk-Authenticated-User')
-    end
-  end
-
-  def test_additional_headers_passed_in_do_not_get_modified
-    stub_request(:get, "http://some.other.endpoint/some.json").to_return(status: 200)
-
-    headers = { 'HEADER-A' => 'A' }
-    GdsApi::JsonClient.new.get_json("http://some.other.endpoint/some.json", headers)
-
-    assert_equal({ 'HEADER-A' => 'A' }, headers)
-  end
-
-  def test_client_can_decompress_gzip_responses
-    url = "http://some.endpoint/some.json"
-    # {"test": "hello"}
-    stub_request(:get, url).to_return(
-      body: "\u001F\x8B\b\u0000Q\u000F\u0019Q\u0000\u0003\xABVP*I-.Q\xB2RP\xCAH\xCD\xC9\xC9WR\xA8\u0005\u0000\xD1C\u0018\xFE\u0013\u0000\u0000\u0000",
-      status: 200,
-      headers: { 'Content-Encoding' => 'gzip' }
-    )
-    response = @client.get_json(url)
-
-    assert_equal "hello", response["test"]
-  end
-
-  def test_client_can_post_multipart_responses
-    url = "http://some.endpoint/some.json"
-    stub_request(:post, url).
-      with(body: %r{------RubyFormBoundary\w+\r\nContent-Disposition: form-data; name="a"\r\n\r\n123\r\n------RubyFormBoundary\w+--\r\n},
-           headers: {
-             'Content-Type' => %r{multipart/form-data; boundary=----RubyFormBoundary\w+}
-           }).
-      to_return(body: '{"b": "1"}', status: 200)
-
-    response = @client.post_multipart("http://some.endpoint/some.json", "a" => "123")
-    assert_equal "1", response["b"]
-  end
-
-  def test_post_multipart_should_raise_exception_if_not_found
-    url = "http://some.endpoint/some.json"
-    stub_request(:post, url).to_return(body: '', status: 404)
-
-    assert_raises GdsApi::HTTPNotFound do
-      @client.post_multipart("http://some.endpoint/some.json", "a" => "123")
-    end
-  end
-
-  def test_post_multipart_should_raise_error_responses
-    url = "http://some.endpoint/some.json"
-    stub_request(:post, url).to_return(body: '', status: 500)
-
-    assert_raises GdsApi::HTTPServerError do
-      @client.post_multipart("http://some.endpoint/some.json", "a" => "123")
-    end
-  end
-
-  # EXACTLY the same as the post_multipart tests
-  def test_client_can_put_multipart_responses
-    url = "http://some.endpoint/some.json"
-    stub_request(:put, url).
-      with(body: %r{------RubyFormBoundary\w+\r\nContent-Disposition: form-data; name="a"\r\n\r\n123\r\n------RubyFormBoundary\w+--\r\n},
-           headers: {
-             'Content-Type' => %r{multipart/form-data; boundary=----RubyFormBoundary\w+}
-           }).
-      to_return(body: '{"b": "1"}', status: 200)
-
-    response = @client.put_multipart("http://some.endpoint/some.json", "a" => "123")
-    assert_equal "1", response["b"]
-  end
-
-  def test_put_multipart_should_raise_exception_if_not_found
-    url = "http://some.endpoint/some.json"
-    stub_request(:put, url).to_return(body: '', status: 404)
-
-    assert_raises GdsApi::HTTPNotFound do
-      @client.put_multipart("http://some.endpoint/some.json", "a" => "123")
-    end
-  end
-
-  def test_put_multipart_should_raise_error_responses
-    url = "http://some.endpoint/some.json"
-    stub_request(:put, url).to_return(body: '', status: 500)
-
-    assert_raises GdsApi::HTTPServerError do
-      @client.put_multipart("http://some.endpoint/some.json", "a" => "123")
-    end
-  end
-
-  def test_should_raise_error_if_attempting_to_disable_timeout
-    assert_raises RuntimeError do
-      GdsApi::JsonClient.new(disable_timeout: true)
-    end
-    assert_raises RuntimeError do
-      GdsApi::JsonClient.new(timeout: -1)
-    end
-  end
-
-  def test_should_add_user_agent_using_env
-    previous_govuk_app_name = ENV['GOVUK_APP_NAME']
-    ENV['GOVUK_APP_NAME'] = "api-tests"
-
-    url = "http://some.other.endpoint/some.json"
-    stub_request(:get, url).to_return(status: 200)
-
-    GdsApi::JsonClient.new.get_json(url)
-
-    assert_requested(:get, %r{/some.json}) do |request|
-      request.headers["User-Agent"] == "gds-api-adapters/#{GdsApi::VERSION} (api-tests)"
-    end
-  ensure
-    ENV['GOVUK_APP_NAME'] = previous_govuk_app_name
-  end
-
-  def test_should_default_to_using_null_logger
-    assert_same @client.logger, NullLogger.instance
-  end
-
-  def test_should_use_custom_logger_specified_in_options
-    custom_logger = stub('custom-logger')
-    client = GdsApi::JsonClient.new(logger: custom_logger)
-    assert_same client.logger, custom_logger
-  end
-
-  def test_should_avoid_content_type_header_on_get_without_body
-    url = "http://some.endpoint/some.json"
-    stub_request(:any, url)
-
-    @client.get_json(url)
-    assert_requested(:get, url, headers: GdsApi::JsonClient.default_request_headers)
-
-    @client.delete_json(url)
-    assert_requested(:delete, url, headers: GdsApi::JsonClient.default_request_headers)
-
-    @client.post_json(url, test: "123")
-    assert_requested(:post, url, headers: GdsApi::JsonClient.default_request_with_json_body_headers)
-
-    @client.put_json(url, test: "123")
-    assert_requested(:put, url, headers: GdsApi::JsonClient.default_request_with_json_body_headers)
-  end
-end