eventmachine-maglev- 0.12.10 → 1.0.0.beta.4

data/tests/test_send_file.rb

@@ -1,242 +1,217 @@
-# $Id$
-#
-# Author:: Francis Cianfrocca (gmail: blackhedd)
-# Homepage::  http://rubyeventmachine.com
-# Date:: 8 April 2006
-# 
-# See EventMachine and EventMachine::Connection for documentation and
-# usage examples.
-#
-#----------------------------------------------------------------------------
-#
-# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
-# Gmail: blackhedd
-# 
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of either: 1) the GNU General Public License
-# as published by the Free Software Foundation; either version 2 of the
-# License, or (at your option) any later version; or 2) Ruby's License.
-# 
-# See the file COPYING for complete licensing information.
-#
-#---------------------------------------------------------------------------
-#
-#
-# 
-
-$:.unshift "../lib"
-require 'eventmachine'
-require 'socket'
-require 'test/unit'
+require 'em_test_helper'
+require 'tempfile'
 
 class TestSendFile < Test::Unit::TestCase
 
-  module TestModule
-    def post_init
-      send_file_data TestFilename
-      close_connection_after_writing
-    end
-  end
+  if EM.respond_to?(:send_file_data)
+    module TestModule
+      def initialize filename
+        @filename = filename
+      end
 
-  module TestClient
-    def data_to(&blk)
-      @data_to = blk
-    end
-    
-    def receive_data(data)
-      @data_to.call(data) if @data_to
-    end
-    
-    def unbind
-      EM.stop
+      def post_init
+        send_file_data @filename
+        close_connection_after_writing
+      end
     end
-  end
 
-  TestHost = "0.0.0.0"
-  TestPort = 9055
-  TestFilename = "./xxxxxx"
-
-  def setup
-  end
-
-  def teardown
-    File.unlink( TestFilename ) if File.exist?( TestFilename )
-  end
-
-  def test_send_file
-    File.open( TestFilename, "w" ) {|f|
-      f << ("A" * 5000)
-    }
-
-    data = ''
+    module TestClient
+      def data_to(&blk)
+        @data_to = blk
+      end
 
-    EM.run {
-      EM.start_server TestHost, TestPort, TestModule
-      EM.add_timer(2) {EM.stop} # avoid hanging in case of error
+      def receive_data(data)
+        @data_to.call(data) if @data_to
+      end
 
-      EM.connect TestHost, TestPort, TestClient do |c|
-        c.data_to { |d| data << d }
+      def unbind
+        EM.stop
       end
-    }
+    end
 
-    assert_equal( "A" * 5000, data )
-    File.unlink TestFilename
-  end
+    def setup
+      @file = Tempfile.new("em_test_file")
+      @filename = @file.path
+      @port = next_port
+    end
 
-  # EventMachine::Connection#send_file_data has a strict upper limit on the filesize it will work with.
-  def test_send_large_file
-    File.open( TestFilename, "w" ) {|f|
-      f << ("A" * 1000000)
-    }
+    def test_send_file
+      File.open( @filename, "w" ) {|f|
+        f << ("A" * 5000)
+      }
 
-    data = ''
+      data = ''
 
-    ex_class = RUBY_PLATFORM == 'java' ? NativeException : RuntimeError
-    assert_raises( ex_class ) {
       EM.run {
-        EM.start_server TestHost, TestPort, TestModule
-        EM.add_timer(2) {EM.stop} # avoid hanging in case of error
-        EM.connect TestHost, TestPort, TestClient do |c|
+        EM.start_server "127.0.0.1", @port, TestModule, @filename
+        setup_timeout
+
+        EM.connect "127.0.0.1", @port, TestClient do |c|
           c.data_to { |d| data << d }
         end
       }
-    }
-
-    File.unlink TestFilename
-  end
 
+      assert_equal( "A" * 5000, data )
+    end
 
-  module StreamTestModule
-    def post_init
-      EM::Deferrable.future( stream_file_data(TestFilename)) {
-        close_connection_after_writing
+    # EM::Connection#send_file_data has a strict upper limit on the filesize it will work with.
+    def test_send_large_file
+      File.open( @filename, "w" ) {|f|
+        f << ("A" * 1000000)
       }
-    end
-  end
 
-  module ChunkStreamTestModule
-    def post_init
-      EM::Deferrable.future( stream_file_data(TestFilename, :http_chunks=>true)) {
-        close_connection_after_writing
+      data = ''
+
+      assert_raises(RuntimeError) {
+        EM.run {
+          EM.start_server "127.0.0.1", @port, TestModule, @filename
+          setup_timeout
+          EM.connect "127.0.0.1", @port, TestClient do |c|
+            c.data_to { |d| data << d }
+          end
+        }
       }
     end
-  end
 
-  def test_stream_file_data
-    File.open( TestFilename, "w" ) {|f|
-      f << ("A" * 1000)
-    }
+    module StreamTestModule
+      def initialize filename
+        @filename = filename
+      end
 
-    data = ''
+      def post_init
+        EM::Deferrable.future( stream_file_data(@filename)) {
+          close_connection_after_writing
+        }
+      end
+    end
 
-    EM.run {
-      EM.start_server TestHost, TestPort, StreamTestModule
-      EM.add_timer(2) {EM.stop} # avoid hanging in case of error
-      EM.connect TestHost, TestPort, TestClient do |c|
-        c.data_to { |d| data << d }
+    module ChunkStreamTestModule
+      def initialize filename
+        @filename = filename
       end
-    }
 
-    assert_equal( "A" * 1000, data )
+      def post_init
+        EM::Deferrable.future( stream_file_data(@filename, :http_chunks=>true)) {
+          close_connection_after_writing
+        }
+      end
+    end
 
-    File.unlink TestFilename
-  end
+    def test_stream_file_data
+      File.open( @filename, "w" ) {|f|
+        f << ("A" * 1000)
+      }
 
-  def test_stream_chunked_file_data
-    File.open( TestFilename, "w" ) {|f|
-      f << ("A" * 1000)
-    }
+      data = ''
 
-    data = ''
+      EM.run {
+        EM.start_server "127.0.0.1", @port, StreamTestModule, @filename
+        setup_timeout
+        EM.connect "127.0.0.1", @port, TestClient do |c|
+          c.data_to { |d| data << d }
+        end
+      }
 
-    EM.run {
-      EM.start_server TestHost, TestPort, ChunkStreamTestModule
-      EM.add_timer(2) {EM.stop} # avoid hanging in case of error
-      EM.connect TestHost, TestPort, TestClient do |c|
-        c.data_to { |d| data << d }
-      end
-    }
+      assert_equal( "A" * 1000, data )
+    end
 
-    assert_equal( "3e8\r\n#{"A" * 1000}\r\n0\r\n\r\n", data )
+    def test_stream_chunked_file_data
+      File.open( @filename, "w" ) {|f|
+        f << ("A" * 1000)
+      }
 
-    File.unlink TestFilename
-  end
+      data = ''
 
-  module BadFileTestModule
-    def post_init
-      de = stream_file_data( TestFilename+"..." )
-      de.errback {|msg|
-        send_data msg
-        close_connection_after_writing
+      EM.run {
+        EM.start_server "127.0.0.1", @port, ChunkStreamTestModule, @filename
+        setup_timeout
+        EM.connect "127.0.0.1", @port, TestClient do |c|
+          c.data_to { |d| data << d }
+        end
       }
+
+      assert_equal( "3e8\r\n#{"A" * 1000}\r\n0\r\n\r\n", data )
     end
-  end
-  def test_stream_bad_file
-    data = ''
-    EM.run {
-      EM.start_server TestHost, TestPort, BadFileTestModule
-      EM.add_timer(2) {EM.stop} # avoid hanging in case of error
-      EM.connect TestHost, TestPort, TestClient do |c|
-        c.data_to { |d| data << d }
+
+    module BadFileTestModule
+      def initialize filename
+        @filename = filename
       end
-    }
 
-    assert_equal( "file not found", data )
-  end
+      def post_init
+        de = stream_file_data( @filename+".wrong" )
+        de.errback {|msg|
+          send_data msg
+          close_connection_after_writing
+        }
+      end
+    end
+    def test_stream_bad_file
+      data = ''
+      EM.run {
+        EM.start_server "127.0.0.1", @port, BadFileTestModule, @filename
+        setup_timeout(5)
+        EM.connect "127.0.0.1", @port, TestClient do |c|
+          c.data_to { |d| data << d }
+        end
+      }
 
-  def test_stream_large_file_data
-    begin
-      require 'fastfilereaderext'
-    rescue LoadError
-      return
+      assert_equal( "file not found", data )
     end
-    File.open( TestFilename, "w" ) {|f|
-      f << ("A" * 10000)
-    }
+  else
+    warn "EM.send_file_data not implemented, skipping tests in #{__FILE__}"
 
-    data = ''
+    # Because some rubies will complain if a TestCase class has no tests
+    def test_em_send_file_data_not_implemented
+      assert !EM.respond_to?(:send_file_data)
+    end
+  end
 
-    EM.run {
-      EM.start_server TestHost, TestPort, StreamTestModule
-      EM.add_timer(2) {EM.stop} # avoid hanging in case of error
-      EM.connect TestHost, TestPort, TestClient do |c|
-        c.data_to { |d| data << d }
-      end
-    }
+  begin
+    require 'fastfilereaderext'
 
-    assert_equal( "A" * 10000, data )
+    def test_stream_large_file_data
+      File.open( @filename, "w" ) {|f|
+        f << ("A" * 10000)
+      }
 
-    File.unlink TestFilename
-  end
+      data = ''
 
-  def test_stream_large_chunked_file_data
-    begin
-      require 'fastfilereaderext'
-    rescue LoadError
-      return
+      EM.run {
+        EM.start_server "127.0.0.1", @port, StreamTestModule, @filename
+        setup_timeout
+        EM.connect "127.0.0.1", @port, TestClient do |c|
+          c.data_to { |d| data << d }
+        end
+      }
+
+      assert_equal( "A" * 10000, data )
     end
-    File.open( TestFilename, "w" ) {|f|
-      f << ("A" * 100000)
-    }
 
-    data = ''
+    def test_stream_large_chunked_file_data
+      File.open( @filename, "w" ) {|f|
+        f << ("A" * 100000)
+      }
 
-    EM.run {
-      EM.start_server TestHost, TestPort, ChunkStreamTestModule
-      EM.add_timer(2) {EM.stop} # avoid hanging in case of error
-      EM.connect TestHost, TestPort, TestClient do |c|
-        c.data_to { |d| data << d }
-      end
-    }
+      data = ''
 
-    expected = [
-      "4000\r\n#{"A" * 16384}\r\n" * 6,
-      "6a0\r\n#{"A" * 0x6a0}\r\n",
-      "0\r\n\r\n"
-    ].join
-    assert_equal( expected, data )
+      EM.run {
+        EM.start_server "127.0.0.1", @port, ChunkStreamTestModule, @filename
+        setup_timeout
+        EM.connect "127.0.0.1", @port, TestClient do |c|
+          c.data_to { |d| data << d }
+        end
+      }
 
-    File.unlink TestFilename
+      expected = [
+        "4000\r\n#{"A" * 16384}\r\n" * 6,
+        "6a0\r\n#{"A" * 0x6a0}\r\n",
+        "0\r\n\r\n"
+      ].join
+      assert_equal( expected, data )
+    end
+  rescue LoadError
+    warn "require 'fastfilereaderext' failed, skipping tests in #{__FILE__}"
   end
 
 end

data/tests/test_servers.rb

@@ -1,76 +1,33 @@
-# $Id$
-#
-# Author:: Francis Cianfrocca (gmail: blackhedd)
-# Homepage::  http://rubyeventmachine.com
-# Date:: 8 April 2006
-# 
-# See EventMachine and EventMachine::Connection for documentation and
-# usage examples.
-#
-#----------------------------------------------------------------------------
-#
-# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
-# Gmail: blackhedd
-# 
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of either: 1) the GNU General Public License
-# as published by the Free Software Foundation; either version 2 of the
-# License, or (at your option) any later version; or 2) Ruby's License.
-# 
-# See the file COPYING for complete licensing information.
-#
-#---------------------------------------------------------------------------
-#
-#
-# 
-
-$:.unshift "../lib"
-require 'eventmachine'
+require 'em_test_helper'
 require 'socket'
-require 'test/unit'
 
 class TestServers < Test::Unit::TestCase
 
-  Host = "127.0.0.1"
-  Port = 9555
-
-  module NetstatHelper
-    GlobalUdp4Rexp = /udp.*\s+(?:\*|(?:0\.){3}0)[:.](\d+)\s/i
-    GlobalTcp4Rexp = /tcp.*\s+(?:\*|(?:0\.){3}0)[:.](\d+)\s/i
-    LocalUdpRexp = /udp.*\s+(?:127\.0\.0\.1|::1)[:.](\d+)\s/i
-    LocalTcpRexp = /tcp.*\s+(?:127\.0\.0\.1|::1)[:.](\d+)\s/i
-    def grep_netstat(pattern)
-      `netstat -an`.scan(/^.*$/).grep(pattern)
-    end
+  def setup
+    @port = next_port
   end
-  include NetstatHelper
 
-  class TestStopServer < EM::Connection
-    def initialize *args
-      super
-    end
-    def post_init
-      # TODO,sucks that this isn't OOPy enough.
-      EM.stop_server @server_instance
-    end
+  def server_alive?
+    port_in_use?(@port)
   end
 
   def run_test_stop_server
     EM.run {
-      sig = EM.start_server(Host, Port)
-      assert(grep_netstat(LocalTcpRexp).grep(%r(#{Port})).size >= 1, "Server didn't start")
+      sig = EM.start_server("127.0.0.1", @port)
+      assert server_alive?, "Server didn't start"
       EM.stop_server sig
       # Give the server some time to shutdown.
       EM.add_timer(0.1) {
-        assert(grep_netstat(LocalTcpRexp).grep(%r(#{Port})).empty?, "Servers didn't stop")
+        assert !server_alive?, "Server didn't stop"
         EM.stop
       }
     }
   end
+
   def test_stop_server
-    assert(grep_netstat(LocalTcpRexp).grep(Port).empty?, "Port already in use")
-    5.times {run_test_stop_server}
-    assert(grep_netstat(LocalTcpRexp).grep(%r(#{Port})).empty?, "Servers didn't stop")
+    assert !server_alive?, "Port already in use"
+    2.times { run_test_stop_server }
+    assert !server_alive?, "Servers didn't stop"
   end
 
 end

data/tests/test_shutdown_hooks.rb

@@ -0,0 +1,23 @@
+require 'em_test_helper'
+
+class TestShutdownHooks < Test::Unit::TestCase
+  def test_shutdown_hooks
+    r = false
+    EM.run {
+      EM.add_shutdown_hook { r = true }
+      EM.stop
+    }
+    assert_equal( true, r )
+  end
+
+  def test_hook_order
+    r = []
+    EM.run {
+      EM.add_shutdown_hook { r << 2 }
+      EM.add_shutdown_hook { r << 1 }
+      EM.stop
+    }
+    assert_equal( [1, 2], r )
+  end
+end
+

data/tests/test_smtpclient.rb

@@ -1,32 +1,4 @@
-# $Id$
-#
-# Author:: Francis Cianfrocca (gmail: blackhedd)
-# Homepage::  http://rubyeventmachine.com
-# Date:: 8 April 2006
-# 
-# See EventMachine and EventMachine::Connection for documentation and
-# usage examples.
-#
-#----------------------------------------------------------------------------
-#
-# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
-# Gmail: blackhedd
-# 
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of either: 1) the GNU General Public License
-# as published by the Free Software Foundation; either version 2 of the
-# License, or (at your option) any later version; or 2) Ruby's License.
-# 
-# See the file COPYING for complete licensing information.
-#
-#---------------------------------------------------------------------------
-#
-#
-#
-
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
+require 'em_test_helper'
 
 class TestSmtpClient < Test::Unit::TestCase
 

data/tests/test_smtpserver.rb

@@ -1,32 +1,4 @@
-# $Id$
-#
-# Author:: Francis Cianfrocca (gmail: blackhedd)
-# Homepage::  http://rubyeventmachine.com
-# Date:: 8 April 2006
-# 
-# See EventMachine and EventMachine::Connection for documentation and
-# usage examples.
-#
-#----------------------------------------------------------------------------
-#
-# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
-# Gmail: blackhedd
-# 
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of either: 1) the GNU General Public License
-# as published by the Free Software Foundation; either version 2 of the
-# License, or (at your option) any later version; or 2) Ruby's License.
-# 
-# See the file COPYING for complete licensing information.
-#
-#---------------------------------------------------------------------------
-#
-#
-#
-
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
+require 'em_test_helper'
 
 class TestSmtpServer < Test::Unit::TestCase
 

data/tests/test_spawn.rb

@@ -1,34 +1,5 @@
-# $Id$
-#
-# Author:: Francis Cianfrocca (gmail: blackhedd)
-# Homepage::  http://rubyeventmachine.com
-# Date:: 25 Aug 2007
-# 
-# See EventMachine and EventMachine::Connection for documentation and
-# usage examples.
-#
-#----------------------------------------------------------------------------
-#
-# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
-# Gmail: blackhedd
-# 
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of either: 1) the GNU General Public License
-# as published by the Free Software Foundation; either version 2 of the
-# License, or (at your option) any later version; or 2) Ruby's License.
-# 
-# See the file COPYING for complete licensing information.
-#
-#---------------------------------------------------------------------------
-#
-#
-#
-#
-
-
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
+
+require 'em_test_helper'
 
 
 

data/tests/test_ssl_args.rb

@@ -1,10 +1,9 @@
 require "test/unit"
 require 'tempfile'
 
-$:.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
-require "eventmachine"
+require 'em_test_helper'
 
-module EventMachine
+module EM
   def self._set_mocks
     class <<self
       alias set_tls_parms_old set_tls_parms
@@ -36,11 +35,11 @@ end
 
 class TestSslArgs < Test::Unit::TestCase
   def setup
-    EventMachine._set_mocks
+    EM._set_mocks
   end
   
   def teardown
-    EventMachine._clear_mocks
+    EM._clear_mocks
   end
   
   def test_tls_params_file_doesnt_exist
@@ -50,15 +49,15 @@ class TestSslArgs < Test::Unit::TestCase
     end
     
     # associate_callback_target is a pain! (build!)
-    conn = EventMachine::Connection.new('foo')
+    conn = EM::Connection.new('foo')
     
-    assert_raises(EventMachine::FileNotFoundException) do
+    assert_raises(EM::FileNotFoundException) do
       conn.start_tls(:private_key_file => priv_file)
     end
-    assert_raises(EventMachine::FileNotFoundException) do
+    assert_raises(EM::FileNotFoundException) do
       conn.start_tls(:cert_chain_file => cert_file)
     end
-    assert_raises(EventMachine::FileNotFoundException) do
+    assert_raises(EM::FileNotFoundException) do
       conn.start_tls(:private_key_file => priv_file, :cert_chain_file => cert_file)
     end
   end
@@ -68,7 +67,7 @@ class TestSslArgs < Test::Unit::TestCase
     cert_file = Tempfile.new('em_test')
     priv_file_path = priv_file.path
     cert_file_path = cert_file.path
-    conn = EventMachine::Connection.new('foo')
+    conn = EM::Connection.new('foo')
     params = {:private_key_file => priv_file_path, :cert_chain_file => cert_file_path}
     begin
       conn.start_tls params

data/tests/test_ssl_methods.rb

@@ -1,6 +1,4 @@
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
+require 'em_test_helper'
 
 class TestSSLMethods < Test::Unit::TestCase