eventmachine 1.0.0.beta.2-x86-mswin32-60 → 1.0.0.beta.3-x86-mswin32-60

data/tests/test_proxy_connection.rb

@@ -1,144 +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
-    end
+  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 post_init
+        EM::enable_proxy(self, @client)
+      end
 
-    def connection_completed
-      EM.next_tick {
-        send_data @request
-      }
-    end
+      def connection_completed
+        EM.next_tick {
+          send_data @request
+        }
+      end
 
-    def proxy_target_unbound
-      $unbound_early = true
-      EM.stop
-    end
+      def proxy_target_unbound
+        $unbound_early = true
+        EM.stop
+      end
 
-    def unbind
-      @client.close_connection_after_writing
+      def unbind
+        @client.close_connection_after_writing
+      end
     end
-  end
 
-  module PartialProxyConnection
-    def initialize(client, request, length)
-      @client, @request, @length = client, request, length
-    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 post_init
+        EM::enable_proxy(self, @client, 0, @length)
+      end
 
-    def receive_data(data)
-      $unproxied_data = data
-      @client.send_data(data) 
-    end
+      def receive_data(data)
+        $unproxied_data = data
+        @client.send_data(data)
+      end
 
-    def connection_completed
-      EM.next_tick {
-        send_data @request
-      }
-    end
+      def connection_completed
+        EM.next_tick {
+          send_data @request
+        }
+      end
 
-    def proxy_target_unbound
-      $unbound_early = true
-      EM.stop
-    end
+      def proxy_target_unbound
+        $unbound_early = true
+        EM.stop
+      end
 
-    def proxy_completed
-      $proxy_completed = true
-    end
+      def proxy_completed
+        $proxy_completed = true
+      end
 
-    def unbind
-      @client.close_connection_after_writing
+      def unbind
+        @client.close_connection_after_writing
+      end
     end
-  end
 
-  module Client
-    def connection_completed
-      send_data "EventMachine rocks!"
+    module Client
+      def connection_completed
+        send_data "EM rocks!"
+      end
+
+      def receive_data(data)
+        $client_data = data
+      end
+
+      def unbind
+        EM.stop
+      end
     end
 
-    def receive_data(data)
-      $client_data = data
+    module Client2
+      include Client
+      def unbind; end
     end
 
-    def unbind
-      EM.stop
+    module Server
+      def receive_data(data)
+        send_data "I know!" if data == "EM rocks!"
+        close_connection_after_writing
+      end
     end
-  end
 
-  module Client2
-    include Client
-    def unbind; end
-  end
+    module ProxyServer
+      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)
+      end
     end
-  end
 
-  module ProxyServer
-    def receive_data(data)
-      EM.connect("127.0.0.1", 54321, ProxyConnection, self, data)
+    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 PartialProxyServer
-    def receive_data(data)
-      EM.connect("127.0.0.1", 54321, PartialProxyConnection, self, data, 1)
+    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
-  end
 
-  module EarlyClosingProxy
-    def receive_data(data)
-      EM.connect("127.0.0.1", 54321, ProxyConnection, self, data)
-      close_connection
+    def setup
+      @port = next_port
+      @proxy_port = next_port
     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_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
+      assert_equal("I know!", $client_data)
+    end
 
-  def test_partial_proxy_connection
-    EM.run {
-      EM.start_server("127.0.0.1", 54321, Server)
-      EM.start_server("127.0.0.1", 12345, PartialProxyServer)
-      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)
-    assert_equal(" know!", $unproxied_data)
-    assert($proxy_completed)
-  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)
+    end
+  else
+    warn "EM.start_proxy not implemented, skipping tests in #{__FILE__}"
 
-    assert($unbound_early)
+    # 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

@@ -1,76 +1,36 @@
-# $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 TestPure < Test::Unit::TestCase
 
-
-  Host,Port = "0.0.0.0", 9060
-
+  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.
 
-  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
 
+  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.
@@ -87,13 +47,16 @@ class TestPure < Test::Unit::TestCase
       raise "should never get here"
     end
   end
+
   def test_connrefused
-    EM.run {
-      EM.connect "0.0.0.0", 60001, TestConnrefused
-    }
+    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.
@@ -104,22 +67,13 @@ class TestPure < Test::Unit::TestCase
     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
-      setup_timeout(1)
-    }
-    assert_equal( false, timeout )
-  end
-  
-  def setup_timeout(timeout = 4)
-    EM.schedule {
-      start_time = EM.current_time
-      EM.add_periodic_timer(0.01) {
-        raise "timeout" if EM.current_time - start_time >= timeout
+    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

data/tests/test_queue.rb

@@ -1,8 +1,6 @@
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
+require 'em_test_helper'
 
-class TestEventMachineQueue < Test::Unit::TestCase
+class TestEMQueue < Test::Unit::TestCase
   def test_queue_push
     s = 0
     EM.run do

data/tests/test_resolver.rb

@@ -0,0 +1,55 @@
+require 'em_test_helper'
+
+class TestBasic < Test::Unit::TestCase
+  def test_a
+    EM.run {
+      d = EM::DNS::Resolver.resolve "google.com"
+      d.errback { assert false }
+      d.callback { |r|
+        assert r
+        EM.stop
+      }
+    }
+  end
+
+  def test_bad_host
+    EM.run {
+      d = EM::DNS::Resolver.resolve "asdfasasdf"
+      d.callback { assert false }
+      d.errback  { assert true; EM.stop }
+    }
+  end
+
+  def test_garbage
+    assert_raises( ArgumentError ) {
+      EM.run {
+        EM::DNS::Resolver.resolve 123
+      }
+    }
+  end
+
+  def test_a_pair
+    EM.run {
+      d = EM::DNS::Resolver.resolve "google.com"
+      d.errback { assert false }
+      d.callback { |r|
+        assert_equal(Array, r.class)
+        assert r.size > 1
+        EM.stop
+      }
+    }
+  end
+
+  def test_localhost
+    EM.run {
+      d = EM::DNS::Resolver.resolve "localhost"
+      d.errback { assert false }
+      d.callback { |r|
+        assert_equal("127.0.0.1", r.first)
+        assert_equal(Array, r.class)
+
+        EM.stop
+      }
+    }
+  end
+end