ruby-web 1.1.1

data/test/web/test.load.rb

@@ -0,0 +1,125 @@
+class TestLoad < Test::Unit::TestCase
+  def cleanup
+    if File.exists?( make_temp( "script.narf" ) )
+      File.delete( make_temp( "script.narf" ) ) 
+    end
+  end
+
+  def setup
+    cleanup
+    Web::connection = Web::Connection::new( :out => "" )
+  end
+
+  def teardown
+    cleanup
+  end
+  
+  def script( src )
+    File.open( make_temp( "script.narf" ), 'w' ) do |f|
+      f.write src
+    end
+  end
+
+  def run_script
+    Web::open(:out => '') do
+      Web::load( make_temp( "script.narf" ) )
+    end
+  end
+
+  def test_hello_world1
+    script <<-SCRIPT
+Hello World
+SCRIPT
+    run_script
+    assert_equal( "Hello World\n", Web::get_content )
+  end
+
+  def test_hello_world2
+    script <<-SCRIPT
+<%= "Hello World" %>
+SCRIPT
+    run_script
+    assert_equal( "Hello World\n", Web::get_content )
+  end
+
+  def test_hello_world3
+    script <<-SCRIPT
+<% print "Hello World" %>
+SCRIPT
+    run_script
+    assert_equal( "Hello World\n", Web::get_content )
+  end
+  
+  def test_hello_world4
+    script <<-SCRIPT
+<%= "Hello World" %>
+SCRIPT
+    run_script
+    assert_equal( "Hello World\n", Web::get_content )
+  end
+
+  def test_hello_world5
+    script <<-SCRIPT
+<% print "Hello World" %>
+SCRIPT
+    run_script
+    assert_equal( "Hello World\n", Web::get_content )
+  end
+
+  def test_hello_world6
+    script <<-SCRIPT
+<% def print_hello
+    print "Hello World"
+   end
+   print_hello
+   %>
+SCRIPT
+    run_script
+    assert_equal( "Hello World\n", Web::get_content )
+  end
+
+end
+
+class TestApplication < Test::Unit::TestCase
+  include Web::Testing
+  
+  def setup
+    teardown
+    Web::docroot = make_temp
+    Web::setup
+  end
+
+  def teardown
+    Web::teardown
+    rm_rf make_temp
+  end
+  
+  def test_application_rb
+    write_file('application.rb', <<-APP )
+    Web::puts "application"
+    APP
+
+    write_file('script.rb', <<-SCRIPT )
+    Web::puts "script"
+    SCRIPT
+
+    do_request('script.rb')
+    assert_content( "application\nscript\n" )
+  end
+
+  def test_application_in_parent_dir
+    write_file('application.rb', <<-APP )
+    Web::puts "application"
+    APP
+
+    write_file('subdir/script.rb', <<-SCRIPT )
+    Web::puts "subdir/script"
+    SCRIPT
+    
+    #Web::load_application( 'subdir/script.rb' )
+               
+    do_request('subdir/script.rb')
+    assert_content( "application\nsubdir/script\n" )
+  end
+end
+

data/test/web/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/web/test.narf.cgi.rb

@@ -0,0 +1,106 @@
+class TestWebCgi < Test::Unit::TestCase
+  def set_up
+    teardown
+  end
+
+  def teardown
+    $stderr = $deferr #@old_stderr
+    @cgi = @options = @mockio = @params = @cookie = nil
+  end
+  
+  def output
+    @mockio ||= ""
+  end
+  
+  def params
+    @params ||= { "field"  => "value"   }
+  end
+  
+  def cookie
+    @cookie ||= { "cookie" => "monster" }
+  end
+  
+  def options
+    @options ||= {:out     => output,
+                  :request => params,
+                  :cookie  => cookie }
+  end
+  
+  def cgi
+    @cgi ||= Web::Connection.new options
+  end
+  
+  def test_initialize
+    assert_equal( output,  cgi.output        )
+    assert_equal( params,  cgi.request )
+    assert_equal( Web::Connection::normalize(cookie), cgi.cookie         )
+  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>"
+  cgi.close
+	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.flush
+	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::open( :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::Connection.create( :out => out ), Web::Connection.create( :out => out )
+	assert_not_equal Web::Connection.create( :out => "" ), Web::Connection.create( :out => "" )
+    end
+end
+
+

data/test/web/test.phprb.rb

@@ -0,0 +1,239 @@
+class TestPHPRBTemplate < Test::Unit::TestCase
+  include Web::Testing
+
+  def setup
+    teardown
+
+    Web::setup( :document_root => get_test_dir, :out => '' )
+
+    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
+    
+    Dir.mkdir(get_test_dir)
+    Dir.mkdir(template_dir)
+
+    @old_default_handler ||= Web::config['load_suffix'].default
+    Web::config['load_suffix'].default = lambda do |script|
+      PHPRB::load(script)
+    end
+  end
+    
+  def teardown
+    Web::teardown
+    @old_default_handler ||= Web::config['load_suffix'].default
+    Web::config['load_suffix'].default = @old_default_handler
+    
+    if File.exists? get_test_dir
+      rm_rf(get_test_dir)
+    end
+  end
+
+
+  
+  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 write_file file, filename="app.rb"
+    File.open( File.expand_path(File.join("#{get_test_dir}",filename)), "w" ) { |f| f.write(file) }
+  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_xml_embeding
+    write_template "x<?= 'foo' ?>y<? Web::write('bar') ?>z"
+    Web::options[:xml] = true
+    Web::load( "test.html" )
+    Web::close
+    Web::assert_content "x<?= 'foo' ?>y<? Web::write('bar') ?>z"
+  end
+
+  def test_xml_embeding2
+    write_template "x<?= 'foo'\n\n ?>y<? Web::write('bar') ?>z"
+    Web::load( "test.html")
+    Web::close
+    Web::assert_content "xfooybarz"
+  end
+
+  def test_xml_open_tags
+    write_template "x<?ruby= 'foo' ?>y<?ruby Web::write('bar') ?>z"
+    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
+
+  def 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::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