sensu-em 2.0.0-java

data/tests/server.key

@@ -0,0 +1,51 @@
+-----BEGIN RSA PRIVATE KEY-----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-----END RSA PRIVATE KEY-----

data/tests/test_attach.rb

@@ -0,0 +1,150 @@
+require 'em_test_helper'
+require 'socket'
+
+class TestAttach < Test::Unit::TestCase
+  class EchoServer < EM::Connection
+    def receive_data data
+      $received_data << data
+      send_data data
+    end
+  end
+
+  class EchoClient < EM::Connection
+    def initialize socket
+      self.notify_readable = true
+      @socket = socket
+      @socket.write("abc\n")
+    end
+
+    def notify_readable
+      $read = @socket.readline
+      $fd = detach
+    end
+
+    def unbind
+      EM.next_tick do
+        @socket.write("def\n")
+        EM.add_timer(0.1) { EM.stop }
+      end
+    end
+  end
+
+  def setup
+    @port = next_port
+    $read, $r, $w, $fd = nil
+    $received_data = ""
+  end
+
+  def teardown
+    [$r, $w].each do |io|
+      io.close rescue nil
+    end
+    $received_data = nil
+  end
+
+  def test_attach
+    socket = nil
+
+    EM.run {
+      EM.start_server "127.0.0.1", @port, EchoServer
+      socket = TCPSocket.new "127.0.0.1", @port
+      EM.watch socket, EchoClient, socket
+    }
+
+    assert_equal $read, "abc\n"
+    unless jruby? # jruby filenos are not real
+      assert_equal $fd, socket.fileno
+    end
+    assert_equal false, socket.closed?
+    assert_equal socket.readline, "def\n"
+  end
+
+  module PipeWatch
+    def notify_readable
+      $read = $r.readline
+      EM.stop
+    end
+  end
+
+  def test_attach_server
+    $before = TCPServer.new("127.0.0.1", @port)
+    sig     = nil
+    EM.run {
+      sig = EM.attach_server $before, EchoServer
+
+      handler = Class.new(EM::Connection) do
+        def initialize
+          send_data "hello world"
+          close_connection_after_writing
+          EM.add_timer(0.1) { EM.stop }
+        end
+      end
+      EM.connect("127.0.0.1", @port, handler)
+    }
+
+    assert_equal false, $before.closed?
+    assert_equal "hello world", $received_data
+    assert sig.is_a?(Integer)
+  end
+
+  def test_attach_pipe
+    EM.run{
+      $r, $w = IO.pipe
+      EM.watch $r, PipeWatch do |c|
+        c.notify_readable = true
+      end
+      $w.write("ghi\n")
+    }
+
+    assert_equal $read, "ghi\n"
+  end
+
+  def test_set_readable
+    before, after = nil
+
+    EM.run{
+      $r, $w = IO.pipe
+      c = EM.watch $r, PipeWatch do |con|
+        con.notify_readable = false
+      end
+
+      EM.next_tick{
+        before = c.notify_readable?
+        c.notify_readable = true
+        after = c.notify_readable?
+      }
+
+      $w.write("jkl\n")
+    }
+
+    assert !before
+    assert after
+    assert_equal $read, "jkl\n"
+  end
+
+  def test_read_write_pipe
+    result = nil
+
+    pipe_reader = Module.new do
+      define_method :receive_data do |data|
+        result = data
+        EM.stop
+      end
+    end
+
+    r,w = IO.pipe
+
+    EM.run {
+      EM.attach r, pipe_reader
+      writer = EM.attach(w)
+      writer.send_data 'ghi'
+
+      # XXX: Process will hang in Windows without this line
+      writer.close_connection_after_writing
+    }
+
+    assert_equal "ghi", result
+  ensure
+    [r,w].each {|io| io.close rescue nil }
+  end
+end

data/tests/test_basic.rb

@@ -0,0 +1,294 @@
+require 'em_test_helper'
+require 'socket'
+
+class TestBasic < Test::Unit::TestCase
+  def setup
+    @port = next_port
+  end
+
+  def test_connection_class_cache
+    mod = Module.new
+    a, b = nil, nil
+    EM.run {
+      EM.start_server '127.0.0.1', @port, mod
+      a = EM.connect '127.0.0.1', @port, mod
+      b = EM.connect '127.0.0.1', @port, mod
+      EM.stop
+    }
+    assert_equal a.class, b.class
+    assert_kind_of EM::Connection, a
+  end
+
+  #-------------------------------------
+
+
+  def test_em
+    assert_nothing_raised do
+      EM.run {
+        setup_timeout
+        EM.add_timer 0 do
+          EM.stop
+        end
+      }
+    end
+  end
+
+  #-------------------------------------
+
+  def test_timer
+    assert_nothing_raised do
+      EM.run {
+        setup_timeout
+        n = 0
+        EM.add_periodic_timer(0.1) {
+          n += 1
+          EM.stop if n == 2
+        }
+      }
+    end
+  end
+
+  #-------------------------------------
+
+  # This test once threw an already-running exception.
+  module Trivial
+    def post_init
+      EM.stop
+    end
+  end
+
+  def test_server
+    assert_nothing_raised do
+      EM.run {
+        setup_timeout
+        EM.start_server "127.0.0.1", @port, Trivial
+        EM.connect "127.0.0.1", @port
+      }
+    end
+  end
+
+  #--------------------------------------
+
+  # EM#run_block starts the reactor loop, runs the supplied block, and then STOPS
+  # the loop automatically. Contrast with EM#run, which keeps running the reactor
+  # even after the supplied block completes.
+  def test_run_block
+    assert !EM.reactor_running?
+    a = nil
+    EM.run_block { a = "Worked" }
+    assert a
+    assert !EM.reactor_running?
+  end
+
+  class UnbindError < EM::Connection
+    ERR = Class.new(StandardError)
+    def initialize *args
+      super
+    end
+    def connection_completed
+      close_connection_after_writing
+    end
+    def unbind
+      raise ERR
+    end
+  end
+
+  def test_unbind_error
+    assert_raises( UnbindError::ERR ) {
+      EM.run {
+        EM.start_server "127.0.0.1", @port
+        EM.connect "127.0.0.1", @port, UnbindError
+      }
+    }
+  end
+
+  module BrsTestSrv
+    def receive_data data
+      $received << data
+    end
+    def unbind
+      EM.stop
+    end
+  end
+  module BrsTestCli
+    def post_init
+      send_data $sent
+      close_connection_after_writing
+    end
+  end
+
+  # From ticket #50
+  def test_byte_range_send
+    $received = ''
+    $sent = (0..255).to_a.pack('C*')
+    EM::run {
+      EM::start_server "127.0.0.1", @port, BrsTestSrv
+      EM::connect "127.0.0.1", @port, BrsTestCli
+
+      setup_timeout
+    }
+    assert_equal($sent, $received)
+  end
+
+  def test_bind_connect
+    local_ip = UDPSocket.open {|s| s.connect('google.com', 80); s.addr.last }
+
+    bind_port = next_port
+
+    port, ip = nil
+    bound_server = Module.new do
+      define_method :post_init do
+        begin
+          port, ip = Socket.unpack_sockaddr_in(get_peername)
+        ensure
+          EM.stop
+        end
+      end
+    end
+
+    EM.run do
+      setup_timeout
+      EM.start_server "127.0.0.1", @port, bound_server
+      EM.bind_connect local_ip, bind_port, "127.0.0.1", @port
+    end
+
+    assert_equal bind_port, port
+    assert_equal local_ip, ip
+  end
+
+  def test_reactor_thread?
+    assert !EM.reactor_thread?
+    EM.run { assert EM.reactor_thread?; EM.stop }
+    assert !EM.reactor_thread?
+  end
+
+  def test_schedule_on_reactor_thread
+    x = false
+    EM.run do
+      EM.schedule { x = true }
+      EM.stop
+    end
+    assert x
+  end
+  
+  def test_schedule_from_thread
+    x = false
+    EM.run do
+      Thread.new { EM.schedule { x = true; EM.stop } }.join
+    end
+    assert x
+  end
+
+  if EM.respond_to? :set_heartbeat_interval
+    def test_set_heartbeat_interval
+      interval = 0.5
+      EM.run {
+        EM.set_heartbeat_interval interval
+        $interval = EM.get_heartbeat_interval
+        EM.stop
+      }
+      assert_equal(interval, $interval)
+    end
+  else
+    warn "EM.set_heartbeat_interval not implemented, skipping a test in #{__FILE__}"
+  end
+  
+  module PostInitRaiser
+    ERR = Class.new(StandardError)
+    def post_init
+      raise ERR
+    end
+  end
+  
+  def test_bubble_errors_from_post_init
+    assert_raises(PostInitRaiser::ERR) do
+      EM.run do
+        EM.start_server "127.0.0.1", @port
+        EM.connect "127.0.0.1", @port, PostInitRaiser
+      end
+    end
+  end
+  
+  module InitializeRaiser
+    ERR = Class.new(StandardError)
+    def initialize
+      raise ERR
+    end
+  end
+  
+  def test_bubble_errors_from_initialize
+    assert_raises(InitializeRaiser::ERR) do
+      EM.run do
+        EM.start_server "127.0.0.1", @port
+        EM.connect "127.0.0.1", @port, InitializeRaiser
+      end
+    end
+  end
+  
+  def test_schedule_close
+    localhost, port = '127.0.0.1', 9000
+    timer_ran = false
+    num_close_scheduled = nil
+    EM.run do
+      assert_equal 0, EM.num_close_scheduled
+      EM.add_timer(1) { timer_ran = true; EM.stop }
+      EM.start_server localhost, port do |s|
+        s.close_connection
+        num_close_scheduled = EM.num_close_scheduled
+      end
+      EM.connect localhost, port do |c|
+        def c.unbind
+          EM.stop
+        end
+      end
+    end
+    assert !timer_ran
+    assert_equal 1, num_close_scheduled
+  end
+
+  def test_fork_safe
+    return unless cpid = fork { exit! } rescue false
+
+    read, write = IO.pipe
+    EM.run do
+      cpid = fork do
+        write.puts "forked"
+        EM.run do
+          EM.next_tick do
+            write.puts "EM ran"
+            exit!
+          end
+        end
+      end
+      EM.stop
+    end
+    Process.waitall
+    assert_equal "forked\n", read.readline
+    assert_equal "EM ran\n", read.readline
+  ensure
+    read.close rescue nil
+    write.close rescue nil
+  end
+
+  def test_error_handler_idempotent # issue 185
+    errors = []
+    ticks = []
+    EM.error_handler do |e|
+      errors << e
+    end
+
+    EM.run do
+      EM.next_tick do
+        ticks << :first
+        raise
+      end
+      EM.next_tick do
+        ticks << :second
+      end
+      EM.add_timer(0.001) { EM.stop }
+    end
+
+    assert_equal 1, errors.size
+    assert_equal [:first, :second], ticks
+  end
+end

data/tests/test_channel.rb

@@ -0,0 +1,62 @@
+require 'em_test_helper'
+
+class TestEMChannel < Test::Unit::TestCase
+  def test_channel_subscribe
+    s = 0
+    EM.run do
+      c = EM::Channel.new
+      c.subscribe { |v| s = v; EM.stop }
+      c << 1
+    end
+    assert_equal 1, s
+  end
+
+  def test_channel_unsubscribe
+    s = 0
+    EM.run do
+      c = EM::Channel.new
+      subscription = c.subscribe { |v| s = v }
+      c.unsubscribe(subscription)
+      c << 1
+      EM.next_tick { EM.stop }
+    end
+    assert_not_equal 1, s
+  end
+
+  def test_channel_pop
+    s = 0
+    EM.run do
+      c = EM::Channel.new
+      c.pop{ |v| s = v }
+      c.push(1,2,3)
+      c << 4
+      c << 5
+      EM.next_tick { EM.stop }
+    end
+    assert_equal 1, s
+  end
+
+  def test_channel_reactor_thread_push
+    out = []
+    c = EM::Channel.new
+    c.subscribe { |v| out << v }
+    Thread.new { c.push(1,2,3) }.join
+    assert out.empty?
+
+    EM.run { EM.next_tick { EM.stop } }
+
+    assert_equal [1,2,3], out
+  end
+
+  def test_channel_reactor_thread_callback
+    out = []
+    c = EM::Channel.new
+    Thread.new { c.subscribe { |v| out << v } }.join
+    c.push(1,2,3)
+    assert out.empty?
+
+    EM.run { EM.next_tick { EM.stop } }
+
+    assert_equal [1,2,3], out
+  end
+end