narf 0.6.3 → 0.7.1

data/test/{test.request.rb → cgi/test.request.rb~}

@@ -1,4 +1,4 @@
-require 'test/mod_ruby_stub'
+require 'test/cgi/mod_ruby_stub'
 
 class TestRequest < Test::Unit::TestCase
     
@@ -42,7 +42,7 @@ class TestRequest < Test::Unit::TestCase
     def params
 	{ "string" => "aString",
 	    "array[]"  => ["one", "two", "three"],
-	    "file"   => Web::Upload.new( File.new( "test/testfiles/text" ),
+	    "file"   => Web::Upload.new( File.new( "test/cgi/testfiles/text" ),
 					           "content-type",
 						   "original-filename" ) }
     end
@@ -204,7 +204,7 @@ class TestRequest < Test::Unit::TestCase
     def test_parse_post
 	ENV["REQUEST_METHOD"] = "POST"
 	ENV["CONTENT_LENGTH"] = "40"
-	File.open( "test/testfiles/post.data" ){ |post_data|
+	File.open( "test/cgi/testfiles/post.data" ){ |post_data|
 	    $stdin = post_data
 	    assert_keys( {"key" => ["a value"], "anotherKey" => ["another value"]},
                          parse_params )
@@ -221,7 +221,7 @@ class TestRequest < Test::Unit::TestCase
 	ENV["REQUEST_METHOD"] = "POST"
 	ENV["CONTENT_LENGTH"] = content_length.to_s
 	ENV["CONTENT_TYPE"  ] = "multipart/form-data, boundary=#{ boundary }"
-	File.open( "test/testfiles/#{ browser }.multipart.data" ) { |post_data|
+	File.open( "test/cgi/testfiles/#{ browser }.multipart.data" ) { |post_data|
 	    $stdin = post_data
 	    multipart_asserts
 	}
@@ -235,7 +235,7 @@ class TestRequest < Test::Unit::TestCase
 	assert_match( /pic hydra.png/, params["file"][0].original_filename )
 	assert_match( /image/,         params["file"][0].content_type      )
 	assert_match( /png/,           params["file"][0].content_type      )
-	File.open( "test/testfiles/pic hydra.png" ) { |test_image|
+	File.open( "test/cgi/testfiles/pic hydra.png" ) { |test_image|
 	    test_image.binmode
 	    params["file"][0].binmode
 	    assert_equal( test_image.read, params["file"][0].read )
@@ -263,7 +263,7 @@ class TestRequest < Test::Unit::TestCase
     def test_mac_ie_multipart_bug
       require 'yaml'
       test_env = nil
-      File.open("test/testfiles/mac_ie_env.yaml", "r") { |f|
+      File.open("test/cgi/testfiles/mac_ie_env.yaml", "r") { |f|
         test_env = YAML.load(f)
       }
 
@@ -274,7 +274,7 @@ class TestRequest < Test::Unit::TestCase
       }
       
       begin
-        File.open("test/testfiles/mac_ie_stdin.bin", "r") { |f|
+        File.open("test/cgi/testfiles/mac_ie_stdin.bin", "r") { |f|
           $stdin = f
           
           parse_request
@@ -296,10 +296,10 @@ end
 class TestUpload < Test::Unit::TestCase
     attr_reader :original_filename, :content_type, :test_file, :move_to
     def setup
-      @test_file         = "test/testfiles/pic hydra.png"
+      @test_file         = "test/cgi/testfiles/pic hydra.png"
       @original_filename = "c:\\workspace\\hydra.png"
       @content_type      = "image/png"
-      @move_to           = "test/testfiles/moved_hydra.png"
+      @move_to           = "test/cgi/testfiles/moved_hydra.png"
     end
 
     def test_initialize

data/test/{test.response.rb → cgi/test.response.rb}

@@ -1,4 +1,4 @@
-require 'test/mod_ruby_stub'
+require 'test/cgi/mod_ruby_stub'
 
 class TestResponse < Test::Unit::TestCase
 
@@ -80,6 +80,43 @@ class TestResponse < Test::Unit::TestCase
 
     end
 
+    def test_send_file
+      # send file, and set a reasonable header
+      cgi = Web::CGI.new(:out=>"")
+      Web::set_cgi(cgi)
+      cgi.send_file( "test/cgi/test_send_file.txt" )
+      cgi.assert_content( "test_send_file\n" )
+      cgi.assert_header( "Content-Type", "text/plain" )
+      
+      # test we don't clobber an existing header
+      cgi = Web::CGI.new(:out=>"")
+      Web::set_cgi(cgi)
+      cgi.content_type = "xapplication/ms-excel"
+      cgi.send_file( "test/cgi/test_send_file.txt" )
+      cgi.assert_content( "test_send_file\n" )
+      cgi.assert_header( "Content-Type", "xapplication/ms-excel" )
+      
+      # this method should be useful for packagers
+      cgi = Web::CGI.new(:out=>"")
+      Web::set_cgi(cgi)
+      cgi.content_type = 'text/html'
+      Web::send_lib_file( "test_send_file.txt" )
+      cgi.assert_content( "test_send_file\n" )
+      cgi.assert_header( "Content-Type", "text/plain" )
+
+      # test we don't clobber an existing header
+      cgi = Web::CGI.new(:out=>"")
+      Web::set_cgi(cgi)
+      cgi.content_type = "xapplication/ms-excel"
+      Web::send_lib_file( "test_send_file.txt" )
+      cgi.assert_content( "test_send_file\n" )
+      cgi.assert_header( "Content-Type", "xapplication/ms-excel" )
+      
+      assert_equal( "test_send_file\n",
+                    Web::lib_file_contents( "test_send_file.txt" ) )
+      
+    end
+
     def test_default_out
 	response = Web::CGI.new
 
@@ -560,6 +597,6 @@ class TestResponse < Test::Unit::TestCase
 	$\ = "\n"
 	unbuffered_response.puts( "hello", 43770, "anyone?" )
 	assert_equal( add_header("hello\n43770\nanyone?\n"), output.string )
-	
     end
+
 end

data/test/cgi/test.response.rb~

@@ -0,0 +1,621 @@
+require 'test/cgi/mod_ruby_stub'
+
+class TestResponse < Test::Unit::TestCase
+
+    def output
+	@output = StringIO.new unless @output
+	@output
+    end
+
+    def unbuffered_response
+	@unbuffered_response ||= Web::CGI.new( :out => output, :unbuffered => true, :session => {} )
+	@unbuffered_response
+    end
+    
+    def nph_response
+	@nph_response ||= Web::CGI.new( :out => output, :nph => true, :session => {} )
+	@nph_response
+    end
+    
+    def response
+	@response ||= Web::CGI.new( :out => output, :session => {} )
+	@response
+    end
+
+    def mod_response
+      require 'web/sapi/mod_ruby'
+      @mod_response ||= Web::CGI.new( :out => output,
+                                  :session => {},
+                                  :cgd => Web::CGD::ModRuby.new( :out => output ) )
+      @mod_response
+    end
+
+    def setup
+	@old_record = $\
+	@old_newline = $/
+	@old_readline = $_
+	@old_stdin = $stdin
+    end
+
+    def teardown
+	$\ = @old_record
+	$/ = @old_newline
+	$_ = @old_readline
+	$stdin = @old_stdin
+	@output = @response = @nph_response = @unbuffered_response = @mod_response = nil
+	ENV["SCRIPT_NAME"] = nil
+	ENV["SERVER_PROTOCOL"] = nil
+	ENV["SERVER_SOFTWARE"] = nil
+	Apache.reset
+    end
+
+    def test_outputs
+      mockio = ""
+      response = Web::CGI.new( :out => mockio, :session => {} )
+      
+      response.content_type = "text/html"
+      response.add_header("Location",     "/home.html" )
+      response.print "He's just a NoWhere Man"
+      response.clear
+      response.print "Hello, World"
+      response.flush
+      
+      expected  = "Content-Type: text/html\r\n"
+      expected += "Location: /home.html\r\n"
+      expected += "Status: 200 OK\r\n"
+      expected += "\r\n"
+      expected += "Hello, World"
+      
+      assert_equal( expected, mockio )
+      
+      # flushing a second time doesn't send more output
+      response.flush
+      assert_equal( expected, mockio )
+
+      # can't clear output after headers have been sent
+      assert_raises( Exception ) {
+        response.clear
+      }
+      expected 
+
+    end
+
+    def test_send_file
+      # send file, and set a reasonable header
+      cgi = Web::CGI.new()
+      cgi.send_file( "test/cgi/test_send_file.txt" )
+      cgi.assert_content( "test_send_file\n" )
+      cgi.assert_header( "Content-Type", "text/plain" )
+
+      # test we don't clobber an existing header
+      cgi.content_type = "xapplication/ms-excel"
+      cgi.send_file( "test/cgi/test_send_file.txt" )
+      cgi.assert_content( "test_send_file\n" )
+      cgi.assert_header( "Content-Type", "xapplication/ms-excel" )
+
+      # this method should be useful for packagers
+      cgi.content_type = 'text/html'
+      cgi.send_lib_file( __FILE__, "test_send_file.txt" )
+      cgi.assert_content( "test_send_file\n" )
+      cgi.assert_header( "Content-Type", "text/plain" )
+
+      # test we don't clobber an existing header
+      cgi.content_type = "xapplication/ms-excel"
+      cgi.send_lib_file( __FILE__, "test_send_file.txt" )
+      cgi.assert_content( "test_send_file\n" )
+      cgi.assert_header( "Content-Type", "xapplication/ms-excel" )
+      
+      assert_equal( "test_send_file\n",
+                    Web::lib_file_contents( __FILE__,
+                                            "test_send_file.txt" ) )
+      
+    end
+
+    def test_output_handler
+      cgi = Web::CGI.new()
+      cgi.ob_start
+      cgi.write "hello "
+      assert_equal( "hello ", cgi.ob_get_contents )
+      cgi.ob_start
+      cgi.write "world"
+      assert_equal( "world", cgi.ob_get_contents )
+      assert_equal( "hello world", cgi.get_contents )
+      
+      cgi.ob_start
+      cgi.write "discard this text"
+      assert_equal( "discard this text", cgi.ob_get_contents )
+      cgi.ob_end_clean
+      assert_equal( "world", cgi.ob_get_contents )
+      assert_equal( "hello world", cgi.get_contents )
+      
+      cgi.ob_end_flush
+      assert_equal( "hello world", cgi.get_contents )
+      assert_equal( "hello world", cgi.ob_get_contents )
+      
+      
+      
+    end
+
+    def test_default_out
+	response = Web::CGI.new
+
+	assert_equal( $stdout, response.cgd.output )
+    end
+
+    def test_default_content_type
+	response.flush
+	assert_equal( "Content-Type: text/html\r\nStatus: 200 OK\r\n\r\n", output.string )
+    end
+
+    def test_set_content_type
+	response.content_type = "text/plain"
+	response.flush
+	assert_equal( "text/plain", response.content_type )
+	assert_equal( "Content-Type: text/plain\r\nStatus: 200 OK\r\n\r\n", output.string )
+
+	assert_raises( Web::Error ) {
+	    response.content_type = "text/something"
+	}
+    end
+
+    def test_set_charset_after_flush_raises_cgiexception
+	response.flush
+	assert_raises( Web::Error ) {
+	    response.charset = "foo"
+	}
+    end
+
+    def test_set_location
+	assert_equal( nil, response.location )
+	response.location = "/somewhere"
+	assert_equal( "/somewhere", response.location )
+	response.flush
+	assert_equal( "Content-Type: text/html\r\nLocation: /somewhere\r\nStatus: 200 OK\r\n\r\n", output.string )
+
+	assert_raises( Web::Error ) {
+	    response.location = "foo"
+	}
+    end
+
+    def test_encoding_sends_header
+	response.encoding = "7bit"
+	response.flush
+	assert_equal( "Content-Encoding: 7bit\r\nContent-Type: text/html\r\nStatus: 200 OK\r\n\r\n", output.string )
+
+	assert_raises( Web::Error ) {
+	    response.encoding = "foo"
+	}
+    end
+
+    def test_status_sends_header
+	response.status = "300"
+	response.flush
+	assert_equal( "Content-Type: text/html\r\nStatus: 300 Multiple Choices\r\n\r\n", output.string )
+
+	assert_raises( Web::Error ) {
+	    response.status = "500"
+	}
+    end
+
+    def test_status_message
+	Web::HTTP_STATUS.each{ |code, message|
+	    setup
+	    response.status = code
+	    response.flush
+	    assert_equal( "Content-Type: text/html\r\n" +
+			  "Status: #{ code } #{ message }\r\n\r\n",
+			  output.string )
+	    teardown
+	}
+    end
+
+    def test_set_status_with_i
+	Web::HTTP_STATUS.each{ |code, message|
+	    setup
+	    response.status = code.to_i
+	    response.flush
+	    assert_equal( "Content-Type: text/html\r\n" +
+			  "Status: #{ code } #{ message }\r\n\r\n",
+			  output.string )
+	    teardown
+	}
+    end
+
+    def test_get_header
+	# test no result
+	assert_equal( [], response.get_header("not there") )
+
+	response.add_header( "patrick", "dufus"        )
+	response.add_header( "tom",     "smarty-pants" )
+	response.add_header( "tom",     "drinker"      )
+
+	# test single
+	assert_equal( ["dufus"], response.get_header("patrick") )
+	# test multiple
+	assert_equal( ["smarty-pants", "drinker"], response.get_header("tom") )
+	# test state unaffected (return value, not reference)
+	response.get_header("patrick").push "drunk"
+	assert_equal( ["dufus"], response.get_header("patrick") )
+	# test case insensitivity
+	assert_equal( ["dufus"], response.get_header("PAtrIck") )
+    end
+
+    def test_assert_header
+	# missing header
+	assert_raises( Test::Unit::AssertionFailedError ){
+	    response.assert_header( "non-existent", "this header doesn't exist" )
+	}
+	
+	# incorrect header
+	response.add_header( "patrick", "dufus" );
+	assert_raises( Test::Unit::AssertionFailedError ){
+	    response.assert_header( "patrick", "genius" )
+	}
+
+	# works with single header
+	response.assert_header( "patrick", "dufus" );
+	# or array
+        response.assert_header( "patrick", ["dufus"] );
+
+	response.add_header( "patrick", "dumbo" );
+
+	# multiple headers need the whole array
+	assert_raises( Test::Unit::AssertionFailedError ){
+	    response.assert_header( "patrick", "dufus" )
+	}
+
+	# full array works
+	response.assert_header( "patrick", ["dufus", "dumbo"] )
+
+	# order matters
+	assert_raises( Test::Unit::AssertionFailedError ){
+	    response.assert_header( "patrick", ["dumbo", "dufus"] )
+	}
+				  
+    end
+
+    def test_add_header_only_adds_one
+	response.add_header( "Content-Type", "text/plain" )
+	response.add_header( "Content-Type", "text/fancy" )
+	response.add_header( "charset", "foo" )
+	response.add_header( "charset", "yoo" )
+	response.add_header( "Status", "300" )
+	response.add_header( "status", "404" )
+	response.add_header( "Content-Encoding", "7bit" )
+	response.add_header( "contEnt-enCoding", "16bit")
+	response.add_header( "location", "somewhere" )
+	response.add_header( "LocaTion", "somewhere/else" )
+	
+	response.flush
+
+	assert_equal( "Content-Encoding: 16bit\r\n" +
+		      "Content-Type: text/fancy; charset=yoo\r\n" +
+		      "Location: somewhere/else\r\n" +
+		      "Status: 404 Not Found\r\n\r\n",
+		      output.string )
+    end
+
+    def test_send_headers
+	assert_equal( "", output.string )
+	response.flush
+        assert_equal( "Content-Type: text/html\r\nStatus: 200 OK\r\n\r\n",
+		      output.string )
+	assert_raises( Web::Error ) {
+	    response.add_header("Set-Cookie", "something")
+	}
+	response << "Hello World"
+	response.flush
+        assert_equal( "Content-Type: text/html\r\nStatus: 200 OK\r\n\r\nHello World",
+		      output.string )
+    end
+
+    def test_send_multiple_headers
+	response.add_header( "Patrick", "Genius" )
+	response.add_header( "Patrick", "Dufus"  )
+	response.flush
+
+	expected = "Content-Type: text/html\r\nPatrick: Genius\r\nPatrick: Dufus\r\nStatus: 200 OK\r\n\r\n"
+        assert_equal( expected, output.string )
+    end
+
+    def test_send_nph_headers
+	nph_response.flush
+	assert_match( %r|HTTP/1.0: 200 OK\r\nDate: |, output.string )
+    end
+
+    def test_nph_uses_env_server_protocol
+	ENV["SERVER_PROTOCOL"] = "HTTP/1.1"
+	nph_response.flush
+	assert_match( %r|HTTP/1.1: 200 OK\r\nDate: |, output.string )
+    end
+
+    def test_nph_uses_status
+	nph_response.status = "300"
+	nph_response.flush
+	assert_match( %r|HTTP/1.0: 300 Multiple Choices\r\nDate: |, output.string )
+	assert_nil( /Status: 300/ =~ output.string )
+    end
+
+    def test_nph_sets_server_software
+	ENV["SERVER_SOFTWARE"] = "Narf"
+	nph_response.flush
+	assert_match( /Server: Narf/, output.string )
+    end
+
+    def test_nph_sets_server_software_to_default
+	nph_response.flush
+	assert_match( /Server: /, output.string )
+    end
+
+    def test_nph_doesnt_overwrite_server_software
+	ENV["SERVER_SOFTWARE"] = "Narf"
+	nph_response.add_header( "Server", "MyNarf" )
+	nph_response.flush
+	assert_match( /Server: MyNarf/, output.string )
+    end
+
+    def test_nph_mode_with_IIS
+	ENV["SERVER_SOFTWARE"] = "IIS"
+	response.flush
+	assert_match( %r|HTTP/1.0: 200 OK|, output.string )
+    end
+
+    def test_send_headers_with_mod_ruby
+      mod_response.set_cookie( "cookie",  "monster" )
+      mod_response.set_cookie( "bert",    "ernie"   )
+      mod_response.add_header( "Patrick", "cool"    )
+      
+      mod_response.send_header
+	
+      headers = Apache::request.headers_out
+      assert_equal( ["cookie=monster; path=", "bert=ernie; path="],
+                    headers["Set-Cookie"] )
+      assert_equal( "cool",      headers["Patrick"]              )
+      assert_equal( "200",       Apache.request.status_line      )
+      assert_equal( "text/html", Apache.request.content_type     )
+      assert_equal( nil,         Apache.request.content_encoding )
+      assert( Apache.request.sent? )
+    end
+
+    def test_send_charset_with_mod_ruby
+	mod_response.charset = "English"
+	mod_response.send_header
+	assert_equal( "text/html; charset=English", Apache.request.content_type )
+	assert( !Apache.request.headers_out.has_key?("Content-Type") )
+    end
+
+    def test_send_content_type_with_mod_ruby
+	mod_response.content_type = "text/something"
+	mod_response.send_header
+	assert_equal( "text/something", Apache.request.content_type )
+	assert( !Apache.request.headers_out.has_key?("Content-Type") )
+    end
+
+    def test_send_status_with_mod_ruby
+	mod_response.status = "300"
+	mod_response.send_header
+	assert_equal( "300", Apache::request.status_line )
+	assert( !Apache.request.headers_out.has_key?("Status") )
+    end
+
+    def test_send_encoding_with_mod_ruby
+	mod_response.encoding = "7bit"
+	mod_response.send_header
+	assert_equal( "7bit", Apache::request.content_encoding )
+	assert( !Apache.request.headers_out.has_key?("Content-Encoding") )
+    end
+
+    def test_append_type_and_charset
+	response.charset = "ISO"
+	response.flush
+	assert_equal( "Content-Type: text/html; charset=ISO\r\nStatus: 200 OK\r\n\r\n",
+		      output.string )
+    end
+
+    def test_charset
+	response.charset = "ISO"
+	assert_equal( "ISO", response.charset )
+    end
+
+    def test_redirect
+	eval <<-EVAL
+	def response.redirect
+	    @header["Location"]
+	end
+	EVAL
+
+	response.set_redirect("/somewhere")
+	assert_equal( "/somewhere", response.location )
+	assert_equal( "302",        response.status   )
+    end
+
+    def test_set_cookie
+	response.set_cookie("myCookie", "myValue",
+                            :path => "/path/" ,
+                            :domain => "mydomain.com",
+                            :expires => Time.gm(2002,2,3),
+                            :secure => true)
+	assert_equal( "myCookie=myValue; path=/path/; domain=mydomain.com; expires=Sun, 03 Feb 2002 00:00:00 GMT; secure", response.header["Set-Cookie"].to_s )
+    end
+
+    def test_get_cookie
+	# test blank result
+	assert_equal( [], response.get_cookie( "not there" ) )
+
+	response.set_cookie("myCookie", "myValue",
+                            :path => "/path/" ,
+                            :domain => "mydomain.com",
+                            :expires => Time.gm(2002,2,3),
+                            :secure => true)
+	response.set_cookie("key", "anything" )
+	response.set_cookie("key", "something" )
+
+	# test single
+	assert_equal( ["myValue"], response.get_cookie( "myCookie" ) )
+
+	# test unaffected state (return cookie value, not reference)
+	response.get_cookie( "myCookie" ).push( "another" )
+	assert_equal( ["myValue"], response.get_cookie( "myCookie" ) )
+
+	# test multiple
+	assert_equal( ["anything", "something"], response.get_cookie("key") )
+    end
+
+    def test_assert_cookie
+	# no cookie fails
+	assert_raises(Test::Unit::AssertionFailedError){
+	    response.assert_cookie( "no cookie", "monster hungry!" )
+	}
+
+	# no cookie passes
+	response.assert_cookie( "no cookie", [] )
+
+	response.set_cookie( "cookie", "monster" )
+	
+	# single cookie passes
+	response.assert_cookie( "cookie", "monster" )
+
+	# single cookie array passes
+	response.assert_cookie( "cookie", ["monster"] )
+    end
+
+    def test_insecure_cookie
+	response.set_cookie("myCookie", "myValue",
+                            :path => "/path/" ,
+                            :domain => "mydomain.com",
+                            :expires => Time.gm(2002,2,3) )
+        
+	assert_equal( "myCookie=myValue; path=/path/; domain=mydomain.com; expires=Sun, 03 Feb 2002 00:00:00 GMT", response.header["Set-Cookie"].to_s )
+
+	# clear for the next test
+	response.header["Set-Cookie"] = []
+	
+	response.set_cookie("myCookie", "myValue",
+                            :path => "/path/",
+                            :domain => "mydomain.com",
+                            :expires => Time.gm(2002,2,3),
+                            :secure => false)
+                        
+	assert_equal( "myCookie=myValue; path=/path/; domain=mydomain.com; expires=Sun, 03 Feb 2002 00:00:00 GMT", response.header["Set-Cookie"].to_s )
+    end
+
+    def test_leave_domain_off_cookie
+	response.set_cookie("myCookie", "myValue",
+                            :path => "/path/" ,
+                            :expires => Time.gm(2002,2,3),
+                            :secure => true)
+                        
+	assert_equal( "myCookie=myValue; path=/path/; expires=Sun, 03 Feb 2002 00:00:00 GMT; secure", response.header["Set-Cookie"].to_s )
+    end
+
+    def test_leave_path_off_cookie
+	response.set_cookie("myCookie", "myValue",
+                            :domain => "mydomain.com",
+                            :expires => Time.gm(2002,2,3),
+                            :secure => true)
+                        
+	    assert_equal( "myCookie=myValue; path=; domain=mydomain.com; expires=Sun, 03 Feb 2002 00:00:00 GMT; secure", response.header["Set-Cookie"].to_s )
+    end
+
+    def test_leave_expires_off_cookie
+	response.set_cookie("myCookie", "myValue",
+                            :path => "/path/" ,
+                            :domain => "mydomain.com",
+                            :secure => true)
+	
+	assert_equal( "myCookie=myValue; path=/path/; domain=mydomain.com; secure", response.header["Set-Cookie"].to_s )
+    end
+
+    def test_ie_path_support
+	ENV["SCRIPT_NAME"] = "http://www.localhost.com/cgi-bin/script.rb"
+	response.set_cookie("myCookie", "myValue" )
+	assert_equal( "myCookie=myValue; path=http://www.localhost.com/cgi-bin/", response.header["Set-Cookie"].to_s )
+    end
+
+    def test_values_are_escaped
+	response.set_cookie("angryCookie", "!@$#%^&*")
+	assert_equal( "angryCookie=%21%40%24%23%25%5E%26%2A; path=", response.header["Set-Cookie"].to_s )
+    end
+
+    def test_array_of_values
+	response.set_cookie( "meals", ["breakfast", "lunch", "dinner"] )
+	assert_equal( "meals=breakfast&lunch&dinner; path=", response.header["Set-Cookie"].to_s )
+    end
+
+    def test_setting_two_cookies
+	response.set_cookie( "first", "one" )
+	response.set_cookie( "next",  "two" )
+	assert_equal( ["first=one; path=", "next=two; path="], response.header["Set-Cookie"] )
+    end
+
+    def test_buffered_output
+	response.encoding = "kanji"
+	response.write( "Your page moved!" )
+	assert_equal( "", output.string )
+	response.set_redirect("/somewhere")
+	assert_equal( "", output.string )
+	
+	response.flush
+	
+	assert_equal( "Content-Encoding: kanji\r\n" +
+		      "Content-Type: text/html\r\n" +
+		      "Location: /somewhere\r\n" +
+		      "Status: 302 Found\r\n" +
+		      "\r\nYour page moved!",
+		      output.string )
+    end
+
+    def test_unbuffered_output
+	unbuffered_response << "Hello World"
+
+	assert_raises( Web::Error ) {
+	    unbuffered_response.add_header( "Patrick", "May" )
+	}
+
+	assert_equal( add_header("Hello World"), output.string )
+
+	# test flush doesn't affect unbuffered output
+	unbuffered_response.flush
+	assert_equal( add_header("Hello World"), output.string )
+    end
+
+    #-----------------------------------------
+    #  test output methods
+    #-----------------------------------------
+
+    def add_header( string )
+	"Content-Type: text/html\r\nStatus: 200 OK\r\n\r\n#{ string }"
+    end
+
+    def test_append
+	unbuffered_response << "Hello World"
+	assert_equal( add_header("Hello World"), output.string )
+    end
+
+    def test_write
+	unbuffered_response.write( "Hello World" )
+	assert_equal( add_header("Hello World"), output.string )
+    end
+
+#    I had trouble testing this
+#    def test_default_print
+#    end
+
+    def test_print_multiple_args
+	$\ = nil
+	unbuffered_response.print( "hello ", "world ", "im ", "here" )
+	assert_equal( add_header("hello world im here"), output.string )
+    end
+
+    def test_print_non_strings
+	unbuffered_response.print( "hello ", 43770 )
+	assert_equal( add_header("hello 43770"), output.string )
+    end
+
+    def test_puts
+	$\ = "\n"
+	unbuffered_response.puts( "hello", 43770, "anyone?" )
+	assert_equal( add_header("hello\n43770\nanyone?\n"), output.string )
+    end
+
+end