iruby 0.5.0 → 0.7.2

data/lib/iruby/version.rb

@@ -1,3 +1,3 @@
 module IRuby
-  VERSION = '0.5.0'
+  VERSION = '0.7.2'
 end

data/test/helper.rb

@@ -1,10 +1,56 @@
 require "iruby"
+require "json"
+require 'multi_json'
+require "pathname"
 require "test/unit"
 require "test/unit/rr"
 require "tmpdir"
 
+
+IRuby.logger = IRuby::MultiLogger.new(*Logger.new(STDERR, level: Logger::Severity::INFO))
+
 module IRubyTest
   class TestBase < Test::Unit::TestCase
+    def self.startup
+      @__config_dir = Dir.mktmpdir("iruby-test")
+      @__config_path = Pathname.new(@__config_dir) + "config.json"
+      File.write(@__config_path, {
+        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"
+      }.to_json)
+
+      @__original_kernel_instance = IRuby::Kernel.instance
+    end
+
+    def self.shutdown
+      FileUtils.remove_entry_secure(@__config_dir)
+    end
+
+    def self.test_config_filename
+      @__config_path.to_s
+    end
+
+    def self.restore_kernel
+      IRuby::Kernel.instance = @__original_kernel_instance
+    end
+
+    def teardown
+      self.class.restore_kernel
+    end
+
+    def with_session_adapter(session_adapter_name)
+      IRuby::Kernel.new(self.class.test_config_filename, session_adapter_name)
+      $stdout = STDOUT
+      $stderr = STDERR
+    end
+
     def assert_output(stdout=nil, stderr=nil)
       flunk "assert_output requires a block to capture output." unless block_given?
 

data/test/iruby/backend_test.rb

@@ -8,6 +8,12 @@ module IRubyTest
       assert_equal 3, @plainbackend.eval('1+2', false)
     end
 
+    def test_include_module
+      assert_nothing_raised do
+        @plainbackend.eval("include Math, Comparable", false)
+      end
+    end
+
     def test_complete_req
       assert_includes @plainbackend.complete('req'), 'require'
     end
@@ -26,6 +32,12 @@ module IRubyTest
       assert_equal 3, @prybackend.eval('1+2', false)
     end
 
+    def test_include_module
+      assert_nothing_raised do
+        @prybackend.eval("include Math, Comparable", false)
+      end
+    end
+
     def test_complete_req
       assert_includes @prybackend.complete('req'), 'require'
     end

data/test/iruby/display_test.rb

@@ -0,0 +1,188 @@
+module IRubyTest
+  class DisplayTest < TestBase
+    def setup
+      @object = Object.new
+      @object.instance_variable_set(:@to_html_called, false)
+      @object.instance_variable_set(:@to_markdown_called, false)
+      @object.instance_variable_set(:@to_iruby_called, false)
+      @object.instance_variable_set(:@to_iruby_mimebundle_called, false)
+
+      class << @object
+        attr_reader :to_html_called
+        attr_reader :to_markdown_called
+        attr_reader :to_iruby_called
+        attr_reader :to_iruby_mimebundle_called
+
+        def html
+          "<b>html</b>"
+        end
+
+        def markdown
+          "*markdown*"
+        end
+
+        def inspect
+          "!!! inspect !!!"
+        end
+      end
+    end
+
+    def define_to_html
+      class << @object
+        def to_html
+          @to_html_called = true
+          html
+        end
+      end
+    end
+
+    def define_to_markdown
+      class << @object
+        def to_markdown
+          @to_markdown_called = true
+          markdown
+        end
+      end
+    end
+
+    def define_to_iruby
+      class << @object
+        def to_iruby
+          @to_iruby_called = true
+          ["text/html", "<b>to_iruby</b>"]
+        end
+      end
+    end
+
+    def define_to_iruby_mimebundle
+      class << @object
+        def to_iruby_mimebundle(include: [])
+          @to_iruby_mimebundle_called = true
+          mimes = if include.empty?
+                    ["text/html", "text/markdown", "application/json"]
+                  else
+                    include
+                  end
+          formats = mimes.map { |mime|
+            result = case mime
+                     when "text/html"
+                       "<i>html</i>"
+                     when "text/markdown"
+                       "**markdown**"
+                     when "application/json"
+                       %Q[{"mimebundle": "json"}]
+                     end
+            [mime, result]
+          }.to_h
+          metadata = {}
+          return formats, metadata
+        end
+      end
+    end
+
+    def assert_iruby_display(expected)
+      assert_equal(expected,
+                   {
+                     result: IRuby::Display.display(@object),
+                     to_html_called: @object.to_html_called,
+                     to_markdown_called: @object.to_markdown_called,
+                     to_iruby_called: @object.to_iruby_called,
+                     to_iruby_mimebundle_called: @object.to_iruby_mimebundle_called
+                   })
+    end
+
+    sub_test_case("the object cannot handle all the mime types") do
+      def test_display
+        assert_iruby_display({
+                               result: {"text/plain" => "!!! inspect !!!"},
+                               to_html_called: false,
+                               to_markdown_called: false,
+                               to_iruby_called: false,
+                               to_iruby_mimebundle_called: false
+                             })
+      end
+    end
+
+    sub_test_case("the object can respond to to_iruby") do
+      def setup
+        super
+        define_to_iruby
+      end
+
+      def test_display
+        assert_iruby_display({
+                               result: {
+                                 "text/html" => "<b>to_iruby</b>",
+                                 "text/plain" => "!!! inspect !!!"
+                               },
+                               to_html_called: false,
+                               to_markdown_called: false,
+                               to_iruby_called: true,
+                               to_iruby_mimebundle_called: false
+                             })
+      end
+
+      sub_test_case("the object can respond to to_markdown") do
+        def setup
+          super
+          define_to_markdown
+        end
+
+        def test_display
+          assert_iruby_display({
+                                 result: {
+                                   "text/markdown" => "*markdown*",
+                                   "text/plain" => "!!! inspect !!!"
+                                 },
+                                 to_html_called: false,
+                                 to_markdown_called: true,
+                                 to_iruby_called: false,
+                                 to_iruby_mimebundle_called: false
+                               })
+        end
+      end
+
+      sub_test_case("the object can respond to to_html") do
+        def setup
+          super
+          define_to_html
+        end
+
+        def test_display
+          assert_iruby_display({
+                                 result: {
+                                   "text/html" => "<b>html</b>",
+                                   "text/plain" => "!!! inspect !!!"
+                                 },
+                                 to_html_called: true,
+                                 to_markdown_called: false,
+                                 to_iruby_called: false,
+                                 to_iruby_mimebundle_called: false
+                               })
+        end
+
+        sub_test_case("the object can respond to to_iruby_mimebundle") do
+          def setup
+            super
+            define_to_iruby_mimebundle
+          end
+
+          def test_display
+            assert_iruby_display({
+                                   result: {
+                                     "text/html" => "<i>html</i>",
+                                     "text/markdown" => "**markdown**",
+                                     "application/json" => %Q[{"mimebundle": "json"}],
+                                     "text/plain" => "!!! inspect !!!"
+                                   },
+                                   to_html_called: false,
+                                   to_markdown_called: false,
+                                   to_iruby_called: false,
+                                   to_iruby_mimebundle_called: true
+                                 })
+          end
+        end
+      end
+    end
+  end
+end

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/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