jruby-httpclient 0.1.0-java → 0.2.0-java

data/Gemfile

@@ -3,6 +3,5 @@ source "http://rubygems.org"
 group :development do
   gem "bundler", "~> 1.0.0"
   gem "jeweler", "~> 1.6.2"
-  gem "rcov", ">= 0"
   gem "rdoc"
 end

data/Gemfile.lock

@@ -7,7 +7,6 @@ GEM
       git (>= 1.2.5)
       rake
     rake (0.9.2)
-    rcov (0.9.9-java)
     rdoc (3.6.1)
 
 PLATFORMS
@@ -16,5 +15,4 @@ PLATFORMS
 DEPENDENCIES
   bundler (~> 1.0.0)
   jeweler (~> 1.6.2)
-  rcov
   rdoc

data/README.rdoc

@@ -1,6 +1,14 @@
 = jruby-httpclient
 
-Description goes here.
+jruby-httpclient is a thin wrapper around Apache's HttpClient (version 4.1).   I found that Net::HTTP was
+not threadsafe in JRuby.    This project is an attempt to make a threadsafe HTTP client for JRuby.
+
+== Usage
+
+  client = HTTP::Client.new(:host => "localhost", :port => 8080)
+  client.get("/src", :param => "value")
+
+  client.post("/create", :param => "value")
 
 == Contributing to jruby-httpclient
  

data/Rakefile

@@ -33,14 +33,6 @@ Rake::TestTask.new(:test) do |test|
   test.verbose = true
 end
 
-require 'rcov/rcovtask'
-Rcov::RcovTask.new do |test|
-  test.libs << 'test'
-  test.pattern = 'test/**/test_*.rb'
-  test.verbose = true
-  test.rcov_opts << '--exclude "gems/*"'
-end
-
 task :default => :test
 
 require 'rdoc/task'

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/jruby-httpclient.gemspec

@@ -0,0 +1,71 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{jruby-httpclient}
+  s.version = "0.2.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.description = %q{An HTTP client designed for use with JRuby in a threaded environment}
+  s.email = %q{adam@esterlines.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "jruby-httpclient.gemspec",
+    "lib/http_client.rb",
+    "lib/http_client/client.rb",
+    "lib/http_client/methods.rb",
+    "lib/http_client/parameters.rb",
+    "test/helper.rb",
+    "test/http_client/test_basic_auth.rb",
+    "test/http_client/test_basic_client_operations.rb",
+    "test/http_client/test_client_headers.rb",
+    "test/http_client/test_client_parameters.rb",
+    "test/http_client/test_request_entity.rb",
+    "test/http_test_server.rb",
+    "vendor/commons-codec-1.4.jar",
+    "vendor/commons-logging-1.1.1.jar",
+    "vendor/httpclient-4.1.1.jar",
+    "vendor/httpclient-cache-4.1.1.jar",
+    "vendor/httpcore-4.1.jar",
+    "vendor/httpmime-4.1.1.jar"
+  ]
+  s.homepage = %q{http://github.com/aesterline/jruby-httpclient}
+  s.licenses = ["Apache 2.0"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.5.1}
+  s.summary = %q{A thin wrapper around the Apache HttpClient}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.2"])
+      s.add_development_dependency(%q<rdoc>, [">= 0"])
+    else
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.2"])
+      s.add_dependency(%q<rdoc>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.2"])
+    s.add_dependency(%q<rdoc>, [">= 0"])
+  end
+end
+

data/lib/http_client.rb

@@ -12,4 +12,6 @@ require 'httpmime-4.1.1'
 require 'httpclient-4.1.1'
 require 'httpclient-cache-4.1.1'
 
-require 'client'
+require 'parameters'
+require 'methods'
+require 'client'

data/lib/http_client/client.rb

@@ -1,60 +1,73 @@
+require 'uri'
 module HTTP
+  DefaultHttpClient = org.apache.http.impl.client.DefaultHttpClient
+  BasicResponseHandler = org.apache.http.impl.client.BasicResponseHandler
+  SocketTimeoutException = java.net.SocketTimeoutException
+
   class Client
-    attr_reader :protocol, :host, :port, :timeout_in_seconds
-    attr_writer :timeout_in_seconds
+    DEFAULT_TIMEOUT = 30_000
+    include HTTP::Parameters
 
     def initialize(options = {})
-      @host = options[:host] || "localhost"
-      @port = options[:port] || 8080
-      @protocol = options[:protocol] || "http"
+      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
 
-      @timeout_in_seconds = 30
+      @uri_builder = URIBuilder.new(nil, nil, nil, "")
+      @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
     end
 
-    def get(path, options = {})
-      params = options.collect { |key, value| BasicNameValuePair.new(key.to_s, value.to_s) }
-      query_string = URLEncodedUtils.format(params, "UTF-8")
-      uri = URIUtils.create_uri(@protocol, @host, @port, path, query_string, nil)
+    # Request Methods
 
-      make_request(HttpGet.new(uri))
+    def get(params, options = {})
+      execute(Get.new(params, options))
     end
 
-    def post(path, options = {})
-      params = options.collect { |key, value| BasicNameValuePair.new(key.to_s, value.to_s) }
+    def post(params, options = {})
+      execute(Post.new(params, options))
+    end
 
-      post = HttpPost.new(URIUtils.create_uri(@protocol, @host, @port, path, nil, nil))
-      post.entity = UrlEncodedFormEntity.new(params, "UTF-8")
+    def delete(path)
+      execute(Delete.new(path))
+    end
 
-      make_request(post)
+    def put(path)
+      execute(Put.new(path))
     end
 
-    private
-    def make_request(request)
-      client = DefaultHttpClient.new(create_client_params)
-      client.execute(request, BasicResponseHandler.new)
+    def execute(request)
+      client = DefaultHttpClient.new(params)
+
+      request.make_native_request(client, @uri_builder, @encoding, @response_handler)
     rescue SocketTimeoutException
-      raise Timeout::Error, "timed out after #{timeout_in_seconds} seconds"
+      raise Timeout::Error, "timed out after #{so_timeout} ms"
     ensure
       client.connection_manager.shutdown
     end
-
-    def create_client_params
-      params = BasicHttpParams.new
-      DefaultHttpClient.set_default_http_params(params)
-      params.set_int_parameter(CoreConnectionPNames::SO_TIMEOUT, @timeout_in_seconds * 1000)
-    end
   end
 
-  DefaultHttpClient = org.apache.http.impl.client.DefaultHttpClient
-  BasicResponseHandler = org.apache.http.impl.client.BasicResponseHandler
-  HttpGet = org.apache.http.client.methods.HttpGet
-  HttpPost = org.apache.http.client.methods.HttpPost
-  BasicNameValuePair = org.apache.http.message.BasicNameValuePair
-  URIUtils = org.apache.http.client.utils.URIUtils
-  URLEncodedUtils = org.apache.http.client.utils.URLEncodedUtils
-  UrlEncodedFormEntity = org.apache.http.client.entity.UrlEncodedFormEntity
-  BasicHttpParams = org.apache.http.params.BasicHttpParams
-  CoreConnectionPNames = org.apache.http.params.CoreConnectionPNames
-  SocketTimeoutException = java.net.SocketTimeoutException
+  class URIBuilder
+    def initialize(protocol, host, port, base_path)
+      @protocol = protocol
+      @host = host
+      @port = port
+      @base_path = base_path
+    end
 
+    def create_uri(path, query_string = nil)
+      URIUtils.create_uri(@protocol, @host, @port, "#{@base_path}#{path}", query_string, nil)
+    end
+  end
 end

data/lib/http_client/methods.rb

@@ -0,0 +1,89 @@
+module HTTP
+  class Request
+    def self.create_type(&native_request_factory)
+      Class.new do
+        def initialize(path, params = {})
+          @path = path
+          @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, uri_builder, encoding, handler=nil)
+          request = create_native_request(uri_builder, 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
+
+        private
+        define_method(:create_native_request) do |uri_builder, encoding|
+          params = @params.collect { |key, value| BasicNameValuePair.new(key.to_s, value.to_s) }
+          request = native_request_factory.call(uri_builder, @path, params, encoding)
+
+          @headers.each { |name, value| request.add_header(name.to_s, value.to_s) }
+
+          request
+        end
+      end
+    end
+  end
+
+  Post = Request.create_type do |uri_builder, path, params, encoding|
+    post = HttpPost.new(uri_builder.create_uri(path))
+    post.entity = UrlEncodedFormEntity.new(params, encoding)
+    post
+  end
+
+  Get = Request.create_type do |uri_builder, path, params, encoding|
+    query_string = URLEncodedUtils.format(params, encoding)
+    get = HttpGet.new(uri_builder.create_uri(path, query_string))
+    get
+  end
+
+  Delete = Request.create_type do |uri_builder, path|
+    HttpDelete.new(uri_builder.create_uri(path))
+  end
+
+  Put = Request.create_type do |uri_builder, path|
+    HttpPut.new(uri_builder.create_uri(path))
+  end
+
+  private
+  HttpGet = org.apache.http.client.methods.HttpGet
+  HttpPost = org.apache.http.client.methods.HttpPost
+  HttpDelete = org.apache.http.client.methods.HttpDelete
+  HttpPut = org.apache.http.client.methods.HttpPut
+  BasicNameValuePair = org.apache.http.message.BasicNameValuePair
+  URIUtils = org.apache.http.client.utils.URIUtils
+  URLEncodedUtils = org.apache.http.client.utils.URLEncodedUtils
+  UrlEncodedFormEntity = org.apache.http.client.entity.UrlEncodedFormEntity
+  BasicResponseHandler = org.apache.http.impl.client.BasicResponseHandler
+  AuthScope = org.apache.http.auth.AuthScope
+  UsernamePasswordCredentials = org.apache.http.auth.UsernamePasswordCredentials
+  StringEntity = org.apache.http.entity.StringEntity
+end

data/lib/http_client/parameters.rb

@@ -0,0 +1,120 @@
+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
+
+  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_basic_auth.rb

@@ -0,0 +1,16 @@
+require 'helper'
+
+class BasicAuthTest < Test::Unit::TestCase
+  def test_get_can_authenticate
+    get = HTTP::Get.new("/protected")
+    get.basic_auth("user", "Password")
+
+    response = @client.execute(get)
+
+    assert_equal("Logged In", response)
+  end
+
+  def setup
+    @client = HTTP::Client.new(:default_host => "http://localhost:8080")
+  end
+end

data/test/http_client/test_basic_client_operations.rb

@@ -0,0 +1,31 @@
+require 'helper'
+
+class TestBasicClientOperations < Test::Unit::TestCase
+  def test_simple_get
+    result = @client.get("/echo", :content => "hello")
+
+    assert_equal("hello", result)
+  end
+
+  def test_simple_post
+    result = @client.post("/echo", :content => "world")
+
+    assert_equal("world", result)
+  end
+
+  def test_simple_delete
+    result = @client.delete("/echo")
+
+    assert_equal("delete", result)
+  end
+
+  def test_simple_put
+    result = @client.put("/echo")
+
+    assert_equal("put", result)
+  end
+
+  def setup
+    @client = HTTP::Client.new(:default_host => "http://localhost:8080")
+  end
+end

data/test/http_client/test_client_headers.rb

@@ -0,0 +1,56 @@
+require 'helper'
+
+class TestClientHeaders < 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)
+  end
+
+  def test_post_headers
+    get = HTTP::Post.new("/echo_header")
+    get.add_headers(:test_header => "post testing")
+
+    response = @client.execute(get)
+    assert_equal("post testing", response)
+  end
+
+  def test_delete_headers
+    get = HTTP::Delete.new("/echo_header")
+    get.add_headers(:test_header => "post testing")
+
+    response = @client.execute(get)
+    assert_equal("post testing", response)
+  end
+
+  def test_put_headers
+    get = HTTP::Put.new("/echo_header")
+    get.add_headers(:test_header => "post testing")
+
+    response = @client.execute(get)
+    assert_equal("post testing", response)
+  end
+
+  def test_multiple_calls_to_add_headers_should_prefer_last_set_of_headers
+    get = HTTP::Get.new("/echo_header")
+    get.add_headers(:test_header => "get testing")
+    get.add_headers(:test_header => "should prefer this one")
+
+    response = @client.execute(get)
+    assert_equal("should prefer this one", response)
+  end
+
+  def test_should_be_able_to_add_content_type
+    get = HTTP::Get.new("/echo_header", :header => 'content-type')
+    get.content_type = 'text/xml'
+
+    response = @client.execute(get)
+    assert_equal('text/xml', response)
+  end
+
+  def setup
+    @client = HTTP::Client.new(:default_host => "http://localhost:8080")
+  end
+end

data/test/http_client/test_client_parameters.rb

@@ -0,0 +1,201 @@
+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

data/test/http_client/test_request_entity.rb

@@ -0,0 +1,23 @@
+require 'helper'
+
+class RequestEntityTest < Test::Unit::TestCase
+  def test_post_request_body
+    post = HTTP::Post.new("/body")
+    post.body = "Here we are"
+
+    result = @client.execute(post)
+    assert_equal("Here we are", result)
+  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)
+  end
+
+  def setup
+    @client = HTTP::Client.new(:default_host => "http://localhost:8080")
+  end
+end

data/test/http_test_server.rb

@@ -5,9 +5,62 @@ module HTTP
     def self.start_server
       SERVER.mount('/echo', EchoServlet)
       SERVER.mount('/slow', SlowServlet)
+      SERVER.mount('/echo_header', HeaderEchoServlet)
+      SERVER.mount('/protected', ProtectedServlet)
+      SERVER.mount('/body', BodyServlet)
       Thread.new { SERVER.start }
     end
 
+    class BodyServlet < WEBrick::HTTPServlet::AbstractServlet
+      def do_POST(request, response)
+        response.status = 200
+        response.body = request.body
+      end
+
+      def do_PUT(request, response)
+        response.status = 200
+        response.body = request.body
+      end
+    end
+
+    class ProtectedServlet < WEBrick::HTTPServlet::AbstractServlet
+      def do_GET(request, response)
+        WEBrick::HTTPAuth.basic_auth(request, response, "Mine") do |user, pass|
+          user == "user" && pass == "Password"
+        end
+
+        response.status = 200
+        response.body = "Logged In"
+      end
+    end
+
+    class HeaderEchoServlet < WEBrick::HTTPServlet::AbstractServlet
+      def do_GET(request, response)
+        echo_header(request, response)
+      end
+
+      def do_POST(request, response)
+        echo_header(request, response)
+      end
+
+      def do_DELETE(request, response)
+        echo_header(request, response)
+      end
+
+      def do_PUT(request, response)
+        echo_header(request, response)
+      end
+
+      private
+      def echo_header(request, response)
+        header_to_echo = request.query['header'] || 'test_header'
+
+        response.status = 200
+        response['Content-Type'] = 'text/plain'
+        response.body = request.header[header_to_echo].first
+      end
+    end
+
     class EchoServlet < WEBrick::HTTPServlet::AbstractServlet
 
       def do_GET(request, response)
@@ -18,11 +71,19 @@ module HTTP
         echo(request, response)
       end
 
+      def do_DELETE(request, response)
+        echo(request, response, "delete")
+      end
+
+      def do_PUT(request, response)
+        echo(request, response, "put")
+      end
+
       private
-      def echo(request, response)
+      def echo(request, response, canned_response = nil)
         response.status = 200
         response['Content-Type'] = 'text/plain'
-        response.body = request.query['content']
+        response.body = canned_response || request.query['content']
       end
     end
 

metadata

@@ -2,7 +2,7 @@
 name: jruby-httpclient
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.1.0
+  version: 0.2.0
 platform: java
 authors: 
   - Adam Esterline
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-08 00:00:00 -06:00
+date: 2011-06-28 00:00:00 -06:00
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency 
@@ -36,7 +36,7 @@ dependencies:
     prerelease: false
     type: :development
   - !ruby/object:Gem::Dependency 
-    name: rcov
+    name: rdoc
     version_requirements: &id003 !ruby/object:Gem::Requirement 
       none: false
       requirements: 
@@ -46,17 +46,6 @@ dependencies:
     requirement: *id003
     prerelease: false
     type: :development
-  - !ruby/object:Gem::Dependency 
-    name: rdoc
-    version_requirements: &id004 !ruby/object:Gem::Requirement 
-      none: false
-      requirements: 
-        - - ">="
-          - !ruby/object:Gem::Version 
-            version: "0"
-    requirement: *id004
-    prerelease: false
-    type: :development
 description: An HTTP client designed for use with JRuby in a threaded environment
 email: adam@esterlines.com
 executables: []
@@ -74,10 +63,17 @@ files:
   - README.rdoc
   - Rakefile
   - VERSION
+  - jruby-httpclient.gemspec
   - lib/http_client.rb
   - lib/http_client/client.rb
+  - lib/http_client/methods.rb
+  - lib/http_client/parameters.rb
   - test/helper.rb
-  - test/http_client/test_client.rb
+  - test/http_client/test_basic_auth.rb
+  - test/http_client/test_basic_client_operations.rb
+  - test/http_client/test_client_headers.rb
+  - test/http_client/test_client_parameters.rb
+  - test/http_client/test_request_entity.rb
   - test/http_test_server.rb
   - vendor/commons-codec-1.4.jar
   - vendor/commons-logging-1.1.1.jar

data/test/http_client/test_client.rb

@@ -1,28 +0,0 @@
-require 'helper'
-
-class TestClient < Test::Unit::TestCase
-  def test_simple_get
-    result = @client.get("/echo", :content => "hello")
-
-    assert_equal("hello", result)
-  end
-
-  def test_simple_post
-    result = @client.post("/echo", :content => "world")
-
-    assert_equal("world", result)
-  end
-
-  def test_timeout
-    client = HTTP::Client.new(:host => "localhost", :port => 8080)
-    @client.timeout_in_seconds = 2
-
-    assert_raises(Timeout::Error) do
-      @client.get("/slow", :sleep => "30")
-    end
-  end
-
-  def setup
-    @client = HTTP::Client.new(:host => "localhost", :port => 8080)
-  end
-end