httpi 2.0.0.rc1 → 2.0.0

data/CHANGELOG.md

@@ -1,4 +1,12 @@
-## 2.0.0.rc1
+## 2.0.0 (2012-12-16)
+
+* Feature: [#66](https://github.com/savonrb/httpi/pull/66) adds a `query` method
+  to the request.
+
+* Fix: [#68](https://github.com/savonrb/httpi/issues/68) request does not yield
+  adapter client.
+
+## 2.0.0.rc1 (2012-11-10)
 
 * Feature: [#63](https://github.com/savonrb/httpi/pull/63) adds support for
   EventMachine::HttpRequest. Additional information at [#40](https://github.com/savonrb/httpi/pull/40).

data/Gemfile

@@ -4,7 +4,6 @@ gemspec
 gem "jruby-openssl",                                :platforms => :jruby
 
 # http clients
-gem "mock-server",               :git => "https://github.com/djanowski/mock-server.git"
 gem "httpclient",      "~> 2.3", :require => false
 gem "curb",            "~> 0.8", :require => false, :platforms => :ruby
 gem 'em-http-request',           :require => false, :platforms => [:ruby, :jruby]

data/httpi.gemspec

@@ -10,16 +10,16 @@ Gem::Specification.new do |s|
   s.email       = "me@rubiii.com"
   s.homepage    = "http://github.com/savonrb/#{s.name}"
   s.summary     = "Common interface for Ruby's HTTP libraries"
-  s.description = "HTTPI provides a common interface for Ruby's HTTP libraries"
+  s.description = s.summary
 
   s.rubyforge_project = s.name
 
   s.add_dependency "rack"
 
-  s.add_development_dependency "rake",    "~> 0.9"
-  s.add_development_dependency "rspec",   "~> 2.11"
-  s.add_development_dependency "mocha",   "~> 0.12"
-  s.add_development_dependency "webmock", "~> 1.8"
+  s.add_development_dependency "rake",  "~> 10.0"
+  s.add_development_dependency "rspec", "~> 2.12"
+  s.add_development_dependency "mocha", "~> 0.13"
+  s.add_development_dependency "puma",  ">= 2.0.0.b3"
 
   s.files = `git ls-files`.split("\n")
   s.require_path = "lib"

data/lib/httpi.rb

@@ -85,9 +85,11 @@ module HTTPI
   class NotSupportedError < Error; end
   class NotImplementedError < Error; end
 
+  module ConnectionError; end
+
   class SSLError < Error
     def initialize(message = nil, original = $!)
-      super(message)
+      super(message || original.message)
       @original = original
     end
     attr_reader :original
@@ -96,33 +98,33 @@ module HTTPI
   class << self
 
     # Executes an HTTP GET request.
-    def get(request, adapter = nil)
+    def get(request, adapter = nil, &block)
       request = Request.new(request) if request.kind_of? String
-      request(:get, request, adapter)
+      request(:get, request, adapter, &block)
     end
 
     # Executes an HTTP POST request.
-    def post(*args)
+    def post(*args, &block)
       request, adapter = request_and_adapter_from(args)
-      request(:post, request, adapter)
+      request(:post, request, adapter, &block)
     end
 
     # Executes an HTTP HEAD request.
-    def head(request, adapter = nil)
+    def head(request, adapter = nil, &block)
       request = Request.new(request) if request.kind_of? String
-      request(:head, request, adapter)
+      request(:head, request, adapter, &block)
     end
 
     # Executes an HTTP PUT request.
-    def put(*args)
+    def put(*args, &block)
       request, adapter = request_and_adapter_from(args)
-      request(:put, request, adapter)
+      request(:put, request, adapter, &block)
     end
 
     # Executes an HTTP DELETE request.
-    def delete(request, adapter = nil)
+    def delete(request, adapter = nil, &block)
       request = Request.new(request) if request.kind_of? String
-      request(:delete, request, adapter)
+      request(:delete, request, adapter, &block)
     end
 
     # Executes an HTTP request for the given +method+.

data/lib/httpi/adapter/curb.rb

@@ -34,6 +34,9 @@ module HTTPI
         raise SSLError
       rescue Curl::Err::SSLPeerCertificateError
         raise SSLError
+      rescue Curl::Err::ConnectionFailedError  # connection refused
+        $!.extend ConnectionError
+        raise
       end
 
       private

data/lib/httpi/adapter/httpclient.rb

@@ -26,6 +26,9 @@ module HTTPI
         respond_with @client.request(method, @request.url, nil, @request.body, @request.headers)
       rescue OpenSSL::SSL::SSLError
         raise SSLError
+      rescue Errno::ECONNREFUSED   # connection refused
+        $!.extend ConnectionError
+        raise
       end
 
       private

data/lib/httpi/adapter/net_http.rb

@@ -34,6 +34,9 @@ module HTTPI
         end
       rescue OpenSSL::SSL::SSLError
         raise SSLError
+      rescue Errno::ECONNREFUSED   # connection refused
+        $!.extend ConnectionError
+        raise
       end
 
       private

data/lib/httpi/request.rb

@@ -31,6 +31,21 @@ module HTTPI
     # Returns the +url+ to access.
     attr_reader :url
 
+    # Sets the +query+ from +url+. Raises an +ArgumentError+ unless the +url+ is valid.
+    def query=(query)
+      raise ArgumentError, "Invalid URL: #{self.url}" unless self.url.respond_to?(:query)
+      if query.kind_of?(Hash)
+        query = Rack::Utils.build_query(query)
+      end
+      query = query.to_s unless query.is_a?(String)
+      self.url.query = query
+    end
+
+    # Returns the +query+ from +url+.
+    def query
+      self.url.query if self.url.respond_to?(:query)
+    end
+
     # Sets the +proxy+ to use. Raises an +ArgumentError+ unless the +proxy+ is valid.
     def proxy=(proxy)
       @proxy = normalize_url! proxy

data/lib/httpi/version.rb

@@ -1,5 +1,5 @@
 module HTTPI
 
-  VERSION = "2.0.0.rc1"
+  VERSION = "2.0.0"
 
 end

data/spec/httpi/adapter/net_http_spec.rb

@@ -1,18 +1,92 @@
 require "spec_helper"
-require "httpi/adapter/net_http"
-require "httpi/request"
-
-HTTPI::Adapter.load_adapter(:net_http)
+require "integration/support/server"
 
 describe HTTPI::Adapter::NetHTTP do
 
-  let(:net_http)       { Net::HTTP.any_instance }
-  let(:request)        { HTTPI::Request.new("http://example.com") }
-  let(:basic_response) { { :body => Fixture.xml, :headers => { "Accept-encoding" => "utf-8" } } }
+  subject(:adapter) { :net_http }
+
+  context "http requests" do
+    before :all do
+      @server = IntegrationServer.run
+    end
+
+    after :all do
+      @server.stop
+    end
+
+    it "sends and receives HTTP headers" do
+      request = HTTPI::Request.new(@server.url + "x-header")
+      request.headers["X-Header"] = "HTTPI"
+
+      response = HTTPI.get(request, adapter)
+      response.body.should include("HTTPI")
+    end
+
+    it "executes GET requests" do
+      response = HTTPI.get(@server.url, adapter)
+      response.body.should eq("get")
+      response.headers["Content-Type"].should eq("text/plain")
+    end
+
+    it "executes POST requests" do
+      response = HTTPI.post(@server.url, "<some>xml</some>", adapter)
+      response.body.should eq("post")
+      response.headers["Content-Type"].should eq("text/plain")
+    end
+
+    it "executes HEAD requests" do
+      response = HTTPI.head(@server.url, adapter)
+      response.code.should == 200
+      response.headers["Content-Type"].should eq("text/plain")
+    end
+
+    it "executes PUT requests" do
+      response = HTTPI.put(@server.url, "<some>xml</some>", adapter)
+      response.body.should eq("put")
+      response.headers["Content-Type"].should eq("text/plain")
+    end
+
+    it "executes DELETE requests" do
+      response = HTTPI.delete(@server.url, adapter)
+      response.body.should eq("delete")
+      response.headers["Content-Type"].should eq("text/plain")
+    end
+
+    it "supports basic authentication" do
+      request = HTTPI::Request.new(@server.url + "basic-auth")
+      request.auth.basic("admin", "secret")
+
+      response = HTTPI.get(request, adapter)
+      response.body.should eq("basic-auth")
+    end
+  end
+
+  # it does not support digest auth
+
+  context "https requests" do
+    before :all do
+      @server = IntegrationServer.run(:ssl => true)
+    end
+
+    after :all do
+      @server.stop
+    end
+
+    # it does not raise when no certificate was set up
+
+    it "works when set up properly" do
+      request = HTTPI::Request.new(@server.url)
+      request.auth.ssl.ca_cert_file = IntegrationServer.ssl_ca_file
+
+      response = HTTPI.get(request, adapter)
+      expect(response.body).to eq("get")
+    end
+  end
+
+end
+
 
-  let(:adapter) {
-    HTTPI::Adapter::NetHTTP.new(request)
-  }
+__END__
 
   describe "#request(:get)" do
     it "should return a valid HTTPI::Response" do

data/spec/httpi/error_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+require "support/error_helper"
+
+describe HTTPI do
+  include ErrorHelper
+
+  context "with :httpclient" do
+    it "tags Errno::ECONNREFUSED with HTTPI::ConnectionError" do
+      expect_error(Errno::ECONNREFUSED, "Connection refused - connect(2)").to be_tagged_with(HTTPI::ConnectionError)
+    end
+
+    def fake_error(error, message)
+      request(:httpclient) { |client| client.expects(:request).raises(error, message) }
+    end
+  end
+
+  unless RUBY_PLATFORM =~ /java/
+    context "with :curb" do
+      it "tags Curl::Err::ConnectionFailedError with HTTPI::ConnectionError" do
+        expect_error(Curl::Err::ConnectionFailedError, "Curl::Err::ConnectionFailedError").to be_tagged_with(HTTPI::ConnectionError)
+      end
+
+      def fake_error(error, message)
+        request(:curb) { |client| client.expects(:send).raises(error, message) }
+      end
+    end
+  end
+
+  context "with :net_http" do
+    it "tags Errno::ECONNREFUSED with HTTPI::ConnectionError" do
+      expect_error(Errno::ECONNREFUSED, "Connection refused - connect(2)").to be_tagged_with(HTTPI::ConnectionError)
+    end
+
+    def fake_error(error, message)
+      request(:net_http) { |client| client.expects(:start).raises(error, message) }
+    end
+  end
+
+  def request(adapter)
+    HTTPI.get("http://example.com", adapter) { |client| yield client }
+  end
+
+end

data/spec/httpi/httpi_spec.rb

@@ -1,5 +1,13 @@
 require "spec_helper"
-require "httpi"
+
+# find out why httpi doesn't load these automatically. [dh, 2012-12-15]
+unless RUBY_VERSION < "1.9"
+  require "em-synchrony"
+  require "em-http-request"
+end
+unless RUBY_PLATFORM =~ /java/
+  require "curb"
+end
 
 describe HTTPI do
   let(:client) { HTTPI }
@@ -196,15 +204,19 @@ describe HTTPI do
             :httpclient => lambda { HTTPClient },
             :curb       => lambda { Curl::Easy },
             :net_http   => lambda { Net::HTTP },
-            :em_http    => lambda { EventMachine::WebMockHttpConnection } # in real life: EventMachine::HttpRequest
+            :em_http    => lambda { EventMachine::HttpConnection }
           }
 
           context "using #{adapter}" do
             before { opts[:class].any_instance.expects(:request).with(method) }
 
-            it "yields the HTTP client instance used for the request" do
+            it "#request yields the HTTP client instance" do
               expect { |b| client.request(method, request, adapter, &b) }.to yield_with_args(client_class[adapter].call)
             end
+
+            it "##{method} yields the HTTP client instance" do
+              expect { |b| client.send(method, request, adapter, &b) }.to yield_with_args(client_class[adapter].call)
+            end
           end
         end
       end

data/spec/httpi/request_spec.rb

@@ -43,6 +43,35 @@ describe HTTPI::Request do
     end
   end
 
+  describe "#query" do
+    it "raises an ArgumentError if url not respond to query" do
+      expect { request.query = "q=query" }.to raise_error(ArgumentError)
+    end
+    it "lets you specify query parameter as String" do
+      request.url = "http://example.com"
+      request.query = "q=query"
+      request.url.to_s.should == "http://example.com?q=query"
+    end
+    it "lets you specify query parameter as Hash" do
+      request.url = "http://example.com"
+      request.query = {:q => "query"}
+      request.url.to_s.should == "http://example.com?q=query"
+    end
+    it "getter return nil for invalid url" do
+      request.query.should be_nil
+    end
+    it "getter return String for query parameter as String" do
+      request.url = "http://example.com"
+      request.query = "q=query"
+      request.query.should == "q=query"
+    end
+    it "getter return String for query parameter as Hash" do
+      request.url = "http://example.com"
+      request.query = {:q => "query"}
+      request.query.should == "q=query"
+    end
+  end
+
   describe "#proxy" do
     it "lets you specify the proxy URL to use as a String" do
       request.proxy = "http://proxy.example.com"

data/spec/integration/curb_spec.rb

@@ -0,0 +1,99 @@
+require "spec_helper"
+require "integration/support/server"
+
+describe HTTPI::Adapter::Curb do
+
+  # curb is not supported on jruby
+  unless RUBY_PLATFORM =~ /java/
+
+    subject(:adapter) { :curb }
+
+    context "http requests" do
+      before :all do
+        @server = IntegrationServer.run
+      end
+
+      after :all do
+        @server.stop
+      end
+
+      it "sends and receives HTTP headers" do
+        request = HTTPI::Request.new(@server.url + "x-header")
+        request.headers["X-Header"] = "HTTPI"
+
+        response = HTTPI.get(request, adapter)
+        response.body.should include("HTTPI")
+      end
+
+      it "executes GET requests" do
+        response = HTTPI.get(@server.url, adapter)
+        response.body.should eq("get")
+        response.headers["Content-Type"].should eq("text/plain")
+      end
+
+      it "executes POST requests" do
+        response = HTTPI.post(@server.url, "<some>xml</some>", adapter)
+        response.body.should eq("post")
+        response.headers["Content-Type"].should eq("text/plain")
+      end
+
+      it "executes HEAD requests" do
+        response = HTTPI.head(@server.url, adapter)
+        response.code.should == 200
+        response.headers["Content-Type"].should eq("text/plain")
+      end
+
+      it "executes PUT requests" do
+        response = HTTPI.put(@server.url, "<some>xml</some>", adapter)
+        response.body.should eq("put")
+        response.headers["Content-Type"].should eq("text/plain")
+      end
+
+      it "executes DELETE requests" do
+        response = HTTPI.delete(@server.url, adapter)
+        response.body.should eq("delete")
+        response.headers["Content-Type"].should eq("text/plain")
+      end
+
+      it "supports basic authentication" do
+        request = HTTPI::Request.new(@server.url + "basic-auth")
+        request.auth.basic("admin", "secret")
+
+        response = HTTPI.get(request, adapter)
+        response.body.should eq("basic-auth")
+      end
+
+      it "supports digest authentication" do
+        request = HTTPI::Request.new(@server.url + "digest-auth")
+        request.auth.digest("admin", "secret")
+
+        response = HTTPI.get(request, adapter)
+        response.body.should eq("digest-auth")
+      end
+    end
+
+    context "https requests" do
+      before :all do
+        @server = IntegrationServer.run(:ssl => true)
+      end
+
+      after :all do
+        @server.stop
+      end
+
+      it "raises when no certificate was set up" do
+        expect { HTTPI.post(@server.url, "", adapter) }.to raise_error(HTTPI::SSLError)
+      end
+
+      it "works when set up properly" do
+        request = HTTPI::Request.new(@server.url)
+        request.auth.ssl.ca_cert_file = IntegrationServer.ssl_ca_file
+
+        response = HTTPI.get(request, adapter)
+        expect(response.body).to eq("get")
+      end
+    end
+
+  end
+end
+