iruby 0.7.4 → 0.8.1

data/lib/iruby/session.rb

@@ -2,6 +2,7 @@ require 'iruby/session_adapter'
 require 'iruby/session/mixin'
 
 require 'securerandom'
+require 'time'
 
 module IRuby
   class Session
@@ -69,7 +70,7 @@ module IRuby
       end
     end
 
-    def send(socket_type, message_type, content)
+    def send(socket_type, message_type, metadata = nil, content)
       sock = check_socket_type(socket_type)
       idents = if socket_type == :reply && @last_recvd_msg
                  @last_recvd_msg[:idents]
@@ -79,11 +80,12 @@ module IRuby
       header = {
         msg_type: message_type,
         msg_id:   SecureRandom.uuid,
+        date:     Time.now.utc.iso8601,
         username: 'kernel',
         session:  @session_id,
         version:  '5.0'
       }
-      @adapter.send(sock, serialize(idents, header, content))
+      @adapter.send(sock, serialize(idents, header, metadata, content))
     end
 
     def recv(socket_type)

data/lib/iruby/version.rb

@@ -1,3 +1,3 @@
 module IRuby
-  VERSION = '0.7.4'
+  VERSION = '0.8.1'
 end

data/test/helper.rb

@@ -2,18 +2,36 @@ require "iruby"
 require "json"
 require 'multi_json'
 require "pathname"
+require "rbconfig"
 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
+    TEST_DIR = File.expand_path("..", __FILE__).freeze
+    EXE_DIR = File.expand_path("../exe", TEST_DIR).freeze
+    LIB_DIR = File.expand_path("../lib", TEST_DIR).freeze
+
+    RUBY = RbConfig.ruby.freeze
+    IRUBY_PATH = File.join(EXE_DIR, "iruby").freeze
+
+    def iruby_command(*args)
+      [RUBY, "-I#{LIB_DIR}", IRUBY_PATH, *args]
+    end
+
     def self.startup
-      @__config_dir = Dir.mktmpdir("iruby-test")
+      @__work_dir = Dir.mktmpdir("iruby-test-data")
+
+      @__jupyter_data_dir = File.join(@__work_dir, "jupyter")
+      @__save_jupyter_data_dir = ENV["JUPYTER_DATA_DIR"]
+      ENV["JUPYTER_DATA_DIR"] = @__jupyter_data_dir
+
+      @__config_dir = File.join(@__work_dir, "config")
       @__config_path = Pathname.new(@__config_dir) + "config.json"
+      @__config_path.dirname.mkpath
       File.write(@__config_path, {
         control_port: 50160,
         shell_port: 57503,
@@ -30,7 +48,8 @@ module IRubyTest
     end
 
     def self.shutdown
-      FileUtils.remove_entry_secure(@__config_dir)
+      FileUtils.remove_entry_secure(@__work_dir)
+      ENV["JUPYTER_DATA_DIR"] = @__save_jupyter_data_dir
     end
 
     def self.test_config_filename

data/test/integration_test.rb

@@ -1,11 +1,17 @@
+require 'bundler'
 require 'pty'
 require 'expect'
 
 class IRubyTest::IntegrationTest < IRubyTest::TestBase
   def setup
+    system(*iruby_command("register", "--name=iruby-test"), out: File::NULL, err: File::NULL)
+    kernel_json = File.join(ENV["JUPYTER_DATA_DIR"], "kernels", "iruby-test", "kernel.json")
+    assert_path_exist kernel_json
+
     $expect_verbose = false # make true if you want to dump the output of iruby console
 
-    @in, @out, pid = PTY.spawn('bin/iruby --simple-prompt')
+    command = iruby_command("console", "--kernel=iruby-test").map {|x| %Q["#{x}"] }
+    @in, @out, pid = PTY.spawn(command.join(" "))
     @waiter = Thread.start { Process.waitpid(pid) }
     expect 'In [', 30
     expect '1'

data/test/iruby/application/application_test.rb

@@ -0,0 +1,32 @@
+require_relative "helper"
+
+module IRubyTest::ApplicationTests
+  class ApplicationTest < ApplicationTestBase
+    DEFAULT_KERNEL_NAME = IRuby::Application::DEFAULT_KERNEL_NAME
+    DEFAULT_DISPLAY_NAME = IRuby::Application::DEFAULT_DISPLAY_NAME
+
+    def test_help
+      out, status = Open3.capture2e(*iruby_command("--help"))
+      assert status.success?
+      assert_match(/--help/, out)
+      assert_match(/--version/, out)
+      assert_match(/^register\b/, out)
+      assert_match(/^unregister\b/, out)
+      assert_match(/^kernel\b/, out)
+      assert_match(/^console\b/, out)
+    end
+
+    def test_version
+      out, status = Open3.capture2e(*iruby_command("--version"))
+      assert status.success?
+      assert_match(/\bIRuby\s+#{Regexp.escape(IRuby::VERSION)}\b/, out)
+    end
+
+    def test_unknown_subcommand
+      out, status = Open3.capture2e(*iruby_command("matz"))
+      refute status.success?
+      assert_match(/^Invalid subcommand name: matz$/, out)
+      assert_match(/^Subcommands$/, out)
+    end
+  end
+end

data/test/iruby/application/console_test.rb

@@ -0,0 +1,97 @@
+require_relative "helper"
+
+module IRubyTest::ApplicationTests
+  class ConsoleTest < ApplicationTestBase
+    def setup
+      Dir.mktmpdir do |tmpdir|
+        @fake_bin_dir = File.join(tmpdir, "bin")
+        FileUtils.mkdir_p(@fake_bin_dir)
+
+        @fake_data_dir = File.join(tmpdir, "data")
+        FileUtils.mkdir_p(@fake_data_dir)
+
+        new_path = [@fake_bin_dir, ENV["PATH"]].join(File::PATH_SEPARATOR)
+        with_env("PATH" => new_path,
+                 "JUPYTER_DATA_DIR" => @fake_data_dir) do
+          yield
+        end
+      end
+    end
+
+    sub_test_case("there is the default IRuby kernel in JUPYTER_DATA_DIR") do
+      def setup
+        super do
+          ensure_iruby_kernel_is_installed
+          yield
+        end
+      end
+
+      test("run `jupyter console` with the default IRuby kernel") do
+        out, status = Open3.capture2e(*iruby_command("console"), in: :close)
+        assert status.success?
+        assert_match(/^Jupyter console [\d\.]+$/, out)
+        assert_match(/^#{Regexp.escape("IRuby #{IRuby::VERSION}")}\b/, out)
+      end
+    end
+
+    # NOTE: this case checks the priority of the default IRuby kernel when both kernels are available
+    sub_test_case("there are both the default IRuby kernel and IRuby kernel named `ruby` in JUPYTER_DATA_DIR") do
+      def setup
+        super do
+          ensure_iruby_kernel_is_installed
+          ensure_iruby_kernel_is_installed("ruby")
+          yield
+        end
+      end
+
+      test("run `jupyter console` with the default IRuby kernel") do
+        out, status = Open3.capture2e(*iruby_command("console"), in: :close)
+        assert status.success?
+        assert_match(/^Jupyter console [\d\.]+$/, out)
+        assert_match(/^#{Regexp.escape("IRuby #{IRuby::VERSION}")}\b/, out)
+      end
+    end
+
+    # NOTE: this case checks the availability of the old kernel name
+    sub_test_case("there is the IRuby kernel, which is named `ruby`, in JUPYTER_DATA_DIR") do
+      def setup
+        super do
+          ensure_iruby_kernel_is_installed("ruby")
+          yield
+        end
+      end
+
+      test("run `jupyter console` with the IRuby kernel `ruby`") do
+        out, status = Open3.capture2e(*iruby_command("console"), in: :close)
+        assert status.success?
+        assert_match(/^Jupyter console [\d\.]+$/, out)
+        assert_match(/^#{Regexp.escape("IRuby #{IRuby::VERSION}")}\b/, out)
+      end
+    end
+
+    sub_test_case("with --kernel option") do
+      test("run `jupyter console` command with the given kernel name") do
+        kernel_name = "other-kernel-#{Process.pid}"
+        out, status = Open3.capture2e(*iruby_command("console", "--kernel=#{kernel_name}"))
+        refute status.success?
+        assert_match(/\bNo such kernel named #{Regexp.escape(kernel_name)}\b/, out)
+      end
+    end
+
+    sub_test_case("no subcommand") do
+      def setup
+        super do
+          ensure_iruby_kernel_is_installed
+          yield
+        end
+      end
+
+      test("Run jupyter console command with the default IRuby kernel") do
+        out, status = Open3.capture2e(*iruby_command, in: :close)
+        assert status.success?
+        assert_match(/^Jupyter console [\d\.]+$/, out)
+        assert_match(/^#{Regexp.escape("IRuby #{IRuby::VERSION}")}\b/, out)
+      end
+    end
+  end
+end

data/test/iruby/application/helper.rb

@@ -0,0 +1,38 @@
+require "helper"
+require "open3"
+require "rbconfig"
+
+require "iruby/application"
+
+module IRubyTest
+  module ApplicationTests
+    class ApplicationTestBase < TestBase
+      DEFAULT_KERNEL_NAME = IRuby::Application::DEFAULT_KERNEL_NAME
+      DEFAULT_DISPLAY_NAME = IRuby::Application::DEFAULT_DISPLAY_NAME
+
+      def ensure_iruby_kernel_is_installed(kernel_name=nil)
+        if kernel_name
+          system(*iruby_command("register", "--name=#{kernel_name}"), out: File::NULL, err: File::NULL)
+        else
+          system(*iruby_command("register"), out: File::NULL, err: File::NULL)
+          kernel_name = DEFAULT_KERNEL_NAME
+        end
+        kernel_json = File.join(ENV["JUPYTER_DATA_DIR"], "kernels", kernel_name, "kernel.json")
+        assert_path_exist kernel_json
+
+        # Insert -I option to add the lib directory in the $LOAD_PATH of the kernel process
+        modified_content = JSON.load(File.read(kernel_json))
+        kernel_index = modified_content["argv"].index("kernel")
+        modified_content["argv"].insert(kernel_index - 1, "-I#{LIB_DIR}")
+        File.write(kernel_json, JSON.pretty_generate(modified_content))
+      end
+
+      def add_kernel_options(*additional_argv)
+        kernel_json = File.join(ENV["JUPYTER_DATA_DIR"], "kernels", DEFAULT_KERNEL_NAME, "kernel.json")
+        modified_content = JSON.load(File.read(kernel_json))
+        modified_content["argv"].concat(additional_argv)
+        File.write(kernel_json, JSON.pretty_generate(modified_content))
+      end
+    end
+  end
+end

data/test/iruby/application/kernel_test.rb

@@ -0,0 +1,93 @@
+require_relative "helper"
+
+module IRubyTest::ApplicationTests
+  class KernelTest < ApplicationTestBase
+    def setup
+      Dir.mktmpdir do |tmpdir|
+        @fake_bin_dir = File.join(tmpdir, "bin")
+        FileUtils.mkdir_p(@fake_bin_dir)
+
+        @fake_data_dir = File.join(tmpdir, "data")
+        FileUtils.mkdir_p(@fake_data_dir)
+
+        new_path = [@fake_bin_dir, ENV["PATH"]].join(File::PATH_SEPARATOR)
+        with_env("PATH" => new_path,
+                 "JUPYTER_DATA_DIR" => @fake_data_dir) do
+          ensure_iruby_kernel_is_installed
+          yield
+        end
+      end
+    end
+
+    test("--test option dumps the given connection file") do
+      connection_info = {
+        "control_port" => 123456,
+        "shell_port" => 123457,
+        "transport" => "tcp",
+        "signature_scheme" => "hmac-sha256",
+        "stdin_port" => 123458,
+        "hb_port" => 123459,
+        "ip" => "127.0.0.1",
+        "iopub_port" => 123460,
+        "key" => "a0436f6c-1916-498b-8eb9-e81ab9368e84"
+      }
+      Dir.mktmpdir do |tmpdir|
+        connection_file = File.join(tmpdir, "connection.json")
+        File.write(connection_file, JSON.dump(connection_info))
+        out, status = Open3.capture2e(*iruby_command("kernel", "-f", connection_file, "--test"))
+        assert status.success?
+        assert_equal connection_info, JSON.load(out)
+      end
+    end
+
+    test("the default log level is INFO") do
+      Dir.mktmpdir do |tmpdir|
+        boot_file = File.join(tmpdir, "boot.rb")
+        File.write(boot_file, <<~BOOT_SCRIPT)
+          puts "!!! INFO: \#{Logger::INFO}"
+          puts "!!! LOG LEVEL: \#{IRuby.logger.level}"
+          puts "!!! LOG LEVEL IS INFO: \#{IRuby.logger.level == Logger::INFO}"
+        BOOT_SCRIPT
+
+        add_kernel_options(boot_file)
+
+        out, status = Open3.capture2e(*iruby_command("console"), in: :close)
+        assert status.success?
+        assert_match(/^!!! LOG LEVEL IS INFO: true$/, out)
+      end
+    end
+
+    test("--debug option makes the log level DEBUG") do
+      Dir.mktmpdir do |tmpdir|
+        boot_file = File.join(tmpdir, "boot.rb")
+        File.write(boot_file, <<~BOOT_SCRIPT)
+          puts "!!! LOG LEVEL IS DEBUG: \#{IRuby.logger.level == Logger::DEBUG}"
+        BOOT_SCRIPT
+
+        add_kernel_options("--debug", boot_file)
+
+        out, status = Open3.capture2e(*iruby_command("console"), in: :close)
+        assert status.success?
+        assert_match(/^!!! LOG LEVEL IS DEBUG: true$/, out)
+      end
+    end
+
+    test("--log option adds a log destination file") do
+      Dir.mktmpdir do |tmpdir|
+        boot_file = File.join(tmpdir, "boot.rb")
+        File.write(boot_file, <<~BOOT_SCRIPT)
+          IRuby.logger.info("bootfile") { "!!! LOG MESSAGE FROM BOOT FILE !!!" }
+        BOOT_SCRIPT
+
+        log_file = File.join(tmpdir, "log.txt")
+
+        add_kernel_options("--log=#{log_file}", boot_file)
+
+        _out, status = Open3.capture2e(*iruby_command("console"), in: :close)
+        assert status.success?
+        assert_path_exist log_file
+        assert_match(/\bINFO -- bootfile: !!! LOG MESSAGE FROM BOOT FILE !!!$/, File.read(log_file))
+      end
+    end
+  end
+end

data/test/iruby/application/register_test.rb

@@ -0,0 +1,139 @@
+require_relative "helper"
+
+module IRubyTest::ApplicationTests
+  class RegisterTest < ApplicationTestBase
+    sub_test_case("when the existing IRuby kernel is in IPython's kernels directory") do
+      def setup
+        Dir.mktmpdir do |tmpdir|
+          ipython_dir = File.join(tmpdir, ".ipython")
+          # prepare the existing IRuby kernel with the default name
+          with_env("JUPYTER_DATA_DIR" => ipython_dir) do
+            ensure_iruby_kernel_is_installed
+          end
+
+          fake_bin_dir = File.join(tmpdir, "bin")
+          fake_jupyter = File.join(fake_bin_dir, "jupyter")
+          FileUtils.mkdir_p(fake_bin_dir)
+          IO.write(fake_jupyter, <<-FAKE_JUPYTER)
+#!/usr/bin/env ruby
+puts "Fake Jupyter"
+          FAKE_JUPYTER
+          File.chmod(0o755, fake_jupyter)
+
+          new_path = [fake_bin_dir, ENV["PATH"]].join(File::PATH_SEPARATOR)
+          with_env(
+            "HOME" => tmpdir,
+            "PATH" => new_path,
+            "JUPYTER_DATA_DIR" => nil,
+            "IPYTHONDIR" => nil
+          ) do
+            yield
+          end
+        end
+      end
+
+      test("IRuby warns the existence of the kernel in IPython's kernels directory and executes `jupyter kernelspec install` command") do
+        out, status = Open3.capture2e(*iruby_command("register"))
+        assert status.success?
+        assert_match(/^Fake Jupyter$/, out)
+        assert_match(/^#{Regexp.escape("IRuby kernel `#{DEFAULT_KERNEL_NAME}` already exists in the deprecated IPython's data directory.")}$/,
+                     out)
+      end
+    end
+
+    sub_test_case("when the existing IRuby kernel is in Jupyter's default kernels directory") do
+      # TODO
+    end
+
+    sub_test_case("JUPYTER_DATA_DIR is supplied") do
+      def setup
+        Dir.mktmpdir do |tmpdir|
+          @kernel_json = File.join(tmpdir, "kernels", DEFAULT_KERNEL_NAME, "kernel.json")
+          with_env(
+            "JUPYTER_DATA_DIR" => tmpdir,
+            "IPYTHONDIR" => nil
+          ) do
+            yield
+          end
+        end
+      end
+
+      test("a new IRuby kernel `#{DEFAULT_KERNEL_NAME}` will be installed in JUPYTER_DATA_DIR") do
+        assert_path_not_exist @kernel_json
+
+        _out, status = Open3.capture2e(*iruby_command("register"))
+        assert status.success?
+        assert_path_exist @kernel_json
+
+        kernel = JSON.load(File.read(@kernel_json))
+        assert_equal DEFAULT_DISPLAY_NAME, kernel["display_name"]
+      end
+
+      sub_test_case("there is a IRuby kernel in JUPYTER_DATA_DIR") do
+        def setup
+          super do
+            FileUtils.mkdir_p(File.dirname(@kernel_json))
+            File.write(@kernel_json, '"dummy kernel"')
+            assert_equal '"dummy kernel"', File.read(@kernel_json)
+            yield
+          end
+        end
+
+        test("warn the existence of the kernel") do
+          out, status = Open3.capture2e(*iruby_command("register"))
+          refute status.success?
+          assert_match(/^#{Regexp.escape("IRuby kernel named `#{DEFAULT_KERNEL_NAME}` already exists!")}$/,
+                       out)
+          assert_match(/^#{Regexp.escape("Use --force to force register the new kernel.")}$/,
+                       out)
+        end
+
+        test("the existing kernel is not overwritten") do
+          _out, status = Open3.capture2e(*iruby_command("register"))
+          refute status.success?
+          assert_equal '"dummy kernel"', File.read(@kernel_json)
+        end
+
+        sub_test_case("`--force` option is specified") do
+          test("the existing kernel is overwritten by the new kernel") do
+            out, status = Open3.capture2e(*iruby_command("register", "--force"))
+            assert status.success?
+            assert_not_match(/^#{Regexp.escape("IRuby kernel named `#{DEFAULT_KERNEL_NAME}` already exists!")}$/,
+                             out)
+            assert_not_match(/^#{Regexp.escape("Use --force to force register the new kernel.")}$/,
+                             out)
+            assert_not_equal '"dummy kernel"', File.read(@kernel_json)
+          end
+        end
+      end
+    end
+
+    sub_test_case("both JUPYTER_DATA_DIR and IPYTHONDIR are supplied") do
+      def setup
+        Dir.mktmpdir do |tmpdir|
+          Dir.mktmpdir do |tmpdir2|
+            with_env(
+              "JUPYTER_DATA_DIR" => tmpdir,
+              "IPYTHONDIR" => tmpdir2
+            ) do
+              yield
+            end
+          end
+        end
+      end
+
+      test("warn for IPYTHONDIR") do
+        out, status = Open3.capture2e(*iruby_command("register"))
+        assert status.success?
+        assert_match(/^#{Regexp.escape("both JUPYTER_DATA_DIR and IPYTHONDIR are supplied; IPYTHONDIR is ignored.")}$/,
+                     out)
+      end
+
+      test("a new kernel is installed in JUPYTER_DATA_DIR") do
+        _out, status = Open3.capture2e(*iruby_command("register"))
+        assert status.success?
+        assert_path_exist File.join(ENV["JUPYTER_DATA_DIR"], "kernels", DEFAULT_KERNEL_NAME, "kernel.json")
+      end
+    end
+  end
+end

data/test/iruby/application/unregister_test.rb

@@ -0,0 +1,77 @@
+require_relative "helper"
+
+module IRubyTest::ApplicationTests
+  class UnregisterTest < ApplicationTestBase
+    def setup
+      Dir.mktmpdir do |tmpdir|
+        @kernel_json = File.join(tmpdir, "kernels", DEFAULT_KERNEL_NAME, "kernel.json")
+        with_env(
+          "JUPYTER_DATA_DIR" => tmpdir,
+          "IPYTHONDIR" => nil
+        ) do
+          yield
+        end
+      end
+    end
+
+    sub_test_case("when there is no IRuby kernel in JUPYTER_DATA_DIR") do
+      test("the command succeeds") do
+        assert system(*iruby_command("unregister", "-f", DEFAULT_KERNEL_NAME),
+                      out: File::NULL, err: File::NULL)
+      end
+    end
+
+    sub_test_case("when the existing IRuby kernel in JUPYTER_DATA_DIR") do
+      def setup
+        super do
+          ensure_iruby_kernel_is_installed
+          yield
+        end
+      end
+
+      test("uninstall the existing kernel") do
+        assert system(*iruby_command("unregister", "-f", DEFAULT_KERNEL_NAME),
+                      out: File::NULL, err: File::NULL)
+        assert_path_not_exist @kernel_json
+      end
+    end
+
+    sub_test_case("when the existing IRuby kernel in IPython's kernels directory") do
+      def setup
+        super do
+          Dir.mktmpdir do |tmpdir|
+            ipython_dir = File.join(tmpdir, ".ipython")
+
+            # prepare the existing IRuby kernel with the default name
+            with_env("JUPYTER_DATA_DIR" => ipython_dir) do
+              ensure_iruby_kernel_is_installed
+            end
+
+            fake_bin_dir = File.join(tmpdir, "bin")
+            fake_jupyter = File.join(fake_bin_dir, "jupyter")
+            FileUtils.mkdir_p(fake_bin_dir)
+            IO.write(fake_jupyter, <<-FAKE_JUPYTER)
+  #!/usr/bin/env ruby
+  puts "Fake Jupyter"
+            FAKE_JUPYTER
+            File.chmod(0o755, fake_jupyter)
+
+            new_path = [fake_bin_dir, ENV["PATH"]].join(File::PATH_SEPARATOR)
+            with_env(
+              "HOME" => tmpdir,
+              "PATH" => new_path,
+              "IPYTHONDIR" => nil
+            ) do
+              yield
+            end
+          end
+        end
+      end
+
+      test("the kernel in IPython's kernels directory is not removed") do
+        assert system(*iruby_command("unregister", "-f"), out: File::NULL, err: File::NULL)
+        assert_path_exist File.join(File.expand_path("~/.ipython"), "kernels", DEFAULT_KERNEL_NAME, "kernel.json")
+      end
+    end
+  end
+end

data/test/iruby/jupyter_test.rb

@@ -2,25 +2,37 @@ require 'iruby/jupyter'
 
 module IRubyTest
   class JupyterDefaultKernelSpecDirectoryTest < TestBase
-    def setup
-      @kernel_spec = IRuby::Jupyter.kernelspec_dir
+    sub_test_case("with JUPYTER_DATA_DIR") do
+      def test_default
+        assert_equal(File.join(ENV["JUPYTER_DATA_DIR"], "kernels"),
+                     IRuby::Jupyter.kernelspec_dir)
+      end
     end
 
-    def test_default_windows
-      windows_only
-      appdata = IRuby::Jupyter.send :windows_user_appdata
-      assert_equal(File.join(appdata, 'jupyter/kernels'), @kernel_spec)
-    end
+    sub_test_case("without JUPYTER_DATA_DIR environment variable") do
+      def setup
+        with_env("JUPYTER_DATA_DIR" => nil) do
+          @kernelspec_dir = IRuby::Jupyter.kernelspec_dir
+          yield
+        end
+      end
 
-    def test_default_apple
-      apple_only
-      assert_equal(File.expand_path('~/Library/Jupyter/kernels'), @kernel_spec)
-    end
+      def test_default_windows
+        windows_only
+        appdata = IRuby::Jupyter.send :windows_user_appdata
+        assert_equal(File.join(appdata, 'jupyter/kernels'), @kernelspec_dir)
+      end
+
+      def test_default_apple
+        apple_only
+        assert_equal(File.expand_path('~/Library/Jupyter/kernels'), @kernelspec_dir)
+      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)
+      def test_default_unix
+        unix_only
+        with_env('XDG_DATA_HOME' => nil) do
+          assert_equal(File.expand_path('~/.local/share/jupyter/kernels'), @kernelspec_dir)
+        end
       end
     end
   end

data/test/iruby/kernel_test.rb

@@ -1,5 +1,3 @@
-require "base64"
-
 module IRubyTest
   class KernelTest < TestBase
     def setup

data/test/iruby/multi_logger_test.rb

@@ -8,4 +8,17 @@ class IRubyTest::MultiLoggerTest < IRubyTest::TestBase
     assert_match 'bad thing', out.string
     assert_match 'bad thing', err.string
   end
+
+  def test_level
+    out, err = StringIO.new, StringIO.new
+    logger = IRuby::MultiLogger.new(Logger.new(out), Logger.new(err))
+
+    logger.level = Logger::DEBUG
+    assert_equal Logger::DEBUG, logger.level
+    assert_all(logger.loggers) {|l| l.level == Logger::DEBUG }
+
+    logger.level = Logger::INFO
+    assert_equal Logger::INFO, logger.level
+    assert_all(logger.loggers) {|l| l.level == Logger::INFO }
+  end
 end

data/test/run-test.rb

@@ -2,6 +2,7 @@
 
 $VERBOSE = true
 
+require "bundler/setup"
 require "pathname"
 
 base_dir = Pathname.new(__dir__).parent.expand_path