eventmachine-mkroman 1.3.0.dev.1

data/tests/test_hc.rb

@@ -0,0 +1,155 @@
+require_relative 'em_test_helper'
+
+class TestHeaderAndContentProtocol < Test::Unit::TestCase
+
+  class SimpleTest < EM::P::HeaderAndContentProtocol
+    attr_reader :first_header, :my_headers, :request
+
+    def receive_first_header_line hdr
+      @first_header ||= []
+      @first_header << hdr
+    end
+    def receive_headers hdrs
+      @my_headers ||= []
+      @my_headers << hdrs
+    end
+    def receive_request hdrs, content
+      @request ||= []
+      @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
+    EM.run {
+      EM.start_server( "127.0.0.1", @port, SimpleTest ) do |conn|
+        the_connection = conn
+      end
+      setup_timeout
+
+      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
+    }
+    assert_equal( ["aaa"], the_connection.first_header )
+    assert_equal( [%w(aaa bbb ccc)], the_connection.my_headers )
+    assert_equal( [[%w(aaa bbb ccc), ""]], the_connection.request )
+  end
+
+  def test_content
+    the_connection = nil
+    content = "A" * 50
+    headers = ["aaa", "bbb", "Content-length: #{content.length}", "ccc"]
+    EM.run {
+      EM.start_server( "127.0.0.1", @port, SimpleTest ) do |conn|
+        the_connection = conn
+      end
+      setup_timeout
+
+      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
+    }
+    assert_equal( ["aaa"], the_connection.first_header )
+    assert_equal( [headers], the_connection.my_headers )
+    assert_equal( [[headers, content]], the_connection.request )
+  end
+
+  def test_several_requests
+    the_connection = nil
+    content = "A" * 50
+    headers = ["aaa", "bbb", "Content-length: #{content.length}", "ccc"]
+    EM.run {
+      EM.start_server( "127.0.0.1", @port, SimpleTest ) do |conn|
+        the_connection = conn
+      end
+      setup_timeout
+
+      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
+    }
+    assert_equal( ["aaa"] * 5, the_connection.first_header )
+    assert_equal( [headers] * 5, the_connection.my_headers )
+    assert_equal( [[headers, content]] * 5, the_connection.request )
+  end
+
+
+  # def x_test_multiple_content_length_headers
+  #   # This is supposed to throw a RuntimeError but it throws a C++ exception instead.
+  #   the_connection = nil
+  #   content = "A" * 50
+  #   headers = ["aaa", "bbb", ["Content-length: #{content.length}"]*2, "ccc"].flatten
+  #   EM.run {
+  #     EM.start_server( "127.0.0.1", @port, SimpleTest ) do |conn|
+  #       the_connection = conn
+  #     end
+  #     EM.add_timer(4) {raise "test timed out"}
+  #     test_proc = proc {
+  #       t = TCPSocket.new "127.0.0.1", @port
+  #       headers.each {|h| t.write "#{h}\r\n" }
+  #       t.write "\n"
+  #       t.write content
+  #       t.close
+  #     }
+  #     EM.defer test_proc, proc {
+  #       EM.stop
+  #     }
+  #   }
+  # end
+
+  def test_interpret_headers
+    the_connection = nil
+    content = "A" * 50
+    headers = [
+      "GET / HTTP/1.0",
+      "Accept: aaa",
+      "User-Agent: bbb",
+      "Host: ccc",
+      "x-tempest-header:ddd"
+    ]
+
+    EM.run {
+      EM.start_server( "127.0.0.1", @port, SimpleTest ) do |conn|
+        the_connection = conn
+      end
+      setup_timeout
+
+      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
+    }
+
+    hsh = the_connection.headers_2_hash( the_connection.my_headers.shift )
+    expect = {
+      :accept => "aaa",
+      :user_agent => "bbb",
+      :host => "ccc",
+      :x_tempest_header => "ddd"
+    }
+    assert_equal(expect, hsh)
+  end
+
+end

data/tests/test_httpclient.rb

@@ -0,0 +1,238 @@
+require_relative 'em_test_helper'
+
+class TestHttpClient < Test::Unit::TestCase
+
+  def setup
+    @port = next_port
+  end
+
+  #-------------------------------------
+
+  def test_http_client
+    ok = false
+    EM.run {
+      c = silent { EM::P::HttpClient.send :request, :host => "www.google.com", :port => 80 }
+      c.callback {
+        ok = true
+        c.close_connection
+        EM.stop
+      }
+      c.errback {EM.stop} # necessary, otherwise a failure blocks the test suite forever.
+    }
+    assert ok
+  end
+
+  #-------------------------------------
+
+  def test_http_client_1
+    ok = false
+    EM.run {
+      c = silent { EM::P::HttpClient.send :request, :host => "www.google.com", :port => 80 }
+      c.callback {
+        ok = true
+        c.close_connection
+        EM.stop
+      }
+      c.errback {EM.stop}
+    }
+    assert ok
+  end
+
+  #-------------------------------------
+
+  def test_http_client_2
+    ok = false
+    EM.run {
+      c = silent { EM::P::HttpClient.send :request, :host => "www.google.com", :port => 80 }
+      c.callback {
+        ok = true
+        c.close_connection
+        EM.stop
+      }
+      c.errback {EM.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 < EM::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
+      EM.run {
+        EM.start_server "127.0.0.1", @port, EmptyContent
+        c = silent { EM::P::HttpClient.send :request, :host => "127.0.0.1", :port => @port }
+        c.callback {
+          ok = true
+          c.close_connection
+          EM.stop
+        }
+      }
+      assert ok
+  end
+
+
+  #---------------------------------------
+
+  class PostContent < EM::P::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
+      EM.run {
+        EM.start_server '127.0.0.1', @port, PostContent
+        setup_timeout 2
+        c = silent { EM::P::HttpClient.request(
+          :host         => '127.0.0.1',
+          :port         => @port,
+          :method       => :post,
+          :request      => "/aaa",
+          :content      => "XYZ",
+          :content_type => "text/plain"
+        )}
+        c.callback {|r|
+          response = r
+          EM.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 = silent { EM::Protocols::HttpClient.send :request, :host => "www.google.com", :port => 80, :cookie=>"aaa=bbb" }
+      c.callback {
+        ok = true
+        c.close_connection
+        EM.stop
+      }
+      c.errback {EM.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 = silent { EM::P::HttpClient.request(
+        :host => "www.google.com",
+        :port => 80,
+        :version => "1.0"
+      )}
+      c.callback {
+        ok = true
+        c.close_connection
+        EM.stop
+      }
+      c.errback {EM.stop}
+    }
+    assert ok
+  end
+
+  #-----------------------------------------
+
+  # Test a server that returns chunked encoding
+  #
+  class ChunkedEncodingContent < EventMachine::Connection
+    def initialize *args
+      super
+    end
+    def receive_data data
+      send_data ["HTTP/1.1 200 OK",
+                "Server: nginx/0.7.67", 
+                "Date: Sat, 23 Oct 2010 16:41:32 GMT",
+                "Content-Type: application/json",
+                "Transfer-Encoding: chunked",
+                "Connection: keep-alive",
+                "", 
+                "1800",
+                "chunk1" * 1024,
+                "5a",
+                "chunk2" * 15,
+                "0",
+                ""].join("\r\n")
+      close_connection_after_writing
+    end
+  end
+
+  def test_http_chunked_encoding_content
+    ok = false
+    EM.run {
+      EM.start_server "127.0.0.1", @port, ChunkedEncodingContent
+      c = silent { EM::P::HttpClient.send :request, :host => "127.0.0.1", :port => @port }
+      c.callback { |result|
+        if result[:content] == "chunk1" * 1024 + "chunk2" * 15
+          ok = true
+        end
+        c.close_connection
+        EM.stop
+      }
+    }
+    assert ok
+  end
+
+end
+
+

data/tests/test_httpclient2.rb

@@ -0,0 +1,132 @@
+require_relative 'em_test_helper'
+
+class TestHttpClient2 < Test::Unit::TestCase
+  class TestServer < EM::Connection
+  end
+
+  TIMEOUT = (windows? ? 2.0 : 1)
+  # below may be due to an issue with OpenSSL 1.0.2 and earlier with Windows
+  CI_WINDOWS_OLD = windows? and RUBY_VERSION < '2.5'
+  
+  def setup
+    @port = next_port
+  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 {
+      setup_timeout
+      EM.start_server '127.0.0.1', @port, TestServer
+      silent do
+        EM::P::HttpClient2.connect '127.0.0.1', @port
+        EM::P::HttpClient2.connect( :host=>'127.0.0.1', :port=>@port )
+      end
+      EM.stop
+    }
+  end
+
+  def test_bad_port
+    EM.run {
+      setup_timeout
+      EM.start_server '127.0.0.1', @port, TestServer
+      assert_raises( ArgumentError ) {
+        silent { EM::P::HttpClient2.connect '127.0.0.1', "xxx" }
+      }
+      EM.stop
+    }
+  end
+
+  def test_bad_server
+    err = nil
+    EM.run {
+      setup_timeout TIMEOUT
+      http = silent { EM::P::HttpClient2.connect '127.0.0.1', 9999 }
+      d = http.get "/"
+      d.errback { err = true; d.internal_error; EM.stop }
+    }
+    assert(err)
+  end
+
+  def test_get
+    content = nil
+    EM.run {
+      setup_timeout(CI_WINDOWS_OLD ? 9 : TIMEOUT)
+      http = silent { EM::P::HttpClient2.connect :host => "www.google.com", :port => 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.
+  # 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 {
+      setup_timeout
+      http = silent { EM::P::HttpClient2.connect "www.google.com" }
+      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 {
+      setup_timeout TIMEOUT
+      http = silent { EM::P::HttpClient2.connect "www.google.com", 80 }
+      d = http.get("/")
+      d.callback {
+        headers = d.headers
+      }
+      e = http.get("/")
+      e.callback {
+        headers2 = e.headers
+      }
+      EM.tick_loop { EM.stop if headers && headers2 }
+      EM.add_timer(1) { EM.stop }
+    }
+    assert(headers)
+    assert(headers2)
+  end
+
+  def test_authheader
+    EM.run {
+      setup_timeout TIMEOUT
+      EM.start_server '127.0.0.1', @port, TestServer
+      http = silent { EM::P::HttpClient2.connect '127.0.0.1', 18842 }
+      d = http.get :url=>"/", :authorization=>"Basic xxx"
+      d.callback {EM.stop}
+      d.errback {EM.stop}
+    }
+  end
+
+  def test_https_get
+    omit("No SSL") unless EM.ssl?
+    d = nil
+    EM.run {
+      setup_timeout(CI_WINDOWS_OLD ? 9 : TIMEOUT)
+      http = silent { EM::P::HttpClient2.connect :host => 'www.google.com', :port => 443, :tls => true }
+      d = http.get "/"
+      d.callback {EM.stop}
+      d.errback {EM.stop}
+    }
+    assert_equal(200, d.status)
+  end
+
+end

data/tests/test_idle_connection.rb

@@ -0,0 +1,31 @@
+require_relative 'em_test_helper'
+
+class TestIdleConnection < Test::Unit::TestCase
+  def setup
+    @port = next_port
+  end
+
+  def test_idle_time
+    omit_if(!EM.respond_to?(:get_idle_time))
+
+    a, b = nil, nil
+    EM.run do
+      EM.start_server '127.0.0.1', @port, Module.new
+      conn = EM.connect '127.0.0.1', @port
+      EM.add_timer(0.3) do
+        a = conn.get_idle_time
+        conn.send_data 'a'
+        EM.next_tick do
+          EM.next_tick do
+            b = conn.get_idle_time
+            conn.close_connection
+            EM.stop
+          end
+        end
+      end
+    end
+
+    assert_in_delta 0.3, a, (darwin? ? 0.2 : 0.1)
+    assert_in_delta 0, b, 0.1
+  end
+end

data/tests/test_inactivity_timeout.rb

@@ -0,0 +1,102 @@
+require_relative 'em_test_helper'
+
+class TestInactivityTimeout < Test::Unit::TestCase
+
+  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
+
+    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
+
+    def test_for_real
+      start, finish, reason = nil
+
+      timeout_start = Module.new do
+        define_method :post_init do
+          start = Time.now
+        end
+      end
+
+      timeout_handler = Module.new do
+        define_method :unbind do
+          finish = Time.now
+          EM.stop
+        end
+      end
+
+      EM.run {
+        setup_timeout 0.4
+        EM.heartbeat_interval = 0.01
+        EM.start_server("127.0.0.1", 12345, timeout_start)
+        EM.add_timer(0.01) {
+          c = EM.connect("127.0.0.1", 12345, timeout_handler)
+          c.comm_inactivity_timeout = 0.02
+        }
+      }
+      # Travis can vary from 0.02 to 0.17, Appveyor maybe as low as 0.01
+      assert_in_delta 0.09, (finish - start), (darwin? ? 0.10 : 0.08)
+
+      # simplified reproducer for comm_inactivity_timeout taking twice as long
+      # as requested -- https://github.com/eventmachine/eventmachine/issues/554
+      timeout_start_tls = Module.new do
+        define_method :post_init do
+          start = Time.now
+          start_tls
+        end
+        define_method :receive_data do |data|
+          send_data ">>>you sent: #{data}"
+        end
+      end
+
+      timeout_handler_tls = Module.new do
+        define_method :connection_completed do
+          start_tls
+        end
+
+        define_method :ssl_handshake_completed do
+          @timer = EM::PeriodicTimer.new(0.05) do
+            #puts "get_idle_time: #{get_idle_time} inactivity: #{comm_inactivity_timeout}"
+          end
+          send_data "hello world"
+        end
+
+        define_method :unbind do |r|
+          finish = Time.now
+          reason = r
+          EM.stop
+        end
+      end
+
+      EM.run {
+        setup_timeout 1.4
+        EM.start_server("127.0.0.1", 12345, timeout_start_tls)
+        c = EM.connect("127.0.0.1", 12345, timeout_handler_tls)
+        c.comm_inactivity_timeout = 0.15
+      }
+
+      # .30 is double the timeout and not acceptable
+      assert_in_delta 0.15, (finish - start), (darwin? ? 0.20 : 0.14)
+      # make sure it was a timeout and not a TLS error
+      assert_equal Errno::ETIMEDOUT, reason
+    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

data/tests/test_io_streamer.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative 'em_test_helper'
+require 'em/io_streamer'
+require 'stringio'
+
+# below to stop 'already initialized constant' warning
+EM::IOStreamer.__send__ :remove_const, :CHUNK_SIZE
+EM::IOStreamer.const_set :CHUNK_SIZE, 2
+
+class TestIOStreamer < Test::Unit::TestCase
+
+  class StreamServer < EM::Connection
+    def initialize(sent)
+      @sent = sent
+    end
+
+    def post_init
+      io = StringIO.new @sent
+      EM::IOStreamer.new(self, io).callback { close_connection_after_writing }
+    end
+  end
+
+  class StreamClient < EM::Connection
+    def initialize(received)
+      @received = received
+    end
+
+    def receive_data data
+      @received << data
+    end
+
+    def unbind
+      EM.stop
+    end
+  end
+
+  def test_io_stream
+    sent = 'this is a test'
+    received = ''.dup
+    EM.run do
+      port = next_port
+      EM.start_server '127.0.0.1', port, StreamServer, sent
+      EM.connect '127.0.0.1', port, StreamClient, received
+    end
+    assert_equal sent, received
+  end
+end