sensu-em 2.0.0-java

data/tests/test_set_sock_opt.rb

@@ -0,0 +1,37 @@
+require 'em_test_helper'
+require 'socket'
+
+class TestSetSockOpt < Test::Unit::TestCase
+
+  if EM.respond_to? :set_sock_opt
+    def setup
+      assert(!EM.reactor_running?)
+    end
+
+    def teardown
+      assert(!EM.reactor_running?)
+    end
+
+    #-------------------------------------
+
+    def test_set_sock_opt
+      test = self
+      EM.run do
+        EM.connect 'google.com', 80, Module.new {
+          define_method :post_init do
+            val = set_sock_opt Socket::SOL_SOCKET, Socket::SO_BROADCAST, true
+            test.assert_equal 0, val
+            EM.stop
+          end
+        }
+      end
+    end
+  else
+    warn "EM.set_sock_opt not implemented, skipping tests in #{__FILE__}"
+
+    # Because some rubies will complain if a TestCase class has no tests
+    def test_em_set_sock_opt_unsupported
+      assert true
+    end
+  end
+end

data/tests/test_shutdown_hooks.rb

@@ -0,0 +1,23 @@
+require 'em_test_helper'
+
+class TestShutdownHooks < Test::Unit::TestCase
+  def test_shutdown_hooks
+    r = false
+    EM.run {
+      EM.add_shutdown_hook { r = true }
+      EM.stop
+    }
+    assert_equal( true, r )
+  end
+
+  def test_hook_order
+    r = []
+    EM.run {
+      EM.add_shutdown_hook { r << 2 }
+      EM.add_shutdown_hook { r << 1 }
+      EM.stop
+    }
+    assert_equal( [1, 2], r )
+  end
+end
+

data/tests/test_smtpclient.rb

@@ -0,0 +1,55 @@
+require 'em_test_helper'
+
+class TestSmtpClient < Test::Unit::TestCase
+
+  Localhost = "127.0.0.1"
+  Localport = 9801
+
+  def setup
+  end
+
+  def teardown
+  end
+
+  def test_a
+    # No real tests until we have a server implementation to test against.
+    # This is what the call looks like, though:
+    err = nil
+    EM.run {
+      d = EM::Protocols::SmtpClient.send :domain=>"example.com",
+      :host=>Localhost,
+      :port=>Localport, # optional, defaults 25
+      :starttls=>true,
+      :from=>"sender@example.com",
+      :to=> ["to_1@example.com", "to_2@example.com"],
+      :header=> {"Subject" => "This is a subject line"},
+      :body=> "This is the body of the email",
+      :verbose=>true
+      d.errback {|e|
+        err = e
+        EM.stop
+      }
+    }
+    assert(err)
+  end
+
+  def test_content
+    err = nil
+    EM.run {
+      d = EM::Protocols::SmtpClient.send :domain=>"example.com",
+      :host=>Localhost,
+      :port=>Localport, # optional, defaults 25
+      :starttls=>true,
+      :from=>"sender@example.com",
+      :to=> ["to_1@example.com", "to_2@example.com"],
+      :content => ["Subject: xxx\r\n\r\ndata\r\n.\r\n"],
+      :verbose=>true
+      d.errback {|e|
+        err = e
+        EM.stop
+      }
+    }
+    assert(err)
+  end
+
+end

data/tests/test_smtpserver.rb

@@ -0,0 +1,57 @@
+require 'em_test_helper'
+
+class TestSmtpServer < Test::Unit::TestCase
+
+  # Don't test on port 25. It requires superuser and there's probably
+  # a mail server already running there anyway.
+  Localhost = "127.0.0.1"
+  Localport = 25001
+
+  # This class is an example of what you need to write in order
+  # to implement a mail server. You override the methods you are
+  # interested in. Some, but not all, of these are illustrated here.
+  #
+  class Mailserver < EM::Protocols::SmtpServer
+
+    attr_reader :my_msg_body, :my_sender, :my_recipients
+
+    def initialize *args
+      super
+    end
+    def receive_sender sender
+      @my_sender = sender
+      #p sender
+      true
+    end
+    def receive_recipient rcpt
+      @my_recipients ||= []
+      @my_recipients << rcpt
+      true
+    end
+    def receive_data_chunk c
+      @my_msg_body = c.last
+    end
+    def connection_ended
+      EM.stop
+    end
+  end
+
+  def test_mail
+    c = nil
+    EM.run {
+      EM.start_server( Localhost, Localport, Mailserver ) {|conn| c = conn}
+      EM::Timer.new(2) {EM.stop} # prevent hanging the test suite in case of error
+      EM::Protocols::SmtpClient.send :host=>Localhost,
+        :port=>Localport,
+        :domain=>"bogus",
+        :from=>"me@example.com",
+        :to=>"you@example.com",
+        :header=> {"Subject"=>"Email subject line", "Reply-to"=>"me@example.com"},
+        :body=>"Not much of interest here."
+
+    }
+    assert_equal( "Not much of interest here.", c.my_msg_body )
+    assert_equal( "<me@example.com>", c.my_sender )
+    assert_equal( ["<you@example.com>"], c.my_recipients )
+  end
+end

data/tests/test_spawn.rb

@@ -0,0 +1,293 @@
+
+require 'em_test_helper'
+
+
+
+class TestSpawn < Test::Unit::TestCase
+
+  # Spawn a process that simply stops the reactor.
+  # Assert that the notification runs after the block that calls it.
+  #
+  def test_stop
+    x = nil
+    EM.run {
+      s = EM.spawn {EM.stop}
+      s.notify
+      x = true
+    }
+    assert x
+  end
+
+
+  # Pass a parameter to a spawned process.
+  #
+  def test_parms
+    val = 5
+    EM.run {
+      s = EM.spawn {|v| val *= v; EM.stop}
+      s.notify 3
+    }
+    assert_equal( 15, val )
+  end
+
+  # Pass multiple parameters to a spawned process.
+  #
+  def test_multiparms
+    val = 5
+    EM.run {
+      s = EM.spawn {|v1,v2| val *= (v1 + v2); EM.stop}
+      s.notify 3,4
+    }
+    assert_equal( 35, val )
+  end
+
+
+  # This test demonstrates that a notification does not happen immediately,
+  # but rather is scheduled sometime after the current code path completes.
+  #
+  def test_race
+    x = 0
+    EM.run {
+      s = EM.spawn {x *= 2; EM.stop}
+      s.notify
+      x = 2
+    }
+    assert_equal( 4, x)
+  end
+
+
+  # Spawn a process and notify it 25 times to run fibonacci
+  # on a pair of global variables.
+  #
+  def test_fibonacci
+    x = 1
+    y = 1
+    EM.run {
+      s = EM.spawn {x,y = y,x+y}
+      25.times {s.notify}
+
+      t = EM.spawn {EM.stop}
+      t.notify
+    }
+    assert_equal( 121393, x)
+    assert_equal( 196418, y)
+  end
+
+  # This one spawns 25 distinct processes, and notifies each one once,
+  # rather than notifying a single process 25 times.
+  #
+  def test_another_fibonacci
+    x = 1
+    y = 1
+    EM.run {
+      25.times {
+      s = EM.spawn {x,y = y,x+y}
+      s.notify
+    }
+
+    t = EM.spawn {EM.stop}
+    t.notify
+    }
+    assert_equal( 121393, x)
+    assert_equal( 196418, y)
+  end
+
+
+  # Make a chain of processes that notify each other in turn
+  # with intermediate fibonacci results. The final process in
+  # the chain stops the loop and returns the result.
+  #
+  def test_fibonacci_chain
+    a,b = nil
+
+    EM.run {
+      nextpid = EM.spawn {|x,y|
+        a,b = x,y
+        EM.stop
+      }
+
+      25.times {
+        n = nextpid
+        nextpid = EM.spawn {|x,y| n.notify( y, x+y )}
+      }
+
+      nextpid.notify( 1, 1 )
+    }
+
+    assert_equal( 121393, a)
+    assert_equal( 196418, b)
+  end
+
+
+  # EM#yield gives a spawed process to yield control to other processes
+  # (in other words, to stop running), and to specify a different code block
+  # that will run on its next notification.
+  #
+  def test_yield
+    a = 0
+    EM.run {
+      n = EM.spawn {
+        a += 10
+        EM.yield {
+          a += 20
+          EM.yield {
+            a += 30
+            EM.stop
+          }
+        }
+      }
+      n.notify
+      n.notify
+      n.notify
+    }
+    assert_equal( 60, a )
+  end
+
+  # EM#yield_and_notify behaves like EM#yield, except that it also notifies the
+  # yielding process. This may sound trivial, since the yield block will run very
+  # shortly after with no action by the program, but this actually can be very useful,
+  # because it causes the reactor core to execute once before the yielding process
+  # gets control back. So it can be used to allow heavily-used network connections
+  # to clear buffers, or allow other processes to process their notifications.
+  #
+  # Notice in this test code that only a simple notify is needed at the bottom
+  # of the initial block. Even so, all of the yielded blocks will execute.
+  #
+  def test_yield_and_notify
+    a = 0
+    EM.run {
+      n = EM.spawn {
+        a += 10
+        EM.yield_and_notify {
+          a += 20
+          EM.yield_and_notify {
+            a += 30
+            EM.stop
+          }
+        }
+      }
+      n.notify
+    }
+    assert_equal( 60, a )
+  end
+
+  # resume is an alias for notify.
+  #
+  def test_resume
+    EM.run {
+      n = EM.spawn {EM.stop}
+      n.resume
+    }
+    assert true
+  end
+
+  # run is an idiomatic alias for notify.
+  #
+  def test_run
+    EM.run {
+      (EM.spawn {EM.stop}).run
+    }
+    assert true
+  end
+
+
+  # Clones the ping-pong example from the Erlang tutorial, in much less code.
+  # Illustrates that a spawned block executes in the context of a SpawnableObject.
+  # (Meaning, we can pass self as a parameter to another process that can then
+  # notify us.)
+  #
+  def test_ping_pong
+    n_pongs = 0
+    EM.run {
+      pong = EM.spawn {|x, ping|
+        n_pongs += 1
+        ping.notify( x-1 )
+      }
+      ping = EM.spawn {|x|
+        if x > 0
+          pong.notify x, self
+        else
+          EM.stop
+        end
+      }
+      ping.notify 3
+    }
+    assert_equal( 3, n_pongs )
+  end
+
+  # Illustrates that you can call notify inside a notification, and it will cause
+  # the currently-executing process to be re-notified. Of course, the new notification
+  # won't run until sometime after the current one completes.
+  #
+  def test_self_notify
+    n = 0
+    EM.run {
+      pid = EM.spawn {|x|
+        if x > 0
+          n += x
+          notify( x-1 )
+        else
+          EM.stop
+        end
+      }
+      pid.notify 3
+    }
+    assert_equal( 6, n )
+  end
+
+
+  # Illustrates that the block passed to #spawn executes in the context of a
+  # SpawnedProcess object, NOT in the local context. This can often be deceptive.
+  #
+  class BlockScopeTest
+    attr_reader :var
+    def run
+      # The following line correctly raises a NameError.
+      # The problem is that the programmer expected the spawned block to
+      # execute in the local context, but it doesn't.
+      #
+      # (EM.spawn { do_something }).notify ### NO! BAD!
+
+
+
+      # The following line correctly passes self as a parameter to the
+      # notified process.
+      #
+      (EM.spawn {|obj| obj.do_something }).notify(self)
+
+
+
+      # Here's another way to do it. This works because "myself" is bound
+      # in the local scope, unlike "self," so the spawned block sees it.
+      #
+      myself = self
+      (EM.spawn { myself.do_something }).notify
+
+
+
+      # And we end the loop.
+      # This is a tangential point, but observe that #notify never blocks.
+      # It merely appends a message to the internal queue of a spawned process
+      # and returns. As it turns out, the reactor processes notifications for ALL
+      # spawned processes in the order that #notify is called. So there is a
+      # reasonable expectation that the process which stops the reactor will
+      # execute after the previous ones in this method. HOWEVER, this is NOT
+      # a documented behavior and is subject to change.
+      #
+      (EM.spawn {EM.stop}).notify
+    end
+    def do_something
+      @var ||= 0
+      @var += 100
+    end
+  end
+
+  def test_block_scope
+    bs = BlockScopeTest.new
+    EM.run {
+      bs.run
+    }
+    assert_equal( 200, bs.var )
+  end
+
+end

data/tests/test_ssl_args.rb

@@ -0,0 +1,78 @@
+require "test/unit"
+require 'tempfile'
+
+require 'em_test_helper'
+
+module EM
+  def self._set_mocks
+    class <<self
+      alias set_tls_parms_old set_tls_parms
+      alias start_tls_old start_tls
+      begin
+        old, $VERBOSE = $VERBOSE, nil
+        def set_tls_parms *args; end
+        def start_tls *args; end
+      ensure
+        $VERBOSE = old
+      end
+    end
+  end
+
+  def self._clear_mocks
+    class <<self
+      begin
+        old, $VERBOSE = $VERBOSE, nil
+        alias set_tls_parms set_tls_parms_old
+        alias start_tls start_tls_old
+      ensure
+        $VERBOSE = old
+      end
+    end
+  end
+end
+
+  
+
+class TestSslArgs < Test::Unit::TestCase
+  def setup
+    EM._set_mocks
+  end
+  
+  def teardown
+    EM._clear_mocks
+  end
+  
+  def test_tls_params_file_doesnt_exist
+    priv_file, cert_file = 'foo_priv_key', 'bar_cert_file'
+    [priv_file, cert_file].all? do |f|
+      assert(!File.exists?(f), "Cert file #{f} seems to exist, and should not for the tests")
+    end
+    
+    # associate_callback_target is a pain! (build!)
+    conn = EM::Connection.new('foo')
+    
+    assert_raises(EM::FileNotFoundException) do
+      conn.start_tls(:private_key_file => priv_file)
+    end
+    assert_raises(EM::FileNotFoundException) do
+      conn.start_tls(:cert_chain_file => cert_file)
+    end
+    assert_raises(EM::FileNotFoundException) do
+      conn.start_tls(:private_key_file => priv_file, :cert_chain_file => cert_file)
+    end
+  end
+  
+  def test_tls_params_file_does_exist
+    priv_file = Tempfile.new('em_test')
+    cert_file = Tempfile.new('em_test')
+    priv_file_path = priv_file.path
+    cert_file_path = cert_file.path
+    conn = EM::Connection.new('foo')
+    params = {:private_key_file => priv_file_path, :cert_chain_file => cert_file_path}
+    begin
+      conn.start_tls params
+    rescue Object
+      assert(false, 'should not have raised an exception')
+    end
+  end
+end if EM.ssl?

data/tests/test_ssl_echo_data.rb

@@ -0,0 +1,60 @@
+require 'em_test_helper'
+
+class TestSSLEchoData < Test::Unit::TestCase
+  def setup
+      $dir = File.dirname(File.expand_path(__FILE__)) + '/'
+  end
+
+  module SslEchoServer
+    def post_init
+      start_tls(:private_key_file => $dir+'server.key', :cert_chain_file => $dir+'server.crt')
+    end
+
+    def receive_data data
+      send_data data
+    end
+
+  end
+
+  module SslEchoClient
+    def connection_completed
+      start_tls
+    end
+
+    def ssl_handshake_completed
+      send_data $expected_return_data[$index]
+      $index += 1
+    end
+
+    def receive_data data
+      $actual_return_data ||= []
+      $actual_return_data << data
+      if $index < 10
+        send_data $expected_return_data[$index]
+        $index += 1
+      else
+        @stopping_on_purpose = true
+        EM.stop
+      end
+    end
+
+    def unbind
+      fail "unexpected socket close" unless @stopping_on_purpose
+    end
+
+  end
+
+  def test_ssl_echo_data
+    $expected_return_data = (1..10).map {|n| "Hello, world! (#{n})"}
+    $index = 0
+
+    EM.run {
+      EM.add_timer(12) { fail "TIMEOUT" }
+      EM.start_server("127.0.0.1", 9999, SslEchoServer)
+      EM.connect("127.0.0.1", 9999, SslEchoClient)
+    }
+
+    assert_equal($expected_return_data, $actual_return_data)
+  end
+
+end if EM.ssl?

data/tests/test_ssl_methods.rb

@@ -0,0 +1,56 @@
+require 'em_test_helper'
+
+class TestSSLMethods < Test::Unit::TestCase
+  def setup
+      $dir = File.dirname(File.expand_path(__FILE__)) + '/'
+      $client_cert_from_file = File.read($dir+'client.crt')
+      $server_cert_from_file = File.read($dir+'server.crt')
+  end
+
+  module ServerHandler
+
+    def post_init
+      start_tls(:private_key_file => $dir+'server.key', :cert_chain_file => $dir+'server.crt', :verify_peer => true)
+    end
+
+    def ssl_handshake_completed
+      $server_called_back = true
+      $client_cert_value = get_peer_cert
+    end
+
+    def ssl_verify_peer cert
+      true
+    end
+  end
+
+  module ClientHandler
+
+    def post_init
+      start_tls(:private_key_file => $dir+'client.key', :cert_chain_file => $dir+'client.crt')
+    end
+
+    def ssl_handshake_completed
+      $client_called_back = true
+      $server_cert_value = get_peer_cert
+      EM.stop_event_loop
+    end
+
+  end
+
+  def test_ssl_methods
+    $server_called_back, $client_called_back = false, false
+    $server_cert_value, $client_cert_value = nil, nil
+
+    EM.run {
+      EM.start_server("127.0.0.1", 9999, ServerHandler)
+      EM.connect("127.0.0.1", 9999, ClientHandler)
+    }
+
+    assert($server_called_back)
+    assert($client_called_back)
+
+    assert_equal($server_cert_from_file, $server_cert_value.gsub("\r", ""))
+    assert_equal($client_cert_from_file, $client_cert_value.gsub("\r", ""))
+  end
+
+end if EM.ssl?