eventmachine-eventmachine 0.12.7 → 0.12.8

data/tests/test_send_file.rb

@@ -31,16 +31,16 @@ require 'test/unit'
 
 class TestSendFile < Test::Unit::TestCase
 
-	module TestModule
-		def post_init
-			send_file_data TestFilename
-			close_connection_after_writing
-		end
-	end
-	
-	module TestClient
-	  def data_to(&blk)
-	    @data_to = blk
+  module TestModule
+    def post_init
+      send_file_data TestFilename
+      close_connection_after_writing
+    end
+  end
+
+  module TestClient
+    def data_to(&blk)
+      @data_to = blk
     end
     
     def receive_data(data)
@@ -52,192 +52,191 @@ class TestSendFile < Test::Unit::TestCase
     end
   end
 
-	TestHost = "0.0.0.0"
-	TestPort = 9055
-	TestFilename = "./xxxxxx"
+  TestHost = "0.0.0.0"
+  TestPort = 9055
+  TestFilename = "./xxxxxx"
 
-	def setup
-	end
+  def setup
+  end
 
-	def teardown
-		File.unlink( TestFilename ) if File.exist?( TestFilename )
-	end
+  def teardown
+    File.unlink( TestFilename ) if File.exist?( TestFilename )
+  end
 
-	def test_send_file
-		File.open( TestFilename, "w" ) {|f|
-			f << ("A" * 5000)
-		}
+  def test_send_file
+    File.open( TestFilename, "w" ) {|f|
+      f << ("A" * 5000)
+    }
 
-		data = ''
+    data = ''
 
-		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|
-			  c.data_to { |d| data << d }
-		  end
-		}
+    EM.run {
+      EM.start_server TestHost, TestPort, TestModule
+      EM.add_timer(2) {EM.stop} # avoid hanging in case of error
 
-		assert_equal( "A" * 5000, data )
-		File.unlink TestFilename
-	end
+      EM.connect TestHost, TestPort, TestClient do |c|
+        c.data_to { |d| data << d }
+      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)
-		}
+    assert_equal( "A" * 5000, data )
+    File.unlink TestFilename
+  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)
+    }
 
-		data = ''
+    data = ''
 
-		ex_class = RUBY_PLATFORM == 'java' ? NativeException : RuntimeError
+    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|
-  			  c.data_to { |d| data << d }
-  		  end
-			}
-		}
-
-		File.unlink TestFilename
-	end
-
-
-	module StreamTestModule
-		def post_init
-			EM::Deferrable.future( stream_file_data(TestFilename)) {
-				close_connection_after_writing
-			}
-		end
-	end
-
-	module ChunkStreamTestModule
-		def post_init
-			EM::Deferrable.future( stream_file_data(TestFilename, :http_chunks=>true)) {
-				close_connection_after_writing
-			}
-		end
-	end
-
-	def test_stream_file_data
-		File.open( TestFilename, "w" ) {|f|
-			f << ("A" * 1000)
-		}
-
-		data = ''
-
-		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
-		}
-
-		assert_equal( "A" * 1000, data )
-
-		File.unlink TestFilename
-	end
-
-	def test_stream_chunked_file_data
-		File.open( TestFilename, "w" ) {|f|
-			f << ("A" * 1000)
-		}
-
-		data = ''
-
-		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( "3e8\r\n#{"A" * 1000}\r\n0\r\n\r\n", data )
-
-		File.unlink TestFilename
-	end
-
-	module BadFileTestModule
-		def post_init
-			de = stream_file_data( TestFilename+"..." )
-			de.errback {|msg|
-				send_data msg
-				close_connection_after_writing
-			}
-		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 }
-		  end
-		}
-
-		assert_equal( "file not found", data )
-	end
-
-	def test_stream_large_file_data
-	  begin
-	    require 'fastfilereaderext'
+      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|
+          c.data_to { |d| data << d }
+        end
+      }
+    }
+
+    File.unlink TestFilename
+  end
+
+
+  module StreamTestModule
+    def post_init
+      EM::Deferrable.future( stream_file_data(TestFilename)) {
+        close_connection_after_writing
+      }
+    end
+  end
+
+  module ChunkStreamTestModule
+    def post_init
+      EM::Deferrable.future( stream_file_data(TestFilename, :http_chunks=>true)) {
+        close_connection_after_writing
+      }
+    end
+  end
+
+  def test_stream_file_data
+    File.open( TestFilename, "w" ) {|f|
+      f << ("A" * 1000)
+    }
+
+    data = ''
+
+    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
+    }
+
+    assert_equal( "A" * 1000, data )
+
+    File.unlink TestFilename
+  end
+
+  def test_stream_chunked_file_data
+    File.open( TestFilename, "w" ) {|f|
+      f << ("A" * 1000)
+    }
+
+    data = ''
+
+    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( "3e8\r\n#{"A" * 1000}\r\n0\r\n\r\n", data )
+
+    File.unlink TestFilename
+  end
+
+  module BadFileTestModule
+    def post_init
+      de = stream_file_data( TestFilename+"..." )
+      de.errback {|msg|
+        send_data msg
+        close_connection_after_writing
+      }
+    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 }
+      end
+    }
+
+    assert_equal( "file not found", data )
+  end
+
+  def test_stream_large_file_data
+    begin
+      require 'fastfilereaderext'
     rescue LoadError
       return
     end
-		File.open( TestFilename, "w" ) {|f|
-			f << ("A" * 10000)
-		}
+    File.open( TestFilename, "w" ) {|f|
+      f << ("A" * 10000)
+    }
 
-		data = ''
+    data = ''
 
-		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
-		}
+    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
+    }
 
-		assert_equal( "A" * 10000, data )
+    assert_equal( "A" * 10000, data )
 
-		File.unlink TestFilename
-	end
+    File.unlink TestFilename
+  end
 
-	def test_stream_large_chunked_file_data
-	  begin
-	    require 'fastfilereaderext'
+  def test_stream_large_chunked_file_data
+    begin
+      require 'fastfilereaderext'
     rescue LoadError
       return
     end
-		File.open( TestFilename, "w" ) {|f|
-			f << ("A" * 100000)
-		}
-
-		data = ''
-
-		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
-		}
-
-		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 )
-
-		File.unlink TestFilename
-	end
+    File.open( TestFilename, "w" ) {|f|
+      f << ("A" * 100000)
+    }
+
+    data = ''
+
+    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
+    }
+
+    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 )
+
+    File.unlink TestFilename
+  end
 
 end
-

data/tests/test_servers.rb

@@ -29,52 +29,48 @@ require 'eventmachine'
 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)
+  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
   end
-	include NetstatHelper
+  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
-	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")
-	    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")  	    
-  	    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")
-	end
+  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
+  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")
+      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")
+        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")
+  end
 
 end
-
-

data/tests/test_smtpserver.rb

@@ -30,64 +30,56 @@ require 'test/unit'
 
 class TestSmtpServer < Test::Unit::TestCase
 
-	# Don't test on port 25. It requires superuser and there's probably
-	# a mail server already running there anyway.
-	Localhost = "127.0.0.1"
-	Localport = 25001
+  # Don't test on port 25. It requires superuser and there's probably
+  # a mail server already running there anyway.
+  Localhost = "127.0.0.1"
+  Localport = 25001
 
-	# This class is an example of what you need to write in order
-	# to implement a mail server. You override the methods you are
-	# interested in. Some, but not all, of these are illustrated here.
-	#
-	class Mailserver < EM::Protocols::SmtpServer
+  # This class is an example of what you need to write in order
+  # to implement a mail server. You override the methods you are
+  # interested in. Some, but not all, of these are illustrated here.
+  #
+  class Mailserver < EM::Protocols::SmtpServer
 
-		attr_reader :my_msg_body, :my_sender, :my_recipients
+    attr_reader :my_msg_body, :my_sender, :my_recipients
 
-		def initialize *args
-			super
-		end
-		def receive_sender sender
-			@my_sender = sender
-			#p sender
-			true
-		end
-		def receive_recipient rcpt
-			@my_recipients ||= []
-			@my_recipients << rcpt
-			true
-		end
-		def receive_data_chunk c
-			@my_msg_body = c.last
-		end
-		def connection_ended
-			EM.stop
-		end
-	end
+    def initialize *args
+      super
+    end
+    def receive_sender sender
+      @my_sender = sender
+      #p sender
+      true
+    end
+    def receive_recipient rcpt
+      @my_recipients ||= []
+      @my_recipients << rcpt
+      true
+    end
+    def receive_data_chunk c
+      @my_msg_body = c.last
+    end
+    def connection_ended
+      EM.stop
+    end
+  end
 
+  def test_mail
+    c = nil
+    EM.run {
+      EM.start_server( Localhost, Localport, Mailserver ) {|conn| c = conn}
+      EM::Timer.new(2) {EM.stop} # prevent hanging the test suite in case of error
+      EM::Protocols::SmtpClient.send :host=>Localhost,
+        :port=>Localport,
+        :domain=>"bogus",
+        :from=>"me@example.com",
+        :to=>"you@example.com",
+        :header=> {"Subject"=>"Email subject line", "Reply-to"=>"me@example.com"},
+        :body=>"Not much of interest here."
 
-	def setup
-	end
-
-	def teardown
-	end
-
-	def test_mail
-		c = nil
-		EM.run {
-			EM.start_server( Localhost, Localport, Mailserver ) {|conn| c = conn}
-			EM::Timer.new(2) {EM.stop} # prevent hanging the test suite in case of error
-			EM::Protocols::SmtpClient.send :host=>Localhost,
-				:port=>Localport,
-				:domain=>"bogus",
-				:from=>"me@example.com",
-				:to=>"you@example.com",
-				:header=> {"Subject"=>"Email subject line", "Reply-to"=>"me@example.com"},
-				:body=>"Not much of interest here."
-
-		}
-		assert_equal( "Not much of interest here.", c.my_msg_body )
-		assert_equal( "<me@example.com>", c.my_sender )
-		assert_equal( ["<you@example.com>"], c.my_recipients )
-	end
+    }
+    assert_equal( "Not much of interest here.", c.my_msg_body )
+    assert_equal( "<me@example.com>", c.my_sender )
+    assert_equal( ["<you@example.com>"], c.my_recipients )
+  end
 end
-