http_tools 0.3.0 → 0.4.0

data/test/builder/response_test.rb

@@ -2,7 +2,7 @@ base = File.expand_path(File.dirname(__FILE__) + '/../../lib')
 require base + '/http_tools'
 require 'test/unit'
 
-class ResponseTest < Test::Unit::TestCase
+class BuilderResponseTest < Test::Unit::TestCase
   
   def test_status_ok
     result = HTTPTools::Builder.response(:ok)
@@ -29,4 +29,17 @@ class ResponseTest < Test::Unit::TestCase
     assert_equal(expected, result)
   end
   
+  def test_newline_separated_multi_value_headers
+    result = HTTPTools::Builder.response(:ok, "Set-Cookie" => "foo=bar\nbaz=qux")
+    
+    expected = "HTTP/1.1 200 OK\r\nSet-Cookie: foo=bar\r\nSet-Cookie: baz=qux\r\n\r\n"
+    assert_equal(expected, result)
+  end
+  
+  def test_array_multi_value_headers
+    result = HTTPTools::Builder.response(:ok, "Set-Cookie" => ["foo=bar", "baz=qux"])
+    
+    expected = "HTTP/1.1 200 OK\r\nSet-Cookie: foo=bar\r\nSet-Cookie: baz=qux\r\n\r\n"
+    assert_equal(expected, result)
+  end
 end

data/test/cover.rb

@@ -1,4 +1,4 @@
-#!/opt/local/bin/ruby1.9
+#!/opt/local/bin/ruby1.9 -w
 
 require 'coverage' # >= ruby 1.9 only
 
@@ -16,8 +16,8 @@ at_exit do
     next unless value.include?(0)
     puts key
     puts
-    File.readlines(key).zip(value).each_with_index do |(line, value), i|
-      print "%3i %3s  %s" % [(i + 1), value, line]
+    File.readlines(key).zip(value).each_with_index do |(line, val), i|
+      print "%3i %3s  %s" % [(i + 1), val, line]
     end
     puts
     puts

data/test/parser/request_test.rb

@@ -2,7 +2,7 @@ base = File.expand_path(File.dirname(__FILE__) + '/../../lib')
 require base + '/http_tools'
 require 'test/unit'
 
-class RequestTest < Test::Unit::TestCase
+class ParserRequestTest < Test::Unit::TestCase
   
   def test_get
     parser = HTTPTools::Parser.new
@@ -461,7 +461,7 @@ class RequestTest < Test::Unit::TestCase
   def test_env
     parser = HTTPTools::Parser.new
     env = nil
-    parser.on(:header) {env = parser.env}
+    parser.on(:finish) {env = parser.env}
     
     parser << "GET /test?q=foo HTTP/1.1\r\n"
     parser << "Host: www.example.com\r\n"
@@ -479,7 +479,8 @@ class RequestTest < Test::Unit::TestCase
     
     assert_equal([1,1], env["rack.version"])
     assert_equal("http", env["rack.url_scheme"])
-    assert_equal(nil, env["rack.input"])
+    assert_instance_of(StringIO, env["rack.input"])
+    assert_equal("", env["rack.input"].read)
     assert_equal(STDERR, env["rack.errors"])
     assert_equal(false, env["rack.multithread"])
     assert_equal(false, env["rack.multiprocess"])
@@ -514,7 +515,8 @@ class RequestTest < Test::Unit::TestCase
     
     assert_equal([1,1], env["rack.version"])
     assert_equal("http", env["rack.url_scheme"])
-    assert_equal(nil, env["rack.input"])
+    assert_instance_of(StringIO, env["rack.input"])
+    assert_equal("Hello world", env["rack.input"].read)
     assert_equal(STDERR, env["rack.errors"])
     assert_equal(false, env["rack.multithread"])
     assert_equal(false, env["rack.multiprocess"])
@@ -524,7 +526,7 @@ class RequestTest < Test::Unit::TestCase
   def test_env_server_port
     parser = HTTPTools::Parser.new
     env = nil
-    parser.on(:header) {env = parser.env}
+    parser.on(:finish) {env = parser.env}
     
     parser << "GET / HTTP/1.1\r\n"
     parser << "Host: localhost:9292\r\n"
@@ -538,7 +540,7 @@ class RequestTest < Test::Unit::TestCase
   def test_env_post
     parser = HTTPTools::Parser.new
     env = nil
-    parser.on(:header) {env = parser.env}
+    parser.on(:finish) {env = parser.env}
     
     parser << "POST / HTTP/1.1\r\n"
     parser << "Host: www.example.com\r\n"
@@ -553,7 +555,31 @@ class RequestTest < Test::Unit::TestCase
     assert_equal("7", env["CONTENT_LENGTH"])
     assert_equal("application/x-www-form-urlencoded", env["CONTENT_TYPE"])
     
+    assert_instance_of(StringIO, env["rack.input"])
+    assert_equal("foo=bar", env["rack.input"].read)
+  end
+  
+  def test_env_with_stream_listener
+    parser = HTTPTools::Parser.new
+    env = nil
+    body = ""
+    parser.on(:finish) {env = parser.env}
+    parser.on(:stream) {|chunk| body << chunk}
+    
+    parser << "POST / HTTP/1.1\r\n"
+    parser << "Host: www.example.com\r\n"
+    parser << "Content-Length: 7\r\n"
+    parser << "\r\n"
+    parser << "foo=bar"
+    
+    assert_equal("foo=bar", body)
     assert_equal(nil, env["rack.input"])
   end
   
+  def test_inspect
+    parser = HTTPTools::Parser.new
+    
+    assert(/#<HTTPTools::Parser:[a-fx0-9]+ line 1, char 1 start>/ === parser.inspect, "Inspect should return useful information")
+  end
+  
 end

data/test/parser/response_test.rb

@@ -2,7 +2,7 @@ base = File.expand_path(File.dirname(__FILE__) + '/../../lib')
 require base + '/http_tools'
 require 'test/unit'
 
-class ResponseTest < Test::Unit::TestCase
+class ParserResponseTest < Test::Unit::TestCase
   
   def test_version
     parser = HTTPTools::Parser.new
@@ -231,7 +231,7 @@ class ResponseTest < Test::Unit::TestCase
     parser << "Set-Cookie: foo=bar\r\n"
     parser << "Set-Cookie: baz=qux\r\n\r\n"
     
-    assert_equal({"Set-Cookie" => ["foo=bar", "baz=qux"]}, headers)
+    assert_equal({"Set-Cookie" => "foo=bar\nbaz=qux"}, headers)
   end
   
   def test_skip_junk_headers_at_end
@@ -392,6 +392,22 @@ class ResponseTest < Test::Unit::TestCase
     assert(parser.finished?, "parser should be finished")
   end
   
+  def test_case_insensitive_content_length
+    parser = HTTPTools::Parser.new
+    headers, body = nil, ""
+    
+    parser.add_listener(:header) {headers = parser.header}
+    parser.add_listener(:stream) {|chunk| body << chunk}
+    
+    parser << "HTTP/1.1 200 OK\r\n"
+    parser << "content-length: 20\r\n\r\n"
+    parser << "<h1>Hello world</h1>"
+    
+    assert_equal({"content-length" => "20"}, headers)
+    assert_equal("<h1>Hello world</h1>", body)
+    assert(parser.finished?, "parser should be finished")
+  end
+  
   def test_zero_length_body
     parser = HTTPTools::Parser.new
     code, message, headers, body = nil
@@ -588,6 +604,24 @@ class ResponseTest < Test::Unit::TestCase
     assert(parser.finished?, "parser should be finished")
   end
   
+  def test_case_insensitive_chunked
+    parser = HTTPTools::Parser.new
+    headers, body = nil, ""
+    
+    parser.add_listener(:header) do
+      headers = parser.header
+    end
+    parser.add_listener(:stream) {|chunk| body << chunk}
+    
+    parser << "HTTP/1.1 200 OK\r\n"
+    parser << "transfer-encoding: CHUNKED\r\n\r\n"
+    parser << "14\r\n<h1>Hello world</h1>\r\n0\r\n"
+    
+    assert_equal({"transfer-encoding" => "CHUNKED"}, headers)
+    assert_equal("<h1>Hello world</h1>", body)
+    assert(parser.finished?, "parser should be finished")
+  end
+  
   def test_chunked_stream
     parser = HTTPTools::Parser.new
     code, message, headers = nil
@@ -630,13 +664,13 @@ class ResponseTest < Test::Unit::TestCase
     parser << "Transfer-Encoding: chunked\r\n"
     parser << "\r\n"
     parser << "9\r\n<h1>Hello\r\nb\r\n world</h1>\r\n"
-    parser << "12\r\n<p>Lorem ipsum</p>\r\n"
-    parser << "0\r\n"
+    parser << "12\r\n<p>Lorem ipsum</p>"
+    parser << "\r\n0\r\n"
     
     assert_equal(200, code)
     assert_equal("OK", message)
     assert_equal({"Transfer-Encoding" => "chunked"}, headers)
-    assert_equal(["<h1>Hello world</h1>", "<p>Lorem ipsum</p>"], body)
+    assert_equal(["<h1>Hello", " world</h1>", "<p>Lorem ipsum</p>"], body)
     assert(parser.finished?, "parser should be finished")
   end
   
@@ -670,6 +704,26 @@ class ResponseTest < Test::Unit::TestCase
     assert(parser.finished?, "parser should be finished")
   end
   
+  def test_case_insensitive_chunked_terminated_by_close
+    parser = HTTPTools::Parser.new
+    headers, body = nil, ""
+    
+    parser.add_listener(:header) {headers = parser.header}
+    parser.add_listener(:stream) {|chunk| body << chunk}
+    
+    parser << "HTTP/1.1 200 OK\r\n"
+    parser << "connection: CLOSE\r\n"
+    parser << "Transfer-Encoding: chunked\r\n\r\n"
+    parser << "9\r\n<h1>Hello\r\nb\r\n world</h1>\r\n"
+    parser.finish # notify parser the connection has closed
+    
+    assert_equal({
+      "Transfer-Encoding" => "chunked",
+      "connection" => "CLOSE"}, headers)
+    assert_equal("<h1>Hello world</h1>", body)
+    assert(parser.finished?, "parser should be finished")
+  end
+  
   def test_html_body_only_not_allowed
     parser = HTTPTools::Parser.new
     
@@ -704,6 +758,37 @@ class ResponseTest < Test::Unit::TestCase
     assert(parser.finished?, "parser should be finished")
   end
   
+  def test_default_stream_listener
+    parser = HTTPTools::Parser.new
+    body = nil
+    
+    parser.add_listener(:finish) do
+      body = parser.body
+    end
+    
+    parser << "HTTP/1.1 200 OK\r\n"
+    parser << "Content-Length: 20\r\n\r\n"
+    parser << "<h1>Hello"
+    parser << " world</h1>"
+    
+    assert_equal("<h1>Hello world</h1>", body)
+  end
+  
+  def test_overide_default_stream_listener
+    parser = HTTPTools::Parser.new
+    body = ""
+    
+    parser.add_listener(:stream) {|chunk| body << chunk}
+    
+    parser << "HTTP/1.1 200 OK\r\n"
+    parser << "Content-Length: 20\r\n\r\n"
+    parser << "<h1>Hello"
+    parser << " world</h1>"
+    
+    assert_equal("<h1>Hello world</h1>", body)
+    assert_nil(parser.body)
+  end
+  
   def test_finished
     parser = HTTPTools::Parser.new
     code, message, remainder = nil
@@ -788,6 +873,23 @@ class ResponseTest < Test::Unit::TestCase
     assert(parser.finished?, "parser should be finished")
   end
   
+  def test_case_insensitive_trailer
+    parser = HTTPTools::Parser.new
+    headers, trailer = nil
+    
+    parser.add_listener(:header) {headers = parser.header}
+    parser.add_listener(:trailer) {trailer = parser.trailer}
+    
+    parser << "HTTP/1.1 200 OK\r\n"
+    parser << "Transfer-Encoding: chunked\r\ntrailer: x-checksum\r\n\r\n"
+    parser << "14\r\n<h1>Hello world</h1>\r\n0\r\n"
+    parser << "X-Checksum: 2a2e12c8edad17de62354ea4531ac82c\r\n\r\n"
+    
+    assert_equal({"Transfer-Encoding" => "chunked", "trailer" => "x-checksum"}, headers)
+    assert_equal({"X-Checksum" => "2a2e12c8edad17de62354ea4531ac82c"}, trailer)
+    assert(parser.finished?, "parser should be finished")
+  end
+  
   def test_trailer_sub_line_chunks
     parser = HTTPTools::Parser.new
     trailer = nil
@@ -821,6 +923,22 @@ class ResponseTest < Test::Unit::TestCase
     assert(parser.finished?, "parser should be finished")
   end
   
+  def test_multiple_trailer_values
+    parser = HTTPTools::Parser.new
+    trailer = nil
+    
+    parser.add_listener(:trailer) {trailer = parser.trailer}
+    
+    parser << "HTTP/1.1 200 OK\r\n"
+    parser << "Transfer-Encoding: chunked\r\n"
+    parser << "Trailer: X-Test\r\n\r\n"
+    parser << "14\r\n<h1>Hello world</h1>\r\n0\r\n"
+    parser << "X-Test: 1\r\n"
+    parser << "X-Test: 2\r\n\r\n"
+    
+    assert_equal({"X-Test" => "1\n2"}, trailer)
+  end
+  
   def test_messed_up_iis_header_style_trailer_1
     parser = HTTPTools::Parser.new
     trailer = nil

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: http_tools
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 15
   prerelease: false
   segments: 
   - 0
-  - 3
+  - 4
   - 0
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Matthew Sadler
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-10 00:00:00 +01:00
+date: 2011-06-12 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -30,7 +30,6 @@ extra_rdoc_files:
 files: 
 - lib/http_tools/builder.rb
 - lib/http_tools/encoding.rb
-- lib/http_tools/errors.rb
 - lib/http_tools/parser.rb
 - lib/http_tools.rb
 - test/builder/request_test.rb
@@ -42,14 +41,15 @@ files:
 - test/parser/request_test.rb
 - test/parser/response_test.rb
 - test/runner.rb
+- bench/parser/large_response_bench.rb
 - bench/parser/request_bench.rb
 - bench/parser/response_bench.rb
 - bench/transfer_encoding_chunked_bench.rb
+- profile/parser/large_response_profile.rb
 - profile/parser/request_profile.rb
 - profile/parser/response_profile.rb
 - example/http_client.rb
 - example/http_server.rb
-- example/simple_http_client.rb
 - README.rdoc
 has_rdoc: true
 homepage: http://github.com/matsadler/http_tools

data/example/simple_http_client.rb

@@ -1,67 +0,0 @@
-require 'socket'
-require 'rubygems'
-require 'http_tools'
-
-# Usage:
-#   uri = URI.parse("http://example.com/")
-#   client = HTTP::Client.new(uri.host, uri.port)
-#   response = client.get(uri.path)
-#   
-#   puts "#{response.status} #{response.message}"
-#   puts response.headers.inspect
-#   puts response.body
-#   
-module HTTP
-  class Client
-    Response = Struct.new(:status, :message, :headers, :body)
-    
-    def initialize(host, port=80)
-      @host, @port = host, port
-    end
-    
-    def head(path, headers={})
-      request(:head, path, nil, headers, false)
-    end
-    
-    def get(path, headers={})
-      request(:get, path, nil, headers)
-    end
-    
-    def post(path, body=nil, headers={})
-      request(:post, path, body, headers)
-    end
-    
-    def put(path, body=nil, headers={})
-      request(:put, path, body, headers)
-    end
-    
-    def delete(path, headers={})
-      request(:delete, path, nil, headers)
-    end
-    
-    private
-    def request(method, path, body=nil, headers={}, response_has_body=true)
-      parser = HTTPTools::Parser.new
-      parser.force_no_body = !response_has_body
-      response = nil
-      
-      parser.on(:header) do
-        code, message, head = parser.status_code, parser.message, parser.header
-        response = Response.new(code, message, head, "")
-      end
-      parser.on(:stream) {|chunk| response.body << chunk}
-      
-      socket = TCPSocket.new(@host, @port)
-      socket << HTTPTools::Builder.request(method, @host, path, headers)
-      socket << body if body
-      begin
-        parser << socket.sysread(1024 * 16)
-      rescue EOFError
-        break parser.finish
-      end until parser.finished?
-      socket.close
-      
-      response
-    end
-  end
-end

data/lib/http_tools/errors.rb

@@ -1,6 +0,0 @@
-module HTTPTools
-  class ParseError < StandardError; end
-  class EndOfMessageError < ParseError; end
-  class MessageIncompleteError < EndOfMessageError; end
-  class EmptyMessageError < MessageIncompleteError; end
-end