wj_eventmachine 1.3.0.dev.1

data/tests/test_process_watch.rb

@@ -0,0 +1,50 @@
+require_relative 'em_test_helper'
+
+if EM.kqueue?
+  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
+    end
+
+    def teardown
+      EM.kqueue = false
+    end
+
+    def test_events
+      omit_if(rbx?)
+      omit_if(jruby?)
+      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.2){
+          Process.kill('TERM', $fork_pid)
+        }
+      }
+
+      assert_equal($pid, $fork_pid)
+      assert($forked)
+      assert($exited)
+      assert($unbind)
+    end
+  end
+end

data/tests/test_processes.rb

@@ -0,0 +1,128 @@
+require_relative 'em_test_helper'
+
+class TestProcesses < Test::Unit::TestCase
+
+  if !windows? && !jruby?
+
+    # 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(0, $status.exitstatus)
+      assert_kind_of(Process::Status, $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(0, $status.exitstatus)
+      assert_kind_of(Process::Status, $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('echo', '1', '2', 'version', proc{ |process|
+        }, proc{ |out,status|
+          $out = out
+          $status = status
+          EM.stop
+        })
+      }
+
+      assert_match(/1 2 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
+
+    def test_em_popen_pause_resume
+      c_rx = 0
+
+      test_client = Module.new do
+        define_method :receive_data do |data|
+          c_rx += 1
+          pause
+          EM.add_timer(0.5) { EM.stop }
+        end
+      end
+
+      EM.run do
+        EM.popen('echo 1', test_client)
+      end
+
+      assert_equal 1, c_rx
+    end
+  else
+    warn "EM.popen not implemented, skipping tests in #{__FILE__}"
+
+    # Because some rubies will complain if a TestCase class has no tests
+    def test_em_popen_unsupported
+      assert true
+    end
+  end
+end

data/tests/test_proxy_connection.rb

@@ -0,0 +1,180 @@
+require_relative 'em_test_helper'
+
+class TestProxyConnection < Test::Unit::TestCase
+
+  if EM.respond_to?(:start_proxy)
+    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
+        $proxied_bytes = self.get_proxied_bytes
+        @client.close_connection_after_writing
+      end
+    end
+
+    module PartialProxyConnection
+      def initialize(client, request, length)
+        @client, @request, @length = client, request, length
+      end
+
+      def post_init
+        EM::enable_proxy(self, @client, 0, @length)
+      end
+
+      def receive_data(data)
+        $unproxied_data = data
+        @client.send_data(data)
+      end
+
+      def connection_completed
+        EM.next_tick {
+          send_data @request
+        }
+      end
+
+      def proxy_target_unbound
+        $unbound_early = true
+        EM.stop
+      end
+
+      def proxy_completed
+        $proxy_completed = true
+      end
+
+      def unbind
+        @client.close_connection_after_writing
+      end
+    end
+
+    module Client
+      def connection_completed
+        send_data "EM 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 == "EM rocks!"
+        close_connection_after_writing
+      end
+    end
+
+    module ProxyServer
+      def initialize port
+        @port = port
+      end
+
+      def receive_data(data)
+        @proxy = EM.connect("127.0.0.1", @port, ProxyConnection, self, data)
+      end
+    end
+
+    module PartialProxyServer
+      def initialize port
+        @port = port
+      end
+
+      def receive_data(data)
+        EM.connect("127.0.0.1", @port, PartialProxyConnection, self, data, 1)
+      end
+    end
+
+    module EarlyClosingProxy
+      def initialize port
+        @port = port
+      end
+
+      def receive_data(data)
+        EM.connect("127.0.0.1", @port, ProxyConnection, self, data)
+        close_connection
+      end
+    end
+
+    def setup
+      @port = next_port
+      @proxy_port = next_port
+    end
+
+    def test_proxy_connection
+      EM.run {
+        EM.start_server("127.0.0.1", @port, Server)
+        EM.start_server("127.0.0.1", @proxy_port, ProxyServer, @port)
+        EM.connect("127.0.0.1", @proxy_port, Client)
+      }
+
+      assert_equal("I know!", $client_data)
+    end
+
+    def test_proxied_bytes
+      EM.run {
+        EM.start_server("127.0.0.1", @port, Server)
+        EM.start_server("127.0.0.1", @proxy_port, ProxyServer, @port)
+        EM.connect("127.0.0.1", @proxy_port, Client)
+      }
+
+      assert_equal("I know!", $client_data)
+      assert_equal("I know!".bytesize, $proxied_bytes)
+    end
+
+    def test_partial_proxy_connection
+      EM.run {
+        EM.start_server("127.0.0.1", @port, Server)
+        EM.start_server("127.0.0.1", @proxy_port, PartialProxyServer, @port)
+        EM.connect("127.0.0.1", @proxy_port, Client)
+      }
+
+      assert_equal("I know!", $client_data)
+      assert_equal(" know!", $unproxied_data)
+      assert($proxy_completed)
+    end
+
+    def test_early_close
+      $client_data = nil
+      EM.run {
+        EM.start_server("127.0.0.1", @port, Server)
+        EM.start_server("127.0.0.1", @proxy_port, EarlyClosingProxy, @port)
+        EM.connect("127.0.0.1", @proxy_port, Client2)
+      }
+
+      assert($unbound_early)
+    end
+  else
+    warn "EM.start_proxy not implemented, skipping tests in #{__FILE__}"
+
+    # Because some rubies will complain if a TestCase class has no tests
+    def test_em_start_proxy_not_implemented
+      assert !EM.respond_to?(:start_proxy)
+    end
+  end
+
+end

data/tests/test_pure.rb

@@ -0,0 +1,156 @@
+require_relative 'em_test_helper'
+
+class TestPure < Test::Unit::TestCase
+
+  def setup
+    @port = next_port
+  end
+
+  # 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.
+
+  #-------------------------------------
+
+  # 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.
+  # 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 test_exception_handling_releases_resources
+    exception = Class.new(StandardError)
+
+    2.times do
+      assert_raises(exception) do
+        EM.run do
+          EM.start_server "127.0.0.1", @port
+          raise exception
+        end
+      end
+    end
+  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
+    assert_nothing_raised do
+      EM.run {
+        setup_timeout(2)
+        EM.connect "127.0.0.1", @port, TestConnrefused
+      }
+    end
+  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
+    assert_nothing_raised do
+      EM.run {
+        EM.start_server "127.0.0.1", @port
+        EM.connect "127.0.0.1", @port, TestConnaccepted
+        setup_timeout(1)
+      }
+    end
+  end
+
+  def test_reactor_running
+    a = false
+    EM.run {
+      a = EM.reactor_running?
+      EM.next_tick {EM.stop}
+    }
+    assert a
+  end
+
+  module TLSServer
+    def post_init
+      start_tls
+    end
+
+    def ssl_handshake_completed
+      $server_handshake_completed = true
+    end
+
+    def receive_data(data)
+      $server_received_data = data
+      send_data(data)
+    end
+  end
+
+  module TLSClient
+    def post_init
+      start_tls
+    end
+
+    def ssl_handshake_completed
+      $client_handshake_completed = true
+    end
+
+    def connection_completed
+      send_data('Hello World!')
+    end
+
+    def receive_data(data)
+      $client_received_data = data
+      close_connection
+    end
+
+    def unbind
+      EM.stop_event_loop
+    end
+  end
+
+  def test_start_tls
+    omit("No SSL") unless EM.ssl?
+    $client_handshake_completed, $server_handshake_completed = false, false
+    $client_received_data, $server_received_data = nil, nil
+    EM.run do
+      EM.start_server("127.0.0.1", 16789, TLSServer)
+      EM.connect("127.0.0.1", 16789, TLSClient)
+    end
+
+    assert($client_handshake_completed)
+    assert($server_handshake_completed)
+    assert($client_received_data == "Hello World!")
+    assert($server_received_data == "Hello World!")
+  end
+
+  def test_periodic_timer
+    x = 0
+    start, finish = nil
+
+    EM.run {
+      start = Time.now.to_f
+      EM::PeriodicTimer.new(0.2) do
+        x += 1
+        finish = Time.now.to_f
+        EM.stop if x == 4
+      end
+    }
+    assert_in_delta 0.8, (finish - start), (darwin? ? 0.6 : 0.2)
+    assert_equal 4, x
+  end
+end