gds-api-adapters 4.2.0 → 4.3.0

data/lib/gds_api/exceptions.rb

@@ -8,6 +8,9 @@ module GdsApi
   class TimedOutException < BaseError
   end
 
+  class TooManyRedirects < BaseError
+  end
+
   class HTTPErrorResponse < BaseError
     attr_accessor :code
 

data/lib/gds_api/json_client.rb

@@ -1,8 +1,8 @@
 require_relative 'response'
 require_relative 'exceptions'
 require_relative 'version'
-require 'net/http'
 require 'lrucache'
+require 'rest-client'
 
 module GdsApi
   class JsonClient
@@ -37,7 +37,9 @@ module GdsApi
     DEFAULT_CACHE_TTL = 15 * 60 # 15 minutes
 
     def get_raw(url)
-      do_raw_request(Net::HTTP::Get, url)
+      ignoring GdsApi::HTTPNotFound do
+        do_raw_request(:get, url)
+      end
     end
 
     # Define "safe" methods for each supported HTTP method
@@ -55,108 +57,135 @@ module GdsApi
     end
 
     def get_json!(url, &create_response)
-      @cache[url] ||= do_json_request(Net::HTTP::Get, url, nil, &create_response)
+      @cache[url] ||= do_json_request(:get, url, nil, &create_response)
     end
 
     def post_json!(url, params)
-      do_json_request(Net::HTTP::Post, url, params)
+      do_json_request(:post, url, params)
     end
 
     def put_json!(url, params)
-      do_json_request(Net::HTTP::Put, url, params)
+      do_json_request(:put, url, params)
     end
 
     def delete_json!(url, params = nil)
-      do_request(Net::HTTP::Delete, url, params)
+      do_request(:delete, url, params)
     end
 
     private
-    def do_raw_request(method_class, url, params = nil)
-      response, loggable = do_request(method_class, url, params)
+    def do_raw_request(method, url, params = nil)
+      response = do_request(method, url, params)
       response.body
+
+    rescue RestClient::ResourceNotFound => e
+      raise GdsApi::HTTPNotFound.new(e.http_code)
+
+    rescue RestClient::Exception => e
+      raise GdsApi::HTTPErrorResponse.new(response.code.to_i), e.response.body
     end
 
-    # method_class: the Net::HTTP class to use, e.g. Net::HTTP::Get
+    # method: the symbolic name of the method to use, e.g. :get, :post
     # url:    the request URL
     # params: the data to send (JSON-serialised) in the request body
     # create_response: optional block to instantiate a custom response object
     #                  from the Net::HTTPResponse
-    def do_json_request(method_class, url, params = nil, &create_response)
+    def do_json_request(method, url, params = nil, &create_response)
 
-      response, loggable = do_request(method_class, url, params)
+      begin
+        response = do_request(method, url, params)
 
-      # If no custom response is given, just instantiate Response
-      create_response ||= Proc.new { |r| Response.new(r) }
+      rescue RestClient::ResourceNotFound => e
+        raise GdsApi::HTTPNotFound.new(e.http_code)
 
-      if response.is_a?(Net::HTTPSuccess)
-        logger.info loggable.merge(status: 'success', end_time: Time.now.to_f).to_json
-        create_response.call(response)
-      elsif response.is_a?(Net::HTTPNotFound)
-        raise GdsApi::HTTPNotFound.new(response.code.to_i)
-      else
+      rescue RestClient::Exception => e
+        # Attempt to parse the body as JSON if possible
         body = begin
-          JSON.parse(response.body.to_s)
+          e.http_body ? JSON.parse(e.http_body) : nil
         rescue JSON::ParserError
-          response.body
+          e.http_body
         end
-        loggable.merge!(status: response.code, end_time: Time.now.to_f, body: body)
-        logger.warn loggable.to_json
-        raise GdsApi::HTTPErrorResponse.new(response.code.to_i), body
+        raise GdsApi::HTTPErrorResponse.new(e.http_code), body
       end
-    end
 
-    def extract_url_and_path(url)
-      url = URI.parse(url)
-      path = url.path
-      path = path + "?" + url.query if url.query
-      return url, path
+      # If no custom response is given, just instantiate Response
+      create_response ||= Proc.new { |r| Response.new(r) }
+      create_response.call(response.net_http_res)
     end
 
-    def attach_auth_options(request)
+    # Take a hash of parameters for Request#execute; return a hash of
+    # parameters with authentication information included
+    def with_auth_options(method_params)
       if @options[:bearer_token]
-        request.add_field('Authorization', "Bearer #{@options[:bearer_token]}")
+        headers = method_params[:headers] || {}
+        method_params.merge(headers: headers.merge(
+          {"Authorization" => "Bearer #{@options[:bearer_token]}"}
+        ))
       elsif @options[:basic_auth]
-        request.basic_auth(@options[:basic_auth][:user], @options[:basic_auth][:password])
+        method_params.merge(
+          user: @options[:basic_auth][:user],
+          password: @options[:basic_auth][:password]
+        )
+      else
+        method_params
       end
     end
 
-    def set_timeout(http)
-      unless options[:disable_timeout]
-        http.read_timeout = options[:timeout] || DEFAULT_TIMEOUT_IN_SECONDS
+    # Take a hash of parameters for Request#execute; return a hash of
+    # parameters with timeouts included
+    def with_timeout(method_params)
+      if options[:disable_timeout]
+        method_params.merge(timeout: -1)
+      else
+        method_params.merge(
+          timeout: options[:timeout] || DEFAULT_TIMEOUT_IN_SECONDS
+        )
       end
     end
 
-    def ssl_options(port)
-      if port == 443
-        {use_ssl: true, verify_mode: OpenSSL::SSL::VERIFY_NONE}
-      else
-        {}
-      end
+    def with_ssl_options(method_params)
+      method_params.merge(
+        # This is the default value anyway, but we should probably be explicit
+        verify_ssl: OpenSSL::SSL::VERIFY_NONE
+      )
     end
 
-    def do_request(method_class, url, params = nil)
+    def do_request(method, 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, path = extract_url_and_path(url)
-
-      response = Net::HTTP.start(url.host, url.port, nil, nil, nil, nil, ssl_options(url.port)) do |http|
-        set_timeout(http)
-        request = method_class.new(path, DEFAULT_REQUEST_HEADERS)
-        attach_auth_options(request)
-        request.body = params.to_json if params
-        http.request(request)
+      method_params = {
+        method: method,
+        url: url,
+        headers: DEFAULT_REQUEST_HEADERS
+      }
+      method_params[:payload] = params.to_json if params
+      method_params = with_auth_options(method_params)
+      method_params = with_timeout(method_params)
+      if URI.parse(url).is_a? URI::HTTPS
+        method_params = with_ssl_options(method_params)
       end
 
-      return response, loggable
+      return ::RestClient::Request.execute(method_params)
 
     rescue Errno::ECONNREFUSED => e
       logger.error loggable.merge(status: 'refused', error_message: e.message, error_class: e.class.name, end_time: Time.now.to_f).to_json
       raise GdsApi::EndpointNotFound.new("Could not connect to #{url}")
-    rescue Timeout::Error => e
+
+    rescue RestClient::RequestTimeout => e
       logger.error loggable.merge(status: 'timeout', error_message: e.message, error_class: e.class.name, end_time: Time.now.to_f).to_json
       raise GdsApi::TimedOutException.new
+
+    rescue RestClient::MaxRedirectsReached => e
+      raise GdsApi::TooManyRedirects
+
+    rescue RestClient::Exception => e
+      # Log the error here, since we have access to loggable, but raise the
+      # exception up to the calling method to deal with
+      loggable.merge!(status: e.http_code, end_time: Time.now.to_f, body: e.http_body)
+      logger.warn loggable.to_json
+      raise
+
     rescue Errno::ECONNRESET => e
       logger.error loggable.merge(status: 'connection_reset', error_message: e.message, error_class: e.class.name, end_time: Time.now.to_f).to_json
       raise GdsApi::TimedOutException.new

data/lib/gds_api/version.rb

@@ -1,3 +1,3 @@
 module GdsApi
-  VERSION = '4.2.0'
+  VERSION = '4.3.0'
 end

data/test/json_client_test.rb

@@ -51,6 +51,14 @@ class JsonClientTest < MiniTest::Spec
     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)
@@ -112,6 +120,7 @@ class JsonClientTest < MiniTest::Spec
     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
     GdsApi::JsonClient.cache = nil # cause it to contruct a new cache instance.
 
@@ -188,6 +197,103 @@ class JsonClientTest < MiniTest::Spec
     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 => 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_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::TooManyRedirects 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::TooManyRedirects do
+      @client.get_json(first_url)
+    end
+  end
+
   def test_post_should_be_nil_if_404_returned_from_endpoint
     url = "http://some.endpoint/some.json"
     stub_request(:post, url).to_return(:body => "{}", :status => 404)
@@ -202,6 +308,19 @@ class JsonClientTest < MiniTest::Spec
     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_nil_if_404_returned_from_endpoint
     url = "http://some.endpoint/some.json"
     stub_request(:put, url).to_return(:body => "{}", :status => 404)

metadata

@@ -2,7 +2,7 @@
 name: gds-api-adapters
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 4.2.0
+  version: 4.3.0
 platform: ruby
 authors: 
 - James Stewart
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-01-16 00:00:00 Z
+date: 2013-01-29 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: plek
@@ -57,8 +57,19 @@ dependencies:
   prerelease: false
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
-  name: rdoc
+  name: rest-client
   requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.6.3
+  type: :runtime
+  prerelease: false
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: rdoc
+  requirement: &id006 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - "="
@@ -66,10 +77,10 @@ dependencies:
         version: "3.12"
   type: :development
   prerelease: false
-  version_requirements: *id005
+  version_requirements: *id006
 - !ruby/object:Gem::Dependency 
   name: rake
-  requirement: &id006 !ruby/object:Gem::Requirement 
+  requirement: &id007 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -77,10 +88,10 @@ dependencies:
         version: 0.9.2.2
   type: :development
   prerelease: false
-  version_requirements: *id006
+  version_requirements: *id007
 - !ruby/object:Gem::Dependency 
   name: webmock
-  requirement: &id007 !ruby/object:Gem::Requirement 
+  requirement: &id008 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -88,10 +99,10 @@ dependencies:
         version: "1.8"
   type: :development
   prerelease: false
-  version_requirements: *id007
+  version_requirements: *id008
 - !ruby/object:Gem::Dependency 
   name: mocha
-  requirement: &id008 !ruby/object:Gem::Requirement 
+  requirement: &id009 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -99,10 +110,10 @@ dependencies:
         version: 0.12.4
   type: :development
   prerelease: false
-  version_requirements: *id008
+  version_requirements: *id009
 - !ruby/object:Gem::Dependency 
   name: minitest
-  requirement: &id009 !ruby/object:Gem::Requirement 
+  requirement: &id010 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -110,10 +121,10 @@ dependencies:
         version: 3.4.0
   type: :development
   prerelease: false
-  version_requirements: *id009
+  version_requirements: *id010
 - !ruby/object:Gem::Dependency 
   name: rack
-  requirement: &id010 !ruby/object:Gem::Requirement 
+  requirement: &id011 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -121,10 +132,10 @@ dependencies:
         version: "0"
   type: :development
   prerelease: false
-  version_requirements: *id010
+  version_requirements: *id011
 - !ruby/object:Gem::Dependency 
   name: simplecov
-  requirement: &id011 !ruby/object:Gem::Requirement 
+  requirement: &id012 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -132,10 +143,10 @@ dependencies:
         version: 0.5.4
   type: :development
   prerelease: false
-  version_requirements: *id011
+  version_requirements: *id012
 - !ruby/object:Gem::Dependency 
   name: simplecov-rcov
-  requirement: &id012 !ruby/object:Gem::Requirement 
+  requirement: &id013 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -143,10 +154,10 @@ dependencies:
         version: "0"
   type: :development
   prerelease: false
-  version_requirements: *id012
+  version_requirements: *id013
 - !ruby/object:Gem::Dependency 
   name: gem_publisher
-  requirement: &id013 !ruby/object:Gem::Requirement 
+  requirement: &id014 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -154,10 +165,10 @@ dependencies:
         version: 1.1.1
   type: :development
   prerelease: false
-  version_requirements: *id013
+  version_requirements: *id014
 - !ruby/object:Gem::Dependency 
   name: timecop
-  requirement: &id014 !ruby/object:Gem::Requirement 
+  requirement: &id015 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -165,7 +176,7 @@ dependencies:
         version: 0.5.1
   type: :development
   prerelease: false
-  version_requirements: *id014
+  version_requirements: *id015
 description: A set of adapters providing easy access to the GDS GOV.UK APIs
 email: 
 - jystewart@gmail.com
@@ -225,7 +236,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -1781835164135696191
+      hash: 4441910162548111668
       segments: 
       - 0
       version: "0"
@@ -234,7 +245,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -1781835164135696191
+      hash: 4441910162548111668
       segments: 
       - 0
       version: "0"