iruby 0.4.0 → 0.7.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

@@ -1,4 +1,3 @@
-require 'test_helper'
 require 'iruby/jupyter'
 
 module IRubyTest

data/test/iruby/kernel_test.rb

@@ -0,0 +1,185 @@
+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
+
+    sub_test_case("#switch_backend!") do
+      sub_test_case("") do
+        def test_switch_backend
+          classes = []
+
+          # First pick the default backend class
+          classes << @kernel.instance_variable_get(:@backend).class
+
+          @kernel.switch_backend!(:pry)
+          classes << @kernel.instance_variable_get(:@backend).class
+
+          @kernel.switch_backend!(:irb)
+          classes << @kernel.instance_variable_get(:@backend).class
+
+          @kernel.switch_backend!(:pry)
+          classes << @kernel.instance_variable_get(:@backend).class
+
+          @kernel.switch_backend!(:plain)
+          classes << @kernel.instance_variable_get(:@backend).class
+
+          assert_equal([
+                         IRuby::PlainBackend,
+                         IRuby::PryBackend,
+                         IRuby::PlainBackend,
+                         IRuby::PryBackend,
+                         IRuby::PlainBackend
+                       ],
+                       classes)
+        end
+      end
+    end
+  end
+end

data/test/iruby/mime_test.rb

@@ -0,0 +1,50 @@
+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
+
+        test("image/svg+xml") do
+          data = '<svg height="30" width="100"><text x="0" y="15" fill="red">SVG</text></svg>'
+          res = IRuby::Display.display(data, mime: "image/svg+xml")
+          assert_equal(data,
+                       res["image/svg+xml"])
+        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,7 +1,3 @@
-require 'stringio'
-require 'test_helper'
-require 'iruby/logger'
-
 class IRubyTest::MultiLoggerTest < IRubyTest::TestBase
   def test_multilogger
     out, err = StringIO.new, StringIO.new

data/test/iruby/session_adapter/cztop_adapter_test.rb

@@ -13,7 +13,7 @@ module IRubyTest
       end
 
       def test_recv
-        skip
+        omit
       end
     end
   end

data/test/iruby/session_adapter/ffirzmq_adapter_test.rb

@@ -13,7 +13,7 @@ module IRubyTest
       end
 
       def test_recv
-        skip
+        omit
       end
     end
   end

data/test/iruby/session_adapter/session_adapter_test_base.rb

@@ -1,5 +1,3 @@
-require 'test_helper'
-
 module IRubyTest
   class SessionAdapterTestBase < TestBase
     # https://jupyter-client.readthedocs.io/en/stable/kernels.html#connection-files
@@ -22,7 +20,7 @@ module IRubyTest
       @session_adapter = adapter_class.new(@config)
 
       unless adapter_class.available?
-        skip "#{@session_adapter.name} is unavailable"
+        omit("#{@session_adapter.name} is unavailable")
       end
     end
   end

data/test/iruby/session_adapter_test.rb

@@ -1,5 +1,3 @@
-require 'test_helper'
-
 module IRubyTest
   class SessionAdapterTest < TestBase
     def test_available_p_return_false_when_load_error
@@ -12,76 +10,49 @@ module IRubyTest
       refute subclass.available?
     end
 
-    def test_select_adapter_class_with_rbczmq
-      IRuby::SessionAdapter::RbczmqAdapter.stub :available?, true do
-        IRuby::SessionAdapter::CztopAdapter.stub :available?, false do
-          IRuby::SessionAdapter::FfirzmqAdapter.stub :available?, false do
-            IRuby::SessionAdapter::PyzmqAdapter.stub :available?, false do
-              cls = IRuby::SessionAdapter.select_adapter_class
-              assert_equal IRuby::SessionAdapter::RbczmqAdapter, cls
-            end
-          end
-        end
-      end
-    end
-
     def test_select_adapter_class_with_cztop
-      IRuby::SessionAdapter::CztopAdapter.stub :available?, true do
-        IRuby::SessionAdapter::RbczmqAdapter.stub :available?, false do
-          IRuby::SessionAdapter::FfirzmqAdapter.stub :available?, false do
-            IRuby::SessionAdapter::PyzmqAdapter.stub :available?, false do
-              cls = IRuby::SessionAdapter.select_adapter_class
-              assert_equal IRuby::SessionAdapter::CztopAdapter, cls
-            end
-          end
-        end
+      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
-      IRuby::SessionAdapter::FfirzmqAdapter.stub :available?, true do
-        IRuby::SessionAdapter::RbczmqAdapter.stub :available?, false do
-          IRuby::SessionAdapter::CztopAdapter.stub :available?, false do
-            IRuby::SessionAdapter::PyzmqAdapter.stub :available?, false do
-              cls = IRuby::SessionAdapter.select_adapter_class
-              assert_equal IRuby::SessionAdapter::FfirzmqAdapter, cls
-            end
-          end
-        end
+      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
-      IRuby::SessionAdapter::PyzmqAdapter.stub :available?, true do
-        IRuby::SessionAdapter::RbczmqAdapter.stub :available?, false do
-          IRuby::SessionAdapter::CztopAdapter.stub :available?, false do
-            IRuby::SessionAdapter::FfirzmqAdapter.stub :available?, false do
-              cls = IRuby::SessionAdapter.select_adapter_class
-              assert_equal IRuby::SessionAdapter::PyzmqAdapter, cls
-            end
-          end
-        end
-      end
-    end
-    def test_select_adapter_class_with_env
-      with_env('IRUBY_SESSION_ADAPTER' => 'rbczmq') do
-        IRuby::SessionAdapter::RbczmqAdapter.stub :available?, true do
-          assert_equal IRuby::SessionAdapter::RbczmqAdapter, IRuby::SessionAdapter.select_adapter_class
-        end
+      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 }
 
-        IRuby::SessionAdapter::RbczmqAdapter.stub :available?, false do
-          assert_raises IRuby::SessionAdapterNotFound do
-            IRuby::SessionAdapter.select_adapter_class
-          end
-        end
+        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
-        IRuby::SessionAdapter::CztopAdapter.stub :available?, true do
+        assert_rr do
+          stub(IRuby::SessionAdapter::CztopAdapter).available? { true }
           assert_equal IRuby::SessionAdapter::CztopAdapter, IRuby::SessionAdapter.select_adapter_class
         end
 
-        IRuby::SessionAdapter::CztopAdapter.stub :available?, false do
+        assert_rr do
+          stub(IRuby::SessionAdapter::CztopAdapter).available? { false }
           assert_raises IRuby::SessionAdapterNotFound do
             IRuby::SessionAdapter.select_adapter_class
           end
@@ -89,11 +60,13 @@ module IRubyTest
       end
 
       with_env('IRUBY_SESSION_ADAPTER' => 'ffi-rzmq') do
-        IRuby::SessionAdapter::FfirzmqAdapter.stub :available?, true do
+        assert_rr do
+          stub(IRuby::SessionAdapter::FfirzmqAdapter).available? { true }
           assert_equal IRuby::SessionAdapter::FfirzmqAdapter, IRuby::SessionAdapter.select_adapter_class
         end
 
-        IRuby::SessionAdapter::FfirzmqAdapter.stub :available?, false do
+        assert_rr do
+          stub(IRuby::SessionAdapter::FfirzmqAdapter).available? { false }
           assert_raises IRuby::SessionAdapterNotFound do
             IRuby::SessionAdapter.select_adapter_class
           end
@@ -101,15 +74,17 @@ module IRubyTest
       end
 
       with_env('IRUBY_SESSION_ADAPTER' => 'pyzmq') do
-        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
+        # 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