Changeset 784 for branches

Show
Ignore:
Timestamp:
09/14/08 06:56:46 (2 months ago)
Author:
raggi
Message:

Copy back to be completed merge commit on trunk, to this branch. Many fixes in tests, rake test now reliable

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • branches/raggi/docs/ChangeLog

    r772 r784  
    12712728Aug08: Added a patch by tmm1 to fix a longstanding problem with Java 
    128128data-sends. 
     12913Sep08: Added LineText2#set_binary_mode, a back-compatibility alias. 
     13013Sep08: Modified the load order of protocol libraries in eventmachine.rb 
     131        to permit a modification of HeaderAndContentProtocol. 
     13213Sep08: Modified HeaderAndContent to use LineText2, which is less buggy 
     133        than LineAndTextProtocol. This change may be reversed if we can fix 
     134        the bugs in buftok. 
     13513Sep08: Improved the password handling in the Postgres protocol handler. 
     136 
     137 
  • branches/raggi/lib/eventmachine.rb

    r772 r784  
    15931593        # 
    15941594        class EventMachine::PeriodicTimer 
     1595                attr_accessor :interval 
    15951596                def initialize *args, &block 
    15961597                        @interval = args.shift 
     
    16241625        end 
    16251626 
    1626  
    1627  
    1628  
    16291627end 
     1628 
     1629# Is inside of protocols/ but not in the namespace? 
     1630require 'protocols/buftok' 
    16301631 
    16311632module Protocols 
     
    16471648        autoload :SmtpServer, 'protocols/smtpserver' 
    16481649        autoload :SASLauth, 'protocols/saslauth' 
     1650         
     1651        #require 'protocols/postgres' UNCOMMENT THIS LINE WHEN THE POSTGRES CODE IS READY FOR PRIME TIME. 
    16491652end 
    1650  
    1651 # Is inside of protocols/ but not in the namespace? 
    1652 require 'protocols/buftok' 
    16531653 
    16541654end # module EventMachine 
     
    16581658EM::P = EventMachine::Protocols 
    16591659 
    1660 # At the bottom of this module, we load up protocol handlers that depend on some 
    1661 # of the classes defined here. Eventually we should refactor this out so it's 
    1662 # laid out in a more logical way. 
    1663 # 
    1664  
    1665 #require 'protocols/postgres' UNCOMMENT THIS LINE WHEN THE POSTGRES CODE IS READY FOR PRIME TIME. 
    1666  
    16671660require 'em/processes' 
  • branches/raggi/lib/protocols/header_and_content.rb

    r668 r784  
    2929    module Protocols 
    3030 
    31         class HeaderAndContentProtocol < LineAndTextProtocol 
     31        # Originally, this subclassed LineAndTextProtocol, which in 
     32        # turn relies on BufferedTokenizer, which doesn't gracefully 
     33        # handle the transitions between lines and binary text. 
     34        # Changed 13Sep08 by FCianfrocca. 
     35        class HeaderAndContentProtocol < Connection 
     36            include LineText2 
     37         
    3238 
    3339            ContentLengthPattern = /Content-length:\s*(\d+)/i 
  • branches/raggi/lib/protocols/linetext2.rb

    r741 r784  
    127127                        end 
    128128 
     129                        # Alias for #set_text_mode, added for back-compatibility with LineAndTextProtocol. 
     130                        def set_binary_mode size=nil 
     131                                set_text_mode size 
     132                        end 
     133 
    129134                        # In case of a dropped connection, we'll send a partial buffer to user code 
    130135                        # when in sized text mode. User overrides of #receive_binary_data need to 
  • branches/raggi/lib/protocols/postgres.rb

    r772 r784  
    136136                        @pending_conn = d 
    137137                        prms = {"user"=>user, "database"=>db} 
     138                        @user = user 
    138139                        if psw 
    139                                 prms["password"] = psw 
     140                                @password = psw 
     141                                #prms["password"] = psw 
    140142                        end 
    141143                        send_data PostgresPR::StartupMessage.new( 3 << 16, prms ).dump 
     
    193195                case msg 
    194196                when AuthentificationClearTextPassword 
    195                         raise ArgumentError, "no password specified" if password.nil? 
    196                         send_data PasswordMessage.new(password).dump 
     197                        raise ArgumentError, "no password specified" if @password.nil? 
     198                        send_data PasswordMessage.new(@password).dump 
    197199 
    198200                when AuthentificationCryptPassword 
    199                         raise ArgumentError, "no password specified" if password.nil? 
    200                         send_data PasswordMessage.new(password.crypt(msg.salt)).dump 
     201                        raise ArgumentError, "no password specified" if @password.nil? 
     202                        send_data PasswordMessage.new(@password.crypt(msg.salt)).dump 
    201203 
    202204                when AuthentificationMD5Password 
    203                         raise ArgumentError, "no password specified" if password.nil? 
     205                        raise ArgumentError, "no password specified" if @password.nil? 
    204206                        require 'digest/md5' 
    205207 
    206                         m = Digest::MD5.hexdigest(password + user)  
     208                        m = Digest::MD5.hexdigest(@password + @user)  
    207209                        m = Digest::MD5.hexdigest(m + msg.salt) 
    208210                        m = 'md5' + m 
  • branches/raggi/Rakefile

    r752 r784  
    4545else 
    4646  desc "Run tests." 
    47   task :default => 'test:partial' 
     47  task :default => :test 
    4848end 
    4949 
  • branches/raggi/tasks/tests.rake

    r723 r784  
    22# behavior so we can use the same tests to test both the 
    33# extension and non-extension versions. 
    4 def run_tests t, libr, test_filename_filter="test_*.rb" 
     4def run_tests t, libr = :cascade, test_files="test_*.rb" 
    55  require 'test/unit/testsuite' 
    66  require 'test/unit/ui/console/testrunner' 
    7  
     7  require 'tests/testem' 
     8   
     9  base_dir = File.expand_path(File.dirname(__FILE__) + '/../') + '/' 
     10   
    811  runner = Test::Unit::UI::Console::TestRunner 
    9  
    10   $eventmachine_library = ((RUBY_PLATFORM =~ /java/) ? :java : libr) 
    11   $LOAD_PATH.unshift('tests') 
    12   $stderr.puts "Checking for test cases:" #if t.verbose 
    13  
    14   if test_filename_filter.is_a?(Array) 
    15     test_filename_filter.each {|testcase| 
    16       $stderr.puts "\t#{testcase}" 
    17       load "tests/#{testcase}" 
    18     } 
    19   else 
    20     Dir["tests/#{test_filename_filter}"].each do |testcase| 
    21       $stderr.puts "\t#{testcase}" #if t.verbose 
    22       load testcase 
    23     end 
    24   end 
    25  
     12   
     13  $eventmachine_library = libr 
     14  EmTestRunner.run(test_files) 
     15   
    2616  suite = Test::Unit::TestSuite.new($name) 
    2717 
     
    3525desc "Run tests for #{Spec.name}." 
    3626task :test do |t| 
    37   run_tests t, nil 
     27  # run_tests t 
     28  # Rake +/ friends leave threads, etc, less stable test runs. 
     29  ruby '-Ilib -Iext -Ijava tests/testem.rb' 
    3830end 
    3931 
     
    5345      "test_httpclient.rb", 
    5446      "test_kb.rb", 
    55       #"test_ltp2.rb", 
     47      "test_ltp2.rb", 
    5648      "test_ltp.rb", 
    5749      "test_next_tick.rb", 
     
    6759      "test_timers.rb", 
    6860      "test_ud.rb", 
    69     ] 
     61    ].map { |tf| "tests/#{tf}" } 
    7062  end 
    7163   
     
    166158  desc "Test Spawn" 
    167159  task :spawn do |t| 
    168     run_tests t, :spawn, "test_spawn*.rb" 
     160    run_tests t, :extension, "test_spawn*.rb" 
    169161  end 
    170162 
  • branches/raggi/tests/test_basic.rb

    r767 r784  
    3232 
    3333  def setup 
     34    assert(!EM.reactor_running?) 
    3435  end 
    3536 
    3637  def teardown 
     38    assert(!EM.reactor_running?) 
    3739  end 
    3840 
     
    8486    n = 0 
    8587    EventMachine.run { 
    86       EventMachine.add_periodic_timer(1) { 
     88      EventMachine.add_periodic_timer(0.1) { 
    8789        n += 1 
    8890        EventMachine.stop if n == 2 
     
    114116  # even after the supplied block completes. 
    115117  def test_run_block 
    116           a = nil 
    117           EM.run_block { a = "Worked" } 
    118           assert a 
     118    assert !EM.reactor_running? 
     119      a = nil 
     120      EM.run_block { a = "Worked" } 
     121      assert a 
     122      assert !EM.reactor_running? 
    119123  end 
    120124 
     
    152156          } 
    153157  end 
    154  
    155158 
    156159  #------------------------------------ 
     
    179182          end 
    180183  end 
    181   def test_post_init_error 
     184  # This test causes issues, the machine becomes unreleasable after  
     185  # release_machine suffers an exception in event_callback. 
     186  def xxx_test_post_init_error 
    182187          assert_raise( EventMachine::ConnectionNotBound ) { 
    183188                  EM.run { 
     
    187192                  } 
    188193          } 
     194          EM.run { 
     195            EM.stop 
     196          } 
     197          assert !EM.reactor_running? 
    189198  end 
    190199   
  • branches/raggi/tests/test_defer.rb

    r668 r784  
    3131class TestDeferUsage < Test::Unit::TestCase 
    3232 
    33         def setup 
    34         end 
    35  
    36         def teardown 
    37         end 
    38  
    39         def run_em_with_defers 
    40                 n = 0 
    41                 n_times = 20 
    42                 EM.run { 
    43                         n_times.times { 
    44                                 EM.defer proc { 
    45                                         sleep 0.1 
    46                                 }, proc { 
    47                                         n += 1 
    48                                         EM.stop if n == n_times 
    49                                 } 
    50                         } 
    51                 } 
    52                 assert_equal( n, n_times ) 
    53         end 
    54         def test_defers 
    55                 10.times { 
    56                         run_em_with_defers {|n,ntimes| 
    57                                 assert_equal( n, ntimes ) 
    58                         } 
    59                 } 
    60         end 
     33  def test_defers 
     34    n = 0 
     35    n_times = 20 
     36    EM.run { 
     37      n_times.times { 
     38        work_proc = proc { n += 1 } 
     39        callback = proc { EM.stop if n == n_times } 
     40        EM.defer work_proc, callback 
     41      } 
     42    } 
     43    assert_equal( n, n_times ) 
     44  end 
    6145 
    6246end 
  • branches/raggi/tests/testem.rb

    r668 r784  
    44# 
    55 
     6module EmTestRunner 
     7  @em_root = File.expand_path(File.dirname(__FILE__) + '/../') 
     8  @lib_dir = File.join(@em_root, 'lib') 
     9  @ext_dir = File.join(@em_root, 'ext') 
     10  @java_dir = File.join(@em_root, 'java') 
     11 
     12  require 'test/unit' 
     13 
     14  def self.run(glob = 'test_*.rb') 
     15    $:.unshift(@lib_dir) 
     16    $:.unshift(@ext_dir) 
     17    $:.unshift(@java_dir) 
     18 
     19    case glob 
     20    when Array 
     21      files = glob 
     22    else 
     23      files = Dir[File.dirname(__FILE__) + '/' + glob] 
     24    end 
     25 
     26    files.each do |tc| 
     27      require tc 
     28    end 
     29  end 
     30end 
     31 
     32if __FILE__ == $0 
     33  EmTestRunner.run 
     34end 
  • branches/raggi/tests/test_epoll.rb

    r749 r784  
    2929# 
    3030 
    31 $:.unshift "../lib" 
    3231require 'eventmachine' 
    3332require 'test/unit' 
     
    3534 
    3635class TestEpoll < Test::Unit::TestCase 
    37  
    38         def setup 
    39         end 
    40  
    41         def teardown 
    42         end 
    43  
    4436 
    4537        module TestEchoServer 
     
    10294                EM.epoll 
    10395                EM.run { 
    104                         sleep_proc = proc {sleep 1} 
    105                         return_proc = proc {$n += 1; EM.stop} 
    106                         EM.defer sleep_proc, return_proc 
     96                        work_proc = proc {$n += 1} 
     97                        callback_proc = proc {EM.stop} 
     98                        EM.defer work_proc, callback_proc 
    10799                } 
    108100                assert_equal( 1, $n ) 
  • branches/raggi/tests/test_hc.rb

    r723 r784  
    2525# 
    2626 
    27 $:.unshift "../lib" 
     27# $:.unshift "../lib" 
    2828require 'eventmachine' 
    29 require 'socket' 
    3029require 'test/unit' 
    3130 
    32 # This doesn't completely work under Ruby 1.9. 
    33 # Part of it is thread race conditions. I added some sleeps to make these 
    34 # tests work. Native threads do strange things when you do I/O on them. 
    35 # 
    36 # And it's even worse in Java, where I/O on native threads doesn't seem 
    37 # to be reliable at all. 
    38 # 
    39  
    40  
    4131class TestHeaderAndContentProtocol < Test::Unit::TestCase 
    4232 
    43         TestHost = "127.0.0.1" 
    44         TestPort = 8905 
    45  
    46  
    47         #-------------------------------------------------------------------- 
    48  
    49         class SimpleTest < EventMachine::Protocols::HeaderAndContentProtocol 
    50                 attr_reader :first_header, :my_headers, :request 
    51  
    52                 def receive_first_header_line hdr 
    53                         @first_header ||= [] 
    54                         @first_header << hdr 
    55                 end 
    56                 def receive_headers hdrs 
    57                         @my_headers ||= [] 
    58                         @my_headers << hdrs 
    59                 end 
    60                 def receive_request hdrs, content 
    61                         @request ||= [] 
    62                         @request << [hdrs, content] 
    63                 end 
    64         end 
    65  
    66  
    67         def test_no_content 
    68                 Thread.abort_on_exception = true 
    69                 the_connection = nil 
    70                 EventMachine.run { 
    71                         EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn| 
    72                                 the_connection = conn 
    73                         end 
    74                         EventMachine.add_timer(4) {raise "test timed out"} 
    75  
    76                         pr = proc { 
    77                                 t = TCPSocket.new TestHost, TestPort 
    78                                 t.write [ "aaa\n", "bbb\r\n", "ccc\n", "\n" ].join 
    79                                 t.close 
    80                         } 
    81  
    82                         if RUBY_PLATFORM =~ /java/i 
    83                                 pr.call 
    84                                 EM.add_timer(0.5) {EM.stop} 
    85                         else 
    86                                 EventMachine.defer proc { 
    87                                         pr.call 
    88                                         if RUBY_VERSION =~ /\A1\.9\./ 
    89                                                 sleep 0.1 
    90                                                 STDERR.puts "Introducing extraneous sleep for Ruby 1.9" 
    91                                         end 
    92                                 }, proc { 
    93                                         EventMachine.stop 
    94                                 } 
    95                         end 
    96                 } 
    97                 assert_equal( ["aaa"], the_connection.first_header ) 
    98                 assert_equal( [%w(aaa bbb ccc)], the_connection.my_headers ) 
    99                 assert_equal( [[%w(aaa bbb ccc), ""]], the_connection.request ) 
    100         end 
    101  
    102  
    103  
    104  
    105         def test_content 
    106                 Thread.abort_on_exception = true 
    107                 the_connection = nil 
    108                 content = "A" * 50 
    109                 headers = ["aaa", "bbb", "Content-length: #{content.length}", "ccc"] 
    110                 EventMachine.run { 
    111                         EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn| 
    112                                 the_connection = conn 
    113                         end 
    114                         EventMachine.add_timer(4) {raise "test timed out"} 
    115  
    116                         pr = proc { 
    117                                 t = TCPSocket.new TestHost, TestPort 
    118                                 headers.each {|h| t.write "#{h}\r\n" } 
    119                                 t.write "\n" 
    120                                 t.write content 
    121                                 t.close 
    122                         } 
    123  
    124                         if RUBY_PLATFORM =~ /java/i 
    125                                 # I/O on threads seems completely unreliable in Java. 
    126                                 pr.call 
    127                                 EM.add_timer(0.5) {EM.stop} 
    128                         else 
    129                                 EventMachine.defer proc { 
    130                                         pr.call 
    131                                         if RUBY_VERSION =~ /\A1\.9\./ 
    132                                                 sleep 0.1 
    133                                                 STDERR.puts "Introducing extraneous sleep for Ruby 1.9" 
    134                                         end 
    135                                 }, proc { 
    136                                         EM.stop 
    137                                 } 
    138                         end 
    139                 } 
    140                 assert_equal( ["aaa"], the_connection.first_header ) 
    141                 assert_equal( [headers], the_connection.my_headers ) 
    142                 assert_equal( [[headers, content]], the_connection.request ) 
    143         end 
    144  
    145  
    146  
    147         def test_several_requests 
    148                 Thread.abort_on_exception = true 
    149                 the_connection = nil 
    150                 content = "A" * 50 
    151                 headers = ["aaa", "bbb", "Content-length: #{content.length}", "ccc"] 
    152                 EventMachine.run { 
    153                         EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn| 
    154                                 the_connection = conn 
    155                         end 
    156                         EventMachine.add_timer(4) {raise "test timed out"} 
    157  
    158                         pr = proc { 
    159                                 t = TCPSocket.new TestHost, TestPort 
    160                                 5.times { 
    161                                         headers.each {|h| t.write "#{h}\r\n" } 
    162                                         t.write "\n" 
    163                                         t.write content 
    164                                 } 
    165                                 t.close 
    166                         } 
    167  
    168                         if RUBY_PLATFORM =~ /java/i 
    169                                 pr.call 
    170                                 EM.add_timer(1) {EM.stop} 
    171                         else 
    172                                 EventMachine.defer proc { 
    173                                         pr.call 
    174                                         if RUBY_VERSION =~ /\A1\.9\./ 
    175                                                 sleep 0.1 
    176                                                 STDERR.puts "Introducing extraneous sleep for Ruby 1.9" 
    177                                         end 
    178                                 }, proc { 
    179                                         EventMachine.stop 
    180                                 } 
    181                         end 
    182                 } 
    183                 assert_equal( ["aaa"] * 5, the_connection.first_header ) 
    184                 assert_equal( [headers] * 5, the_connection.my_headers ) 
    185                 assert_equal( [[headers, content]] * 5, the_connection.request ) 
    186         end 
    187  
    188  
    189     def x_test_multiple_content_length_headers 
    190         # This is supposed to throw a RuntimeError but it throws a C++ exception instead. 
    191         Thread.abort_on_exception = true 
    192         the_connection = nil 
    193         content = "A" * 50 
    194         headers = ["aaa", "bbb", ["Content-length: #{content.length}"]*2, "ccc"].flatten 
    195         EventMachine.run { 
    196             EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn| 
    197                 the_connection = conn 
    198             end 
    199             EventMachine.add_timer(4) {raise "test timed out"} 
    200             EventMachine.defer proc { 
    201                 t = TCPSocket.new TestHost, TestPort 
    202                 headers.each {|h| t.write "#{h}\r\n" } 
    203                 t.write "\n" 
    204                 t.write content 
    205                 t.close 
    206             }, proc { 
    207                 EventMachine.stop 
    208             } 
    209         } 
     33  TestHost = "127.0.0.1" 
     34  TestPort = 8905 
     35 
     36  class SimpleTest < EventMachine::Protocols::HeaderAndContentProtocol 
     37    attr_reader :first_header, :my_headers, :request 
     38 
     39    def receive_first_header_line hdr 
     40      @first_header ||= [] 
     41      @first_header << hdr 
    21042    end 
    211  
    212         def test_interpret_headers 
    213                 Thread.abort_on_exception = true 
    214                 the_connection = nil 
    215                 content = "A" * 50 
    216                 headers = [ 
    217                         "GET / HTTP/1.0", 
    218                         "Accept: aaa", 
    219                         "User-Agent: bbb", 
    220                         "Host:      ccc", 
    221                         "x-tempest-header:ddd" 
    222                 ] 
    223  
    224                 EventMachine.run { 
    225                         EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn| 
    226                                 the_connection = conn 
    227                         end 
    228                         EventMachine.add_timer(4) {raise "test timed out"} 
    229  
    230                         pr = proc { 
    231                                 t = TCPSocket.new TestHost, TestPort 
    232                                 headers.each {|h| t.write "#{h}\r\n" } 
    233                                 t.write "\n" 
    234                                 t.write content 
    235                                 t.close 
    236                         } 
    237  
    238                         if RUBY_PLATFORM =~ /java/i 
    239                                 pr.call 
    240                                 EM.add_timer(0.5) {EM.stop} 
    241                         else 
    242                                 EventMachine.defer proc { 
    243                                         pr.call 
    244                                         if RUBY_VERSION =~ /\A1\.9\./ 
    245                                                 sleep 0.1 
    246                                                 STDERR.puts "Introducing extraneous sleep for Ruby 1.9" 
    247                                         end 
    248                                 }, proc { 
    249                                         EventMachine.stop 
    250                                 } 
    251                         end 
    252                 } 
    253  
    254                 hsh = the_connection.headers_2_hash( the_connection.my_headers.shift ) 
    255                 assert_equal( 
    256                         { 
    257                                 :accept => "aaa", 
    258                                 :user_agent => "bbb", 
    259                                 :host => "ccc", 
    260                                 :x_tempest_header => "ddd" 
    261                         }, 
    262                         hsh 
    263                 ) 
    264         end 
    265  
     43    def receive_headers hdrs 
     44      @my_headers ||= [] 
     45      @my_headers << hdrs 
     46    end 
     47    def receive_request hdrs, content 
     48      @request ||= [] 
     49      @request << [hdrs, content] 
     50    end 
     51  end 
     52 
     53  def test_no_content 
     54    the_connection = nil 
     55    EventMachine.run { 
     56      EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn| 
     57        the_connection = conn 
     58      end 
     59      EventMachine.add_timer(4) {raise "test timed out"} 
     60 
     61      client = Module.new do 
     62        def unbind 
     63          EM.add_timer(0.1) { EM.stop } 
     64        end 
     65 
     66        def post_init 
     67          send_data [ "aaa\n", "bbb\r\n", "ccc\n", "\n" ].join 
     68          close_connection_after_writing 
     69        end 
     70      end 
     71 
     72      EventMachine.connect( TestHost, TestPort, client ) 
     73    } 
     74    assert_equal( ["aaa"], the_connection.first_header ) 
     75    assert_equal( [%w(aaa bbb ccc)], the_connection.my_headers ) 
     76    assert_equal( [[%w(aaa bbb ccc), ""]], the_connection.request ) 
     77  end 
     78 
     79  def test_content 
     80    the_connection = nil 
     81    content = "A" * 50 
     82    headers = ["aaa", "bbb", "Content-length: #{content.length}", "ccc"] 
     83    EventMachine.run { 
     84      EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn| 
     85        the_connection = conn 
     86      end 
     87      EventMachine.add_timer(4) { assert(false, 'test timeout'); EM.stop } 
     88 
     89      client = Module.new do 
     90        define_method(:headers) { headers } 
     91        define_method(:content) { content } 
     92 
     93        def unbind 
     94          EM.add_timer(0.1) { EM.stop } 
     95        end 
     96 
     97        def post_init 
     98          headers.each { |h| send_data "#{h}\r\n" } 
     99          send_data "\n" 
     100          send_data content 
     101          close_connection_after_writing 
     102        end 
     103      end 
     104 
     105      EventMachine.connect( TestHost, TestPort, client ) 
     106 
     107    } 
     108    assert_equal( ["aaa"], the_connection.first_header ) 
     109    assert_equal( [headers], the_connection.my_headers ) 
     110    assert_equal( [[headers, content]], the_connection.request ) 
     111  end 
     112 
     113  def test_several_requests 
     114    the_connection = nil 
     115    content = "A" * 50 
     116    headers = ["aaa", "bbb", "Content-length: #{content.length}", "ccc"] 
     117    EventMachine.run { 
     118      EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn| 
     119        the_connection = conn 
     120      end 
     121      EventMachine.add_timer(4) { assert(false, 'test timeout'); EM.stop } 
     122 
     123      client = Module.new do 
     124        define_method(:headers) { headers } 
     125        define_method(:content) { content } 
     126 
     127        def unbind 
     128          EM.add_timer(0.1) { EM.stop } 
     129        end 
     130 
     131        def post_init 
     132          5.times do 
     133            headers.each { |h| send_data "#{h}\r\n" } 
     134            send_data "\n" 
     135            send_data content 
     136          end 
     137          close_connection_after_writing 
     138        end 
     139      end 
     140 
     141      EventMachine.connect( TestHost, TestPort, client ) 
     142    } 
     143    assert_equal( ["aaa"] * 5, the_connection.first_header ) 
     144    assert_equal( [headers] * 5, the_connection.my_headers ) 
     145    assert_equal( [[headers, content]] * 5, the_connection.request ) 
     146  end 
     147 
     148 
     149  # def x_test_multiple_content_length_headers 
     150  #   # This is supposed to throw a RuntimeError but it throws a C++ exception instead. 
     151  #   the_connection = nil 
     152  #   content = "A" * 50 
     153  #   headers = ["aaa", "bbb", ["Content-length: #{content.length}"]*2, "ccc"].flatten 
     154  #   EventMachine.run { 
     155  #     EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn| 
     156  #       the_connection = conn 
     157  #     end 
     158  #     EventMachine.add_timer(4) {raise "test timed out"} 
     159  #     test_proc = proc { 
     160  #       t = TCPSocket.new TestHost, TestPort 
     161  #       headers.each {|h| t.write "#{h}\r\n" } 
     162  #       t.write "\n" 
     163  #       t.write content 
     164  #       t.close 
     165  #     } 
     166  #     EventMachine.defer test_proc, proc { 
     167  #       EventMachine.stop 
     168  #     } 
     169  #   } 
     170  # end 
     171 
     172  def test_interpret_headers 
     173    the_connection = nil 
     174    content = "A" * 50 
     175    headers = [ 
     176      "GET / HTTP/1.0", 
     177      "Accept: aaa", 
     178      "User-Agent: bbb", 
     179      "Host:        ccc", 
     180      "x-tempest-header:ddd" 
     181    ] 
     182 
     183    EventMachine.run { 
     184      EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn| 
     185        the_connection = conn 
     186      end 
     187      EventMachine.add_timer(4) {raise "test timed out"} 
     188 
     189      client = Module.new do 
     190        define_method(:headers) { headers } 
     191        define_method(:content) { content } 
     192 
     193        def unbind 
     194          EM.add_timer(0.1) { EM.stop } 
     195        end 
     196 
     197        def post_init 
     198          headers.each { |h| send_data "#{h}\r\n" } 
     199          send_data "\n" 
     200          send_data content 
     201          close_connection_after_writing 
     202        end 
     203      end 
     204 
     205      EventMachine.connect( TestHost, TestPort, client ) 
     206    } 
     207 
     208    hsh = the_connection.headers_2_hash( the_connection.my_headers.shift ) 
     209    expect = { 
     210      :accept => "aaa", 
     211      :user_agent => "bbb", 
     212      :host => "ccc", 
     213      :x_tempest_header => "ddd" 
     214    } 
     215    assert_equal(expect, hsh) 
     216  end 
    266217 
    267218end 
    268  
    269  
  • branches/raggi/tests/test_ltp.rb

    r668 r784  
    2626# 
    2727 
    28 $:.unshift "../lib" 
    2928require 'eventmachine' 
    30 require 'socket' 
    3129require 'test/unit' 
    3230 
    3331class TestLineAndTextProtocol < Test::Unit::TestCase 
    3432 
    35     TestHost = "127.0.0.1" 
    36     TestPort = 8905 
     33  TestHost = "127.0.0.1" 
     34  TestPort = 8905 
    3735 
    3836 
    39     #-------------------------------------------------------------------- 
     37  #-------------------------------------------------------------------- 
    4038 
    41     class SimpleLineTest < EventMachine::Protocols::LineAndTextProtocol 
    42         def receive_line line 
    43             @line_buffer << line 
    44         end 
     39  class SimpleLineTest < EventMachine::Protocols::LineAndTextProtocol 
     40    def receive_line line 
     41      @line_buffer << line 
    4542    end 
     43  end 
    4644 
    47     def test_simple_lines 
    48         # THIS TEST CURRENTLY FAILS IN JRUBY. 
    49         assert( RUBY_PLATFORM !~ /java/ ) 
    50  
    51         lines_received = [] 
    52         Thread.abort_on_exception = true 
    53         EventMachine.run { 
    54             EventMachine.start_server( TestHost, TestPort, SimpleLineTest ) do |conn| 
    55                 conn.instance_eval "@line_buffer = lines_received" 
    56             end 
    57             EventMachine.add_timer(4) {raise "test timed out"} 
    58             EventMachine.defer proc { 
    59                 t = TCPSocket.new TestHost, TestPort 
    60                 t.write [ 
    61                     "aaa\n", "bbb\r\n", "ccc\n" 
    62                 ].join 
    63                 t.close 
    64             }, proc { 
    65                 EventMachine.stop 
    66             } 
    67         } 
    68         assert_equal( %w(aaa bbb ccc), lines_received ) 
     45  module StopClient 
     46    def set_receive_data(&blk) 
     47      @rdb = blk 
    6948    end 
    70  
    71     #-------------------------------------------------------------------- 
    72  
    73     class SimpleLineTest < EventMachine::Protocols::LineAndTextProtocol 
    74         def receive_error text 
    75             @error_message << text 
    76         end 
     49     
     50    def receive_data data 
     51      @rdb.call(data) if @rdb 
    7752    end 
    78  
    79     def test_overlength_lines 
    80         # THIS TEST CURRENTLY FAILS IN JRUBY. 
    81         assert( RUBY_PLATFORM !~ /java/ ) 
    82  
    83         lines_received = [] 
    84         Thread.abort_on_exception = true 
    85         EventMachine.run { 
    86             EventMachine.start_server( TestHost, TestPort, SimpleLineTest ) do |conn| 
    87                 conn.instance_eval "@error_message = lines_received" 
    88             end 
    89             EventMachine.add_timer(4) {raise "test timed out"} 
    90             EventMachine.defer proc { 
    91                 t = TCPSocket.new TestHost, TestPort 
    92                 t.write "a" * (16*1024 + 1) 
    93                 t.write "\n" 
    94                 t.close 
    95             }, proc { 
    96                 EventMachine.stop 
    97             } 
    98         } 
    99         assert_equal( ["overlength line"], lines_received ) 
     53     
     54    def unbind 
     55      EM.add_timer(0.1) { EM.stop } 
    10056    end 
     57  end 
    10158 
    10259 
    103     #-------------------------------------------------------------------- 
     60  def test_simple_lines 
     61    # THIS TEST CURRENTLY FAILS IN JRUBY. 
     62    assert( RUBY_PLATFORM !~ /java/ ) 
    10463 
    105     class LineAndTextTest < EventMachine::Protocols::LineAndTextProtocol 
    106         def post_init 
    107         end 
    108         def receive_line line 
    109             if line =~ /content-length:\s*(\d+)/i 
    110                 @content_length = $1.to_i 
    111             elsif line.length == 0 
    112                 set_binary_mode @content_length 
    113             end 
    114         end 
    115         def rec