eventmachine-maglev- 0.12.10 → 1.0.0.beta.4

data/tests/test_hc.rb

@@ -1,39 +1,8 @@
-# $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 TestHeaderAndContentProtocol < Test::Unit::TestCase
 
-  TestHost = "127.0.0.1"
-  TestPort = 8905
-
-  class SimpleTest < EventMachine::Protocols::HeaderAndContentProtocol
+  class SimpleTest < EM::P::HeaderAndContentProtocol
     attr_reader :first_header, :my_headers, :request
 
     def receive_first_header_line hdr
@@ -49,27 +18,29 @@ class TestHeaderAndContentProtocol < Test::Unit::TestCase
       @request << [hdrs, content]
     end
   end
+  
+  class StopOnUnbind < EM::Connection
+    def unbind
+      EM.add_timer(0.01) { EM.stop }
+    end
+  end
+
+  def setup
+    @port = next_port
+  end
 
   def test_no_content
     the_connection = nil
-    EventMachine.run {
-      EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
+    EM.run {
+      EM.start_server( "127.0.0.1", @port, SimpleTest ) do |conn|
         the_connection = conn
       end
-      EventMachine.add_timer(4) {raise "test timed out"}
-
-      client = Module.new do
-        def unbind
-          EM.add_timer(0.1) { EM.stop }
-        end
+      setup_timeout
 
-        def post_init
-          send_data [ "aaa\n", "bbb\r\n", "ccc\n", "\n" ].join
-          close_connection_after_writing
-        end
+      EM.connect "127.0.0.1", @port, StopOnUnbind do |c|
+        c.send_data [ "aaa\n", "bbb\r\n", "ccc\n", "\n" ].join
+        c.close_connection_after_writing
       end
-
-      EventMachine.connect( TestHost, TestPort, client )
     }
     assert_equal( ["aaa"], the_connection.first_header )
     assert_equal( [%w(aaa bbb ccc)], the_connection.my_headers )
@@ -80,30 +51,18 @@ class TestHeaderAndContentProtocol < Test::Unit::TestCase
     the_connection = nil
     content = "A" * 50
     headers = ["aaa", "bbb", "Content-length: #{content.length}", "ccc"]
-    EventMachine.run {
-      EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
+    EM.run {
+      EM.start_server( "127.0.0.1", @port, SimpleTest ) do |conn|
         the_connection = conn
       end
-      EventMachine.add_timer(4) { assert(false, 'test timeout'); EM.stop }
-
-      client = Module.new do
-        define_method(:headers) { headers }
-        define_method(:content) { content }
-
-        def unbind
-          EM.add_timer(0.1) { EM.stop }
-        end
+      setup_timeout
 
-        def post_init
-          headers.each { |h| send_data "#{h}\r\n" }
-          send_data "\n"
-          send_data content
-          close_connection_after_writing
-        end
+      EM.connect "127.0.0.1", @port, StopOnUnbind do |c|
+        headers.each { |h| c.send_data "#{h}\r\n" }
+        c.send_data "\n"
+        c.send_data content
+        c.close_connection_after_writing
       end
-
-      EventMachine.connect( TestHost, TestPort, client )
-
     }
     assert_equal( ["aaa"], the_connection.first_header )
     assert_equal( [headers], the_connection.my_headers )
@@ -114,31 +73,20 @@ class TestHeaderAndContentProtocol < Test::Unit::TestCase
     the_connection = nil
     content = "A" * 50
     headers = ["aaa", "bbb", "Content-length: #{content.length}", "ccc"]
-    EventMachine.run {
-      EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
+    EM.run {
+      EM.start_server( "127.0.0.1", @port, SimpleTest ) do |conn|
         the_connection = conn
       end
-      EventMachine.add_timer(4) { assert(false, 'test timeout'); EM.stop }
-
-      client = Module.new do
-        define_method(:headers) { headers }
-        define_method(:content) { content }
-
-        def unbind
-          EM.add_timer(0.1) { EM.stop }
-        end
+      setup_timeout
 
-        def post_init
-          5.times do
-            headers.each { |h| send_data "#{h}\r\n" }
-            send_data "\n"
-            send_data content
-          end
-          close_connection_after_writing
+      EM.connect( "127.0.0.1", @port, StopOnUnbind ) do |c|
+        5.times do
+          headers.each { |h| c.send_data "#{h}\r\n" }
+          c.send_data "\n"
+          c.send_data content
         end
+        c.close_connection_after_writing
       end
-
-      EventMachine.connect( TestHost, TestPort, client )
     }
     assert_equal( ["aaa"] * 5, the_connection.first_header )
     assert_equal( [headers] * 5, the_connection.my_headers )
@@ -151,20 +99,20 @@ class TestHeaderAndContentProtocol < Test::Unit::TestCase
   #   the_connection = nil
   #   content = "A" * 50
   #   headers = ["aaa", "bbb", ["Content-length: #{content.length}"]*2, "ccc"].flatten
-  #   EventMachine.run {
-  #     EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
+  #   EM.run {
+  #     EM.start_server( "127.0.0.1", @port, SimpleTest ) do |conn|
   #       the_connection = conn
   #     end
-  #     EventMachine.add_timer(4) {raise "test timed out"}
+  #     EM.add_timer(4) {raise "test timed out"}
   #     test_proc = proc {
-  #       t = TCPSocket.new TestHost, TestPort
+  #       t = TCPSocket.new "127.0.0.1", @port
   #       headers.each {|h| t.write "#{h}\r\n" }
   #       t.write "\n"
   #       t.write content
   #       t.close
   #     }
-  #     EventMachine.defer test_proc, proc {
-  #       EventMachine.stop
+  #     EM.defer test_proc, proc {
+  #       EM.stop
   #     }
   #   }
   # end
@@ -180,29 +128,18 @@ class TestHeaderAndContentProtocol < Test::Unit::TestCase
       "x-tempest-header:ddd"
     ]
 
-    EventMachine.run {
-      EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
+    EM.run {
+      EM.start_server( "127.0.0.1", @port, SimpleTest ) do |conn|
         the_connection = conn
       end
-      EventMachine.add_timer(4) {raise "test timed out"}
-
-      client = Module.new do
-        define_method(:headers) { headers }
-        define_method(:content) { content }
-
-        def unbind
-          EM.add_timer(0.1) { EM.stop }
-        end
+      setup_timeout
 
-        def post_init
-          headers.each { |h| send_data "#{h}\r\n" }
-          send_data "\n"
-          send_data content
-          close_connection_after_writing
-        end
+      EM.connect( "127.0.0.1", @port, StopOnUnbind ) do |c|
+        headers.each { |h| c.send_data "#{h}\r\n" }
+        c.send_data "\n"
+        c.send_data content
+        c.close_connection_after_writing
       end
-
-      EventMachine.connect( TestHost, TestPort, client )
     }
 
     hsh = the_connection.headers_2_hash( the_connection.my_headers.shift )

data/tests/test_httpclient.rb

@@ -1,32 +1,4 @@
-# $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 TestHttpClient < Test::Unit::TestCase
 
@@ -43,13 +15,13 @@ class TestHttpClient < Test::Unit::TestCase
 
   def test_http_client
     ok = false
-    EventMachine.run {
-      c = EventMachine::Protocols::HttpClient.send :request, :host => "www.bayshorenetworks.com", :port => 80
+    EM.run {
+      c = silent { EM::P::HttpClient.send :request, :host => "www.google.com", :port => 80 }
       c.callback {
         ok = true
-        EventMachine.stop
+        EM.stop
       }
-      c.errback {EventMachine.stop} # necessary, otherwise a failure blocks the test suite forever.
+      c.errback {EM.stop} # necessary, otherwise a failure blocks the test suite forever.
     }
     assert ok
   end
@@ -58,10 +30,10 @@ class TestHttpClient < Test::Unit::TestCase
 
   def test_http_client_1
     ok = false
-    EventMachine.run {
-      c = EventMachine::Protocols::HttpClient.send :request, :host => "www.bayshorenetworks.com", :port => 80
-      c.callback {ok = true; EventMachine.stop}
-      c.errback {EventMachine.stop}
+    EM.run {
+      c = silent { EM::P::HttpClient.send :request, :host => "www.google.com", :port => 80 }
+      c.callback {ok = true; EM.stop}
+      c.errback {EM.stop}
     }
     assert ok
   end
@@ -70,13 +42,13 @@ class TestHttpClient < Test::Unit::TestCase
 
   def test_http_client_2
     ok = false
-    EventMachine.run {
-      c = EventMachine::Protocols::HttpClient.send :request, :host => "www.bayshorenetworks.com", :port => 80
+    EM.run {
+      c = silent { EM::P::HttpClient.send :request, :host => "www.google.com", :port => 80 }
       c.callback {|result|
         ok = true;
-        EventMachine.stop
+        EM.stop
       }
-      c.errback {EventMachine.stop}
+      c.errback {EM.stop}
     }
     assert ok
   end
@@ -89,7 +61,7 @@ class TestHttpClient < Test::Unit::TestCase
   # causing this test to hang. Observe, there was no problem with responses
   # lacking a content-length, just when the content-length was zero.
   #
-  class EmptyContent < EventMachine::Connection
+  class EmptyContent < EM::Connection
       def initialize *args
         super
       end
@@ -101,12 +73,12 @@ class TestHttpClient < Test::Unit::TestCase
 
   def test_http_empty_content
       ok = false
-      EventMachine.run {
-        EventMachine.start_server "127.0.0.1", 9701, EmptyContent
-        c = EventMachine::Protocols::HttpClient.send :request, :host => "127.0.0.1", :port => 9701
+      EM.run {
+        EM.start_server "127.0.0.1", 9701, EmptyContent
+        c = silent { EM::P::HttpClient.send :request, :host => "127.0.0.1", :port => 9701 }
         c.callback {|result|
           ok = true
-          EventMachine.stop
+          EM.stop
         }
       }
       assert ok
@@ -115,7 +87,7 @@ class TestHttpClient < Test::Unit::TestCase
 
   #---------------------------------------
 
-  class PostContent < EventMachine::Protocols::LineAndTextProtocol
+  class PostContent < EM::P::LineAndTextProtocol
       def initialize *args
         super
         @lines = []
@@ -154,25 +126,25 @@ class TestHttpClient < Test::Unit::TestCase
         close_connection_after_writing
       end
   end
-
+  
   # TODO, this is WRONG. The handler is asserting an HTTP 1.1 request, but the client
   # is sending a 1.0 request. Gotta fix the client
   def test_post
       response = nil
-      EventMachine.run {
-        EventMachine.start_server Localhost, Localport, PostContent
-        EventMachine.add_timer(2) {raise "timed out"}
-        c = EventMachine::Protocols::HttpClient.request(
+      EM.run {
+        EM.start_server Localhost, Localport, PostContent
+        setup_timeout(2)
+        c = silent { EM::P::HttpClient.request(
           :host=>Localhost,
           :port=>Localport,
           :method=>:post,
           :request=>"/aaa",
           :content=>"XYZ",
           :content_type=>"text/plain"
-        )
+        )}
         c.callback {|r|
           response = r
-          EventMachine.stop
+          EM.stop
         }
       }
 
@@ -186,12 +158,12 @@ class TestHttpClient < Test::Unit::TestCase
   def test_cookie
     ok = false
     EM.run {
-      c = EM::Protocols::HttpClient.send :request, :host => "www.bayshorenetworks.com", :port => 80, :cookie=>"aaa=bbb"
+      c = silent { EM::Protocols::HttpClient.send :request, :host => "www.google.com", :port => 80, :cookie=>"aaa=bbb" }
       c.callback {|result|
         ok = true;
-        EventMachine.stop
+        EM.stop
       }
-      c.errback {EventMachine.stop}
+      c.errback {EM.stop}
     }
     assert ok
   end
@@ -201,16 +173,16 @@ class TestHttpClient < Test::Unit::TestCase
   def test_version_1_0
     ok = false
     EM.run {
-      c = EM::P::HttpClient.request(
-        :host => "www.bayshorenetworks.com",
+      c = silent { EM::P::HttpClient.request(
+        :host => "www.google.com",
         :port => 80,
         :version => "1.0"
-      )
+      )}
       c.callback {|result|
         ok = true;
-        EventMachine.stop
+        EM.stop
       }
-      c.errback {EventMachine.stop}
+      c.errback {EM.stop}
     }
     assert ok
   end

data/tests/test_httpclient2.rb

@@ -1,32 +1,4 @@
-# $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 TestHttpClient2 < Test::Unit::TestCase
   Localhost = "127.0.0.1"
@@ -50,8 +22,10 @@ class TestHttpClient2 < Test::Unit::TestCase
   def test_connect
     EM.run {
       EM.start_server Localhost, Localport, TestServer
-      http1 = EM::P::HttpClient2.connect Localhost, Localport
-      http2 = EM::P::HttpClient2.connect( :host=>Localhost, :port=>Localport )
+      silent do
+        EM::P::HttpClient2.connect Localhost, Localport
+        EM::P::HttpClient2.connect( :host=>Localhost, :port=>Localport )
+      end
       EM.stop
     }
   end
@@ -61,7 +35,7 @@ class TestHttpClient2 < Test::Unit::TestCase
     EM.run {
       EM.start_server Localhost, Localport, TestServer
       assert_raises( ArgumentError ) {
-        EM::P::HttpClient2.connect Localhost, "xxx"
+        silent { EM::P::HttpClient2.connect Localhost, "xxx" }
       }
       EM.stop
     }
@@ -70,7 +44,7 @@ class TestHttpClient2 < Test::Unit::TestCase
   def test_bad_server
     err = nil
     EM.run {
-      http = EM::P::HttpClient2.connect Localhost, 9999
+      http = silent { EM::P::HttpClient2.connect Localhost, 9999 }
       d = http.get "/"
       d.errback { err = true; d.internal_error; EM.stop }
     }
@@ -80,7 +54,7 @@ class TestHttpClient2 < Test::Unit::TestCase
   def test_get
     content = nil
     EM.run {
-      http = EM::P::HttpClient2.connect "google.com", 80
+      http = silent { EM::P::HttpClient2.connect "google.com", 80 }
       d = http.get "/"
       d.callback {
         content = d.content
@@ -96,7 +70,7 @@ class TestHttpClient2 < Test::Unit::TestCase
   def _test_get_multiple
     content = nil
     EM.run {
-      http = EM::P::HttpClient2.connect "google.com", 80
+      http = silent { EM::P::HttpClient2.connect "google.com", 80 }
       d = http.get "/"
       d.callback {
         e = http.get "/"
@@ -112,7 +86,7 @@ class TestHttpClient2 < Test::Unit::TestCase
   def test_get_pipeline
     headers, headers2 = nil, nil
     EM.run {
-      http = EM::P::HttpClient2.connect "google.com", 80
+      http = silent { EM::P::HttpClient2.connect "google.com", 80 }
       d = http.get("/")
       d.callback {
         headers = d.headers
@@ -121,7 +95,8 @@ class TestHttpClient2 < Test::Unit::TestCase
       e.callback {
         headers2 = e.headers
       }
-      EM::Timer.new(1) {EM.stop}
+      EM.tick_loop { EM.stop if headers && headers2 }
+      EM.add_timer(1) { EM.stop }
     }
     assert(headers)
     assert(headers2)
@@ -131,7 +106,7 @@ class TestHttpClient2 < Test::Unit::TestCase
   def test_authheader
     EM.run {
       EM.start_server Localhost, Localport, TestServer
-      http = EM::P::HttpClient2.connect Localhost, 18842
+      http = silent { EM::P::HttpClient2.connect Localhost, 18842 }
       d = http.get :url=>"/", :authorization=>"Basic xxx"
       d.callback {EM.stop}
       d.errback {EM.stop}
@@ -141,7 +116,7 @@ class TestHttpClient2 < Test::Unit::TestCase
   def test_https_get
     d = nil
     EM.run {
-      http = EM::P::HttpClient2.connect :host => 'www.amazon.com', :port => 443, :ssl => true
+      http = silent { EM::P::HttpClient2.connect :host => 'www.apple.com', :port => 443, :ssl => true }
       d = http.get "/"
       d.callback {
         EM.stop

data/tests/test_inactivity_timeout.rb

@@ -1,50 +1,54 @@
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
+require 'em_test_helper'
 
 class TestInactivityTimeout < Test::Unit::TestCase
 
-  def test_default
-    $timeout = nil
-    EM.run {
-      c = EM.connect("127.0.0.1", 54321)
-      $timeout = c.comm_inactivity_timeout
-      EM.stop
-    }
-
-    assert_equal(0.0, $timeout)
-  end
-
-  def test_set_and_get
-    $timeout = nil
-    EM.run {
-      c = EM.connect("127.0.0.1", 54321)
-      c.comm_inactivity_timeout = 2.5
-      $timeout = c.comm_inactivity_timeout
-      EM.stop
-    }
-
-    assert_equal(2.5, $timeout)
-  end
-
-  module TimeoutHandler
-    def unbind
-      EM.stop
+  if EM.respond_to? :get_comm_inactivity_timeout
+    def test_default
+      EM.run {
+        c = EM.connect("127.0.0.1", 54321)
+        assert_equal 0.0, c.comm_inactivity_timeout
+        EM.stop
+      }
     end
-  end
 
-  def test_for_real
-    EM.run {
-      EM.heartbeat_interval = 0.1
-      EM.start_server("127.0.0.1", 12345)
-      EM.add_timer(0.2) {
-        $start = Time.now
-        c = EM.connect("127.0.0.1", 12345, TimeoutHandler)
+    def test_set_and_get
+      EM.run {
+        c = EM.connect("127.0.0.1", 54321)
         c.comm_inactivity_timeout = 2.5
+        assert_equal 2.5, c.comm_inactivity_timeout
+        EM.stop
       }
-    }
+    end
 
-    assert_in_delta(2.5, (Time.now - $start), 0.3)
-  end
+    def test_for_real
+      start, finish = nil
+
+      timeout_handler = Module.new do
+        define_method :unbind do
+          finish = Time.now
+          EM.stop
+        end
+      end
+
+      EM.run {
+        setup_timeout
+        EM.heartbeat_interval = 0.01
+        EM.start_server("127.0.0.1", 12345)
+        EM.add_timer(0.01) {
+          start = Time.now
+          c = EM.connect("127.0.0.1", 12345, timeout_handler)
+          c.comm_inactivity_timeout = 0.02
+        }
+      }
 
+      assert_in_delta(0.02, (finish - start), 0.02)
+    end
+  else
+    warn "EM.comm_inactivity_timeout not implemented, skipping tests in #{__FILE__}"
+
+    # Because some rubies will complain if a TestCase class has no tests
+    def test_em_comm_inactivity_timeout_not_implemented
+      assert true
+    end
+  end
 end