hugs 2.5.2 → 2.6.0

data/.gitignore

@@ -1,2 +1,4 @@
-pkg/
-.bundle/
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/README.md

@@ -1,6 +1,6 @@
 # Hugs
 
-Hugs net-http-persistent with convenient get, delete, post, and put methods.
+Hugs net-http-persistent with convenient delete, get, head, post, and put methods.
 
 Opted to write this gem for four reasons:
 
@@ -15,13 +15,12 @@ Opted to write this gem for four reasons:
   There looks to be [work on this front](https://github.com/geemus/excon/issues#issue/29).
 * Wanted to learn how to handle this pattern.
 
-The XML usage of this gem will probably change.  In the next couple of weeks Hugs
-will be implemented against an XML OCCI API.
-
-## Assumptions
+## Opinionated
 
 * The webservice returns JSON or XML.
-* To objectify the returned JSON or hand back a Nokogiri::XML::Document.
+* It is okay to parse the response.
+  * A Hash is returned when response is JSON.
+  * A Nokogiri::XML::Document is returned when XML.
 
 ## Usage
 
@@ -33,8 +32,18 @@ will be implemented against an XML OCCI API.
 
 See the 'Examples' section in the [wiki](http://github.com/retr0h/hugs/wiki/).
 
+## Compatability
+
+ruby 1.9.2
+
 ## Testing
 
 Tests can run offline thanks to [webmock](https://github.com/bblimke/webmock).
 
     $ bundle exec rake
+
+## TODOs
+
+* avoid the parse (eg client.raw)
+* override type per request
+* support hased query params

data/lib/hugs/client.rb

@@ -1,60 +1,68 @@
 require "hugs/errors"
 
 require "net/http/persistent"
-require "net/http/post/multipart"
+require "uri"
 require "nokogiri"
 require "yajl"
 
 module Hugs
   class Client
-    attr_accessor :headers
-    attr_accessor :raise_4xx, :raise_5xx, :debug, :http
-    attr_writer   :raise_4xx, :raise_5xx, :debug, :http
-
-    Headers = {
-      :json => "application/json",
-      :xml  => "application/xml",
+    MIME_TYPES = {
+      :binary => "application/octet-stream",
+      :json   => "application/json",
+      :xml    => "application/xml",
     }.freeze
 
-    Classes = [
-      Net::HTTP::Get,
+    CLASSES = [
       Net::HTTP::Delete,
+      Net::HTTP::Get,
+      Net::HTTP::Head,
       Net::HTTP::Post,
-      Net::HTTP::Put,
-      Net::HTTP::Head
+      Net::HTTP::Put
     ].freeze
 
     ##
     # Required options:
     #   +host+: A String with the host to connect.
     # Optional:
-    #   +user+: A String containing the username for use in HTTP Basic auth.
-    #   +password+: A String containing the password for use in HTTP Basic auth.
-    #   +port+: An Integer containing the port to connect.
-    #   +scheme+: A String containing the HTTP scheme.
+    #   +user+:    A String containing the username for use in HTTP Basic Authentication.
+    #   +pass+:    A String containing the password for use in HTTP Basic Authentication.
+    #   +port+:    An Integer containing the port to connect.
+    #   +scheme+:  A String containing the HTTP scheme.
+    #   +type+:    A Symbol containing (:json or :xml) for automatic content-type parsing
+    #              and encoding.
+    #   +headers+: A Hash containing HTTP headers.
+    #   +raises+:  A boolean if HTTP 4xx and 5xx status codes should be raised.
 
     def initialize options
-      @user     = options[:user]
-      @password = options[:password]
-      @host     = options[:host]
-      @port     = options[:port]    || 80
-      @scheme   = options[:scheme]  || "http"
-      @type     = options[:type]    || :json
-      @headers  = options[:headers] || {}
-
-      @http     = Net::HTTP::Persistent.new
-      @url      = URI.parse "#{@scheme}://#{@host}:#{@port}"
+      @user    = options[:user]
+      @pass    = options[:password]
+      host     = options[:host]
+      raises   = options[:raise_errors]
+      port     = options[:port]    || 80
+      scheme   = options[:scheme]  || "http"
+      @type    = options[:type]    || :json
+      @headers = options[:headers] || {}
+
+      @http   = Net::HTTP::Persistent.new
+      @errors = Errors::HTTP.new :raise_errors => raises
+      @uri    = URI.parse "#{scheme}://#{options[:host]}:#{port}"
+
+      @http.debug_output = $stdout if options[:debug]
     end
 
     ##
-    # Perform an HTTP get, delete, post, or put.
+    # Perform an HTTP Delete, Head, Get, Post, or Put.
+    #
     # +path+: A String with the path to the HTTP resource.
     # +params+: A Hash with the following keys:
-    #   - +:query+: Query String in the format "foo=bar"
-    #   - +:body+: A sub Hash to be JSON encoded, and  posted in
-    #     the message body.
+    #   +:query+:    A String with the format "foo=bar".
+    #   +:body+:     A String containing the message body for Put and Post requests.
+    #   +:upload+:   A Hash with the following keys:
+    #     +file+:    The file to be HTTP chunked uploaded.
+    #     +headers+: A Hash containing additional HTTP headers.
 
-    Classes.each do |clazz|
+    CLASSES.each do |clazz|
       verb = clazz.to_s.split("::").last.downcase
 
       define_method verb do |*args|
@@ -66,10 +74,13 @@ module Hugs
     end
 
     ##
-    # :method: get
+    # :method: delete
 
     ##
-    # :method: delete
+    # :method: head
+
+    ##
+    # :method: get
 
     ##
     # :method: post
@@ -79,57 +90,88 @@ module Hugs
 
   private
     ##
-    # Worker method to be called by #get, #delete, #post, #put.
+    # Worker method to be called by #delete, #get, #head, #post, or #put.
+    #
     # Method arguments have been documented in the callers.
 
-    def response_for request, path, params
-      @http.debug_output = $stdout if debug
+    def response_for clazz, path, params
+      request      = clazz.new path_with_query path, params[:query]
+      request.body = encode params[:body]
 
-      query     = params[:query]  && params.delete(:query)
-      body      = params[:body]   && params.delete(:body)
-      upload    = params[:upload] && params.delete(:upload)
-      full_path = path_with_query path, query
+      handle_request request, params[:upload]
+    end
 
-      if upload && request.class === Net::HTTP::Post
-        parts        = upload[:parts] || {}
-        parts[:file] = UploadIO.new(parts[:file], upload[:content_type]) if parts[:file]
+    ##
+    # Handles setting headers, performing the HTTP connection, parsing the
+    # response, and checking for any response errors (if configured).
+    #
+    # +request+: A net/http request Object.
 
-        request = Net::HTTP::Post::Multipart.new full_path, parts
-      else
-        request      = request.new full_path
-        request.body = encode body
+    def handle_request request, upload
+      uploads request, upload
+      headers request, upload
 
-        add_headers request
-      end
+      response      = @http.request @uri, request
+      response.body = parse response.body
+
+      request.body_stream.close if request.body_stream
 
-      request.basic_auth(@user, @password) if requires_authentication?
-      handle_response request
+      @errors.errors response
     end
 
-    def handle_response request
-      resp = @http.request @url, request
-      Hugs::Errors::status_error resp, @raise_4xx, @raise_5xx
-      resp.body = parse resp.body if resp.body
+    ##
+    # Handle chunked uploads.
+    #
+    # +request+: A net/http request Object.
+    # +upload+:  A Hash containing :file and :headers for uploading.
 
-      resp
-    end
+    def uploads request, upload
+      return unless upload
 
-    def path_with_query path, query
-      [path, query].compact.join "?"
+      @headers.merge! chunked_headers upload if upload
+
+      request.body_stream = File.open upload[:file]
     end
 
-    def add_headers request
-      request.add_field "Accept", Headers[@type]
-      if [Net::HTTP::Post, Net::HTTP::Put].include? request.class
-        request.add_field "Content-Type", Headers[@type]
-      end
+    ##
+    # Handles the setting of various default and custom headers.
+    # Headers set in initialize can override all others.
+    #
+    # +request+: A net/http request Object.
+
+    def headers request, upload
+      request.basic_auth(@user, @pass) if requires_authentication?
+
+      request.add_field "Accept", MIME_TYPES[@type]
+      request.add_field "Content-Type", MIME_TYPES[@type] if requires_content_type? request
 
       @headers.each do |header, value|
-        request.add_field header, value
-      end
+        request[header] = value
+      end if @headers
+    end
+
+    ##
+    # Setting of chunked upload headers.
+    #
+    # +:upload+:   A Hash with the following keys:
+    #   +file+:    The file to be HTTP chunked uploaded.
+    #   +headers+: A Hash containing additional HTTP headers.
+
+    def chunked_headers upload
+      chunked_headers = {
+        "Content-Type"      => MIME_TYPES[:binary],
+        "Content-Length"    => File.size(upload[:file]),
+        "Transfer-Encoding" => "chunked"
+      }.merge upload[:headers] || {}
+    end
+
+    def path_with_query path, query
+      [path, query].compact.join "?"
     end
 
     def parse data
+      return unless data
+
       if is_json?
         Yajl::Parser.parse data
       elsif is_xml?
@@ -141,11 +183,16 @@ module Hugs
 
     def encode body
       return unless body
+
       is_json? ? (Yajl::Encoder.encode body) : body
     end
 
     def requires_authentication?
-      @user && @password
+      @user && @pass
+    end
+
+    def requires_content_type? request
+      [Net::HTTP::Post, Net::HTTP::Put].include? request.class
     end
 
     def is_xml?

data/lib/hugs/errors.rb

@@ -39,46 +39,56 @@ module Hugs
     class ServiceUnavailable < HTTPStatusError; end           # 503
     class GatewayTimeout < HTTPStatusError; end               # 504
 
+    class HTTP
+      def initialize options
+        @raise_errors = options[:raise_errors]
+        
+        initialize_errors
+      end
 
-    def self.status_error response, raise_4xx, raise_5xx
-      @errors ||= {
-        400 => [Hugs::Errors::BadRequest, 'Bad Request'],
-        401 => [Hugs::Errors::Unauthorized, 'Unauthorized'],
-        402 => [Hugs::Errors::PaymentRequired, 'Payment Required'],
-        403 => [Hugs::Errors::Forbidden, 'Forbidden'],
-        404 => [Hugs::Errors::NotFound, 'Not Found'],
-        405 => [Hugs::Errors::MethodNotAllowed, 'Method Not Allowed'],
-        406 => [Hugs::Errors::NotAcceptable, 'Not Acceptable'],
-        407 => [Hugs::Errors::ProxyAuthenticationRequired, 'Proxy Authentication Required'],
-        408 => [Hugs::Errors::RequestTimeout, 'Request Timeout'],
-        409 => [Hugs::Errors::Conflict, 'Conflict'],
-        410 => [Hugs::Errors::Gone, 'Gone'],
-        411 => [Hugs::Errors::LengthRequired, 'Length Required'],
-        412 => [Hugs::Errors::PreconditionFailed, 'Precondition Failed'],
-        413 => [Hugs::Errors::RequestEntityTooLarge, 'Request Entity Too Large'],
-        414 => [Hugs::Errors::RequestURITooLong, 'Request-URI Too Long'],
-        415 => [Hugs::Errors::UnsupportedMediaType, 'Unsupported Media Type'],
-        416 => [Hugs::Errors::RequestedRangeNotSatisfiable, 'Request Range Not Satisfiable'],
-        417 => [Hugs::Errors::ExpectationFailed, 'Expectation Failed'],
-        422 => [Hugs::Errors::UnprocessableEntity, 'Unprocessable Entity'],
-        500 => [Hugs::Errors::InternalServerError, 'InternalServerError'],
-        501 => [Hugs::Errors::NotImplemented, 'Not Implemented'],
-        502 => [Hugs::Errors::BadGateway, 'Bad Gateway'],
-        503 => [Hugs::Errors::ServiceUnavailable, 'Service Unavailable'],
-        504 => [Hugs::Errors::GatewayTimeout, 'Gateway Timeout']
-      }
+      def errors response
+        case response.code
+          when @raise_errors && %r{^[45]{1}[0-9]{2}$} ; raise_for(response)
+        end
 
-      case response.code
-        when raise_4xx && %r{^4[0-9]{2}$} ; raise_for(response)
-        when raise_5xx && %r{^5[0-9]{2}$} ; raise_for(response)
+        response
       end
-    end
 
-  private
-    def self.raise_for response
-      error, message = @errors[response.code.to_i]
+    private
+      def raise_for response
+        error, message = @errors[response.code.to_i]
 
-      raise error.new message, response
+        raise error.new message, response
+      end
+
+      def initialize_errors
+        @errors ||= {
+          400 => [Hugs::Errors::BadRequest, 'Bad Request'],
+          401 => [Hugs::Errors::Unauthorized, 'Unauthorized'],
+          402 => [Hugs::Errors::PaymentRequired, 'Payment Required'],
+          403 => [Hugs::Errors::Forbidden, 'Forbidden'],
+          404 => [Hugs::Errors::NotFound, 'Not Found'],
+          405 => [Hugs::Errors::MethodNotAllowed, 'Method Not Allowed'],
+          406 => [Hugs::Errors::NotAcceptable, 'Not Acceptable'],
+          407 => [Hugs::Errors::ProxyAuthenticationRequired, 'Proxy Authentication Required'],
+          408 => [Hugs::Errors::RequestTimeout, 'Request Timeout'],
+          409 => [Hugs::Errors::Conflict, 'Conflict'],
+          410 => [Hugs::Errors::Gone, 'Gone'],
+          411 => [Hugs::Errors::LengthRequired, 'Length Required'],
+          412 => [Hugs::Errors::PreconditionFailed, 'Precondition Failed'],
+          413 => [Hugs::Errors::RequestEntityTooLarge, 'Request Entity Too Large'],
+          414 => [Hugs::Errors::RequestURITooLong, 'Request-URI Too Long'],
+          415 => [Hugs::Errors::UnsupportedMediaType, 'Unsupported Media Type'],
+          416 => [Hugs::Errors::RequestedRangeNotSatisfiable, 'Request Range Not Satisfiable'],
+          417 => [Hugs::Errors::ExpectationFailed, 'Expectation Failed'],
+          422 => [Hugs::Errors::UnprocessableEntity, 'Unprocessable Entity'],
+          500 => [Hugs::Errors::InternalServerError, 'InternalServerError'],
+          501 => [Hugs::Errors::NotImplemented, 'Not Implemented'],
+          502 => [Hugs::Errors::BadGateway, 'Bad Gateway'],
+          503 => [Hugs::Errors::ServiceUnavailable, 'Service Unavailable'],
+          504 => [Hugs::Errors::GatewayTimeout, 'Gateway Timeout']
+        }
+      end
     end
   end
 end

data/lib/hugs/version.rb

@@ -1,3 +1,3 @@
 module Hugs
-  VERSION = "2.5.2"
+  VERSION = "2.6.0"
 end

data/test/lib/hugs/client_test.rb

@@ -1,270 +1,279 @@
 require "test_helper"
 
-require "base64"
+require "uri"
 
 describe Hugs::Client do
   before do
-    @instance = Hugs::Client.new valid_options
-    @request  = Net::HTTP::Get
+    @uri      = URI::HTTP.build :host => "example.com", :path => "/"
+    @client   = Hugs::Client.new :host => @uri.host
 
     WebMock.reset!
   end
 
-  describe "path" do
-    it "is valid" do
-      stub_request :get, url
-
-      @instance.send :response_for, @request, "/", {}
-
-      assert_requested :get, url
+  describe "verbs" do
+    it "supports HTTP Get" do
+      must_support_http_get
     end
 
-    it "is valid when an invalid :query is supplied" do
-      stub_request :get, url
-
-      @instance.send :response_for, @request, "/", :query => nil
-
-      assert_requested :get, url
+    it "supports HTTP Delete" do
+      must_support_http_delete
     end
 
-    it "also has a query string" do
-      stub_request(:get, url).with:query => {"foo" => "bar"}
-
-      @instance.send :response_for, @request, "/", :query => "foo=bar"
-
-      assert_requested :get, url, :query => {"foo" => "bar"}
+    it "supports HTTP Head" do
+      must_support_http_head
     end
-  end
 
-  describe "multi-part" do
-    Content_Type_Matcher = %r{multipart/form-data}
-
-    before do
-      @request = Net::HTTP::Post
+    it "supports HTTP Post" do
+      must_support_http_post
     end
 
-    it "uploads a file" do
-      stub_request :post, url
-      upload = {
-        :upload => {
-          :parts => { :file => "/dev/null" },
-          :content_type => "type/subtype"
-        }
-      }
-
-      @instance.send :response_for, @request, "/", upload
-
-      assert_requested :post, url, :body => %r{Content-Type: type/subtype}, :headers => {
-        "Content-Type" => Content_Type_Matcher
-      }
+    it "supports HTTP Put" do
+      must_support_http_put
     end
+  end
 
-    it "has parts" do
-      stub_request :post, url
-      upload = {
-        :upload => {
-          :parts => { :foo => :bar, :baz => :xyzzy },
-          :content_type => "foo/bar"
-        }
-      }
+  describe "path" do
+    it "supports a query string" do
+      stub_request(:get, @uri.to_s).with:query => { "foo" => "bar" }
 
-      @instance.send :response_for, @request, "/", upload
+      @client.get @uri.path, :query => "foo=bar"
 
-      ### wtf can't use mx together.
-      content_disposition_matcher = %r{^Content-Disposition: form-data; name="foo".*^bar.*^Content-Disposition: form-data; name="baz".*^xyzzy.*}m
-      assert_requested :post, url, :body => content_disposition_matcher, :headers => {
-        "Content-Type" => Content_Type_Matcher
-      }
+      assert_requested :get, @uri.to_s, :query => { "foo" => "bar" }
     end
   end
 
-  describe "body" do
-    describe "parses response" do
-      describe "json" do
-        it "objectifies and returns a hash" do
-          stub_request(:get, url).to_return :body => '{"foo":"bar"}'
-          instance = Hugs::Client.new valid_options(:type => :json)
-
-          response = instance.get "/"
-
-          response.body.must_be_kind_of Hash
-        end
+  describe "headers" do
+    describe "json" do
+      it "adds Accept header" do
+        must_have_headers_for_get :json
       end
 
-      describe "xml" do
-        it "parses and returns a Nokogiri object" do
-          stub_request(:get, url).to_return :body => "<STORAGE></STORAGE>"
-          instance = Hugs::Client.new valid_options(:type => :xml)
-
-          response = instance.get "/"
+      it "adds Content-Type header" do
+        must_have_headers_for_put :json
+        must_have_headers_for_post :json
+      end
+    end
 
-          response.body.must_be_kind_of Nokogiri::XML::Document
-        end
+    describe "xml" do
+      before do
+        @client = Hugs::Client.new :host => @uri.host, :type => :xml
       end
 
-      ### TODO: webmock seems to turn nil into "" body.  Cannot test a failing case.
-      ### TODO: fix when I can.
-      it "doesn't parse a nil body" do
-        #stub_request(:head, url).to_return :body => nil
+      it "adds Accept header" do
+        must_have_headers_for_get :xml
+      end
 
-        #@instance.send :response_for, Net::HTTP::Head, "/", {}
+      it "adds Content-Type header" do
+        must_have_headers_for_put :xml
+        must_have_headers_for_post :xml
       end
     end
 
-    describe "encodes request" do
+    describe "custom" do
       before do
-        stub_request :get, url
+        @client = Hugs::Client.new(
+          :host    => @uri.host,
+          :headers => { "foo" => "bar", "baz" => "xyzzy" }
+        )
       end
 
-      it "is not set when :body invalid" do
-        @instance.send :response_for, @request, "/", :body => nil
-
-        assert_requested :get, url, :body => nil
+      it "adds headers" do
+        must_have_headers_for :get, {}, "foo" => "bar", "baz" => "xyzzy"
       end
+    end
 
-      it "is not set when :body is missing" do
-        @instance.send :response_for, @request, "/", {}
-
-        assert_requested :get, url, {}
+    describe "custom override defaults" do
+      before do
+        @client = Hugs::Client.new(
+          :host    => @uri.host,
+          :headers => { "Accept" => "foo bar" }
+        )
       end
 
-      describe "json" do
-        it "is valid" do
-          instance = Hugs::Client.new valid_options(:type => :json)
-
-          instance.send :response_for, @request, "/", :body => {:foo => :bar}
-
-          assert_requested :get, url, :body => '{"foo":"bar"}'
-        end
+      it "replaces headers" do
+        must_have_headers_for :get, {}, "Accept" => "foo bar"
       end
+    end
+  end
 
-      describe "xml" do
-        it "is valid" do
-          instance = Hugs::Client.new valid_options(:type => :xml)
+  describe "authentication" do
+    before do
+      @uri.userinfo = "user:credentials"
+      @client = Hugs::Client.new(
+        :host     => @uri.host,
+        :user     => "user",
+        :password => "credentials"
+      )
+    end
 
-          instance.send :response_for, @request, "/", :body => "foo bar"
+    it "uses Basic Authentication when initialized with :user and :password" do
+      stub_request :get, @uri.to_s
 
-          assert_requested :get, url, :body => "foo bar"
-        end
-      end
+      @client.get @uri.path
+
+      assert_requested :get, @uri.to_s
     end
   end
 
-  describe "headers" do
-    describe "authentication" do
-      it "uses basic auth when providing user and password" do
-        stub_request :get, url("/", "user:credentials")
-        instance = Hugs::Client.new valid_options(:user => "user", :password => "credentials")
+  describe "parse body" do
+    describe "json" do
+      it "parses the body" do
+        stub_request(:get, @uri.to_s).to_return :body => '{"foo":"bar"}'
 
-        instance.send :response_for, @request, "/", {}
-        assert_requested :get, url("/", "user:credentials")
+        response = @client.get @uri.path
+
+        response.body['foo'].must_equal "bar"
       end
+    end
 
-      it "doesn't use basic auth without a user" do
-        assert_doesnt_use_basic_auth_without :user
+    describe "xml" do
+      before do
+        @client = Hugs::Client.new :host => @uri.host, :type => :xml
       end
 
-      it "doesn't use basic auth without a password" do
-        assert_doesnt_use_basic_auth_without :password
+      it "parses the body" do
+        stub_request(:get, @uri.to_s).to_return :body => "<foo>bar</foo>"
+
+        response = @client.get @uri.path
+
+        response.body.xpath('foo').text.must_equal "bar"
       end
     end
+  end
 
-    describe "JSON" do
-      it "supports json GET" do
-        assert_supports_http_verb :json, :get
-      end
+  describe "encode body" do
+    describe "json" do
+      it "encodes the body" do
+        stub_request :post, @uri.to_s
 
-      it "supports json DELETE" do
-        assert_supports_http_verb :json, :delete
-      end
+        @client.post @uri.path, :body => { :foo => :bar }
 
-      it "supports json POST" do
-        assert_supports_http_verb :json, :post
+        assert_requested :post, @uri.to_s, :body => '{"foo":"bar"}'
       end
+    end
 
-      it "supports json PUT" do
-        assert_supports_http_verb :json, :put
+    describe "xml" do
+      before do
+        @client = Hugs::Client.new :host => @uri.host, :type => :xml
       end
 
-      it "supports json HEAD" do
-        assert_supports_http_verb :json, :head
+      it "does not encode the body" do
+        stub_request :post, @uri.to_s
+
+        @client.post @uri.path, :body => "foo bar"
+
+        assert_requested :post, @uri.to_s, :body => "foo bar"
       end
     end
+  end
 
-    describe "XML" do
-      it "supports xml GET" do
-        assert_supports_http_verb :xml, :get
-      end
+  describe "upload" do
+    describe "chunked" do
+      before do
+        @upload = {
+          :upload => { :file => "/dev/null" }
+        }
 
-      it "supports xml DELETE" do
-        assert_supports_http_verb :xml, :delete
+        @upload_with_headers = {
+          :upload => {
+            :file    => "/dev/null",
+            :headers => { "Accept" => "foo bar" }
+          }
+        }
       end
 
-      it "supports xml POST" do
-        assert_supports_http_verb :xml, :post
+      it "has chunked headers" do
+        must_have_headers_for :post, @upload, {
+          "Content-Type"      => "application/octet-stream",
+          ###"Content-Length"    => "0",
+          "Transfer-Encoding" => "chunked"
+        }
       end
 
-      it "supports xml PUT" do
-        assert_supports_http_verb :xml, :put
+      it "upload headers override default headers" do
+        must_have_headers_for :post, @upload_with_headers, "Accept" => "foo bar"
       end
 
-      it "supports xml HEAD" do
-        assert_supports_http_verb :xml, :head
+      it "has chunked body" do
+        #stub_request :post, @uri.to_s
+
+        #@client.post @uri.path, @upload
+
+        #assert_requested verb, @uri.to_s, :headers => headers
       end
     end
   end
 
-  describe "debug_output" do
+  describe "debug" do
     before do
-      @instance = Hugs::Client.new valid_options(
-        :host => "gist.github.com",
-        :port => "80"
-      )
-
       WebMock.allow_net_connect!
     end
 
     it "outputs net/http debug data" do
-      @instance.debug = true
+      out, _ = capture_io {
+        client = Hugs::Client.new :host => "gist.github.com", :debug => true
 
-      out, err = capture_io { @instance.send :response_for, Net::HTTP::Get, "/api/v1/json/374130", {} }
+        client.get "/api/v1/json/374130"
+      }
 
       out.wont_be_empty
     end
 
     it "does not output net/http debug data" do
-      out, err = capture_io { @instance.send :response_for, Net::HTTP::Get, "/api/v1/json/374130", {} }
+      out, _ = capture_io {
+        client = Hugs::Client.new :host => "gist.github.com"
+
+        client.get "/api/v1/json/374130"
+      }
 
       out.must_be_empty
     end
   end
 
+  def must_support_http_delete
+    must_support_http :delete
+  end
 
-  def assert_supports_http_verb type, verb
-    mimetype = {:xml  => 'application/xml',
-                :json => 'application/json'}[type]
+  def must_support_http_get
+    must_support_http :get
+  end
 
-    assert mimetype, "Unsupported Mimetype '#{type}'"
+  def must_support_http_head
+    must_support_http :head
+  end
 
-    clazz = Net::HTTP.const_get verb.capitalize
+  def must_support_http_post
+    must_support_http :post
+  end
 
-    stub_request verb, url
-    instance = Hugs::Client.new valid_options(:type => type)
+  def must_support_http_put
+    must_support_http :put
+  end
 
-    instance.send :response_for, clazz, "/", {}
+  def must_support_http verb
+    stub_request verb, @uri.to_s
+    @client.send verb, @uri.path
 
-    headers = { "Accept" => ["*/*", mimetype] }
-    headers["Content-Type"] = mimetype if [:put, :put].include? type
+    assert_requested verb, @uri.to_s
+  end
+
+  def must_have_headers_for_get type
+    must_have_headers_for :get, {}, "Accept" => ["*/*", "application/#{type}"]
+  end
+
+  def must_have_headers_for_put type
+    must_have_headers_for :put, {}, "Content-Type" => "application/#{type}"
+  end
 
-    assert_requested verb, url, :headers => headers
+  def must_have_headers_for_post type
+    must_have_headers_for :post, {}, "Content-Type" => "application/#{type}"
   end
 
-  def assert_doesnt_use_basic_auth_without option
-    stub_request :get, url
-    instance = Hugs::Client.new valid_options(option => "value")
+  def must_have_headers_for verb, options, headers
+    stub_request verb, @uri.to_s
 
-    instance.send :response_for, @request, "/", {}
+    @client.send verb, @uri.path, options
 
-    assert_requested :get, url
+    assert_requested verb, @uri.to_s, :headers => headers
   end
 end

data/test/lib/hugs/errors_test.rb

@@ -1,46 +1,59 @@
 require "test_helper"
 
-describe Hugs::Errors do
+describe Hugs::Errors::HTTP do
   before do
-    @instance = Hugs::Client.new valid_options
+    @errors_4xx = (400..417).to_a << 422
+    @errors_5xx = (500..504).to_a
+    @errors_all = @errors_4xx + @errors_5xx
+    @uri        = URI::HTTP.build :host => "example.com"
 
     WebMock.reset!
   end
 
-  describe "response codes" do
-    Errors_4xx = (400..417).to_a << 422
-    Errors_5xx = (500..504).to_a
-
-    (Errors_4xx + Errors_5xx).each do |code|
-      it "raises on #{code}" do
-        assert_raises_on code
+  describe "errors" do
+    describe "does not raise" do
+      before do
+        @client = Hugs::Client.new :host => @uri.host
       end
 
-      it "does not raise on #{code}" do
-        assert_does_not_raise_on code
+      it "returns response" do
+        @errors_all.each do |code|
+          must_not_raise_on code
+        end
       end
     end
 
-    def assert_raises_on code
-      (code.to_s =~ %r{^4[0-9]{2}$}) ? (@instance.raise_4xx = true) : (@instance.raise_5xx = true)
-      stub_request(:get, url).to_return :status => [code, "error #{code}"]
+    describe "raises" do
+      before do
+        @client = Hugs::Client.new :host => @uri.host, :raise_errors => true
+      end
 
-      begin
-        @instance.send :response_for, Net::HTTP::Get, "/", {}
-      rescue => e
-        e.class.superclass.must_be_same_as Hugs::Errors::HTTPStatusError
-        e.must_respond_to :response
-        return
+      it "returns exception" do
+        @errors_all.each do |code|
+          must_raise_on code
+        end
       end
-      raise StandardError.new "did not raise expected exception"
     end
+  end
 
-    def assert_does_not_raise_on code
-      stub_request(:get, url).to_return :status => [code, "error #{code}"]
-
-      response = @instance.send :response_for, Net::HTTP::Get, "/", {}
+  def must_raise_on code
+    stub_request(:get, @uri.to_s).to_return :status => [code, "error #{code}"]
 
-      response.code.must_equal code.to_s
+    begin
+      @client.get "/"
+    rescue => e
+      e.class.superclass.must_be_same_as Hugs::Errors::HTTPStatusError
+      e.must_respond_to :response
+      return
     end
+    raise StandardError.new "did not raise expected exception"
+  end
+
+  def must_not_raise_on code
+    stub_request(:get, @uri.to_s).to_return :status => [code, "error #{code}"]
+
+    response = @client.get "/"
+
+    response.code.must_equal code.to_s
   end
 end

data/test/test_helper.rb

@@ -3,28 +3,10 @@ Bundler.setup :default, :test
 require "hugs"
 
 require "minitest/spec"
-require "uri"
 require "webmock"
 
 class MiniTest::Unit::TestCase
   include WebMock::API
-
-  def valid_options opts = {}
-    {
-      :host   => "example.com",
-      :port   => 80,
-      :scheme => "http"
-    }.merge opts
-  end
-
-  def url path = "/", credentials = nil
-    URI::HTTP.build(
-      valid_options(
-        :path => path,
-        :userinfo => credentials
-      )
-    ).to_s
-  end
 end
 
 MiniTest::Unit.autorun

metadata

@@ -2,7 +2,7 @@
 name: hugs
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 2.5.2
+  version: 2.6.0
 platform: ruby
 authors: 
 - John Dewey
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-07 00:00:00 -07:00
+date: 2011-05-17 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -103,7 +103,6 @@ files:
 - .gitignore
 - .rvmrc
 - Gemfile
-- Gemfile.lock
 - LICENSE
 - README.md
 - Rakefile

data/Gemfile.lock

@@ -1,32 +0,0 @@
-PATH
-  remote: .
-  specs:
-    hugs (2.5.1)
-      multipart-post (~> 1.0.1)
-      net-http-persistent (~> 1.4.1)
-      nokogiri (~> 1.4.4)
-      yajl-ruby (~> 0.7.9)
-
-GEM
-  remote: http://rubygems.org/
-  specs:
-    addressable (2.2.2)
-    crack (0.1.8)
-    minitest (2.0.2)
-    multipart-post (1.0.1)
-    net-http-persistent (1.4.1)
-    nokogiri (1.4.4)
-    rake (0.8.7)
-    webmock (1.6.1)
-      addressable (>= 2.2.2)
-      crack (>= 0.1.7)
-    yajl-ruby (0.7.9)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  hugs!
-  minitest
-  rake
-  webmock