eventmachine-mkroman 1.3.0.dev.1

data/tests/test_ssl_inline_cert.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+require_relative 'em_test_helper'
+
+class TestSSLInlineCert < Test::Unit::TestCase
+
+  require_relative 'em_ssl_handlers'
+  include EMSSLHandlers
+
+  CERT_FILE="#{__dir__}/client.crt"
+  PRIVATE_KEY_FILE="#{__dir__}/client.key"
+  ENCODED_KEY_FILE="#{__dir__}/encoded_client.key"
+  
+  CERT = File.read CERT_FILE
+  PRIVATE_KEY = File.read PRIVATE_KEY_FILE
+  ENCODED_KEY = File.read ENCODED_KEY_FILE
+
+  ENCODED_KEY_PASS = 'nicercat'
+  
+  def test_proper_key_required_for_client
+    # an assert in ssl.ccp code make this fail
+    # with no way of catching the error
+    omit_if(rbx?)
+
+    bad_key=PRIVATE_KEY.dup
+    assert(bad_key[100]!=4)
+    bad_key[100]='4'
+
+    server = { verify_peer: true, ssl_verify_result: true }
+
+    assert_raises EM::InvalidPrivateKey do
+      client_server Client, Server,
+                    client: { private_key: bad_key,
+                              cert: CERT },
+                    server: server
+    end
+    refute Client.handshake_completed?
+  end
+
+  def test_proper_key_required_for_server
+    # an assert in ssl.ccp code make this fail
+    # with no way of catching the error
+    omit_if(rbx?)
+
+    bad_key=PRIVATE_KEY.dup
+    assert(bad_key[100]!=4)
+    bad_key[100]='4'
+
+    server = { verify_peer: true, ssl_verify_result: true,
+               private_key: bad_key, cert: CERT }
+
+    assert_raises EM::InvalidPrivateKey do
+      client_server Client, Server,
+                    server: server
+    end
+    refute Server.handshake_completed?
+  end
+
+  def test_accept_client_key_inline_cert_inline
+    omit_if(rbx?)
+
+    server = { verify_peer: true, ssl_verify_result: true }
+    client = { private_key: PRIVATE_KEY,
+               cert: CERT }
+
+    client_server Client, Server,
+                  client: client,
+                  server: server
+
+    assert Client.handshake_completed?
+    assert Server.handshake_completed?
+    assert_equal CERT, Server.cert
+  end
+
+  def test_accept_server_key_inline_cert_inline
+    omit_if(rbx?)
+
+    client = { verify_peer: true, ssl_verify_result: true }
+    server = { private_key: PRIVATE_KEY,
+               cert: CERT }
+
+    client_server Client, Server,
+                  client: client,
+                  server: server
+
+    assert Client.handshake_completed?
+    assert Server.handshake_completed?
+    assert_equal CERT, Client.cert
+  end
+
+  def test_accept_client_encoded_key_inline_cert_inlince
+    omit_if(rbx?)
+
+    server = { verify_peer: true, ssl_verify_result: true }
+    client = { private_key: ENCODED_KEY,
+               private_key_pass: ENCODED_KEY_PASS,
+               cert: CERT }
+
+    client_server Client, Server,
+                  client: client,
+                  server: server
+
+    assert Client.handshake_completed?
+    assert Server.handshake_completed?
+    assert_equal CERT, Server.cert
+  end
+
+  def test_accept_server_encoded_key_inline_cert_inlince
+    omit_if(rbx?)
+
+    client = { verify_peer: true, ssl_verify_result: true }
+    server = { private_key: ENCODED_KEY,
+               private_key_pass: ENCODED_KEY_PASS,
+               cert: CERT }
+
+    client_server Client, Server,
+                  client: client,
+                  server: server
+
+    assert Client.handshake_completed?
+    assert Server.handshake_completed?
+    assert_equal CERT, Client.cert
+  end
+
+  def test_accept_client_key_from_file_cert_inline
+    omit_if(rbx?)
+
+    server = { verify_peer: true, ssl_verify_result: true }
+    client = { private_key_file: PRIVATE_KEY_FILE,
+               cert: CERT }
+
+    client_server Client, Server,
+                  client: client,
+                  server: server
+
+    assert Client.handshake_completed?
+    assert Server.handshake_completed?
+    assert_equal CERT, Server.cert
+  end
+
+  def test_accept_server_key_from_file_cert_inline
+    omit_if(rbx?)
+
+    client = { verify_peer: true, ssl_verify_result: true }
+    server = { private_key_file: PRIVATE_KEY_FILE,
+               cert: CERT }
+
+    client_server Client, Server,
+                  client: client,
+                  server: server
+
+    assert Client.handshake_completed?
+    assert Server.handshake_completed?
+    assert_equal CERT, Client.cert
+  end
+
+  def test_accept_client_key_inline_cert_from_file
+    omit_if(rbx?)
+
+    server = { verify_peer: true, ssl_verify_result: true }
+    client = { private_key: PRIVATE_KEY,
+               cert_chain_file: CERT_FILE }
+
+    client_server Client, Server,
+                  client: client,
+                  server: server
+
+    assert Client.handshake_completed?
+    assert Server.handshake_completed?
+    assert_equal CERT, Server.cert
+  end
+
+  def test_accept_server_key_inline_cert_from_file
+    omit_if(rbx?)
+
+    client = { verify_peer: true, ssl_verify_result: true }
+    server = { private_key: PRIVATE_KEY,
+               cert_chain_file: CERT_FILE }
+
+    client_server Client, Server,
+                  client: client,
+                  server: server
+
+    assert Client.handshake_completed?
+    assert Server.handshake_completed?
+    assert_equal CERT, Client.cert
+  end
+
+  def test_accept_client_encoded_key_inline_cert_from_file
+    omit_if(rbx?)
+
+    server = { verify_peer: true, ssl_verify_result: true }
+    client = { private_key: ENCODED_KEY,
+               private_key_pass: ENCODED_KEY_PASS,
+               cert_chain_file: CERT_FILE }
+
+    client_server Client, Server,
+                  client: client,
+                  server: server
+
+    assert Client.handshake_completed?
+    assert Server.handshake_completed?
+    assert_equal CERT, Server.cert
+  end
+
+  def test_accept_server_encoded_key_inline_cert_from_file
+    omit_if(rbx?)
+
+    client = { verify_peer: true, ssl_verify_result: true}
+    server = { private_key: ENCODED_KEY,
+               private_key_pass: ENCODED_KEY_PASS,
+               cert_chain_file: CERT_FILE }
+
+    client_server Client, Server,
+                  client: client,
+                  server: server
+
+    assert Client.handshake_completed?
+    assert Server.handshake_completed?
+    assert_equal CERT, Client.cert
+  end
+end if EM.ssl?

data/tests/test_ssl_methods.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'em_test_helper'
+
+class TestSSLMethods < Test::Unit::TestCase
+
+  require_relative 'em_ssl_handlers'
+  include EMSSLHandlers
+
+  def test_ssl_methods
+    omit_if(rbx?)
+
+    client_server
+    
+    assert Server.handshake_completed?
+    assert Client.handshake_completed?
+
+    assert Server.cert_value.is_a? NilClass
+    assert Client.cert_value.is_a? String
+
+    assert Client.cipher_bits > 0
+    assert_equal Client.cipher_bits, Server.cipher_bits
+
+    assert Client.cipher_name.length > 0
+    assert_match(/AES/, Client.cipher_name)
+    assert_equal Client.cipher_name, Server.cipher_name
+
+    assert Client.cipher_protocol.start_with? "TLS"
+    assert_equal Client.cipher_protocol, Server.cipher_protocol
+  end
+end  if EM.ssl?

data/tests/test_ssl_protocols.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require_relative 'em_test_helper'
+
+# For OpenSSL 1.1.0 and later, cipher_protocol returns single cipher, older
+# versions return "TLSv1/SSLv3"
+# TLSv1.1 handshake_completed Server/Client callback order is reversed from
+# older protocols
+
+class TestSSLProtocols < Test::Unit::TestCase
+
+  require_relative 'em_ssl_handlers'
+  include EMSSLHandlers
+
+  # We're checking for whether Context min_version= & max_version= are defined, but
+  # JRuby has a bug where they're defined, but the private method they call isn't
+  RUBY_SSL_GE_2_1 = OpenSSL::SSL::SSLContext.private_instance_methods(false).include?(:set_minmax_proto_version)
+
+  def test_invalid_ssl_version
+    assert_raises(RuntimeError, "Unrecognized SSL/TLS Version: badinput") do
+      client = { ssl_version: %w(tlsv1 badinput) }
+      server = { ssl_version: %w(tlsv1 badinput) }
+      client_server client: client, server: server
+    end
+  end
+
+  def test_any_to_v3
+    omit("SSLv3 is (correctly) unavailable") if EM::OPENSSL_NO_SSL3
+    client_server client: TLS_ALL, server: SSL_3
+    assert Client.handshake_completed?
+    assert Server.handshake_completed?
+  end
+
+  def test_any_to_tlsv1_2
+    client_server client: TLS_ALL, server: TLS_1_2
+    assert Client.handshake_completed?
+    assert Server.handshake_completed?
+    if IS_SSL_GE_1_1
+      assert_equal "TLSv1.2", Client.cipher_protocol
+    end
+  end
+
+  def test_case_insensitivity
+    lower_case = SSL_AVAIL.map { |p| p.downcase }
+    client = { ssl_version: %w(tlsv1_2) }
+    server = { ssl_version: lower_case  }
+    client_server client: client, server: server
+    assert Client.handshake_completed?
+    assert Server.handshake_completed?
+  end
+
+  def test_v3_to_any
+    omit("SSLv3 is (correctly) unavailable") if EM::OPENSSL_NO_SSL3
+    client_server client: SSL_3, server: TLS_ALL
+    assert Client.handshake_completed?
+    assert Server.handshake_completed?
+  end
+
+  def test_tlsv1_2_to_any
+    client_server client: TLS_1_2, server: TLS_ALL
+    assert Client.handshake_completed?
+    assert Server.handshake_completed?
+    if IS_SSL_GE_1_1
+      assert_equal "TLSv1.2", Server.cipher_protocol
+    end
+  end
+
+  def test_v3_to_v3
+    omit("SSLv3 is (correctly) unavailable") if EM::OPENSSL_NO_SSL3
+    client_server client: SSL_3, server: SSL_3
+    assert Client.handshake_completed?
+    assert Server.handshake_completed?
+  end
+
+  def test_tlsv1_2_to_tlsv1_2
+    client_server client: TLS_1_2, server: TLS_1_2
+    assert Client.handshake_completed?
+    assert Server.handshake_completed?
+    if IS_SSL_GE_1_1
+      assert_equal "TLSv1.2", Client.cipher_protocol
+      assert_equal "TLSv1.2", Server.cipher_protocol
+    end
+  end
+
+  def test_tlsv1_3_to_tlsv1_3
+    omit("TLSv1_3 is unavailable") unless EM.const_defined? :EM_PROTO_TLSv1_3
+    client_server client: TLS_1_3, server: TLS_1_3
+    assert Client.handshake_completed?
+    assert Server.handshake_completed?
+    assert_equal "TLSv1.3", Client.cipher_protocol
+    assert_equal "TLSv1.3", Server.cipher_protocol
+  end
+
+  def test_any_to_any
+    client_server client: TLS_ALL, server: TLS_ALL
+    assert Client.handshake_completed?
+    assert Server.handshake_completed?
+    if IS_SSL_GE_1_1
+      best_protocol = SSL_AVAIL.last.tr "_", "."
+      assert_equal best_protocol, Client.cipher_protocol
+      assert_equal best_protocol, Server.cipher_protocol
+    end
+  end
+
+  def test_default_to_default
+    client_server
+    assert Client.handshake_completed?
+    assert Server.handshake_completed?
+    if IS_SSL_GE_1_1
+      best_protocol = SSL_AVAIL.last.tr "_", "."
+      assert_equal best_protocol, Client.cipher_protocol
+      assert_equal best_protocol, Server.cipher_protocol
+    end
+  end
+
+  def external_client(ext_min, ext_max, ext_ssl, server)
+    EM.run do
+#        setup_timeout 2
+      EM.start_server IP, PORT, Server, server.merge( { stop_after_handshake: true} )
+      EM.defer do
+        sock = TCPSocket.new IP, PORT
+        ctx = OpenSSL::SSL::SSLContext.new
+        if RUBY_SSL_GE_2_1
+          ctx.min_version = ext_min if ext_min
+          ctx.max_version = ext_max if ext_max
+        else
+          ctx.ssl_version = ext_ssl
+        end
+        ssl = OpenSSL::SSL::SSLSocket.new(sock, ctx)
+        ssl.connect
+        ssl.close rescue nil
+        sock.close rescue nil
+      end
+    end
+    assert Server.handshake_completed?
+  end
+
+  def test_v3_with_external_client
+    omit("SSLv3 is (correctly) unavailable") if EM::OPENSSL_NO_SSL3
+    external_client nil, nil, :SSLv3_client, SSL_3
+  end
+
+  # Fixed Server
+  def test_tlsv1_2_with_external_client
+    external_client nil, nil, :SSLv23_client, TLS_1_2
+  end
+
+  def test_tlsv1_3_with_external_client
+    omit("TLSv1_3 is unavailable") unless EM.const_defined?(:EM_PROTO_TLSv1_3) &&
+      OpenSSL::SSL.const_defined?(:TLS1_3_VERSION)
+    external_client nil, nil, :SSLv23_client, TLS_1_3
+  end
+
+  # Fixed Client
+  def test_any_with_external_client_tlsv1_2
+    external_client :TLS1_2, :TLS1_2, :TLSv1_2_client, TLS_ALL
+  end
+
+  def test_any_with_external_client_tlsv1_3
+    omit("TLSv1_3 is unavailable") unless EM.const_defined? :EM_PROTO_TLSv1_3
+    external_client :TLS1_3, :TLS1_3, :TLSv1_2_client, TLS_ALL
+  end
+
+  # Refuse a client?
+  def test_tlsv1_2_required_with_external_client
+    EM.run do
+      n = 0
+      EM.add_periodic_timer(0.5) do
+        n += 1
+        (EM.stop rescue nil) if n == 2
+      end
+      EM.start_server IP, PORT, Server, TLS_1_2.merge( { stop_after_handshake: true} )
+      EM.defer do
+        sock = TCPSocket.new IP, PORT
+        ctx = OpenSSL::SSL::SSLContext.new
+        if RUBY_SSL_GE_2_1
+          ctx.max_version = :TLS1_1
+        else
+          ctx.ssl_version = :TLSv1_client
+        end
+        ssl = OpenSSL::SSL::SSLSocket.new sock, ctx
+        assert_raise(OpenSSL::SSL::SSLError) { ssl.connect }
+        ssl.close  rescue nil
+        sock.close rescue nil
+        EM.stop    rescue nil
+      end
+    end
+    refute Server.handshake_completed?
+  end
+end if EM.ssl?

data/tests/test_ssl_verify.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require_relative 'em_test_helper'
+
+class TestSSLVerify < Test::Unit::TestCase
+
+  require_relative 'em_ssl_handlers'
+  include EMSSLHandlers
+
+  CERT_FROM_FILE = File.read "#{__dir__}/client.crt"
+
+  CERT_CONFIG = { private_key_file: "#{__dir__}/client.key",
+                  cert_chain_file:  "#{__dir__}/client.crt" }
+
+  ENCODED_CERT_CONFIG = { private_key_file: "#{__dir__}/encoded_client.key",
+                          private_key_pass: 'nicercat',
+                          cert_chain_file:  "#{__dir__}/client.crt" }
+
+  def test_fail_no_peer_cert
+    omit_if(rbx?)
+
+    server = { verify_peer: true, fail_if_no_peer_cert: true,
+      ssl_verify_result: "|RAISE|Verify peer should not get called for a client without a certificate" }
+
+    client_server Client, Server, server: server
+
+    refute Client.handshake_completed? unless "TLSv1.3" == Client.cipher_protocol
+    refute Server.handshake_completed?
+  end
+
+  def test_accept_server
+    omit_if(EM.library_type == :pure_ruby) # Server has a default cert chain
+    omit_if(rbx?)
+
+    server = { verify_peer: true, ssl_verify_result: true }
+
+    client_server Client, Server, client: CERT_CONFIG, server: server
+
+    assert_equal CERT_FROM_FILE, Server.cert
+    assert Client.handshake_completed?
+    assert Server.handshake_completed?
+  end
+
+  def test_accept_client
+    omit_if(EM.library_type == :pure_ruby) # Server has a default cert chain
+    omit_if(rbx?)
+
+    client = { verify_peer: true, ssl_verify_result: true }
+
+    client_server Client, Server, server: CERT_CONFIG, client: client
+
+    assert_equal CERT_FROM_FILE, Client.cert
+    assert Client.handshake_completed?
+    assert Server.handshake_completed?
+  end
+
+  def test_encoded_accept_server
+    omit_if(EM.library_type == :pure_ruby) # Server has a default cert chain
+    omit_if(rbx?)
+
+    server = { verify_peer: true, ssl_verify_result: true }
+
+    client_server Client, Server, client: ENCODED_CERT_CONFIG, server: server
+
+    assert Client.handshake_completed?
+    assert Server.handshake_completed?
+    assert_equal CERT_FROM_FILE, Server.cert
+  end
+
+  def test_encoded_accept_client
+    omit_if(EM.library_type == :pure_ruby) # Server has a default cert chain
+    omit_if(rbx?)
+
+    client = { verify_peer: true, ssl_verify_result: true }
+
+    client_server Client, Server, server: ENCODED_CERT_CONFIG, client: client
+
+    assert Client.handshake_completed?
+    assert Server.handshake_completed?
+    assert_equal CERT_FROM_FILE, Client.cert
+  end
+
+  def test_deny_server
+    omit_if(EM.library_type == :pure_ruby) # Server has a default cert chain
+    omit_if(rbx?)
+
+    server = { verify_peer: true, ssl_verify_result: false }
+
+    client_server Client, Server, client: CERT_CONFIG, server: server
+
+    assert_equal CERT_FROM_FILE, Server.cert
+    refute Client.handshake_completed? unless "TLSv1.3" == Client.cipher_protocol
+    refute Server.handshake_completed?
+  end
+
+  def test_deny_client
+    omit_if(EM.library_type == :pure_ruby) # Server has a default cert chain
+    omit_if(rbx?)
+
+    client = { verify_peer: true, ssl_verify_result: false }
+
+    client_server Client, Server, server: CERT_CONFIG, client: client
+
+    refute Client.handshake_completed? unless "TLSv1.3" == Client.cipher_protocol
+    refute Server.handshake_completed?
+    assert_equal CERT_FROM_FILE, Client.cert
+  end
+end if EM.ssl?

data/tests/test_stomp.rb

@@ -0,0 +1,38 @@
+require_relative 'em_test_helper'
+
+class TestStomp < Test::Unit::TestCase
+  CONTENT_LENGTH_REGEX = /^content-length: (\d+)$/
+
+  def bytesize(str)
+    str = str.to_s
+    size = str.bytesize if str.respond_to?(:bytesize) # bytesize added in 1.9
+    size || str.size
+  end
+
+  class TStomp
+    include EM::P::Stomp
+
+    def last_sent_content_length
+      @sent && Integer(@sent[CONTENT_LENGTH_REGEX, 1])
+    end
+
+    def send_data(string)
+      @sent = string
+    end
+  end
+
+  def test_content_length_in_bytes
+    connection = TStomp.new
+
+    queue = "queue"
+    failure_message = "header content-length is not the byte size of last sent body"
+
+    body = "test"
+    connection.send queue, body
+    assert_equal bytesize(body), connection.last_sent_content_length, failure_message
+
+    body = "test\u221A"
+    connection.send queue, body
+    assert_equal bytesize(body), connection.last_sent_content_length, failure_message
+  end
+end

data/tests/test_system.rb

@@ -0,0 +1,46 @@
+# coding: utf-8
+require_relative 'em_test_helper'
+
+class TestSystem < Test::Unit::TestCase
+  def setup
+    @filename = File.expand_path("../я манал dump.txt", __FILE__)
+    @test_data = 'a' * 100
+    File.open(@filename, 'w'){|f| f.write(@test_data)}
+  end
+
+  def test_system
+    omit_if(windows?)
+
+    result = nil
+    status = nil
+    EM.run {
+      EM.system('cat', @filename){|out, state|
+        result = out
+        status = state.exitstatus
+        EM.stop
+      }
+    }
+    assert_equal(0, status)
+    assert_equal(@test_data, result)
+  end
+
+  def test_system_with_string
+    omit_if(windows?)
+
+    result = nil
+    status = nil
+    EM.run {
+      EM.system("cat '#@filename'"){|out, state|
+        result = out
+        status = state.exitstatus
+        EM.stop
+      }
+    }
+    assert_equal(0, status)
+    assert_equal(@test_data, result)
+  end
+
+  def teardown
+    File.unlink(@filename)
+  end
+end

data/tests/test_threaded_resource.rb

@@ -0,0 +1,68 @@
+require_relative 'em_test_helper'
+
+class TestThreadedResource < Test::Unit::TestCase
+  def object
+    @object ||= {}
+  end
+
+  def resource
+    @resource = EM::ThreadedResource.new do
+      object
+    end
+  end
+
+  def teardown
+    resource.shutdown
+  end
+
+  def test_dispatch_completion
+    EM.run do
+      EM.add_timer(3) do
+        EM.stop
+        if ENV['CI'].casecmp('true').zero? and RUBY_PLATFORM[/darwin/]
+          notify "Intermittent Travis MacOS: Resource dispatch timed out"
+          return
+        else
+          assert false, 'Resource dispatch timed out'
+        end
+      end
+      completion = resource.dispatch do |o|
+        o[:foo] = :bar
+        :foo
+      end
+      completion.callback do |result|
+        assert_equal :foo, result
+        EM.stop
+      end
+      completion.errback do |error|
+        EM.stop
+        assert false, "Unexpected error: #{error.message}"
+      end
+    end
+    assert_equal :bar, object[:foo]
+  end
+
+  def test_dispatch_failure
+    completion = resource.dispatch do |o|
+      raise 'boom'
+    end
+    completion.errback do |error|
+      assert_kind_of RuntimeError, error
+      assert_equal 'boom', error.message
+    end
+  end
+
+  def test_dispatch_threading
+    main = Thread.current
+    resource.dispatch do |o|
+      o[:dispatch_thread] = Thread.current
+    end
+    assert_not_equal main, object[:dispatch_thread]
+  end
+
+  def test_shutdown
+    # This test should get improved sometime. The method returning thread is
+    # NOT an api that will be maintained.
+    assert !resource.shutdown.alive?
+  end
+end