giant_client 0.1.0

data/lib/giant_client/curb_adapter.rb

@@ -0,0 +1,56 @@
+require 'giant_client/abstract_adapter'
+require 'curb'
+
+class GiantClient
+  class CurbAdapter < AbstractAdapter
+    CRLF = /\r\n/
+    HEADER_SPLIT = /:\s*/
+
+    def request(method, opts)
+
+      if BODYLESS_METHODS.include?(method)
+        raise GiantClient::Error::NotImplemented unless opts[:body] == ''
+      end
+
+      url = url_from_opts(opts)
+
+      if method == :post
+        post_body = opts[:body]
+      elsif method == :put
+        put_data = opts[:body]
+      end
+
+      begin
+        response = Curl.http( method.upcase, url, post_body, put_data ) do |curl|
+          curl.headers = opts[:headers]
+          curl.timeout = opts[:timeout]
+          curl.connect_timeout = opts[:timeout]
+        end
+      rescue Curl::Err::TimeoutError
+        raise GiantClient::Error::Timeout, "the request timed out (timeout: #{opts[:timeout]}"
+      end
+
+      normalize_response(response)
+    end
+
+    def normalize_response(response)
+      status_code = response.response_code
+      headers = parse_out_headers(response.header_str)
+      body = response.body_str
+      Response.new(status_code, headers, body)
+    end
+
+    def parse_out_headers(header_string)
+      headers = {}
+      pairs = header_string.split(CRLF)
+      pairs.shift
+      pairs.each do |pair|
+        header, value = *pair.split(HEADER_SPLIT, 2)
+        header = normalize_header(header)
+        headers[header] = value
+      end
+      headers
+    end
+
+  end
+end

data/lib/giant_client/error.rb

@@ -0,0 +1,8 @@
+class GiantClient
+  class Error < StandardError
+
+    class NotImplemented < Error; end
+    class Timeout        < Error; end
+
+  end
+end

data/lib/giant_client/excon_adapter.rb

@@ -0,0 +1,42 @@
+require 'giant_client/abstract_adapter'
+require 'excon'
+
+class GiantClient
+  class ExconAdapter < AbstractAdapter
+
+    def request(method, opts)
+      if BODYLESS_METHODS.include?(method)
+        raise GiantClient::Error::NotImplemented unless opts[:body] == ''
+      end
+
+      url = url_from_opts(opts)
+
+      params = {}
+      params[:method]  = method.to_s
+      params[:headers] = opts[:headers]
+      params[:body]  = opts[:body]
+      params[:read_timeout]  = opts[:timeout]
+      params[:connect_timeout]  = opts[:timeout]
+      params[:write_timeout]  = opts[:timeout]
+
+      begin
+        response = Excon.new(url).request(params)
+      rescue Excon::Errors::Timeout
+        raise GiantClient::Error::Timeout, "the request timed out (timeout: #{opts[:timeout]}"
+      end
+
+      normalize_response(response)
+    end
+
+    def normalize_response(response)
+      status_code = response.status
+      headers = normalize_header_hash(response.headers)
+      body = response.body
+      Response.new(status_code, headers, body)
+    end
+  end
+end
+
+
+
+

data/lib/giant_client/mock_adapter.rb

@@ -0,0 +1,57 @@
+require 'giant_client/abstract_adapter'
+require 'giant_client/mock_request'
+
+class GiantClient
+  class MockAdapter < AbstractAdapter
+
+    attr_accessor :requests, :responses
+    def initialize
+      @requests = []
+      @responses = []
+    end
+
+    def request(method, opts)
+      last_request = MockRequest.new
+
+      if BODYLESS_METHODS.include?(method)
+        unless opts[:body] == ''
+          last_request.raised_error = true
+          last_request.error_type = GiantClient::Error::NotImplemented
+        end
+      end
+
+      last_request.host = opts[:host]
+      last_request.ssl = opts[:ssl]
+      last_request.port = opts[:port]
+      last_request.path = opts[:path]
+      last_request.query = opts[:query]
+      last_request.headers = opts[:headers]
+      last_request.body = opts[:body]
+      last_request.timeout = opts[:timeout]
+
+      last_request.url = url_from_opts(opts)
+
+      last_request.querystring = stringify_query(opts[:query])
+
+      last_response = { :status_code => 200, :headers => {}, :body => nil }
+
+      @requests.unshift(last_request)
+      @responses.unshift(last_response)
+
+      self
+    end
+
+    def respond_with(hash)
+      @responses[0] = @responses[0].merge(hash)
+    end
+
+    def last_request
+      @requests[0]
+    end
+
+    def last_response
+      @responses[0]
+    end
+
+  end
+end

data/lib/giant_client/mock_request.rb

@@ -0,0 +1,11 @@
+class GiantClient
+  class MockRequest
+    attr_accessor :host, :ssl, :port, :path, :query, :headers, :body, :timeout,
+                  :url, :querystring, :raised_error, :error_type
+
+    def raised_error?
+      @raised_error
+    end
+
+  end
+end

data/lib/giant_client/net_http_adapter.rb

@@ -0,0 +1,55 @@
+require 'giant_client/abstract_adapter'
+require 'net/http'
+
+class GiantClient
+  class NetHttpAdapter < AbstractAdapter
+
+    def request(method, opts)
+      if BODYLESS_METHODS.include?(method)
+        raise GiantClient::Error::NotImplemented unless opts[:body] == ''
+      end
+      query = encode_query(opts[:query])
+
+      http = Net::HTTP.new( opts[:host], opts[:port] )
+      http.use_ssl = opts[:ssl]
+      http.read_timeout = opts[:timeout]
+      http.open_timeout = opts[:timeout]
+
+      request_class =
+        case method
+          when :get then Net::HTTP::Get
+          when :post then Net::HTTP::Post
+          when :put then Net::HTTP::Put
+          when :delete then Net::HTTP::Delete
+          when :head then Net::HTTP::Head
+        end
+
+      request = request_class.new( opts[:path] + query, opts[:headers] )
+
+      if request.request_body_permitted?
+        request.body = opts[:body]
+      end
+
+      begin
+        response = http.start {|http| http.request(request)}
+      rescue Timeout::Error
+        raise GiantClient::Error::Timeout, "the request timed out (timeout: #{opts[:timeout]}"
+      end
+
+      # make response object
+      normalize_response(response)
+    end
+
+    def normalize_response(response)
+      status_code = response.code.to_i
+      headers = {}
+      response.each_header do |header, value|
+        header = normalize_header(header)
+        headers[header] = value
+      end
+      body = response.body
+      Response.new(status_code, headers, body)
+    end
+
+  end
+end

data/lib/giant_client/patron_adapter.rb

@@ -0,0 +1,38 @@
+require 'giant_client/abstract_adapter'
+require 'patron'
+
+class GiantClient
+  class PatronAdapter < AbstractAdapter
+
+    def request(method, opts)
+      if BODYLESS_METHODS.include?(method)
+        raise GiantClient::Error::NotImplemented unless opts[:body] == ''
+      end
+
+      url = url_from_opts(opts)
+
+      http = Patron::Session.new
+      http.timeout = opts[:timeout]
+      http.connect_timeout = opts[:timeout]
+
+      # TODO support all extra options
+      extra_opts = {}
+      extra_opts[:data] = opts[:body]
+      begin
+        response = http.request(method, url, opts[:headers], extra_opts)
+      rescue Patron::TimeoutError
+        raise GiantClient::Error::Timeout, "the request timed out (timeout: #{opts[:timeout]}"
+      end
+
+      normalize_response(response)
+    end
+
+    def normalize_response(response)
+       status_code = response.status
+       headers = normalize_header_hash(response.headers)
+       body = response.body
+       Response.new(status_code, headers, body)
+    end
+
+  end
+end

data/lib/giant_client/response.rb

@@ -0,0 +1,12 @@
+class GiantClient
+  class Response
+    attr_accessor :body, :headers, :status_code
+
+    def initialize(status_code, headers, body)
+      @status_code = status_code
+      @headers = headers
+      @body = body
+    end
+
+  end
+end

data/lib/giant_client/typhoeus_adapter.rb

@@ -0,0 +1,40 @@
+require 'giant_client/abstract_adapter'
+require 'typhoeus'
+
+class GiantClient
+  class TyphoeusAdapter < AbstractAdapter
+
+    def request(method, opts)
+
+      if BODYLESS_METHODS.include?(method)
+        raise GiantClient::Error::NotImplemented unless opts[:body] == ''
+      end
+
+      url = url_from_opts(opts)
+
+      params = {}
+      params[:method] = method
+      params[:headers] = opts[:headers]
+      params[:body] = opts[:body]
+      params[:timeout] = 1000 * opts[:timeout] # typhoeus does milliseconds
+      params[:connect_timeout] = 1000 * opts[:timeout]
+
+      response = Typhoeus::Request.run(url, params)
+
+      if response.curl_return_code == 28 # timeout
+        raise GiantClient::Error::Timeout, "the request timed out (timeout: #{opts[:timeout]}"
+      end
+
+      normalize_response(response)
+
+    end
+
+    def normalize_response(response)
+      status_code = response.code
+      headers = normalize_header_hash(response.headers_hash)
+      body = response.body
+      Response.new(status_code, headers, body)
+    end
+
+  end
+end

data/lib/giant_client/version.rb

@@ -0,0 +1,3 @@
+class GiantClient
+  VERSION = "0.1.0"
+end

data/spec/examples/giant_client_spec.rb

@@ -0,0 +1,299 @@
+require File.expand_path( '../spec_helper', __FILE__ )
+
+describe 'GiantClient' do
+
+  shared_examples "an adapter" do
+
+    context 'GET requests' do
+      let(:client) { GiantClient.new( :host => 'example.com', :adapter => adapter ) }
+
+      it 'should perform a simple GET request' do
+        stub = stub_request(:get, 'example.com')
+        client.get( :path => '/' )
+        stub.should have_been_requested
+      end
+
+      it 'should treat a string argument as a path' do
+        stub = stub_request(:get, 'example.com')
+        client.get( '/' )
+        stub.should have_been_requested
+      end
+
+      it 'should respond with 200' do
+        stub = stub_request(:get, 'example.com')
+                      .to_return(:status => [200, 'OK'])
+        client.get( :path => '/' ).status_code.should == 200
+      end
+
+      it 'should respond with a success header' do
+        stub = stub_request(:get, 'example.com')
+                       .to_return(:headers => {'Success' => 'true'})
+        client.get( :path => '/' ).headers.should == {'Success' => 'true'}
+      end
+
+      it 'should respond with a multiple headers' do
+        stub = stub_request(:get, 'example.com')
+                       .to_return(:headers =>
+                                  {'Success' => 'true', 'doodle' => 'kaboodle'})
+        client.get( :path => '/' ).headers.should ==
+                                      {'Success' => 'true', 'Doodle' => 'kaboodle'}
+      end
+
+      it 'should respond with a header and status, and should capitalize status' do
+        stub = stub_request(:get, 'example.com')
+                       .to_return(:status => 1700, :headers => {'success' => 'true'})
+        client.get( :path => '/' ).headers.should == {'Success' => 'true'}
+        client.get( :path => '/' ).status_code.should == 1700
+      end
+
+      it 'should respond with a body' do
+        stub = stub_request(:get, 'example.com')
+                       .to_return(:body => 'Chucky Cheese')
+        client.get( :path => '/' ).body.should == 'Chucky Cheese'
+      end
+
+      it 'should pass on the port' do
+        stub = stub_request(:get, 'example.com:8080')
+        client.get( :path => '/', :port => '8080' )
+        stub.should have_been_requested
+      end
+
+      it 'should pass on the request headers' do
+        stub = stub_request(:get, 'example.com').with( :headers => { 'Content-Type' => 'text/special' } )
+        client.get( :path => '/', :headers => { 'Content-Type' => 'text/special' } )
+        stub.should have_been_requested
+      end
+
+      it 'should pass on the request params' do
+        stub = stub_request(:get, 'example.com').with( :query => { 'a' => 'b' } )
+        client.get( :path => '/', :query => { 'a' => 'b' } )
+        stub.should have_been_requested
+      end
+
+      it 'should allow a query in the url path' do
+        stub = stub_request(:get, 'example.com').with( :query => { 'z' => 'me' } )
+        client.get( :path => '/?z=me' )
+        stub.should have_been_requested
+      end
+
+      it 'should raise an error if there is a request body' do
+        stub = stub_request(:get, 'example.com').with( :body => 'hey yo' )
+        expect{ client.get( :path => '/', :body => 'hey yo' ) }.to raise_error( GiantClient::Error::NotImplemented )
+      end
+
+      context 'timing out' do
+        let(:client) { GiantClient.new( :host => 'example.com', :adapter => adapter, :timeout => 1 ) }
+
+        it 'should raise a timeout error if there is a timeout' do
+          stub = stub_request(:get, 'example.com').to_timeout
+          expect{ client.get( :path => '/' ) }.to raise_error( GiantClient::Error::Timeout )
+        end
+      end
+
+      context 'ssl' do
+        let(:client) { GiantClient.new( :host => 'example.com', :ssl => true, :adapter => adapter ) }
+
+        it 'should perform a simple get request' do
+          stub = stub_request(:get, 'https://example.com')
+          client.get( :path => '/' )
+          stub.should have_been_requested
+        end
+      end
+
+      context 'custom port' do
+        let(:client) { GiantClient.new( :host => 'example.com', :ssl => true, :port => 8080, :adapter => adapter ) }
+
+        it 'should perform a simple GET request' do
+          stub = stub_request(:get, 'https://example.com:8080')
+          client.get( :path => '/' )
+          stub.should have_been_requested
+        end
+      end
+    end
+
+    context 'POST requests' do
+      let(:client) { GiantClient.new( :host => 'example.com', :adapter => adapter ) }
+
+      it 'should perform a simple POST request' do
+        stub = stub_request(:post, 'example.com')
+        client.post( :path => '/' )
+        stub.should have_been_requested
+      end
+
+      it 'should post the body as well' do
+        stub = stub_request(:post, 'example.com').with( :body => 'woohoo' )
+        client.post( :path => '/', :body => 'woohoo' )
+        stub.should have_been_requested
+      end
+    end
+
+    context 'PUT requests' do
+      let(:client) { GiantClient.new( :host => 'example.com', :adapter => adapter ) }
+
+      it 'should perform a simple PUT request' do
+        stub = stub_request(:put, 'example.com')
+        client.put( :path => '/' )
+        stub.should have_been_requested
+      end
+
+      it 'should perform a PUT request to a specific path' do
+        stub = stub_request(:put, 'example.com/heyyy')
+        client.put( :path => '/heyyy' )
+        stub.should have_been_requested
+      end
+
+      it 'should put the body as well' do
+        stub = stub_request(:put, 'example.com').with( :body => 'woohoo' )
+        client.put( :path => '/', :body => 'woohoo' )
+        stub.should have_been_requested
+      end
+    end
+
+    context 'DELETE requests' do
+      let(:client) { GiantClient.new( :host => 'example.com', :adapter => adapter ) }
+
+      it 'should perform a simple DELETE request' do
+        stub = stub_request(:delete, 'example.com')
+        client.delete( :path => '/' )
+        stub.should have_been_requested
+      end
+
+      it 'should perform a DELETE request to a specific path' do
+        stub = stub_request(:delete, 'example.com/heyyy/how/ya/doin')
+        client.delete( :path => '/heyyy/how/ya/doin' )
+        stub.should have_been_requested
+      end
+
+      it 'should raise an error if there is a request body' do
+        stub = stub_request(:delete, 'example.com').with( :body => 'woohoo' )
+        expect{ client.delete( :path => '/', :body => 'woohoo' ) }.to raise_error( GiantClient::Error::NotImplemented )
+      end
+    end
+
+    context 'HEAD requests' do
+      let(:client) { GiantClient.new( :host => 'example.com', :adapter => adapter ) }
+
+      it 'should perform a simple HEAD request' do
+        stub = stub_request(:head, 'example.com')
+        client.head( :path => '/' )
+        stub.should have_been_requested
+      end
+
+      it 'should perform a HEAD request to a specific path' do
+        stub = stub_request(:head, 'example.com/heyyy/how/ya/doin')
+        client.head( :path => '/heyyy/how/ya/doin' )
+        stub.should have_been_requested
+      end
+
+      it 'should raise an error if there is a request body' do
+        stub = stub_request(:head, 'example.com').with( :body => 'woohoo' )
+        expect{ client.head( :path => '/', :body => 'woohoo' ) }.to raise_error( GiantClient::Error::NotImplemented )
+      end
+    end
+  end
+
+  describe 'NetHttpAdapter' do
+    it_behaves_like 'an adapter' do
+      let(:adapter){ :net_http }
+    end
+  end
+
+  describe 'PatronAdapter' do
+    it_behaves_like 'an adapter' do
+      let(:adapter){ :patron }
+    end
+  end
+
+  describe 'Curb' do
+    it_behaves_like 'an adapter' do
+      let(:adapter){ :curb }
+    end
+  end
+
+  describe 'Excon' do
+    it_behaves_like 'an adapter' do
+      let(:adapter){ :excon }
+    end
+  end
+
+  describe 'Typhoeus' do
+    it_behaves_like 'an adapter' do
+      let(:adapter){ :typhoeus }
+    end
+  end
+
+
+  describe 'AbstractAdapter' do
+
+    let(:adapter){ GiantClient::AbstractAdapter.new }
+
+    describe '#normalize_header' do
+
+      it 'should not touch a header that is already title case' do
+        adapter.normalize_header('Content-Type').should == 'Content-Type'
+      end
+
+      it 'should convert a header to title case' do
+        adapter.normalize_header('content-type').should == 'Content-Type'
+      end
+
+      it 'should only capitalize the first letter of words' do
+        adapter.normalize_header('CONTENT-type').should == 'Content-Type'
+      end
+
+      it 'should work for one word' do
+        adapter.normalize_header('acCEPTS').should == 'Accepts'
+      end
+
+      it 'should downcase appropriately' do
+        adapter.normalize_header('CONTENT-LENGTH').should == 'Content-Length'
+      end
+
+      it 'should handle a another, similar situation' do
+        adapter.normalize_header('x-Forwarded-for').should == 'X-Forwarded-For'
+      end
+    end
+
+    describe '#encode_query' do
+
+      it 'should return empty string from empty hash' do
+        adapter.encode_query({}).should == ''
+      end
+
+      it 'should prefix string argument with ?' do
+        adapter.encode_query('parsnips').should == '?parsnips'
+      end
+
+      it 'should correctly convert hash to query string with ?' do
+        adapter.encode_query({ :tra => "lala", :ha => "za"} )
+                                      .should == '?tra=lala&ha=za'
+      end
+    end
+
+    describe '#url_from_opts' do
+      let(:opts){{
+        :path => '/', :host => 'example.com',
+        :ssl => false, :port => 80,
+        :query => {}, :body => '',
+        :headers => {}
+      }}
+
+      it 'should not have the correct url' do
+        adapter.url_from_opts(opts).should == "http://example.com/"
+      end
+
+      it 'should use ssl if we tell it to' do
+        opts[:ssl] = true
+        adapter.url_from_opts(opts)[0...8].should == "https://"
+      end
+
+      it 'should work with a custom port' do
+        opts[:ssl] = true
+        opts[:port] = 8080
+        adapter.url_from_opts(opts)[19...24].should == ":8080"
+      end
+
+    end
+  end
+
+end