eventmachine 0.12.6 → 0.12.8

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

data/tests/test_inactivity_timeout.rb

@@ -0,0 +1,30 @@
+$:.unshift "../lib"
+require 'eventmachine'
+require 'test/unit'
+
+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_with_set
+    $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
+
+end

data/tests/test_kb.rb

@@ -37,10 +37,10 @@ class TestKeyboardEvents < Test::Unit::TestCase
   end
 
   module KbHandler
-	  include EM::Protocols::LineText2
-	  def receive_line d
-		  EM::stop if d == "STOP"
-	  end
+    include EM::Protocols::LineText2
+    def receive_line d
+      EM::stop if d == "STOP"
+    end
   end
 
   # This test doesn't actually do anything useful but is here to
@@ -51,11 +51,10 @@ class TestKeyboardEvents < Test::Unit::TestCase
   # When someone figures that out, then we can make this a real test.
   #
   def test_kb
-	  EM.run {
-		  EM.open_keyboard KbHandler
-		  EM::Timer.new(1) { EM.stop }
-	  } if $stdout.tty? # don't run the test unless it stands a chance of validity.
+    EM.run {
+      EM.open_keyboard KbHandler
+      EM::Timer.new(1) { EM.stop }
+    } if $stdout.tty? # don't run the test unless it stands a chance of validity.
   end
 
 end
-

data/tests/test_ltp2.rb

@@ -33,288 +33,285 @@ require 'test/unit'
 
 class TestLineText2 < Test::Unit::TestCase
 
-	# Run each of these tests two ways: passing in the whole test-dataset in one chunk,
-	# and passing it in one character at a time.
-
-	class Basic
-		include EM::Protocols::LineText2
-		attr_reader :lines
-		def receive_line line
-			(@lines ||= []) << line
-		end
-	end
-	def test_basic
-		testdata = "Line 1\nLine 2\r\nLine 3\n"
-
-		a = Basic.new
-		a.receive_data testdata
-		assert_equal( ["Line 1", "Line 2", "Line 3"], a.lines )
-
-		a = Basic.new
-		testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
-		assert_equal( ["Line 1", "Line 2", "Line 3"], a.lines )
-	end
-
-
-	class ChangeDelimiter
-		include EM::Protocols::LineText2
-		attr_reader :lines
-		def initialize *args
-			super
-			@delim = "A"
-			set_delimiter @delim
-		end
-		def receive_line line
-			(@lines ||= []) << line
-			set_delimiter( @delim.succ! )
-		end
-	end
-
-	def test_change_delimiter
-		testdata = %Q(LineaALinebBLinecCLinedD)
-
-		a = ChangeDelimiter.new
-		a.receive_data testdata
-		assert_equal( ["Linea", "Lineb", "Linec", "Lined"], a.lines )
-
-		a = ChangeDelimiter.new
-		testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
-		assert_equal( ["Linea", "Lineb", "Linec", "Lined"], a.lines )
-	end
-
-
-	#--
-	# Test two lines followed by an empty line, ten bytes of binary data, then
-	# two more lines.
-
-	class Binary
-		include EM::Protocols::LineText2
-		attr_reader :lines, :body
-		def initialize *args
-			super
-			@lines = []
-			@body = nil
-		end
-		def receive_line ln
-			if ln == ""
-				set_text_mode 10
-			else
-				@lines << ln
-			end
-		end
-		def receive_binary_data data
-			@body = data
-		end
-	end
-
-	def test_binary
-		testdata = %Q(Line 1
+  # Run each of these tests two ways: passing in the whole test-dataset in one chunk,
+  # and passing it in one character at a time.
+
+  class Basic
+    include EM::Protocols::LineText2
+    attr_reader :lines
+    def receive_line line
+      (@lines ||= []) << line
+    end
+  end
+  def test_basic
+    testdata = "Line 1\nLine 2\r\nLine 3\n"
+
+    a = Basic.new
+    a.receive_data testdata
+    assert_equal( ["Line 1", "Line 2", "Line 3"], a.lines )
+
+    a = Basic.new
+    testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
+    assert_equal( ["Line 1", "Line 2", "Line 3"], a.lines )
+  end
+
+  class ChangeDelimiter
+    include EM::Protocols::LineText2
+    attr_reader :lines
+    def initialize *args
+      super
+      @delim = "A"
+      set_delimiter @delim
+    end
+    def receive_line line
+      (@lines ||= []) << line
+      set_delimiter( @delim.succ! )
+    end
+  end
+
+  def test_change_delimiter
+    testdata = %Q(LineaALinebBLinecCLinedD)
+
+    a = ChangeDelimiter.new
+    a.receive_data testdata
+    assert_equal( ["Linea", "Lineb", "Linec", "Lined"], a.lines )
+
+    a = ChangeDelimiter.new
+    testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
+    assert_equal( ["Linea", "Lineb", "Linec", "Lined"], a.lines )
+  end
+
+
+  #--
+  # Test two lines followed by an empty line, ten bytes of binary data, then
+  # two more lines.
+
+  class Binary
+    include EM::Protocols::LineText2
+    attr_reader :lines, :body
+    def initialize *args
+      super
+      @lines = []
+      @body = nil
+    end
+    def receive_line ln
+      if ln == ""
+        set_text_mode 10
+      else
+        @lines << ln
+      end
+    end
+    def receive_binary_data data
+      @body = data
+    end
+  end
+
+  def test_binary
+    testdata = %Q(Line 1
 Line 2
 
 0000000000Line 3
 Line 4
 )
 
-		a = Binary.new
-		a.receive_data testdata
-		assert_equal( ["Line 1", "Line 2", "Line 3", "Line 4"], a.lines)
-		assert_equal( "0000000000", a.body )
-
-		a = Binary.new
-		testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
-		assert_equal( ["Line 1", "Line 2", "Line 3", "Line 4"], a.lines)
-		assert_equal( "0000000000", a.body )
-	end
-
-
-	# Test unsized binary data. The expectation is that each chunk of it
-	# will be passed to us as it it received.
-	class UnsizedBinary
-		include EM::Protocols::LineText2
-		attr_reader :n_calls, :body
-		def initialize *args
-			super
-			set_text_mode
-		end
-		def receive_binary_data data
-			@n_calls ||= 0
-			@n_calls += 1
-			(@body ||= "") << data
-		end
-	end
-
-	def test_unsized_binary
-		testdata = "X\0" * 1000
-
-		a = UnsizedBinary.new
-		a.receive_data testdata
-		assert_equal( 1, a.n_calls )
-		assert_equal( testdata, a.body )
-
-		a = UnsizedBinary.new
-		testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
-		assert_equal( 2000, a.n_calls )
-		assert_equal( testdata, a.body )
-	end
-
-
-	# Test binary data with a "throw back" into line-mode.
-	class ThrowBack
-		include EM::Protocols::LineText2
-		attr_reader :headers
-		def initialize *args
-			super
-			@headers = []
-			@n_bytes = 0
-			set_text_mode
-		end
-		def receive_binary_data data
-			wanted = 25 - @n_bytes
-			will_take = if data.length > wanted
-				data.length - wanted
-			else
-				data.length
-			end
-			@n_bytes += will_take
-
-			if @n_bytes == 25
-				set_line_mode( data[will_take..-1] )
-			end
-		end
-		def receive_line ln
-			@headers << ln
-		end
-	end
-	def test_throw_back
-		testdata = "Line\n" * 10
-
-		a = ThrowBack.new
-		a.receive_data testdata
-		assert_equal( ["Line"] * 5, a.headers )
-
-		a = ThrowBack.new
-		testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
-		assert_equal( ["Line"] * 5, a.headers )
-	end
-
-	# Test multi-character line delimiters.
-	# Also note that the test data has a "tail" with no delimiter, that will be
-	# discarded, but cf. the BinaryTail test.
-	# TODO!!! This test doesn't work in the byte-by-byte case.
-	class Multichar
-		include EM::Protocols::LineText2
-		attr_reader :lines
-		def initialize *args
-			super
-			@lines = []
-			set_delimiter "012"
-		end
-		def receive_line ln
-			@lines << ln
-		end
-	end
-	def test_multichar
-		testdata = "Line012Line012Line012Line"
-
-		a = Multichar.new
-		a.receive_data testdata
-		assert_equal( ["Line"]*3, a.lines )
-
-		a = Multichar.new
-		testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
-		# DOESN'T WORK in this case. Multi-character delimiters are broken.
-		#assert_equal( ["Line"]*3, a.lines )
-	end
-
-	# Test a binary "tail," when a sized binary transfer doesn't complete because
-	# of an unbind. We get a partial result.
-	class BinaryTail
-		include EM::Protocols::LineText2
-		attr_reader :data
-		def initialize *args
-			super
-			@data = ""
-			set_text_mode 1000
-		end
-		def receive_binary_data data
-			# we expect to get all the data in one chunk, even in the byte-by-byte case,
-			# because sized transfers by definition give us exactly one call to
-			# #receive_binary_data.
-			@data = data
-		end
-	end
-	def test_binary_tail
-		testdata = "0" * 500
-
-		a = BinaryTail.new
-		a.receive_data testdata
-		a.unbind
-		assert_equal( "0" * 500, a.data )
-
-		a = BinaryTail.new
-		testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
-		a.unbind
-		assert_equal( "0" * 500, a.data )
-	end
-
-
-
-	# Test an end-of-binary call. Arrange to receive binary data but don't bother counting it
-	# as it comes. Rely on getting receive_end_of_binary_data to signal the transition back to
-	# line mode.
-	# At the present time, this isn't strictly necessary with sized binary chunks because by
-	# definition we accumulate them and make exactly one call to receive_binary_data, but
-	# we may want to support a mode in the future that would break up large chunks into multiple
-	# calls.
-	class LazyBinary
-		include EM::Protocols::LineText2
-		attr_reader :data, :end
-		def initialize *args
-			super
-			@data = ""
-			set_text_mode 1000
-		end
-		def receive_binary_data data
-			# we expect to get all the data in one chunk, even in the byte-by-byte case,
-			# because sized transfers by definition give us exactly one call to
-			# #receive_binary_data.
-			@data = data
-		end
-		def receive_end_of_binary_data
-			@end = true
-		end
-	end
-	def test_receive_end_of_binary_data
-		testdata = "_" * 1000
-		a = LazyBinary.new
-		testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
-		assert_equal( "_" * 1000, a.data )
-		assert( a.end )
-	end
-
-
-	# This tests a bug fix in which calling set_text_mode failed when called
-	# inside receive_binary_data.
-	#
-	class BinaryPair
-		include EM::Protocols::LineText2
-		attr_reader :sizes
-		def initialize *args
-			super
-			set_text_mode 1
-			@sizes = []
-		end
-		def receive_binary_data dt
-			@sizes <<  dt.length
-			set_text_mode( (dt.length == 1) ? 2 : 1 )
-		end
-	end
-	def test_binary_pairs
-		test_data = "123" * 5
-		a = BinaryPair.new
-		a.receive_data test_data
-		assert_equal( [1,2,1,2,1,2,1,2,1,2], a.sizes )
-	end
+    a = Binary.new
+    a.receive_data testdata
+    assert_equal( ["Line 1", "Line 2", "Line 3", "Line 4"], a.lines)
+    assert_equal( "0000000000", a.body )
+
+    a = Binary.new
+    testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
+    assert_equal( ["Line 1", "Line 2", "Line 3", "Line 4"], a.lines)
+    assert_equal( "0000000000", a.body )
+  end
+
+
+  # Test unsized binary data. The expectation is that each chunk of it
+  # will be passed to us as it it received.
+  class UnsizedBinary
+    include EM::Protocols::LineText2
+    attr_reader :n_calls, :body
+    def initialize *args
+      super
+      set_text_mode
+    end
+    def receive_binary_data data
+      @n_calls ||= 0
+      @n_calls += 1
+      (@body ||= "") << data
+    end
+  end
+
+  def test_unsized_binary
+    testdata = "X\0" * 1000
+
+    a = UnsizedBinary.new
+    a.receive_data testdata
+    assert_equal( 1, a.n_calls )
+    assert_equal( testdata, a.body )
+
+    a = UnsizedBinary.new
+    testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
+    assert_equal( 2000, a.n_calls )
+    assert_equal( testdata, a.body )
+  end
+
+
+  # Test binary data with a "throw back" into line-mode.
+  class ThrowBack
+    include EM::Protocols::LineText2
+    attr_reader :headers
+    def initialize *args
+      super
+      @headers = []
+      @n_bytes = 0
+      set_text_mode
+    end
+    def receive_binary_data data
+      wanted = 25 - @n_bytes
+      will_take = if data.length > wanted
+                    data.length - wanted
+                  else
+                    data.length
+                  end
+      @n_bytes += will_take
+
+      if @n_bytes == 25
+        set_line_mode( data[will_take..-1] )
+      end
+    end
+    def receive_line ln
+      @headers << ln
+    end
+  end
+  def test_throw_back
+    testdata = "Line\n" * 10
+
+    a = ThrowBack.new
+    a.receive_data testdata
+    assert_equal( ["Line"] * 5, a.headers )
+
+    a = ThrowBack.new
+    testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
+    assert_equal( ["Line"] * 5, a.headers )
+  end
+
+  # Test multi-character line delimiters.
+  # Also note that the test data has a "tail" with no delimiter, that will be
+  # discarded, but cf. the BinaryTail test.
+  # TODO!!! This test doesn't work in the byte-by-byte case.
+  class Multichar
+    include EM::Protocols::LineText2
+    attr_reader :lines
+    def initialize *args
+      super
+      @lines = []
+      set_delimiter "012"
+    end
+    def receive_line ln
+      @lines << ln
+    end
+  end
+  def test_multichar
+    testdata = "Line012Line012Line012Line"
+
+    a = Multichar.new
+    a.receive_data testdata
+    assert_equal( ["Line"]*3, a.lines )
+
+    a = Multichar.new
+    testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
+    # DOESN'T WORK in this case. Multi-character delimiters are broken.
+    #assert_equal( ["Line"]*3, a.lines )
+  end
+
+  # Test a binary "tail," when a sized binary transfer doesn't complete because
+  # of an unbind. We get a partial result.
+  class BinaryTail
+    include EM::Protocols::LineText2
+    attr_reader :data
+    def initialize *args
+      super
+      @data = ""
+      set_text_mode 1000
+    end
+    def receive_binary_data data
+      # we expect to get all the data in one chunk, even in the byte-by-byte case,
+      # because sized transfers by definition give us exactly one call to
+      # #receive_binary_data.
+      @data = data
+    end
+  end
+  def test_binary_tail
+    testdata = "0" * 500
+
+    a = BinaryTail.new
+    a.receive_data testdata
+    a.unbind
+    assert_equal( "0" * 500, a.data )
+
+    a = BinaryTail.new
+    testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
+    a.unbind
+    assert_equal( "0" * 500, a.data )
+  end
+
+
+  # Test an end-of-binary call. Arrange to receive binary data but don't bother counting it
+  # as it comes. Rely on getting receive_end_of_binary_data to signal the transition back to
+  # line mode.
+  # At the present time, this isn't strictly necessary with sized binary chunks because by
+  # definition we accumulate them and make exactly one call to receive_binary_data, but
+  # we may want to support a mode in the future that would break up large chunks into multiple
+  # calls.
+  class LazyBinary
+    include EM::Protocols::LineText2
+    attr_reader :data, :end
+    def initialize *args
+      super
+      @data = ""
+      set_text_mode 1000
+    end
+    def receive_binary_data data
+      # we expect to get all the data in one chunk, even in the byte-by-byte case,
+      # because sized transfers by definition give us exactly one call to
+      # #receive_binary_data.
+      @data = data
+    end
+    def receive_end_of_binary_data
+      @end = true
+    end
+  end
+  def test_receive_end_of_binary_data
+    testdata = "_" * 1000
+    a = LazyBinary.new
+    testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
+    assert_equal( "_" * 1000, a.data )
+    assert( a.end )
+  end
+
+
+  # This tests a bug fix in which calling set_text_mode failed when called
+  # inside receive_binary_data.
+  #
+  class BinaryPair
+    include EM::Protocols::LineText2
+    attr_reader :sizes
+    def initialize *args
+      super
+      set_text_mode 1
+      @sizes = []
+    end
+    def receive_binary_data dt
+      @sizes <<  dt.length
+      set_text_mode( (dt.length == 1) ? 2 : 1 )
+    end
+  end
+  def test_binary_pairs
+    test_data = "123" * 5
+    a = BinaryPair.new
+    a.receive_data test_data
+    assert_equal( [1,2,1,2,1,2,1,2,1,2], a.sizes )
+  end
 
 end
-