narf 0.6.2 → 0.6.3

data/test/test.action.rb~

@@ -1,142 +0,0 @@
-module Web
-    class Action
-	def Action.clear_actions
-	    @@all_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.has_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" => // )
-	second = Web::Action.new( "name" => "patrick" )
-	third = Web::Action.new( "name" => /patrick|tom/ )
-
-	assert_equal( second, Web::Action.pick( cgi({ "name" => "patrick"}) ) )
-    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
-	}
-
-	Web::Action.run :params => cgi_params, :out => ""
-
-	assert_equal( cgi_params, test_params )
-    end
-
-    def todo_test_subclassing_action
-
-    end
-    
-end

data/test/test.assertinclude.rb~

@@ -1,109 +0,0 @@
-class TestHashCompare < Test::Unit::TestCase
-    def test_includes_same
-	assert_includes( {"a" => "aa"}  , {"a" => "aa"} )
-    end
-
-    def test_includes_missing
-	e = assert_raises( Test::Unit::AssertionFailedError ) {
-	    assert_includes( { "a" => "aa", "b" => "bb" }  , {"a" => "aa"} )
-	}
-        assert_equal "Missing from actual: b => \"bb\".", e.to_s
-    end
-
-    def test_includes_different
-	e = assert_raises( Test::Unit::AssertionFailedError ) {
-	    assert_includes( {"a" => "aa"}   , { "a" => "bb" } )
-	}
-        assert_equal "Difference: required <a => \"aa\"> was <a => \"bb\">.", e.to_s
-    end
-
-    def test_includes_multi_level
-	e = assert_raises( Test::Unit::AssertionFailedError ) {
-	    assert_includes( {"a" => { "a" => "aa", "b" => "bb" }}   , { "a" => { "a" => "aa", "b" => "cc"}} )
-	}
-        assert_equal "Difference: required <a.b => \"bb\"> was <a.b => \"cc\">.", e.to_s
-    end
-
-    def test_includes_array_with_difference
-	e = assert_raises( Test::Unit::AssertionFailedError ) {
-	    assert_includes( {"a" => [{ "a" => "aa" }, {"b" => "bb" }]},{ "a" => [ {"a" => "aa"}, {"b" => "cc"}]})
-	}
-        assert_equal "Difference: required <a[1].b => \"bb\"> was <a[1].b => \"cc\">.", e.to_s
-    end
-
-    def test_includes_array_with_items_missing
-	e = assert_raises( Test::Unit::AssertionFailedError ) {
-	    assert_includes( { "a" => [ {"a" => "aa"}, {"b" => "cc"}]} , {"a" => [{ "a" => "aa" }]} )
-	}
-        assert_equal "Missing from actual: a[1] => {\"b\"=>\"cc\"}.", e.to_s
-    end
-
-    def test_includes_hash_when_should_not
-	e = assert_raises( Test::Unit::AssertionFailedError ) {
-	    assert_includes( {"a" => "b"}  , { "a" => { "a" => "aa", "b" => "cc"}} )
-	}
-        assert_equal "Difference: required <a => \"b\"> was <a => {\"a\"=>\"aa\", \"b\"=>\"cc\"}>.", e.to_s
-    end
-
-    def test_does_not_include_hash_when_it_should
-	e = assert_raises( Test::Unit::AssertionFailedError ) {
-	    assert_includes( { "a" => { "a" => "aa" , "b" => "cc"}}, {"a" => "b"}  )
-	}
-        assert_equal "Difference: required <a => {\"a\"=>\"aa\", \"b\"=>\"cc\"}> was <a => \"b\">.", e.to_s
-    end
-
-    def test_includes_array_when_should_not
-	e = assert_raises( Test::Unit::AssertionFailedError ) {
-	    assert_includes( {"a" => "a"}, { "a" => [ {"a" => "aa"}, {"b" => "cc"}]} )
-	}
-        assert_equal "Difference: required <a => \"a\"> was <a => [{\"a\"=>\"aa\"}, {\"b\"=>\"cc\"}]>.", e.to_s
-    end
-
-    def test_does_not_include_array_when_it_should
-	e = assert_raises( Test::Unit::AssertionFailedError ) {
-	    assert_includes( {"a" => "b"}  , { "a" => { "a" => "aa" , "b" => "cc"}} )
-	}
-        assert_equal "Difference: required <a => \"b\"> was <a => {\"a\"=>\"aa\", \"b\"=>\"cc\"}>.", e.to_s
-    end
-
-    def test_assert_includes
-        assert_includes( {"a" => { "a" => "aa" }}, { "a" => { "a" => "aa" , "b" => "aa"}} )
-    end
-
-    def test_assert_includes2
-        assert_raises (Test::Unit::AssertionFailedError) {
-            assert_includes( { "a" => { "a" => "aa" , "b" => "cc"}}, {"a" => { "c" => "bb" },"b" => { "c" => "bb" }})
-        }
-    end
-
-    def test_assert_includes_array
-        assert_includes( ["a"],[ "a","b"] )
-    end
-    
-    def test_demonstrate_failure
-        assert_raises (Test::Unit::AssertionFailedError) {
-            assert_includes(["a","b"],[ "a"])
-        }
-    end
-
-    class Trivial
-	attr_accessor :name
-	def initialize( name )
-	    @name = name
-	end
-    end
-    
-    def test_compare_object_tree_to_hash
-	assert_includes({"name" => "patrick"}, Trivial.new("patrick"))
-    end
-
-    def test_compare_object_tree_to_hash
-	assert_includes({"name" => { "name" => "patrick" }}, Trivial.new(Trivial.new("patrick")))
-    end
-
-   
-    # TODO:
-    # reports an error if either item is not a hash
-    # improve error reporting when comparing a hash to an array and vice versa
-    # add an enhanced version of assert equals
-end

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

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

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