ruby-web 1.1.1

data/test/web/test.code.loader.rb

@@ -0,0 +1,78 @@
+class TestCodeLoader < 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/")
+    end
+    
+    def teardown
+      Dir.chdir(@pwd)
+	    rm_rf(temp_dir + "/test_dir")
+    end
+    
+    def write_file filename, contents
+      File.open( temp_dir + "/test_dir/#{filename}" , "w" ) { |f|
+        f.write(contents)
+      }
+    end
+
+    def test_ruby
+      write_file "app.rb", <<-EOF
+      print "Hello, World"
+      EOF
+
+      do_request "app.rb"
+
+      assert_content "Hello, World"
+    end
+
+    def test_phprb
+      require 'pp'
+      @old_default_handler = Web::config['load_suffix'].default
+      Web::config['load_suffix'].default = lambda do |script|
+        PHPRB::load(script)
+      end
+      
+      write_file "app.rhtml", <<-EOF
+      <?= "Hello, World" ?>
+      EOF
+
+      do_request "app.rhtml"
+
+      assert_equal( "Hello, World", Web::get_content.strip )
+    ensure
+      Web::config['load_suffix'].default = @old_default_handler
+    end
+
+    def test_erb
+      write_file "app.erb", <<-EOF
+      <%= "Hello, World" %>
+      EOF
+      
+      do_request "app.erb"
+      
+      assert_equal( "Hello, World", Web::get_content.strip )
+      
+    end
+
+    def test_custom
+      Web::config[:load_suffix][:custom] = lambda do |script|
+        Web::write script
+      end
+
+      write_file "app.custom", <<-EOF
+      this code doesn't matter
+      EOF
+      
+      do_request "app.custom"
+      assert_match( /app.custom$/, Web::get_content.strip )
+    ensure
+      Web::config[:load_suffix].delete :custom
+    end
+
+end

data/test/web/test.config.rb

@@ -0,0 +1,31 @@
+class TestWebConfig < Test::Unit::TestCase
+  def setup
+    @old_config = Web::config
+    Web::module_eval do
+      @@config = Web::Config.new
+    end
+  end
+
+  def teardown
+    c = @old_config
+    Web::module_eval do
+      @@config = c
+    end
+  end
+
+  def test_preferences
+    Web::config.set("random_pref" => "random value",
+                    "another_pref" => "another value")
+    assert_equal( "random value", Web::config::random_pref )
+    assert_equal( "random value", Web::config["random_pref"] )
+    assert_equal( "another value", Web::config::another_pref )
+    assert_equal( "another value", Web::config["another_pref"] )
+  end
+
+  def test_docs
+    assert_equal( nil, Web::config["random_pref"] )
+    Web::config::describe( :random_pref => "This is a test" )
+    assert_equal( "This is a test", Web::config::docs[:random_pref] )
+  end
+  
+end

data/test/web/test.error.handling.rb

@@ -0,0 +1,91 @@
+class TestErrorHandling < Test::Unit::TestCase
+  def app
+    temp_dir + "/test_dir/app.rb"
+  end
+
+  def setup
+    File.delete(app) if File.exists? app
+    @stdout, @stderr = $stdout, $stderr
+    $stdout, $stderr = StringIO.new, StringIO.new
+    Web::setup
+  end
+
+  def teardown
+    File.delete(app) if File.exists? app
+    Web::teardown
+    $stdout, $stderr = @stdout, @stderr
+  end
+  
+  def write_file file
+    File.open( temp_dir + "/test_dir/app.rb" , "w" ) { |f| f.write(file) }
+  end
+
+  def test_error_handling
+    Web::config[:error_style]  = :production
+    
+    Web::open do
+      Web::filter do
+        raise "hell"
+      end
+    end
+    assert_match( /RuntimeError.*hell/m, $stdout.string )
+  end
+
+  def test_production
+    Web::config[:error_style]  = :production
+    
+    Web::open do
+      raise "this is a test error"
+    end
+
+    assert_equal( '500', Web::status )
+
+    assert_match( /^RuntimeError: this is a test error/,
+                  $stderr.string,
+                  "Error printed to stderr" )
+    assert_match( /<b style='font-size:20px'>this is a test error<\/b>/,
+                  $stdout.string,
+                  "Error printed with html to stdout" )
+    assert_no_match( /test.error.handling.rb/,
+                  $stdout.string,
+                  "No backtrace should be printed to stdout" )
+
+  end
+
+  def test_development
+    Web::config[:error_style] = :development
+
+    Web::open do
+      raise "this is a test error"
+    end
+
+    assert_equal( '500', Web::status )
+
+    assert_match( /^RuntimeError: this is a test error/,
+                  $stderr.string,
+                  "Error printed to stderr" )
+    assert_match( /<b style='font-size:20px'>this is a test error<\/b>/,
+                  $stdout.string,
+                  "Error printed with html to stdout" )
+    assert_match( /test.error.handling.rb/,
+                  $stdout.string,
+                  "backtrace printed" )
+  end
+  
+  def test_content_type
+    Web::config[:error_style] = :development
+    
+    Web::open do
+      Web::content_type = "application/ms-excel"
+      raise "this is a test error"
+    end
+    
+    assert_match( /Content-Type: text\/html/,
+                  $stdout.string,
+                  "Content-Type Changed back to text/html" )
+  end
+
+    
+    
+
+end

data/test/web/test.formreader-2.0.rb

@@ -0,0 +1,352 @@
+
+class TestFormReader2 < Test::Unit::TestCase
+  # for each kind of html element
+  #   * test the parsed html element handles "assert_include" properly
+  #   * test submit the html element
+  # a few important bits:
+  #   * handle multiple elements in a form properly.
+  #     i.e. just because a field isn't name="field[]"
+  #          doesn't mean that multiple params on a field are lost.
+  #     also, you should be able to have multiple elements with the
+  #          same name, but different types
+  # this should work exactly the same for simple text elements.
+  # this will work very differently for select elements,
+  # testing of which IMHO is broken
+  #
+  # More notes from patrick:
+  # There are two dimensions of "multiples" on a form
+  #    * single or multiple elements in the html
+  #    * a request by the programmer that elements be returned as a array or as a string
+  #
+  # I have some simple templating constructs in here to help write the tests.
+  # I'm not using Narflates b/c this templating is only to support these tests;
+  # the FormReader code works on just html
+  #
+
+  include Web::Testing
+
+  def setup
+    @parser = nil
+  end
+
+  def make_form( content )
+    @parser = FormReader.new( "<form name='aForm'>" + content + "</form>" )
+  end
+
+  def get_fields
+    @parser.get_fields( "aForm" )
+  end
+
+  def merge_fields( edited_fields={} )
+    @parser.merge_fields( "aForm", edited_fields )
+  end
+
+  def get_options
+    @parser.get_options( "aForm" )
+  end
+
+  def test_blank_form
+    make_form ""
+    assert_equal( {}, get_fields )
+    assert_equal( {}, merge_fields )
+    assert_raises( Web::Testing::FieldNotFoundException ) {
+      merge_fields( "missing" => "element" )
+    }
+  end
+
+
+  # -----------------------------------------
+  # the text elements should behave similarly
+  # -----------------------------------------
+  
+  def test_plain_input
+    do_text_tests <<-HTML
+    <input name="{name}" value="{value}">
+    HTML
+  end
+
+  def test_text
+    do_text_tests <<-HTML
+    <input type="text" name="{name}" value="{value}">
+    HTML
+  end
+
+  def test_password
+    do_text_tests <<-HTML
+    <input type="password" name="{name}" value="{value}">
+    HTML
+  end
+
+  def test_textarea
+    do_text_tests <<-HTML
+    <textarea name="{name}">
+    {value}
+    </textarea>
+    HTML
+  end
+
+  def test_hidden
+    do_text_tests <<-HTML
+    <input type="hidden" name="{name}" value="{value}">
+    HTML
+  end
+
+  def make_text_field( pattern, name, value )
+    pattern.gsub( /\{name\}/i, name ).gsub( /\{value\}/i, value )
+  end
+
+  def do_text_tests( field_pattern )
+    make_form( make_text_field( field_pattern, "atextfield", "avalue" ) )
+
+    assert_includes( { "atextfield" => "avalue" }, get_fields )
+    assert_equal( { "atextfield" => ["avalue"] }, merge_fields )
+
+    assert_equal( { "atextfield" => ["other"] },
+                   merge_fields( "atextfield" => "other" ) )
+    assert_equal( { "atextfield" => ["other"] },
+                   merge_fields( :atextfield  => "other" ) )
+
+    assert_raises( FormMergeError ) {
+      merge_fields( "atextfield" => [ "one", "two" ] )
+    }
+
+    # multiple elements.  Note that it doesn't matters
+    # how the programmer wants the cgi to return results,
+    # s/he still tests multiple elements the same
+    # i.e. "field" and "field[]" behave the same
+    # when asserting content on a form or merging elements
+    make_form( make_text_field( field_pattern, "atextfield[]", "two" ) + 
+               make_text_field( field_pattern, "atextfield[]", "one" ) )
+
+    assert_includes( { "atextfield[]" => ["two", "one"] }, get_fields )
+    assert_equal(   { "atextfield[]" => ["two", "one"] }, merge_fields )
+
+    make_form( make_text_field( field_pattern, "atextfield", "two" ) + 
+               make_text_field( field_pattern, "atextfield", "one" ) )
+
+    assert_includes( { "atextfield" =>["two", "one"] }, get_fields )
+    assert_equal(   { "atextfield" => ["two", "one"] }, merge_fields )
+
+    # if you merge a multiple with a string,
+    # the string replaces the first element
+    # in the multiple
+    assert_equal( { "atextfield" => ["first", "one"] },
+                   merge_fields( :atextfield => "first" ) )
+    assert_equal( { "atextfield" => ["first", "second"] },
+                   merge_fields( :atextfield => ["first", "second"] ) )
+    assert_raises( FormMergeError ) {
+      merge_fields( :atextfield => ["first", "second", "third"] )
+    }
+
+  end
+
+  # -----------------------------------------
+  # file uploads may be odd
+  # -----------------------------------------
+  
+  def test_file
+    make_form( make_file_field( "file" ) )
+    assert_includes( { "file" => "" }, get_fields )
+    ### do browsers send the file field when
+    ### nothing was entered?
+    assert_equal( {"file" => [""] }, merge_fields )
+    
+    upload = Web::Upload.new( File.new( "test/web/testfiles/text" ),
+                              "content-type",
+                              "original-filename" ) 
+    assert_equal( { "file" => [upload] },
+                  merge_fields( :file => upload ) )
+  end
+  
+  def make_file_field( name )
+    "<input type=\"file\" name=\"#{name}\">"
+  end
+  
+  # -----------------------------------------
+  # use the same api for:
+  #    single selects and radio buttons
+  #    multi selects and checkboxes
+  # since they more or less are used
+  # to say same thing on a form
+  # -----------------------------------------
+  
+  def test_select
+    do_select_tests <<-HTML
+    <select name="{name}">
+    {option}<option {checked}selected{endchecked}>{value}</option>{endoption}
+    </select>
+    HTML
+
+    do_select_tests <<-HTML
+    <select name="{name}">
+    {option}<option value="{value}" {checked}selected{endchecked}></option>{endoption}
+    </select>
+    HTML
+    do_multiselect_tests <<-HTML
+    <select name="{name}" multiple>
+    {option}<option {checked}selected{endchecked}>{value}</option>{endoption}
+    </select>
+    HTML
+    
+    # select field + select field = two different select fields
+
+  end
+
+  def test_radio_and_checkbox
+    do_select_tests <<-HTML
+    {option}<input type="radio" name="{name}" value="{value}" {checked}checked{endchecked}>{endoption}
+    HTML
+
+    do_select_tests <<-HTML
+    <select name="{name}">
+    {option}<option value="{value}" {checked}selected{endchecked}></option>{endoption}
+    </select>
+    HTML
+    
+    do_multiselect_tests <<-HTML
+    <select name="{name}" multiple>
+    {option}<option {checked}selected{endchecked}>{value}</option>{endoption}
+    </select>
+    HTML
+    
+    # select field + select field = two different select fields
+
+    # checkboxes + checkboxes = one big group of checkboxes
+    # that can return multiple values
+    
+    # radio buttons + radio buttons = one big group of radio buttons
+    # that can return one value
+
+    # checkboxes + radio buttons = ?????
+  end
+
+  def make_select_field( pattern, name, values )
+    pattern.gsub!( /\{NAME\}/i, name )
+    pattern =~ /\{OPTION\}(.*)\{ENDOPTION\}/si
+    option_pattern = $1
+    options = ""
+    values.each{ |k,v|
+      options += option_pattern.gsub( /\{VALUE\}/i, k ). \
+                 gsub( if v
+                         /\{CHECKED\}|\{ENDCHECKED\}/i
+                       else
+                         /\{CHECKED\}.*\{ENDCHECKED\}/i
+                       end, "" )
+    }
+    pattern.gsub( /\{OPTION\}.*\{ENDOPTION\}/i, options )
+  end
+  
+
+  def do_select_tests( pattern )
+    make_form( make_select_field( pattern,
+                                  "field",
+                                  {"first" => true,
+                                   "second" => false } ) )
+    
+    assert_includes( { "field" => "first" }, get_fields )
+    assert_equal(   { "field" => ["first"] }, merge_fields )
+    assert_equal(   { "field" => ["second"] },
+                    merge_fields( "field" => select("second") ) )
+    assert_raises( FormMergeError ) {
+      merge_fields( "field" => select("missing value") )
+    }
+
+    assert_raises( FormMergeError ) {
+      merge_fields( "field" => select("first", "second") )
+    }
+   
+  end
+
+  def do_multiselect_tests( pattern )
+    make_form( make_select_field( pattern,
+                                  "field",
+                                  {"first"  => true,
+                                   "second" => false,
+                                   "third"  => true } ) )
+    assert_includes( { "field" => ["first", "third"] }, get_fields )
+    assert_includes( { "field" => ["first", "second", "third"] }, get_options )
+    assert_equal(   { "field" => ["first", "third"] }, merge_fields )
+
+    # three cases for merge_fields with selects:
+    # using the select function:
+    # * a single text value adds to the selected values
+    assert_equal(   { "field" => ["first", "second", "third" ] },
+                    merge_fields( "field" => select("second") ) )
+    # * an multiples add to the selected values
+    assert_equal(   { "field" => ["first", "second", "third" ] },
+                    merge_fields( "field" => select("second","third") ) )
+    
+    # * a hash turns values on and off
+    assert_equal(   { "field" => ["second", "third"] },
+                    merge_fields( "field" => {"first" => false,
+                                              "second" => true } ) )
+    assert_equal(   { "field" => ["second", "third"] },
+                    merge_fields( "field" => select("first" => false,
+                                                     "second" => true ) ) )
+
+
+    assert_raises( FormMergeError ) {
+      merge_fields( "field" => "not using select method" )
+    }
+
+    assert_raises( FormMergeError ) {
+      merge_fields( "field" => select("missing value") )
+    }
+
+    #assert_raises( FormMergeError ) {
+    #  merge_fields( "field" => ["first", "second"] )
+    #}
+
+  end
+  
+  # -----------------------------------------
+  # test checkboxes as booleans
+  # -----------------------------------------
+
+  def test_boolean_checkbox
+    html = ""
+    
+    {"first"  => true,
+     "second" => false,
+     "third"  => true }.each{ |k, v|
+
+      html += "<input type=\"checkbox\" name=\"#{k}\"";
+      html += " checked" if (v)
+      html += ">";
+
+    }
+
+    make_form( html )
+
+    assert_includes( {"first"  => [true ],
+                      "second" => [false],
+                      "third"  => [true ]  }, get_fields   )
+    assert_equal(    {"first"  => [true ],
+                      "third"  => [true ]  }, merge_fields )
+    
+    # how to check a checkbox...
+    assert_equal( {"first"  => [true ],
+                   "second" => [true],
+                   "third"  => [true ]  },
+                  merge_fields( "second" => true ) )
+
+    # how to uncheck a check box
+    assert_equal( {"second" => [true],
+                   "third"  => [true ]  },
+                  merge_fields( "first"  => false,
+                                "second" => true   ) )
+
+  end
+
+  # -----------------------------------------
+  # test blending different kinds
+  # of elements into the same
+  # "field" or "field[]"
+  # -----------------------------------------
+
+  # -----------------------------------------
+  # test fields with narflate style names,
+  # i.e. "field[1].name" / etc
+  # -----------------------------------------
+
+end