ruby-web 1.1.1

data/test/web/test.request.rb

@@ -0,0 +1,368 @@
+require 'test/web/mod_ruby_stub'
+
+class TestRequest < Test::Unit::TestCase
+  
+  def env
+    ENV
+  end
+
+  def raw_post_data
+    $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
+    
+    @get = @post = @cookies = 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/web/testfiles/text" ),
+                                  "content-type",
+                                  "original-filename" ) }
+  end
+  
+  def cookie
+    { "aCookie" => "Peanut Butter" }
+  end
+  
+  def cgi
+    @cgi ||= Web::Connection.new( :request => params,
+                                  :cookie => cookie,
+                                  :out => self.out )
+  end
+  
+  def out
+    @out ||= ""
+  end
+  
+  def test_mock_cookies
+    assert_includes( Web::Connection.normalize(cookie), cgi.cookie )
+  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.request["string"] )
+    assert_equal( ["one", "two", "three"], cgi.request["array[]"] )
+    assert_equal( "original-filename", cgi.request["file"][0].original_filename )
+    assert_equal( 1, cgi.request["file"].length)
+    
+    assert_equal( [], cgi.request["non-existent"] )
+    
+    Web.connection = cgi
+    
+    assert_equal( ["aString"], Web::request["string"] )
+    assert_equal( ["one", "two", "three"], Web::request["array[]"] )
+    assert_equal( "original-filename", Web::request["file"][0].original_filename )
+    assert_equal( 1, Web::request["file"].length)
+    
+    assert_equal( [], Web::request["non-existent"] )
+  end
+
+  def test_request
+    assert_equal( ["aString"], cgi.request["string"] )
+    assert_equal( ["one", "two", "three"], cgi.request["array[]"] )
+    assert_equal( "original-filename", cgi.request["file"][0].original_filename )
+    assert_equal( 1, cgi.request["file"].length)
+    
+    assert_equal( [], cgi.request["non-existent"] )
+    
+    Web.connection = cgi
+    
+    assert_equal( ["aString"], Web::request["string"] )
+    assert_equal( ["one", "two", "three"], Web::request["array[]"] )
+    assert_equal( "original-filename", Web::request["file"][0].original_filename )
+    assert_equal( 1, Web::request["file"].length)
+    
+    assert_equal( [], Web::request["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::Connection.parse_query_string('query1=%7Evalue1&query2=value1&query2=value2') )
+    
+  end
+
+  def test_parse_nil_cookie
+    assert_keys( {},  Web::Connection::CookieHash.new(nil) )
+    assert_equal( [], Web::Connection::CookieHash.new(nil).default )
+  end
+
+  def test_parse_cookie
+    assert_equal( {"cookie1"=>["~value1"], "cookie2"=>["value1", "value2"]}.inspect,
+                  Web::Connection::CookieHash.new("cookie1=%7Evalue1; cookie2=value1; cookie2=value2").inspect )
+  end
+
+  def test_parse_multiple_cookies
+    assert_equal( {"cookie"=>["~value1", "value 2"]}.inspect,
+                  Web::Connection::CookieHash.new("cookie=%7Evalue1&value%202").inspect )
+  end
+
+  def test_parse_blank_cookie
+    assert_keys( {"cookie"=>[]},
+                 Web::Connection::CookieHash.new("cookie=") )
+  end
+
+  def test_parse_get_and_post
+    ENV["REQUEST_METHOD"] = "POST"
+    ENV["QUERY_STRING"]   = "key=get_value_1&get_only=get_value_2"
+    ENV["CONTENT_LENGTH"] = "40"
+    File.open( "test/web/testfiles/post.and.get.data" ){ |post_data|
+      $stdin = post_data
+
+      cgi = Web::Connection.new
+
+      assert_equal( {"key" => ["get_value_1"],  "get_only"  => ["get_value_2"] },
+                    cgi.get )
+      assert_equal( {"key" => ["post_value_1"], "post_only" => ["post_value_2"]},
+                    cgi.post )
+      assert_equal( {"key" => ["post_value_1"], "get_only"  => ["get_value_2"], "post_only" => ["post_value_2"]},
+                    cgi.request )
+    }
+  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::Connection.new.get )
+    assert_keys( {"key" => ["a value"], "anotherKey" => ["another value"] },
+                 Web::Connection.new.request )
+  end
+  
+  def test_cgi_parses_http_cookie
+    ENV['HTTP_COOKIE'] = "cookie1=%7Evalue1; cookie2=value1; cookie2=value2"
+    assert_keys( {"cookie1"=>["~value1"], "cookie2"=>["value1", "value2"]},
+                 Web::Connection.new.cookie )
+    assert_keys( {"cookie1"=>["~value1"], "cookie2"=>["value1", "value2"]},
+                 Web::Connection.new.request )
+  end
+
+  def test_cgi_parses_cookie
+    ENV['COOKIE'] = "cookie1=%7Evalue1; cookie2=value1; cookie2=value2"
+    
+    assert_keys( {"cookie1"=>["~value1"], "cookie2"=>["value1", "value2"]},
+                 Web::Connection.new.cookie )
+  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::Connection.new.cookie )
+  end
+  
+  def test_parse_empty_query_string
+    ENV["REQUEST_METHOD"] = "GET"
+    cgi = Web::Connection.new
+    assert_equal( {}, cgi.request )
+  end
+  
+  def test_parse_get_query_string
+    ENV["REQUEST_METHOD"] = "GET"
+    ENV["QUERY_STRING"]   = "key=a%20value&anotherKey=another%20value"
+    cgi = Web::Connection.new
+    assert_equal( {"key" => ["a value"], "anotherKey" => ["another value"]}, cgi.request )
+  end
+
+  def test_parse_get_multiples
+    ENV["REQUEST_METHOD"] = "GET"
+    ENV["QUERY_STRING"]   = "key=a%20value&key=another%20value"
+    cgi = Web::Connection.new
+    assert_equal( {"key" => ["a value", "another value"]}, cgi.request )
+  end
+
+  def test_parse_head_like_get
+    ENV["REQUEST_METHOD"] = "HEAD"
+    cgi = Web::Connection.new
+    assert_equal( {}, cgi.request )
+    
+    teardown
+
+    ENV["REQUEST_METHOD"] = "HEAD"
+    ENV["QUERY_STRING"]   = "key=a%20value&anotherKey=another%20value"
+    cgi = Web::Connection.new
+    assert_equal( {"key" => ["a value"], "anotherKey" => ["another value"]},
+                  cgi.request )
+  end
+
+  def test_parse_post
+    ENV["REQUEST_METHOD"] = "POST"
+    ENV["CONTENT_LENGTH"] = "40"
+    File.open( "test/web/testfiles/post.data" ){ |post_data|
+      $stdin = post_data
+      cgi = Web::Connection.new
+
+      assert_equal( "key=a%20value&anotherKey=another%20value", cgi.raw_post_data.read )
+      assert_keys( {"key" => ["a value"], "anotherKey" => ["another value"]},
+                   cgi.post )
+      assert_keys( {"key" => ["a value"], "anotherKey" => ["another value"]},
+                   cgi.request )
+    }
+  end
+
+  # TODO: add multipart tests for mozilla, netscape 4, explorer 5
+  def test_parse_multiparts
+    multipart_test(177696,
+                   '----------0xKhTmLbOuNdArY',
+                   'mac-safari-fallow_dump.bin' )
+  end
+
+  def multipart_test( content_length, boundary, datafile )
+    ENV["REQUEST_METHOD"] = "POST"
+    ENV["CONTENT_LENGTH"] = content_length.to_s
+    ENV["CONTENT_TYPE"  ] = "multipart/form-data, boundary=#{ boundary }"
+    
+    @stdin = $stdin
+    
+    File.open( "test/web/testfiles/#{ datafile }" ) do |post_data|
+      $stdin = post_data
+      multipart_asserts
+    end
+  ensure
+    $stdin = @stdin
+  end
+
+  def multipart_asserts
+    progress_events = [ ]
+    Web::config[:multipart_progress_hook] = lambda do |total, read|
+      progress_events.push [total, read]
+    end
+    params = Web::open(:out=>'') do |connection|
+      connection.request
+    end
+    
+    image = 'fallow_keep.png.450x450.2005-07-24.jpg'
+    assert_equal( ["key", "file"], params.keys )
+    assert_equal( "value", params["key"] )
+    assert_match( /#{image}/, params["file"].original_filename )
+    assert_match( /image/,    params["file"].content_type      )
+    assert_match( /jpeg/,     params["file"].content_type      )
+    File.open( "test/web/testfiles/#{image}" ) { |test_image|
+      test_image.binmode
+      assert_equal( test_image.read, params["file"].read )
+    }
+    assert_equal( [ [177667, 0],
+                   [177667, 10240],
+                   [177667, 177667] ],
+                  progress_events )
+  ensure
+    Web::config[:multipart_progress_hook] = nil
+  end
+  
+  ### TODO: What happens if you upload two files?
+  ###       What if they have the same name?
+  def test_parse_two_uploaded_files
+    
+  end
+
+  def test_downcase_env
+    ENV["KEY"] = "value"
+    env = Web::Connection::downcase_env( ENV )
+    ["key", "kEy", "kEY", "KEY", "KEy", "Key", "keY"].each{ |k|
+      assert( env.has_key?(k) )
+      assert_equal( "value", env[k] )
+    }
+  end
+
+  def options
+    {}
+  end
+
+  def test_mac_ie_multipart_bug
+    require 'yaml'
+    test_env = nil
+    File.open("test/web/testfiles/mac_ie_env.yaml", "r") { |f|
+      test_env = YAML.load(f)
+    }
+
+    backup_env = {}
+    test_env.each{ |k,v|
+      backup_env[k.downcase] = ENV[k.downcase]
+      ENV[k.downcase] = v
+    }
+    
+    begin
+      File.open("test/web/testfiles/mac_ie_stdin.bin", "r") { |f|
+        $stdin = f
+        
+        cgi.parse_request
+        
+        assert_equal "test",      cgi.post["text"].first
+        assert_equal Web::Upload, cgi.post["small"].first.class
+        assert_equal 15,          cgi.post["button.x"].first.to_i
+        assert_equal 11,          cgi.post["button.y"].first.to_i
+      }
+    ensure
+      backup_env.each{ |k,v|
+        ENV[k] = v
+      }
+    end
+  end
+end

data/test/web/test.response.rb

@@ -0,0 +1,637 @@
+require 'test/web/mod_ruby_stub'
+
+class TestResponse < Test::Unit::TestCase
+
+  def output
+    @output = StringIO.new unless @output
+    @output
+  end
+  
+  def unbuffered_response
+    @unbuffered_response ||= Web::Connection.new( :out => output, :buffered => false, :session => {} )
+    @unbuffered_response
+  end
+  
+  def nph_response
+    @nph_response ||= Web::Connection.new( :out => output, :nph => true, :session => {} )
+    @nph_response
+  end
+  
+  def response
+    @response ||= Web::Connection.new( :out => output, :session => {} )
+      @response
+  end
+  
+  def mod_response
+    require 'web/sapi/apache'
+    @mod_response ||= Web::ModRubyConnection.new( :out => output,
+                                               :session => {} )
+    @mod_response
+  end
+  
+  def setup
+    @old_record = $\
+    @old_newline = $/
+    @old_readline = $_
+    @old_stdin = $stdin
+    @output = nil
+  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_noheader
+    mockio = ""
+    response = Web::Connection.new( :out => mockio, :session => {}, :noheader => true )
+    response.add_header("Location",     "/home.html" )
+    response.print "Should be no headers"
+    response.flush
+    expected = "Should be no headers"
+    assert_equal( expected, mockio )
+  end
+  
+  def test_outputs
+    mockio = ""
+    response = Web::Connection.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::Connection.new(:out=>"")
+    Web::connection = cgi
+    cgi.send_file( "test/web/test_send_file.txt" )
+    cgi.assert_content( "test_send_file\n" )
+    cgi.assert_header( "Content-Type", "text/plain" )
+    
+    cgi.write "no more output should be written"
+    cgi.assert_content( "test_send_file\n" )
+    
+    
+    
+    # test we don't clobber an existing header
+    cgi = Web::Connection.new(:out=>"")
+    Web::connection = cgi
+    cgi.content_type = "xapplication/ms-excel"
+    cgi.send_file( "test/web/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::Connection.new(:out=>"")
+    Web::connection = 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::Connection.new(:out=>"")
+    Web::connection = 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::Connection.new
+
+    assert_equal( $stdout, response.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::Connection::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::Connection::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
+    assert_equal( [ ], response.get_cookie( "not there" ) )
+    assert_equal( [ ], response.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" )
+
+    assert_equal( [ ], response.get_cookie( "myCookie" ) )
+    assert_equal( [ ], response.get_cookie( "key" ) )
+    
+    if false
+      # do I really want to set @cookie values when we called set_cookie?
+      # it seems to make a mess, esp. with multiple cookies.
+      #   ~ patrick
+      
+      # test single
+      assert_equal( "myValue", response.get_cookie( "myCookie" ) )
+      assert_equal( "myValue", response.cookie["myCookie"] )
+      
+      response.set_cookie( "myCookie", "another" )
+      assert_equal( "another", response.get_cookie( "myCookie" ) )
+      assert_equal( "another", response.cookie["myCookie"] )
+      
+      # test multiple
+      assert_equal( "something", response.get_cookie("key") )
+      assert_equal( "something", response.cookie["key"] )
+    end
+  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", nil )
+    
+    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
+
+    def test_stdin
+      c = nil
+      Web::open( :out => output ) do
+        c = Web::connection
+        Kernel::puts "Hello World"
+      end
+      c.assert_content( "Hello World\n" )
+    end
+    
+  end