eventmachine 0.12.6-java

data/tests/test_httpclient.rb

@@ -0,0 +1,215 @@
+# $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'
+
+class TestHttpClient < Test::Unit::TestCase
+
+    Localhost = "127.0.0.1"
+    Localport = 9801
+
+  def setup
+  end
+
+  def teardown
+  end
+
+  #-------------------------------------
+
+  def test_http_client
+    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} # necessary, otherwise a failure blocks the test suite forever.
+    }
+    assert ok
+  end
+
+  #-------------------------------------
+
+  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}
+    }
+    assert ok
+  end
+
+  #-------------------------------------
+
+  def test_http_client_2
+    ok = false
+    EventMachine.run {
+      c = EventMachine::Protocols::HttpClient.send :request, :host => "www.bayshorenetworks.com", :port => 80
+      c.callback {|result|
+        ok = true;
+        EventMachine.stop
+      }
+      c.errback {EventMachine.stop}
+    }
+    assert ok
+  end
+
+
+  #-----------------------------------------
+
+  # Test a server that returns a page with a zero content-length.
+  # This caused an early version of the HTTP client not to generate a response,
+  # 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
+      def initialize *args
+	  super
+      end
+      def receive_data data
+	  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
+	  }
+      }
+      assert ok
+  end
+
+
+  #---------------------------------------
+
+  class PostContent < EventMachine::Protocols::LineAndTextProtocol
+      def initialize *args
+	  super
+	  @lines = []
+      end
+      def receive_line line
+	  if line.length > 0
+	      @lines << line
+	  else
+	      process_headers
+	  end
+      end
+      def receive_binary_data data
+	  @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
+      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
+      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 :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] )
+      assert_equal( "0123456789", response[:content] )
+  end
+
+
+  # TODO, need a more intelligent cookie tester.
+  # In fact, this whole test-harness needs a beefier server implementation.
+  def test_cookie
+    ok = false
+    EM.run {
+      c = EM::Protocols::HttpClient.send :request, :host => "www.bayshorenetworks.com", :port => 80, :cookie=>"aaa=bbb"
+      c.callback {|result|
+        ok = true;
+        EventMachine.stop
+      }
+      c.errback {EventMachine.stop}
+    }
+    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.callback {|result|
+        ok = true;
+        EventMachine.stop
+      }
+      c.errback {EventMachine.stop}
+    }
+    assert ok
+  end
+
+
+end
+
+

data/tests/test_httpclient2.rb

@@ -0,0 +1,155 @@
+# $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'
+
+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
+    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
+
+
+
+end
+
+

data/tests/test_kb.rb

@@ -0,0 +1,61 @@
+# $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'
+
+class TestKeyboardEvents < Test::Unit::TestCase
+
+  def setup
+  end
+
+  def teardown
+  end
+
+  module KbHandler
+	  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
+  # illustrate the usage. If you removed the timer and ran this test
+  # by itself on a console, and then typed into the console, it would
+  # work.
+  # I don't know how to get the test harness to simulate actual keystrokes.
+  # 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.
+  end
+
+end
+

data/tests/test_ltp.rb

@@ -0,0 +1,188 @@
+# $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.
+#
+#---------------------------------------------------------------------------
+#
+#
+#
+#
+
+require 'eventmachine'
+require 'test/unit'
+
+class TestLineAndTextProtocol < Test::Unit::TestCase
+
+  TestHost = "127.0.0.1"
+  TestPort = 8905
+
+
+  #--------------------------------------------------------------------
+
+  class SimpleLineTest < EventMachine::Protocols::LineAndTextProtocol
+    def receive_line line
+      @line_buffer << line
+    end
+  end
+
+  module StopClient
+    def set_receive_data(&blk)
+      @rdb = blk
+    end
+    
+    def receive_data data
+      @rdb.call(data) if @rdb
+    end
+    
+    def unbind
+      EM.add_timer(0.1) { EM.stop }
+    end
+  end
+
+
+  def test_simple_lines
+    # THIS TEST CURRENTLY FAILS IN JRUBY.
+    assert( RUBY_PLATFORM !~ /java/ )
+
+    lines_received = []
+    EventMachine.run {
+      EventMachine.start_server( TestHost, TestPort, SimpleLineTest ) do |conn|
+        conn.instance_eval "@line_buffer = lines_received"
+      end
+      EventMachine.add_timer(4) {assert(false, "test timed out")}
+
+      EventMachine.connect TestHost, TestPort, StopClient do |c|
+        c.send_data "aaa\nbbb\r\nccc\n"
+        c.close_connection_after_writing
+      end
+    }
+    assert_equal( %w(aaa bbb ccc), lines_received )
+  end
+
+  #--------------------------------------------------------------------
+
+  class SimpleLineTest < EventMachine::Protocols::LineAndTextProtocol
+    def receive_error text
+      @error_message << text
+    end
+  end
+
+  def test_overlength_lines
+    # THIS TEST CURRENTLY FAILS IN JRUBY.
+    assert( RUBY_PLATFORM !~ /java/ )
+
+    lines_received = []
+    EventMachine.run {
+      EventMachine.start_server( TestHost, TestPort, SimpleLineTest ) do |conn|
+        conn.instance_eval "@error_message = lines_received"
+      end
+      EventMachine.add_timer(4) {assert(false, "test timed out")}
+
+      EventMachine.connect TestHost, TestPort, StopClient do |c|
+        c.send_data "a" * (16*1024 + 1)
+        c.send_data "\n"
+        c.close_connection_after_writing
+      end
+
+    }
+    assert_equal( ["overlength line"], lines_received )
+  end
+
+
+  #--------------------------------------------------------------------
+
+  class LineAndTextTest < EventMachine::Protocols::LineAndTextProtocol
+    def post_init
+    end
+    def receive_line line
+      if line =~ /content-length:\s*(\d+)/i
+        @content_length = $1.to_i
+      elsif line.length == 0
+        set_binary_mode @content_length
+      end
+    end
+    def receive_binary_data text
+      send_data "received #{text.length} bytes"
+      close_connection_after_writing
+    end
+  end
+
+  def test_lines_and_text
+    output = ''
+    lines_received = []
+    text_received = []
+    EventMachine.run {
+      EventMachine.start_server( TestHost, TestPort, LineAndTextTest ) do |conn|
+        conn.instance_eval "@lines = lines_received; @text = text_received"
+      end
+      EventMachine.add_timer(4) {assert(false, "test timed out")}
+
+      EventMachine.connect TestHost, TestPort, StopClient do |c|
+        c.set_receive_data { |data| output << data }
+        c.send_data "Content-length: 400\n"
+        c.send_data "\n"
+        c.send_data "A" * 400
+        EM.add_timer(0.1) { c.close_connection_after_writing }
+      end
+    }
+    assert_equal( "received 400 bytes", output )
+  end
+
+  #--------------------------------------------------------------------
+
+
+  class BinaryTextTest < EventMachine::Protocols::LineAndTextProtocol
+    def post_init
+    end
+    def receive_line line
+      if line =~ /content-length:\s*(\d+)/i
+        set_binary_mode $1.to_i
+      else
+        raise "protocol error"
+      end
+    end
+    def receive_binary_data text
+      send_data "received #{text.length} bytes"
+      close_connection_after_writing
+    end
+  end
+
+  def test_binary_text
+    output = ''
+    lines_received = []
+    text_received = []
+    EventMachine.run {
+      EventMachine.start_server( TestHost, TestPort, BinaryTextTest ) do |conn|
+        conn.instance_eval "@lines = lines_received; @text = text_received"
+      end
+      EventMachine.add_timer(4) {assert(false, "test timed out")}
+
+      EventMachine.connect TestHost, TestPort, StopClient do |c|
+        c.set_receive_data { |data| output << data }
+        c.send_data "Content-length: 10000\n"
+        c.send_data "A" * 10000
+        EM.add_timer(0.2) { c.close_connection_after_writing }
+      end
+    }
+    assert_equal( "received 10000 bytes", output )
+  end
+
+  #--------------------------------------------------------------------
+end