rest 1.2.2 → 2.0.0

data/Gemfile.lock

@@ -1,14 +1,17 @@
 PATH
   remote: .
   specs:
-    rest (1.2.1)
+    rest (1.2.2)
+      net-http-persistent
       rest-client (>= 0.3.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    excon (0.14.3)
     ffi (1.0.11)
     mime-types (1.19)
+    minitest (3.2.0)
     net-http-persistent (2.7)
     quicky (0.0.1)
     rake (0.9.2.2)
@@ -24,7 +27,8 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
-  net-http-persistent
+  excon
+  minitest
   quicky
   rake
   rest!

data/README.md

@@ -1,8 +1,22 @@
 Rest Wrapper
 -------------
 
-HTTP/REST client wrapper that provides a standard interface for making http requests using different http clients.
-If no client is specified it will choose the best one you have installed.
+HTTP/REST client wrapper that provides a standard interface for making http requests using different http
+clients. If no client is specified **it will choose the best http client** you have installed based on
+our performance tests.
+
+Features
+========
+
+* All clients behave exactly the same:
+  * Same error behavior
+  * Same 30X redirect behavior
+  * Same response object methods
+  * Same way to access and manipulate requests and responses such as body, headers, code, etc.
+* Chooses best client you have installed on your system based on what we have found performs the best.
+  * Currently net_http_persistent and typhoeus are nearly the same, but since net_http_persistent doesn't have a binary
+    dependency, it wins.
+
 
 Getting Started
 ==============
@@ -70,3 +84,14 @@ The response object you get back will always be consistent and will have the fol
     response.code
     response.body
 
+
+Exceptions
+======
+
+If it didn't get a response for whatever reason, you will get a Rest::ClientError
+
+If status code is 40X or 50X, it will raise an exception with the following methods.
+
+    err.code
+    err.response (which has body: err.response.body)
+

data/Rakefile

@@ -6,6 +6,7 @@ Rake::TestTask.new(:test) do |test|
   test.libs << 'lib' << 'test'
   test.pattern = 'test/**/test_*.rb'
   test.verbose = true
+  p ENV['gem']
 end
 
 task :default => :test

data/lib/rest/client.rb

@@ -5,26 +5,12 @@ require 'logger'
 # The purpose of this is so that users who can't install binaries easily (like windoze users)
 # can have fallbacks that work.
 
-module Rest
-
-  class ClientError < StandardError
-
-  end
+require_relative 'errors'
 
-
-  class TimeoutError < ClientError
-    def initialize(msg=nil)
-      msg ||= "HTTP Request Timed out."
-      super(msg)
-    end
-  end
+module Rest
 
   require_relative 'wrappers/base_wrapper'
 
-  #def self.puts(s)
-  #  Kernel.puts("rest gem: #{s}")
-  #end
-
   class Client
 
     attr_accessor :options, :logger, :gem
@@ -42,7 +28,11 @@ module Rest
         choose_best_gem()
       end
 
-      if @gem == :typhoeus
+      if @gem == :excon
+        require_relative 'wrappers/excon_wrapper'
+        @wrapper = Rest::Wrappers::ExconWrapper.new(self)
+        @logger.debug "Using excon gem."
+      elsif @gem == :typhoeus
         require_relative 'wrappers/typhoeus_wrapper'
         @wrapper = Rest::Wrappers::TyphoeusWrapper.new
         @logger.debug "Using typhoeus gem."
@@ -60,13 +50,13 @@ module Rest
     def choose_best_gem
       begin
         raise LoadError
-        #require 'typhoeus'
-        #@gem = :client
+        require 'typhoeus'
+        @gem = :typhoeus
       rescue LoadError => ex
         begin
           # try net-http-persistent
-          #require 'net/http/persistent'
-          #@gem = :net_http_persistent
+          require 'net/http/persistent'
+          @gem = :net_http_persistent
         rescue LoadError => ex
         end
       end
@@ -78,7 +68,7 @@ module Rest
 
     def get(url, req_hash={})
       res = nil
-      perform_op do
+      res = perform_op(:get, req_hash) do
         res = @wrapper.get(url, req_hash)
       end
       return res
@@ -86,38 +76,71 @@ module Rest
 
     # This will attempt to perform the operation with an exponential backoff on 503 errors.
     # Amazon services throw 503
-    def perform_op(&blk)
-      max_retries = @options[:max_retries] || 5
+    # todo: just make perform_op a method and have it call the wrapper. The block is a waste now.
+    def perform_op(method, req_hash, options={}, &blk)
+      set_defaults(options)
+      max_retries = options[:max_retries] || 5
+      max_follows = options[:max_follows] || 10
+      if options[:follow_count] && options[:follow_count] >= max_follows
+        raise Rest::RestError "Too many follows. #{options[:follow_count]}"
+      end
       current_retry = 0
+      current_follow = 0
       success = false
       res = nil
-      while current_retry < max_retries do
-        res = yield blk
-        #p res
-        #p res.code
-        if res.code == 503
-          pow = (4 ** (current_retry)) * 100 # milliseconds
-                                             #puts 'pow=' + pow.to_s
-          s = Random.rand * pow
-                                             #puts 's=' + s.to_s
-          sleep_secs = 1.0 * s / 1000.0
-          puts 'sleep for ' + sleep_secs.to_s
-          current_retry += 1
-          @logger.debug "503 Received. Retrying #{current_retry} out of #{max_retries} max in #{sleep_secs} seconds."
-          sleep sleep_secs
-        else
+      while current_retry < max_retries && current_follow < max_follows do
+        begin
+          res = yield blk
+          res.tries = current_retry + 1
+          if res.code >= 300 && res.code < 400
+            # try new location
+            #p res.headers
+            loc = res.headers["location"]
+            @logger.debug "#{res.code} Received. Trying new location: #{loc}"
+            if loc.nil?
+              raise InvalidResponseError.new("No location header received with #{res.code} status code!")
+            end
+            # options.merge({:max_follows=>options[:max_follows-1]}
+            options[:follow_count] ||= 0
+            options[:follow_count] += 1
+            res = perform_op(method, req_hash, options) do
+              res = @wrapper.send(method, loc, req_hash)
+            end
+            #puts 'X: ' + res.inspect
+            return res
+          end
+          # If it's here, then it's all good
           break
+        rescue Rest::HttpError => ex
+          if ex.code == 503
+            pow = (4 ** (current_retry)) * 100 # milliseconds
+                                               #puts 'pow=' + pow.to_s
+            s = Random.rand * pow
+                                               #puts 's=' + s.to_s
+            sleep_secs = 1.0 * s / 1000.0
+                                               #puts 'sleep for ' + sleep_secs.to_s
+            current_retry += 1
+            @logger.debug "#{ex.code} Received. Retrying #{current_retry} out of #{max_retries} max in #{sleep_secs} seconds."
+            sleep sleep_secs
+          else
+            raise ex
+          end
         end
       end
       res
     end
 
+    def set_defaults(options)
+      options[:max_retries] ||= (@options[:max_retries] || 5)
+      options[:max_follows] ||= (@options[:max_follows] || 10)
+    end
+
     # req_hash options:
     # - :body => post body
     #
     def post(url, req_hash={})
       res = nil
-      perform_op do
+      res = perform_op(:post, req_hash) do
         res = @wrapper.post(url, req_hash)
       end
       return res
@@ -125,7 +148,7 @@ module Rest
 
     def put(url, req_hash={})
       res = nil
-      perform_op do
+      res = perform_op(:put, req_hash) do
         res = @wrapper.put(url, req_hash)
       end
       return res
@@ -133,7 +156,7 @@ module Rest
 
     def delete(url, req_hash={})
       res = nil
-      perform_op do
+      res = perform_op(:delete, req_hash) do
         res = @wrapper.delete(url, req_hash)
       end
       return res
@@ -141,7 +164,7 @@ module Rest
 
     def post_file(url, req_hash={})
       res = nil
-      perform_op do
+      res = perform_op(:post_file, req_hash) do
         res = @wrapper.post_file(url, req_hash)
       end
       return res

data/lib/rest/errors.rb

@@ -0,0 +1,43 @@
+
+module Rest
+
+  # Base Rest error class
+  class RestError < StandardError
+
+  end
+
+  class HttpError < RestError
+    def initialize(response)
+      super("#{response.code} Error")
+      @response = response
+    end
+
+    def response
+      @response
+    end
+    def code
+      response.code
+    end
+
+    def to_s
+      "HTTP #{code} Error. #{response.body}"
+    end
+  end
+
+  # If it didn't even get a response, it will be a ClientError
+  class ClientError < RestError
+
+  end
+
+  class TimeoutError < ClientError
+    def initialize(msg=nil)
+      msg ||= "HTTP Request Timed out."
+      super(msg)
+    end
+  end
+
+  class InvalidResponseError < RestError
+
+  end
+end
+

data/lib/rest/version.rb

@@ -1,3 +1,3 @@
 module Rest
-  VERSION = "1.2.2"
+  VERSION = "2.0.0"
 end

data/lib/rest/wrappers/base_wrapper.rb

@@ -1,29 +1,53 @@
-class BaseWrapper
-
-  def post_file(url, req_hash={})
-    response = nil
-    begin
-      if req_hash[:body]
-        req_hash = req_hash.merge(req_hash[:body])
-        req_hash.delete(:body)
-      end
+module Rest
+  class BaseWrapper
+
+    def post_file(url, req_hash={})
+      response = nil
+      begin
+        if req_hash[:body]
+          req_hash = req_hash.merge(req_hash[:body])
+          req_hash.delete(:body)
+        end
+
+        headers = {}
+        if req_hash[:headers]
+          headers = req_hash[:headers]
+          req_hash.delete(:headers)
+        end
 
-      headers = {}
-      if req_hash[:headers]
-        headers = req_hash[:headers]
-        req_hash.delete(:headers)
+        r2 = RestClient.post(url, req_hash, headers)
+        response = Rest::Wrappers::RestClientResponseWrapper.new(r2)
+      rescue RestClient::Exception => ex
+        raise Rest::Wrappers::RestClientExceptionWrapper.new(ex)
       end
+      response
+    end
+
+    # if body is a hash, it will convert it to json
+    def to_json_parts(h)
+      h[:body] = h[:body].to_json if h[:body] && h[:body].is_a?(Hash)
+    end
+
+    # if wrapper has a close/shutdown, override this
+    def close
 
-      r2 = RestClient.post(url, req_hash, headers)
-      response = Rest::Wrappers::RestClientResponseWrapper.new(r2)
-    rescue RestClient::Exception => ex
-      raise Rest::Wrappers::RestClientExceptionWrapper.new(ex)
     end
-    response
   end
 
-  # if wrapper has a close/shutdown, override this
-  def close
+  class BaseResponseWrapper
+    attr_accessor :tries
+
+    # Provide a headers_orig method in your wrapper to allow this to work
+    def headers
+      new_h = {}
+      headers_orig.each_pair do |k,v|
+        if v.is_a?(Array) && v.size == 1
+          v = v[0]
+        end
+        new_h[k.downcase] = v
+      end
+      new_h
+    end
 
   end
 end

data/lib/rest/wrappers/excon_wrapper.rb

@@ -0,0 +1,111 @@
+require 'excon'
+
+module Rest
+
+  module Wrappers
+    class ExconExceptionWrapper < ClientError
+      def initialize(ex)
+        super(ex.message)
+        @ex = ex
+      end
+    end
+
+    class ExconResponseWrapper < BaseResponseWrapper
+      def initialize(response)
+        @response = response
+      end
+
+      def code
+        @response.status
+      end
+
+      def body
+        @response.body
+      end
+
+      def headers_orig
+        @response.headers
+      end
+
+    end
+
+    class ExconWrapper < BaseWrapper
+
+      def initialize(client)
+        @client = client
+        # Would need to pass in base url to use persistent connection.
+        #@http = Excon.new("")
+      end
+
+      def default_headers
+        {}
+      end
+
+      def get(url, req_hash={})
+        response = nil
+        begin
+          uri = URI(url)
+          req_hash[:method] = :get
+          req_hash[:url] = url
+          req_hash[:headers] ||= default_headers
+          req_hash[:query] = req_hash[:params] if req_hash[:params]
+          #p req_hash
+          response = excon_request(url, req_hash)
+        rescue RestClient::Exception => ex
+          #p ex
+          raise ExconExceptionWrapper.new(ex)
+        end
+        response
+      end
+
+      def excon_request(url, req_hash)
+        conn = Excon.new(url)
+        r2 = conn.request(req_hash)
+        response = ExconResponseWrapper.new(r2)
+        if response.code >= 400
+          raise HttpError.new(response)
+        end
+        response
+      end
+
+      def post(url, req_hash={})
+        response = nil
+        begin
+          req_hash[:method] = :post
+          req_hash[:url] = url
+          to_json_parts(req_hash)
+          response = excon_request(url, req_hash)
+        rescue RestClient::Exception => ex
+          raise HttpError.new(ex)
+        end
+        response
+      end
+
+      def put(url, req_hash={})
+        response = nil
+        begin
+          req_hash[:method] = :put
+          req_hash[:url] = url
+          response = excon_request(url, req_hash)
+        rescue RestClient::Exception => ex
+          raise RestClientExceptionWrapper.new(ex)
+        end
+        response
+      end
+
+      def delete(url, req_hash={})
+        response = nil
+        begin
+          req_hash[:method] = :delete
+          req_hash[:url] = url
+          response = excon_request(url, req_hash)
+        rescue RestClient::Exception => ex
+          raise RestClientExceptionWrapper.new(ex)
+        end
+        response
+      end
+    end
+
+  end
+
+end

data/lib/rest/wrappers/net_http_persistent_wrapper.rb

@@ -10,7 +10,7 @@ module Rest
       end
     end
 
-    class NetHttpPersistentResponseWrapper
+    class NetHttpPersistentResponseWrapper < BaseResponseWrapper
       def initialize(response)
         @response = response
       end
@@ -23,6 +23,10 @@ module Rest
         @response.body
       end
 
+      def headers_orig
+        @response.to_hash
+      end
+
     end
 
     class NetHttpPersistentWrapper < BaseWrapper
@@ -36,7 +40,7 @@ module Rest
 
       def default_headers
         {
-            "Accept-Encoding" => "gzip, deflate",
+            #"Accept-Encoding" => "gzip, deflate",
             #"Accept" => "*/*; q=0.5, application/xml"
         }
       end
@@ -53,37 +57,49 @@ module Rest
       def get(url, req_hash={}, options={})
         @client.logger.debug "limit #{options[:limit]}"
         options[:limit] ||= 10
-        response = nil
+        r = nil
         begin
 
           uri = URI(url)
           #p uri
           #p uri.path
+          #p uri.request_uri
+          #puts "query: " + uri.query.inspect
+          #puts "fragment: " + uri.fragment.inspect
+          if req_hash[:params]
+            new_q = URI.encode_www_form(req_hash[:params])
+            if uri.query
+              new_q = uri.query + "&" + new_q
+            end
+            #puts "new_q: " + new_q
+            uri.query = new_q
+          end
+          #p uri.request_uri
           post = Net::HTTP::Get.new fix_path(uri.request_uri)
           add_headers(post, req_hash, default_headers)
           response = http.request uri, post
           @client.logger.debug response.class.name
+          r = NetHttpPersistentResponseWrapper.new(response)
           case response
-            when Net::HTTPRedirection
-              @client.logger.debug "moved to #{response['location']}"
-              response = get(response['location'], req_hash, {limit: options[:limit]-1})
-            when Net::HTTPMovedPermanently
-              @client.logger.debug "moved to #{response['location']}"
-              response = get(response['location'], req_hash, {limit: options[:limit]-1})
-          end
-          response = NetHttpPersistentResponseWrapper.new(response)
-        rescue Net::HTTPClientError => ex
-          if ex.code == 404
-            return NetHttpPersistentResponseWrapper.new(ex)
-          end
-          raise NetHttpPersistentExceptionWrapper.new(ex)
-        rescue Net::HTTPServerError => ex
-          if ex.code == 404
-            return NetHttpPersistentResponseWrapper.new(ex)
+            when Net::HTTPClientError, Net::HTTPServerError
+              raise Rest::HttpError.new(r)
           end
-          raise NetHttpPersistentExceptionWrapper.new(ex)
+          #  when Net::HTTPRedirection
+          #    @client.logger.debug "moved to #{response['location']}"
+          #    response = get(response['location'], req_hash, {limit: options[:limit]-1})
+          #  when Net::HTTPMovedPermanently
+          #    @client.logger.debug "moved to #{response['location']}"
+          #    response = get(response['location'], req_hash, {limit: options[:limit]-1})
+          #end
+        #rescue Net::HTTPClientError, Net::HTTPServerError => ex
+        #  raise NetHttpPersistentExceptionWrapper.new(ex)
+        #rescue Net::HTTPServerError => ex
+        #  if ex.code == 404
+        #    return NetHttpPersistentResponseWrapper.new(ex)
+        #  end
+        #  raise NetHttpPersistentExceptionWrapper.new(ex)
         end
-        response
+        r
       end
 
       def fix_path(path)

data/lib/rest/wrappers/rest_client_wrapper.rb

@@ -3,14 +3,16 @@ require 'rest_client'
 module Rest
 
   module Wrappers
-    class RestClientExceptionWrapper < ClientError
+    class RestClientExceptionWrapper < HttpError
+      attr_reader :ex
+
       def initialize(ex)
-        super(ex.message)
+        super(ex.response)
         @ex = ex
       end
     end
 
-    class RestClientResponseWrapper
+    class RestClientResponseWrapper < BaseResponseWrapper
       def initialize(response)
         @response = response
       end
@@ -23,6 +25,10 @@ module Rest
         @response.body
       end
 
+      def headers_orig
+        @response.headers
+      end
+
     end
 
     class RestClientWrapper < BaseWrapper
@@ -43,9 +49,9 @@ module Rest
           response = RestClientResponseWrapper.new(r2)
         rescue RestClient::Exception => ex
           #p ex
-          if ex.http_code == 404
-            return RestClientResponseWrapper.new(ex.response)
-          end
+          #if ex.http_code == 404
+          #  return RestClientResponseWrapper.new(ex.response)
+          #end
           raise RestClientExceptionWrapper.new(ex)
         end
         response

data/lib/rest/wrappers/typhoeus_wrapper.rb

@@ -11,6 +11,26 @@ module Rest
       end
     end
 
+    class TyphoeusResponseWrapper < BaseResponseWrapper
+
+      def initialize(response)
+        @response = response
+      end
+
+      def code
+        @response.code
+      end
+
+      def body
+        @response.body
+      end
+
+      def headers_orig
+        @response.headers_hash
+      end
+
+    end
+
     class TyphoeusWrapper < BaseWrapper
 
       def default_typhoeus_options
@@ -28,29 +48,28 @@ module Rest
         # puts "REQ_HASH=" + req_hash.inspect
         response = Typhoeus::Request.get(url, req_hash)
         #p response
+        response = handle_response(response)
+        response
+      end
+
+      def handle_response(response)
         if response.timed_out?
           raise TyphoeusTimeoutError.new(response)
         end
-
-        response
+        r = TyphoeusResponseWrapper.new(response)
+        if response.code >= 400
+          raise Rest::HttpError.new(r)
+        end
+        r
       end
 
-      # if body is a hash, it will convert it to json
-      def to_json_parts(h)
-        h[:body] = h[:body].to_json if h[:body] && h[:body].is_a?(Hash)
-      end
+
 
       def post(url, req_hash={})
         req_hash = default_typhoeus_options.merge(req_hash)
-        # puts "REQ_HASH=" + req_hash.inspect
-
-        # Convert body to json - NEED TO TEST THIS MORE
         to_json_parts(req_hash)
         response = Typhoeus::Request.post(url, req_hash)
-        #p response
-        if response.timed_out?
-          raise TyphoeusTimeoutError.new(response)
-        end
+        response = handle_response(response)
         response
       end
 
@@ -58,19 +77,14 @@ module Rest
         req_hash = default_typhoeus_options.merge(req_hash)
         # puts "REQ_HASH=" + req_hash.inspect
         response = Typhoeus::Request.put(url, req_hash)
-        #p response
-        if response.timed_out?
-          raise TyphoeusTimeoutError.new(response)
-        end
+        response = handle_response(response)
         response
       end
 
       def delete(url, req_hash={})
         req_hash = default_typhoeus_options.merge(req_hash)
         response = Typhoeus::Request.delete(url, req_hash)
-        if response.timed_out?
-          raise TyphoeusTimeoutError.new(response)
-        end
+        response = handle_response(response)
         response
       end
 

data/rest.gemspec

@@ -17,13 +17,15 @@ Gem::Specification.new do |gem|
   gem.required_rubygems_version = ">= 1.3.6"
   gem.required_ruby_version = Gem::Requirement.new(">= 1.9")
   gem.add_runtime_dependency "rest-client", ">= 0.3.0"
+  gem.add_runtime_dependency "net-http-persistent"
 
   gem.add_development_dependency "test-unit"
+  gem.add_development_dependency "minitest"
   gem.add_development_dependency "rake"
   gem.add_development_dependency "uber_config"
   gem.add_development_dependency "typhoeus"
   gem.add_development_dependency "quicky"
-  gem.add_development_dependency "net-http-persistent"
+  gem.add_development_dependency "excon"
 
 end
 

data/test/test_base.rb

@@ -8,13 +8,18 @@ rescue Exception => ex
   raise ex
 end
 
-
 class TestBase < Test::Unit::TestCase
- def setup
+
+  def setup
     puts 'setup'
-    #@config = YAML::load_file(File.expand_path(File.join("~", "Dropbox", "configs", "rest", "test", "config.yml")))
-    @rest = Rest::Client.new(:gem=>:rest_client)
+    @rest = Rest::Client.new(:gem => :net_http_persistent)
     @rest.logger.level = Logger::DEBUG
+    @request_bin = "http://requestb.in/13t6hs51"
 
   end
+
+  def bin
+    @request_bin
+  end
+
 end

data/test/test_performance.rb

@@ -5,19 +5,20 @@ require 'quicky'
 
 require_relative 'test_base'
 
-class TestTests < TestBase
+class TestPerformance < TestBase
   def setup
     super
 
   end
 
   def test_get_performance
+    puts 'test_get_performance'
 
-    times = 10
+    times = 100
 
     quicky = Quicky::Timer.new
 
-    to_run = [:typhoeus, :rest_client, :net_http_persistent]
+    to_run = [:typhoeus, :rest_client, :net_http_persistent, :excon]
     to_run.each do |gem|
       run_perf(quicky, times, gem)
     end
@@ -32,7 +33,7 @@ class TestTests < TestBase
     puts "Starting #{gem} test..."
     client = Rest::Client.new(:gem => gem)
     quicky.loop(gem, times) do
-      client.get("http://requestb.in/ydyd4nyd")
+      client.get("http://rest-test.iron.io/code/200")
     end
   end
 

data/test/test_rest.rb

@@ -5,7 +5,7 @@ require 'test/unit'
 require 'yaml'
 require_relative 'test_base'
 
-class TestTests < TestBase
+class TestRest < TestBase
   def setup
     super
 
@@ -17,7 +17,7 @@ class TestTests < TestBase
     p response
     p response.code
     assert response.code == 200
-    #p response.body
+    p response.body
     assert response.body.include?("Social Coding")
   end
 
@@ -25,6 +25,9 @@ class TestTests < TestBase
     response = @rest.get("http://rest-test.iron.io/code/503?switch_after=3&switch_to=200")
     p response
     p response.code
+    p response.tries == 3
+    assert response.code == 200
+
   end
 
   def test_gets
@@ -35,8 +38,64 @@ class TestTests < TestBase
         'User-Agent' => "someagent"
     }
     body = {"foo" => "bar"}
-    response = @rest.get("http://requestb.in/16q6zwq1?param1=x")
+    response = @rest.get("#{bin}?param1=x")
+
+    # params as hash
+    response = @rest.get("#{bin}?x=y#frag", :params => {:param2 => "abc"})
+    response = @rest.get("#{bin}", :params => {param3: "xyz"})
+    response = @rest.get("#{bin}")
+
+    response = @rest.get("http://rest-test.iron.io/code/200")
+    assert response.code == 200
+    assert response.body.include?("200")
+    p response.headers
+    assert response.headers.is_a?(Hash)
+
+  end
 
+  def test_404
+    begin
+      response = @rest.get("http://rest-test.iron.io/code/404")
+      assert false, "shouldn't get here"
+    rescue Rest::HttpError => ex
+      puts "EX: " + ex.inspect
+      p ex.backtrace
+      assert ex.is_a?(Rest::HttpError)
+      assert ex.response
+      assert ex.response.body
+      assert ex.code == 404
+      assert ex.response.body.include?("404")
+      assert ex.to_s.include?("404")
+    end
+  end
+
+  def test_400
+    begin
+      response = @rest.get("http://rest-test.iron.io/code/400")
+      assert false, "shouldn't get here"
+    rescue Rest::HttpError => ex
+      puts "EX: #{ex}"
+      p ex.backtrace
+      assert ex.is_a?(Rest::HttpError)
+      assert ex.response
+      assert ex.response.body
+      assert ex.code == 400
+    end
+  end
+
+  def test_500
+    puts '500'
+    begin
+      response = @rest.get("http://rest-test.iron.io/code/500")
+      assert false, "shouldn't get here"
+    rescue Rest::HttpError => ex
+      puts "EX: " + ex.inspect
+      p ex.backtrace
+      assert ex.is_a?(Rest::HttpError)
+      assert ex.response
+      assert ex.response.body
+      assert ex.code == 500
+    end
   end
 
   def test_post_with_headers
@@ -48,12 +107,16 @@ class TestTests < TestBase
         'User-Agent' => "someagent"
     }
     body = {"foo" => "bar"}
-    response = @rest.post("http://requestb.in/ydyd4nyd",
+    response = @rest.post("#{bin}",
+                          :body => body,
+                          :headers => headers)
+    p response
+    response = @rest.post("http://rest-test.iron.io/code/200",
                           :body => body,
                           :headers => headers)
     p response
 
-    response = @rest.post("http://requestb.in/ydyd4nyd",
+    response = @rest.post("#{bin}",
                           :body => "some string body",
                           :headers => headers)
     p response

data/test/tmp.rb

@@ -1,14 +1,27 @@
+gem 'test-unit'
+require 'test/unit'
 require 'yaml'
-begin
-  require File.join(File.dirname(__FILE__), '../lib/rest')
-rescue Exception => ex
-  puts "Could NOT load gem: " + ex.message
-  raise ex
-end
+require_relative 'test_base'
+
+class TestTemp < TestBase
+  def setup
+    super
 
-@rest = Rest::Client.new # (:gem=>:rest_client)
-@rest.logger.level = Logger::DEBUG
+  end
+
+  def test_500
+    puts '500'
+    begin
+      puts 'in block'
+      response = @rest.get("http://rest-test.iron.io/code/500")
+      assert false, "shouldn't get here"
+    rescue => ex
+      p ex
+      assert ex.is_a?(Rest::HttpError)
+      assert ex.response
+      assert ex.response.body
+      assert ex.code == 500
+    end
+  end
+end
 
-response = @rest.get("http://smooth-sword-1395.herokuapp.com/code/503?switch_after=3&switch_to=200")
-p response
-p response.code

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rest
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 2.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-09 00:00:00.000000000 Z
+date: 2012-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
@@ -27,6 +27,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: net-http-persistent
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: test-unit
   requirement: !ruby/object:Gem::Requirement
@@ -43,6 +59,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -108,7 +140,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: net-http-persistent
+  name: excon
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -138,8 +170,10 @@ files:
 - Rakefile
 - lib/rest.rb
 - lib/rest/client.rb
+- lib/rest/errors.rb
 - lib/rest/version.rb
 - lib/rest/wrappers/base_wrapper.rb
+- lib/rest/wrappers/excon_wrapper.rb
 - lib/rest/wrappers/net_http_persistent_wrapper.rb
 - lib/rest/wrappers/rest_client_wrapper.rb
 - lib/rest/wrappers/typhoeus_wrapper.rb