narf 0.6.2 → 0.6.3

data/test/test.response.rb~

@@ -1,556 +0,0 @@
-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 "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 )
-	response.flush
-	assert_equal( expected, mockio )
-
-	# and check that flushing again doesn't output anymore
-    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