httpi 0.1.0 → 0.2.0

data/lib/httpi/request.rb

@@ -0,0 +1,73 @@
+require "uri"
+
+module HTTPI
+  class Request
+
+    # Request accessor methods.
+    ACCESSORS = [:url, :proxy, :headers, :body, :open_timeout, :read_timeout]
+
+    # Request authentication methods.
+    AUTHENTICATION = [:basic_auth]
+
+    # Accepts a Hash of +options+ which may contain any number of ACCESSORS and/or
+    # AUTHENTICATION credentials to set.
+    def initialize(options = {})
+      assign_accessors options
+      assign_authentication options
+    end
+
+    # Sets the +url+ to access. Raises an +ArgumentError+ unless the +url+ is valid.
+    def url=(url)
+      @url = normalize_url! url
+    end
+
+    # Returns the +url+ to access.
+    attr_reader :url
+
+    # Sets the +proxy+ to use. Raises an +ArgumentError+ unless the +proxy+ is valid.
+    def proxy=(proxy)
+      @proxy = normalize_url! proxy
+    end
+
+    # Returns the +proxy+ to use.
+    attr_reader :proxy
+
+    # Returns a Hash of HTTP headers. Defaults to return an empty Hash.
+    def headers
+      @headers ||= {}
+    end
+
+    # Sets the Hash of HTTP headers.
+    attr_writer :headers
+
+    attr_accessor :body, :open_timeout, :read_timeout
+
+    # 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)
+      @basic_auth = extract_credentials @basic_auth, args.flatten
+    end
+
+ private
+
+    def assign_accessors(options)
+      ACCESSORS.each { |a| send("#{a}=", options[a]) if options[a] }
+    end
+ 
+    def assign_authentication(options)
+      AUTHENTICATION.each { |c| send(c, options[c]) if options[c] }
+    end
+ 
+    def normalize_url!(url)
+      raise ArgumentError, "Invalid URL: #{url}" unless url.to_s =~ /^http/
+      url.kind_of?(URI) ? url : URI(url)
+    end
+
+    def extract_credentials(credentials, args)
+      return unless args.empty? || args.first
+      args[1] ? args[0, 2] : credentials
+    end
+
+  end
+end

data/lib/httpi/version.rb

@@ -1,5 +1,5 @@
 module HTTPI
 
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 
 end

data/spec/fixtures/xml.xml

@@ -0,0 +1,10 @@
+<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:ex="http://service.example.com/">
+  <soapenv:Header/>
+  <soapenv:Body>
+    <ex:findUser>
+      <request>
+        <id>1</id>
+      </request>
+    </ex:findUser>
+  </soapenv:Body>
+</soapenv:Envelope>

data/spec/httpi/adapter/curb_spec.rb

@@ -1,89 +1,49 @@
 require "spec_helper"
 require "httpi/adapter/curb"
+require "httpi/request"
+
+require "curb"
 
 describe HTTPI::Adapter::Curb do
-  before do
-    @adapter = Class.new { include HTTPI::Adapter::Curb }.new
-  end
+  let(:adapter) { HTTPI::Adapter::Curb.new }
 
-  describe "#setup" do
+  describe ".new" do
     it "should require the Curb gem" do
-      @adapter.expects(:require).with("curb")
-      @adapter.setup
+      HTTPI::Adapter::Curb.any_instance.expects(:require).with("curb")
+      HTTPI::Adapter::Curb.new
     end
   end
 
-  context "after #setup:" do
-    before { @adapter.setup }
-
-    describe "#client" do
-      it "should return a memoized Curl::Easy instance" do
-        client = @adapter.client
-        
-        client.should be_an(Curl::Easy)
-        client.should equal(@adapter.client)
-      end
-    end
-
-    describe "#headers" do
-      it "should default to return an empty Hash" do
-        @adapter.headers.should == {}
-      end
-    end
-
-    describe "#headers=" do
-      it "should set a given Hash of HTTP headers" do
-        @adapter.headers = Some.headers
-        @adapter.headers.should == Some.headers
-      end
+  describe "#get" do
+    before do
+      curb.expects(:http_get)
+      curb.expects(:response_code).returns(200)
+      curb.expects(:headers).returns(Hash.new)
+      curb.expects(:body_str).returns(Fixture.xml)
     end
 
-    describe "#proxy" do
-      it "should set the proxy server to use" do
-        @adapter.proxy = Some.proxy_url
-        @adapter.proxy.should == URI(Some.proxy_url)
-      end
-
-      it "should accept a URI" do
-        @adapter.proxy = URI(Some.proxy_url)
-        @adapter.proxy.should == URI(Some.proxy_url)
-      end
+    it "should return a valid HTTPI::Response" do
+      request = HTTPI::Request.new :url => "http://example.com"
+      adapter.get(request).should be_a_valid_httpi_response
     end
+  end
 
-    describe "#auth" do
-      it "should set authentication credentials" do
-        @adapter.client.expects(:username=).with("username")
-        @adapter.client.expects(:password=).with("password")
-        
-        @adapter.auth "username", "password"
-      end
+  describe "#post" do
+    before do
+      curb.expects(:http_post)
+      curb.expects(:response_code).returns(200)
+      curb.expects(:headers).returns(Hash.new)
+      curb.expects(:body_str).returns(Fixture.xml)
     end
 
-    describe "#get" do
-      before do
-        @adapter.client.expects(:http_get)
-        @adapter.client.expects(:response_code).returns(Some.response_code)
-        @adapter.client.expects(:headers).returns(Some.headers)
-        @adapter.client.expects(:body_str).returns(Fixture.xml)
-      end
-
-      it "should return a valid HTTPI::Response" do
-        @adapter.get(Some.url).should be_a_valid_httpi_response
-      end
+    it "should return a valid HTTPI::Response" do
+      request = HTTPI::Request.new :url => "http://example.com"
+      adapter.post(request).should be_a_valid_httpi_response
     end
+  end
 
-   describe "#post" do
-     before do
-       @adapter.client.expects(:http_post)
-       @adapter.client.expects(:response_code).returns(Some.response_code)
-       @adapter.client.expects(:headers).returns(Some.headers)
-       @adapter.client.expects(:body_str).returns(Fixture.xml)
-     end
-
-     it "should return a valid HTTPI::Response" do
-       @adapter.post(Some.url, Fixture.xml).should be_a_valid_httpi_response
-     end
-   end
+  def curb
+    Curl::Easy.any_instance
   end
 
 end

data/spec/httpi/adapter/httpclient_spec.rb

@@ -1,86 +1,45 @@
 require "spec_helper"
 require "httpi/adapter/httpclient"
+require "httpi/request"
+
+require "httpclient"
 
 describe HTTPI::Adapter::HTTPClient do
-  before do
-    @adapter = Class.new { include HTTPI::Adapter::HTTPClient }.new
-  end
+  let(:adapter) { HTTPI::Adapter::HTTPClient.new }
 
-  describe "#setup" do
+  describe ".new" do
     it "should require the HTTPClient gem" do
-      @adapter.expects(:require).with("httpclient")
-      @adapter.setup
+      HTTPI::Adapter::HTTPClient.any_instance.expects(:require).with("httpclient")
+      HTTPI::Adapter::HTTPClient.new
     end
   end
 
-  context "after #setup:" do
-    before { @adapter.setup }
-
-    describe "#client" do
-      it "should return a memoized HTTPClient instance" do
-        client = @adapter.client
-        
-        client.should be_an(HTTPClient)
-        client.should equal(@adapter.client)
-      end
+  describe "#get" do
+    before do
+      @request = HTTPI::Request.new :url => "http://example.com"
+      response = HTTP::Message.new_response Fixture.xml
+      httpclient.expects(:get).with(@request.url, nil, @request.headers).returns(response)
     end
 
-    describe "#headers" do
-      it "should default to return an empty Hash" do
-        @adapter.headers.should == {}
-      end
-    end
-
-    describe "#headers=" do
-      it "should set a given Hash of HTTP headers" do
-        @adapter.headers = Some.headers
-        @adapter.headers.should == Some.headers
-      end
-    end
-
-    describe "#proxy" do
-      it "should set the proxy server to use" do
-        @adapter.proxy = Some.proxy_url
-        @adapter.proxy.should == URI(Some.proxy_url)
-      end
-
-      it "should accept a URI" do
-        @adapter.proxy = URI(Some.proxy_url)
-        @adapter.proxy.should == URI(Some.proxy_url)
-      end
+    it "should return a valid HTTPI::Response" do
+      adapter.get(@request).should be_a_valid_httpi_response
     end
+  end
 
-    describe "#auth" do
-      it "should set authentication credentials" do
-        @adapter.client.expects(:set_auth).with(nil, "username", "password")
-        @adapter.auth "username", "password"
-      end
+  describe "#post" do
+    before do
+      @request = HTTPI::Request.new :url => "http://example.com", :body => Fixture.xml
+      response = HTTP::Message.new_response Fixture.xml
+      httpclient.expects(:post).with(@request.url, @request.body, @request.headers).returns(response)
     end
 
-    describe "#get" do
-      before do
-        response = HTTP::Message.new_response Fixture.xml
-        response.header.add *Some.headers.to_a.first
-        @adapter.client.expects(:get).with(Some.url).returns(response)
-      end
-
-      it "should return a valid HTTPI::Response" do
-        @adapter.get(Some.url).should be_a_valid_httpi_response
-      end
+    it "should return a valid HTTPI::Response" do
+      adapter.post(@request).should be_a_valid_httpi_response
     end
+  end
 
-    describe "#post" do
-      before do
-        response = HTTP::Message.new_response Fixture.xml
-        response.header.add *Some.headers.to_a.first
-        @adapter.headers = Some.headers
-        @adapter.client.expects(:post).with(Some.url, Fixture.xml, Some.headers).returns(response)
-      end
-
-      it "should return a valid HTTPI::Response" do
-        @adapter.post(Some.url, Fixture.xml).should be_a_valid_httpi_response
-      end
-    end
+  def httpclient
+    HTTPClient.any_instance
   end
 
 end

data/spec/httpi/adapter_spec.rb

@@ -2,31 +2,30 @@ require "spec_helper"
 require "httpi/adapter"
 
 describe HTTPI::Adapter do
+  let(:adapter) { HTTPI::Adapter }
 
   describe ".use" do
     it "should default to HTTPClient" do
-      HTTPI::Adapter.use.should == :httpclient
+      adapter.use.should == :httpclient
     end
-  end
-
-  describe ".use=" do
+    
     it "should accept an adapter to use" do
-      HTTPI::Adapter.use = :curb
-      HTTPI::Adapter.use.should == :curb
+      adapter.use = :curb
+      adapter.use.should == :curb
       
       # reset to default
-      HTTPI::Adapter.use = HTTPI::Adapter::DEFAULT
+      adapter.use = HTTPI::Adapter::DEFAULT
     end
 
     it "should raise an ArgumentError in case of an invalid adapter" do
-      lambda { HTTPI::Adapter.use = :unknown }.should raise_error(ArgumentError)
+      lambda { adapter.use = :unknown }.should raise_error(ArgumentError)
     end
   end
 
   describe ".adapters" do
     it "should return a memoized Hash of adapters" do
-      HTTPI::Adapter.adapters.should have(2).items
-      HTTPI::Adapter.adapters.should include(
+      adapter.adapters.should have(2).items
+      adapter.adapters.should include(
         :httpclient => HTTPI::Adapter::HTTPClient,
         :curb => HTTPI::Adapter::Curb
       )
@@ -35,11 +34,11 @@ describe HTTPI::Adapter do
 
   describe ".find" do
     it "should return the adapter for a given Symbol" do
-      HTTPI::Adapter.find(:httpclient).should == HTTPI::Adapter::HTTPClient
+      adapter.find(:httpclient).should == HTTPI::Adapter::HTTPClient
     end
 
     it "should raise an ArgumentError in case of an invalid adapter" do
-      lambda { HTTPI::Adapter.find :unknown }.should raise_error(ArgumentError)
+      lambda { adapter.find :unknown }.should raise_error(ArgumentError)
     end
   end
 

data/spec/httpi/client_spec.rb

@@ -2,20 +2,101 @@ require "spec_helper"
 require "httpi"
 
 describe HTTPI::Client do
+  let(:client) { HTTPI::Client }
+  let(:default_adapter) { HTTPI::Adapter.find HTTPI::Adapter.use }
+  let(:curb) { HTTPI::Adapter.find :curb }
 
-  describe ".new" do
-    it "should default to use HTTPI::Adapter::DEFAULT" do
-      @httpi = HTTPI::Client.new
-      @httpi.client.should be_an(HTTPClient)
+  describe ".get(request)" do
+    it "should execute an HTTP GET request using the default adapter" do
+      request = HTTPI::Request.new
+      default_adapter.any_instance.expects(:get).with(request)
+      
+      client.get request
     end
+  end
 
-    it "should accept an adapter to use" do
-      @httpi = HTTPI::Client.new :curb
-      @httpi.client.should be_a(Curl::Easy)
+  describe ".get(request, adapter)" do
+    it "should execute an HTTP GET request using the given adapter" do
+      request = HTTPI::Request.new
+      curb.any_instance.expects(:get).with(request)
+      
+      client.get request, :curb
     end
+  end
 
+  describe ".get(url)" do
+    it "should execute an HTTP GET request using the default adapter" do
+      HTTPI::Request.any_instance.expects(:url=).with("http://example.com")
+      default_adapter.any_instance.expects(:get).with(instance_of(HTTPI::Request))
+      
+      client.get "http://example.com"
+    end
+  end
+
+  describe ".get(url, adapter)" do
+    it "should execute an HTTP GET request using the given adapter" do
+      HTTPI::Request.any_instance.expects(:url=).with("http://example.com")
+      curb.any_instance.expects(:get).with(instance_of(HTTPI::Request))
+      
+      client.get "http://example.com", :curb
+    end
+  end
+  
+  describe ".get" do
     it "should raise an ArgumentError in case of an invalid adapter" do
-      lambda { HTTPI::Client.new :unknown }.should raise_error(ArgumentError)
+      lambda { client.get 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)
+    end
+  end
+
+  describe ".post(request)" do
+    it "should execute an HTTP POST request using the default adapter" do
+      request = HTTPI::Request.new
+      default_adapter.any_instance.expects(:post).with(request)
+      
+      client.post request
+    end
+  end
+
+  describe ".post(request, adapter)" do
+    it "should execute an HTTP POST request using the given adapter" do
+      request = HTTPI::Request.new
+      curb.any_instance.expects(:post).with(request)
+      
+      client.post request, :curb
+    end
+  end
+
+  describe ".post(url, body)" do
+    it "should execute an HTTP POST 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(:post).with(instance_of(HTTPI::Request))
+      
+      client.post "http://example.com", "<some>xml</some>"
+    end
+  end
+
+  describe ".post(url, body, adapter)" do
+    it "should execute an HTTP POST 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(:post).with(instance_of(HTTPI::Request))
+      
+      client.post "http://example.com", "<some>xml</some>", :curb
+    end
+  end
+
+  describe ".post" do
+    it "should raise an ArgumentError in case of an invalid adapter" do
+      lambda { client.post HTTPI::Request.new, :invalid }.should raise_error(ArgumentError)
+    end
+
+    it "should raise an ArgumentError in case of an invalid URL" do
+      lambda { client.post "invalid" }.should raise_error(ArgumentError)
     end
   end