narf 0.6.3 → 0.7.1

data/sapi/win/narf.c

@@ -0,0 +1,29 @@
+#define _CRTBLD
+
+#include <ruby.h>
+#include <windows.h>
+#include <stdio.h>
+
+int main(int argc, char *argv[])
+{
+  int state;
+  ruby_init();
+  ruby_init_loadpath();
+  ruby_script("narf");
+  ruby_set_argv(argc, argv);
+  rb_eval_string_protect("require 'web/runner'; Web::Runner::run(ARGV[1] || ENV['PATH_TRANSLATED']);", &state);
+  if (state) {
+    rb_p( ruby_errinfo );
+  }
+}
+
+/*
+
+  int state;
+
+  rb_eval_string_protect("require 'web/runner'", &state);
+  if (state) {
+    rb_p(ruby_errinfo);
+  } return state;
+  */
+

data/scripts/makedist.rb

@@ -18,10 +18,19 @@ version  = ARGV[2]
 
 versiontag = "VERSION_#{version.gsub(/\./,'_')}"
 
-svn = "svn --username #{username} --password #{ password }"
+system( "rm narf*.gem" )
+gemspec = File.open( "narf.gemspec", "r" ) { |f|
+  f.read
+}
+gemspec.sub(/s.version = "\d.\d.\d"/,
+            "s.version = \"#{version}\"" )
+File.open("narf.gemspec", "w" ) { |f|
+  f.write gemspec
+}
 
+svn = "svn --username #{username} --password #{ password }"
 system( "#{svn} log > ChangeLog")
-system( "#{svn} commit -m \"Updated ChangeLog for #{version}\"" )
+system( "#{svn} commit -m \"Preparing for #{version} release\"" )
 system( "#{svn} delete #{NARF_SVN_SERVER}/releases/#{versiontag} -m \"Deleted any existing release branch for #{version}\"" )
 system( "#{svn} copy #{NARF_SVN_SERVER}/trunk/ #{NARF_SVN_SERVER}/releases/#{versiontag} -m \"Created release branch for #{version}\"" )
 
@@ -33,16 +42,15 @@ system("#{svn} export #{NARF_SVN_SERVER}/releases/#{versiontag} narf-#{version}"
 
 system("cd narf-#{version}; ruby build.rb rdoc");
 system("tar cvzf narf-#{version}.tgz narf-#{version}")
+
+# update sourcefoge
 system("ncftpput upload.sourceforge.net incoming narf-#{version}.tgz")
+system("gem build narf.gemspec")
+system("ncftpput upload.sourceforge.net incoming narf-#{version}.gem")
 
-# old stuff
-#system("cvs2cl.pl -T --hide-filenames")
-#system("cvs commit -m \"Updated ChangeLog\"")
-#system("cvs -d :ext:pinetops@cvs.narf-lib.sourceforge.net:/cvsroot/narf-lib rtag -FD now #{versiontag} cgi-install.rb")
-#Dir.chdir("../dist")
-#system("cvs -d :ext:pinetops@cvs.narf-lib.sourceforge.net:/cvsroot/narf-lib export -r #{versiontag} -d narf-#{version} cgi-install.rb ")
-# end old stuff
+# update raa
 
+# update ruby-forge
 
 
 

data/test/{bufferedtestrunner.rb → cgi/bufferedtestrunner.rb~}

@@ -9,7 +9,7 @@
 
 require 'test/unit/ui/testrunnermediator'
 require 'test/unit/ui/testrunnerutilities'
-require 'test/stringio'
+require 'test/cgi/stringio'
 
 module Test
 	module Unit

data/test/{test.action.rb → cgi/test.action.rb}

@@ -1,7 +1,7 @@
 module Web
     class Action
 	def Action.clear_actions
-	    @@all_actions = []
+          Thread::current[:actions] = [ ]
 	end
     end
 end
@@ -90,11 +90,14 @@ class TestAction < Test::Unit::TestCase
     end
 
     def test_pick_action_picks_the_most_specific_action
-	one = Web::Action.new( "name" => // )
-	second = Web::Action.new( "name" => "patrick" )
-	third = Web::Action.new( "name" => /patrick|tom/ )
-
-	assert_equal( second, Web::Action.pick( cgi({ "name" => "patrick"}) ) )
+      one = Web::Action.new( "name" => // ) { assert false }
+      second = Web::Action.new( "name" => "patrick" ) { assert true }
+      third = Web::Action.new( "name" => /patrick|tom/ ) { assert false }
+      
+      # for some reason, object ids change with thread local variables
+      # assert_equal( second, Web::Action.pick( cgi({ "name" => "patrick"}) ) )
+      
+      Web::Action.pick( cgi({ "name" => "patrick"}) ).run
     end
 
     def test_set_default_action
@@ -123,18 +126,19 @@ class TestAction < Test::Unit::TestCase
     end
 
     def test_run
-	cgi_params = { "name" => "patrick" }
-	test_params = {}
-
-	Web::Action.new { |cgi|
-	    test_params = cgi.multiple_params
-	}
-
-	Web::Action.run :params => cgi_params, :out => ""
-
-	assert_equal( cgi_params, test_params )
+      cgi_params = { "name" => "patrick" }
+      test_params = {}
+      
+      Web::Action.new { |cgi|
+        test_params = cgi.multiple_params
+      }
+      
+      Web::set_cgi nil
+      Web::Action.run :params => cgi_params, :out => ""
+
+      assert_equal( cgi_params, test_params )
     end
-
+    
     def todo_test_subclassing_action
 
     end

data/test/cgi/test.action.rb~

@@ -0,0 +1,147 @@
+module Web
+    class Action
+	def Action.clear_actions
+          Thread::current[:actions] = [ ]
+	end
+    end
+end
+
+class TestAction < Test::Unit::TestCase
+    def set_up
+    end
+    
+    def teardown
+	@output = @cgi = @action = @stored_pattern = nil
+	Web::Action.clear_actions
+    end
+
+    def output
+	@output ||= ""
+    end
+
+    def cgi params={}
+	Web::CGI.new( :out => output, :params => params )
+    end
+
+    def stored_pattern pattern={}
+	@stored_pattern ||= pattern
+    end
+
+    def action( pattern=stored_pattern, &function )
+	@action ||= Web::Action.new( pattern, &function )
+    end
+
+    def test_failed_match_on_blank_cgi
+	action( "name" => // )
+	assert_equal( false, action.applies?(cgi) )
+    end
+
+    def test_fails_with_different_params
+	action "name" => //
+	assert_equal( false, action.applies?(cgi( {"not" => "me"} )) )
+    end
+
+    def test_matchs_by_param_present
+	action "name" => //
+	assert action.applies?(cgi( {"name" => "something"}) )
+    end
+    
+    def test_matches_exact_param
+	action "name" => "patrick"
+	assert action.applies?(cgi( {"name" => "patrick" } ))
+	assert_equal( false, action.applies?(cgi( {"name" => "patrick.may"} ) ))
+    end
+
+    def test_matches_pattern
+	action "name" => /patrick|tom/
+	assert action.applies?(cgi( {"name" => "patrick the great" } ))
+	assert action.applies?(cgi( {"name" => "tom the silly" } ))
+    end
+	
+    def test_match_is_not_anal
+	action "name" => //
+	assert action.applies?(cgi( {"name" => "something", "ignore" => "me"} ))
+    end
+
+    def test_runs_block
+	action_ran_flag = false
+	action( "name" => // ) {
+	    action_ran_flag = true
+	}
+
+	action.run
+
+	assert action_ran_flag
+    end
+
+    def test_guards_block
+	Web::Action.new.run
+    end
+
+    def test_passes_cgi_in_with_run
+	action_ran_flag = false
+	action( "name" => // ){ |cgi|
+	    action_ran_flag = cgi.key? "flag"
+	}
+
+	action.run cgi( "flag" => "it ran" )
+
+	assert action_ran_flag
+    end
+
+    def test_pick_action_picks_the_most_specific_action
+      one = Web::Action.new( "name" => // ) { assert false }
+      second = Web::Action.new( "name" => "patrick" ) { assert true }
+      third = Web::Action.new( "name" => /patrick|tom/ ) { assert false }
+      
+      # for some reason, object ids change with thread local variables
+      # assert_equal( second, Web::Action.pick( cgi({ "name" => "patrick"}) ) )
+      
+      Web::Action.pick( cgi({ "name" => "patrick"}) ).run
+    end
+
+    def test_set_default_action
+	default = Web::Action.new
+	another = Web::Action.new( "this" => "that", "here" => "there" )
+	assert_equal( default, Web::Action.pick( cgi ) )
+    end
+
+# this test causes no initial default action
+#    def test_raises_exception_if_no_action_is_found
+#	assert_raises(Web::Exception){ 
+#	    Web::Action.pick cgi
+#	}
+#    end
+
+    def test_doesnt_raise_exception_if_no_exception_is_found
+	Web::Action.pick(cgi).run
+    end
+
+    def test_blank_action_doesnt_mask_default
+	Web::Action.pick(cgi).run
+
+	default = Web::Action.new
+
+	assert_equal( default, Web::Action.pick(cgi) )
+    end
+
+    def test_run
+      cgi_params = { "name" => "patrick" }
+      test_params = {}
+      
+      Web::Action.new { |cgi|
+        test_params = cgi.multiple_params
+      }
+      
+      Kernel.p Thread::current[:actions]
+      Web::set_cgi nil
+      Web::Action.run :params => cgi_params, :out => ""
+
+      assert_equal( cgi_params, test_params )
+    end
+    
+    def todo_test_subclassing_action
+
+    end
+    
+end

data/test/{test.formreader-2.0.rb → cgi/test.formreader-2.0.rb}

@@ -151,7 +151,7 @@ class TestFormReader2 < Test::Unit::TestCase
     ### nothing was entered?
     assert_equal( {"file" => [""] }, merge_fields )
     
-    upload = Web::Upload.new( File.new( "test/testfiles/text" ),
+    upload = Web::Upload.new( File.new( "test/cgi/testfiles/text" ),
                               "content-type",
                               "original-filename" ) 
     assert_equal( { "file" => [upload] },

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

@@ -0,0 +1,104 @@
+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
+
+    # instead of one instance per output stream,
+    # how about one instance per thread
+    # this is tested by testing installation under webrick
+    def deprecated_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/cgi/test.request.rb

@@ -0,0 +1,363 @@
+require 'test/cgi/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/cgi/testfiles/text" ),
+					           "content-type",
+						   "original-filename" ) }
+    end
+
+    def cookies
+	{ "aCookie" => "Peanut Butter" }
+    end
+    
+    def cgi
+	@cgi ||= Web::CGI.new( :params => params,
+		 :cookies => cookies, :out => self.out )
+    end
+    
+    def out
+      @out ||= ""
+    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.set_cgi cgi
+      
+      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_params
+	assert_equal( ["aString"], cgi.params["string"] )
+	assert_equal( ["one", "two", "three"], cgi.params["array[]"] )
+	assert_equal( "original-filename", cgi.params["file"][0].original_filename )
+	assert_equal( 1, cgi.params["file"].length)
+
+	assert_equal( [], cgi.params["non-existent"] )
+      
+      Web.get_cgi.params = cgi.params
+      
+      assert_equal( ["aString"], Web::params["string"] )
+      assert_equal( ["one", "two", "three"], Web::params["array[]"] )
+      assert_equal( "original-filename", Web::params["file"][0].original_filename )
+      assert_equal( 1, Web::params["file"].length)
+      
+      assert_equal( [], Web::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/cgi/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/cgi/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/cgi/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
+
+    def options
+      {}
+    end
+
+    def test_mac_ie_multipart_bug
+      require 'yaml'
+      test_env = nil
+      File.open("test/cgi/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/cgi/testfiles/mac_ie_stdin.bin", "r") { |f|
+          $stdin = f
+          
+          parse_request
+          
+          assert_equal "test",      @multiple_params["text"].first
+          assert_equal Web::Upload, @multiple_params["small"].first.class
+          assert_equal 15,          @multiple_params["button.x"].first.to_i
+          assert_equal 11,          @multiple_params["button.y"].first.to_i
+        }
+      ensure
+        backup_env.each{ |k,v|
+          ENV[k] = v
+        }
+      end
+
+    end
+end
+
+class TestUpload < Test::Unit::TestCase
+    attr_reader :original_filename, :content_type, :test_file, :move_to
+    def setup
+      @test_file         = "test/cgi/testfiles/pic hydra.png"
+      @original_filename = "c:\\workspace\\hydra.png"
+      @content_type      = "image/png"
+      @move_to           = "test/cgi/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