narf 0.5.1

data/test/test.request.rb~

@@ -0,0 +1,318 @@
+require 'test/mod_ruby_stub'
+
+class TestRequest < Test::Unit::TestCase
+    
+  include Web::Parser
+
+  def env
+    ENV
+  end
+
+  def input
+    $stdin
+  end
+
+    def assert_keys( expected, found )
+       passes = true
+       expected.each { |k, v|
+          passes = false unless found[k] == v
+       }
+       passes
+    end
+
+    def setup
+	@stdin_back = $stdin
+    end
+
+    def teardown
+	ENV["QUERY_STRING"  ] = nil
+	ENV["REQUEST_METHOD"] = nil
+	ENV["CONTENT_TYPE"  ] = nil
+	ENV["CONTENT_LENGTH"] = nil
+	ENV["HTTP_COOKIE"   ] = nil
+	ENV["COOKIE"        ] = nil
+	$stdin = @stdin_back
+
+	if defined? MOD_RUBY
+	    Object.module_eval{ remove_const :MOD_RUBY }
+	end
+      @cgi = nil
+    end
+
+    def params
+	{ "string" => "aString",
+	    "array[]"  => ["one", "two", "three"],
+	    "file"   => Web::Upload.new( File.new( "test/testfiles/text" ),
+					           "content-type",
+						   "original-filename" ) }
+    end
+
+    def cookies
+	{ "aCookie" => "Peanut Butter" }
+    end
+    
+    def cgi
+	@cgi ||= Web::CGI.new( :params => params,
+		 :cookies => cookies )
+    end
+    
+    def test_mock_cookies
+	assert_equal( Web::Parser.normalize(cookies), cgi.cookies )
+    end
+
+    def test_convenience_defaults_to_param
+	assert_equal( "aString", cgi["string"] )
+    end
+
+    def test_convenience_returns_array
+	assert_equal( ["one", "two", "three"], cgi["array[]"] )
+    end
+
+    def test_setting_params
+      assert_equal( "aString", cgi["string"] )
+      assert_equal( ["one", "two", "three"], cgi["array[]"] )
+
+      cgi["array[]"] = ["four", "five", "six"]
+      cgi["string"]  = "another_string"
+      
+      assert_equal( "another_string", cgi["string"] )
+      assert_equal( ["four", "five", "six"], cgi["array[]"] )
+
+    end
+    
+    def test_single_param
+	assert_equal( "aString", cgi.single_param("string") )
+	assert_equal( "one,two,three", cgi.single_param("array[]") )
+	assert_equal( "original-filename", cgi.single_param("file").original_filename )
+
+	assert_equal( "", cgi.single_param("non-existent") )
+    end
+
+    def test_multiple_params
+	assert_equal( ["aString"], cgi.multiple_params["string"] )
+	assert_equal( ["one", "two", "three"], cgi.multiple_params["array[]"] )
+	assert_equal( "original-filename", cgi.multiple_params["file"][0].original_filename )
+	assert_equal( 1, cgi.multiple_params["file"].length)
+
+	assert_equal( [], cgi.multiple_params["non-existent"] )
+      
+      Web.get_cgi.multiple_params = cgi.multiple_params
+      
+      assert_equal( ["aString"], Web::multiple_params["string"] )
+      assert_equal( ["one", "two", "three"], Web::multiple_params["array[]"] )
+      assert_equal( "original-filename", Web::multiple_params["file"][0].original_filename )
+      assert_equal( 1, Web::multiple_params["file"].length)
+      
+      assert_equal( [], Web::multiple_params["non-existent"] )
+    end
+
+    def test_keys
+	assert_equal( ["string", "array[]", "file"].sort, cgi.keys.sort )
+    end
+
+    def test_has_key?
+	assert cgi.key?( "string" )
+	assert cgi.key?( "array[]" )
+	assert cgi.key?( "file" )
+	
+	assert ((cgi.key? "missing key") == false)
+    end
+
+    def test_parse_query_string
+	assert_equal({}, {})
+	assert_keys( {"query1"=>["~value1"], "query2"=>["value1", "value2"] },
+		      Web::Parser.parse_query_string('query1=%7Evalue1&query2=value1&query2=value2') )
+    end
+
+    def test_parse_nil_cookie
+	assert_keys( {}, Web::Parser.parse_cookie(nil) )
+	assert_equal( [], Web::Parser.parse_cookie(nil).default )
+    end
+
+    def test_parse_cookie
+	assert_equal( {"cookie1"=>["~value1"], "cookie2"=>["value1", "value2"]}.inspect,
+		      Web::Parser.parse_cookie("cookie1=%7Evalue1; cookie2=value1; cookie2=value2").inspect )
+    end
+
+    def test_parse_multiple_cookies
+	assert_equal( {"cookie"=>["~value1", "value 2"]}.inspect,
+		      Web::Parser.parse_cookie("cookie=%7Evalue1&value%202").inspect )
+    end
+
+    def test_parse_blank_cookie
+	assert_keys( {"cookie"=>[]},
+		      Web::Parser.parse_cookie("cookie=") )
+    end
+
+    def test_cgi_parses_by_default
+	ENV["REQUEST_METHOD"] = "GET"
+	ENV["QUERY_STRING"]   = "key=a%20value&anotherKey=another%20value"
+	assert_keys( {"key" => ["a value"], "anotherKey" => ["another value"] },
+		     Web::CGI.new.multiple_params )
+    end
+
+    def test_cgi_parses_http_cookie
+	ENV['HTTP_COOKIE'] = "cookie1=%7Evalue1; cookie2=value1; cookie2=value2"
+	assert_keys( {"cookie1"=>["~value1"], "cookie2"=>["value1", "value2"]},
+		      Web::CGI.new.cookies )
+    end
+
+    def test_cgi_parses_cookie
+	ENV['COOKIE'] = "cookie1=%7Evalue1; cookie2=value1; cookie2=value2"
+
+	assert_keys( {"cookie1"=>["~value1"], "cookie2"=>["value1", "value2"]},
+		      Web::CGI.new.cookies )
+    end
+
+    def test_cgi_only_parses_cookies_once
+	ENV['HTTP_COOKIE'] = "cookie1=%7Evalue1; cookie2=value1; cookie2=value2"
+	ENV['COOKIE'] = "cookie1=%7Evalue1; cookie2=value1; cookie2=value2"
+	assert_keys( {"cookie1"=>["~value1"], "cookie2"=>["value1", "value2"]},
+		      Web::CGI.new.cookies )
+    end
+    
+    def test_parse_empty_query_string
+	ENV["REQUEST_METHOD"] = "GET"
+	assert_keys( {}, parse_params )
+    end
+
+    def test_parse_get_query_string
+	ENV["REQUEST_METHOD"] = "GET"
+	ENV["QUERY_STRING"]   = "key=a%20value&anotherKey=another%20value"
+	assert_keys( {"key" => ["a value"], "anotherKey" => ["another value"]},
+		      parse_params )
+    end
+
+    def test_parse_get_multiples
+	ENV["REQUEST_METHOD"] = "GET"
+	ENV["QUERY_STRING"]   = "key=a%20value&key=another%20value"
+	assert_keys( {"key" => ["a value", "another value"]}, parse_params )
+    end
+
+    def test_parse_head_like_get
+	ENV["REQUEST_METHOD"] = "HEAD"
+	assert_keys( {}, parse_params )
+
+	teardown
+
+	ENV["REQUEST_METHOD"] = "HEAD"
+	ENV["QUERY_STRING"]   = "key=a%20value&anotherKey=another%20value"
+	assert_keys( {"key" => ["a value"], "anotherKey" => ["another value"]},
+		      parse_params )
+    end
+
+    def test_parse_post
+	ENV["REQUEST_METHOD"] = "POST"
+	ENV["CONTENT_LENGTH"] = "40"
+	File.open( "test/testfiles/post.data" ){ |post_data|
+	    $stdin = post_data
+	    assert_keys( {"key" => ["a value"], "anotherKey" => ["another value"]},
+                         parse_params )
+	}
+    end
+
+#    def test_parse_multiparts
+#	multipart_test( 19441, "---------------------------1934113851018", "mozilla" )
+#	multipart_test( 19483, "---------------------------22501762916738", "netscape4" )
+#	multipart_test( 19480, "---------------------------7d21f962d00c4", "explorer5" )
+#    end
+
+    def multipart_test( content_length, boundary, browser )
+	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|
+	    $stdin = post_data
+	    multipart_asserts
+	}
+    end
+
+    def multipart_asserts
+	params = Web::Request.parse
+	assert_equal( ["key", "file"], params.keys )
+	assert_equal( ["value"], params["key"] )
+	assert_equal( 1, params["file"].length )
+	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|
+	    test_image.binmode
+	    params["file"][0].binmode
+	    assert_equal( test_image.read, params["file"][0].read )
+	}
+    end
+
+    def test_parse_two_uploaded_files
+
+    end
+
+#-------------------------------------------------------
+#    I've been unable to get this test to work right.
+#    For some reason, the code inside Request.parse
+#    can't see the MOD_RUBY constant I'm trying to set.
+#
+#    Tracing statements have shown that the
+#    if(defined?MOD_RUBY) in Request.parse returns false
+#    but if(defined?MOD_RUBY) returns true within the
+#    test's scope.
+#-------------------------------------------------------
+#    def test_parse_get_with_mod_ruby
+#	Object.const_set( :MOD_RUBY, true )
+#	assert_equal( {"key" => ["some value"], "anotherKey" => ["someother value"]},
+#		      Web::Request.parse )
+#    end
+
+    # this test added so I can test the effect of above apart from the cause
+    #def test_mod_ruby_query_string
+#	assert_equal( "key=some%20value&anotherKey=someother%20value",
+#		      Web::CGD.mod_ruby_query_string )
+#    end
+
+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"
+      @original_filename = "c:\\workspace\\hydra.png"
+      @content_type      = "image/png"
+      @move_to           = "test/testfiles/moved_hydra.png"
+    end
+
+    def test_initialize
+	File.open( test_file ) { |file|
+	    upload = Web::Upload.new( file, content_type, original_filename )
+
+	    assert_equal(   content_type,      upload.content_type      )
+	    assert_equal(   original_filename, upload.original_filename )
+	}
+    end
+    
+    def test_initialize_with_filename
+        upload = Web::Upload.new( test_file, content_type, original_filename )
+
+	assert_equal( File.open( test_file, "r" ) { |f| f.read }, upload.read )
+    end
+
+    def test_read_open_and_write_file
+      expected_contents = File.open( test_file, "r" ) { |f| f.read }
+
+      upload = Web::Upload.new( test_file, content_type, original_filename )
+
+      assert_equal( expected_contents, upload.read )
+
+      upload.open{ |io|
+        assert_equal( expected_contents, io.read )
+      }
+
+      begin
+        upload.write_to_file( move_to )
+        File.open( move_to, "r" ) { |io|
+          assert_equal( expected_contents, io.read )
+        }
+      ensure
+        File.delete( move_to )
+      end
+
+    end
+end

data/test/test.response.rb

@@ -0,0 +1,565 @@
+require 'test/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_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