sensu-em 2.4.0-x86-mingw32

data/tests/test_httpclient.rb

@@ -0,0 +1,190 @@
+require 'em_test_helper'
+
+class TestHttpClient < Test::Unit::TestCase
+
+    Localhost = "127.0.0.1"
+    Localport = 9801
+
+  def setup
+  end
+
+  def teardown
+  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
+        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; 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 {|result|
+        ok = true;
+        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", 9701, EmptyContent
+        c = silent { EM::P::HttpClient.send :request, :host => "127.0.0.1", :port => 9701 }
+        c.callback {|result|
+          ok = true
+          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 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
+          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 {|result|
+        ok = true;
+        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 {|result|
+        ok = true;
+        EM.stop
+      }
+      c.errback {EM.stop}
+    }
+    assert ok
+  end
+
+end

data/tests/test_httpclient2.rb

@@ -0,0 +1,133 @@
+require 'em_test_helper'
+
+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
+      silent do
+        EM::P::HttpClient2.connect Localhost, Localport
+        EM::P::HttpClient2.connect( :host=>Localhost, :port=>Localport )
+      end
+      EM.stop
+    }
+  end
+
+
+  def test_bad_port
+    EM.run {
+      EM.start_server Localhost, Localport, TestServer
+      assert_raises( ArgumentError ) {
+        silent { EM::P::HttpClient2.connect Localhost, "xxx" }
+      }
+      EM.stop
+    }
+  end
+
+  def test_bad_server
+    err = nil
+    EM.run {
+      http = silent { 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 = silent { EM::P::HttpClient2.connect "google.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.
+  # 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 = silent { EM::P::HttpClient2.connect "google.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 = silent { EM::P::HttpClient2.connect "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 {
+      EM.start_server Localhost, Localport, TestServer
+      http = silent { EM::P::HttpClient2.connect Localhost, 18842 }
+      d = http.get :url=>"/", :authorization=>"Basic xxx"
+      d.callback {EM.stop}
+      d.errback {EM.stop}
+    }
+  end
+
+  # This test fails under JRuby - but not if you use google.com instead of apple.com
+  # Since this client is deprecated, it's probably not worth investigating further
+  def test_https_get
+    d = nil
+    EM.run {
+      http = silent { EM::P::HttpClient2.connect :host => 'www.apple.com', :port => 443, :ssl => true }
+      d = http.get "/"
+      d.errback {
+        fail "Request failed"
+      }
+      d.callback {
+        EM.stop
+      }
+    }
+    assert_equal(200, d.status)
+  end if EM.ssl?
+
+end

data/tests/test_idle_connection.rb

@@ -0,0 +1,25 @@
+require 'em_test_helper'
+
+class TestIdleConnection < Test::Unit::TestCase
+  if EM.respond_to?(:get_idle_time)
+    def test_idle_time
+      EM.run{
+        conn = EM.connect 'www.google.com', 80
+        EM.add_timer(3){
+          $idle_time = conn.get_idle_time
+          conn.send_data "GET / HTTP/1.0\r\n\r\n"
+          EM.next_tick{
+            EM.next_tick{
+              $idle_time_after_send = conn.get_idle_time
+              conn.close_connection
+              EM.stop
+            }
+          }
+        }
+      }
+
+      assert_in_delta 3, $idle_time, 0.2
+      assert_in_delta 0, $idle_time_after_send, 0.1
+    end
+  end
+end

data/tests/test_inactivity_timeout.rb

@@ -0,0 +1,54 @@
+require '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 = 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

data/tests/test_iterator.rb

@@ -0,0 +1,97 @@
+require 'em_test_helper'
+
+class TestIterator < Test::Unit::TestCase
+
+  def get_time
+    EM.current_time.strftime('%H:%M:%S')
+  end
+
+  def test_default_concurrency
+    items = {}
+    list = 1..10
+    EM.run {
+      EM::Iterator.new(list).each( proc {|num,iter|
+        time = get_time
+        items[time] ||= []
+        items[time] << num
+        EM::Timer.new(1) {iter.next}
+      }, proc {EM.stop})
+    }
+    assert_equal(10, items.keys.size)
+    assert_equal((list).to_a, items.values.flatten)
+  end
+
+  def test_concurrency_bigger_than_list_size
+    items = {}
+    list = [1,2,3]
+    EM.run {
+      EM::Iterator.new(list,10).each(proc {|num,iter|
+        time = get_time
+        items[time] ||= []
+        items[time] << num
+        EM::Timer.new(1) {iter.next}
+      }, proc {EM.stop})
+    }
+    assert_equal(1, items.keys.size)
+    assert_equal((list).to_a, items.values.flatten)
+  end
+
+
+  def test_changing_concurrency_affects_active_iteration
+    items = {}
+    list = 1..25
+    EM.run {
+      i = EM::Iterator.new(list,5)
+      i.each(proc {|num,iter|
+        time = get_time
+        items[time] ||= []
+        items[time] << num
+        EM::Timer.new(1) {iter.next}
+      }, proc {EM.stop})
+      EM.add_timer(1){
+        i.concurrency = 1
+      }
+      EM.add_timer(3){
+        i.concurrency = 3
+      }
+    }
+    assert_equal(9, items.keys.size)
+    assert_equal((list).to_a, items.values.flatten)
+  end
+
+  def test_map
+    list = 100..150
+    EM.run {
+      EM::Iterator.new(list).map(proc{ |num,iter|
+        EM.add_timer(0.01){ iter.return(num) }
+      }, proc{ |results|
+        assert_equal((list).to_a.size, results.size)
+       EM.stop
+      })
+    }
+  end
+
+  def test_inject
+    list = %w[ pwd uptime uname date ]
+    EM.run {
+      EM::Iterator.new(list, 2).inject({}, proc{ |hash,cmd,iter|
+        EM.system(cmd){ |output,status|
+          hash[cmd] = status.exitstatus == 0 ? output.strip : nil
+          iter.return(hash)
+        }
+      }, proc{ |results|
+        assert_equal(results.keys, list)
+        EM.stop
+      })
+    }
+  end
+
+  def test_concurrency_is_0
+    EM.run {
+      assert_raise ArgumentError do
+        EM::Iterator.new(1..5,0)
+      end
+      EM.stop
+    }
+  end
+end