eventmachine-mkroman 1.3.0.dev.1

data/tests/test_sock_opt.rb

@@ -0,0 +1,53 @@
+require_relative 'em_test_helper'
+
+class TestSockOpt < Test::Unit::TestCase
+  def setup
+    assert(!EM.reactor_running?)
+    @port = next_port
+  end
+
+  def teardown
+    assert(!EM.reactor_running?)
+  end
+
+  def test_set_sock_opt
+    omit_if(windows?)
+    omit_if(!EM.respond_to?(:set_sock_opt))
+
+    val = nil
+    test_module = Module.new do
+      define_method :post_init do
+        val = set_sock_opt Socket::SOL_SOCKET, Socket::SO_BROADCAST, true
+        EM.stop
+      end
+    end
+
+    EM.run do
+      EM.start_server '127.0.0.1', @port
+      EM.connect '127.0.0.1', @port, test_module
+    end
+
+    assert_equal 0, val
+  end
+
+  def test_get_sock_opt
+    omit_if(windows?)
+    omit_if(!EM.respond_to?(:set_sock_opt))
+
+    val = nil
+    test_module = Module.new do
+      define_method :connection_completed do
+        val = get_sock_opt Socket::SOL_SOCKET, Socket::SO_ERROR
+        EM.stop
+      end
+    end
+
+    EM.run do
+      EM.start_server '127.0.0.1', @port
+      EM.connect '127.0.0.1', @port, test_module
+    end
+
+    assert_equal "\0\0\0\0", val
+  end
+
+end

data/tests/test_spawn.rb

@@ -0,0 +1,290 @@
+require_relative '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,70 @@
+# frozen_string_literal: true
+
+require_relative 'em_test_helper'
+require 'tempfile'
+
+class TestSSLArgs < Test::Unit::TestCase
+
+  require_relative 'em_ssl_handlers'
+  include EMSSLHandlers
+
+  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.exist?(f), "Cert file #{f} seems to exist, and should not for the tests")
+    end
+
+    assert_raises EM::FileNotFoundException do
+      client_server client: { private_key_file: priv_file }
+    end
+
+    assert_raises EM::FileNotFoundException do
+      client_server client: { cert_chain_file: cert_file }
+    end
+
+    assert_raises EM::FileNotFoundException do
+      client_server client: { private_key_file: priv_file, cert_chain_file: cert_file }
+    end
+  end
+
+  def test_tls_cert_not_defined_twice
+    cert_file_path="#{__dir__}/client.crt"
+    cert=File.read "#{__dir__}/client.crt"
+
+    assert_raises EM::BadCertParams do
+      client_server client: {cert: cert, cert_chain_file: cert_file_path}
+    end
+  end
+
+  def test_tls_key_not_defined_twice
+    cert_file_path="#{__dir__}/client.crt"
+    key_file_path="#{__dir__}/client.key"
+    key=File.read "#{__dir__}/client.key"
+
+    assert_raises EM::BadPrivateKeyParams do
+      client_server client: {private_key_file: key_file_path, private_key: key, cert_chain_file: cert_file_path}
+    end
+  end
+
+  def test_tls_key_requires_cert
+    #specifying a key but no cert will generate an error at SSL level
+    #with a misleading text
+    #140579476657920:error:1417A0C1:SSL routines:tls_post_process_client_hello:no shared cipher
+
+    assert_raises EM::BadParams do
+      client_server client: {private_key_file: "#{__dir__}/client.key"}
+    end
+  end
+
+  def _test_tls_params_file_improper
+    priv_file_path = Tempfile.new('em_test').path
+    cert_file_path = Tempfile.new('em_test').path
+    params = { private_key_file: priv_file_path,
+                cert_chain_file: cert_file_path }
+    begin
+      client_server client: params
+    rescue Object
+      assert false, 'should not have raised an exception'
+    end
+  end
+end if EM.ssl?

data/tests/test_ssl_dhparam.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative 'em_test_helper'
+
+class TestSSLDhParam < Test::Unit::TestCase
+
+  require_relative 'em_ssl_handlers'
+  include EMSSLHandlers
+
+  DH_PARAM_FILE = File.join(__dir__, 'dhparam.pem')
+
+  DH_1_2 =   { cipher_list: "DHE,EDH", ssl_version: %w(TLSv1_2) }
+  CLIENT_1_2 = { client_unbind: true,  ssl_version: %w(TLSv1_2) }
+
+  def test_no_dhparam
+    omit_if(EM.library_type == :pure_ruby) # DH will work with defaults
+    omit_if(rbx?)
+
+    client_server client: CLIENT_1_2, server: DH_1_2
+
+    refute Client.handshake_completed?
+    refute Server.handshake_completed?
+  end
+
+  def test_dhparam_1_2
+    omit_if(rbx?)
+
+    client_server client: CLIENT_1_2, server: DH_1_2.merge(dhparam: DH_PARAM_FILE)
+
+    assert Client.handshake_completed?
+    assert Server.handshake_completed?
+
+    assert Client.cipher_name.length > 0
+    assert_equal Client.cipher_name, Server.cipher_name
+
+    assert_match(/^(DHE|EDH)/, Client.cipher_name)
+  end
+
+  def test_dhparam_1_3
+    omit_if(rbx?)
+    omit("TLSv1_3 is unavailable") unless EM.const_defined? :EM_PROTO_TLSv1_3
+
+    client = { client_unbind: true, ssl_version: %w(TLSv1_3) }
+    server = { dhparam: DH_PARAM_FILE, cipher_list: "DHE,EDH", ssl_version: %w(TLSv1_3) }
+    client_server client: client, server: server
+
+    assert Client.handshake_completed?
+    assert Server.handshake_completed?
+
+    assert Client.cipher_name.length > 0
+    assert_equal Client.cipher_name, Server.cipher_name
+
+    # see https://wiki.openssl.org/index.php/TLS1.3#Ciphersuites
+    # may depend on OpenSSL build options
+    assert_equal "TLS_AES_256_GCM_SHA384", Client.cipher_name
+  end
+end if EM.ssl?

data/tests/test_ssl_ecdh_curve.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative 'em_test_helper'
+
+class TestSSLEcdhCurve < Test::Unit::TestCase
+
+  require_relative 'em_ssl_handlers'
+  include EMSSLHandlers
+
+  def test_no_ecdh_curve
+    omit_if(rbx?)
+    omit("OpenSSL 1.1.x (and later) auto selects curve") if IS_SSL_GE_1_1
+
+    client_server server: { cipher_list: "ECDH", ssl_version: %w(TLSv1_2) }
+
+    refute Client.handshake_completed?
+    refute Server.handshake_completed?
+  end
+
+  def test_ecdh_curve_tlsv1_2
+    omit_if(EM.library_type == :pure_ruby && RUBY_VERSION < "2.3.0")
+    omit_if(rbx?)
+
+    server = { cipher_list: "ECDH", ssl_version: %w(TLSv1_2) }
+    server.merge!(ecdh_curve: "prime256v1") unless IS_SSL_GE_1_1
+
+    client_server server: server
+
+    assert Client.handshake_completed?
+    assert Server.handshake_completed?
+
+    assert Client.cipher_name.length > 0
+    assert_equal Client.cipher_name, Server.cipher_name
+
+    assert_match(/^(AECDH|ECDHE)/, Client.cipher_name)
+  end
+
+  def test_ecdh_curve_tlsv1_3
+    omit_if(EM.library_type == :pure_ruby && RUBY_VERSION < "2.3.0")
+    omit_if(rbx?)
+    omit("TLSv1_3 is unavailable") unless EM.const_defined? :EM_PROTO_TLSv1_3
+
+    tls = { cipher_list: "ECDH", ssl_version: %w(TLSv1_3) }
+
+    client_server server: tls
+
+    assert Client.handshake_completed?
+    assert Server.handshake_completed?
+
+    assert Client.cipher_name.length > 0
+    assert_equal Client.cipher_name, Server.cipher_name
+
+    # see https://wiki.openssl.org/index.php/TLS1.3#Ciphersuites
+    # may depend on OpenSSL build options
+    assert_equal "TLS_AES_256_GCM_SHA384", Client.cipher_name
+  end
+end if EM.ssl?

data/tests/test_ssl_extensions.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'em_test_helper'
+
+class TestSSLExtensions < Test::Unit::TestCase
+
+  require_relative 'em_ssl_handlers'
+  include EMSSLHandlers
+
+  def test_tlsext_sni_hostname_1_2
+    client = { sni_hostname: 'example.com', ssl_version: %w(TLSv1_2) }
+    client_server client: client
+    assert Server.handshake_completed?
+    assert_equal 'example.com', Server.sni_hostname
+  end
+  
+  def test_tlsext_sni_hostname_1_3
+    omit("TLSv1_3 is unavailable") unless EM.const_defined? :EM_PROTO_TLSv1_3
+    client = { sni_hostname: 'example.com', ssl_version: %w(TLSv1_3) }
+    client_server client: client
+    assert Server.handshake_completed?
+    assert_equal 'example.com', Server.sni_hostname
+  end
+end if EM.ssl?