eventmachine-eventmachine 0.12.7 → 0.12.8

data/tests/test_file_watch.rb

@@ -0,0 +1,49 @@
+$:.unshift "../lib"
+require 'eventmachine'
+require 'test/unit'
+
+class TestFileWatch < Test::Unit::TestCase
+  module FileWatcher
+    def file_modified
+      $modified = true
+    end
+    def file_deleted
+      $deleted = 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{
+      require 'tempfile'
+      file = Tempfile.new('em-watch')
+      $tmp_path = file.path
+
+      # watch it
+      watch = EM.watch_file(file.path, FileWatcher)
+      $path = watch.path
+
+      # modify it
+      File.open(file.path, 'w'){ |f| f.puts 'hi' }
+
+      # delete it
+      EM.add_timer(0.25){ file.close; file.delete }
+    }
+
+    assert_equal($path, $tmp_path)
+    assert($modified)
+    assert($deleted)
+    assert($unbind)
+  end
+end

data/tests/test_futures.rb

@@ -28,8 +28,6 @@ $:.unshift "../lib"
 require 'eventmachine'
 require 'test/unit'
 
-
-
 class TestFutures < Test::Unit::TestCase
 
   def setup
@@ -45,21 +43,19 @@ class TestFutures < Test::Unit::TestCase
       assert_equal(101, EventMachine::Deferrable.future(p1) )
   end
 
-
-
   class MyFuture
       include EventMachine::Deferrable
       def initialize *args
-	  super
-	  set_deferred_status :succeeded, 40
+        super
+        set_deferred_status :succeeded, 40
       end
   end
 
   class MyErrorFuture
       include EventMachine::Deferrable
       def initialize *args
-	  super
-	  set_deferred_status :failed, 41
+        super
+        set_deferred_status :failed, 41
       end
   end
 
@@ -67,7 +63,7 @@ class TestFutures < Test::Unit::TestCase
   def test_future_1
       # Call future with one additional argument and it will be treated as a callback.
       def my_future
-	  MyFuture.new
+        MyFuture.new
       end
 
       value = nil
@@ -90,7 +86,7 @@ class TestFutures < Test::Unit::TestCase
       # treated as a callback.
       value = nil
       EventMachine::Deferrable.future MyFuture.new do |v|
-	  value=v
+        value=v
       end
       assert_equal( 40, value )
   end
@@ -107,108 +103,96 @@ class TestFutures < Test::Unit::TestCase
       n = 0 # counter assures that all the tests actually run.
       rc = RecursiveCallback.new
       rc.callback {|a|
-	  assert_equal(100, a)
-	  n += 1
-	  rc.set_deferred_status :succeeded, 101, 101
+        assert_equal(100, a)
+        n += 1
+        rc.set_deferred_status :succeeded, 101, 101
       }
       rc.callback {|a,b|
-	  assert_equal(101, a)
-	  assert_equal(101, b)
-	  n += 1
-	  rc.set_deferred_status :succeeded, 102, 102, 102
+        assert_equal(101, a)
+        assert_equal(101, b)
+        n += 1
+        rc.set_deferred_status :succeeded, 102, 102, 102
       }
       rc.callback {|a,b,c|
-	  assert_equal(102, a)
-	  assert_equal(102, b)
-	  assert_equal(102, c)
-	  n += 1
+        assert_equal(102, a)
+        assert_equal(102, b)
+        assert_equal(102, c)
+        n += 1
       }
       rc.set_deferred_status :succeeded, 100
       assert_equal(3, n)
   end
 
+  def test_syntactic_sugar
+    rc = RecursiveCallback.new
+    rc.set_deferred_success 100
+    rc.set_deferred_failure 200
+  end
 
+  # It doesn't raise an error to set deferred status more than once.
+  # In fact, this is a desired and useful idiom when it happens INSIDE
+  # a callback or errback.
+  # However, it's less useful otherwise, and in fact would generally be
+  # indicative of a programming error. However, we would like to be resistant
+  # to such errors. So whenever we set deferred status, we also clear BOTH
+  # stacks of handlers.
+  #
+  def test_double_calls
+    s = 0
+    e = 0
 
-	def test_syntactic_sugar
-		rc = RecursiveCallback.new
-		rc.set_deferred_success 100
-		rc.set_deferred_failure 200
-	end
-
-
-
-	# It doesn't raise an error to set deferred status more than once.
-	# In fact, this is a desired and useful idiom when it happens INSIDE
-	# a callback or errback.
-	# However, it's less useful otherwise, and in fact would generally be
-	# indicative of a programming error. However, we would like to be resistant
-	# to such errors. So whenever we set deferred status, we also clear BOTH
-	# stacks of handlers.
-	#
-	def test_double_calls
-		s = 0
-		e = 0
-
-		d = EM::DefaultDeferrable.new
-		d.callback {s += 1}
-		d.errback {e += 1}
-
-		d.succeed	# We expect the callback to be called, and the errback to be DISCARDED.
-		d.fail	# Presumably an error. We expect the errback NOT to be called.
-		d.succeed	# We expect the callback to have been discarded and NOT to be called again.
-
-		assert_equal(1, s)
-		assert_equal(0, e)
-	end
-
-
-	# Adding a callback to a Deferrable that is already in a success state executes the callback
-	# immediately. The same applies to a an errback added to an already-failed Deferrable.
-	# HOWEVER, we expect NOT to be able to add errbacks to succeeded Deferrables, or callbacks
-	# to failed ones.
-	#
-	# We illustrate this with a rather contrived test. The test calls #fail after #succeed,
-	# which ordinarily would not happen in a real program.
-	#
-	# What we're NOT attempting to specify is what happens if a Deferrable is succeeded and then
-	# failed (or vice-versa). Should we then be able to add callbacks/errbacks of the appropriate
-	# type for immediate execution? For now at least, the official answer is "don't do that."
-	#
-	def test_delayed_callbacks
-		s1 = 0
-		s2 = 0
-		e = 0
+    d = EM::DefaultDeferrable.new
+    d.callback {s += 1}
+    d.errback {e += 1}
 
-		d = EM::DefaultDeferrable.new
-		d.callback {s1 += 1}
+    d.succeed	# We expect the callback to be called, and the errback to be DISCARDED.
+    d.fail	  # Presumably an error. We expect the errback NOT to be called.
+    d.succeed	# We expect the callback to have been discarded and NOT to be called again.
 
-		d.succeed	# Triggers and discards the callback.
+    assert_equal(1, s)
+    assert_equal(0, e)
+  end
 
-		d.callback {s2 += 1}	# This callback is executed immediately and discarded.
+  # Adding a callback to a Deferrable that is already in a success state executes the callback
+  # immediately. The same applies to a an errback added to an already-failed Deferrable.
+  # HOWEVER, we expect NOT to be able to add errbacks to succeeded Deferrables, or callbacks
+  # to failed ones.
+  #
+  # We illustrate this with a rather contrived test. The test calls #fail after #succeed,
+  # which ordinarily would not happen in a real program.
+  #
+  # What we're NOT attempting to specify is what happens if a Deferrable is succeeded and then
+  # failed (or vice-versa). Should we then be able to add callbacks/errbacks of the appropriate
+  # type for immediate execution? For now at least, the official answer is "don't do that."
+  #
+  def test_delayed_callbacks
+    s1 = 0
+    s2 = 0
+    e = 0
 
-		d.errback {e += 1}	# This errback should be DISCARDED and never execute.
-		d.fail		# To prove it, let's 
+    d = EM::DefaultDeferrable.new
+    d.callback {s1 += 1}
 
-		assert_equal( [1,1], [s1,s2] )
-		assert_equal( 0, e )
-	end
+    d.succeed # Triggers and discards the callback.
 
+    d.callback {s2 += 1} # This callback is executed immediately and discarded.
 
+    d.errback {e += 1} # This errback should be DISCARDED and never execute.
+    d.fail # To prove it, fail and assert e is 0
 
+    assert_equal( [1,1], [s1,s2] )
+    assert_equal( 0, e )
+  end
 
-	#
-	#
-	#
-	def test_timeout
-		n = 0
-		EM.run {
-			d = EM::DefaultDeferrable.new
-			d.callback {n = 1; EM.stop}
-			d.errback {n = 2; EM.stop}
-			d.timeout(1)
-		}
-		assert_equal( 2, n )
-	end
+  def test_timeout
+    n = 0
+    EM.run {
+      d = EM::DefaultDeferrable.new
+      d.callback {n = 1; EM.stop}
+      d.errback {n = 2; EM.stop}
+      d.timeout(1)
+    }
+    assert_equal( 2, n )
+  end
 
 end
-

data/tests/test_hc.rb

@@ -176,7 +176,7 @@ class TestHeaderAndContentProtocol < Test::Unit::TestCase
       "GET / HTTP/1.0",
       "Accept: aaa",
       "User-Agent: bbb",
-      "Host:	    ccc",
+      "Host: ccc",
       "x-tempest-header:ddd"
     ]
 
@@ -215,4 +215,4 @@ class TestHeaderAndContentProtocol < Test::Unit::TestCase
     assert_equal(expect, hsh)
   end
 
-end
+end

data/tests/test_httpclient.rb

@@ -91,23 +91,23 @@ class TestHttpClient < Test::Unit::TestCase
   #
   class EmptyContent < EventMachine::Connection
       def initialize *args
-	  super
+        super
       end
       def receive_data data
-	  send_data "HTTP/1.0 404 ...\r\nContent-length: 0\r\n\r\n"
-	  close_connection_after_writing
+        send_data "HTTP/1.0 404 ...\r\nContent-length: 0\r\n\r\n"
+        close_connection_after_writing
       end
   end
 
   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
-	  c.callback {|result|
-	      ok = true
-	      EventMachine.stop
-	  }
+        EventMachine.start_server "127.0.0.1", 9701, EmptyContent
+        c = EventMachine::Protocols::HttpClient.send :request, :host => "127.0.0.1", :port => 9701
+        c.callback {|result|
+          ok = true
+          EventMachine.stop
+        }
       }
       assert ok
   end
@@ -117,40 +117,41 @@ class TestHttpClient < Test::Unit::TestCase
 
   class PostContent < EventMachine::Protocols::LineAndTextProtocol
       def initialize *args
-	  super
-	  @lines = []
+        super
+        @lines = []
       end
       def receive_line line
-	  if line.length > 0
-	      @lines << line
-	  else
-	      process_headers
-	  end
+        if line.length > 0
+          @lines << line
+        else
+          process_headers
+        end
       end
       def receive_binary_data data
-	  @post_content = data
-	  send_response
+        @post_content = data
+        send_response
       end
       def process_headers
-	  if @lines.first =~ /\APOST ([^\s]+) HTTP\/1.1\Z/
-	      @uri = $1.dup
-	  else
-	      raise "bad request"
-	  end
-	  @lines.each {|line|
-	      if line =~ /\AContent-length:\s*(\d+)\Z/i
-		  @content_length = $1.dup.to_i
-	      elsif line =~ /\AContent-type:\s*(\d+)\Z/i
-		  @content_type = $1.dup
-	      end
-	  }
-
-	  raise "invalid content length" unless @content_length
-	  set_binary_mode @content_length
+        if @lines.first =~ /\APOST ([^\s]+) HTTP\/1.1\Z/
+          @uri = $1.dup
+        else
+          raise "bad request"
+        end
+
+        @lines.each {|line|
+          if line =~ /\AContent-length:\s*(\d+)\Z/i
+            @content_length = $1.dup.to_i
+          elsif line =~ /\AContent-type:\s*(\d+)\Z/i
+            @content_type = $1.dup
+          end
+        }
+
+        raise "invalid content length" unless @content_length
+        set_binary_mode @content_length
       end
       def send_response
-	  send_data "HTTP/1.1 200 ...\r\nConnection: close\r\nContent-length: 10\r\nContent-type: text/html\r\n\r\n0123456789"
-	  close_connection_after_writing
+        send_data "HTTP/1.1 200 ...\r\nConnection: close\r\nContent-length: 10\r\nContent-type: text/html\r\n\r\n0123456789"
+        close_connection_after_writing
       end
   end
 
@@ -159,15 +160,20 @@ class TestHttpClient < Test::Unit::TestCase
   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 :host=>Localhost,
-	      :port=>Localport, :method=>:post, :request=>"/aaa", :content=>"XYZ",
-	      :content_type=>"text/plain"
-          c.callback {|r|
-	      response = r
-	      EventMachine.stop
-	  }
+        EventMachine.start_server Localhost, Localport, PostContent
+        EventMachine.add_timer(2) {raise "timed out"}
+        c = EventMachine::Protocols::HttpClient.request(
+          :host=>Localhost,
+          :port=>Localport,
+          :method=>:post,
+          :request=>"/aaa",
+          :content=>"XYZ",
+          :content_type=>"text/plain"
+        )
+        c.callback {|r|
+          response = r
+          EventMachine.stop
+        }
       }
 
       assert_equal( 200, response[:status] )
@@ -190,16 +196,16 @@ class TestHttpClient < Test::Unit::TestCase
     assert ok
   end
 
-
-
   # We can tell the client to send an HTTP/1.0 request (default is 1.1).
   # This is useful for suppressing chunked responses until those are working.
   def test_version_1_0
     ok = false
     EM.run {
-      c = EM::P::HttpClient.request :host => "www.bayshorenetworks.com",
-      	:port => 80,
-	:version => "1.0"
+      c = EM::P::HttpClient.request(
+        :host => "www.bayshorenetworks.com",
+        :port => 80,
+        :version => "1.0"
+      )
       c.callback {|result|
         ok = true;
         EventMachine.stop
@@ -209,7 +215,4 @@ class TestHttpClient < Test::Unit::TestCase
     assert ok
   end
 
-
 end
-
-

data/tests/test_httpclient2.rb

@@ -29,127 +29,125 @@ require 'eventmachine'
 require 'test/unit'
 
 class TestHttpClient2 < Test::Unit::TestCase
-	Localhost = "127.0.0.1"
-	Localport = 9801
-
-	def setup
-	end
-
-	def teardown
-	end
-
-
-	class TestServer < EM::Connection
-	end
-
-	# #connect returns an object which has made a connection to an HTTP server
-	# and exposes methods for making HTTP requests on that connection.
-	# #connect can take either a pair of parameters (a host and a port),
-	# or a single parameter which is a Hash.
-	#
-	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 )
-			EM.stop
-		}
-	end
-
-
-	def test_bad_port
-		EM.run {
-			EM.start_server Localhost, Localport, TestServer
-			assert_raises( ArgumentError ) {
-				EM::P::HttpClient2.connect Localhost, "xxx"
-			}
-			EM.stop
-		}
-	end
-
-	def test_bad_server
-	  err = nil
-		EM.run {
-			http = EM::P::HttpClient2.connect Localhost, 9999
-			d = http.get "/"
-			d.errback { err = true; d.internal_error; EM.stop }
-		}
-		assert(err)
-	end
-
-	def test_get
-	  content = nil
-		EM.run {
-			http = EM::P::HttpClient2.connect "www.bayshorenetworks.com", 80
-			d = http.get "/"
-			d.callback {
-				content = d.content
-				EM.stop
-			}
-		}
-		assert(content)
-	end
-
-	# Not a pipelined request because we wait for one response before we request the next.
-	def test_get_multiple
-	  content = nil
-		EM.run {
-			http = EM::P::HttpClient2.connect "www.bayshorenetworks.com", 80
-			d = http.get "/"
-			d.callback {
-				e = http.get "/"
-				e.callback {
-					content = e.content
-					EM.stop
-				}
-			}
-		}
-		assert(content)
-	end
-
-	def test_get_pipeline
-	  headers, headers2 = nil, nil
-		EM.run {
-			http = EM::P::HttpClient2.connect "www.microsoft.com", 80
-			d = http.get("/")
-			d.callback {
-				headers = d.headers
-			}
-			e = http.get("/")
-			e.callback {
-				headers2 = e.headers
-			}
-			EM::Timer.new(1) {EM.stop}
-		}
-		assert(headers)
-		assert(headers2)
-	end
-
-
-	def test_authheader
-		EM.run {
-			EM.start_server Localhost, Localport, TestServer
-			http = EM::P::HttpClient2.connect Localhost, 18842
-			d = http.get :url=>"/", :authorization=>"Basic xxx"
-			d.callback {EM.stop}
-			d.errback {EM.stop}
-		}
-	end
-	
-  def test_https_get
-    d = nil
+  Localhost = "127.0.0.1"
+  Localport = 9801
+
+  def setup
+  end
+
+  def teardown
+  end
+
+
+  class TestServer < EM::Connection
+  end
+
+  # #connect returns an object which has made a connection to an HTTP server
+  # and exposes methods for making HTTP requests on that connection.
+  # #connect can take either a pair of parameters (a host and a port),
+  # or a single parameter which is a Hash.
+  #
+  def test_connect
     EM.run {
-      http = EM::P::HttpClient2.connect :host => 'www.amazon.com', :port => 443, :ssl => true
+      EM.start_server Localhost, Localport, TestServer
+      http1 = EM::P::HttpClient2.connect Localhost, Localport
+      http2 = EM::P::HttpClient2.connect( :host=>Localhost, :port=>Localport )
+      EM.stop
+    }
+  end
+
+
+  def test_bad_port
+    EM.run {
+      EM.start_server Localhost, Localport, TestServer
+      assert_raises( ArgumentError ) {
+        EM::P::HttpClient2.connect Localhost, "xxx"
+      }
+      EM.stop
+    }
+  end
+
+  def test_bad_server
+    err = nil
+    EM.run {
+      http = EM::P::HttpClient2.connect Localhost, 9999
+      d = http.get "/"
+      d.errback { err = true; d.internal_error; EM.stop }
+    }
+    assert(err)
+  end
+
+  def test_get
+    content = nil
+    EM.run {
+      http = EM::P::HttpClient2.connect "www.bayshorenetworks.com", 80
       d = http.get "/"
       d.callback {
+        content = d.content
         EM.stop
       }
     }
-    assert_equal(200, d.status)
+    assert(content)
   end
 
+  # Not a pipelined request because we wait for one response before we request the next.
+  # XXX this test is broken because it sends the second request to the first connection
+  # XXX right before the connection closes
+  def _test_get_multiple
+    content = nil
+    EM.run {
+      http = EM::P::HttpClient2.connect "www.bayshorenetworks.com", 80
+      d = http.get "/"
+      d.callback {
+        e = http.get "/"
+        e.callback {
+          content = e.content
+          EM.stop
+        }
+      }
+    }
+    assert(content)
+  end
 
+  def test_get_pipeline
+    headers, headers2 = nil, nil
+    EM.run {
+      http = EM::P::HttpClient2.connect "www.microsoft.com", 80
+      d = http.get("/")
+      d.callback {
+        headers = d.headers
+      }
+      e = http.get("/")
+      e.callback {
+        headers2 = e.headers
+      }
+      EM::Timer.new(1) {EM.stop}
+    }
+    assert(headers)
+    assert(headers2)
+  end
 
-end
 
+  def test_authheader
+    EM.run {
+      EM.start_server Localhost, Localport, TestServer
+      http = EM::P::HttpClient2.connect Localhost, 18842
+      d = http.get :url=>"/", :authorization=>"Basic xxx"
+      d.callback {EM.stop}
+      d.errback {EM.stop}
+    }
+  end
 
+  def test_https_get
+    d = nil
+    EM.run {
+      http = EM::P::HttpClient2.connect :host => 'www.amazon.com', :port => 443, :ssl => true
+      d = http.get "/"
+      d.callback {
+        EM.stop
+      }
+    }
+    assert_equal(200, d.status)
+  end if EM.ssl?
+
+end