http_tools 0.1.0 → 0.2.0

data/test/encoding/transfer_encoding_chunked_test.rb

@@ -119,6 +119,28 @@ class TransferEncodingChunkedTest < Test::Unit::TestCase
     assert_equal("14\r\n<h1>Hello world</h1>\r\n0\r\n", encoded)
   end
   
+  def test_decode_with_space_after_chunk_length
+    # some servers mistakenly put a space after the chunk length
+    encoded = "14  \r\n<h1>Hello world</h1>\r\n0\r\n"
+    decoded = HTTPTools::Encoding.transfer_encoding_chunked_decode(encoded)
+    
+    assert_equal(["<h1>Hello world</h1>", nil], decoded)
+  end
+  
+  def test_decode_lots_of_tiny_chunks
+    encoded = "1\r\na\r\n" * 10000 + "0\r\n"
+    decoded = HTTPTools::Encoding.transfer_encoding_chunked_decode(encoded)
+    
+    assert_equal(["a" * 10000, nil], decoded)
+  end
+  
+  def test_decode_break_between_cr_lf
+    encoded = "14\r\n<h1>Hello world</h1>\r"
+    decoded = HTTPTools::Encoding.transfer_encoding_chunked_decode(encoded)
+    
+    assert_equal([nil, "14\r\n<h1>Hello world</h1>\r"], decoded)
+  end
+  
   def test_encode
     encoded = HTTPTools::Encoding.transfer_encoding_chunked_encode("foo")
     

data/test/parser/request_test.rb

@@ -8,11 +8,11 @@ class RequestTest < Test::Unit::TestCase
     parser = HTTPTools::Parser.new
     result = nil
     
-    parser.add_listener(:method) do |method|
-      result = method
+    parser.add_listener(:header) do
+      result = parser.request_method
     end
     
-    parser << "GET / HTTP/1.1\r\n"
+    parser << "GET / HTTP/1.1\r\n\r\n"
     
     assert_equal("GET", result)
   end
@@ -21,52 +21,52 @@ class RequestTest < Test::Unit::TestCase
     parser = HTTPTools::Parser.new
     result = nil
     
-    parser.add_listener(:method) do |method|
-      result = method
+    parser.add_listener(:header) do
+      result = parser.request_method
     end
     
-    parser << "POST / HTTP/1.1\r\n"
+    parser << "POST / HTTP/1.1\r\n\r\n"
     
     assert_equal("POST", result)
   end
   
   def test_empty_path
     parser = HTTPTools::Parser.new
-    result = nil
+    path, query = nil
     
-    parser.add_listener(:path) do |path, query|
-      result = path
+    parser.add_listener(:header) do
+      path, query = parser.path_info, parser.query_string
     end
     
-    parser << "GET / HTTP/1.1\r\n"
+    parser << "GET / HTTP/1.1\r\n\r\n"
     
-    assert_equal("/", result)
+    assert_equal("/", path)
+    assert_equal("", query)
   end
   
   def test_basic_path
     parser = HTTPTools::Parser.new
-    result = nil
+    path, query = nil
     
-    parser.add_listener(:path) do |path, query|
-      result = path
+    parser.add_listener(:header) do
+      path, query = parser.path_info, parser.query_string
     end
     
-    parser << "GET /foo HTTP/1.1\r\n"
+    parser << "GET /foo HTTP/1.1\r\n\r\n"
     
-    assert_equal("/foo", result)
+    assert_equal("/foo", path)
+    assert_equal("", query)
   end
   
   def test_complicated_path
     parser = HTTPTools::Parser.new
-    path = nil
-    query = nil
+    path, query = nil
     
-    parser.add_listener(:path) do |p, q|
-      path = p
-      query = q
+    parser.add_listener(:header) do
+      path, query = parser.path_info, parser.query_string
     end
     
-    parser << "GET /foo%20bar/baz.html?key=value#qux HTTP/1.1\r\n"
+    parser << "GET /foo%20bar/baz.html?key=value#qux HTTP/1.1\r\n\r\n"
     
     assert_equal("/foo%20bar/baz.html", path)
     assert_equal("key=value", query)
@@ -76,7 +76,7 @@ class RequestTest < Test::Unit::TestCase
     parser = HTTPTools::Parser.new
     
     assert_raise(HTTPTools::ParseError) do
-      parser << "GET \\ HTTP/1.1\r\n"
+      parser << "GET \\ HTTP/1.1\r\n\r\n"
     end
   end
   
@@ -84,11 +84,11 @@ class RequestTest < Test::Unit::TestCase
     parser = HTTPTools::Parser.new
     result = nil
     
-    parser.add_listener(:uri) do |uri|
-      result = uri
+    parser.add_listener(:header) do
+      result = parser.request_uri
     end
     
-    parser << "GET http://example.com/foo HTTP/1.1\r\n"
+    parser << "GET http://example.com/foo HTTP/1.1\r\n\r\n"
     
     assert_equal("http://example.com/foo", result)
   end
@@ -97,11 +97,11 @@ class RequestTest < Test::Unit::TestCase
     parser = HTTPTools::Parser.new
     result = nil
     
-    parser.add_listener(:path) do |path, query|
-      result = path
+    parser.add_listener(:header) do
+      result = parser.path_info
     end
     
-    parser << "GET http://example.com/foo HTTP/1.1\r\n"
+    parser << "GET http://example.com/foo HTTP/1.1\r\n\r\n"
     
     assert_nil(result)
   end
@@ -112,13 +112,13 @@ class RequestTest < Test::Unit::TestCase
     path = nil
     query = nil
     
-    parser.add_listener(:uri) {|u| uri = u}
-    parser.add_listener(:path) do |p, q|
-      path = p
-      query = q
+    parser.add_listener(:header) do
+      uri = parser.request_uri
+      path = parser.path_info
+      query = parser.query_string
     end
     
-    parser << "GET /foo/bar.html?key=value HTTP/1.1\r\n"
+    parser << "GET /foo/bar.html?key=value HTTP/1.1\r\n\r\n"
     
     assert_equal("/foo/bar.html?key=value", uri)
     assert_equal("/foo/bar.html", path)
@@ -130,10 +130,12 @@ class RequestTest < Test::Unit::TestCase
     path = nil
     fragment = nil
     
-    parser.add_listener(:path) {|p, q| path = p}
-    parser.add_listener(:fragment) {|f| fragment = f}
+    parser.add_listener(:header) do
+      path = parser.path_info
+      fragment = parser.fragment
+    end
     
-    parser << "GET /foo#bar HTTP/1.1\r\n"
+    parser << "GET /foo#bar HTTP/1.1\r\n\r\n"
     
     assert_equal("/foo", path)
     assert_equal("bar", fragment)
@@ -144,10 +146,12 @@ class RequestTest < Test::Unit::TestCase
     uri = nil
     fragment = nil
     
-    parser.add_listener(:uri) {|u| uri = u}
-    parser.add_listener(:fragment) {|f| fragment = f}
+    parser.add_listener(:header) do
+      uri = parser.request_uri
+      fragment = parser.fragment
+    end
     
-    parser << "GET http://example.com/foo#bar HTTP/1.1\r\n"
+    parser << "GET http://example.com/foo#bar HTTP/1.1\r\n\r\n"
     
     assert_equal("http://example.com/foo", uri)
     assert_equal("bar", fragment)
@@ -159,9 +163,11 @@ class RequestTest < Test::Unit::TestCase
     path = nil
     headers = nil
     
-    parser.add_listener(:method) {|m| method = m}
-    parser.add_listener(:path) {|p, q| path = p}
-    parser.add_listener(:headers) {|h| headers = h}
+    parser.add_listener(:header) do
+      method = parser.request_method
+      path = parser.path_info
+      headers = parser.header
+    end
     
     parser << "GET / HTTP/1.1\r\n"
     parser << "Host: www.example.com\r\n"
@@ -178,9 +184,11 @@ class RequestTest < Test::Unit::TestCase
     path = nil
     headers = nil
     
-    parser.add_listener(:method) {|m| method = m}
-    parser.add_listener(:path) {|p, q| path = p}
-    parser.add_listener(:headers) {|h| headers = h}
+    parser.add_listener(:header) do
+      method = parser.request_method
+      path = parser.path_info
+      headers = parser.header
+    end
     
     parser << "GET / HTTP/1.1\r\n"
     parser << "Host: www.example.com\r\n"
@@ -198,9 +206,11 @@ class RequestTest < Test::Unit::TestCase
     path = nil
     headers = nil
     
-    parser.add_listener(:method) {|m| method = m}
-    parser.add_listener(:path) {|p, q| path = p}
-    parser.add_listener(:headers) {|h| headers = h}
+    parser.add_listener(:header) do
+      method = parser.request_method
+      path = parser.path_info
+      headers = parser.header
+    end
     
     parser << "GE"
     parser << "T /foo/"
@@ -222,9 +232,11 @@ class RequestTest < Test::Unit::TestCase
     path = nil
     headers = nil
     
-    parser.add_listener(:method) {|m| method = m}
-    parser.add_listener(:path) {|p, q| path = p}
-    parser.add_listener(:headers) {|h| headers = h}
+    parser.add_listener(:header) do
+      method = parser.request_method
+      path = parser.path_info
+      headers = parser.header
+    end
     
     parser << "POST"
     parser << " /bar/foo"
@@ -250,9 +262,11 @@ class RequestTest < Test::Unit::TestCase
     path = nil
     headers = nil
     
-    parser.add_listener(:method) {|m| method = m}
-    parser.add_listener(:path) {|p, q| path = p}
-    parser.add_listener(:headers) {|h| headers = h}
+    parser.add_listener(:header) do
+      method = parser.request_method
+      path = parser.path_info
+      headers = parser.header
+    end
     
     request = "GET /foo/bar HTTP/1.1\r\n"
     request << "Host: www.example.com\r\nAccept: text/plain\r\n\r\n"
@@ -268,9 +282,9 @@ class RequestTest < Test::Unit::TestCase
     parser = HTTPTools::Parser.new
     method = nil
     
-    parser.add_listener(:method) {|m| method = m}
+    parser.add_listener(:header) {method = parser.request_method}
     
-    parser << "UNICORNS / HTTP/1.1\r\n"
+    parser << "UNICORNS / HTTP/1.1\r\n\r\n"
     
     assert_equal("UNICORNS", method)
   end
@@ -281,9 +295,11 @@ class RequestTest < Test::Unit::TestCase
     path = nil
     headers = nil
     
-    parser.add_listener(:method) {|m| method = m}
-    parser.add_listener(:path) {|p, q| path = p}
-    parser.add_listener(:headers) {|h| headers = h}
+    parser.add_listener(:header) do
+      method = parser.request_method
+      path = parser.path_info
+      headers = parser.header
+    end
     
     parser << "GET /\r\nHost: www.example.com\r\n\r\n"
     
@@ -302,9 +318,9 @@ class RequestTest < Test::Unit::TestCase
     parser = HTTPTools::Parser.new
     version = nil
     
-    parser.add_listener(:version) {|v| version = v}
+    parser.add_listener(:header) {version = parser.version}
     
-    parser << "GET / HTTP/1.1\r\n"
+    parser << "GET / HTTP/1.1\r\n\r\n"
     
     assert_equal("1.1", version)
   end
@@ -312,21 +328,33 @@ class RequestTest < Test::Unit::TestCase
   def test_protocol_without_version
     parser = HTTPTools::Parser.new
     
-    assert_raise(HTTPTools::ParseError) {parser << "GET / HTTP\r\n"}
+    assert_raise(HTTPTools::ParseError) {parser << "GET / HTTP\r\n\r\n"}
+  end
+  
+  def test_one_dot_x_protocol_version
+    parser = HTTPTools::Parser.new
+    version = nil
+    
+    parser.add_listener(:header) {version = parser.version}
+    
+    parser << "GET / HTTP/1.x\r\n\r\n"
+    
+    assert_equal("1.x", version)
   end
   
   def test_reset
     parser = HTTPTools::Parser.new
     method = nil
-    method_calls = 0
     path = nil
-    path_calls = 0
     headers = nil
-    header_calls = 0
+    calls = 0
     
-    parser.add_listener(:method) {|m| method = m; method_calls += 1}
-    parser.add_listener(:path) {|p, q| path = p; path_calls += 1}
-    parser.add_listener(:headers) {|h| headers = h; header_calls += 1}
+    parser.add_listener(:header) do
+      method = parser.request_method
+      path = parser.path_info
+      headers = parser.header
+      calls += 1
+    end
     
     parser << "GET / HTTP/1.1\r\n"
     parser << "Host: www.example.com\r\n"
@@ -336,7 +364,7 @@ class RequestTest < Test::Unit::TestCase
     assert_equal("GET", method)
     assert_equal("/", path)
     assert_equal({"Host"=>"www.example.com", "Accept"=>"text/plain"}, headers)
-    assert_equal([1, 1, 1], [method_calls, path_calls, header_calls])
+    assert_equal(1, calls)
     
     parser.reset
     
@@ -348,7 +376,7 @@ class RequestTest < Test::Unit::TestCase
     assert_equal("POST", method)
     assert_equal("/example", path)
     assert_equal({"Host"=>"www.test.co.uk", "Accept"=>"text/html"}, headers)
-    assert_equal([2, 2, 2], [method_calls, path_calls, header_calls])
+    assert_equal(2, calls)
   end
   
   def test_not_a_http_request
@@ -371,11 +399,11 @@ class RequestTest < Test::Unit::TestCase
     parser = HTTPTools::Parser.new
     result = nil
     
-    parser.add_listener(:method) do |method|
-      result = method
+    parser.add_listener(:header) do
+      result = parser.request_method
     end
     
-    parser << "get / HTTP/1.1\r\n"
+    parser << "get / HTTP/1.1\r\n\r\n"
     
     assert_equal("GET", result)
   end
@@ -384,67 +412,19 @@ class RequestTest < Test::Unit::TestCase
     parser = HTTPTools::Parser.new
     version = nil
     
-    parser.add_listener(:version) {|v| version = v}
+    parser.add_listener(:header) {version = parser.version}
     
-    parser << "GET / http/1.1\r\n"
+    parser << "GET / http/1.1\r\n\r\n"
     
     assert_equal("1.1", version)
   end
   
-  def test_delegate
-    request_class = Class.new
-    request_class.class_eval do
-      attr_reader :http_method, :path, :headers, :body
-      def on_method(name)
-        @http_method = name
-      end
-      def on_path(path, query)
-        @path = path
-        @query = query
-      end
-      def on_headers(headers)
-        @headers = headers
-      end
-      def on_body(body)
-        @body = body
-      end
-    end
-    request = request_class.new
-    
-    parser = HTTPTools::Parser.new(request)
-    parser << "POST /test HTTP/1.1\r\n"
-    parser << "Content-Length: 13\r\n"
-    parser << "\r\n"
-    parser << "query=example"
-    
-    assert_equal("POST", request.http_method)
-    assert_equal("/test", request.path)
-    assert_equal({"Content-Length" => "13"}, request.headers)
-    assert_equal("query=example", request.body)
-  end
-  
   def test_invalid_version
     parser = HTTPTools::Parser.new
     
     assert_raise(HTTPTools::ParseError) {parser << "GET / HTTP/one dot one\r\n"}
   end
   
-  def test_invalid_header_key_with_space
-    parser = HTTPTools::Parser.new
-    
-    assert_raise(HTTPTools::ParseError) do
-      parser << "GET / HTTP/1.1\r\nx-invalid key: text/plain\r\n"
-    end
-  end
-  
-  def test_invalid_header_key_with_colon
-    parser = HTTPTools::Parser.new
-    
-    assert_raise(HTTPTools::ParseError) do
-      parser << "GET / HTTP/1.1\r\nx-invalid:key: text/plain\r\n"
-    end
-  end
-    
   def test_invalid_header_key_with_control_character
     parser = HTTPTools::Parser.new
     
@@ -457,7 +437,7 @@ class RequestTest < Test::Unit::TestCase
     parser = HTTPTools::Parser.new
     
     assert_raise(HTTPTools::ParseError) do
-      parser << "GET / HTTP/1.1\r\nx-invalid-kéy: text/plain\r\n"
+      parser << "GET / HTTP/1.1\r\nx-invalid\000key: text/plain\r\n"
     end
   end
   
@@ -465,7 +445,7 @@ class RequestTest < Test::Unit::TestCase
     parser = HTTPTools::Parser.new
     
     assert_raise(HTTPTools::ParseError) do
-      parser << "GET / HTTP/1.1\r\nAccept: téxt/plain\r\n"
+      parser << "GET / HTTP/1.1\r\nAccept: \000text/plain\r\n"
     end
   end
   
@@ -478,4 +458,67 @@ class RequestTest < Test::Unit::TestCase
     assert_instance_of(HTTPTools::ParseError, error)
   end
   
+  def test_env
+    parser = HTTPTools::Parser.new
+    env = nil
+    parser.on(:header) {env = parser.env}
+    
+    parser << "GET /test?q=foo HTTP/1.1\r\n"
+    parser << "Host: www.example.com\r\n"
+    parser << "Accept: text/html\r\n"
+    parser << "\r\n"
+    
+    assert_equal("GET", env["REQUEST_METHOD"])
+    assert_equal("", env["SCRIPT_NAME"])
+    assert_equal("/test", env["PATH_INFO"])
+    assert_equal("q=foo", env["QUERY_STRING"])
+    assert_equal(nil, env["SERVER_NAME"])
+    assert_equal(nil, env["SERVER_PORT"])
+    assert_equal("www.example.com", env["HTTP_HOST"])
+    assert_equal("text/html", env["HTTP_ACCEPT"])
+    
+    assert_equal([1,1], env["rack.version"])
+    assert_equal("http", env["rack.url_scheme"])
+    assert_equal(nil, env["rack.input"])
+    assert_equal(STDERR, env["rack.errors"])
+    assert_equal(false, env["rack.multithread"])
+    assert_equal(false, env["rack.multiprocess"])
+    assert_equal(false, env["rack.run_once"])
+  end
+  
+  def test_env_with_trailer
+    parser = HTTPTools::Parser.new
+    env = nil
+    parser.on(:finish) {env = parser.env}
+    
+    parser << "POST /submit HTTP/1.1\r\n"
+    parser << "Host: www.example.com\r\n"
+    parser << "Transfer-Encoding: chunked\r\n"
+    parser << "Trailer: X-Checksum\r\n"
+    parser << "\r\n"
+    parser << "5\r\nHello\r\n"
+    parser << "6\r\n world\r\n0\r\n"
+    parser << "X-Checksum: 3e25960a79dbc69b674cd4ec67a72c62\r\n"
+    parser << "\r\n"
+    
+    assert_equal("POST", env["REQUEST_METHOD"])
+    assert_equal("", env["SCRIPT_NAME"])
+    assert_equal("/submit", env["PATH_INFO"])
+    assert_equal("", env["QUERY_STRING"])
+    assert_equal(nil, env["SERVER_NAME"])
+    assert_equal(nil, env["SERVER_PORT"])
+    assert_equal("www.example.com", env["HTTP_HOST"])
+    assert_equal("chunked", env["HTTP_TRANSFER_ENCODING"])
+    assert_equal("X-Checksum", env["HTTP_TRAILER"])
+    assert_equal("3e25960a79dbc69b674cd4ec67a72c62", env["HTTP_X_CHECKSUM"])
+    
+    assert_equal([1,1], env["rack.version"])
+    assert_equal("http", env["rack.url_scheme"])
+    assert_equal(nil, env["rack.input"])
+    assert_equal(STDERR, env["rack.errors"])
+    assert_equal(false, env["rack.multithread"])
+    assert_equal(false, env["rack.multiprocess"])
+    assert_equal(false, env["rack.run_once"])
+  end
+  
 end