ruby-web 1.1.1

data/test/unit/test_table.rb

@@ -0,0 +1,70 @@
+=begin
+= test for WebUnit::Table
+  Copyright(C) 2001 yuichi TAKAHASHI
+  $Id: test_table.rb,v 1.1.1.1 2003/01/21 11:50:40 yuichi Exp $
+=end
+
+require 'webunit/webunit'
+require 'runit/cui/testrunner'
+
+module WebUnit
+
+  class TestTable < WebUnit::TestCase
+
+    def test_accessor
+    end
+
+    def test_Table
+
+      url = @urlbase + "webunit/table.html"
+      response = Response::get( url )
+
+      table = response.tables[0]
+
+      assert_instance_of( Array, table.rows )
+      assert_equals( 4, table.rows.size )
+
+      assert_exception( ArgumentError ){ table.at(0) }
+      assert_instance_of( TableRow, table.at(1) )
+      assert_instance_of( TableRow, table.at(4) )
+      assert_exception( RuntimeError ){ table.at(5) }
+
+      assert_exception( ArgumentError ){ table.at(0,1) }
+      assert_exception( ArgumentError ){ table.at(1,0) }
+      assert_instance_of( TableCell, table.at(1,1) )
+      assert_instance_of( TableCell, table.at(4,3) )
+      assert_instance_of( NilTableCell, table.at(5,1) )
+      assert_instance_of( NilTableCell, table.at(1,4) )
+
+      assert_equals( "this 11", table.at(1,1).data )
+      assert_equals( "test 23", table.at(2,3).data )
+      assert_equals( "this 21", table.at(3,1).data )
+      assert_equals( "test 32", table.at(3,2).data )
+      assert_equals( "test 32", table.at(3,3).data )
+      assert_equals( "this 21", table.at(4,1).data )
+
+      table = response.tables[1]
+
+      assert_equals( "green", table.at(1).attrs['bgcolor'] )
+      assert_equals( "blue",  table.at(2).attrs['bgcolor'] )
+      assert_equals( "red",   table.at(3).attrs['bgcolor'] )
+
+      table = response.tables[2]
+
+      assert_equals( "", table.at(3,1).data )
+      assert_equals( "ggg", table.at(3,1).find("a")[0].data )
+
+      assert_include( "ggg", table.at(3,1) )
+      assert( table.at(3,1).has?( response.link ) )
+
+      assert_equals( 3, table.row_index( "ggg" ) )
+      assert_equals( 4, table.row_index( "kkk", 2 ) )
+
+      assert_equals( 2, table.col_index( "bbb" ) )
+      assert_equals( 1, table.col_index( "ggg", 3 ) )
+
+    end
+
+  end
+
+end

data/test/unit/test_utils.rb

@@ -0,0 +1,106 @@
+=begin
+= test for WebUnit::Utils
+  Copyright(C) 2001 yuichi TAKAHASHI
+  $Id: test_utils.rb,v 1.1.1.1 2003/01/21 11:50:40 yuichi Exp $
+=end
+
+require 'webunit/webunit'
+require 'runit/cui/testrunner'
+
+module WebUnit
+
+  class TestUtils < WebUnit::TestCase
+
+    def test_parse_url
+
+      url = "http://localhost/xxxx.html"
+      prot, host, port, path = parse_url( url )
+
+      assert_equals( 'http', prot )
+      assert_equals( 'localhost', host )
+      assert_equals( 80, port )
+      assert_equals( '/xxxx.html', path )
+
+      url = "http://localhost/"
+      prot, host, port, path = parse_url( url )
+
+      assert_equals( 'http', prot )
+      assert_equals( 'localhost', host )
+      assert_equals( 80, port )
+      assert_equals( '/', path )
+
+      url = "http://localhost"
+      prot, host, port, path = parse_url( url )
+
+      assert_equals( 'http', prot )
+      assert_equals( 'localhost', host )
+      assert_equals( 80, port )
+      assert_equals( '', path )
+
+      url = "file:/home/yyyy/xxxx.html"
+      prot, host, port, path = parse_url( url )
+
+      assert_equals( 'file', prot )
+      assert_equals( nil, host )
+      assert_equals( nil, port )
+      assert_equals( '/home/yyyy/xxxx.html', path )
+
+      url = "yyyy/xxxx.html"
+      prot, host, port, path = parse_url( url )
+
+      assert_equals( nil, prot )
+      assert_equals( nil, host )
+      assert_equals( nil, port )
+      assert_equals( 'yyyy/xxxx.html', path )
+
+    end
+
+    def test_orthop_url
+
+      url = "http://localhost/xxxx.html"
+      assert_equals( 'http://localhost:80/xxxx.html', orthop_url( url ) )
+
+      url = "http://local-host/"
+      assert_equals( 'http://local-host:80/', orthop_url( url ) )
+
+      url = "http://localhost"
+      assert_equals( 'http://localhost:80', orthop_url( url ) )
+
+      url = "http://localhost/a/./xxxx.html"
+      assert_equals( 'http://localhost:80/a/xxxx.html', orthop_url( url ) )
+
+      url = "http://localhost/a/../xxxx.html"
+      assert_equals( 'http://localhost:80/xxxx.html', orthop_url( url ) )
+
+    end
+
+    def test_complete_url
+
+      base = "http://localhost:80/a/xxxx.html"
+
+      url = 'http://localhost:80/a/yyyy.html'
+      assert_equals( url, complete_url( url, base ) )
+
+      url = 'http://localhost:80/yyyy.html'
+      assert_equals( url, complete_url( '/yyyy.html', base ) )
+
+      url = 'http://localhost:80/a/yyyy.html'
+      assert_equals( url, complete_url( 'yyyy.html', base ) )
+
+      assert_equals( base, complete_url( nil, base ) )
+
+      base = "http://localhost:80/a/xxxx.html?args..."
+      url  = 'http://localhost:80/a/xxxx.html'
+      assert_equals( url, complete_url( nil, base ) )
+
+      url  = 'xxxx.html'
+      assert_equals( url, complete_url( url, nil ) )
+
+      url  = 'http://localhost:80/a/xxxx.html'
+      assert_equals( url, complete_url( url, nil ) )
+
+    end
+
+  end
+
+end

data/test/unit/test_webunit.rb

@@ -0,0 +1,28 @@
+=begin
+= test for WebUnit
+  Copyright(C) 2001 yuichi TAKAHASHI
+  $Id: test_webunit.rb,v 1.2 2004/02/11 04:26:40 yuichi Exp $
+=end
+
+require 'webunit/webunit'
+require 'runit/cui/testrunner'
+
+if $0 == __FILE__
+  
+  module WebUnit
+  
+    class TestWebUnit < WebUnit::TestCase
+    end
+  
+  end
+
+  if ARGV.size == 0
+    suite = WebUnit::TestWebUnit::suite
+  else
+    suite = RUNIT::TestSuite.new
+    ARGV.each do |testmethod|
+      suite.add_test( WebUnit::TestWebUnit::new( testmethod ) )
+    end
+  end
+  RUNIT::CUI::TestRunner.run( suite )
+end

data/test/web/mod_ruby_stub.rb

@@ -0,0 +1,39 @@
+class Apache
+    class Request
+	attr_reader :status_line, :content_type, :content_encoding, :headers_out, :headers_in
+	attr_writer :status_line, :content_type, :content_encoding
+	
+	def initialize
+	    @headers_out = {}
+	    eval <<-EVAL
+	    def @headers_out.add( k, v )
+		self[k] ||= []
+		self[k].push v
+	    end
+	    EVAL
+            @headers_in = {}
+	end
+
+	def sent?
+	    @sent
+	end
+
+	def send_http_header
+	    @sent = true
+	end
+
+	def args
+	    "key=some%20value&anotherKey=someother%20value"
+	end
+    end
+
+    def Apache.reset
+	@@request = nil
+    end
+
+    @@request = nil
+    def Apache::request
+	@@request ||= Request.new
+	@@request
+    end
+end

data/test/web/test.assertinclude.rb

@@ -0,0 +1,109 @@
+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 e.to_s.index( "Missing from actual: b => \"bb\"" )
+    end
+
+    def test_includes_different
+	e = assert_raises( Test::Unit::AssertionFailedError ) {
+	    assert_includes( {"a" => "aa"}   , { "a" => "bb" } )
+	}
+        assert e.to_s.index("Difference: required <a => \"aa\"> was <a => \"bb\">" )
+    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 e.to_s.index("Difference: required <a.b => \"bb\"> was <a.b => \"cc\">")
+    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 e.to_s.index("Difference: required <a[1].b => \"bb\"> was <a[1].b => \"cc\">")
+    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 e.to_s.index("Missing from actual: a[1] => {\"b\"=>\"cc\"}")
+    end
+
+    def test_includes_hash_when_should_not
+	e = assert_raises( Test::Unit::AssertionFailedError ) {
+	    assert_includes( {"a" => "b"}  , { "a" => { "a" => "aa", "b" => "cc"}} )
+	}
+        assert e.to_s.index("Difference: required <a => \"b\"> was <a => {\"a\"=>\"aa\", \"b\"=>\"cc\"}>")
+    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 e.to_s.index("Difference: required <a => {\"a\"=>\"aa\", \"b\"=>\"cc\"}> was <a => \"b\">")
+    end
+
+    def test_includes_array_when_should_not
+	e = assert_raises( Test::Unit::AssertionFailedError ) {
+	    assert_includes( {"a" => "a"}, { "a" => [ {"a" => "aa"}, {"b" => "cc"}]} )
+	}
+        assert e.to_s.index("Difference: required <a => \"a\"> was <a => [{\"a\"=>\"aa\"}, {\"b\"=>\"cc\"}]>")
+    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 e.to_s.index("Difference: required <a => \"b\"> was <a => {\"a\"=>\"aa\", \"b\"=>\"cc\"}>" )
+    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_hash1
+      assert_includes({"name" => "patrick"}, Trivial.new("patrick"))
+    end
+
+    def test_compare_object_tree_to_hash2
+      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/web/test.buffer.rb

@@ -0,0 +1,182 @@
+class TestBuffer < Test::Unit::TestCase
+  include Web::Testing
+  def setup
+    Web::setup
+  end
+
+  def teardown
+    Web::teardown
+  end
+
+  # Web::filter is an alias to ob_start
+  def test_filter
+    Web::open( :out=>'' ) do
+      Web::filter do |content|
+        [ "start", content, "end" ].join(",")
+      end
+      
+      Web::write "middle"
+    end
+    
+    assert_equal( "start,middle,end", Web::get_content )
+  end
+
+
+  #  ob_start -- Turn on output buffering
+  def test_ob_start
+    Web::open( :out=>'' ) do
+      Web::ob_start do |content|
+        [ "start", content, "end" ].join(",")
+      end
+      
+      Web::write "middle"
+    end
+    
+    assert_equal( "start,middle,end", Web::get_content )
+  end
+
+  #  ob_flush --  Flush (send) the output buffer
+  def test_ob_flush
+    Web::open( :out=>'' ) do
+      Web::ob_start do |content|
+        "[" + content +"]"
+      end
+      
+      Web::write "write 1"
+
+      Web::ob_flush
+
+      Web::write "write 2"
+    end
+
+    assert_equal( '[write 1][write 2]', Web::get_content )
+  end
+
+  #  ob_clean --  erase the output buffer
+  def test_ob_clean
+    Web::open( :out=>'' ) do 
+      Web::write "this text will be erased"
+      Web::ob_clean
+      Web::write "expected content"
+    end
+    
+    assert_equal( 'expected content', Web::get_content )
+  end
+
+  #  ob_end_clean --  Clean (erase) the output buffer and turn off output buffering
+  def test_ob_end_clean
+    Web::open( :out=>'' ) do
+      Web::ob_start do |content|
+        "[" + content + "]"
+      end
+      
+      Web::ob_start do |content|
+        "{" + content + "}"
+      end
+      
+      Web::write "this content will not be seen"
+      
+      assert( Web::ob_end_clean )
+      
+      Web::write "expected content"
+    end
+
+    assert_equal( '[expected content]', Web::get_content )
+  end
+  
+  #  ob_end_flush --  Flush (send) the output buffer and turn off output buffering
+  def test_ob_end_flush
+    Web::open( :out=>'' ) do
+      Web::ob_start do |content|
+        "[" + content + "]"
+      end
+      
+      Web << "expected content"
+
+      Web::ob_end_flush
+
+      Web << "a little more"
+    end
+
+    assert_equal( '[expected content]a little more', Web::get_content )
+  end
+
+  #  ob_get_clean --  Get current buffer contents and delete current output buffer
+  def test_ob_get_clean
+    Web::open( :out=>'' ) do
+      Web::ob_start do |content|
+        "[" + content + "]"
+      end
+
+      Web << 'expected content'
+      assert_equal( 'expected content', Web::ob_get_clean )
+      Web << 'more content'
+    end
+
+    assert_equal( 'more content', Web::get_content )
+  end
+  
+  #  ob_get_contents --  Return the contents of the output buffer
+  def test_ob_get_contents
+    Web::open( :out=>'' ) do
+      Web << 'expected'
+      assert_equal( 'expected', Web::ob_get_contents )
+    end
+    assert_equal( 'expected', Web::get_content )
+  end
+
+  #  ob_get_flush --  Flush the output buffer, return it as a string and turn off output buffering
+  def test_ob_get_flush
+    Web::open( :out=>'' ) do
+      Web::ob_start do |content|
+        "[" + content + "]"
+      end
+      Web << 'expected'
+      assert_equal( 'expected', Web::ob_get_flush )
+      Web::ob_end_clean
+    end
+    assert_equal( '[expected]', Web::get_content )
+  end
+  
+  #  ob_get_length --  Return the length of the output buffer
+  #  ob_get_contents --  Return the contents of the output buffer
+  def test_ob_get_length
+    Web::open( :out=>'' ) do
+      Web << 'expected'
+      assert_equal( 8, Web::ob_get_length )
+    end
+  end
+  
+  #  ob_get_level --  Return the nesting level of the output buffering mechanism
+  def test_ob_get_level
+    Web::open( :out=>'' ) do
+      assert_equal( 1, Web::ob_get_level )
+      Web::ob_start
+      assert_equal( 2, Web::ob_get_level )
+      Web::ob_start
+      assert_equal( 3, Web::ob_get_level )
+      Web::ob_end_clean
+      assert_equal( 2, Web::ob_get_level )
+    end
+  end
+
+  #  ob_list_handlers --  List all output handlers in use
+  def test_ob_list_handlers
+    Web::open( :out=>'' ) do
+      Web::ob_start do |content|
+        "[" + content + "]"
+      end
+
+      assert_equal( "[expected]",
+                    Web::ob_list_handlers.last.callback.call('expected') )
+    end
+  end
+
+  #  ob_get_status --  Get status of output buffers
+  #  ob_implicit_flush --  Turn implicit flush on/off
+  #  ob_gzhandler --  ob_start callback function to gzip output buffer
+  #  output_add_rewrite_var --  Add URL rewriter values
+  #  output_reset_rewrite_vars 
+
+
+end