ruby-web 1.1.1

data/test/web/test.ruby-web.rb

@@ -0,0 +1,10 @@
+class TestRubyWeb < Test::Unit::TestCase
+  def test_parse_options
+    args = ['ruby-web', '-a', '-b', '--something', '--', 'program', 'program opt']
+    switches = Web::argv_switches( args )
+    assert_equal( ['-a', '-b', '--something'], switches )
+    assert_equal( ['program', 'program opt'],  args     )
+  end
+end
+
+

data/test/web/test.session.rb

@@ -0,0 +1,50 @@
+class TestSession < Test::Unit::TestCase
+  def test_session_ids_are_uniq
+    assert_equal( 1000, Array.new( 1000 ).collect {
+    Web::Session.create_id
+  }.uniq.length )
+  end
+
+  def test_set_value_on_session
+    cgi = Web::Connection.new( :out => "" )
+    cgi.session["testvar"] = "test"
+    assert_equal( "test", cgi.session["testvar"] )
+  end
+
+  def test_session_end_to_end
+    cgi = Web::Connection.new( :out => "" )
+    cgi.session["key"] = ["value"]
+    session_id = cgi.cookies_sent["_session_id"]
+
+    Web::Connection.new( :out => "", :cookies => { "_session_id", session_id } )
+    
+    assert_equal( ["value"], cgi.session["key"] )
+  end
+
+  def test_clear_session
+    cgi = Web::Connection.new( :out => "" )
+    cgi.session["aKey"] = "aValue"
+    cgi.close
+
+    session_id = cgi.cookies_sent["_session_id"]
+    Web::Connection.new( :out => "", :cookies => { "_session_id", session_id } )
+
+    cgi.session.reset
+    assert_nil( cgi.session["aKey"] )
+  end
+  
+  def test_can_iterate_over_session
+    cgi = Web::Connection.new( :out => "" )
+    cgi.session["aKey"] = "1"
+    cgi.session["aKey2"] = "2"
+    cgi.close
+
+    values = []
+    cgi.session.each do |i,j|
+	    values << j
+    end
+    assert_equal [ "1" , "2" ], values
+  end
+end
+
+

data/test/web/test.shim.cgi.rb

@@ -0,0 +1,96 @@
+require 'web/shim/cgi'
+    
+class TestCGIShim < Test::Unit::TestCase
+  include Web::Testing
+  
+  def setup
+    @pwd = Dir.pwd
+    if File.exists?( temp_dir + "/test_dir/" )
+      rm_rf(temp_dir + "/test_dir")
+    end
+    Dir.mkdir(temp_dir + "/test_dir/")
+    Dir.chdir(temp_dir + "/test_dir/")
+    #@docroot = Web.get_docroot
+    #Web.set_docroot( temp_dir + "/test_dir/")
+  end
+    
+  def teardown
+    Dir.chdir(@pwd)
+    rm_rf(temp_dir + "/test_dir")
+    #Web.set_docroot( @docroot )
+  end
+  
+  def write_file file
+    File.open( temp_dir + "/test_dir/app.rb" , "w" ) do |f|
+      f.write <<-EOF
+      require 'web/shim/cgi'
+      cgi = CGI.new
+      require 'test/unit/assertions'
+      include Test::Unit::Assertions
+      EOF
+      f.write file
+    end
+  end
+
+  def test_single_params
+    write_file <<-EOF
+    assert_equal( 'Dave Thomas', cgi['name']   )
+    assert_equal( 'flexible',    cgi['reason'] )
+    EOF
+    
+    do_request( "app.rb",
+                'name' => 'Dave Thomas',
+                'reason' => 'flexible' )
+  end
+
+  def test_multiple_params
+    write_file <<-EOF
+    assert_equal( ['Dave Thomas'], cgi.params['name']   )
+    assert_equal( ['flexible',
+                   'transparent',
+                   'fun'],
+                  cgi.params['reason'] )
+    cgi.params['name'] = [ cgi['name'].upcase ]
+    assert_equal( {'name' => ['DAVE THOMAS'],
+                   'reason' => ['flexible','transparent','fun'] },
+                  cgi.params )
+    EOF
+    
+    do_request( "app.rb",
+                'name' => 'Dave Thomas',
+                'reason' => ['flexible','transparent','fun'] )
+
+  end
+
+  def test_has_key?
+    write_file <<-EOF
+    assert_equal( true,  cgi.has_key?('name') )
+    assert_equal( false, cgi.has_key?('age')  )
+    EOF
+    
+    do_request( "app.rb",
+                'name' => 'Dave Thomas',
+                'reason' => ['flexible','transparent','fun'] )
+  end
+  
+  def test_escape
+    str = "Nicholas Payton/Trumpet & Flugel Horn"
+    esc = 'Nicholas+Payton%2FTrumpet+%26+Flugel+Horn'
+    assert_equal(esc, CGI.escape(str)   )
+    assert_equal(str, CGI.unescape(str) )
+  end
+
+  def test_escapeHTML
+    str = 'a < 100 && b > 200'
+    esc = 'a &lt; 100 &amp;&amp; b &gt; 200'
+    assert_equal(esc, CGI.escapeHTML(str) )
+    assert_equal(str, CGI.unescapeHTML(esc) )
+  end
+
+  def test_escapeElement
+    str = '<hr><a href="/mp3">Click Here</a><br>'
+    esc = '<hr>&lt;a href=&quot;/mp3&quot;&gt;Click Here&lt;/a&gt;<br>'
+    assert_equal( esc, CGI::escapeElement( str, 'A' ) )
+    assert_equal( str, CGI::unescapeElement( str, 'A' ) )
+  end
+end

data/test/web/test.tagparser.rb

@@ -0,0 +1,65 @@
+class TestAttributeParser < Test::Unit::TestCase
+    def test_test_no_attributes
+	block_used = false
+	StrScanParser.new(StringScanner.new("<narf:name>")).match_tag { |tag|
+	    assert_equal( "name", tag.name )
+	    assert_equal( {}, tag.attributes )
+	    block_used = true
+	}
+	assert block_used
+    end
+
+    def test_test_one_attribute
+	block_used = false
+	StrScanParser.new(StringScanner.new("<narf:name foo=bar>")).match_tag { |tag|
+	    assert_equal( "name", tag.name )
+	    assert_equal( { "foo" => "bar" }, tag.attributes )
+	    block_used = true
+	}
+	assert block_used
+    end
+
+    def test_quoted_value
+	block_used = false
+	StrScanParser.new(StringScanner.new("<narf:name foo=\"bar x\">")).match_tag{ |tag|
+	    assert_equal( "name", tag.name )
+	    assert_equal( { "foo" => "bar x" }, tag.attributes )
+	    block_used = true
+	}
+	assert block_used
+    end
+
+    def test_test_two_attributes
+	block_used = false
+	StrScanParser.new(StringScanner.new("<narf:name foo=bar x=y>")).match_tag{|tag|
+	    assert_equal( "name", tag.name )
+	    assert_equal( { "foo" => "bar", "x" => "y" }, tag.attributes )
+	    block_used = true
+	}
+	assert block_used
+    end
+
+    def test_test_unclosed_tag
+	assert_raises(TagNotClosedException) {
+	    StrScanParser.new(StringScanner.new("<narf:name foo=bar x=y")).match_tag {}
+	}
+    end
+
+    def test_test_no_tag_name
+	assert_raises(TagNotNamedException) {
+	    StrScanParser.new(StringScanner.new("<narf: name foo=bar x=y")).match_tag  {}
+	}
+    end
+
+    def test_missing_attribute_value
+	assert_raises(MissingAttributeException) {
+	    StrScanParser.new(StringScanner.new("<narf:name foo=")).match_tag  {}
+	}
+    end
+
+    def test_missing_quote
+	assert_raises(MissingQuoteException) {
+	    StrScanParser.new(StringScanner.new("<narf:name foo=\"foo}")).match_tag  {}
+	}
+    end
+end

data/test/web/test.template2.rb

@@ -0,0 +1,297 @@
+module TemplateTestEnvironment
+  def get_test_dir
+    File.expand_path(File.join(temp_dir,"test_dir"))
+  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
+    Web::teardown
+    Web::setup
+
+    template_dir = File.expand_path((File.join("#{get_test_dir}","templates")))
+    
+    unless Web::config[:load_path].include? template_dir
+      Web::config[:load_path] << template_dir
+    end
+    
+    remove_test_dir
+    Dir.mkdir(get_test_dir)
+    Dir.mkdir(template_dir)
+
+  end
+
+  def remove_test_dir
+    if File.exists? get_test_dir
+      rm_rf(get_test_dir)
+    end
+  end
+
+  def write_file file, filename="app.rb"
+    File.open( File.expand_path(File.join("#{get_test_dir}",filename)), "w" ) { |f| f.write(file) }
+  end
+end
+
+class TestTemplate < Test::Unit::TestCase
+  include TemplateTestEnvironment
+  include Web::Testing
+  
+  def setup
+    Web::setup( :document_root => get_test_dir, :out => '' )
+    setup_test_dir
+  end
+    
+  def teardown
+    Web::teardown
+    remove_test_dir
+  end
+
+  def test_template_file
+    write_template( "here's a test" )
+    assert_equal( "#{temp_dir}/test_dir/templates/test.html",
+		  Web::template_file( "test.html" ) )
+    
+    teardown
+    setup
+      
+    begin
+      File.open( "test.html", "w" ) { |f|
+        f.write("here's a test")
+      }
+      assert_equal( "./test.html",
+                    Web::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( "./test.html",
+                    Web::template_file( "test.html" ) )
+    ensure
+      File.delete( "test.html" )
+    end
+  end
+
+  # ========= Variable Resolution ==========
+  def test_print_vars
+    write_template "x<%= Web::local['foo'] %>y<%= Web::local['bar'] %>z"
+    vars = { "foo" => "FOO", "bar" => "BAR" }
+    Web::options[:local] = vars
+    Web::load( "test.html" )
+    Web::close
+               
+    Web::assert_content "xFOOyBARz"
+  end
+
+  def test_comments
+    write_template "x<%# this will be missing %>y<%# this too %>z"
+    Web::load( "test.html" )
+    Web::close
+    Web::assert_content "xyz"
+  end
+
+  # TODO: add <!--- ---> comments to erb?
+  def todo_test_comments_with_internal_tags
+    write_template "x<%# this will be <%= missing %> %>y<%# this too %>z"
+    Web::load( "test.html" )
+    Web::close
+    Web::assert_content "xyz"
+  end
+
+  def deprecated_test_throw_exception_if_var_doesnt_exist
+    write_template "x<%= Web::local['foo'] %>y<%= Web::local['bar'] %>z"
+    vars = { "foo" => "FOO" }
+    
+    assert_raises(NameError) {
+      Web::options[:local] = vars
+      Web::load( "test.html" )
+                 
+    }
+  end
+
+  def test_nil_values_display_nothing
+    write_template "x<%= Web::local['foo'] %>yz"
+    vars = { "foo" => nil }
+    Web::options[:local] = vars
+    Web::load( "test.html" )
+    Web::close
+    Web::assert_content "xyz"
+  end
+
+
+  class TestClass
+    attr_reader :var
+    
+    def initialize var
+	    @var = var
+    end
+    
+    def foo
+	    TestClass.new("XXX")
+    end
+  end
+  
+  def test_print_method
+    write_template "x<%= Web::local['foo'].var %>y<%= Web::local['bar'] %>z"
+    vars = { "foo" => TestClass.new("FOO"), "bar" => "BAR" }
+    
+    Web::options[:local] = vars
+    Web::load( "test.html" )
+    Web::close
+    Web::assert_content "xFOOyBARz"
+  end
+
+  def test_template
+    write_template "<html><body><h1>hi</h1></body></html>"
+    
+    Web::load( "test.html" )
+    Web::close
+    Web::assert_template_used( "test.html" )
+  end
+
+  def test_exception_thrown_if_no_template_used
+    write_template "<html><body><h1>{$var}</h1></body></html>"
+
+    assert_raises(Test::Unit::AssertionFailedError) do
+      Web::assert_template_used( "/test.html" )
+    end
+  end
+
+  def test_template_fails_assertion_with_wrong_template
+    write_template "<html><body><h1>{$var}</h1></body></html>"
+  
+    Web::load( "test.html" )
+    Web::close
+
+    assert_raises( Test::Unit::AssertionFailedError ) do
+      Web::assert_template_used( "test_not_it.html" )
+    end
+      
+  end
+  
+  def test_assert_template_not_used
+    write_template "<html><body><h1>foo</h1></body></html>"
+    Web::load( "test.html" )
+    Web::close
+    Web::assert_template_not_used( "foo.html" )
+  end
+  
+  def test_assert_template_not_used_with_no_template_used
+    write_template "<html><body><h1>foo</h1></body></html>"
+    
+    Web::assert_template_not_used( "test.html" )
+  end
+  
+  def test_basic_load
+    write_template "blah blah blah"
+    Web::load( "test.html" )
+    Web::close
+    Web::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"
+    }
+    
+    write_template( bad_template )
+    Web::load( "test.html" )
+    Web::close
+
+    Web::assert_content bad_template	
+  end
+  
+end
+
+
+class TestIncludes <  Test::Unit::TestCase
+  include TemplateTestEnvironment
+  include Web::Testing
+  
+  def setup
+    Web::setup( :document_root => get_test_dir )
+    setup_test_dir
+  end
+  
+  def teardown
+    Web::teardown
+    remove_test_dir
+  end
+  
+  
+  def test_include_prints_contents
+    write_template "<html><body><% Web::load( \"incfile.html\" ) %></body></html>" , "test.html"
+    write_template "<h1>Hello</h1>", "incfile.html"
+    
+    Web::load( "test.html" )
+    Web::close
+
+    Web.assert_content "<html><body><h1>Hello</h1></body></html>"
+  end
+  
+  def test_assert_template_used_works_for_included_templates
+    write_template "<html><body><% Web::load( \"incfile.html\" ) %></body></html>" , "test.html"
+    write_template "<h1><%= Web::local['foo']['name'] %></h1>", "incfile.html"
+    
+    Web::options[:local] = { "foo" => { "name" => "bar" }}
+    Web::load( "test.html" )
+    Web::close
+
+    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_load_with_variables
+    write_template "<html><body><% Web::load 'incfile.html' %></body></html>" , "test.html"
+    write_template "<h1><%= Web::local['foo']['name'] %></h1>", "incfile.html"
+    
+    Web::local.merge!( { "foo" => { "name" => "bar" }} )
+    
+    Web::load( "test.html" )
+    Web::close
+    Web.assert_content "<html><body><h1>bar</h1></body></html>"
+  end
+  
+  def test_exception_thrown_if_template_doesnt_exist
+    write_template "<html><body><% Web::load 'nonexistant.html' %></body></html>" , "test.html"
+    
+    assert_raises( LoadError ) do
+      Web::load( "test.html" )
+    end
+  end
+  
+  def test_load_filename_from_var
+    write_template "<html><body><% Web::load( Web::local['incfile'] ) %></body></html>" , "test.html"
+    write_template "<h1><%= Web::local['foo']['name'] %></h1>", "incfile.html"
+    
+    Web::options[:local] = { "foo" => { "name" => "bar" }, "incfile" =>  "incfile.html" }
+    Web::load( "test.html" )
+    Web::close
+    Web.assert_content "<html><body><h1>bar</h1></body></html>"
+  end
+end