jruby-httpclient 0.3.0-java → 0.4.0-java

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.4.0

data/jruby-httpclient.gemspec

@@ -5,12 +5,12 @@
 
 Gem::Specification.new do |s|
   s.name = %q{jruby-httpclient}
-  s.version = "0.3.0"
+  s.version = "0.4.0"
   s.platform = Gem::Platform.new([nil, "java", nil])
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Adam Esterline"]
-  s.date = %q{2011-06-28}
+  s.date = %q{2011-07-01}
   s.description = %q{An HTTP client designed for use with JRuby in a threaded environment}
   s.email = %q{adam@esterlines.com}
   s.extra_rdoc_files = [
@@ -28,16 +28,19 @@ Gem::Specification.new do |s|
     "jruby-httpclient.gemspec",
     "lib/http_client.rb",
     "lib/http_client/client.rb",
+    "lib/http_client/client_configuration.rb",
     "lib/http_client/methods.rb",
-    "lib/http_client/parameters.rb",
+    "lib/http_client/response.rb",
     "test/helper.rb",
     "test/http_client/test_basic_auth.rb",
     "test/http_client/test_basic_client_operations.rb",
+    "test/http_client/test_client_configuration.rb",
     "test/http_client/test_client_headers.rb",
-    "test/http_client/test_client_parameters.rb",
     "test/http_client/test_cookies.rb",
     "test/http_client/test_redirect.rb",
     "test/http_client/test_request_entity.rb",
+    "test/http_client/test_response.rb",
+    "test/http_client/test_server_headers.rb",
     "test/http_test_server.rb",
     "vendor/commons-codec-1.4.jar",
     "vendor/commons-logging-1.1.1.jar",

data/lib/http_client.rb

@@ -12,6 +12,7 @@ require 'httpmime-4.1.1'
 require 'httpclient-4.1.1'
 require 'httpclient-cache-4.1.1'
 
-require 'parameters'
+require 'client_configuration'
+require 'response'
 require 'methods'
 require 'client'

data/lib/http_client/client.rb

@@ -5,53 +5,34 @@ module HTTP
   SocketTimeoutException = java.net.SocketTimeoutException
 
   class Client
-    DEFAULT_TIMEOUT = 30_000
-    include HTTP::Parameters
-
     def initialize(options = {})
-      self.so_timeout = DEFAULT_TIMEOUT
-
-      if options[:disable_response_handler]
-        @response_handler = nil
-      elsif options[:response_handler]
-        @response_handler = options[:response_handler]
-      else
-        @response_handler = BasicResponseHandler.new
-      end
-
-      @encoding = options[:encoding] || "UTF-8"
-
-      # Set options from the rest of the options-hash
-      options.each do |parameter_name, parameter_value|
-        setter_name = "#{parameter_name}="
-        self.send(setter_name, parameter_value) if self.respond_to?(setter_name)
-      end
-
-      @client = DefaultHttpClient.new(params)
+      @client = HTTP::ClientConfiguration.new(options).build_http_client
     end
 
-    # Request Methods
-
     def get(params, options = {})
-      execute(Get.new(params, options))
+      read_response(Get.new(params, options))
     end
 
     def post(params, options = {})
-      execute(Post.new(params, options))
+      read_response(Post.new(params, options))
     end
 
     def delete(path)
-      execute(Delete.new(path))
+      read_response(Delete.new(path))
     end
 
     def put(path)
-      execute(Put.new(path))
+      read_response(Put.new(path))
+    end
+
+    def read_response(request)
+      execute(request).body
     end
 
     def execute(request)
-      request.make_native_request(@client, @encoding, @response_handler)
-    rescue SocketTimeoutException
-      raise Timeout::Error, "timed out after #{so_timeout} ms"
+      request.make_native_request(@client)
+    rescue SocketTimeoutException => e
+      raise Timeout::Error, e.message
     end
 
     def shutdown

data/lib/http_client/client_configuration.rb

@@ -0,0 +1,136 @@
+module HTTP
+  BasicHttpParams = org.apache.http.params.BasicHttpParams
+  HttpHost = org.apache.http.HttpHost
+  CoreProtocolPNames = org.apache.http.params.CoreProtocolPNames
+  CoreConnectionPNames = org.apache.http.params.CoreConnectionPNames
+  ConnRoutePNames = org.apache.http.conn.params.ConnRoutePNames
+  CookieSpecPNames = org.apache.http.cookie.params.CookieSpecPNames
+  AuthPNames = org.apache.http.auth.params.AuthPNames
+  ClientPNames = org.apache.http.client.params.ClientPNames
+  CookiePolicy = org.apache.http.client.params.CookiePolicy
+
+  CLIENT_CONFIGURATION_PARAMETERS = {
+      :protocol_version => HTTP::CoreProtocolPNames::PROTOCOL_VERSION,
+      :strict_transfer_encoding => HTTP::CoreProtocolPNames::STRICT_TRANSFER_ENCODING,
+      :http_element_charset => HTTP::CoreProtocolPNames::HTTP_ELEMENT_CHARSET,
+      :use_expect_continue => HTTP::CoreProtocolPNames::USE_EXPECT_CONTINUE,
+      :wait_for_continue => HTTP::CoreProtocolPNames::WAIT_FOR_CONTINUE,
+      :user_agent => HTTP::CoreProtocolPNames::USER_AGENT,
+      :tcp_nodelay => HTTP::CoreConnectionPNames.TCP_NODELAY,
+      :so_timeout => HTTP::CoreConnectionPNames.SO_TIMEOUT,
+      :so_linger => HTTP::CoreConnectionPNames.SO_LINGER,
+      :so_reuseaddr => HTTP::CoreConnectionPNames.SO_REUSEADDR,
+      :socket_buffer_size => HTTP::CoreConnectionPNames.SOCKET_BUFFER_SIZE,
+      :connection_timeout => HTTP::CoreConnectionPNames.CONNECTION_TIMEOUT,
+      :max_line_length => HTTP::CoreConnectionPNames.MAX_LINE_LENGTH,
+      :max_header_count => HTTP::CoreConnectionPNames.MAX_HEADER_COUNT,
+      :stale_connection_check => HTTP::CoreConnectionPNames.STALE_CONNECTION_CHECK,
+      # :forced_route             => HTTP::ConnRoutePNames::FORCED_ROUTE, # not implemented
+      :local_address => HTTP::ConnRoutePNames::LOCAL_ADDRESS,
+      :default_proxy => HTTP::ConnRoutePNames::DEFAULT_PROXY,
+      :date_patterns => HTTP::CookieSpecPNames::DATE_PATTERNS,
+      :single_cookie_header => HTTP::CookieSpecPNames::SINGLE_COOKIE_HEADER,
+      :credential_charset => HTTP::AuthPNames::CREDENTIAL_CHARSET,
+      :cookie_policy => HTTP::ClientPNames::COOKIE_POLICY,
+      :handle_authentication => HTTP::ClientPNames::HANDLE_AUTHENTICATION,
+      :handle_redirects => HTTP::ClientPNames::HANDLE_REDIRECTS,
+      :max_redirects => HTTP::ClientPNames::MAX_REDIRECTS,
+      :allow_circular_redirects => HTTP::ClientPNames::ALLOW_CIRCULAR_REDIRECTS,
+      :virtual_host => HTTP::ClientPNames::VIRTUAL_HOST,
+      :default_host => HTTP::ClientPNames::DEFAULT_HOST
+      # :default_headers          => HTTP::ClientPNames::DEFAULT_HEADERS, # not implemented
+      # :connection_manager_factory_class_name => HTTP::ClientPNames::CONNECTION_MANAGER_FACTORY_CLASS_NAME # not implemented
+  }
+
+  class ClientConfiguration
+    DEFAULT_TIMEOUT = 30_000
+
+    CLIENT_CONFIGURATION_PARAMETERS.each do |method_name, param_class|
+      define_method(method_name) do
+        params.get_parameter param_class
+      end
+
+      define_method("#{method_name}=") do |arg|
+        arg.add_to_params(params, CLIENT_CONFIGURATION_PARAMETERS[method_name])
+      end
+    end
+
+    def initialize(options = {})
+      self.so_timeout = DEFAULT_TIMEOUT
+
+      options.each do |parameter_name, parameter_value|
+        setter_name = "#{parameter_name}="
+        self.send(setter_name, parameter_value) if self.respond_to?(setter_name)
+      end
+    end
+
+    def build_http_client
+      DefaultHttpClient.new(params)
+    end
+
+    def protocol_version=(version_string)
+      protocol, major_version, minor_version = version_string.split(/[\.|\s|\/]/)
+      params.set_parameter HTTP::CoreProtocolPNames::PROTOCOL_VERSION, org.apache.http.ProtocolVersion.new(protocol, major_version.to_i, minor_version.to_i)
+    end
+
+    def local_address=(local_addr_str)
+      params.set_parameter HTTP::ConnRoutePNames::LOCAL_ADDRESS, java.net.InetAddress.getByName(local_addr_str)
+    end
+
+    def default_proxy=(host)
+      set_host_parameter(HTTP::ConnRoutePNames::DEFAULT_PROXY, host)
+    end
+
+    def virtual_host=(host)
+      set_host_parameter(HTTP::ClientPNames::VIRTUAL_HOST, host)
+    end
+
+    def default_host=(host)
+      set_host_parameter(HTTP::ClientPNames::DEFAULT_HOST, host)
+    end
+
+    def timeout_in_seconds=(timeout)
+      self.so_timeout = timeout * 1000
+    end
+
+    private
+    def set_host_parameter(parameter_name, host)
+      uri = URI.parse host
+      params.set_parameter(parameter_name, HTTP::HttpHost.new(uri.host, uri.port, uri.scheme))
+    end
+
+    def params
+      @params ||= default_params
+    end
+
+    def default_params
+      params = BasicHttpParams.new
+      DefaultHttpClient.set_default_http_params(params)
+      params
+    end
+  end
+end
+
+class Integer
+  def add_to_params(params, param_name)
+    params.set_int_parameter(param_name, self)
+  end
+end
+
+class TrueClass
+  def add_to_params(params, param_name)
+    params.set_boolean_parameter(param_name, self)
+  end
+end
+
+class FalseClass
+  def add_to_params(params, param_name)
+    params.set_boolean_parameter(param_name, self)
+  end
+end
+
+class Object
+  def add_to_params(params, param_name)
+    params.set_parameter(param_name, self)
+  end
+end

data/lib/http_client/methods.rb

@@ -2,86 +2,81 @@ require 'cgi'
 
 module HTTP
   class Request
-    def self.create_type(&native_request_factory)
-      Class.new do
-        def initialize(uri, params = {})
-          @uri = uri
-          @params = params
-          @headers = {}
-        end
-
-        def add_headers(headers)
-          @headers.merge!(headers)
-        end
-
-        def content_type=(type)
-          add_headers({'content-type' => type})
-        end
-
-        def body=(request_body)
-          @body = request_body
-        end
-
-        def basic_auth(username, password)
-          @username = username
-          @password = password
-        end
-
-        def make_native_request(client, encoding, handler=nil)
-          request = create_native_request(encoding)
-          request.entity = StringEntity.new(@body) unless @body.nil?
-
-          unless @username.nil?
-            client.credentials_provider.set_credentials(AuthScope::ANY, UsernamePasswordCredentials.new(@username, @password))
-          end
-
-          if handler
-            client.execute(request, handler)
-          else
-            client.execute(request)
-          end
-        end
-
-        def parse_uri
-          uri = URI.parse(@uri)
-          [uri.scheme, uri.host, uri.port, uri.path, uri.query]
-        rescue URI::InvalidURIError
-          [nil, nil, nil, @uri, nil]
-        end
-
-        private
-        define_method(:create_native_request) do |encoding|
-          scheme, host, port, path, query = parse_uri
-          query_params = CGI.parse(query || "").merge(@params)
-
-          params = query_params.collect { |key, value| BasicNameValuePair.new(key.to_s, value.to_s) }
-          request = native_request_factory.call(scheme, host, port, path, params, encoding)
-
-          @headers.each { |name, value| request.add_header(name.to_s, value.to_s) }
-
-          request
-        end
+    attr_accessor :body, :encoding
+
+    def initialize(uri, params = {})
+      @scheme, @host, @port, @path, query = parse_uri(uri)
+      combined_params = CGI.parse(query || "").merge(params)
+      @query_params = combined_params.collect { |key, value| BasicNameValuePair.new(key.to_s, value.to_s) }
+
+      @encoding = "UTF-8"
+      @headers = {}
+    end
+
+    def add_headers(headers)
+      @headers.merge!(headers)
+    end
+
+    def content_type=(type)
+      add_headers({'content-type' => type})
+    end
+
+    def basic_auth(username, password)
+      @username = username
+      @password = password
+    end
+
+    def make_native_request(client)
+      request = create_native_request
+
+      request.entity = StringEntity.new(@body) unless @body.nil?
+      @headers.each { |name, value| request.add_header(name.to_s, value.to_s) }
+
+      unless @username.nil?
+        client.credentials_provider.set_credentials(AuthScope::ANY, UsernamePasswordCredentials.new(@username, @password))
       end
+
+      HTTP::Response.new(client.execute(request), client.cookie_store.cookies)
+    end
+
+    private
+    def create_uri(query_string = nil)
+      URIUtils.create_uri(@scheme, @host, @port, @path, query_string, nil)
+    end
+
+    def parse_uri(uri)
+      uri = URI.parse(uri)
+      [uri.scheme, uri.host, uri.port, uri.path, uri.query]
+    rescue URI::InvalidURIError
+      [nil, nil, nil, uri, nil]
     end
   end
 
-  Post = Request.create_type do |scheme, host, port, path, params, encoding|
-    post = HttpPost.new(URIUtils.create_uri(scheme, host, port, path, nil, nil))
-    post.entity = UrlEncodedFormEntity.new(params, encoding)
-    post
+  class Post < Request
+    def create_native_request
+      post = HttpPost.new(create_uri)
+      post.entity = UrlEncodedFormEntity.new(@query_params, encoding)
+      post
+    end
   end
 
-  Get = Request.create_type do |scheme, host, port, path, params, encoding|
-    query_string = URLEncodedUtils.format(params, encoding)
-    HttpGet.new(URIUtils.create_uri(scheme, host, port, path, query_string, nil))
+  class Get < Request
+    def create_native_request
+      query_string = URLEncodedUtils.format(@query_params, encoding)
+      HttpGet.new(create_uri(query_string))
+    end
   end
 
-  Delete = Request.create_type do |scheme, host, port, path|
-    HttpDelete.new(URIUtils.create_uri(scheme, host, port, path, nil, nil))
+  class Delete < Request
+    def create_native_request
+      HttpDelete.new(create_uri)
+    end
   end
 
-  Put = Request.create_type do |scheme, host, port, path|
-    HttpPut.new(URIUtils.create_uri(scheme, host, port, path, nil, nil))
+  class Put < Request
+    def create_native_request
+      HttpPut.new(create_uri)
+    end
   end
 
   private

data/lib/http_client/response.rb

@@ -0,0 +1,93 @@
+module HTTP
+  class Response
+    attr_reader :headers, :cookies
+
+    def initialize(native_response, cookies)
+      @native_response = native_response
+      @headers = Headers.new(native_response)
+      @cookies = Cookies.new(cookies)
+    end
+
+    def body
+      @body ||= EntityUtils.to_string(@native_response.entity)
+    end
+
+    def status_code
+      @native_response.status_line.status_code
+    end
+  end
+
+  module Status
+    ACCEPTED = 202
+    BAD_GATEWAY = 502
+    BAD_REQUEST = 400
+    CONFLICT = 409
+    CONTINUE = 100
+    CREATED = 201
+    EXPECTATION_FAILED = 417
+    FAILED_DEPENDENCY = 424
+    FORBIDDEN = 403
+    GATEWAY_TIMEOUT = 504
+    GONE = 410
+    HTTP_VERSION_NOT_SUPPORTED = 505
+    INSUFFICIENT_SPACE_ON_RESOURCE = 419
+    INSUFFICIENT_STORAGE = 507
+    INTERNAL_SERVER_ERROR = 500
+    LENGTH_REQUIRED = 411
+    LOCKED = 423
+    METHOD_FAILURE = 420
+    METHOD_NOT_ALLOWED = 405
+    MOVED_PERMANENTLY = 301
+    MOVED_TEMPORARILY = 302
+    MULTI_STATUS = 207
+    MULTIPLE_CHOICES = 300
+    NO_CONTENT = 204
+    NON_AUTHORITATIVE_INFORMATION = 203
+    NOT_ACCEPTABLE = 406
+    NOT_FOUND = 404
+    NOT_IMPLEMENTED = 501
+    NOT_MODIFIED = 304
+    OK = 200
+    PARTIAL_CONTENT = 206
+    PAYMENT_REQUIRED = 402
+    PRECONDITION_FAILED = 412
+    PROCESSING = 102
+    PROXY_AUTHENTICATION_REQUIRED = 407
+    REQUEST_TIMEOUT = 408
+    REQUEST_TOO_LONG = 413
+    REQUEST_URI_TOO_LONG = 414
+    REQUESTED_RANGE_NOT_SATISFIABLE = 416
+    RESET_CONTENT = 205
+    SEE_OTHER = 303
+    SERVICE_UNAVAILABLE = 503
+    SWITCHING_PROTOCOLS = 101
+    TEMPORARY_REDIRECT = 307
+    UNAUTHORIZED = 401
+    UNPROCESSABLE_ENTITY = 422
+    UNSUPPORTED_MEDIA_TYPE = 415
+    USE_PROXY = 305
+  end
+
+  private
+  EntityUtils = org.apache.http.util.EntityUtils
+
+  class Headers
+    def initialize(native_response)
+      @native_response = native_response
+    end
+
+    def [](header_name)
+      @native_response.get_first_header(header_name).value
+    end
+  end
+
+  class Cookies
+    def initialize(cookies)
+      @cookies = cookies
+    end
+
+    def [](cookie_name)
+      @cookies.find {|cookie| cookie.name == cookie_name }.value
+    end
+  end
+end

data/test/http_client/test_basic_auth.rb

@@ -7,7 +7,7 @@ class BasicAuthTest < Test::Unit::TestCase
 
     response = @client.execute(get)
 
-    assert_equal("Logged In", response)
+    assert_equal("Logged In", response.body)
   end
 
   def setup

data/test/http_client/test_client_configuration.rb

@@ -0,0 +1,142 @@
+require 'helper'
+
+class TestClientConfiguration < Test::Unit::TestCase
+  def test_timeout
+    client = HTTP::Client.new(:default_host => "http://localhost:8080", :timeout_in_seconds => 2)
+
+    assert_raises(Timeout::Error) do
+      client.get("/slow", :sleep => "30")
+    end
+  end
+
+  def test_protocol_version
+    config = HTTP::ClientConfiguration.new(:protocol_version => "HTTP 1.0")
+    assert_equal(config.protocol_version.to_s, "HTTP/1.0")
+  end
+
+  def test_strict_transfer_encodeing
+    config = HTTP::ClientConfiguration.new(:strict_transfer_encoding => true)
+    assert_equal(config.strict_transfer_encoding, true)
+  end
+
+  def test_http_element_charset
+    config = HTTP::ClientConfiguration.new(:http_element_charset => "ASCII")
+    assert_equal(config.http_element_charset, "ASCII")
+  end
+
+  def test_use_expect_continue
+    config = HTTP::ClientConfiguration.new(:use_expect_continue => true)
+    assert_equal(config.use_expect_continue, true)
+  end
+
+  def test_wait_for_continue
+    config = HTTP::ClientConfiguration.new(:wait_for_continue => true)
+    assert_equal(config.wait_for_continue, true)
+  end
+
+  def test_user_agent
+    user_agent_name = "Mozilla/5.0 (Macintosh; U; PPC Mac OS X 10.5; en-US; rv:1.9.0.3) Gecko/2008092414 Firefox/3.0.3"
+    config = HTTP::ClientConfiguration.new(:user_agent => user_agent_name)
+    assert_equal(config.user_agent, user_agent_name)
+  end
+
+  def test_tcp_nodelay
+    config = HTTP::ClientConfiguration.new(:tcp_nodelay => true)
+    assert_equal(config.tcp_nodelay, true)
+  end
+
+  def test_so_linger
+    config = HTTP::ClientConfiguration.new(:so_linger => 3000)
+    assert_equal(config.so_linger, 3000)
+  end
+
+  def test_so_reuseaddr
+    config = HTTP::ClientConfiguration.new(:so_reuseaddr => true)
+    assert_equal(config.so_reuseaddr, true)
+  end
+
+  def test_socket_buffer_size
+    config = HTTP::ClientConfiguration.new(:socket_buffer_size => 10000)
+    assert_equal(config.socket_buffer_size, 10000)
+  end
+
+  def test_connection_timeout
+    config = HTTP::ClientConfiguration.new(:connection_timeout => 2)
+    assert_equal(config.connection_timeout, 2)
+  end
+
+  def test_max_line_length
+    config = HTTP::ClientConfiguration.new(:max_line_length => 2)
+    assert_equal(config.max_line_length, 2)
+  end
+
+  def test_max_header_count
+    config = HTTP::ClientConfiguration.new(:max_header_count => 10)
+    assert_equal(config.max_header_count, 10)
+  end
+
+  def test_stale_connection_check
+    config = HTTP::ClientConfiguration.new(:stale_connection_check => true)
+    assert_equal(config.stale_connection_check, true)
+  end
+
+  def test_local_address
+    config = HTTP::ClientConfiguration.new(:local_address => "127.0.0.1")
+    assert_equal(config.local_address.get_host_address, "127.0.0.1")
+  end
+
+  def test_default_proxy
+    config = HTTP::ClientConfiguration.new(:default_proxy => "http://127.0.0.1:8080")
+    assert_equal(config.default_proxy.to_s, "http://127.0.0.1:8080")
+  end
+
+  def test_date_patterns
+    config = HTTP::ClientConfiguration.new(:date_patterns => ["MDy"])
+    assert(config.date_patterns.include? 'MDy')
+  end
+
+  def test_single_cookie_header
+    config = HTTP::ClientConfiguration.new(:single_cookie_header => true)
+    assert_equal(config.single_cookie_header, true)
+  end
+
+  def test_credential_charset
+    config = HTTP::ClientConfiguration.new(:credential_charset => "ASCII")
+    assert_equal(config.credential_charset, "ASCII")
+  end
+
+  def test_cookie_policy
+    config = HTTP::ClientConfiguration.new(:cookie_policy => "RFC2109")
+    assert_equal(config.cookie_policy, "RFC2109")
+  end
+
+  def test_handle_authentication
+    config = HTTP::ClientConfiguration.new(:handle_authentication => true)
+    assert_equal(config.handle_authentication, true)
+  end
+
+  def test_handle_redirects
+    config = HTTP::ClientConfiguration.new(:handle_redirects => true)
+    assert_equal(config.handle_redirects, true)
+  end
+
+  def test_max_redirects
+    config = HTTP::ClientConfiguration.new(:max_redirects => 1)
+    assert_equal(config.max_redirects, 1)
+  end
+
+  def test_allow_circular_redirects
+    config = HTTP::ClientConfiguration.new(:allow_circular_redirects => true)
+    assert_equal(config.allow_circular_redirects, true)
+  end
+
+  def test_virtual_host
+    config = HTTP::ClientConfiguration.new(:virtual_host => "http://127.0.0.1:80")
+    assert_equal(config.virtual_host.to_s, "http://127.0.0.1:80")
+  end
+
+  def test_default_host
+    config = HTTP::ClientConfiguration.new(:default_host => "http://localhost:8080")
+    assert_equal(config.default_host.to_s, "http://localhost:8080")
+  end
+end

data/test/http_client/test_client_headers.rb

@@ -1,12 +1,12 @@
 require 'helper'
 
-class TestClientHeaders < Test::Unit::TestCase
+class ClientHeadersTest < Test::Unit::TestCase
   def test_get_headers
     get = HTTP::Get.new("/echo_header")
     get.add_headers(:test_header => "get testing")
 
     response = @client.execute(get)
-    assert_equal("get testing", response)
+    assert_equal("get testing", response.body)
   end
 
   def test_post_headers
@@ -14,7 +14,7 @@ class TestClientHeaders < Test::Unit::TestCase
     get.add_headers(:test_header => "post testing")
 
     response = @client.execute(get)
-    assert_equal("post testing", response)
+    assert_equal("post testing", response.body)
   end
 
   def test_delete_headers
@@ -22,7 +22,7 @@ class TestClientHeaders < Test::Unit::TestCase
     get.add_headers(:test_header => "post testing")
 
     response = @client.execute(get)
-    assert_equal("post testing", response)
+    assert_equal("post testing", response.body)
   end
 
   def test_put_headers
@@ -30,7 +30,7 @@ class TestClientHeaders < Test::Unit::TestCase
     get.add_headers(:test_header => "post testing")
 
     response = @client.execute(get)
-    assert_equal("post testing", response)
+    assert_equal("post testing", response.body)
   end
 
   def test_multiple_calls_to_add_headers_should_prefer_last_set_of_headers
@@ -39,7 +39,7 @@ class TestClientHeaders < Test::Unit::TestCase
     get.add_headers(:test_header => "should prefer this one")
 
     response = @client.execute(get)
-    assert_equal("should prefer this one", response)
+    assert_equal("should prefer this one", response.body)
   end
 
   def test_should_be_able_to_add_content_type
@@ -47,7 +47,7 @@ class TestClientHeaders < Test::Unit::TestCase
     get.content_type = 'text/xml'
 
     response = @client.execute(get)
-    assert_equal('text/xml', response)
+    assert_equal('text/xml', response.body)
   end
 
   def setup

data/test/http_client/test_cookies.rb

@@ -8,6 +8,13 @@ class CookieTest < Test::Unit::TestCase
     assert_equal("nom nom nom", result)
   end
 
+  def test_cookie_can_be_retrieved_from_response
+    get = HTTP::Get.new("/set_cookie", :cookie => "yum")
+    response = @client.execute(get)
+
+    assert_equal("yum", response.cookies["test_cookie"])
+  end
+
   def setup
     @client = HTTP::Client.new(:default_host => "http://localhost:8080", :cookie_policy => HTTP::CookiePolicy::BROWSER_COMPATIBILITY)
   end

data/test/http_client/test_request_entity.rb

@@ -5,16 +5,16 @@ class RequestEntityTest < Test::Unit::TestCase
     post = HTTP::Post.new("/body")
     post.body = "Here we are"
 
-    result = @client.execute(post)
-    assert_equal("Here we are", result)
+    response = @client.execute(post)
+    assert_equal("Here we are", response.body)
   end
 
   def test_put_request_body
     post = HTTP::Put.new("/body")
     post.body = "We are there"
 
-    result = @client.execute(post)
-    assert_equal("We are there", result)
+    response = @client.execute(post)
+    assert_equal("We are there", response.body)
   end
 
   def setup

data/test/http_client/test_response.rb

@@ -0,0 +1,24 @@
+require 'helper'
+
+class ResponseTest < Test::Unit::TestCase
+
+  def test_response_body
+    get = HTTP::Get.new("/echo", :content => "baz")
+    response = @client.execute(get)
+    assert_equal("baz", response.body)
+  end
+
+  def test_response_code
+    get = HTTP::Get.new("/echo", :content => "baz")
+    response = @client.execute(get)
+    assert_equal(HTTP::Status::OK, response.status_code)
+  end
+
+  def setup
+    @client = HTTP::Client.new(:default_host => "http://localhost:8080")
+  end
+
+  def teardown
+    @client.shutdown
+  end
+end

data/test/http_client/test_server_headers.rb

@@ -0,0 +1,18 @@
+require 'helper'
+
+class ServerHeadersTest < Test::Unit::TestCase
+  def test_response_contains_server_headers
+    get = HTTP::Get.new("/set_header")
+    response = @client.execute(get)
+
+    assert_equal("FooBar", response.headers["Test-Header"])
+  end
+
+  def setup
+    @client = HTTP::Client.new(:default_host => "http://localhost:8080")
+  end
+
+  def teardown
+    @client.shutdown
+  end
+end

data/test/http_test_server.rb

@@ -11,9 +11,16 @@ module HTTP
       SERVER.mount('/redirect', RedirectServlet)
       SERVER.mount('/set_cookie', SetCookieServlet)
       SERVER.mount('/echo_cookie', EchoCookieServlet)
+      SERVER.mount('/set_header', SetHeaderServlet)
       Thread.new { SERVER.start }
     end
 
+    class SetHeaderServlet < WEBrick::HTTPServlet::AbstractServlet
+      def do_GET(request, response)
+        response["Test-Header"] = "FooBar"
+      end
+    end
+
     class SetCookieServlet < WEBrick::HTTPServlet::AbstractServlet
       def do_GET(request, response)
         response.cookies << WEBrick::Cookie.new("test_cookie", request.query['cookie'])

metadata

@@ -2,7 +2,7 @@
 name: jruby-httpclient
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.3.0
+  version: 0.4.0
 platform: java
 authors: 
   - Adam Esterline
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-28 00:00:00 -06:00
+date: 2011-07-01 00:00:00 -06:00
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency 
@@ -66,16 +66,19 @@ files:
   - jruby-httpclient.gemspec
   - lib/http_client.rb
   - lib/http_client/client.rb
+  - lib/http_client/client_configuration.rb
   - lib/http_client/methods.rb
-  - lib/http_client/parameters.rb
+  - lib/http_client/response.rb
   - test/helper.rb
   - test/http_client/test_basic_auth.rb
   - test/http_client/test_basic_client_operations.rb
+  - test/http_client/test_client_configuration.rb
   - test/http_client/test_client_headers.rb
-  - test/http_client/test_client_parameters.rb
   - test/http_client/test_cookies.rb
   - test/http_client/test_redirect.rb
   - test/http_client/test_request_entity.rb
+  - test/http_client/test_response.rb
+  - test/http_client/test_server_headers.rb
   - test/http_test_server.rb
   - vendor/commons-codec-1.4.jar
   - vendor/commons-logging-1.1.1.jar

data/lib/http_client/parameters.rb

@@ -1,121 +0,0 @@
-module HTTP
-  BasicHttpParams = org.apache.http.params.BasicHttpParams
-  HttpHost = org.apache.http.HttpHost
-  CoreProtocolPNames = org.apache.http.params.CoreProtocolPNames
-  CoreConnectionPNames = org.apache.http.params.CoreConnectionPNames
-  ConnRoutePNames = org.apache.http.conn.params.ConnRoutePNames
-  CookieSpecPNames = org.apache.http.cookie.params.CookieSpecPNames
-  AuthPNames = org.apache.http.auth.params.AuthPNames
-  ClientPNames = org.apache.http.client.params.ClientPNames
-  CookiePolicy = org.apache.http.client.params.CookiePolicy
-
-  module Parameters
-    CLIENT_PARAMETERS = {
-        :protocol_version => HTTP::CoreProtocolPNames::PROTOCOL_VERSION,
-        :strict_transfer_encoding => HTTP::CoreProtocolPNames::STRICT_TRANSFER_ENCODING,
-        :http_element_charset => HTTP::CoreProtocolPNames::HTTP_ELEMENT_CHARSET,
-        :use_expect_continue => HTTP::CoreProtocolPNames::USE_EXPECT_CONTINUE,
-        :wait_for_continue => HTTP::CoreProtocolPNames::WAIT_FOR_CONTINUE,
-        :user_agent => HTTP::CoreProtocolPNames::USER_AGENT,
-        :tcp_nodelay => HTTP::CoreConnectionPNames.TCP_NODELAY,
-        :so_timeout => HTTP::CoreConnectionPNames.SO_TIMEOUT,
-        :so_linger => HTTP::CoreConnectionPNames.SO_LINGER,
-        :so_reuseaddr => HTTP::CoreConnectionPNames.SO_REUSEADDR,
-        :socket_buffer_size => HTTP::CoreConnectionPNames.SOCKET_BUFFER_SIZE,
-        :connection_timeout => HTTP::CoreConnectionPNames.CONNECTION_TIMEOUT,
-        :max_line_length => HTTP::CoreConnectionPNames.MAX_LINE_LENGTH,
-        :max_header_count => HTTP::CoreConnectionPNames.MAX_HEADER_COUNT,
-        :stale_connection_check => HTTP::CoreConnectionPNames.STALE_CONNECTION_CHECK,
-        # :forced_route             => HTTP::ConnRoutePNames::FORCED_ROUTE, # not implemented
-        :local_address => HTTP::ConnRoutePNames::LOCAL_ADDRESS,
-        :default_proxy => HTTP::ConnRoutePNames::DEFAULT_PROXY,
-        :date_patterns => HTTP::CookieSpecPNames::DATE_PATTERNS,
-        :single_cookie_header => HTTP::CookieSpecPNames::SINGLE_COOKIE_HEADER,
-        :credential_charset => HTTP::AuthPNames::CREDENTIAL_CHARSET,
-        :cookie_policy => HTTP::ClientPNames::COOKIE_POLICY,
-        :handle_authentication => HTTP::ClientPNames::HANDLE_AUTHENTICATION,
-        :handle_redirects => HTTP::ClientPNames::HANDLE_REDIRECTS,
-        :max_redirects => HTTP::ClientPNames::MAX_REDIRECTS,
-        :allow_circular_redirects => HTTP::ClientPNames::ALLOW_CIRCULAR_REDIRECTS,
-        :virtual_host => HTTP::ClientPNames::VIRTUAL_HOST,
-        :default_host => HTTP::ClientPNames::DEFAULT_HOST
-        # :default_headers          => HTTP::ClientPNames::DEFAULT_HEADERS, # not implemented
-        # :connection_manager_factory_class_name => HTTP::ClientPNames::CONNECTION_MANAGER_FACTORY_CLASS_NAME # not implemented
-    }
-
-    CLIENT_PARAMETERS.each do |method_name, param_class|
-      define_method(method_name) do
-        params.get_parameter param_class
-      end
-
-      define_method("#{method_name}=") do |arg|
-        arg.add_to_params(params, CLIENT_PARAMETERS[method_name])
-      end
-    end
-
-    def protocol_version=(version_string)
-      protocol, major_version, minor_version = version_string.split(/[\.|\s|\/]/)
-      params.set_parameter HTTP::CoreProtocolPNames::PROTOCOL_VERSION, org.apache.http.ProtocolVersion.new(protocol, major_version.to_i, minor_version.to_i)
-    end
-
-    def local_address=(local_addr_str)
-      params.set_parameter HTTP::ConnRoutePNames::LOCAL_ADDRESS, java.net.InetAddress.getByName(local_addr_str)
-    end
-
-    def default_proxy=(host)
-      set_host_parameter(HTTP::ConnRoutePNames::DEFAULT_PROXY, host)
-    end
-
-    def virtual_host=(host)
-      set_host_parameter(HTTP::ClientPNames::VIRTUAL_HOST, host)
-    end
-
-    def default_host=(host)
-      set_host_parameter(HTTP::ClientPNames::DEFAULT_HOST, host)
-    end
-
-    def timeout_in_seconds=(timeout)
-      self.so_timeout = timeout * 1000
-    end
-
-    private
-    def set_host_parameter(parameter_name, host)
-      uri = URI.parse host
-      params.set_parameter(parameter_name, HTTP::HttpHost.new(uri.host, uri.port, uri.scheme))
-    end
-
-    def params
-      @params ||= default_params
-    end
-
-    def default_params
-      params = BasicHttpParams.new
-      DefaultHttpClient.set_default_http_params(params)
-      params
-    end
-  end
-end
-
-class Integer
-  def add_to_params(params, param_name)
-    params.set_int_parameter(param_name, self)
-  end
-end
-
-class TrueClass
-  def add_to_params(params, param_name)
-    params.set_boolean_parameter(param_name, self)
-  end
-end
-
-class FalseClass
-  def add_to_params(params, param_name)
-    params.set_boolean_parameter(param_name, self)
-  end
-end
-
-class Object
-  def add_to_params(params, param_name)
-    params.set_parameter(param_name, self)
-  end
-end

data/test/http_client/test_client_parameters.rb

@@ -1,201 +0,0 @@
-require 'helper'
-
-class TestClientParameters < Test::Unit::TestCase
-  def test_timeout
-    client = HTTP::Client.new(:default_host => "http://localhost:8080", :timeout_in_seconds => 2)
-
-    assert_raises(Timeout::Error) do
-      client.get("/slow", :sleep => "30")
-    end
-  end
-  
-  def test_protocol_version
-    client = HTTP::Client.new(:default_host => "http://localhost:8080", :protocol_version => "HTTP 1.0")
-    result = client.get("/echo", :content => "hello")
-    # We did set the parameter, right?
-    assert_equal(client.protocol_version.to_s, "HTTP/1.0")
-    # Make sure the client is still working (badly set params would prevent this)
-    assert_equal("hello", result)
-  end
-  
-  def test_strict_transfer_encodeing
-    client = HTTP::Client.new(:default_host => "http://localhost:8080", :strict_transfer_encoding => true)
-    result = client.get("/echo", :content => "hello")
-    assert_equal(client.strict_transfer_encoding, true)
-    assert_equal("hello", result)
-  end
-  
-  def test_http_element_charset
-    client = HTTP::Client.new(:default_host => "http://localhost:8080", :http_element_charset => "ASCII")
-    result = client.get("/echo", :content => "hello")
-    assert_equal(client.http_element_charset, "ASCII")
-    assert_equal("hello", result)    
-  end
-  
-  def test_use_expect_continue
-    client = HTTP::Client.new(:default_host => "http://localhost:8080", :use_expect_continue => true)
-    result = client.get("/echo", :content => "hello")
-    assert_equal(client.use_expect_continue, true)
-    assert_equal("hello", result)
-  end
-  
-  def test_wait_for_continue
-    client = HTTP::Client.new(:default_host => "http://localhost:8080", :wait_for_continue => true)
-    result = client.get("/echo", :content => "hello")
-    assert_equal(client.wait_for_continue, true)
-    assert_equal("hello", result)
-  end
-  
-  def test_user_agent
-    client = HTTP::Client.new(:default_host => "http://localhost:8080", :user_agent => "Mozilla/5.0 (Macintosh; U; PPC Mac OS X 10.5; en-US; rv:1.9.0.3) Gecko/2008092414 Firefox/3.0.3")
-    result = client.get("/echo", :content => "hello")
-    assert_equal(client.user_agent, "Mozilla/5.0 (Macintosh; U; PPC Mac OS X 10.5; en-US; rv:1.9.0.3) Gecko/2008092414 Firefox/3.0.3")
-    assert_equal("hello", result)
-  end
-  
-  def test_tcp_nodelay
-    client = HTTP::Client.new(:default_host => "http://localhost:8080", :tcp_nodelay => true)
-    result = client.get("/echo", :content => "hello")
-    assert_equal(client.tcp_nodelay, true)
-    assert_equal("hello", result)
-  end
-  
-  def test_so_linger
-    client = HTTP::Client.new(:default_host => "http://localhost:8080", :so_linger => 3000)
-    result = client.get("/echo", :content => "hello")
-    assert_equal(client.so_linger, 3000)
-    assert_equal("hello", result)
-  end
-  
-  def test_so_reuseaddr
-    client = HTTP::Client.new(:default_host => "http://localhost:8080", :so_reuseaddr => true)
-    result = client.get("/echo", :content => "hello")
-    assert_equal(client.so_reuseaddr, true)
-    assert_equal("hello", result)
-  end
-  
-  def test_socket_buffer_size
-    client = HTTP::Client.new(:default_host => "http://localhost:8080", :socket_buffer_size => 10000)
-    result = client.get("/echo", :content => "hello")
-    assert_equal(client.socket_buffer_size, 10000)
-    assert_equal("hello", result)
-  end
-  
-  def test_connection_timeout
-    client = HTTP::Client.new(:default_host => "http://localhost:8080", :connection_timeout => 2)
-    result = client.get("/echo", :content => "hello")
-    assert_equal(client.connection_timeout, 2)
-    assert_equal("hello", result)
-  end
-  
-  def test_max_line_length
-    client = HTTP::Client.new(:default_host => "http://localhost:8080", :max_line_length => 2)
-    result = client.get("/echo", :content => "hello")
-    assert_equal(client.max_line_length, 2)
-    assert_equal("hello", result)
-  end
-  
-  def test_max_header_count
-    client = HTTP::Client.new(:default_host => "http://localhost:8080", :max_header_count => 10)
-    result = client.get("/echo", :content => "hello")
-    assert_equal(client.max_header_count, 10)
-    assert_equal("hello", result)    
-  end
-  
-  def test_stale_connection_check
-    client = HTTP::Client.new(:default_host => "http://localhost:8080", :stale_connection_check => true)
-    result = client.get("/echo", :content => "hello")
-    assert_equal(client.stale_connection_check, true)
-    assert_equal("hello", result)
-  end
-  
-  def test_local_address
-    client = HTTP::Client.new(:default_host => "http://localhost:8080", :local_address => "127.0.0.1")
-    result = client.get("/echo", :content => "hello")
-    assert_equal(client.local_address.get_host_address, "127.0.0.1")
-    assert_equal("hello", result)    
-  end
-  
-  def test_default_proxy
-    client = HTTP::Client.new(:default_host => "http://localhost:8080", :default_proxy => "http://127.0.0.1:8080")
-    result = client.get("/echo", :content => "hello")
-    assert_equal(client.default_proxy.to_s, "http://127.0.0.1:8080")
-    assert_equal("hello", result)    
-  end
-  
-  def test_date_patterns
-    client = HTTP::Client.new(:default_host => "http://localhost:8080", :date_patterns => ["MDy"])
-    result = client.get("/echo", :content => "hello")
-    assert(client.date_patterns.include? 'MDy')
-    assert_equal("hello", result)        
-  end
-  
-  def test_single_cookie_header
-    client = HTTP::Client.new(:default_host => "http://localhost:8080", :single_cookie_header => true)
-    result = client.get("/echo", :content => "hello")
-    assert_equal(client.single_cookie_header, true)
-    assert_equal("hello", result)
-  end
-  
-  def test_credential_charset
-    client = HTTP::Client.new(:default_host => "http://localhost:8080", :credential_charset => "ASCII")
-    result = client.get("/echo", :content => "hello")
-    assert_equal(client.credential_charset, "ASCII")
-    assert_equal("hello", result)
-  end
-  
-  def test_cookie_policy
-    client = HTTP::Client.new(:default_host => "http://localhost:8080", :cookie_policy => "RFC2109")
-    result = client.get("/echo", :content => "hello")
-    assert_equal(client.cookie_policy, "RFC2109")
-    assert_equal("hello", result)
-  end
-  
-  def test_handle_authentication
-    client = HTTP::Client.new(:default_host => "http://localhost:8080", :handle_authentication => true)
-    result = client.get("/echo", :content => "hello")
-    assert_equal(client.handle_authentication, true)
-    assert_equal("hello", result)
-  end
-  
-  def test_handle_redirects
-    client = HTTP::Client.new(:default_host => "http://localhost:8080", :handle_redirects => true)
-    result = client.get("/echo", :content => "hello")
-    assert_equal(client.handle_redirects, true)
-    assert_equal("hello", result)
-  end
-  
-  def test_max_redirects
-    client = HTTP::Client.new(:default_host => "http://localhost:8080", :max_redirects => 1)
-    result = client.get("/echo", :content => "hello")
-    assert_equal(client.max_redirects, 1)
-    assert_equal("hello", result)
-  end
-  
-  def test_allow_circular_redirects
-    client = HTTP::Client.new(:default_host => "http://localhost:8080", :allow_circular_redirects => true)
-    result = client.get("/echo", :content => "hello")
-    assert_equal(client.allow_circular_redirects, true)
-    assert_equal("hello", result)
-  end
-  
-  def test_virtual_host
-    client = HTTP::Client.new(:default_host => "http://localhost:8080", :virtual_host => "http://127.0.0.1:80")
-    result = client.get("/echo", :content => "hello")
-    assert_equal(client.virtual_host.to_s, "http://127.0.0.1:80")
-    assert_equal("hello", result)
-  end
-
-  def test_default_host
-    client = HTTP::Client.new(:default_host => "http://localhost:8080")
-    result = client.get("/echo", :content => "hello")
-    assert_equal(client.default_host.to_s, "http://localhost:8080")
-    assert_equal("hello", result)
-  end
-  
-  def test_disable_response_handler
-    client = HTTP::Client.new(:default_host => "http://localhost:8080", :disable_response_handler => true)
-    result = client.get("/echo", :content => "hello")
-    assert_equal(Java::OrgApacheHttpMessage::BasicHttpResponse, result.class)
-  end
-end