httpi 0.3.0 → 0.4.0

data/.autotest

@@ -0,0 +1,5 @@
+Autotest.add_hook(:initialize) do |at|
+  at.clear_mappings
+  at.add_mapping(%r%^spec/httpi/.*_spec.rb$%) { |filename, _| filename }
+  at.add_mapping(%r%^lib/(.*)\.rb$%) { |_, m| ["spec/#{m[1]}_spec.rb"] }
+end

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    httpi (0.2.0)
+    httpi (0.3.0)
 
 GEM
   remote: http://rubygems.org/

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Daniel Harrington
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -3,6 +3,8 @@ HTTPI
 
 HTTPI provides a common interface for Ruby HTTP libraries.
 
+[Feedback](http://httpi.uservoice.com) | [Bugs](http://github.com/rubiii/httpi/issues) | [Docs](http://rubydoc.info/gems/httpi)
+
 Installation
 ------------
 
@@ -13,12 +15,12 @@ The gem is available through [Rubygems](http://rubygems.org/gems/httpi) and can
 Some examples
 -------------
 
-Let's create the most basic request object and execute a GET request:
+Executing a POST request with the most basic request object:
 
     request = HTTPI::Request.new :url => "http://example.com"
     HTTPI.get request
 
-A POST request with a request object:
+Here's a POST request with a request object:
 
     request = HTTPI::Request.new
     request.url = "http://post.example.com"
@@ -34,19 +36,19 @@ And a GET request using HTTP basic auth and the Curb adapter:
   
     HTTPI.get request, :curb
 
-HTTPI also comes with some shortcuts. This executes a GET request:
+HTTPI also comes with some shortcuts. This executes a PUT request:
 
-    HTTPI.get "http://example.com"
+    HTTPI.put "http://example.com", "<some>xml</some>"
 
-And here's a POST:
+And this executes a DELETE request:
 
-    HTTPI.post "http://example.com", "<some>xml</some>"
+    HTTPI.delete "http://example.com"
 
 HTTPI
 -------------
 
-The `HTTPI` module uses one of the available adapters to execute HTTP requests.  
-It currently supports GET and POST requests:
+The `HTTPI` module uses one of the available adapters to execute HTTP requests.
+It supports GET, POST, HEAD, PUT and DELETE requests:
 
 ### GET
 
@@ -58,6 +60,21 @@ It currently supports GET and POST requests:
     .post(request, adapter = nil)
     .post(url, body, adapter = nil)
 
+### HEAD
+
+    .head(request, adapter = nil)
+    .head(url, adapter = nil)
+
+### PUT
+
+    .put(request, adapter = nil)
+    .put(url, body, adapter = nil)
+
+### DELETE
+
+    .delete(request, adapter = nil)
+    .delete(url, adapter = nil)
+
 ### Notice
 
 * You can specify the adapter to use per request
@@ -72,10 +89,6 @@ by your adapter in a block:
       http.use_ssl = true  # Curb example
     end
 
-### TODO
-
-* Add support for HEAD, PUT and DELETE requests
-
 HTTPI::Request
 --------------
 
@@ -91,17 +104,18 @@ It represents an HTTP request and lets you customize various settings through th
 
 It also contains methods for setting up authentication:
 
-    #basic_auth(username, password)  # HTTP basic auth credentials
+    #basic_auth(username, password)   # HTTP basic auth credentials
+    #digest_auth(username, password)  # HTTP digest auth credentials
 
 ### TODO
 
-* Add support for HTTP digest authentication
 * Add support for SSL client authentication
+* Add support for NTLM authentication
 
 HTTPI::Adapter
 --------------
 
-HTTPI uses adapters to support multiple HTTP libraries.  
+HTTPI uses adapters to support multiple HTTP libraries.
 It currently contains adapters for:
 
 * [httpclient](http://rubygems.org/gems/httpclient) ~> 2.1.5
@@ -109,16 +123,12 @@ It currently contains adapters for:
 
 By default, HTTPI uses the `HTTPClient`. But changing the default is fairly easy:
 
-    HTTPI::Adapter.use = :curb
-
-You can find a list of supported adapters via:
-
-    HTTPI::Adapter.adapters  # returns a Hash of supported adapters
+    HTTPI::Adapter.use = :curb  # or :httpclient
 
 HTTPI::Response
 ---------------
 
-As mentioned before, every request method return an `HTTPI::Response`.  
+As mentioned before, every request method return an `HTTPI::Response`.
 It contains the response code, headers and body.
 
     response = HTTPI.get request

data/Rakefile

@@ -29,6 +29,13 @@ begin
   require "rspec/core/rake_task"
   
   RSpec::Core::RakeTask.new do |t|
+    t.pattern = "spec/httpi/*_spec.rb"
+    t.rspec_opts = %w(-fd -c)
+  end
+
+  desc "Run RSpec integration examples"
+  RSpec::Core::RakeTask.new "spec:integration" do |t|
+    t.pattern = "spec/integration/*_spec.rb"
     t.rspec_opts = %w(-fd -c)
   end
 rescue LoadError

data/lib/httpi.rb

@@ -5,33 +5,73 @@ require "httpi/adapter"
 # = HTTPI
 #
 # Executes HTTP requests using a predefined adapter.
+# All request methods accept an <tt>HTTPI::Request</tt> and an optional adapter.
+# They may also offer shortcut methods for executing basic requests.
+# Also they all return an <tt>HTTPI::Response</tt>.
+#
+# == GET
+#
+#   request = HTTPI::Request.new :url => "http://example.com"
+#   HTTPI.get request, :httpclient
+#
+# === Shortcuts
+#
+#   HTTPI.get "http://example.com", :curb
+#
+# == POST
+#
+#   request = HTTPI::Request.new
+#   request.url = "http://example.com"
+#   request.body = "<some>xml</some>"
+#   
+#   HTTPI.post request, :httpclient
+#
+# === Shortcuts
+#
+#   HTTPI.post "http://example.com", "<some>xml</some>", :curb
+#
+# == HEAD
+#
+#   request = HTTPI::Request.new :url => "http://example.com"
+#   HTTPI.head request, :httpclient
+#
+# === Shortcuts
+#
+#   HTTPI.head "http://example.com", :curb
+#
+# == PUT
+#
+#   request = HTTPI::Request.new
+#   request.url = "http://example.com"
+#   request.body = "<some>xml</some>"
+#   
+#   HTTPI.put request, :httpclient
+#
+# === Shortcuts
+#
+#   HTTPI.put "http://example.com", "<some>xml</some>", :curb
+#
+# == DELETE
+#
+#   request = HTTPI::Request.new :url => "http://example.com"
+#   HTTPI.delete request, :httpclient
+#
+# === Shortcuts
+#
+#   HTTPI.delete "http://example.com", :curb
+#
+# == More control
+#
+# If you need more control over your request, you can access the HTTP client
+# instance represented by your adapter in a block.
+#
+#   HTTPI.get request do |http|
+#     http.follow_redirect_count = 3  # HTTPClient example
+#   end
 module HTTPI
   class << self
 
-    # Executes an HTTP GET request and returns an <tt>HTTPI::Response</tt>.
-    #
-    # ==== Example
-    #
-    # Accepts an <tt>HTTPI::Request</tt> and an optional adapter:
-    #
-    #   request = HTTPI::Request.new :url => "http://example.com"
-    #   HTTPI.get request, :httpclient
-    #
-    # ==== Shortcut
-    #
-    # You can also just pass a URL and an optional adapter if you don't
-    # need to configure the request:
-    #
-    #   HTTPI.get "http://example.com", :curb
-    #
-    # ==== More control
-    #
-    # If you need more control over the request, you can access the HTTP
-    # client instance represented by your adapter in a block.
-    #
-    #   HTTPI.get request do |http|
-    #     http.follow_redirect_count = 3  # HTTPClient example
-    #   end
+    # Executes an HTTP GET request.
     def get(request, adapter = nil)
       request = Request.new :url => request if request.kind_of? String
       
@@ -41,35 +81,9 @@ module HTTPI
       end
     end
 
-    # Executes an HTTP POST request and returns an <tt>HTTPI::Response</tt>.
-    #
-    # ==== Example
-    #
-    # Accepts an <tt>HTTPI::Request</tt> and an optional adapter:
-    #
-    #   request = HTTPI::Request.new
-    #   request.url = "http://example.com"
-    #   request.body = "<some>xml</some>"
-    #   
-    #   HTTPI.post request, :httpclient
-    #
-    # ==== Shortcut
-    #
-    # You can also just pass a URL, a request body and an optional adapter
-    # if you don't need to configure the request:
-    #
-    #   HTTPI.post "http://example.com", "<some>xml</some>", :curb
-    #
-    # ==== More control
-    #
-    # If you need more control over the request, you can access the HTTP
-    # client instance represented by your adapter in a block.
-    #
-    #   HTTPI.post request do |http|
-    #     http.use_ssl = true  # Curb example
-    #   end
+    # Executes an HTTP POST request.
     def post(*args)
-      request, adapter = extract_post_args(args)
+      request, adapter = request_and_adapter_from(args)
       
       with adapter do |adapter|
         yield adapter.client if block_given?
@@ -77,12 +91,42 @@ module HTTPI
       end
     end
 
-    private
+    # Executes an HTTP HEAD request.
+    def head(request, adapter = nil)
+      request = Request.new :url => request if request.kind_of? String
+      
+      with adapter do |adapter|
+        yield adapter.client if block_given?
+        adapter.head request
+      end
+    end
+
+    # Executes an HTTP PUT request.
+    def put(*args)
+      request, adapter = request_and_adapter_from(args)
+      
+      with adapter do |adapter|
+        yield adapter.client if block_given?
+        adapter.put request
+      end
+    end
+
+    # Executes an HTTP DELETE request.
+    def delete(request, adapter = nil)
+      request = Request.new :url => request if request.kind_of? String
+      
+      with adapter do |adapter|
+        yield adapter.client if block_given?
+        adapter.delete request
+      end
+    end
+
+  private
 
     # Checks whether +args+ contains of an <tt>HTTPI::Request</tt> or a URL
     # and a request body plus an optional adapter and returns an Array with
     # an <tt>HTTPI::Request</tt> and (if given) an adapter.
-    def extract_post_args(args)
+    def request_and_adapter_from(args)
       return args if args[0].kind_of? Request
       [Request.new(:url => args[0], :body => args[1]), args[2]]
     end

data/lib/httpi/adapter/curb.rb

@@ -9,39 +9,60 @@ module HTTPI
     # http://rubygems.org/gems/curb
     class Curb
 
+      # Requires the "curb" gem.
       def initialize
         require "curb"
       end
 
+      # Returns a memoized <tt>Curl::Easy</tt> instance.
       def client
         @client ||= Curl::Easy.new
       end
 
+      # Executes an HTTP GET request.
+      # @see HTTPI.get
       def get(request)
-        get_request(request) { |client| client.http_get }
+        do_request(request) { |client| client.http_get }
       end
 
+      # Executes an HTTP POST request.
+      # @see HTTPI.post
       def post(request)
-        post_request(request) { |client, body| client.http_post body }
+        do_request(request) { |client, body| client.http_post body }
+      end
+
+      # Executes an HTTP HEAD request.
+      # @see HTTPI.head
+      def head(request)
+        do_request(request) { |client| client.http_head }
+      end
+
+      # Executes an HTTP PUT request.
+      # @see HTTPI.put
+      def put(request)
+        do_request(request) { |client, body| client.http_put body }
+      end
+
+      # Executes an HTTP DELETE request.
+      # @see HTTPI.delete
+      def delete(request)
+        do_request(request) { |client| client.http_delete }
       end
 
     private
 
-      def get_request(request)
+      def do_request(request)
         setup_client request
         yield client
         respond_with client
       end
 
-      def post_request(request)
-        request.url.query = nil if request.url.query == "wsdl"
-        
-        setup_client request
-        yield client, request.body
-        respond_with client
+      def setup_client(request)
+        basic_setup request
+        setup_auth request if request.auth?
       end
 
-      def setup_client(request)
+      def basic_setup(request)
         client.url = request.url.to_s
         client.timeout = request.read_timeout
         client.connect_timeout = request.open_timeout
@@ -49,6 +70,11 @@ module HTTPI
         client.verbose = false
       end
 
+      def setup_auth(request)
+        client.http_auth_types = request.auth_type
+        client.username, client.password = *request.credentials
+      end
+
       def respond_with(client)
         Response.new client.response_code, client.headers, client.body_str
       end

data/lib/httpi/adapter/httpclient.rb

@@ -9,44 +9,77 @@ module HTTPI
     # http://rubygems.org/gems/httpclient
     class HTTPClient
 
+      # Requires the "httpclient" gem.
       def initialize
         require "httpclient"
       end
 
+      # Returns a memoized <tt>HTTPClient</tt> instance.
       def client
         @client ||= ::HTTPClient.new
       end
 
+      # Executes an HTTP GET request.
+      # @see HTTPI.get
       def get(request)
-        get_request request do |client, url, headers|
+        do_request request do |client, url, headers|
           client.get url, nil, headers
         end
       end
 
+      # Executes an HTTP POST request.
+      # @see HTTPI.post
       def post(request)
-        post_request request do |client, url, headers, body|
+        do_request request do |client, url, headers, body|
           client.post url, body, headers
         end
       end
 
-    private
+      # Executes an HTTP HEAD request.
+      # @see HTTPI.head
+      def head(request)
+        do_request request do |client, url, headers|
+          client.head url, nil, headers
+        end
+      end
 
-      def get_request(request)
-        setup_client request
-        respond_with yield(client, request.url, request.headers)
+      # Executes an HTTP PUT request.
+      # @see HTTPI.put
+      def put(request)
+        do_request request do |client, url, headers, body|
+          client.put url, body, headers
+        end
       end
 
-      def post_request(request)
+      # Executes an HTTP DELETE request.
+      # @see HTTPI.delete
+      def delete(request)
+        do_request request do |client, url, headers|
+          client.delete url, headers
+        end
+      end
+    private
+
+      def do_request(request)
         setup_client request
         respond_with yield(client, request.url, request.headers, request.body)
       end
 
       def setup_client(request)
+        basic_setup request
+        auth_setup request if request.auth?
+      end
+
+      def basic_setup(request)
         client.proxy = request.proxy if request.proxy
         client.connect_timeout = request.open_timeout
         client.receive_timeout = request.read_timeout
       end
 
+      def auth_setup(request)
+        client.set_auth request.url.to_s, *request.credentials
+      end
+
       def respond_with(response)
         Response.new response.code, Hash[response.header.all], response.content
       end

data/lib/httpi/request.rb

@@ -11,7 +11,7 @@ module HTTPI
     ACCESSORS = [:url, :proxy, :headers, :body, :open_timeout, :read_timeout]
 
     # Request authentication methods.
-    AUTHENTICATION = [:basic_auth]
+    AUTHENTICATION = [:basic_auth, :digest_auth]
 
     # Accepts a Hash of +options+ which may contain any number of ACCESSORS and/or
     # AUTHENTICATION credentials to set.
@@ -44,15 +44,36 @@ module HTTPI
     # Sets the Hash of HTTP headers.
     attr_writer :headers
 
-    attr_accessor :body, :open_timeout, :read_timeout
+    attr_accessor :body, :open_timeout, :read_timeout, :auth_type
+
+    # Returns whether any authentication credentials were specified.
+    def auth?
+      !!auth_type
+    end
+
+    # Shortcut method for returning the credentials for the authentication specified.
+    # Return +nil+ unless any authentication credentials were specified.
+    def credentials
+      return unless auth?
+      send "#{auth_type}_auth"
+    end
 
     # Sets the HTTP basic auth credentials. Accepts an Array or two arguments for the
     # +username+ and +password+. Resets the credentials when +nil+ is passed and returns
     # an Array of credentials when no +args+ where given.
     def basic_auth(*args)
+      self.auth_type = :basic
       @basic_auth = extract_credentials @basic_auth, args.flatten
     end
 
+    # Sets the HTTP digest auth credentials. Accepts an Array or two arguments for the
+    # +username+ and +password+. Resets the credentials when +nil+ is passed and returns
+    # an Array of credentials when no +args+ where given.
+    def digest_auth(*args)
+      self.auth_type = :digest
+      @digest_auth = extract_credentials @digest_auth, args.flatten
+    end
+
  private
 
     def assign_accessors(options)

data/lib/httpi/version.rb

@@ -1,5 +1,5 @@
 module HTTPI
 
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 
 end

data/spec/httpi/adapter/curb_spec.rb

@@ -6,6 +6,7 @@ require "curb"
 
 describe HTTPI::Adapter::Curb do
   let(:adapter) { HTTPI::Adapter::Curb.new }
+  let(:curb) { Curl::Easy.any_instance }
 
   describe ".new" do
     it "should require the Curb gem" do
@@ -42,8 +43,46 @@ describe HTTPI::Adapter::Curb do
     end
   end
 
-  def curb
-    Curl::Easy.any_instance
+  describe "#head" do
+    before do
+      curb.expects(:http_head)
+      curb.expects(:response_code).returns(200)
+      curb.expects(:headers).returns(Hash.new)
+      curb.expects(:body_str).returns(Fixture.xml)
+    end
+
+    it "should return a valid HTTPI::Response" do
+      request = HTTPI::Request.new :url => "http://example.com"
+      adapter.head(request).should be_a_valid_httpi_response
+    end
+  end
+
+  describe "#put" do
+    before do
+      curb.expects(:http_put)
+      curb.expects(:response_code).returns(200)
+      curb.expects(:headers).returns(Hash.new)
+      curb.expects(:body_str).returns(Fixture.xml)
+    end
+
+    it "should return a valid HTTPI::Response" do
+      request = HTTPI::Request.new :url => "http://example.com"
+      adapter.put(request).should be_a_valid_httpi_response
+    end
+  end
+
+  describe "#delete" do
+    before do
+      curb.expects(:http_delete)
+      curb.expects(:response_code).returns(200)
+      curb.expects(:headers).returns(Hash.new)
+      curb.expects(:body_str).returns("")
+    end
+
+    it "should return a valid HTTPI::Response" do
+      request = HTTPI::Request.new :url => "http://example.com"
+      adapter.delete(request).should be_a_valid_httpi_response
+    end
   end
 
 end

data/spec/httpi/adapter/httpclient_spec.rb

@@ -6,6 +6,7 @@ require "httpclient"
 
 describe HTTPI::Adapter::HTTPClient do
   let(:adapter) { HTTPI::Adapter::HTTPClient.new }
+  let(:httpclient) { HTTPClient.any_instance }
 
   describe ".new" do
     it "should require the HTTPClient gem" do
@@ -38,8 +39,40 @@ describe HTTPI::Adapter::HTTPClient do
     end
   end
 
-  def httpclient
-    HTTPClient.any_instance
+  describe "#head" do
+    before do
+      @request = HTTPI::Request.new :url => "http://example.com"
+      response = HTTP::Message.new_response Fixture.xml
+      httpclient.expects(:head).with(@request.url, nil, @request.headers).returns(response)
+    end
+
+    it "should return a valid HTTPI::Response" do
+      adapter.head(@request).should be_a_valid_httpi_response
+    end
+  end
+
+  describe "#put" do
+    before do
+      @request = HTTPI::Request.new :url => "http://example.com", :body => Fixture.xml
+      response = HTTP::Message.new_response Fixture.xml
+      httpclient.expects(:put).with(@request.url, @request.body, @request.headers).returns(response)
+    end
+
+    it "should return a valid HTTPI::Response" do
+      adapter.put(@request).should be_a_valid_httpi_response
+    end
+  end
+
+  describe "#delete" do
+    before do
+      @request = HTTPI::Request.new :url => "http://example.com"
+      response = HTTP::Message.new_response "" 
+      httpclient.expects(:delete).with(@request.url, nil, @request.headers).returns(response)
+    end
+
+    it "should return a valid HTTPI::Response" do
+      adapter.delete(@request).should be_a_valid_httpi_response
+    end
   end
 
 end

data/spec/httpi/httpi_spec.rb

@@ -1,6 +1,9 @@
 require "spec_helper"
 require "httpi"
 
+require "httpclient"
+require "curb"
+
 describe HTTPI do
   let(:client) { HTTPI }
   let(:default_adapter) { HTTPI::Adapter.find HTTPI::Adapter.use }
@@ -41,25 +44,29 @@ describe HTTPI do
       client.get "http://example.com", :curb
     end
   end
-  
-  describe ".get" do
+
+  shared_examples_for "a request method" do
     context "(with a block)" do
       it "should yield the HTTP client instance used for the request" do
-        client.get "http://example.com" do |http|
+        client.delete "http://example.com" do |http|
           http.should be_an(HTTPClient)
         end
       end
     end
 
-    it "should raise an ArgumentError in case of an invalid adapter" do
-      lambda { client.get HTTPI::Request.new, :invalid }.should raise_error(ArgumentError)
+    it "and raise an ArgumentError in case of an invalid adapter" do
+      lambda { client.delete HTTPI::Request.new, :invalid }.should raise_error(ArgumentError)
     end
 
-    it "should raise an ArgumentError in case of an invalid URL" do
-      lambda { client.get "invalid" }.should raise_error(ArgumentError)
+    it "and raise an ArgumentError in case of an invalid URL" do
+      lambda { client.delete "invalid" }.should raise_error(ArgumentError)
     end
   end
 
+  describe ".get" do
+    it_should_behave_like "a request method"
+  end
+
   describe ".post(request)" do
     it "should execute an HTTP POST request using the default adapter" do
       request = HTTPI::Request.new
@@ -99,21 +106,129 @@ describe HTTPI do
   end
 
   describe ".post" do
-    context "(with a block)" do
-      it "should yield the HTTP client instance used for the request" do
-        client.get "http://example.com", :curb do |http|
-          http.should be_a(Curl::Easy)
-        end
-      end
+    it_should_behave_like "a request method"
+  end
+
+  describe ".head(request)" do
+    it "should execute an HTTP HEAD request using the default adapter" do
+      request = HTTPI::Request.new
+      default_adapter.any_instance.expects(:head).with(request)
+      
+      client.head request
+    end
+  end
+
+  describe ".head(request, adapter)" do
+    it "should execute an HTTP HEAD request using the given adapter" do
+      request = HTTPI::Request.new
+      curb.any_instance.expects(:head).with(request)
+      
+      client.head request, :curb
+    end
+  end
+
+  describe ".head(url)" do
+    it "should execute an HTTP HEAD request using the default adapter" do
+      HTTPI::Request.any_instance.expects(:url=).with("http://example.com")
+      default_adapter.any_instance.expects(:head).with(instance_of(HTTPI::Request))
+      
+      client.head "http://example.com"
+    end
+  end
+
+  describe ".head(url, adapter)" do
+    it "should execute an HTTP HEAD request using the given adapter" do
+      HTTPI::Request.any_instance.expects(:url=).with("http://example.com")
+      curb.any_instance.expects(:head).with(instance_of(HTTPI::Request))
+      
+      client.head "http://example.com", :curb
+    end
+  end
+
+  describe ".head" do
+    it_should_behave_like "a request method"
+  end
+
+  describe ".put(request)" do
+    it "should execute an HTTP PUT request using the default adapter" do
+      request = HTTPI::Request.new
+      default_adapter.any_instance.expects(:put).with(request)
+      
+      client.put request
     end
+  end
 
-    it "should raise an ArgumentError in case of an invalid adapter" do
-      lambda { client.post HTTPI::Request.new, :invalid }.should raise_error(ArgumentError)
+  describe ".put(request, adapter)" do
+    it "should execute an HTTP PUT request using the given adapter" do
+      request = HTTPI::Request.new
+      curb.any_instance.expects(:put).with(request)
+      
+      client.put request, :curb
     end
+  end
 
-    it "should raise an ArgumentError in case of an invalid URL" do
-      lambda { client.post "invalid" }.should raise_error(ArgumentError)
+  describe ".put(url, body)" do
+    it "should execute an HTTP PUT request using the default adapter" do
+      HTTPI::Request.any_instance.expects(:url=).with("http://example.com")
+      HTTPI::Request.any_instance.expects(:body=).with("<some>xml</some>")
+      default_adapter.any_instance.expects(:put).with(instance_of(HTTPI::Request))
+      
+      client.put "http://example.com", "<some>xml</some>"
     end
   end
 
+  describe ".put(url, body, adapter)" do
+    it "should execute an HTTP PUT request using the given adapter" do
+      HTTPI::Request.any_instance.expects(:url=).with("http://example.com")
+      HTTPI::Request.any_instance.expects(:body=).with("<some>xml</some>")
+      curb.any_instance.expects(:put).with(instance_of(HTTPI::Request))
+      
+      client.put "http://example.com", "<some>xml</some>", :curb
+    end
+  end
+
+  describe ".put" do
+    it_should_behave_like "a request method"
+  end
+
+  describe ".delete(request)" do
+    it "should execute an HTTP DELETE request using the default adapter" do
+      request = HTTPI::Request.new
+      default_adapter.any_instance.expects(:delete).with(request)
+      
+      client.delete request
+    end
+  end
+
+  describe ".delete(request, adapter)" do
+    it "should execute an HTTP DELETE request using the given adapter" do
+      request = HTTPI::Request.new
+      curb.any_instance.expects(:delete).with(request)
+      
+      client.delete request, :curb
+    end
+  end
+
+  describe ".delete(url)" do
+    it "should execute an HTTP DELETE request using the default adapter" do
+      HTTPI::Request.any_instance.expects(:url=).with("http://example.com")
+      default_adapter.any_instance.expects(:delete).with(instance_of(HTTPI::Request))
+      
+      client.delete "http://example.com"
+    end
+  end
+
+  describe ".delete(url, adapter)" do
+    it "should execute an HTTP DELETE request using the given adapter" do
+      HTTPI::Request.any_instance.expects(:url=).with("http://example.com")
+      curb.any_instance.expects(:delete).with(instance_of(HTTPI::Request))
+      
+      client.delete "http://example.com", :curb
+    end
+  end
+  
+  describe ".delete" do
+    it_should_behave_like "a request method"
+  end
+
 end

data/spec/httpi/request_spec.rb

@@ -99,6 +99,65 @@ describe HTTPI::Request do
       request.basic_auth nil
       request.basic_auth.should be_nil
     end
- end
+  end
+
+  describe "#digest_auth" do
+    it "lets you specify the digest auth credentials" do
+      request.digest_auth "username", "password"
+      request.digest_auth.should == ["username", "password"]
+    end
+   
+    it "also accepts an Array of credentials" do
+      request.digest_auth ["username", "password"]
+      request.digest_auth.should == ["username", "password"]
+    end
+
+    it "lets you reset the credentials" do
+      request.digest_auth "username", "password"
+      request.digest_auth.should == ["username", "password"]
 
+      request.digest_auth nil
+      request.digest_auth.should be_nil
+    end
+  end
+
+  describe "#auth?" do
+    it "should return false unless any authentication credentials were specified" do
+      request.auth?.should be_false
+    end
+
+    it "should return true if HTTP basic auth authentication credentials were specified" do
+      request.basic_auth "username", "password"
+      request.auth?.should be_true
+    end
+
+    it "should return true if HTTP digest auth authentication credentials were specified" do
+      request.digest_auth "username", "password"
+      request.auth?.should be_true
+    end
+  end
+
+  describe "#credentials" do
+    it "return the credentials for HTTP basic auth" do
+      request.basic_auth "username", "basic"
+      request.credentials.should == ["username", "basic"]
+    end
+
+    it "return the credentials for HTTP digest auth" do
+      request.digest_auth "username", "digest"
+      request.credentials.should == ["username", "digest"]
+    end
+  end
+
+  describe "#auth_type" do
+    it "should return :basic for HTTP basic auth" do
+      request.basic_auth "username", "password"
+      request.auth_type.should == :basic
+    end
+
+    it "should return :digest for HTTP basic auth" do
+      request.digest_auth "username", "password"
+      request.auth_type.should == :digest
+    end
+  end
 end

data/spec/integration/request_spec.rb

@@ -0,0 +1,68 @@
+require "spec_helper"
+require "httpi"
+
+describe HTTPI do
+  let(:client) { HTTPI }
+
+  # Uses example.com for basic request methods and webdav.org
+  # for HTTP basic and digest authentication.
+  #
+  # http://example.com
+  # http://test.webdav.org
+
+  before :all do
+    @username = @password = "user1"
+    @error_message = "Authorization Required"
+    @example_web_page = "Example Web Page"
+  end
+
+  HTTPI::Adapter.adapters.keys.each do |adapter|
+    context "using :#{adapter}" do
+      it "should execute an HTTP GET request" do
+        response = HTTPI.get "http://example.com", adapter
+        response.body.should include(@example_web_page)
+      end
+
+      it "should execute an HTTP POST request" do
+        response = HTTPI.post "http://example.com", "<some>xml</some>", adapter
+        response.body.should include(@example_web_page)
+      end
+
+      it "should execute an HTTP HEAD request" do
+        response = HTTPI.head "http://example.com", adapter
+        response.code.should == 200
+      end
+
+      it "should execute an HTTP PUT request" do
+        response = HTTPI.put "http://example.com", "<some>xml</some>", adapter
+        response.body.should include("PUT is not allowed")
+      end
+
+      it "should execute an HTTP DELETE request" do
+        response = HTTPI.delete "http://example.com", adapter
+        response.body.should include("DELETE is not allowed")
+      end
+
+      context "with HTTP basic authentication" do
+        it "requires a username and password" do
+          request = HTTPI::Request.new :url => "http://test.webdav.org/auth-basic/"
+          request.basic_auth @username, @password
+          
+          response = HTTPI.get request, adapter
+          response.body.should_not include(@error_message)
+        end
+      end
+
+      context "with HTTP digest authentication" do
+        it "requires a username and password" do
+          request = HTTPI::Request.new :url => "http://test.webdav.org/auth-digest/"
+          request.digest_auth @username, @password
+          
+          response = HTTPI.get request, adapter
+          response.body.should_not include(@error_message)
+        end
+      end
+    end
+  end
+
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: httpi
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 15
   prerelease: false
   segments: 
   - 0
-  - 3
+  - 4
   - 0
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Daniel Harrington
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-24 00:00:00 +02:00
+date: 2010-09-25 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -96,8 +96,10 @@ extra_rdoc_files: []
 files: 
 - Gemfile
 - Gemfile.lock
+- LICENSE
 - Rakefile
 - README.md
+- .autotest
 - .rspec
 - autotest/discover.rb
 - lib/httpi/adapter/curb.rb
@@ -115,6 +117,7 @@ files:
 - spec/httpi/httpi_spec.rb
 - spec/httpi/request_spec.rb
 - spec/httpi/response_spec.rb
+- spec/integration/request_spec.rb
 - spec/spec_helper.rb
 - spec/support/fixture.rb
 - spec/support/matchers.rb