smparkes-eventmachine 0.12.10

data/tests/test_pause.rb

@@ -0,0 +1,70 @@
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../lib")
+require 'eventmachine'
+require 'socket'
+require 'test/unit'
+
+class TestPause < Test::Unit::TestCase
+  TestHost = "127.0.0.1"
+  TestPort = 9070
+
+  def setup
+    assert(!EM.reactor_running?)
+  end
+
+  def teardown
+    assert(!EM.reactor_running?)
+  end
+
+  #-------------------------------------
+
+  def test_pause_resume
+    test = self
+    server = nil
+
+    s_rx = c_rx = 0
+
+    EM.run do
+      EM.start_server TestHost, TestPort, Module.new {
+        define_method :post_init do
+          server = self
+        end
+
+        define_method :receive_data do |data|
+          s_rx += 1
+
+          EM.add_periodic_timer(0.01) { send_data 'hi' }
+          send_data 'hi'
+
+          # pause server, now no outgoing data will actually
+          # be sent and no more incoming data will be received
+          pause
+        end
+      }
+
+      c = EM.connect TestHost, TestPort, Module.new {
+        define_method :receive_data do |data|
+          c_rx += 1
+        end
+      }
+      EM.add_periodic_timer(0.01) { c.send_data 'hi' }
+
+      EM.add_timer(1) do
+        test.assert_equal 1, s_rx
+        test.assert_equal 0, c_rx
+        test.assert server.paused?
+
+        # resume server, queued outgoing and incoming data will be flushed
+        server.resume
+
+        test.assert ! server.paused?
+
+        EM.add_timer(1) do
+          test.assert server.paused?
+          test.assert s_rx >= 2
+          test.assert c_rx >= 1
+          EM.stop_event_loop
+        end
+      end
+    end
+  end
+end

data/tests/test_pending_connect_timeout.rb

@@ -0,0 +1,48 @@
+$:.unshift "../lib"
+require 'eventmachine'
+require 'test/unit'
+
+class TestPendingConnectTimeout < Test::Unit::TestCase
+
+  def test_default
+    $timeout = nil
+    EM.run {
+      c = EM.connect("127.0.0.1", 54321)
+      $timeout = c.pending_connect_timeout
+      EM.stop
+    }
+
+    assert_equal(20.0, $timeout)
+  end
+
+  def test_set_and_get
+    $timeout = nil
+    EM.run {
+      c = EM.connect("1.2.3.4", 54321)
+      c.pending_connect_timeout = 2.5
+      $timeout = c.pending_connect_timeout
+      EM.stop
+    }
+
+    assert_equal(2.5, $timeout)
+  end
+
+  module TimeoutHandler
+    def unbind
+      EM.stop
+    end
+  end
+
+  def test_for_real
+    $timeout = nil
+    EM.run {
+      EM.heartbeat_interval = 0.1
+      $start = Time.now
+      c = EM.connect("1.2.3.4", 54321, TimeoutHandler)
+      c.pending_connect_timeout = 5
+    }
+
+    assert_in_delta(5, (Time.now - $start), 0.3)
+  end
+
+end

data/tests/test_process_watch.rb

@@ -0,0 +1,48 @@
+$:.unshift "../lib"
+require 'eventmachine'
+require 'test/unit'
+
+class TestProcessWatch < Test::Unit::TestCase
+  module ParentProcessWatcher
+    def process_forked
+      $forked = true
+    end
+  end
+
+  module ChildProcessWatcher
+    def process_exited
+      $exited = true
+    end
+    def unbind
+      $unbind = true
+      EM.stop
+    end
+  end
+
+  def setup
+    EM.kqueue = true if EM.kqueue?
+  end
+
+  def teardown
+    EM.kqueue = false if EM.kqueue?
+  end
+
+  def test_events
+    EM.run{
+      # watch ourselves for a fork notification
+      EM.watch_process(Process.pid, ParentProcessWatcher)
+      $fork_pid = fork{ sleep }
+      child = EM.watch_process($fork_pid, ChildProcessWatcher)
+      $pid = child.pid
+
+      EM.add_timer(0.5){
+        Process.kill('TERM', $fork_pid)
+      }
+    }
+
+    assert_equal($pid, $fork_pid)
+    assert($forked)
+    assert($exited)
+    assert($unbind)
+  end
+end

data/tests/test_processes.rb

@@ -0,0 +1,128 @@
+# $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'
+
+class TestProcesses < Test::Unit::TestCase
+
+  # EM::DeferrableChildProcess is a sugaring of a common use-case
+  # involving EM::popen.
+  # Call the #open method on EM::DeferrableChildProcess, passing
+  # a command-string. #open immediately returns an EM::Deferrable
+  # object. It also schedules the forking of a child process, which
+  # will execute the command passed to #open.
+  # When the forked child terminates, the Deferrable will be signalled
+  # and execute its callbacks, passing the data that the child process
+  # wrote to stdout.
+  #
+  def test_deferrable_child_process
+    ls = ""
+    EM.run {
+      d = EM::DeferrableChildProcess.open( "ls -ltr" )
+      d.callback {|data_from_child|
+        ls = data_from_child
+        EM.stop
+      }
+    }
+    assert( ls.length > 0)
+  end
+
+  def setup
+    $out = nil
+    $status = nil
+  end
+
+  def test_em_system
+    EM.run{
+      EM.system('ls'){ |out,status| $out, $status = out, status; EM.stop }
+    }
+
+    assert( $out.length > 0 )
+    assert_equal($status.exitstatus, 0)
+    assert_equal($status.class, Process::Status)
+  end
+
+  def test_em_system_pid
+    $pids = []
+
+    EM.run{
+      $pids << EM.system('echo hi', proc{ |out,status|$pids << status.pid; EM.stop })
+    }
+
+    assert_equal $pids[0], $pids[1]
+  end
+
+  def test_em_system_with_proc
+    EM.run{
+      EM.system('ls', proc{ |out,status| $out, $status = out, status; EM.stop })
+    }
+
+    assert( $out.length > 0 )
+    assert_equal($status.exitstatus, 0)
+    assert_equal($status.class, Process::Status)
+  end
+
+  def test_em_system_with_two_procs
+    EM.run{
+      EM.system('sh', proc{ |process|
+        process.send_data("echo hello\n")
+        process.send_data("exit\n")
+      }, proc{ |out,status|
+        $out = out
+        $status = status
+        EM.stop
+      })
+    }
+
+    assert_equal("hello\n", $out)
+  end
+
+  def test_em_system_cmd_arguments
+    EM.run{
+      EM.system('sh', '--version', proc{ |process|
+      }, proc{ |out,status|
+        $out = out
+        $status = status
+        EM.stop
+      })
+    }
+
+    assert_match(/version/i, $out)
+  end
+
+  def test_em_system_spaced_arguments
+    EM.run{
+      EM.system('ruby', '-e', 'puts "hello"', proc{ |out,status|
+        $out = out
+        EM.stop
+      })
+    }
+
+    assert_equal("hello\n", $out)
+  end
+end

data/tests/test_proxy_connection.rb

@@ -0,0 +1,92 @@
+$:.unshift "../lib"
+require 'eventmachine'
+require 'test/unit'
+
+class TestProxyConnection < Test::Unit::TestCase
+
+  module ProxyConnection
+    def initialize(client, request)
+      @client, @request = client, request
+    end
+
+    def post_init
+      EM::enable_proxy(self, @client)
+    end
+
+    def connection_completed
+      EM.next_tick {
+        send_data @request
+      }
+    end
+
+    def proxy_target_unbound
+      $unbound_early = true
+      EM.stop
+    end
+
+    def unbind
+      @client.close_connection_after_writing
+    end
+  end
+
+  module Client
+    def connection_completed
+      send_data "EventMachine rocks!"
+    end
+
+    def receive_data(data)
+      $client_data = data
+    end
+
+    def unbind
+      EM.stop
+    end
+  end
+
+  module Client2
+    include Client
+    def unbind; end
+  end
+
+  module Server
+    def receive_data(data)
+      send_data "I know!" if data == "EventMachine rocks!"
+      close_connection_after_writing
+    end
+  end
+
+  module ProxyServer
+    def receive_data(data)
+      EM.connect("127.0.0.1", 54321, ProxyConnection, self, data)
+    end
+  end
+
+  module EarlyClosingProxy
+    def receive_data(data)
+      EM.connect("127.0.0.1", 54321, ProxyConnection, self, data)
+      close_connection
+    end
+  end
+
+  def test_proxy_connection
+    EM.run {
+      EM.start_server("127.0.0.1", 54321, Server)
+      EM.start_server("127.0.0.1", 12345, ProxyServer)
+      EM.connect("127.0.0.1", 12345, Client)
+    }
+
+    assert_equal("I know!", $client_data)
+  end
+
+  def test_early_close
+    $client_data = nil
+    EM.run {
+      EM.start_server("127.0.0.1", 54321, Server)
+      EM.start_server("127.0.0.1", 12345, EarlyClosingProxy)
+      EM.connect("127.0.0.1", 12345, Client2)
+    }
+
+    assert($unbound_early)
+  end
+
+end

data/tests/test_pure.rb

@@ -0,0 +1,125 @@
+# $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'
+
+class TestPure < Test::Unit::TestCase
+
+
+  Host,Port = "0.0.0.0", 9060
+
+
+  # These tests are intended to exercise problems that come up in the
+  # pure-Ruby implementation. However, we DON'T constrain them such that
+  # they only run in pure-Ruby. These tests need to work identically in
+  # any implementation.
+
+  def setup
+  end
+
+  def teardown
+  end
+
+  #-------------------------------------
+
+  # The EM reactor needs to run down open connections and release other resources
+  # when it stops running. Make sure this happens even if user code throws a Ruby
+  # exception.
+  # One way to see this is to run identical tests that open a TCP server and throw
+  # an exception. (We do this twice because an exception aborts a test. We make the
+  # two tests identical except for the method name because we can't predict the order
+  # in which the test harness will run them.)
+  # If exception handling is incorrect, the second test will fail with a no-bind error
+  # because the TCP server opened in the first test will not have been closed.
+  #
+  def run_exception
+      EM.run {
+        EM.start_server Host, Port
+        raise "an exception"
+      }
+  end
+  def test_exception_1
+    assert_raises( RuntimeError ) { run_exception }
+  end
+  def test_exception_2
+    ex_class = RUBY_PLATFORM == 'java' ? NativeException : RuntimeError
+    assert_raises( ex_class ) { run_exception }
+  end
+
+
+  # Under some circumstances, the pure Ruby library would emit an Errno::ECONNREFUSED
+  # exception on certain kinds of TCP connect-errors.
+  # It's always been something of an open question whether EM should throw an exception
+  # in these cases but the defined answer has always been to catch it the unbind method.
+  # With a connect failure, the latter will always fire, but connection_completed will
+  # never fire. So even though the point is arguable, it's incorrect for the pure Ruby
+  # version to throw an exception.
+  module TestConnrefused
+    def unbind
+      EM.stop
+    end
+    def connection_completed
+      raise "should never get here"
+    end
+  end
+  def test_connrefused
+    EM.run {
+      EM.connect "0.0.0.0", 60001, TestConnrefused
+    }
+  end
+
+
+  # Make sure connection_completed gets called as expected with TCP clients. This is the
+  # opposite of test_connrefused.
+  # If the test fails, it will hang because EM.stop never gets called.
+  #
+  module TestConnaccepted
+    def connection_completed
+      EM.stop
+    end
+  end
+  def test_connaccepted
+    timeout = false
+    EM.run {
+      EM.start_server "0.0.0.0", 60002
+      EM.connect "0.0.0.0", 60002, TestConnaccepted
+      EM::Timer.new(1) {timeout = true; EM.stop}
+    }
+    assert_equal( false, timeout )
+  end
+
+  def test_reactor_running
+    a = false
+    EM.run {
+      a = EM.reactor_running?
+      EM.next_tick {EM.stop}
+    }
+    assert a
+  end
+
+end

data/tests/test_queue.rb

@@ -0,0 +1,44 @@
+$:.unshift "../lib"
+require 'eventmachine'
+require 'test/unit'
+
+class TestEventMachineQueue < Test::Unit::TestCase
+  def test_queue_push
+    s = 0
+    EM.run do
+      q = EM::Queue.new
+      q.push(1)
+      EM.next_tick { s = q.size; EM.stop }
+    end
+    assert_equal 1, s
+  end
+
+  def test_queue_pop
+    x,y,z = nil
+    EM.run do
+      q = EM::Queue.new
+      q.push(1,2,3)
+      q.pop { |v| x = v }
+      q.pop { |v| y = v }
+      q.pop { |v| z = v; EM.stop }
+    end
+    assert_equal 1, x
+    assert_equal 2, y
+    assert_equal 3, z
+  end
+
+  def test_queue_reactor_thread
+    q = EM::Queue.new
+
+    Thread.new { q.push(1,2,3) }.join
+    assert q.empty?
+    EM.run { EM.next_tick { EM.stop } }
+    assert_equal 3, q.size
+
+    x = nil
+    Thread.new { q.pop { |v| x = v } }.join
+    assert_equal nil, x
+    EM.run { EM.next_tick { EM.stop } }
+    assert_equal 1, x
+  end
+end

data/tests/test_running.rb

@@ -0,0 +1,42 @@
+# $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'
+
+class TestRunning < Test::Unit::TestCase
+  def test_running
+    assert_equal( false, EM::reactor_running? )
+    r = false
+    EM.run {
+      r = EM::reactor_running?
+      EM.stop
+    }
+    assert_equal( true, r )
+  end
+end
+

data/tests/test_sasl.rb

@@ -0,0 +1,72 @@
+# $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'
+
+
+class TestSASL < Test::Unit::TestCase
+
+  # SASL authentication is usually done with UNIX-domain sockets, but
+  # we'll use TCP so this test will work on Windows. As far as the
+  # protocol handlers are concerned, there's no difference.
+
+  Host,Port = "127.0.0.1",9560
+  TestUser,TestPsw = "someone", "password"
+
+  class SaslServer < EM::Connection
+    include EM::Protocols::SASLauth
+    def validate usr, psw, sys, realm
+      usr == TestUser and psw == TestPsw
+    end
+  end
+
+  class SaslClient < EM::Connection
+    include EM::Protocols::SASLauthclient
+  end
+
+  def test_sasl
+    resp = nil
+    EM.run {
+      EM.start_server( Host, Port, SaslServer )
+
+      c = EM.connect( Host, Port, SaslClient )
+      d = c.validate?( TestUser, TestPsw )
+      d.timeout 2
+      d.callback {
+        resp = true
+        EM.stop
+      }
+      d.errback {
+        resp = false
+        EM.stop
+      }
+    }
+    assert_equal( true, resp )
+  end
+
+end