narf 0.5.1

data/test/test.response.rb~

@@ -0,0 +1,556 @@
+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