narf 0.6.2 → 0.6.3

data/test/test.template.rb~

@@ -1,832 +0,0 @@
-module TemplateTestEnvironment
-    def parse_template io, template , vars , query={}
-        templater = Web::Narflates.new(template,query)
-        templater.parse(io,vars)
-    end
-
-    def get_test_dir
-	File.expand_path(File.join(temp_dir,"test_dir2"))
-    end
-
-    def temp_file filename
-	File.expand_path(File.join(get_test_dir,"templates",filename))
-    end
-
-    def write_template contents, filename = "test.html"
-        File.open( File.expand_path(File.join(get_test_dir,"templates",filename))  ,"w") { | file | file.write contents }
-    end
-
-    def handle_request cgi, filename = "test.html"
-	cgi.print_template(  filename, { "var" => cgi["displayVar"] } )
-    end
-
-    def setup_test_dir
-	remove_test_dir
-	Dir.mkdir(get_test_dir)
-	Dir.mkdir(File.expand_path((File.join("#{get_test_dir}","templates"))))
-    end
-
-    def remove_test_dir
-	if File.exists? get_test_dir
-	  File.rm_rf(get_test_dir)
-	end
-    end
-
-    def write_file file
-	File.open( File.expand_path(File.join("#{get_test_dir}","app.rb")), "w" ) { |f| f.write(file) }
-    end
-end
-
-
-class TestTemplate < Test::Unit::TestCase
-    include TemplateTestEnvironment
-    include Web::Testing
-    
-    def setup
-      Web.set_docroot get_test_dir
-      Web.set_cgi( Web::CGI.new() )
-      setup_test_dir
-    end
-    
-    def teardown
-      remove_test_dir
-    end
-
-    def test_append_template_path
-      
-      assert_equal( [Dir.pwd,
-		     "#{temp_dir}/test_dir2/templates"],
-		    Web::template_include_path )
-
-      Web::template_include_path << "/.."
-      assert_equal( [Dir.pwd,
-		     "#{temp_dir}/test_dir2/templates",
-                     "/.."],
-		    Web::template_include_path )
-    end
-
-    def test_template_file
-      write_template( "here's a test" )
-      assert_equal( "#{temp_dir}/test_dir2/templates/test.html",
-		    Web::Narflates.template_file( "test.html" ) )
-      teardown
-      setup
-      
-      begin
-      	File.open( "test.html", "w" ) { |f|
-	  f.write("here's a test")
-	}
-	assert_equal( File.join( Dir.pwd, "test.html" ),
-		      Web::Narflates.template_file( "test.html" ) )
-      ensure
-	File.delete( "test.html" )
-      end
-      
-    end
-
-    def test_template_dir_precedence
-      write_template( "here's a test" )
-      begin
-      	File.open( "test.html", "w" ) { |f|
-	  f.write("here's a test")
-	}
-	assert_equal( File.join( Dir.pwd, "test.html" ),
-		      Web::Narflates.template_file( "test.html" ) )
-      ensure
-	File.delete( "test.html" )
-      end
-    end
-
-    # ========= Variable Resolution ==========
-
-    def test_print_vars
-	mockio = StringIO.new
-        template = "x{$foo}y{$bar}z"
-        vals = { "foo" => "FOO", "bar" => "BAR" }
-
-        parse_template(mockio, template, vals)
-        assert_equal "xFOOyBARz", mockio.string
-    end
-
-    def test_print_subvars
-	mockio = StringIO.new
-        template = "x{$foo.a}y{$foo.b}z{$bar}"
-
-        vals = { "foo" => { "a" => "1", "b" => "2" }, "bar" => "BAR" }
-
-        parse_template(mockio, template, vals)
-        assert_equal "x1y2zBAR", mockio.string
-    end
-
-    def test_throw_exception_if_subvar_doesnt_exist
-	mockio = StringIO.new
-        template = "x{$foo.a}y{$foo.b}z{$bar}"
-
-        vals = { "foo" => { "a" => "1" }, "bar" => "BAR" }
-
-        assert_raises(Web::Scope::VarNotFoundException) {
-            parse_template(mockio, template, vals)
-        }
-    end
-
-    def test_throw_exception_if_var_doesnt_exist
-	mockio = StringIO.new
-        template = "x{$foo}y{$bar}z"
-        vals = { "foo" => "FOO" }
-        
-        assert_raises(Web::Scope::VarNotFoundException) {
-            parse_template(mockio, template, vals)
-        }
-    end
-
-    def test_nil_values_display_nothing
-	mockio = StringIO.new
-        template = "x{$foo}yz"
-        vals = { "foo" => nil }
-
-        parse_template(mockio, template, vals)
-        assert_equal "xyz", mockio.string
-    end
-
-
-    class TestClass
-	attr_reader :var
-
-	def initialize var
-	    @var = var
-	end
-
-	def foo
-	    TestClass.new("XXX")
-	end
-    end
-
-    def test_print_method
-	mockio = StringIO.new
-        template = "x{$foo.var}y{$bar}z"
-        vals = { "foo" => TestClass.new("FOO"), "bar" => "BAR" }
-
-        parse_template(mockio, template, vals)
-        assert_equal "xFOOyBARz", mockio.string
-    end
-
-    def test_print_nested_method
-	mockio = StringIO.new
-        template = "x{$foo.foo.var}y{$bar}z"
-        vals = { "foo" => TestClass.new("FOO"), "bar" => "BAR" }
-
-        parse_template(mockio, template, vals)
-        assert_equal "xXXXyBARz", mockio.string
-    end
-
-    
-    # ========= ForEach ==========
-
-    def test_foreach
-	mockio = StringIO.new
-        template = "x<narf:foreach from=arr item=item>y{$item.a}{$item.b}y</narf:foreach>z"
-
-        vals = { "arr" => [ {"a" => "1", "b" => "2" }, { "a" => "3" , "b" => "4" } ] }
-
-        parse_template(mockio,template, vals)
-        assert_equal "xy12yy34yz", mockio.string
-    end
-
-    def test_foreach_with_empty_array
-	mockio = StringIO.new
-        template = "x<narf:foreach from=arr item=item>y{$item.a}{$item.b}y</narf:foreach>z"
-
-        vals = { "arr" => [ ] }
-
-        parse_template(mockio,template, vals)
-        assert_equal "xz", mockio.string
-    end
-
-
-    def test_nested_foreach
-	mockio = StringIO.new
-        template = "x<narf:foreach from=arr item=item><narf:foreach from=arrx item=itemx>{$itemx.b}{$item.a}</narf:foreach></narf:foreach>z"
-
-        vals = { 
-            "arr" => [ {"a" => "1" } ] ,
-            "arrx" => [ { "b" => "4" } ] }        
-
-        parse_template(mockio,template, vals)
-        assert_equal "x41z", mockio.string
-    end
-
-
-    def test_foreach_on_foreach
-	mockio = StringIO.new
-        template = "x<narf:foreach from=arr item=item><narf:foreach from=item.a item=item2>{$item.c}{$item2.b}</narf:foreach></narf:foreach>z"
-        
-        vals = { "arr" => [ {"a" => [ { "b" => "4" } ] , "c" => "1" } ]};
-
-        parse_template(mockio,template, vals)
-        assert_equal "x14z", mockio.string
-    end
-
-
-    def test_method_on_foreach
-	mockio = StringIO.new
-        template = "<narf:foreach from=items item=item>{$item.var}</narf:foreach>"
-        vals = { "items" => [ TestClass.new("FOO"), TestClass.new("BAR") ] }
-
-        parse_template(mockio, template, vals)
-        assert_equal "FOOBAR", mockio.string
-    end
-    
-    class TestEacher
-	include Enumerable
-	
-	def each(&block)
-	    [{"foo" => "bar"},{"foo" => "bar2"}].each &block
-	end
-    end
-
-    def test_foreach_on_object
-	mockio = StringIO.new
-        template = "<narf:foreach from=items item=item>{$item.foo}</narf:foreach>"
-        vals = { "items" => TestEacher.new() }
-
-        parse_template(mockio, template, vals)
-        assert_equal "barbar2", mockio.string
-    end
-
-    
-    #TODO foo.to_s is default
-
-    # ========= If ==========
-
-    def test_if
-	mockio = StringIO.new
-        template = "x<narf:if condition=a>aa</narf:if><narf:if condition=b>bb</narf:if>z"
-        vals = { "a" => true , "b" => false }
-	
-        parse_template(mockio,template, vals)
-        assert_equal "xaaz", mockio.string
-    end
-    
-    # ========= Unless ==========
-
-    def test_if
-	mockio = StringIO.new
-        template = "x<narf:unless condition=a>aa</narf:if><narf:unless condition=b>bb</narf:if>z"
-        vals = { "a" => false , "b" => true }
-	
-        parse_template(mockio,template, vals)
-        assert_equal "xaaz", mockio.string
-    end
-
-    # ========= Form ==========
-    
-    def test_form
-	mockio = StringIO.new
-        template = "<narf:form name=\"formname\" method=\"post\">{$item}</narf:form>"
-        vals = { "item" => "bar" }
-
-        parse_template(mockio, template, vals)
-        assert_equal "<form name=\"formname\" method=\"post\">"+
-	             "<input type=\"hidden\" name=\"__submitted\" value=\"formname\">"+
-	             "bar</form>", mockio.string
-    end
-
-    def test_add_query_to_form
-	mockio = StringIO.new
-        template = "<narf:form name=\"formname\" method=\"post\">{$item}</narf:form>"
-        vals = { "item" => "bar" }
-	
-        parse_template(mockio, template, vals , { "name1" => "value1", "name2" => "value2" })
-	assert_equal "<form name=\"formname\" method=\"post\">"+
-	     "<input type=\"hidden\" name=\"__submitted\" value=\"formname\">"+
-	     "<input type=\"hidden\" name=\"__q.name1\" value=\"value1\">"+
-	     "<input type=\"hidden\" name=\"__q.name2\" value=\"value2\">"+
- 	     "bar</form>", mockio.string
-    end
-
-    # ========= Input Box ==========
-    
-    def test_input_box
-	mockio = StringIO.new
-        write_template "<html><body><form name=\"form\">x<narf:input type=text name=test>y</form></body></html>"
-        vals = { "test" => "abc" }
-	
-        header = "Content-Type: text/html\r\nStatus: 200\r\n\r\n"
-	
-        cgi = Web::CGI.new( :out => mockio ) 
-        cgi.print_template( "test.html", vals )
-        assert_equal "<html><body><form name=\"form\">x<input type=\"text\" name=\"test\" value=\"abc\">y</form></body></html>", cgi.get_content
-      	cgi.assert_vars_includes "test" => "abc"
-        cgi.assert_form_includes "form" , { "test" => "abc" }
-    end
-
-    def test_input_box_in_form
-	mockio = StringIO.new
-        write_template "<html><body><form name=\"form\">x<narf:input type=text name=test>y</form></body></html>"
-        vals = { "test" => "abc" }
-
-        header = "Content-Type: text/html\r\nStatus: 200\r\n\r\n"
-
-        cgi = Web::CGI.new( :out => mockio ) 
-        cgi.print_template( "/test.html", vals )
-        assert_equal "<html><body><form name=\"form\">x<input type=\"text\" name=\"test\" value=\"abc\">y</form></body></html>", cgi.get_content
-        cgi.assert_vars_includes "test" => "abc"
-        cgi.assert_form_includes "form" , { "test" => "abc" }
-    end
-  
-    # ========= Text Area ==========
-
-    def test_textarea
-	write_file <<-EOF
-	    Web.print_template( "<html><body><form name='form1'>x<narf:textarea name=test1>y</form></body></html>", { "test1" => "test" } )
-	EOF
-	do_request "/app.rb"
-	assert_vars_includes "test1" => "test"
-	assert_form_includes "form1", { "test1" => "test" } 
-    end
-
-    # ========= Hidden ==========
-
-    def test_hidden
-	write_file <<-EOF
-	Web.print_template( "<html><body>"+
-			   " <form name='form1'>x"+
-			   "  <narf:input type=hidden name=test1>y"+
-			   " </form></body></html>", { 
-			       "test1" => "thisishidden",
-			   } )
-	EOF
-	do_request "/app.rb"
-	assert_vars_includes "test1" => "thisishidden"
-	assert_form_includes "form1", { "test1" => "thisishidden" } 
-    end
-
-
-    # ========= Password ==========
-
-    def test_password
-	write_file <<-EOF
-	Web.print_template( "<html><body>"+
-			   " <form name='form1'>x"+
-			   "  <narf:input type=password name=test1>y"+
-			   " </form></body></html>", { 
-			       "test1" => "thisishidden",
-			   } )
-	EOF
-	do_request "/app.rb"
-	assert_vars_includes "test1" => "thisishidden"
-	assert_form_includes "form1", { "test1" => "thisishidden" } 
-    end
-
-
-    # ========= Checkbox ==========
-    
-    def test_checkbox
-      write_file <<-EOF
-      Web.print_template( "<html><body>
-                           <form name='form1'>x
-                           <narf:input type=checkbox name=test1>y
-			   <narf:input type=checkbox name=test2>y
-			   </form></body></html>",
-                          { 
-                            "test1" => true,
-                           "test2" => false,
-                          } )
-      EOF
-      do_request "/app.rb"
-      assert_vars_includes "test1" => true, "test2" => false
-      assert_form_includes "form1", { "test1" => true, "test2" => false } 
-    end
-  end
-
-   
-class TestMultiHashTree1 < Test::Unit::TestCase
-    include TemplateTestEnvironment
-    include Web::Testing
-    
-    def setup
-	setup_test_dir
-	Web.set_docroot get_test_dir
-    end
-
-    def tear_down
-	remove_test_dir
-    end
-
-    def test_hidden_in_loop
-	write_file <<-EOF
-	Web.print_template( "<html><body>"+
-			   " <form name=form1>"+
-			   "  <narf:foreach from=items item=item>"+
-			   "   <narf:input type=hidden name=item.test1>"+
-			   "   <narf:input type=hidden name=item.test2>"+
-			   "  </narf:foreach>"+
-			   "</form></body></html>", { 
- 				   "items" => [ 
-				   { "test1" => "a", "test2" => "b" },
-				   { "test1" => "c", "test2" => "d" } ]
-			   } )
-	EOF
-	do_request "/app.rb"	
-      
-      assert_form_includes("form1",
-                           { "items" => [{"test1" => "a",
-                                          "test2" => "b" },
-                                         {"test1" => "c",
-                                          "test2" => "d" } ] } )
-
-      submitted = false
-      write_file <<-EOF
-      ["a"] == Web.split_params["items"][0]["test1"] || raise("no match")
-      ["b"] == Web.split_params["items"][0]["test2"] || raise("no match")
-      ["c"] == Web.split_params["items"][1]["test1"] || raise("no match")
-      ["d"] == Web.split_params["items"][1]["test2"] || raise("no match")
-      EOF
-      do_submit "form1"
-    end 
-
-    
-    def test_checkbox_in_loop
-	write_file <<-EOF
-	Web.print_template( "<html><body>"+
-			   " <form name='form1'>"+
-			   "  <narf:foreach from=items item=item>"+
-			   "   <narf:input type=checkbox name=item.test1>"+
-			   "   <narf:input type=checkbox name=item.test2>"+
-			   "  </narf:foreach>"+
-			   "</form></body></html>", { 
-			       "items" => [ 
-				   { "test1" => true, "test2" => false },
-				   { "test1" => false, "test2" => true } ]
-			       } )
-	EOF
-	do_request "/app.rb"
-	
-        assert /name=\"items\[0\].test1\"/ =~ Web.get_cgi.get_content
-        assert /name=\"items\[0\].test2\"/ =~ Web.get_cgi.get_content
-        assert /name=\"items\[1\].test1\"/ =~ Web.get_cgi.get_content
-        assert /name=\"items\[1\].test2\"/ =~ Web.get_cgi.get_content
-	
-	assert_form_includes "form1", { "items" => [ 
-          { "test1" => true, "test2" => false },
-          { "test1" => false, "test2" => true } ] }
-
-	write_file <<-EOF
-	[true] == Web.split_params["items"][0]["test1"] || raise("no match1")
-	nil ==  Web.split_params["items"][0]["test2"] || raise("no match2")
-	nil == Web.split_params["items"][1]["test1"] || raise("no match3")
-	[true] ==  Web.split_params["items"][1]["test2"] || raise("no match4")
-	EOF
-	do_submit "form1", {}
-    end 
-
-    def test_other_fields_in_loop
-	write_file <<-EOF
-	Web.print_template( "<html><body>"+
-			   " <form name='form1'>"+
-			   "  <input type='hidden' name='action' value='submit'>"+
-			   "  <narf:foreach from=items item=item>"+
-			   "   <narf:input type=text name=item.test1>"+
-			   "   <narf:input type=hidden name=item.test2>"+
-			   "  </narf:foreach>"+
-			   "</form></body></html>", { 
-			       "items" => [ 
-				   { "test1" => true, "test2" => false },
-				   { "test1" => false, "test2" => true } ]
-			   } )
-	EOF
-	do_request "/app.rb"
-	
-        assert /name=\"items\[0\].test1\"/ =~ Web.get_content
-        assert /name=\"items\[0\].test2\"/ =~ Web.get_content
-        assert /name=\"items\[1\].test1\"/ =~ Web.get_content
-        assert /name=\"items\[1\].test2\"/ =~ Web.get_content
-    end 
-
-    # ###
-    # this is a problem I need to think about.
-    # this is a use of checkboxes to represent boolean
-    # values, which isn't supported very well at the moment.
-    #   ~ patrick
-    def think_about_this_test_checkbox_in_loop_submit
-      write_file <<-EOF
-      Web.print_template( "<html><body>
-			   <form name='form1'>
-			     <input type='hidden' name='action' value='submit'>
-			     <narf:foreach from=items item=item>
-			      <narf:input type=checkbox name=item.test1>
-			      <narf:input type=checkbox name=item.test2>
-			     </narf:foreach>
-			   </form></body></html>", { 
-			       "items" => [ 
-				   { "test1" => true, "test2" => false },
-				   { "test1" => false, "test2" => true } ]
-			   } )
-      EOF
-      
-      do_request "/app.rb"
-
-      Kernel.puts Web.get_content
-      write_file <<-EOF
-      false == Web.split_params["items"][0]["test1"] || raise("no match 1")
-      true == Web.split_params["items"][0]["test2"] || raise("no match 2")
-      true == Web.split_params["items"][1]["test1"] || raise("no match 3")
-      true == Web.split_params["items"][1]["test2"] || raise("no match 4")
-      EOF
-      
-      do_submit( "form1", {"items[0].test1" => false,
-                           "items[0].test2" => true,
-                           "items[1].test1" => true, } )
-    end 
-
-
-    def test_double_nested_checkbox_in_loop
-	write_file <<-EOF
-	Web.print_template( "<html><body>"+
-			   " <form name='form1'>"+
-			   "  <narf:foreach from=itemsouter item=itemouter>"+
-			   "   <narf:foreach from=itemouter.itemsinner item=iteminner>"+
-			   "     <narf:input type=checkbox name=iteminner.test1>"+
-			   "   </narf:foreach>"+
-			   "  </narf:foreach>"+
-			   " </form></body></html>", { 
-			       "itemsouter" => [ 
-				   { "itemsinner" => [
-					   "test1"=>"value" ] } ] } 
-			   )
-	EOF
-	do_request "/app.rb"
-        assert /name=\"itemsouter\[0\].itemsinner\[0\].test1\"/ =~ Web.get_content
-    end
-
-    def test_select_box
-	mockio = StringIO.new
-        write_template "<html><body><form name=\"form\">x<narf:select name=test values=options>y</form></body></html>"
-        vals = { "test" => "value2",
-            "options" => [ { "name" => "name1", "value" => "value1" },
-                           { "name" => "name2", "value" => "value2" } ] }
-
-        cgi = Web::CGI.new( :out => mockio ) 
-        cgi.print_template( "/test.html", vals )
-        string = "<html><body><form name=\"form\">x<select name=\"test\">" +
-                 "<option value=\"value1\">name1</option>"+
-                 "<option value=\"value2\" selected>name2</option>"+
-                 "</select>y"+
-                 "</form></body></html>"
-
-        assert_equal string, cgi.get_content
-        assert_equal ["value2"], cgi.get_form_value( "form","test" )
-    end
-
-    def test_select_box_converts_to_strings
-        #--- first, one side of the problem...
-
-	mockio = StringIO.new
-        write_template "<html><body><form name=\"form\">x<narf:select name=test values=options>y</form></body></html>"
-        vals = { "test" => 2,
-            "options" => [ { "name" => "name1", "value" => "1" },
-                           { "name" => "name2", "value" => "2" } ] }
-
-        header = "Content-Type: text/html\r\nStatus: 200\r\n\r\n"
-
-        cgi = Web::CGI.new( :out => mockio ) 
-        cgi.print_template( "/test.html", vals )
-        string = "<html><body><form name=\"form\">x<select name=\"test\">" +
-                 "<option value=\"1\">name1</option>"+
-                 "<option value=\"2\" selected>name2</option>"+
-                 "</select>y"+
-                 "</form></body></html>"
-
-        assert_equal string, cgi.get_content
-        assert_equal ["2"], cgi.get_form_value( "form","test" )
-
-        #--- now the other
-
-	mockio = StringIO.new
-        write_template "<html><body><form name=\"form\">x<narf:select name=test values=options>y</form></body></html>"
-        vals = { "test" => "2",
-            "options" => [ { "name" => "name1", "value" => 1 },
-                           { "name" => "name2", "value" => 2 } ] }
-
-        header = "Content-Type: text/html\r\nStatus: 200\r\n\r\n"
-
-        cgi = Web::CGI.new( :out => mockio ) 
-        cgi.print_template( "/test.html", vals )
-        string = "<html><body><form name=\"form\">x<select name=\"test\">" +
-                 "<option value=\"1\">name1</option>"+
-                 "<option value=\"2\" selected>name2</option>"+
-                 "</select>y"+
-                 "</form></body></html>"
-
-        assert_equal string, cgi.get_content
-        assert_equal ["2"], cgi.get_form_value( "form","test" )
-
-    end
-
-
-    def test_select_box_from_array
-	mockio = StringIO.new
-        write_template "<html><body><form name=\"form\">x<narf:select name=test values=options>y</form></body></html>"
-        vals = { "test" => "value2",
-            "options" => [ "value1", "value2" ] }
-
-        header = "Content-Type: text/html\r\nStatus: 200\r\n\r\n"
-
-        cgi = Web::CGI.new( :out => mockio ) 
-        cgi.print_template( "/test.html", vals )
-        string = "<html><body><form name=\"form\">x<select name=\"test\">" +
-                 "<option value=\"value1\">value1</option>"+
-                 "<option value=\"value2\" selected>value2</option>"+
-                 "</select>y"+
-                 "</form></body></html>"
-
-        assert_equal string, cgi.get_content
-        assert_equal ["value2"], cgi.get_form_value( "form","test" )
-    end
-
-
-
-
-    def test_get_elements
-        p = HTMLTree::Parser.new(true, false)
-        p.feed('<html><head></head><body><form method=get name=test></form></body></html>')
-        assert_equal("test",p.html.get_elements("form")[0].attribute("name"))
-    end
-
-    def test_template
-        write_template "<html><body><h1>{$var}</h1></body></html>"
-	Web.process(:params => {"displayVar" => "foo"}, :out => ""){ |cgi|
-	    handle_request cgi
-	    cgi.assert_template_used( "test.html" )
-	    cgi.assert_vars_includes({ "var" => "foo" })
-	}
-    end
-
-    def test_exception_thrown_if_no_template_used
-        write_template "<html><body><h1>{$var}</h1></body></html>"
-	Web.process(:params => {"displayVar" => "foo"}, :out => ""){ |cgi|
-	    assert_raises(Web::TemplateException) {
-		cgi.assert_template_used( "/test.html" )
-	    }
-	}
-    end
-
-    def test_template_fails_assertion_with_wrong_template
-        write_template "<html><body><h1>{$var}</h1></body></html>"
-
-	Web.process(:out => "", :params => {"displayVar" => "bar"}){ |cgi|
-	    handle_request cgi
-	    
-	    assert_raises (Test::Unit::AssertionFailedError) {
-		cgi.assert_template_used( "test_not_it.html" )
-	    }
-
-	    assert_raises (Test::Unit::AssertionFailedError) {
-		cgi.assert_vars_includes({ "var" => "foo" })
-	    }
-	}
-    end
-    
-    def test_assert_template_not_used
-        write_template "<html><body><h1>{$var}</h1></body></html>"
-	Web.process(:params => {"displayVar" => "foo"}, :out => ""){ |cgi|
-	    handle_request cgi
-	    cgi.assert_template_not_used( "foo.html" )
-	}
-    end
-
-    def test_assert_template_not_used_exception_thrown_if_template_used
-        write_template "<html><body><h1>{$var}</h1></body></html>"
-	Web.process(:params => {"displayVar" => "foo"}, :out => ""){ |cgi|
-	    assert_raises(Test::Unit::AssertionFailedError) {
-                handle_request cgi
-		cgi.assert_template_not_used( "test.html" )
-	    }
-	}
-    end
-
-    def test_print_template_uses_empty_hash_by_default
-	write_template "blah blah blah"
-	Web.process( :out => "" ) { |cgi|
-	    cgi.print_template "test.html"
-	}.assert_content "blah blah blah"
-    end
-    
-    def test_print_template_survives_enormous_templates
-    	bad_template =  ""
-    
-    	1.upto(1000){ |i|
-    		bad_template += "this template sucks\n"
-    	}
-    	
-    	Web.process( :out => "" ) { |cgi|
-    		cgi.print_template bad_template
-    	}.assert_content bad_template	
-    end
-end
-
-
-class TestIncludes <  Test::Unit::TestCase
-    include TemplateTestEnvironment
-    include Web::Testing
-
-    def setup
-	Web.set_docroot get_test_dir
-	setup_test_dir
-    end
-    
-    def teardown
-	remove_test_dir
-    end
-
-
-    def test_include_prints_contents
-	write_template "<html><body><narf:include file=\"incfile.html\"></body></html>" , "test.html"
-        write_template "<h1>Hello</h1>", "incfile.html"
-	
-	write_file <<-EOF
-	    Web.print_template( "test.html", {} )
-	EOF
-	
-	do_request "/app.rb"
-	Web.assert_content "<html><body><h1>Hello</h1></body></html>"
-    end
-
-    def test_assert_template_used_works_for_included_templates
-	write_template "<html><body><narf:include file=\"incfile.html\" vars=foo></body></html>" , "test.html"
-        write_template "<h1>{$name}</h1>", "incfile.html"
-
-	write_file <<-EOF
-	    Web.print_template( "test.html" , { "foo" => { "name" => "bar" }} )
-	EOF
-	
-	do_request "/app.rb"
-	Web.assert_content "<html><body><h1>bar</h1></body></html>"
-
-	Web.assert_template_used 'test.html'
-	Web.assert_template_used 'incfile.html'
-    end
-
-    def todo_assert_template_used_works_for_multiple_print_template_calls
-
-    end
-
-    def test_included_vars_are_evaluated
-	write_template "<html><body><narf:include file=\"#{ 'incfile.html' }\" vars=foo></body></html>" , "test.html"
-        write_template "<h1>{$name}</h1>", "incfile.html"
-	
-	write_file <<-EOF
-	    Web.print_template(  "test.html" , { "foo" => { "name" => "bar" }} )
-	EOF
-
-	do_request "/app.rb"	
-	Web.assert_content "<html><body><h1>bar</h1></body></html>"
-    end
-
-    def test_checks_included_then_global_vars
-	write_template "<html><body><narf:include file=\"#{ 'incfile.html' }\"></body></html>" , "test.html"
-        write_template "<h1>{$foo.name}</h1>", "incfile.html"
-	
-	write_file <<-EOF
-	    Web.print_template(  "test.html" , { "foo" => { "name" => "bar" }} )
-	EOF
-	
-	Web.assert_content "<html><body><h1>bar</h1></body></html>"
-    end
-
-    def test_exception_thrown_if_template_doesnt_exist
-	write_template "<html><body><narf:include file=\"#{ 'nonexistant.html' }\"></body></html>" , "test.html"
-
-	write_file <<-EOF
-	    exceptionThrown = false
-	    begin
-		Web.print_template(  "test.html" , { "foo" => { "name" => "bar" }} )
-	    rescue Object
-		exceptionThrown = true
-	    end
-	    raise "error" if !exceptionThrown
-	EOF
-
-    	do_request "/app.rb"
-    end
-
-    def test_load_filename_from_var
-	write_template "<html><body><narf:include file=$incfile></body></html>" , "test.html"
-        write_template "<h1>{$foo.name}</h1>", "incfile.html"
-	
-	write_file <<-EOF
-	    Web.print_template(  "test.html" ,
-			       { "foo" => { "name" => "bar" }, "incfile" =>  "incfile.html" })
-	EOF
-	
-    	do_request "/app.rb"
-	Web.assert_content "<html><body><h1>bar</h1></body></html>"
-    end
-end
-
-
-# TODO:
-# add the ability to output the widgets manually
-# add the ability to define your own widgets
-# make sure you can't select an option that isn't in the option list
-# handle queries in an include