gds-api-adapters 0.0.20 → 0.0.23

data/lib/gds_api/base.rb

@@ -1,9 +1,23 @@
-require_relative 'json_utils'
+require_relative 'json_client'
 require 'cgi'
 require 'null_logger'
 
 class GdsApi::Base
-  include GdsApi::JsonUtils
+  extend Forwardable
+  
+  def client
+    @client ||= create_client
+  end
+  
+  def create_client
+    if options[:access_key]
+      GdsApi::OAuth2Client.new(options)
+    else
+      GdsApi::JsonClient.new(options)
+    end
+  end
+  
+  def_delegators :client, :get_json, :post_json, :put_json
 
   attr_reader :options
 

data/lib/gds_api/contactotron.rb

@@ -6,6 +6,6 @@ require_relative 'base'
 class GdsApi::Contactotron < GdsApi::Base
 
   def contact_for_uri(uri)
-    to_ostruct get_json(uri)
+    get_json(uri)
   end
 end

data/lib/gds_api/json_client.rb

@@ -0,0 +1,72 @@
+require_relative 'response'
+require_relative 'exceptions'
+
+module GdsApi
+  class JsonClient
+    attr_accessor :logger, :options
+    
+    def initialize(options = {})
+      @logger = options[:logger] || GdsApi::Base.logger
+      @options = options
+    end
+    
+    REQUEST_HEADERS = {
+      'Accept' => 'application/json', 
+      'Content-Type' => 'application/json',
+      'User-Agent' => "GDS Api Client v. #{GdsApi::VERSION}"
+    }
+    DEFAULT_TIMEOUT_IN_SECONDS = 0.5
+
+    def get_json(url)
+      do_request(Net::HTTP::Get, url)
+    end
+
+    def post_json(url, params)
+      do_request(Net::HTTP::Post, url, params)
+    end
+
+    def put_json(url, params)
+      do_request(Net::HTTP::Put, url, params)
+    end
+  
+  private
+  
+    def do_request(method_class, url, params = nil)
+      loggable = {request_uri: url, start_time: Time.now.to_f}
+      start_logging = loggable.merge(action: 'start')
+      logger.debug start_logging.to_json
+
+      url = URI.parse(url)
+      path = url.path
+      path = path + "?" + url.query if url.query
+
+      response = Net::HTTP.start(url.host, url.port, nil, nil, nil, nil, {use_ssl: url.port == 443, verify_mode: (OpenSSL::SSL::VERIFY_NONE if url.port == 443) }) do |http|
+        http.read_timeout = options[:timeout] || DEFAULT_TIMEOUT_IN_SECONDS
+        request = method_class.new(path, REQUEST_HEADERS)
+        request.basic_auth(@options[:basic_auth][:user], @options[:basic_auth][:password]) if @options[:basic_auth]
+        request.body = params.to_json if params
+        http.request(request)
+      end
+
+      if response.is_a?(Net::HTTPSuccess)
+        logger.info loggable.merge(status: 'success', end_time: Time.now.to_f).to_json
+        Response.new(response)
+      else
+        body = begin
+          JSON.parse(response.body)
+        rescue
+          response.body
+        end
+        loggable.merge!(status: response.code, end_time: Time.now.to_f, body: body)
+        logger.warn loggable.to_json
+        nil
+      end
+    rescue Errno::ECONNREFUSED
+      logger.error loggable.merge(status: 'refused', end_time: Time.now.to_f).to_json
+      raise GdsApi::EndpointNotFound.new("Could not connect to #{url}")
+    rescue Timeout::Error, Errno::ECONNRESET => e
+      logger.error loggable.merge(status: 'failed', end_time: Time.now.to_f).to_json
+      nil
+    end
+  end
+end

data/lib/gds_api/needotron.rb

@@ -2,13 +2,13 @@ require_relative 'base'
 
 class GdsApi::Needotron < GdsApi::Base
   def need_by_id(id, opts = {})
-    need_hash = get_json("#{base_url}/#{id}.json")
-    return nil if need_hash.nil? or need_hash['need'].nil?
+    response = get_json("#{base_url}/#{id}.json")
+    return nil if response.nil? or response['need'].nil?
 
     if opts[:as_hash]
-      need_hash
+      response.to_hash
     else
-      to_ostruct(need_hash['need'])
+      response.to_ostruct.need
     end
   end
 

data/lib/gds_api/oauth2_client.rb

@@ -0,0 +1,25 @@
+require_relative 'response'
+require_relative 'exceptions'
+
+# TODO: This is a work in progress
+module GdsApi
+  class OAuth2Client
+    def initialize(options)
+      raise "access_token required" unless options[:access_token]
+      @oauth_client = OAuth2::Client.new(nil, nil)
+      @access_token = OAuth2::AccessToken.new(@oauth_client, options[:access_token], options[:token_options])
+    end
+    
+    def get_json(url)
+      @access_token.get(url, headers: REQUEST_HEADERS)
+    end
+
+    def post_json(url, params)
+      @access_token.post(url, body: params, headers: REQUEST_HEADERS)
+    end
+
+    def put_json(url, params)
+      @access_token.put(url, body: params, headers: REQUEST_HEADERS)
+    end
+  end
+end

data/lib/gds_api/panopticon.rb

@@ -1,16 +1,15 @@
 require_relative 'base'
 
 class GdsApi::Panopticon < GdsApi::Base
+  def all
+    url = base_url + '.json'
+    json = get_json url
+    to_ostruct json
+  end
 
   def artefact_for_slug(slug, opts = {})
     return nil if slug.nil? or slug == ''
-
-    details = get_json(url_for_slug(slug))
-    if opts[:as_hash]
-      details
-    else
-      to_ostruct(details)
-    end
+    get_json(url_for_slug(slug))
   end
 
   def create_artefact(artefact)

data/lib/gds_api/publisher.rb

@@ -6,9 +6,9 @@ class GdsApi::Publisher < GdsApi::Base
   def publication_for_slug(slug, options = {})
     return nil if slug.nil? or slug == ''
 
-    publication_hash = get_json(url_for_slug(slug, options))
-    if publication_hash
-      container = to_ostruct(publication_hash)
+    response = get_json(url_for_slug(slug, options))
+    if response
+      container = response.to_ostruct
       container.extend(GdsApi::PartMethods) if container.parts
       convert_updated_date(container)
       container

data/lib/gds_api/response.rb

@@ -0,0 +1,49 @@
+require 'json'
+require 'ostruct'
+require_relative 'core-ext/openstruct'
+
+module GdsApi
+  class Response
+    extend Forwardable
+    include Enumerable
+    
+    def_delegators :to_hash, :[], :"<=>", :each
+    
+    def initialize(net_http_response)
+      @net_http_response = net_http_response
+    end
+    
+    def to_hash
+      @parsed ||= JSON.parse(@net_http_response.body)
+    end
+
+    def to_ostruct
+      self.class.build_ostruct_recursively(to_hash)
+    end
+    
+    def method_missing(method)
+      if to_hash.has_key?(method.to_s)
+        to_ostruct.send(method)
+      else
+        super
+      end
+    end
+    
+    def respond_to_missing?(method)
+      to_hash.has_key?(method.to_s) || super
+    end
+    
+  private
+  
+    def self.build_ostruct_recursively(value)
+      case value
+      when Hash
+        OpenStruct.new(Hash[value.map { |k, v| [k, build_ostruct_recursively(v)] }])
+      when Array
+        value.map { |v| build_ostruct_recursively(v) }
+      else
+        value
+      end
+    end
+  end
+end

data/lib/gds_api/test_helpers/publisher.rb

@@ -1,4 +1,4 @@
-require 'gds_api/json_utils'
+require 'gds_api/json_client'
 
 module GdsApi
   module TestHelpers
@@ -29,8 +29,8 @@ module GdsApi
         json = JSON.dump(output_details)
         slug = input_details.delete('slug')
         uri = "#{PUBLISHER_ENDPOINT}/local_transactions/#{slug}/verify_snac.json"
-        stub_request(:post, uri).with(:body => JSON.dump(input_details),
-          :headers => GdsApi::JsonUtils::REQUEST_HEADERS).
+        stub_request(:post, uri).with(:body => JSON.dump(input_details), 
+          :headers => GdsApi::JsonClient::REQUEST_HEADERS).
           to_return(:body => json, :status => 200)
       end
 

data/lib/gds_api/version.rb

@@ -1,3 +1,3 @@
 module GdsApi
-  VERSION = '0.0.20'
+  VERSION = '0.0.23'
 end

data/test/contactotron_api_test.rb

@@ -12,6 +12,6 @@ class ContactotronApiTest < MiniTest::Unit::TestCase
   def test_should_fetch_and_parse_JSON_into_ostruct
     uri = "http://contactotron.platform/contacts/1"
     contactotron_has_contact(uri, {details: 'value'})
-    assert_equal OpenStruct, api.contact_for_uri(uri).class
+    assert_equal "value", api.contact_for_uri(uri).details
   end
 end

data/test/{json_utils_test.rb → json_client_test.rb}

@@ -1,6 +1,8 @@
 require_relative 'test_helper'
-require 'gds_api/json_utils'
+require 'gds_api/base'
+require 'gds_api/json_client'
 require 'rack'
+require 'base64'
 
 StubRackApp = lambda do |env|
   sleep(30)
@@ -8,29 +10,31 @@ StubRackApp = lambda do |env|
   [200, {"Content-Type" => "text/plain", "Content-Length" => body.length.to_s}, [body]]
 end
 
-class JsonUtilsTest < MiniTest::Unit::TestCase
-  include GdsApi::JsonUtils
+class JsonClientTest < MiniTest::Spec
+  def setup
+    @client = GdsApi::JsonClient.new
+  end
 
   def options; {}; end
   def pending_test_long_requests_timeout
     url = "http://www.example.com/timeout.json"
     stub_request(:get, url).to_rack(StubRackApp)
     assert_raises GdsApi::TimedOut do
-      get_json(url)
+      @client.get_json(url)
     end
   end
 
   def test_get_returns_nil_on_timeout
     url = "http://some.endpoint/some.json"
     stub_request(:get, url).to_raise(Timeout::Error)
-    assert_nil get_json(url)
+    assert_nil @client.get_json(url)
   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
-      get_json(url)
+      @client.get_json(url)
     end
   end
 
@@ -38,32 +42,62 @@ class JsonUtilsTest < MiniTest::Unit::TestCase
     url = "http://some.endpoint/some.json"
     stub_request(:get, url).to_raise(Errno::ECONNREFUSED)
     assert_raises GdsApi::EndpointNotFound do
-      get_json(url)
+      @client.get_json(url)
     end
   end
 
   def test_post_returns_nil_on_timeout
     url = "http://some.endpoint/some.json"
     stub_request(:post, url).to_raise(Timeout::Error)
-    assert_nil post_json(url, {})
+    assert_nil @client.post_json(url, {})
   end
 
-  def test_should_fetch_and_parse_json_into_hash
+  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 Hash, get_json(url).class
+    assert_equal GdsApi::Response, @client.get_json(url).class
   end
 
   def test_should_return_nil_if_404_returned_from_endpoint
     url = "http://some.endpoint/some.json"
     stub_request(:get, url).to_return(:body => "{}", :status => 404)
-    assert_nil get_json(url)
+    assert_nil @client.get_json(url)
   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({}, put_json(url, payload))
+    assert_equal({}, @client.put_json(url, payload).to_hash)
+  end
+  
+  def test_can_convert_response_to_ostruct
+    url = "http://some.endpoint/some.json"
+    payload = {a:1}
+    stub_request(:put, url).with(body: payload.to_json).to_return(:body => '{"a":1}', :status => 200)
+    response = @client.put_json(url, payload)
+    assert_equal(OpenStruct.new(a:1), response.to_ostruct)
+  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_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
 end

data/test/panopticon_api_test.rb

@@ -37,14 +37,14 @@ class PanopticonApiTest < MiniTest::Unit::TestCase
   def test_given_a_slug_can_fetch_artefact_as_hash
     panopticon_has_metadata(basic_artefact)
     artefact = api.artefact_for_slug(basic_artefact[:slug], :as_hash => true)
-    assert artefact.is_a?(Hash)
+    assert_equal basic_artefact[:name], artefact['name']
   end
 
   def should_fetch_and_parse_JSON_into_hash
     url = "#{PANOPTICON_ENDPOINT}/some.json"
-    stub_request(:get, url).to_return(body: {}.to_json)
-
-    assert_equal Hash, api.get_json(url).class
+    stub_request(:get, url).to_return(body: {a:1}.to_json)
+  
+    assert_equal 1, api.get_json(url)['a']
   end
 
   def test_should_return_nil_if_404_returned_from_endpoint
@@ -83,4 +83,14 @@ class PanopticonApiTest < MiniTest::Unit::TestCase
 
     api.update_artefact(1, basic_artefact)
   end
+
+  def test_can_use_basic_auth
+    credentials = {user: 'fred', password: 'secret'}
+    api = GdsApi::Panopticon.new('test', endpoint_url: 'http://some.url', basic_auth: credentials)
+    url = "http://#{credentials[:user]}:#{credentials[:password]}@some.url/artefacts/1.json"
+    stub_request(:put, url)
+      .to_return(status: 200, body: '{}')
+
+    api.update_artefact(1, basic_artefact)
+  end
 end

data/test/publisher_api_test.rb

@@ -1,5 +1,6 @@
 require 'test_helper'
 require 'gds_api/publisher'
+require 'gds_api/json_client'
 require 'gds_api/test_helpers/publisher'
 
 class GdsApi::PublisherTest < MiniTest::Unit::TestCase
@@ -100,7 +101,7 @@ class GdsApi::PublisherTest < MiniTest::Unit::TestCase
 
   def test_should_be_able_to_retrieve_local_transaction_details
     stub_request(:post, "#{PUBLISHER_ENDPOINT}/local_transactions/fake-transaction/verify_snac.json").
-      with(:body => "{\"snac_codes\":[12345]}", :headers => GdsApi::JsonUtils::REQUEST_HEADERS).
+      with(:body => "{\"snac_codes\":[12345]}", :headers => GdsApi::JsonClient::REQUEST_HEADERS).
       to_return(:status => 200, :body => '{"snac": "12345"}', :headers => {})
     assert_equal '12345', api.council_for_slug('fake-transaction', [12345])
   end

data/test/test_helper.rb

@@ -1,8 +1,12 @@
+require 'bundler'
+Bundler.setup :default, :development, :test
+
 require 'minitest/autorun'
 require 'webmock/minitest'
 require 'rack/utils'
 require 'simplecov'
 require 'simplecov-rcov'
+require 'mocha'
 
 SimpleCov.start do
   add_filter "/test/"

metadata

@@ -1,111 +1,139 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: gds-api-adapters
-version: !ruby/object:Gem::Version
-  version: 0.0.20
+version: !ruby/object:Gem::Version 
   prerelease: 
+  version: 0.0.23
 platform: ruby
-authors:
+authors: 
 - James Stewart
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-05 00:00:00.000000000Z
-dependencies:
-- !ruby/object:Gem::Dependency
+
+date: 2012-01-10 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
   name: plek
-  requirement: &70348224358200 !ruby/object:Gem::Requirement
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
   type: :runtime
   prerelease: false
-  version_requirements: *70348224358200
-- !ruby/object:Gem::Dependency
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
   name: null_logger
-  requirement: &70348224356460 !ruby/object:Gem::Requirement
+  requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
   type: :runtime
   prerelease: false
-  version_requirements: *70348224356460
-- !ruby/object:Gem::Dependency
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
   name: rake
-  requirement: &70348224344180 !ruby/object:Gem::Requirement
+  requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
+    requirements: 
     - - ~>
-      - !ruby/object:Gem::Version
+      - !ruby/object:Gem::Version 
         version: 0.9.2.2
   type: :development
   prerelease: false
-  version_requirements: *70348224344180
-- !ruby/object:Gem::Dependency
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
   name: webmock
-  requirement: &70348224342980 !ruby/object:Gem::Requirement
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
+    requirements: 
     - - ~>
-      - !ruby/object:Gem::Version
-        version: '1.7'
+      - !ruby/object:Gem::Version 
+        version: "1.7"
   type: :development
   prerelease: false
-  version_requirements: *70348224342980
-- !ruby/object:Gem::Dependency
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.10.0
+  type: :development
+  prerelease: false
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: minitest
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 2.10.0
+  type: :development
+  prerelease: false
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
   name: rack
-  requirement: &70348224342540 !ruby/object:Gem::Requirement
+  requirement: &id007 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
   type: :development
   prerelease: false
-  version_requirements: *70348224342540
-- !ruby/object:Gem::Dependency
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
   name: simplecov
-  requirement: &70348224342000 !ruby/object:Gem::Requirement
+  requirement: &id008 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
+    requirements: 
     - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.4.2
+      - !ruby/object:Gem::Version 
+        version: 0.5.4
   type: :development
   prerelease: false
-  version_requirements: *70348224342000
-- !ruby/object:Gem::Dependency
+  version_requirements: *id008
+- !ruby/object:Gem::Dependency 
   name: simplecov-rcov
-  requirement: &70348224341560 !ruby/object:Gem::Requirement
+  requirement: &id009 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
   type: :development
   prerelease: false
-  version_requirements: *70348224341560
+  version_requirements: *id009
 description: A set of adapters providing easy access to the GDS gov.uk APIs
-email:
+email: 
 - jystewart@gmail.com
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
 - lib/gds_api/base.rb
 - lib/gds_api/contactotron.rb
 - lib/gds_api/core-ext/openstruct.rb
 - lib/gds_api/exceptions.rb
 - lib/gds_api/helpers.rb
 - lib/gds_api/imminence.rb
-- lib/gds_api/json_utils.rb
+- lib/gds_api/json_client.rb
 - lib/gds_api/needotron.rb
+- lib/gds_api/oauth2_client.rb
 - lib/gds_api/panopticon.rb
 - lib/gds_api/part_methods.rb
 - lib/gds_api/publisher.rb
+- lib/gds_api/response.rb
 - lib/gds_api/test_helpers/contactotron.rb
 - lib/gds_api/test_helpers/imminence.rb
 - lib/gds_api/test_helpers/panopticon.rb
@@ -115,38 +143,47 @@ files:
 - Rakefile
 - test/contactotron_api_test.rb
 - test/gds_api_base_test.rb
-- test/json_utils_test.rb
+- test/json_client_test.rb
 - test/panopticon_api_test.rb
 - test/publisher_api_test.rb
 - test/test_helper.rb
 homepage: http://github.com/alphagov/gds-api-adapters
 licenses: []
+
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: -3544667812721100865
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: -3544667812721100865
+      segments: 
+      - 0
+      version: "0"
 requirements: []
+
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.13
 signing_key: 
 specification_version: 3
 summary: Adapters to work with GDS APIs
-test_files:
+test_files: 
 - test/contactotron_api_test.rb
 - test/gds_api_base_test.rb
-- test/json_utils_test.rb
+- test/json_client_test.rb
 - test/panopticon_api_test.rb
 - test/publisher_api_test.rb
 - test/test_helper.rb

data/lib/gds_api/json_utils.rb

@@ -1,83 +0,0 @@
-require 'json'
-require 'net/http'
-require 'ostruct'
-require_relative 'core-ext/openstruct'
-require_relative 'version'
-require_relative 'exceptions'
-
-module GdsApi::JsonUtils
-  REQUEST_HEADERS = {
-    'Accept' => 'application/json',
-    'Content-Type' => 'application/json',
-    'User-Agent' => "GDS Api Client v. #{GdsApi::VERSION}"
-  }
-  DEFAULT_TIMEOUT_IN_SECONDS = 0.5
-
-  def do_request(url, &block)
-    loggable = {request_uri: url, start_time: Time.now.to_f}
-
-    url = URI.parse(url)
-    request = url.path
-    request = request + "?" + url.query if url.query
-    logger.debug "I will request #{request}"
-
-    response = Net::HTTP.start(url.host, url.port, nil, nil, nil, nil, {use_ssl: url.port == 443, verify_mode: (OpenSSL::SSL::VERIFY_NONE if url.port == 443) }) do |http|
-      http.read_timeout = options[:timeout] || DEFAULT_TIMEOUT_IN_SECONDS
-      yield http, request
-    end
-
-    if response.is_a?(Net::HTTPSuccess)
-      logger.info loggable.merge(status: 'success', end_time: Time.now).to_json
-      JSON.parse(response.body)
-    else
-      body = begin
-        JSON.parse(response.body)
-      rescue
-        response.body
-      end
-      loggable.merge!(status: response.code, end_time: Time.now.to_f, body: body)
-      logger.warn loggable.to_json
-      nil
-    end
-  rescue Errno::ECONNREFUSED
-    logger.error loggable.merge(status: 'refused', end_time: Time.now.to_f).to_json
-    raise GdsApi::EndpointNotFound.new("Could not connect to #{url}")
-  rescue Timeout::Error, Errno::ECONNRESET => e
-    logger.error loggable.merge(status: 'failed', end_time: Time.now.to_f).to_json
-    nil
-  end
-
-  def logger
-    GdsApi::Base.logger
-  end
-  private :logger
-
-  def get_json(url)
-    do_request(url) do |http, path|
-      http.get(path, REQUEST_HEADERS)
-    end
-  end
-
-  def post_json(url, params)
-    do_request(url) do |http, path|
-      http.post(path, params.to_json, REQUEST_HEADERS)
-    end
-  end
-
-  def put_json(url, params)
-    do_request(url) do |http, path|
-      http.put(path, params.to_json, REQUEST_HEADERS)
-    end
-  end
-
-  def to_ostruct(object)
-    case object
-    when Hash
-      OpenStruct.new Hash[object.map { |key, value| [key, to_ostruct(value)] }]
-    when Array
-      object.map { |k| to_ostruct(k) }
-    else
-      object
-    end
-  end
-end