iruby 0.2.9 → 0.6.1

data/test/iruby/event_manager_test.rb

@@ -0,0 +1,92 @@
+module IRubyTest
+  class EventManagerTest < TestBase
+    def setup
+      @man = IRuby::EventManager.new([:foo, :bar])
+    end
+
+    def test_available_events
+      assert_equal([:foo, :bar],
+                   @man.available_events)
+    end
+
+    sub_test_case("#register") do
+      sub_test_case("known event name") do
+        def test_register
+          fn = ->() {}
+          assert_equal(fn,
+                       @man.register(:foo, &fn))
+        end
+      end
+
+      sub_test_case("unknown event name") do
+        def test_register
+          assert_raise_message("Unknown event name: baz") do
+            @man.register(:baz) {}
+          end
+        end
+      end
+    end
+
+    sub_test_case("#unregister") do
+      sub_test_case("no event is registered") do
+        def test_unregister
+          fn = ->() {}
+          assert_raise_message("Given callable object #{fn} is not registered as a foo callback") do
+            @man.unregister(:foo, fn)
+          end
+        end
+      end
+
+      sub_test_case("the registered callable is given") do
+        def test_unregister
+          results = { values: [] }
+          fn = ->(a) { values << a }
+
+          @man.register(:foo, &fn)
+
+          results[:retval] = @man.unregister(:foo, fn)
+
+          @man.trigger(:foo, 42)
+
+          assert_equal({
+                         values: [],
+                         retval: fn
+                       },
+                       results)
+        end
+      end
+    end
+
+    sub_test_case("#trigger") do
+      sub_test_case("no event is registered") do
+        def test_trigger
+          assert_nothing_raised do
+            @man.trigger(:foo)
+          end
+        end
+      end
+
+      sub_test_case("some events are registered") do
+        def test_trigger
+          values = []
+          @man.register(:foo) {|a| values << a }
+          @man.register(:foo) {|a| values << 10*a }
+          @man.register(:foo) {|a| values << 100+a }
+
+          @man.trigger(:foo, 5)
+
+          assert_equal([5, 50, 105],
+                       values)
+        end
+      end
+
+      sub_test_case("unknown event name") do
+        def test_trigger
+          assert_raise_message("Unknown event name: baz") do
+            @man.trigger(:baz, 100)
+          end
+        end
+      end
+    end
+  end
+end

data/test/iruby/jupyter_test.rb

@@ -0,0 +1,27 @@
+require 'iruby/jupyter'
+
+module IRubyTest
+  class JupyterDefaultKernelSpecDirectoryTest < TestBase
+    def setup
+      @kernel_spec = IRuby::Jupyter.kernelspec_dir
+    end
+
+    def test_default_windows
+      windows_only
+      appdata = IRuby::Jupyter.send :windows_user_appdata
+      assert_equal(File.join(appdata, 'jupyter/kernels'), @kernel_spec)
+    end
+
+    def test_default_apple
+      apple_only
+      assert_equal(File.expand_path('~/Library/Jupyter/kernels'), @kernel_spec)
+    end
+
+    def test_default_unix
+      unix_only
+      with_env('XDG_DATA_HOME' => nil) do
+        assert_equal(File.expand_path('~/.local/share/jupyter/kernels'), @kernel_spec)
+      end
+    end
+  end
+end

data/test/iruby/kernel_test.rb

@@ -0,0 +1,153 @@
+require "base64"
+
+module IRubyTest
+  class KernelTest < TestBase
+    def setup
+      super
+      with_session_adapter("test")
+      @kernel = IRuby::Kernel.instance
+    end
+
+    sub_test_case("iruby_initialized event") do
+      def setup
+        super
+        @initialized_kernel = nil
+        @callback = IRuby::Kernel.events.register(:initialized) do |kernel|
+          @initialized_kernel = kernel
+        end
+      end
+
+      def teardown
+        IRuby::Kernel.events.unregister(:initialized, @callback)
+      end
+
+      def test_iruby_initialized_event
+        with_session_adapter("test")
+        assert_same(IRuby::Kernel.instance, @initialized_kernel)
+      end
+    end
+
+    def test_execute_request
+      obj = Object.new
+
+      class << obj
+        def to_html
+          "<b>HTML</b>"
+        end
+
+        def inspect
+          "!!! inspect !!!"
+        end
+      end
+
+      ::IRubyTest.define_singleton_method(:test_object) { obj }
+
+      msg_types = []
+      execute_reply = nil
+      execute_result = nil
+      @kernel.session.adapter.send_callback = ->(sock, msg) do
+        header = msg[:header]
+        content = msg[:content]
+        msg_types << header["msg_type"]
+        case header["msg_type"]
+        when "execute_reply"
+          execute_reply = content
+        when "execute_result"
+          execute_result = content
+        end
+      end
+
+      msg = {
+        content: {
+          "code" => "IRubyTest.test_object",
+          "silent" => false,
+          "store_history" => false,
+          "user_expressions" => {},
+          "allow_stdin" => false,
+          "stop_on_error" => true,
+        }
+      }
+      @kernel.execute_request(msg)
+
+      assert_equal({
+                     msg_types: [ "execute_input", "execute_result", "execute_reply" ],
+                     execute_reply: {
+                       status: "ok",
+                       user_expressions: {},
+                     },
+                     execute_result: {
+                       data: {
+                         "text/html" => "<b>HTML</b>",
+                         "text/plain" => "!!! inspect !!!"
+                       },
+                       metadata: {},
+                     }
+                   },
+                   {
+                     msg_types: msg_types,
+                     execute_reply: {
+                       status: execute_reply["status"],
+                       user_expressions: execute_reply["user_expressions"]
+                     },
+                     execute_result: {
+                       data: execute_result["data"],
+                       metadata: execute_result["metadata"]
+                     }
+                   })
+    end
+
+    def test_events_around_of_execute_request
+      event_history = []
+
+      @kernel.events.register(:pre_execute) do
+        event_history << :pre_execute
+      end
+
+      @kernel.events.register(:pre_run_cell) do |exec_info|
+        event_history << [:pre_run_cell, exec_info]
+      end
+
+      @kernel.events.register(:post_execute) do
+        event_history << :post_execute
+      end
+
+      @kernel.events.register(:post_run_cell) do |result|
+        event_history << [:post_run_cell, result]
+      end
+
+      msg = {
+        content: {
+          "code" => "true",
+          "silent" => false,
+          "store_history" => false,
+          "user_expressions" => {},
+          "allow_stdin" => false,
+          "stop_on_error" => true,
+        }
+      }
+      @kernel.execute_request(msg)
+
+      msg = {
+        content: {
+          "code" => "true",
+          "silent" => true,
+          "store_history" => false,
+          "user_expressions" => {},
+          "allow_stdin" => false,
+          "stop_on_error" => true,
+        }
+      }
+      @kernel.execute_request(msg)
+
+      assert_equal([
+                     :pre_execute,
+                     [:pre_run_cell, IRuby::ExecutionInfo.new("true", false, false)],
+                     :post_execute,
+                     [:post_run_cell, true],
+                     :pre_execute,
+                     :post_execute
+                   ],
+                   event_history)
+    end
+  end
+end

data/test/iruby/mime_test.rb

@@ -0,0 +1,43 @@
+class IRubyTest::MimeTest < IRubyTest::TestBase
+  sub_test_case("IRuby::Display") do
+    sub_test_case(".display") do
+      sub_test_case("with mime type") do
+        test("text/html") do
+          html = "<b>Bold Text</b>"
+
+          obj = Object.new
+          obj.define_singleton_method(:to_s) { html }
+
+          res = IRuby::Display.display(obj, mime: "text/html")
+          assert_equal({ plain: obj.inspect,       html: html },
+                       { plain: res["text/plain"], html: res["text/html"] })
+        end
+
+        test("application/javascript") do
+          data = "alert('Hello World!')"
+          res = IRuby::Display.display(data, mime: "application/javascript")
+          assert_equal(data,
+                       res["application/javascript"])
+        end
+      end
+    end
+  end
+
+  sub_test_case("Rendering a file") do
+    def setup
+      @html = "<b>Bold Text</b>"
+      Dir.mktmpdir do |tmpdir|
+        @file = File.join(tmpdir, "test.html")
+        File.write(@file, @html)
+        yield
+      end
+    end
+
+    def test_display
+      File.open(@file, "rb") do |f|
+        res = IRuby::Display.display(f)
+        assert_equal(@html, res["text/html"])
+      end
+    end
+  end
+end

data/test/iruby/multi_logger_test.rb

@@ -1,8 +1,7 @@
 require 'stringio'
-require 'test_helper'
 require 'iruby/logger'
 
-class MultiLoggerTest < IRubyTest
+class IRubyTest::MultiLoggerTest < IRubyTest::TestBase
   def test_multilogger
     out, err = StringIO.new, StringIO.new
     logger = IRuby::MultiLogger.new(Logger.new(out), Logger.new(err))

data/test/iruby/session_adapter/cztop_adapter_test.rb

@@ -0,0 +1,20 @@
+require_relative 'session_adapter_test_base'
+require 'iruby'
+
+module IRubyTest
+  if ENV['IRUBY_TEST_SESSION_ADAPTER_NAME'] == 'cztop'
+    class CztopAdapterTest < SessionAdapterTestBase
+      def adapter_class
+        IRuby::SessionAdapter::CztopAdapter
+      end
+
+      def test_send
+        assert(adapter_class.available?)
+      end
+
+      def test_recv
+        omit
+      end
+    end
+  end
+end

data/test/iruby/session_adapter/ffirzmq_adapter_test.rb

@@ -0,0 +1,20 @@
+require_relative 'session_adapter_test_base'
+require 'iruby'
+
+module IRubyTest
+  if ENV['IRUBY_TEST_SESSION_ADAPTER_NAME'] == 'ffi-rzmq'
+    class FfirzmqAdapterTest < SessionAdapterTestBase
+      def adapter_class
+        IRuby::SessionAdapter::FfirzmqAdapter
+      end
+
+      def test_send
+        assert(adapter_class.available?)
+      end
+
+      def test_recv
+        omit
+      end
+    end
+  end
+end

data/test/iruby/session_adapter/session_adapter_test_base.rb

@@ -0,0 +1,27 @@
+module IRubyTest
+  class SessionAdapterTestBase < TestBase
+    # https://jupyter-client.readthedocs.io/en/stable/kernels.html#connection-files
+    def make_connection_config
+      {
+        "control_port" => 50160,
+        "shell_port" => 57503,
+        "transport" => "tcp",
+        "signature_scheme" => "hmac-sha256",
+        "stdin_port" => 52597,
+        "hb_port" => 42540,
+        "ip" => "127.0.0.1",
+        "iopub_port" => 40885,
+        "key" => "a0436f6c-1916-498b-8eb9-e81ab9368e84"
+      }
+    end
+
+    def setup
+      @config = make_connection_config
+      @session_adapter = adapter_class.new(@config)
+
+      unless adapter_class.available?
+        omit("#{@session_adapter.name} is unavailable")
+      end
+    end
+  end
+end

data/test/iruby/session_adapter_test.rb

@@ -0,0 +1,91 @@
+module IRubyTest
+  class SessionAdapterTest < TestBase
+    def test_available_p_return_false_when_load_error
+      subclass = Class.new(IRuby::SessionAdapter::BaseAdapter)
+      class << subclass
+        def load_requirements
+          raise LoadError
+        end
+      end
+      refute subclass.available?
+    end
+
+    def test_select_adapter_class_with_cztop
+      assert_rr do
+        stub(IRuby::SessionAdapter::CztopAdapter).available? { true }
+        stub(IRuby::SessionAdapter::FfirzmqAdapter).available? { false }
+        stub(IRuby::SessionAdapter::PyzmqAdapter).available? { false }
+
+        cls = IRuby::SessionAdapter.select_adapter_class
+        assert_equal IRuby::SessionAdapter::CztopAdapter, cls
+      end
+    end
+
+    def test_select_adapter_class_with_ffirzmq
+      assert_rr do
+        stub(IRuby::SessionAdapter::FfirzmqAdapter).available? { true }
+        stub(IRuby::SessionAdapter::CztopAdapter).available? { false }
+        stub(IRuby::SessionAdapter::PyzmqAdapter).available? { false }
+
+        cls = IRuby::SessionAdapter.select_adapter_class
+        assert_equal IRuby::SessionAdapter::FfirzmqAdapter, cls
+      end
+    end
+
+    def test_select_adapter_class_with_pyzmq
+      omit("pyzmq adapter is disabled")
+      assert_rr do
+        stub(IRuby::SessionAdapter::PyzmqAdapter).available? { true }
+        stub(IRuby::SessionAdapter::FfirzmqAdapter).available? { false }
+        stub(IRuby::SessionAdapter::CztopAdapter).available? { false }
+
+        cls = IRuby::SessionAdapter.select_adapter_class
+        assert_equal IRuby::SessionAdapter::PyzmqAdapter, cls
+      end
+    end
+
+    def test_select_adapter_class_with_env
+      with_env('IRUBY_SESSION_ADAPTER' => 'cztop') do
+        assert_rr do
+          stub(IRuby::SessionAdapter::CztopAdapter).available? { true }
+          assert_equal IRuby::SessionAdapter::CztopAdapter, IRuby::SessionAdapter.select_adapter_class
+        end
+
+        assert_rr do
+          stub(IRuby::SessionAdapter::CztopAdapter).available? { false }
+          assert_raises IRuby::SessionAdapterNotFound do
+            IRuby::SessionAdapter.select_adapter_class
+          end
+        end
+      end
+
+      with_env('IRUBY_SESSION_ADAPTER' => 'ffi-rzmq') do
+        assert_rr do
+          stub(IRuby::SessionAdapter::FfirzmqAdapter).available? { true }
+          assert_equal IRuby::SessionAdapter::FfirzmqAdapter, IRuby::SessionAdapter.select_adapter_class
+        end
+
+        assert_rr do
+          stub(IRuby::SessionAdapter::FfirzmqAdapter).available? { false }
+          assert_raises IRuby::SessionAdapterNotFound do
+            IRuby::SessionAdapter.select_adapter_class
+          end
+        end
+      end
+
+      with_env('IRUBY_SESSION_ADAPTER' => 'pyzmq') do
+        # pyzmq adapter is disabled
+        #
+        # IRuby::SessionAdapter::PyzmqAdapter.stub :available?, true do
+        #   assert_equal IRuby::SessionAdapter::PyzmqAdapter, IRuby::SessionAdapter.select_adapter_class
+        # end
+        #
+        # IRuby::SessionAdapter::PyzmqAdapter.stub :available?, false do
+        #   assert_raises IRuby::SessionAdapterNotFound do
+        #     IRuby::SessionAdapter.select_adapter_class
+        #   end
+        # end
+      end
+    end
+  end
+end