eventmachine-maglev- 0.12.10 → 1.0.0.beta.4

data/tests/test_pool.rb

@@ -0,0 +1,128 @@
+class TestPool < Test::Unit::TestCase
+  def pool
+    @pool ||= EM::Pool.new
+  end
+
+  def go
+    EM.run { yield }
+  end
+
+  def stop
+    EM.stop
+  end
+
+  def deferrable
+    @deferrable ||= EM::DefaultDeferrable.new
+  end
+
+  def test_supports_more_work_than_resources
+    ran = false
+    go do
+      pool.perform do
+        ran = true
+        deferrable
+      end
+      stop
+    end
+    assert_equal false, ran
+    go do
+      pool.add :resource
+      stop
+    end
+    assert_equal true, ran
+  end
+
+  def test_reques_resources_on_error
+    pooled_res, pooled_res2 = nil
+    pool.add :res
+    go do
+      pool.perform do |res|
+        pooled_res = res
+        deferrable
+      end
+      stop
+    end
+    deferrable.fail
+    go do
+      pool.perform do |res|
+        pooled_res2 = res
+        deferrable
+      end
+      stop
+    end
+    assert_equal :res, pooled_res
+    assert_equal pooled_res, pooled_res2
+  end
+
+  def test_supports_custom_error_handler
+    eres = nil
+    pool.on_error do |res|
+      eres = res
+    end
+    performs = []
+    pool.add :res
+    go do
+      pool.perform do |res|
+        performs << res
+        deferrable
+      end
+      pool.perform do |res|
+        performs << res
+        deferrable
+      end
+      deferrable.fail
+      stop
+    end
+    assert_equal :res, eres
+    # manual requeues required when error handler is installed:
+    assert_equal 1, performs.size
+    assert_equal :res, performs.first
+  end
+
+  def test_catches_successful_deferrables
+    performs = []
+    pool.add :res
+    go do
+      pool.perform { |res| performs << res; deferrable }
+      pool.perform { |res| performs << res; deferrable }
+      stop
+    end
+    assert_equal [:res], performs
+    deferrable.succeed
+    go { stop }
+    assert_equal [:res, :res], performs
+  end
+
+  def test_prunes_locked_and_removed_resources
+    performs = []
+    pool.add :res
+    deferrable.succeed
+    go do
+      pool.perform { |res| performs << res; pool.remove res; deferrable }
+      pool.perform { |res| performs << res; pool.remove res; deferrable }
+      stop
+    end
+    assert_equal [:res], performs
+  end
+
+  # Contents is only to be used for inspection of the pool!
+  def test_contents
+    pool.add :res
+    assert_equal [:res], pool.contents
+    # Assert that modifying the contents list does not affect the pools
+    # contents.
+    pool.contents.delete(:res)
+    assert_equal [:res], pool.contents
+  end
+
+  def test_num_waiting
+    pool.add :res
+    assert_equal 0, pool.num_waiting
+    pool.perform { |r| EM::DefaultDeferrable.new }
+    assert_equal 0, pool.num_waiting
+    10.times { pool.perform { |r| EM::DefaultDeferrable.new } }
+    EM.run { EM.next_tick { EM.stop } }
+    assert_equal 10, pool.num_waiting
+  end
+
+end

data/tests/test_process_watch.rb

@@ -1,48 +1,48 @@
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
+require 'em_test_helper'
 
-class TestProcessWatch < Test::Unit::TestCase
-  module ParentProcessWatcher
-    def process_forked
-      $forked = true
+if EM.kqueue?
+  class TestProcessWatch < Test::Unit::TestCase
+    module ParentProcessWatcher
+      def process_forked
+        $forked = true
+      end
     end
-  end
 
-  module ChildProcessWatcher
-    def process_exited
-      $exited = true
-    end
-    def unbind
-      $unbind = true
-      EM.stop
+    module ChildProcessWatcher
+      def process_exited
+        $exited = true
+      end
+      def unbind
+        $unbind = true
+        EM.stop
+      end
     end
-  end
 
-  def setup
-    EM.kqueue = true if EM.kqueue?
-  end
+    def setup
+      EM.kqueue = true
+    end
 
-  def teardown
-    EM.kqueue = false if EM.kqueue?
-  end
+    def teardown
+      EM.kqueue = false
+    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
+    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)
+        EM.add_timer(0.2){
+          Process.kill('TERM', $fork_pid)
+        }
       }
-    }
 
-    assert_equal($pid, $fork_pid)
-    assert($forked)
-    assert($exited)
-    assert($unbind)
+      assert_equal($pid, $fork_pid)
+      assert($forked)
+      assert($exited)
+      assert($unbind)
+    end
   end
-end
+end

data/tests/test_processes.rb

@@ -1,128 +1,110 @@
-# $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 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
+  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
+      assert( ls.length > 0)
+    end
 
-  def setup
-    $out = nil
-    $status = nil
-  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 }
-    }
+    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
+      assert( $out.length > 0 )
+      assert_equal($status.exitstatus, 0)
+      assert_equal($status.class, Process::Status)
+    end
 
-  def test_em_system_pid
-    $pids = []
+    def test_em_system_pid
+      $pids = []
 
-    EM.run{
-      $pids << EM.system('echo hi', proc{ |out,status|$pids << status.pid; EM.stop })
-    }
+      EM.run{
+        $pids << EM.system('echo hi', proc{ |out,status|$pids << status.pid; EM.stop })
+      }
 
-    assert_equal $pids[0], $pids[1]
-  end
+      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 })
+      }
 
-  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( $out.length > 0 )
-    assert_equal($status.exitstatus, 0)
-    assert_equal($status.class, Process::Status)
-  end
+      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
+        })
+      }
 
-  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
+      assert_match(/1 2 version/i, $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
+        })
+      }
 
-  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
+  else
+    warn "EM.popen not implemented, skipping tests in #{__FILE__}"
 
-    assert_equal("hello\n", $out)
+    # 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

@@ -1,92 +1,168 @@
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
+require 'em_test_helper'
 
 class TestProxyConnection < Test::Unit::TestCase
 
-  module ProxyConnection
-    def initialize(client, request)
-      @client, @request = client, request
+  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
+        @client.close_connection_after_writing
+      end
     end
 
-    def post_init
-      EM::enable_proxy(self, @client)
+    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
 
-    def connection_completed
-      EM.next_tick {
-        send_data @request
-      }
-    end
+    module Client
+      def connection_completed
+        send_data "EM rocks!"
+      end
+
+      def receive_data(data)
+        $client_data = data
+      end
 
-    def proxy_target_unbound
-      $unbound_early = true
-      EM.stop
+      def unbind
+        EM.stop
+      end
     end
 
-    def unbind
-      @client.close_connection_after_writing
+    module Client2
+      include Client
+      def unbind; end
     end
-  end
 
-  module Client
-    def connection_completed
-      send_data "EventMachine rocks!"
+    module Server
+      def receive_data(data)
+        send_data "I know!" if data == "EM rocks!"
+        close_connection_after_writing
+      end
     end
 
-    def receive_data(data)
-      $client_data = data
+    module ProxyServer
+      def initialize port
+        @port = port
+      end
+
+      def receive_data(data)
+        EM.connect("127.0.0.1", @port, ProxyConnection, self, data)
+      end
     end
 
-    def unbind
-      EM.stop
+    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
-  end
 
-  module Client2
-    include Client
-    def unbind; end
-  end
+    module EarlyClosingProxy
+      def initialize port
+        @port = port
+      end
 
-  module Server
-    def receive_data(data)
-      send_data "I know!" if data == "EventMachine rocks!"
-      close_connection_after_writing
+      def receive_data(data)
+        EM.connect("127.0.0.1", @port, ProxyConnection, self, data)
+        close_connection
+      end
     end
-  end
 
-  module ProxyServer
-    def receive_data(data)
-      EM.connect("127.0.0.1", 54321, ProxyConnection, self, data)
+    def setup
+      @port = next_port
+      @proxy_port = next_port
     end
-  end
 
-  module EarlyClosingProxy
-    def receive_data(data)
-      EM.connect("127.0.0.1", 54321, ProxyConnection, self, data)
-      close_connection
+    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
-  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)
-    }
+    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)
-  end
+      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", 54321, Server)
-      EM.start_server("127.0.0.1", 12345, EarlyClosingProxy)
-      EM.connect("127.0.0.1", 12345, Client2)
-    }
+    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)
+      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