narf 0.5.1

data/test/test.mime-type.rb

@@ -0,0 +1,23 @@
+class TestMimeType < Test::Unit::TestCase
+  def test_all_mime_types_work
+    # this is somewhat circular.
+    Web::Mime.mime_types.each { |extension, mimetype|
+      assert_equal( mimetype,
+		    Web::Mime.get_mime_type( "../some/directory/file." + extension ) )
+    }
+  end
+
+  def test_some_standard_mimetypes
+    assert_equal( "text/plain",               Web::Mime.get_mime_type( "file.txt"  ) )
+    assert_equal( "text/html",                Web::Mime.get_mime_type( "file.html" ) )
+    assert_equal( "image/jpeg",               Web::Mime.get_mime_type( "file.jpg"  ) )
+    assert_equal( "application/zip",          Web::Mime.get_mime_type( "file.zip"  ) )
+    assert_equal( "application/octet-stream", Web::Mime.get_mime_type( "file.exe"  ) )
+
+    assert_equal( "text/plain",               Web::get_mime_type( "file.txt"  ) )
+    assert_equal( "text/html",                Web::get_mime_type( "file.html" ) )
+    assert_equal( "image/jpeg",               Web::get_mime_type( "file.jpg"  ) )
+    assert_equal( "application/zip",          Web::get_mime_type( "file.zip"  ) )
+    assert_equal( "application/octet-stream", Web::get_mime_type( "file.exe"  ) )
+  end
+end

data/test/test.narf.cgi.rb

@@ -0,0 +1,101 @@
+class TestWebCgi < Test::Unit::TestCase
+    def set_up
+	#@old_stderr = $stderr
+    end
+
+    def teardown
+	$stderr = $deferr #@old_stderr
+	@mockio = @params = @cookies = nil
+    end
+
+    def output
+	@mockio || (@mockio = ""; @mockio)
+    end
+    
+    def params
+	@params || (@params = { "field"  => "value"   }; @params)
+    end
+
+    def cookies
+	@cookies || (@cookies = { "cookie" => "monster" }; @cookies)
+    end
+
+    def options
+	@options || (@options =
+		     { :out => output, :params => params, :cookies => cookies };
+		     @options)
+    end
+
+    def cgi
+	@cgi || (@cgi = Web::CGI.new options; @cgi)
+    end
+
+    def test_initialize
+	assert_equal( output,  cgi.cgd.output        )
+	assert_equal( params,  cgi.multiple_params )
+	assert_equal( Web::Parser.normalize(cookies), cgi.cookies         )
+    end
+
+    def test_output
+	cgi << "<h1>Hello</h1>"
+	cgi.flush
+	assert_match( /Content-Type: text\/html\r\n/, output )
+	assert_match( /\r\n<h1>Hello<\/h1>/,          output )
+    end
+
+    def test_get_content
+	# test blank result
+	assert_equal( "", cgi.get_content )
+	
+	# test content
+	cgi << "<h1>hola mundo!</h1>"
+	assert_equal( "<h1>hola mundo!</h1>", cgi.get_content )
+
+	# test return value, not reference
+	content = cgi.get_content 
+	content += " some trailing garbage"
+	assert_equal( "<h1>hola mundo!</h1>", cgi.get_content )
+    end
+
+    def test_assert_content
+        assert_raises(Test::Unit::AssertionFailedError){
+	    cgi.assert_content "No content here"
+	}
+	cgi.write "Here is some content"
+	cgi.assert_content "Here is some content"
+    end
+
+    # this is a bit incomplete -- only encodes ampersands
+    def test_html_encode
+      assert_equal( '&amp;', Web::html_encode( '&' ) )
+    end
+
+    def test_escape
+	assert_equal( '%21%40%24%25%5E%26%2A%28%29', Web::escape('!@$%^&*()') )
+    end
+
+    def test_unescape
+	assert_equal( '!@$%^&*()', Web::unescape('%21%40%24%25%5E%26%2A%28%29') )
+    end
+
+    def test_rfc1123_date
+	assert_match( /[A-Z][a-z]{2}, \d{1,2} [A-Z][a-z]{2} \d{4} \d\d:\d\d:\d\d GMT/,
+		      Web::rfc1123_date(Time.now) )
+    end
+
+    def test_web_process_returns_the_cgi
+	cgi = Web.process( :out => "" ){ |cgi|
+	    cgi.write "Hello World"
+	}
+
+	assert_equal( "Hello World", cgi.get_content )
+    end
+
+    def test_get_instance_of_cgi_per_output_stream
+	out = ""
+	assert_equal Web::CGI.create( :out => out ), Web::CGI.create( :out => out )
+	assert_not_equal Web::CGI.create( :out => "" ), Web::CGI.create( :out => "" )
+    end
+end
+
+

data/test/test.narf.cgi.rb~

@@ -0,0 +1,105 @@
+class TestWebCgi < Test::Unit::TestCase
+    def set_up
+	#@old_stderr = $stderr
+    end
+
+    def teardown
+	$stderr = $deferr #@old_stderr
+	@mockio = @params = @cookies = nil
+    end
+
+    def output
+	@mockio || (@mockio = ""; @mockio)
+    end
+    
+    def params
+	@params || (@params = { "field"  => "value"   }; @params)
+    end
+
+    def cookies
+	@cookies || (@cookies = { "cookie" => "monster" }; @cookies)
+    end
+
+    def options
+	@options || (@options =
+		     { :out => output, :params => params, :cookies => cookies };
+		     @options)
+    end
+
+    def cgi
+	@cgi || (@cgi = Web::CGI.new options; @cgi)
+    end
+
+    def test_initialize
+	def cgi.outputer
+	    @outputer
+	end
+
+	assert_equal( output,  cgi.cgd.outputer        )
+	assert_equal( params,  cgi.multiple_params )
+	assert_equal( Web::Request.normalize(cookies), cgi.cookies         )
+    end
+
+    def test_output
+	cgi << "<h1>Hello</h1>"
+	cgi.flush
+	assert_match( /Content-Type: text\/html\r\n/, output )
+	assert_match( /\r\n<h1>Hello<\/h1>/,          output )
+    end
+
+    def test_get_content
+	# test blank result
+	assert_equal( "", cgi.get_content )
+	
+	# test content
+	cgi << "<h1>hola mundo!</h1>"
+	assert_equal( "<h1>hola mundo!</h1>", cgi.get_content )
+
+	# test return value, not reference
+	content = cgi.get_content 
+	content += " some trailing garbage"
+	assert_equal( "<h1>hola mundo!</h1>", cgi.get_content )
+    end
+
+    def test_assert_content
+        assert_raises(Test::Unit::AssertionFailedError){
+	    cgi.assert_content "No content here"
+	}
+	cgi.write "Here is some content"
+	cgi.assert_content "Here is some content"
+    end
+
+    # this is a bit incomplete -- only encodes ampersands
+    def test_html_encode
+      assert_equal( '&amp;', Web::html_encode( '&' ) )
+    end
+
+    def test_escape
+	assert_equal( '%21%40%24%25%5E%26%2A%28%29', Web::escape('!@$%^&*()') )
+    end
+
+    def test_unescape
+	assert_equal( '!@$%^&*()', Web::unescape('%21%40%24%25%5E%26%2A%28%29') )
+    end
+
+    def test_rfc1123_date
+	assert_match( /[A-Z][a-z]{2}, \d{1,2} [A-Z][a-z]{2} \d{4} \d\d:\d\d:\d\d GMT/,
+		      Web::rfc1123_date(Time.now) )
+    end
+
+    def test_web_process_returns_the_cgi
+	cgi = Web.process( :out => "" ){ |cgi|
+	    cgi.write "Hello World"
+	}
+
+	assert_equal( "Hello World", cgi.get_content )
+    end
+
+    def test_get_instance_of_cgi_per_output_stream
+	out = ""
+	assert_equal Web::CGI.create( :out => out ), Web::CGI.create( :out => out )
+	assert_not_equal Web::CGI.create( :out => "" ), Web::CGI.create( :out => "" )
+    end
+end
+
+

data/test/test.request.rb

@@ -0,0 +1,328 @@
+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
+
+    def test_downcase_env
+      ENV["KEY"] = "value"
+      env = downcase_env( ENV )
+      ["key", "kEy", "kEY", "KEY", "KEy", "Key", "keY"].each{ |k|
+        assert( env.has_key?(k) )
+        assert_equal( "value", env[k] )
+      }
+      
+    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